/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：JKKUpdSpMskmOtherOpBaseCC
*   ソースファイル名：JKKUpdSpMskmOtherOpBaseCC.java
*   作成者          ：富士通
*   日付            ：2017年04月25日
*＜機能概要＞
*   セキュリティパック申込他オプション更新(共通)CC
*＜修正履歴＞
*   バージョン  修正日       修正者      修正内容
*   v32.00.00   2017/04/25   FJ）池原    【ANK-3149-00-00】新セキュリティパック導入 新規作成
*   v32.00.01   2017/05/25   FJ）川島    【IT2-2017-0000010】対応
*   v32.00.02   2017/05/26   FJ）川島    【IT2-2017-0000012】対応
*   v32.00.03   2017/06/02   FJ）川島    【IT1-2017-0000074】対応
*   v32.00.04   2017/06/08   FJ）川島    【IT1-2017-0000080】対応
*   v32.00.05   2017/06/15   FJ）川島    【IT1-2017-0000086】対応
*	v61.00.00   2022/01/31   FJ) 永江    【ANK-4315-00-00】【eo定期】 eoホームゲートウェイ導入対応
*   v65.00.00   2024/01/31   FJ）福島    【ANK-4346-00-00】【eo定期】CCMG再構築対応（IT不具合修正）
*   v65.00.00   2024/02/06   FJ）福島    【ANK-4346-00-00】【eo定期】CCMG再構築対応
*	v70.00.00	2024/03/04	FJ)吉田		【#84105】SIFエラーがＣＣＭＧエラーとして表示される
*	v71.00.00   2024/06/28   FJ) 謝      【#85051】対応
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import static com.fujitsu.futurity.bp.custom.common.JCNDslScParamHenshu.getResultMsgList;

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

import org.apache.commons.lang3.StringUtils;

import com.fujitsu.futurity.bp.x21.bpm.ServiceComponentRequestInvoker;
import com.fujitsu.futurity.bp.x21.bpm.db.SessionHandle;
import com.fujitsu.futurity.bp.x21.bpm.exception.RequestParameterException;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadWrite;
import com.fujitsu.futurity.bp.x21.cc.AbstractCommonComponent;
import com.fujitsu.futurity.bp.x21.cc.exception.CCException;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.ErrorInfoMapKeys;
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.fujitsu.futurity.model.ejb.common.StatusCodes;

import eo.common.constant.JCNStrConst;
import eo.common.constant.JKKStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.util.JCNStringUtil;
import eo.common.util.JKKCommonUtil;
import eo.common.util.JKKStringUtil;
import eo.common.util.JPCDateUtil;
import eo.ejb.cbs.cbsmsg.ECK0011B003CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0011B003CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECN0021A001CBSMsg;
import eo.ejb.cbs.cbsmsg.ECN0021A001CBSMsgList;
import eo.ejb.cbs.cbsmsg.ECN0021B001CBSMsg;
import eo.ejb.cbs.cbsmsg.ECN0021B001CBSMsgList;
import eo.ejb.cbs.cbsmsg.ECNA0010001CBSMsg;
import eo.ejb.cbs.cbsmsg.ECNA0100001CBSMsg;
import eo.ejb.cbs.cbsmsg.ECNA0170001CBSMsg;
import eo.ejb.cbs.cbsmsg.ECNA0210001CBSMsg;
import eo.ejb.cbs.cbsmsg.ECNA0210001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECNA0240001CBSMsg;
import eo.ejb.cbs.cbsmsg.ECNA0240001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECNA0240001CBSMsg2List;
import eo.ejb.cbs.cbsmsg.ECNA0240001CBSMsg3List;
import eo.ejb.cbs.cbsmsg.EKK0021A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0021A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0021C040CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341B019CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341B019CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0451A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0451A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0451B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0451B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0451C020CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0451C030CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0451C070CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1041B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1041B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1091B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091B002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK2811A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811B504CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811B504CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKU0011B090CBSMsg;
import eo.ejb.cbs.cbsmsg.EKU0011B090CBSMsg1List;
import eo.ejb.cbs.mainproc.JECNA0240001TPMA;


/**
 * セキュリティパック申込他オプション更新(共通)CC.
 * <br>
 * @author 富士通
 */
public class JKKUpdSpMskmOtherOpBaseCC extends AbstractCommonComponent
{
	/** リターンメッセージ */
	private static final String RETURN_MESSAGE_STRING = "RETURN_MESSAGE_";
	/** リターンメッセージ */
	private static final String RETURN_MESSAGE_FORMAT = "%1$04d";
	/** エラー用 */
	protected static final String SC_ERROR_STRING = "サービスコンポーネントエラー";
	/** コンテンツ契約終了年月日時分秒 日付最大値文字列 */
	protected static final String CONT_KEI_END_DTM_MAX_DATE = JCNStrConst.S_MAX_DATE + JCNStrConst.S_MAX_MMDDSS;
	/** 文字列：半角カンマ */
	private static final String STR_HALF_COMMA = ",";
	/** 文字列：半角シングルクォーテーションマーク */
	private static final String STR_HALF_SINGLE_QUOTATION = "'";
	
	/** 機器提供サービス契約番号 */
	protected String ekk0341b019KktkSvcKeiNo = "";
// #85051 ADD START
	/** 機器提供サービス契約番号リスト */
	protected ArrayList<String> ekk0341b019KktkSvcKeiNoList = new ArrayList<String>();
// #85051 ADD END
	/** 機器オプションサービス契約一覧照会（複合検索）ルーター機能保持用 */
	private HashMap<String, Object> ekk2811b504MapG01 = null;
	/** 機器オプションサービス契約一覧照会（複合検索）電話アダプター機能保持用 */
	private HashMap<String, Object> ekk2811b504MapG02 = null;
	
	/** 機器一覧機器オプション契約更新部品パラメータ */
	private static final String KIKI_KIKIOPT_KEI_UPD_CC = "JKKKikiIchiranKkOpKyUpdCC";
	/** ソート項目 (異動年月日時分秒) */
	private static final String SORT_ITEM_NO_IDONEN = "2";	
	/** 多機能ルーター処理パターン (有線ルーター機能に変更) */
	private static final String TAKINORT_TRNPTN_YUSEN = "1";
	/** エラーコード (ウイルスバスター複数件エラー) */
	private static final String ERR_CD_VIRUSBUSTER_FUKUSU_ERR = "1";
	/** エラーコード (ウイルスバスターCCMG連携エラー) */
	private static final String ERR_CD_VIRUSBUSTER_CCMG_ERR = "2";
	
//ANK-4346-00-00 ADD START
	/** コンテンツ区分 */
	private static final String CONTENTS_DIVISION = "contents_division";
	/** 契約フラグ */
	private static final String CONTRACT_FLG = "contract_flg";
	/**  コンテンツ区分 : "1"（コンテンツ） */
	public static final String DIVISION_1 = "1";
	/**  要否フラグ : "0"（不要） */
	public static final String INFO_YOHI_0 = "0";
	/**  要否フラグ : "1"（要） */
	public static final String INFO_YOHI_1 = "1";
//ANK-4346-00-00 ADD END
	
	/** エラーコード */
	private static final String ERRCODE = "errcode";
	
	/** ファミリー会員のSYSIDリスト */
	protected ArrayList<String> sysidList = null;

	/**
	 * 他オプション共通部分の更新を行う。
	 * <br>
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	protected IRequestParameterReadWrite updOtherOpBase(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception, Throwable
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		if (inMap == null)
		{
			return param;
		}
		
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		HashMap<String, Object> paramMap = setSCInputCommonData(param, new HashMap<String, Object>());
		Map<?, ?> result = null;
		CAANMsg template = null;
		
		// ファミリーパック解約有無がnull、かつ、ウイルスバスター解約有無がnull、かつ、有害Webフィルター解約希望有無がnull以外の場合
		if (!(JKKCommonUtil.isNull((String)inMap.get("fp_dsl_um")) && JKKCommonUtil.isNull((String)inMap.get("vb_dsl_um")) && JKKCommonUtil.isNull((String)inMap.get("yugai_web_flt_dsl_um"))))
		{
			HashMap<String, Object> ekk0021a010OutputMap = new HashMap<String, Object>();
			
			// 申込明細一意照会
			template = editInEKK0021A010(param, fixedText); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK0021A010(result, param, fixedText, ekk0021a010OutputMap); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
			
			HashMap<String, Object> ekk0021c040OutputMap = new HashMap<String, Object>();
			
			// 申込明細情報変更
			template = editInEKK0021C040(param, fixedText, ekk0021a010OutputMap); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK0021C040(result, param, fixedText, ekk0021c040OutputMap); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		
		
		ArrayList<HashMap<String, Object>> ekk0451b010OutputList = new ArrayList<HashMap<String, Object>>();
		HashMap<String, Object> ekk0451a010OutputMap = new HashMap<String, Object>();
		HashMap<String, Object> ekk0081a010OutputMap = new HashMap<String, Object>();
		
		// セキュリティパック申込他オプション更新CCマップ.ファミリーパック解約有無が有の場合
		if (JKKStrConst.CD_DIV_UM_ARI.equals((String)inMap.get("fp_dsl_um")))
		{
			// 割引サービス契約一覧照会（割引サービス指定）
			template = editInEKK0451B010(param, fixedText); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK0451B010(result, param, fixedText, ekk0451b010OutputList); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
			
			if (ekk0451b010OutputList.size() > 0)
			{
				// 割引サービス契約一意照会
				template = editInEKK0451A010(param, fixedText, ekk0451b010OutputList); // 上りマッピング
				result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
				editRetEKK0451A010(result, param, fixedText, ekk0451a010OutputMap); // 下りマッピング
				if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
				{ // ステータスが単項目エラー以上であれば例外をスロー
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}
			
			// サービス契約一意照会
			template = editInEKK0081A010(param, fixedText); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK0081A010(result, param, fixedText, ekk0081a010OutputMap); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
			
			
			HashMap<String, Object> ekk0451c070OutputMap = new HashMap<String, Object>();
			HashMap<String, Object> ekk0451c020OutputMap = new HashMap<String, Object>();
			HashMap<String, Object> ekk0451c030OutputMap = new HashMap<String, Object>();
			
			// 割引サービス契約一意照会で取得した割引サービス契約ステータスが受付済の場合
			if (JKKStrConst.CD00055_UKZM.equals((String)ekk0451a010OutputMap.get(EKK0451A010CBSMsg1List.WRIB_SVC_KEI_STAT)))
			{
				// 割引サービス契約キャンセル
				template = editInEKK0451C070(param, fixedText, ekk0451b010OutputList, ekk0451a010OutputMap); // 上りマッピング
				result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
				editRetEKK0451C070(result, param, fixedText, ekk0451c070OutputMap); // 下りマッピング
				if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
				{ // ステータスが単項目エラー以上であれば例外をスロー
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}
			// 割引サービス契約一意照会で取得した割引サービス契約ステータスがサービス提供中の場合
			else if (((String)ekk0451a010OutputMap.get(EKK0451A010CBSMsg1List.WRIB_SVC_KEI_STAT)).equals(JKKStrConst.CD00055_SVCTK_CHU))
			{
				// 割引サービス契約解約
// IT1-2017-0000080 MOD START
//				template = editInEKK0451C020(param, fixedText, ekk0451b010OutputList, ekk0451a010OutputMap, ekk0081a010OutputMap); // 上りマッピング
				template = editInEKK0451C020(handle, param, fixedText, ekk0451b010OutputList, ekk0451a010OutputMap, ekk0081a010OutputMap); // 上りマッピング
// IT1-2017-0000080 MOD END
				result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
				editRetEKK0451C020(result, param, fixedText, ekk0451c020OutputMap); // 下りマッピング
				if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
				{ // ステータスが単項目エラー以上であれば例外をスロー
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
				
				// 割引サービス契約解約確定
				template = editInEKK0451C030(param, fixedText, ekk0451b010OutputList, ekk0451c020OutputMap); // 上りマッピング
				result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
				editRetEKK0451C030(result, param, fixedText, ekk0451c030OutputMap); // 下りマッピング
				if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
				{ // ステータスが単項目エラー以上であれば例外をスロー
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}
			
			ArrayList<HashMap<String, Object>> ekk1091b002OutputList = new ArrayList<HashMap<String, Object>>();
			ArrayList<HashMap<String, Object>> ekk1091d010OutputList = new ArrayList<HashMap<String, Object>>();
			
// IT1-2017-0000074 DEL START
//			// サービス契約一意照会で取得したサービス契約ステータスが受付済の場合
//			if (((String)ekk0081a010OutputMap.get(EKK0081A010CBSMsg1List.SVC_KEI_STAT)).equals(JKKStrConst.CD00037_UK_ZM))
//			{
// IT1-2017-0000074 DEL END
			// 進捗一覧照会（異動区分）
			template = editInEKK1091B002(param, fixedText); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK1091B002(result, param, fixedText, ekk1091b002OutputList); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
// IT1-2017-0000074 DEL START
//			}
// IT1-2017-0000074 DEL END
			
			// 進捗登録
			template = editInEKK1091D010(param, fixedText, ekk1091b002OutputList); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK1091D010(result, param, fixedText, ekk1091d010OutputList); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		
		
		HashMap<String, Object> ekk0081a010OutputMap2 = new HashMap<String, Object>();
		sysidList = new ArrayList<String>();
		ArrayList<HashMap<String, Object>> ecn0021b001OutputList = new ArrayList<HashMap<String, Object>>();
		
		// サービス契約一意照会
		template = editInEKK0081A010(param, fixedText); // 上りマッピング
		result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
		editRetEKK0081A0102(result, param, fixedText, ekk0081a010OutputMap2); // 下りマッピング
		if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
		{ // ステータスが単項目エラー以上であれば例外をスロー
			throw new CCException(SC_ERROR_STRING, new Exception());
		}
		
		if (ekk0081a010OutputMap2.size() > 0)
		{
			// 家族会員情報一覧照会
			template = editInECK0011B003(param, fixedText, ekk0081a010OutputMap2); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetECK0011B003(result, param, fixedText, sysidList); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		

		HashMap<String, Object> ecn0240001Map = new HashMap<String, Object>();
	//	List<HashMap<String, Object>> ecn0240001RetMap = new ArrayList<HashMap<String,Object>>();
		
		// セキュリティパック申込他オプション更新CCマップ.ウイルスバスター解約有無が有の場合
		if (JKKStrConst.CD_DIV_UM_ARI.equals((String)inMap.get("vb_dsl_um")))
		{
			if (sysidList.size() > 0)
			{
// ANK-4346-00-00 DEL START
//				// コンテンツ契約一覧照会
//				template = editInECN0021B001(param, fixedText, sysidList); // 上りマッピング
//				result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
//				editRetECN0021B001(result, param, fixedText, ecn0021b001OutputList); // 下りマッピング
//				if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
//				{ // ステータスが単項目エラー以上であれば例外をスロー
//					throw new CCException(SC_ERROR_STRING, new Exception());
//				}
// ANK-4346-00-00 DEL END

// ANK-4346-00-00 ADD START
				// コンテンツ契約一覧API処理
				ecn0021b001OutputList = execECNA0170001(handle, param, fixedText, sysidList, JKKStrConst.CONT_SVC_CD_VIRUSBUSTER);
				HashMap<String, Object> ecna0170001Map = new HashMap<String, Object>();
				paramMap.put("ECNA0170001", ecna0170001Map);

				//ecna0021b001Map.put(ECNA0240001CBSMsg2List.ECNA0240001CBSMSG3LIST, ecn0240001RetMap);
			}
// ANK-4346-00-00 ADD END
			
			// ウイルスバスター表示パターンの設定を行う
			// ウイルスバスター件数
			int vbCnt = 0;
			
//			HashMap<String, Object> ecn0021a001OutputMap = new HashMap<String, Object>();
//			HashMap<String, Object> ecna0010001OutputMap = new HashMap<String, Object>();
//			HashMap<String, Object> vecn0021b001OutputListbMap = null;
			
//			for (int i = 0; i < ecn0021b001OutputList.size(); i++)
//			{
//				HashMap<String, Object> childMap = (HashMap<String, Object>) ecn0021b001OutputList.get(i);
//				
//				// コンテンツサービスコードがウイルスバスター以外の場合
//				if (!JKKStrConst.CONT_SVC_CD_VIRUSBUSTER.equals((String)childMap.get(ECN0021B001CBSMsgList.CONT_SVC_CD)))
//				{
//					continue;
//				}
//				// コンテンツ種別コードがコンテンツ以外の場合
//				if (!JKKStrConst.CONT_SBT_CD_CONT.equals((String)childMap.get(ECN0021B001CBSMsgList.CONT_SBT_CD)))
//				{
//					continue;
//				}
//				// コンテンツ契約終了年月日時分秒が日付最大値文字列以外の場合
//				if (!CONT_KEI_END_DTM_MAX_DATE.equals((String)childMap.get(ECN0021B001CBSMsgList.CONT_KEI_END_DTM)))
//				{
//					continue;
//				}
//				
//				// ウイルスバスター件数を＋１する
//				vbCnt++;
//				
//				vbMap = childMap;
//			}
			// 契約中の件数をカウントする
			vbCnt = ecn0021b001OutputList.size();
			
			// 件数が２件以上の場合
			if (vbCnt > 1)
			{
				// 例外スローのため、ダミーのSIFエラーを設定
				setExceptionErr(param, inMap, "ECNA0170001", "key_sysid_err");
				// エラーコード：ウイルスバスター複数件エラー
				inMap.put("err_cd", ERR_CD_VIRUSBUSTER_FUKUSU_ERR);
				// 例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
			// 件数が１件の場合
			else if (vbCnt == 1)
			{
				if (null != ecn0021b001OutputList && ecn0021b001OutputList.size() > 0)
				{
// ANK-4346-00-00 MOD START
					// コンテンツ契約一意照会
//					template = editInECN0021A001(param, fixedText, vbMap); // 上りマッピング
//					result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
//					editRetECN0021A001(result, param, fixedText, ecn0021a001OutputMap); // 下りマッピング
//					if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
//					{ // ステータスが単項目エラー以上であれば例外をスロー
//						throw new CCException(SC_ERROR_STRING, new Exception());
//					}
//					
//					// コンテンツサービス解約
//					template = editInECNA0010001(param, fixedText, ecn0021a001OutputMap); // 上りマッピング
//					result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
//					editRetECNA0010001(result, param, fixedText, ecna0010001OutputMap); // 下りマッピング
//					if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
//					{ // ステータスが単項目エラー以上であれば例外をスロー
//						throw new CCException(SC_ERROR_STRING, new Exception());
//					}

					template = editInECNA0240001(param, fixedText, ecn0240001Map, ecn0021b001OutputList);
					result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
					editRetECNA0240001(result, param, fixedText, ecn0240001Map);
					inMap.put(ECNA0240001CBSMsg.STATUS,ecn0240001Map.get(ECNA0240001CBSMsg.STATUS).toString());
					String state = ecn0240001Map.get(ECNA0240001CBSMsg.STATUS).toString();
					boolean isError = false;

					if (StringUtils.isEmpty(state))
					{
						if (getReturnCode(param) != 0)
						{
							isError = true;
						}
					}
					else
					{
						if (!Integer.toString(StatusCodes.NORMAL_END).equals(state))
						{
							isError = true;
						}
					}					
					if (isError)
					{   // ステータスが単項目エラー以上であれば例外をスロー
						// 例外スローのため、ダミーのSIFエラーを設定
						setExceptionErr(param, inMap, "ECNA0170001", "key_sysid_err");
						inMap.put("front_err_cd", ERR_CD_VIRUSBUSTER_CCMG_ERR);
						// エラーコード：CCMGエラー
						inMap.put("err_cd", (String)ecn0240001Map.get(ECNA0240001CBSMsg2List.ERR_CD));
						// #84105 ADD START
						inMap.put("CCMG_ERR_FLG", "1");
						inMap.put("CCMG_ERR_MSG", "コンテンツ契約変更");
						// #84105 ADD END
						throw new CCException(SC_ERROR_STRING, new Exception());
					}
// ANK-4346-00-00 MOD END
				}
				
// ANK-4346-00-00 DEL START
				//				// コンテンツサービス解約正常判定
//				// コンテンツサービス解約で取得したステータスが応答なしの場合

//				if (JKKStrConst.CONT_SVC_KAI_STAT_NASI.equals((String)ecna0010001OutputMap.get(ECNA0010001CBSMsg.STAT)))
//				{
//					// 例外スローのため、ダミーのSIFエラーを設定
//					setExceptionErr(param, inMap, "ECNA0010001", "sysid_err");
//					// エラーコード：ウイルスバスターCCMG連携エラー
//					inMap.put("err_cd", ERR_CD_VIRUSBUSTER_CCMG_ERR);
//					// 例外をスロー
//					throw new CCException(SC_ERROR_STRING, new Exception());
//				}
//				// コンテンツサービス解約で取得したエラーコードが正常終了、または、コンテンツ契約番号解約済み 以外の場合
//				if (!(JKKStrConst.CONT_SVC_KAI_ERR_CD_NORMAL.equals((String)ecna0010001OutputMap.get(ECNA0010001CBSMsg.ERR_CD)) || JKKStrConst.CONT_SVC_KAI_ERR_CD_CONT_KEI_NO_KAI.equals((String)ecna0010001OutputMap.get(ECNA0010001CBSMsg.ERR_CD)))) 
//				{
//					// 例外スローのため、ダミーのSIFエラーを設定
//					setExceptionErr(param, inMap, "ECNA0010001", "sysid_err");
//					// エラーコード：ウイルスバスターCCMG連携エラー
//					inMap.put("err_cd", ERR_CD_VIRUSBUSTER_CCMG_ERR);
//					// 例外をスロー
//					throw new CCException(SC_ERROR_STRING, new Exception());
//				}
// ANK-4346-00-00 DEL END
			}
		}
		
		ArrayList<HashMap<String, Object>> ekk0341b019OutputList = new ArrayList<HashMap<String, Object>>();
		
		// 機器提供サービス契約一覧照会(サービス契約番号、回線対象サービス契約経由)
		template = editInEKK0341B019(param, fixedText); // 上りマッピング
		result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
		editRetEKK0341B019(result, param, fixedText ,ekk0341b019OutputList); // 下りマッピング
		if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
		{ // ステータスが単項目エラー以上であれば例外をスロー
			throw new CCException(SC_ERROR_STRING, new Exception());
		}
		
// ANK-4315-00-00 ADD START
// #85051 MOD START
//		ArrayList<String> ekk0341b019KktkSvcKeiNoList = new ArrayList<String>();
		ekk0341b019KktkSvcKeiNoList = new ArrayList<String>();
// #85051 MOD END
// ANK-4315-00-00 ADD END
		// 多機能ルーターを特定する
		for (int i = 0; i < ekk0341b019OutputList.size(); i++)
		{
			HashMap<String, Object> childMap = (HashMap<String, Object>) ekk0341b019OutputList.get(i);
			
// ANK-4315-00-00 MOD START
//			// 宅内機器種別コードが多機能ルーター以外の場合
//			if (!JKKStrConst.TAKNKIKI_SBT_CD_TAKINORT.equals((String)childMap.get(EKK0341B019CBSMsg1List.TAKNKIKI_SBT_CD)))
			// 宅内機器種別コードが多機能ルーター、HGW以外の場合
			if (!JKKStrConst.TAKNKIKI_SBT_CD_TAKINORT.equals((String)childMap.get(EKK0341B019CBSMsg1List.TAKNKIKI_SBT_CD)) && 
				!JKKStrConst.TAKNKIKI_SBT_CD_HGW.equals((String)childMap.get(EKK0341B019CBSMsg1List.TAKNKIKI_SBT_CD)))
// ANK-4315-00-00 MOD END
			{
				continue;
			}
			// 機器提供サービス契約番号を保持する
// ANK-4315-00-00 MOD START
//			ekk0341b019KktkSvcKeiNo = (String)childMap.get(EKK0341B019CBSMsg1List.KKTK_SVC_KEI_NO);
//			break;
			ekk0341b019KktkSvcKeiNoList.add((String)childMap.get(EKK0341B019CBSMsg1List.KKTK_SVC_KEI_NO));
// ANK-4315-00-00 MOD END
		}
			
		// セキュリティパック申込他オプション更新CCマップ.多機能ルーター処理パターンが有線ルーター機能に変更の場合
		if (TAKINORT_TRNPTN_YUSEN.equals((String)inMap.get("takinortTrnPtn")))
		{
// ANK-4315-00-00 ADD START
			for (int j = 0; j < ekk0341b019KktkSvcKeiNoList.size(); j++)
			{
				ekk0341b019KktkSvcKeiNo = ekk0341b019KktkSvcKeiNoList.get(j);
// ANK-4315-00-00 ADD END
				ArrayList<HashMap<String, Object>> ekk2811b504OutputList = new ArrayList<HashMap<String, Object>>();
				
				// 機器提供サービス契約番号が存在する場合
				if (!JKKCommonUtil.isNull(ekk0341b019KktkSvcKeiNo))
				{
					// 機器オプションサービス契約一覧照会（複合検索）
					template = editInEKK2811B504(param, fixedText); // 上りマッピング
					result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
					editRetEKK2811B504(result, param, fixedText, ekk2811b504OutputList); // 下りマッピング
					if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
					{ // ステータスが単項目エラー以上であれば例外をスロー
						throw new CCException(SC_ERROR_STRING, new Exception());
					}
				}
				// ルーター機能、電話アダプター機能を特定する
				for (int i = 0; i < ekk2811b504OutputList.size(); i++)
				{
					HashMap<String, Object> childMap = (HashMap<String, Object>) ekk2811b504OutputList.get(i);
					
					// 機器オプションサービスコードがルーター機能、または、電話アダプター機能以外の場合
					if (!(JKKStrConst.KKOP_SVC_CD_ROUTER.equals((String)childMap.get(EKK2811B504CBSMsg1List.KKOP_SVC_CD)) || JKKStrConst.KKOP_SVC_CD_TEL_ADAPT.equals((String)childMap.get(EKK2811B504CBSMsg1List.KKOP_SVC_CD))))
					{
						continue;
					}
					
					// 機器オプションサービス契約ステータスが解約済以上の場合
					if (JKKStrConst.CD01616_STAT_DSLZUMI.compareTo((String)childMap.get(EKK2811B504CBSMsg1List.KKOP_SVC_KEI_STAT)) <= 0)
					{
						continue;
					}
					
					// 機器オプションサービスコードがルーター機能のレコードを保持する
					if (JKKStrConst.KKOP_SVC_CD_ROUTER.equals((String)childMap.get(EKK2811B504CBSMsg1List.KKOP_SVC_CD)))
					{
						ekk2811b504MapG01 = childMap;
					}
					// 機器オプションサービスコードが電話アダプター機能のレコードを保持する
					else
					{
						ekk2811b504MapG02 = childMap;
					}
				}
				
				
				HashMap<String, Object> ekk0341a010OutputMap = new HashMap<String, Object>();
				
				// 機器提供サービス契約番号が存在する場合
				if (!JKKCommonUtil.isNull(ekk0341b019KktkSvcKeiNo))
				{
					// 機器提供サービス契約一意照会
					template = editInEKK0341A010(param, fixedText); // 上りマッピング
					result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
					editRetEKK0341A010(result, param, fixedText, ekk0341a010OutputMap); // 下りマッピング
					if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
					{ // ステータスが単項目エラー以上であれば例外をスロー
						throw new CCException(SC_ERROR_STRING, new Exception());
					}
				}
				
				
				ArrayList<HashMap<String, Object>> ekk1041b001OutputList = new ArrayList<HashMap<String, Object>>();
				
				if (ekk0341a010OutputMap.size() > 0)
				{
					// オーダ設定一覧照会
					template = editInEKK1041B001(param, fixedText, ekk0341a010OutputMap); // 上りマッピング
					result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
					editRetEKK1041B001(result, param, fixedText ,ekk1041b001OutputList); // 下りマッピング
					if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
					{ // ステータスが単項目エラー以上であれば例外をスロー
						throw new CCException(SC_ERROR_STRING, new Exception());
					}
				}
				
				
				// 機器一覧機器オプションサービス契約更新部品呼び出し
				
				HashMap<String, Object> ccInputMap = new HashMap<String, Object>();
				
				// 機器一覧機器オプションサービス契約更新部品.機能コード
				ccInputMap.put("func_code", (String)inMap.get("func_code"));
				
				// 機器一覧機器オプションサービス契約更新部品.サービス契約番号
				ccInputMap.put("svc_kei_no", (String)inMap.get("svc_kei_no"));
				
				// 機器一覧機器オプションサービス契約更新部品.異動区分
				ccInputMap.put("ido_div", (String)inMap.get("ido_div"));
				
				// 機器一覧機器オプションサービス契約更新部品.異動理由コード
				ArrayList<HashMap<String, Object>> ekk1091d010cbsmsg1List = (ArrayList<HashMap<String, Object>>)inMap.get("EKK1091D010CBSMsg1List");
				HashMap<String, Object> chiledMap = ekk1091d010cbsmsg1List.get(0);
				ccInputMap.put("ido_rsn_cd", (String)chiledMap.get("ido_rsn_cd"));
				
				// 運用年月日
				String gyomuOpDate = JCCBPCommon.getOpeDate(null);
				
				// 運用日
				ccInputMap.put("unyo_ymd", gyomuOpDate);
				
				// ルーター機能コード
				ccInputMap.put("ruta_kino_cd", JKKStrConst.CD00134_KKOP_YUSEN);
				
				// ルーター機能解約区分 (解約しない)
				ccInputMap.put("rt_dsl_kbn", "0");
				
				// 機器オプションサービス契約処理区分 (変更「機器オプション更新」)
// IT2-2017-0000010 ADD START
//			ccIutputMap.put("kiki_opt_svc_kei_shori_kbn", "3");
				ccInputMap.put("KIKI_OPT_SVC_KEI_SHORI_KBN", "3");
// IT2-2017-0000010 ADD END
				
				// 機器一覧機器オプションサービス契約更新部品.機器提供サービス契約番号
				ccInputMap.put("kktk_svc_kei_no", ekk0341b019KktkSvcKeiNo);
				
				
				// 機器一覧機器オプションサービス契約更新部品.ルーター機器オプションサービス契約番号
				ccInputMap.put("ruta_kkop_svc_kei_no", (String)ekk2811b504MapG01.get("kkop_svc_kei_no"));
				
				
				// 電話アダプター機能が存在する場合設定
				if (!JKKCommonUtil.isNull(ekk2811b504MapG02))
				{
					// 機器一覧機器オプションサービス契約更新部品.電話アダプター機器オプションサービス契約番号
					ccInputMap.put("va_kkop_svc_kei_no", (String)ekk2811b504MapG02.get("kkop_svc_kei_no"));
					
					// 機器一覧機器オプションサービス契約更新部品.電話アダプター機能コード
					ccInputMap.put("va_adp_kino_cd", (String)ekk2811b504MapG02.get("pcrs_cd"));
					
					// 電話アダプター機能解約区分 (解約しない)
					ccInputMap.put("va_dsl_kbn", "0");
				}
				
				if (ekk1041b001OutputList.size() > 0)
				{
					HashMap<String, Object> ekk1041b001ChildMap = (HashMap<String, Object>) ekk1041b001OutputList.get(0);
					
					// 機器一覧機器オプションサービス契約更新部品.登録ＳＯＤ送信年月日
					ccInputMap.put("add_sod_send_ymd", (String)ekk1041b001ChildMap.get("add_sod_send_ymd"));
					
					// 機器一覧機器オプションサービス契約更新部品.停止ＳＯＤ送信年月日
					ccInputMap.put("stp_sod_send_ymd", (String)ekk1041b001ChildMap.get("stp_sod_send_ymd"));
					
				}
				
				// CC入力パラメータの作成
				param.setData(KIKI_KIKIOPT_KEI_UPD_CC, ccInputMap);
				
				// ワーク領域に申込明細番号を設定する
				// すでに設定されていることを考慮し、設定値を退避する
				Map workMap = param.getMappingWorkArea();
				if(workMap == null)
				{
					workMap = new HashMap();
					param.setMappingWorkArea(workMap);
				}
				
				String mskmDtlNo = (String)workMap.get("mskm_dtl_no");
				workMap.put("mskm_dtl_no", (String)inMap.get("mskm_dtl_no"));
				
				HashMap<String, Object> ccItemMap = null;
				
				// CCを呼出す
				JKKKikiIchiranKkOpKyUpdCC jkkKikiIchiranKkOpKyUpdCC = new JKKKikiIchiranKkOpKyUpdCC();
				jkkKikiIchiranKkOpKyUpdCC.execKikiOptKeiCreUpd(handle, param, KIKI_KIKIOPT_KEI_UPD_CC, ccItemMap);
				
				// CC入力パラメータの削除
				param.removeData(KIKI_KIKIOPT_KEI_UPD_CC);
				
// IT2-2017-0000010 ADD START
				// 工事案件連携情報作成
				execKojiAnkenRenkei(handle, scCall, param, fixedText);
// IT2-2017-0000010 ADD END
				
				// ワーク領域の申込明細番号を戻す
				workMap.put("mskm_dtl_no", mskmDtlNo);
// ANK-4315-00-00 ADD START
			}
// ANK-4315-00-00 ADD END
		}
		return param;
	}

	/**
	 * 例外発生させるためのサービスIFエラー（ダミー）を設定します。
	 * <br>
	 * @param param
	 * @param paramMap
	 * @param errIfId エラー発生サービスIFID
	 * @param errItem エラー発生項目
	 * @return パラメータマップ
	 * @throws RequestParameterException
	 */
	protected void setExceptionErr(IRequestParameterReadWrite param, HashMap<String, Object> inMap, String errIfId, String errItem)
			throws RequestParameterException
	{
		inMap.put(errItem, "EZ");
		
		int templateStatus = JPCModelConstant.RELATION_ERR;
		
		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);
		}
		
		// エラー情報のリストを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		HashMap<String, Object> errorMap = new HashMap<String, Object>();
		HashMap<String, String> errorMapChild = new HashMap<String, String>();
		
		errorMap.put(ErrorInfoMapKeys.RETURN_CODE, JPCModelConstant.NORMAL_END);
		errorMap.put(ErrorInfoMapKeys.TEMPLATE_ID, errIfId);
		errorMap.put(ErrorInfoMapKeys.STATUS, JPCModelConstant.RELATION_ERR);
		
		errorMapChild.put(errItem, "EZ");
		errorMap.put(ErrorInfoMapKeys.ITEM_CHECK_ERRORS, errorMapChild);
		
		errList.add(errorMap);
		
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, errList);
	}

	/**
	 * SCインプット共通データ設定処理を行います。
	 * <br>
	 * @param param
	 * @param paramMap
	 * @return パラメータマップ
	 * @throws RequestParameterException
	 */
	protected HashMap<String, Object> setSCInputCommonData(IRequestParameterReadWrite param, HashMap<String, Object> paramMap)
			throws RequestParameterException
	{
		/* SCインプット共通データ */
		// **********************************************
		// 【取得元：電文ヘッダ(ヘッダ)】
		// **********************************************
		// 電文ID
		paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID());
		// ユースケースID
		paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID());
		// オペレーションID
		paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID());
		// サービス呼び出し区分
		paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType());

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

		return paramMap;
	}

	/**
	 * 単一CAANMsgのマッピング処理を行います。
	 * <br>
	 * @param paramMap
	 * @param template
	 * @return パラメータマップ
	 * @throws RequestParameterException
	 */
	protected HashMap<String, Object> putParamMap(HashMap<String, Object> paramMap, CAANMsg template) throws RequestParameterException
	{
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

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

	/**
	 * CAANMsgに必要なデータのマッピング処理を行います。
	 * <br>
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return パラメータマップ
	 * @throws RequestParameterException
	 */
	public HashMap<String, Object> getInvokeCBS(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
			throws RequestParameterException
	{
		// 実装なし
		
		CAANMsg[] templates = new CAANMsg[0];
		
		HashMap<String, Object> paramMap = setSCInputCommonData(param, new HashMap<String, Object>());
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}

	/**
	 * エラー情報のマッピング処理を行います。
	 * <br>
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
			throws RequestParameterException
	{
		// 実装なし
		return param;
	}
	
	/**
	 * 申込明細一意照会の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0021A010(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0021A010CBSMsg.class.getName());
		String prefix = "";
		
		// テンプレートID
		template.set(EKK0021A010CBSMsg.TEMPLATEID, "EKK0021A010");
		
		// 機能コード
		template.set(EKK0021A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// 申込明細一意照会.ＫＥＹ＿申込明細番号
		setTemplate(template, EKK0021A010CBSMsg.KEY_MSKM_DTL_NO, inMap, prefix, "mskm_dtl_no");
		
		return template;
	}
	
	/**
	 * 申込明細一意照会の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputMap
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0021A010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> outputMap)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		if (template != null)
		{
			
			templateArray = template.getCAANMsgList(EKK0021A010CBSMsg.EKK0021A010CBSMSG1LIST);
			CAANMsg childTemplate = templateArray[0];
			
			// 申込明細番号 ← 申込明細一意照会.申込明細番号
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_DTL_NO, childTemplate, EKK0021A010CBSMsg1List.MSKM_DTL_NO);

			// 世代登録年月日時分秒 ← 申込明細一意照会.世代登録年月日時分秒
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.GENE_ADD_DTM, childTemplate, EKK0021A010CBSMsg1List.GENE_ADD_DTM);

			// 申込明細ステータス ← 申込明細一意照会.申込明細ステータス
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_DTL_STAT, childTemplate, EKK0021A010CBSMsg1List.MSKM_DTL_STAT);

			// 申込明細ステータス名称 ← 申込明細一意照会.申込明細ステータス名称
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_DTL_STAT_NM, childTemplate, EKK0021A010CBSMsg1List.MSKM_DTL_STAT_NM);

			// 申込番号 ← 申込明細一意照会.申込番号
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_NO, childTemplate, EKK0021A010CBSMsg1List.MSKM_NO);

			// 申込書番号 ← 申込明細一意照会.申込書番号
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKMSHO_NO, childTemplate, EKK0021A010CBSMsg1List.MSKMSHO_NO);

			// 申込書明細番号 ← 申込明細一意照会.申込書明細番号
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKMSHO_DTL_NO, childTemplate, EKK0021A010CBSMsg1List.MSKMSHO_DTL_NO);

			// 申込年月日 ← 申込明細一意照会.申込年月日
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_YMD, childTemplate, EKK0021A010CBSMsg1List.MSKM_YMD);

			// SYSID ← 申込明細一意照会.SYSID
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.SYSID, childTemplate, EKK0021A010CBSMsg1List.SYSID);

			// SYSID名称 ← 申込明細一意照会.SYSID名称
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.SYSID_NM, childTemplate, EKK0021A010CBSMsg1List.SYSID_NM);

			// WEB受付番号 ← 申込明細一意照会.WEB受付番号
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.WEB_UK_NO, childTemplate, EKK0021A010CBSMsg1List.WEB_UK_NO);

			// 申込形態コード ← 申込明細一意照会.申込形態コード
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_FORM_CD, childTemplate, EKK0021A010CBSMsg1List.MSKM_FORM_CD);

			// 申込形態コード名称 ← 申込明細一意照会.申込形態コード名称
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_FORM_CD_NM, childTemplate, EKK0021A010CBSMsg1List.MSKM_FORM_CD_NM);

			// 申込明細種別コード ← 申込明細一意照会.申込明細種別コード
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_DTL_SBT_CD, childTemplate, EKK0021A010CBSMsg1List.MSKM_DTL_SBT_CD);

			// 連絡先携帯電話番号 ← 申込明細一意照会.連絡先携帯電話番号
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.RRKS_KTAI_TELNO, childTemplate, EKK0021A010CBSMsg1List.RRKS_KTAI_TELNO);

			// 連絡先勤務先名 ← 申込明細一意照会.連絡先勤務先名
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.RRKS_OFFC_NM, childTemplate, EKK0021A010CBSMsg1List.RRKS_OFFC_NM);

			// 昼間連絡先電話番号 ← 申込明細一意照会.昼間連絡先電話番号
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.DT_RRKS_TELNO, childTemplate, EKK0021A010CBSMsg1List.DT_RRKS_TELNO);

			// 新規申込種別コード ← 申込明細一意照会.新規申込種別コード
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.NEW_MSKM_SBT_CD, childTemplate, EKK0021A010CBSMsg1List.NEW_MSKM_SBT_CD);

			// 申込契機コード ← 申込明細一意照会.申込契機コード
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_OPTNTY_CD, childTemplate, EKK0021A010CBSMsg1List.MSKM_OPTNTY_CD);

			// 申込契機コード名称 ← 申込明細一意照会.申込契機コード名称
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_OPTNTY_CD_NM, childTemplate, EKK0021A010CBSMsg1List.MSKM_OPTNTY_CD_NM);

			// 宅内調査希望アポ期限年月日 ← 申込明細一意照会.宅内調査希望アポ期限年月日
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.TAKCHO_KIBO_APO_KIGEN_YMD, childTemplate, EKK0021A010CBSMsg1List.TAKCHO_KIBO_APO_KIGEN_YMD);

			// 工事アポ連絡先指定コード ← 申込明細一意照会.工事アポ連絡先指定コード
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.KOJI_APO_RRKS_SHITEI_CD, childTemplate, EKK0021A010CBSMsg1List.KOJI_APO_RRKS_SHITEI_CD);

			// 工事アポ連絡先電話番号 ← 申込明細一意照会.工事アポ連絡先電話番号
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.KOJI_APO_RRKS_TELNO, childTemplate, EKK0021A010CBSMsg1List.KOJI_APO_RRKS_TELNO);

			// 連絡事項登録年月日時分秒 ← 申込明細一意照会.連絡事項登録年月日時分秒
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.RRK_JIKO_ADD_DTM, childTemplate, EKK0021A010CBSMsg1List.RRK_JIKO_ADD_DTM);

			// 申込明細照査年月日時分秒 ← 申込明細一意照会.申込明細照査年月日時分秒
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_DTL_SHOSA_DTM, childTemplate, EKK0021A010CBSMsg1List.MSKM_DTL_SHOSA_DTM);

			// 申込明細照査取消年月日 ← 申込明細一意照会.申込明細照査取消年月日
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_DTL_SHOSA_CL_YMD, childTemplate, EKK0021A010CBSMsg1List.MSKM_DTL_SHOSA_CL_YMD);

			// 後続業務依頼年月日 ← 申込明細一意照会.後続業務依頼年月日
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.KZKWRK_REQYMD, childTemplate, EKK0021A010CBSMsg1List.KZKWRK_REQYMD);

			// 申込明細キャンセル年月日 ← 申込明細一意照会.申込明細キャンセル年月日
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_DTL_CANCEL_YMD, childTemplate, EKK0021A010CBSMsg1List.MSKM_DTL_CANCEL_YMD);

			// 申込明細キャンセル理由コード ← 申込明細一意照会.申込明細キャンセル理由コード
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_DTL_CANCEL_RSN_CD, childTemplate, EKK0021A010CBSMsg1List.MSKM_DTL_CANCEL_RSN_CD);

			// 申込明細キャンセル理由メモ ← 申込明細一意照会.申込明細キャンセル理由メモ
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_DTL_CANCEL_RSN_MEMO, childTemplate, EKK0021A010CBSMsg1List.MSKM_DTL_CANCEL_RSN_MEMO);

			// 申込明細キャンセル取消年月日 ← 申込明細一意照会.申込明細キャンセル取消年月日
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_DTL_CANCEL_CL_YMD, childTemplate, EKK0021A010CBSMsg1List.MSKM_DTL_CANCEL_CL_YMD);

			// 申込連絡先メールアドレス ← 申込明細一意照会.申込連絡先メールアドレス
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKM_RRKS_MLAD, childTemplate, EKK0021A010CBSMsg1List.MSKM_RRKS_MLAD);

			// 工事進捗通知メールアドレス ← 申込明細一意照会.工事進捗通知メールアドレス
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.KOJI_PRG_TCHI_MLAD, childTemplate, EKK0021A010CBSMsg1List.KOJI_PRG_TCHI_MLAD);

			// 連絡事項 ← 申込明細一意照会.連絡事項
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.RRK_JIKO, childTemplate, EKK0021A010CBSMsg1List.RRK_JIKO);

			// 最新照会年月日 ← 申込明細一意照会.最新照会年月日
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.RCNT_SHOKAI_YMD, childTemplate, EKK0021A010CBSMsg1List.RCNT_SHOKAI_YMD);

			// Web照会回数 ← 申込明細一意照会.Web照会回数
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.WEB_SHOKAI_CNT, childTemplate, EKK0021A010CBSMsg1List.WEB_SHOKAI_CNT);

			// PC照会回数 ← 申込明細一意照会.PC照会回数
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.PC_SHOKAI_CNT, childTemplate, EKK0021A010CBSMsg1List.PC_SHOKAI_CNT);

			// 携帯照会回数 ← 申込明細一意照会.携帯照会回数
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.KTAI_SHOKAI_CNT, childTemplate, EKK0021A010CBSMsg1List.KTAI_SHOKAI_CNT);

			// 工事進捗通知携帯メールアドレス ← 申込明細一意照会.工事進捗通知携帯メールアドレス
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.KJSC_TCH_KTAI_MLAD, childTemplate, EKK0021A010CBSMsg1List.KJSC_TCH_KTAI_MLAD);

			// 工事進捗通知PCメールアドレス変更年月日 ← 申込明細一意照会.工事進捗通知PCメールアドレス変更年月日
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.KJSC_TCH_PC_MLAD_CHG_YMD, childTemplate, EKK0021A010CBSMsg1List.KJSC_TCH_PC_MLAD_CHG_YMD);

			// 工事進捗通知携帯メールアドレス変更年月日 ← 申込明細一意照会.工事進捗通知携帯メールアドレス変更年月日
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.KJSC_TCH_KTAI_MLAD_CHG_YMD, childTemplate, EKK0021A010CBSMsg1List.KJSC_TCH_KTAI_MLAD_CHG_YMD);

			// 進捗メール最終送信年月日時分秒 ← 申込明細一意照会.進捗メール最終送信年月日時分秒
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.PRG_ML_LAST_SEND_DTM, childTemplate, EKK0021A010CBSMsg1List.PRG_ML_LAST_SEND_DTM);

			// メール送信除外フラグ ← 申込明細一意照会.メール送信除外フラグ
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.ML_SEND_JGI_FLG, childTemplate, EKK0021A010CBSMsg1List.ML_SEND_JGI_FLG);

			// メール送信除外理由メモ ← 申込明細一意照会.メール送信除外理由メモ
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.ML_SEND_JGI_RSN_MEMO, childTemplate, EKK0021A010CBSMsg1List.ML_SEND_JGI_RSN_MEMO);

			// 番ポ申込連絡先電話番号 ← 申込明細一意照会.番ポ申込連絡先電話番号
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.BMP_MSKM_RRKS_TLN, childTemplate, EKK0021A010CBSMsg1List.BMP_MSKM_RRKS_TLN);

			// オプションサービス引継有無 ← 申込明細一意照会.オプションサービス引継有無
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.OP_SVC_HKTGI_UM, childTemplate, EKK0021A010CBSMsg1List.OP_SVC_HKTGI_UM);

			// オプションサービス引継有無名称 ← 申込明細一意照会.オプションサービス引継有無名称
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.OP_SVC_HKTGI_UM_NM, childTemplate, EKK0021A010CBSMsg1List.OP_SVC_HKTGI_UM_NM);

			// 解約書類送付希望有無 ← 申込明細一意照会.解約書類送付希望有無
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.DSL_ATICLE_SOHU_KIBO_UM, childTemplate, EKK0021A010CBSMsg1List.DSL_ATICLE_SOHU_KIBO_UM);

			// 解約書類送付希望有無名称 ← 申込明細一意照会.解約書類送付希望有無名称
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.DSL_ATICLE_SOHU_KIBO_UM_NM, childTemplate, EKK0021A010CBSMsg1List.DSL_ATICLE_SOHU_KIBO_UM_NM);

			// 連絡手段補記 ← 申込明細一意照会.連絡手段補記
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.RRK_WAY_HOKI, childTemplate, EKK0021A010CBSMsg1List.RRK_WAY_HOKI);

			// 新築物件コード ← 申込明細一意照会.新築物件コード
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.NEWCONST_BUKKEN_CD, childTemplate, EKK0021A010CBSMsg1List.NEWCONST_BUKKEN_CD);

			// 新築物件コード名称 ← 申込明細一意照会.新築物件コード名称
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.NEWCONST_BUKKEN_CD_NM, childTemplate, EKK0021A010CBSMsg1List.NEWCONST_BUKKEN_CD_NM);

			// 復活案件フラグ ← 申込明細一意照会.復活案件フラグ
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.HUKKAT_ANKEN_FLG, childTemplate, EKK0021A010CBSMsg1List.HUKKAT_ANKEN_FLG);

			// 復活案件フラグ名称 ← 申込明細一意照会.復活案件フラグ名称
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.HUKKAT_ANKEN_FLG_NM, childTemplate, EKK0021A010CBSMsg1List.HUKKAT_ANKEN_FLG_NM);

			// 同一設備再申込コード ← 申込明細一意照会.同一設備再申込コード
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.SAME_EQUIP_RE_MSKM_CD, childTemplate, EKK0021A010CBSMsg1List.SAME_EQUIP_RE_MSKM_CD);

			// 同一設備再申込コード名称 ← 申込明細一意照会.同一設備再申込コード名称
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.SAME_EQUIP_RE_MSKM_CD_NM, childTemplate, EKK0021A010CBSMsg1List.SAME_EQUIP_RE_MSKM_CD_NM);

			// 本人確認書類種別コード ← 申込明細一意照会.本人確認書類種別コード
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.HNIN_CFM_ATICLE_SBT_CD, childTemplate, EKK0021A010CBSMsg1List.HNIN_CFM_ATICLE_SBT_CD);

			// 本人確認書類種別コード名称 ← 申込明細一意照会.本人確認書類種別コード名称
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.HNIN_CFM_ATICLE_SBT_CD_NM, childTemplate, EKK0021A010CBSMsg1List.HNIN_CFM_ATICLE_SBT_CD_NM);

			// 申込書種別コード ← 申込明細一意照会.申込書種別コード
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKMSHO_SBT_CD, childTemplate, EKK0021A010CBSMsg1List.MSKMSHO_SBT_CD);

			// 申込書種別コード名称 ← 申込明細一意照会.申込書種別コード名称
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKMSHO_SBT_CD_NM, childTemplate, EKK0021A010CBSMsg1List.MSKMSHO_SBT_CD_NM);

			// 契約付加コード ← 申込明細一意照会.契約付加コード
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.KEI_HUKA_CD, childTemplate, EKK0021A010CBSMsg1List.KEI_HUKA_CD);

			// 地図添付有無 ← 申込明細一意照会.地図添付有無
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MAP_TEMP_UM, childTemplate, EKK0021A010CBSMsg1List.MAP_TEMP_UM);

			// 地図添付有無名称 ← 申込明細一意照会.地図添付有無名称
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MAP_TEMP_UM_NM, childTemplate, EKK0021A010CBSMsg1List.MAP_TEMP_UM_NM);

			// KCNSTB申込台数 ← 申込明細一意照会.KCNSTB申込台数
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.KCN_STB_MSKM_CNT, childTemplate, EKK0021A010CBSMsg1List.KCN_STB_MSKM_CNT);

			// KCNSTB種類コード ← 申込明細一意照会.KCNSTB種類コード
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.KCN_STB_KIND_CD, childTemplate, EKK0021A010CBSMsg1List.KCN_STB_KIND_CD);

			// マンション設備システム連携用記事欄 ← 申込明細一意照会.マンション設備システム連携用記事欄
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MANSSBSYS_RNKI_YO_KIJIRAN, childTemplate, EKK0021A010CBSMsg1List.MANSSBSYS_RNKI_YO_KIJIRAN);

			// マンションID ← 申込明細一意照会.マンションID
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MANSION_ID, childTemplate, EKK0021A010CBSMsg1List.MANSION_ID);

			// CAT-ID ← 申込明細一意照会.CAT-ID
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.CATID, childTemplate, EKK0021A010CBSMsg1List.CATID);

			// 申込受付種別コード ← 申込明細一意照会.申込受付種別コード
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MKM_UK_SBT_CD, childTemplate, EKK0021A010CBSMsg1List.MKM_UK_SBT_CD);

			// 申込受付種別コード名称 ← 申込明細一意照会.申込受付種別コード名称
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MKM_UK_SBT_CD_NM, childTemplate, EKK0021A010CBSMsg1List.MKM_UK_SBT_CD_NM);

			// 申込書取扱情報担当者名 ← 申込明細一意照会.申込書取扱情報担当者名
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKMSHO_TRAT_IF_TNTSHA_NM, childTemplate, EKK0021A010CBSMsg1List.MSKMSHO_TRAT_IF_TNTSHA_NM);

			// 申込書取扱情報電話番号 ← 申込明細一意照会.申込書取扱情報電話番号
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MSKMSHO_TRAT_IF_TELNO, childTemplate, EKK0021A010CBSMsg1List.MSKMSHO_TRAT_IF_TELNO);

			// 登録年月日時分秒 ← 申込明細一意照会.登録年月日時分秒
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.ADD_DTM, childTemplate, EKK0021A010CBSMsg1List.ADD_DTM);

			// 登録オペレータアカウント ← 申込明細一意照会.登録オペレータアカウント
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.ADD_OPEACNT, childTemplate, EKK0021A010CBSMsg1List.ADD_OPEACNT);

			// 更新年月日時分秒 ← 申込明細一意照会.更新年月日時分秒
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.UPD_DTM, childTemplate, EKK0021A010CBSMsg1List.UPD_DTM);

			// 更新オペレータアカウント ← 申込明細一意照会.更新オペレータアカウント
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.UPD_OPEACNT, childTemplate, EKK0021A010CBSMsg1List.UPD_OPEACNT);

			// 削除年月日時分秒 ← 申込明細一意照会.削除年月日時分秒
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.DEL_DTM, childTemplate, EKK0021A010CBSMsg1List.DEL_DTM);

			// 削除オペレータアカウント ← 申込明細一意照会.削除オペレータアカウント
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.DEL_OPEACNT, childTemplate, EKK0021A010CBSMsg1List.DEL_OPEACNT);

			// 無効フラグ ← 申込明細一意照会.無効フラグ
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MK_FLG, childTemplate, EKK0021A010CBSMsg1List.MK_FLG);

			// 無効フラグ名称 ← 申込明細一意照会.無効フラグ名称
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.MK_FLG_NM, childTemplate, EKK0021A010CBSMsg1List.MK_FLG_NM);

			// 最終更新年月日時分秒 ← 申込明細一意照会.最終更新年月日時分秒
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.LAST_UPD_DTM, childTemplate, EKK0021A010CBSMsg1List.LAST_UPD_DTM);

			// 本人確認書類名 ← 申込明細一意照会.本人確認書類名
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.HNIN_CFM_ATICLE_NM, childTemplate, EKK0021A010CBSMsg1List.HNIN_CFM_ATICLE_NM);

			// 割引自動適用対象外フラグ ← 申込明細一意照会.割引自動適用対象外フラグ
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.WRIB_AUTO_APLY_TG_GAI_FLG, childTemplate, EKK0021A010CBSMsg1List.WRIB_AUTO_APLY_TG_GAI_FLG);

			// 割引自動適用対象外フラグ名称 ← 申込明細一意照会.割引自動適用対象外フラグ名称
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.WRIB_AUTO_APLY_TG_GAI_FLG_NM, childTemplate, EKK0021A010CBSMsg1List.WRIB_AUTO_APLY_TG_GAI_FLG_NM);

			// 多機能ルーター交換希望有無 ← 申込明細一意照会.多機能ルーター交換希望有無
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.TAKINORT_KKN_KIBO_UM, childTemplate, EKK0021A010CBSMsg1List.TAKINORT_KKN_KIBO_UM);

			// 同時申込eo光申込書番号 ← 申込明細一意照会.同時申込eo光申込書番号
			setDataMap(outputMap, "", EKK0021A010CBSMsg1List.DOJI_MSKM_EOH_MSKMSHO_NO, childTemplate, EKK0021A010CBSMsg1List.DOJI_MSKM_EOH_MSKMSHO_NO);
		}
		
		// エラー情報の設定
		editErrInfoEKK0021A010(param, template, (Integer)returnCode, fixedText);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	/**
	 * 申込明細一意照会のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0021A010(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);
		
		HashMap inMap = (HashMap)param.getData(fixedText);
		
		// 申込明細一意照会.ＫＥＹ＿申込明細番号 → 申込明細番号のエラー情報返却
		setErrInfo(inMap, "", EKK0021A010CBSMsg.KEY_MSKM_DTL_NO_ERR, template, EKK0021A010CBSMsg.KEY_MSKM_DTL_NO_ERR);
		
		return param;
	}
	
	/**
	 * 申込明細情報変更の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param outputMap
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0021C040(IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> outputMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0021C040CBSMsg.class.getName());
		String prefix = "";
		
		// テンプレートID
		template.set(EKK0021C040CBSMsg.TEMPLATEID, "EKK0021C040");
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// 申込明細情報変更.機能コード
		setTemplate(template, EKK0021C040CBSMsg.FUNC_CODE, inMap, prefix, "func_code");
		
		// 申込明細情報変更.申込明細番号
		setTemplate(template, EKK0021C040CBSMsg.MSKM_DTL_NO, inMap, prefix, "mskm_dtl_no");
		
		// 申込明細情報変更.ファミリーパック解約有無
		setTemplate(template, EKK0021C040CBSMsg.FAMILY_PACK_DSL_KIBO_UM, inMap, prefix, "fp_dsl_um");
		
		// 申込明細情報変更.ウイルスバスター解約有無
		setTemplate(template, EKK0021C040CBSMsg.VIRUSBUSTER_DSL_KIBO_UM, inMap, prefix, "vb_dsl_um");
		
		// 申込明細情報変更.有害Webフィルター解約有無
		setTemplate(template, EKK0021C040CBSMsg.YUGAI_WEB_FLT_DSL_KIBO_UM, inMap, prefix, "yugai_web_flt_dsl_um");
		
		
		// 申込明細情報変更.申込書番号
		setTemplate(template, EKK0021C040CBSMsg.MSKMSHO_NO, outputMap, prefix, EKK0021A010CBSMsg1List.MSKMSHO_NO);

		// 申込明細情報変更.申込年月日
		setTemplate(template, EKK0021C040CBSMsg.MSKM_YMD, outputMap, prefix, EKK0021A010CBSMsg1List.MSKM_YMD);

		// 申込明細情報変更.申込形態コード
		setTemplate(template, EKK0021C040CBSMsg.MSKM_FORM_CD, outputMap, prefix, EKK0021A010CBSMsg1List.MSKM_FORM_CD);

		// 申込明細情報変更.申込明細種別コード
		setTemplate(template, EKK0021C040CBSMsg.MSKM_DTL_SBT_CD, outputMap, prefix, EKK0021A010CBSMsg1List.MSKM_DTL_SBT_CD);

		// 申込明細情報変更.連絡先携帯電話番号
		setTemplate(template, EKK0021C040CBSMsg.RRKS_KTAI_TELNO, outputMap, prefix, EKK0021A010CBSMsg1List.RRKS_KTAI_TELNO);

		// 申込明細情報変更.連絡先勤務先名
		setTemplate(template, EKK0021C040CBSMsg.RRKS_OFFC_NM, outputMap, prefix, EKK0021A010CBSMsg1List.RRKS_OFFC_NM);

		// 申込明細情報変更.昼間連絡先電話番号
		setTemplate(template, EKK0021C040CBSMsg.DT_RRKS_TELNO, outputMap, prefix, EKK0021A010CBSMsg1List.DT_RRKS_TELNO);

		// 申込明細情報変更.新規申込種別コード
		setTemplate(template, EKK0021C040CBSMsg.NEW_MSKM_SBT_CD, outputMap, prefix, EKK0021A010CBSMsg1List.NEW_MSKM_SBT_CD);

		// 申込明細情報変更.申込契機コード
		setTemplate(template, EKK0021C040CBSMsg.MSKM_OPTNTY_CD, outputMap, prefix, EKK0021A010CBSMsg1List.MSKM_OPTNTY_CD);

		// 申込明細情報変更.宅内調査希望アポ期限年月日
		setTemplate(template, EKK0021C040CBSMsg.TAKCHO_KIBO_APO_KIGEN_YMD, outputMap, prefix, EKK0021A010CBSMsg1List.TAKCHO_KIBO_APO_KIGEN_YMD);

		// 申込明細情報変更.工事アポ連絡先指定コード
		setTemplate(template, EKK0021C040CBSMsg.KOJI_APO_RRKS_SHITEI_CD, outputMap, prefix, EKK0021A010CBSMsg1List.KOJI_APO_RRKS_SHITEI_CD);

		// 申込明細情報変更.工事アポ連絡先電話番号
		setTemplate(template, EKK0021C040CBSMsg.KOJI_APO_RRKS_TELNO, outputMap, prefix, EKK0021A010CBSMsg1List.KOJI_APO_RRKS_TELNO);

		// 申込明細情報変更.連絡事項登録年月日時分秒
		setTemplate(template, EKK0021C040CBSMsg.RRK_JIKO_ADD_DTM, outputMap, prefix, EKK0021A010CBSMsg1List.RRK_JIKO_ADD_DTM);

		// 申込明細情報変更.申込連絡先メールアドレス
		setTemplate(template, EKK0021C040CBSMsg.MSKM_RRKS_MLAD, outputMap, prefix, EKK0021A010CBSMsg1List.MSKM_RRKS_MLAD);

		// 申込明細情報変更.工事進捗通知メールアドレス
		setTemplate(template, EKK0021C040CBSMsg.KOJI_PRG_TCHI_MLAD, outputMap, prefix, EKK0021A010CBSMsg1List.KOJI_PRG_TCHI_MLAD);

		// 申込明細情報変更.連絡事項
		setTemplate(template, EKK0021C040CBSMsg.RRK_JIKO, outputMap, prefix, EKK0021A010CBSMsg1List.RRK_JIKO);

		// 申込明細情報変更.最新照会年月日
		setTemplate(template, EKK0021C040CBSMsg.RCNT_SHOKAI_YMD, outputMap, prefix, EKK0021A010CBSMsg1List.RCNT_SHOKAI_YMD);

		// 申込明細情報変更.Web照会回数
		setTemplate(template, EKK0021C040CBSMsg.WEB_SHOKAI_CNT, outputMap, prefix, EKK0021A010CBSMsg1List.WEB_SHOKAI_CNT);

		// 申込明細情報変更.PC照会回数
		setTemplate(template, EKK0021C040CBSMsg.PC_SHOKAI_CNT, outputMap, prefix, EKK0021A010CBSMsg1List.PC_SHOKAI_CNT);

		// 申込明細情報変更.携帯照会回数
		setTemplate(template, EKK0021C040CBSMsg.KTAI_SHOKAI_CNT, outputMap, prefix, EKK0021A010CBSMsg1List.KTAI_SHOKAI_CNT);

		// 申込明細情報変更.工事進捗通知携帯メールアドレス
		setTemplate(template, EKK0021C040CBSMsg.KJSC_TCH_KTAI_MLAD, outputMap, prefix, EKK0021A010CBSMsg1List.KJSC_TCH_KTAI_MLAD);

		// 申込明細情報変更.工事進捗通知PCメールアドレス変更年月日
		setTemplate(template, EKK0021C040CBSMsg.KJSC_TCH_PC_MLAD_CHG_YMD, outputMap, prefix, EKK0021A010CBSMsg1List.KJSC_TCH_PC_MLAD_CHG_YMD);

		// 申込明細情報変更.工事進捗通知携帯メールアドレス変更年月日
		setTemplate(template, EKK0021C040CBSMsg.KJSC_TCH_KTAI_MLAD_CHG_YMD, outputMap, prefix, EKK0021A010CBSMsg1List.KJSC_TCH_KTAI_MLAD_CHG_YMD);

		// 申込明細情報変更.メール送信除外フラグ
		setTemplate(template, EKK0021C040CBSMsg.ML_SEND_JGI_FLG, outputMap, prefix, EKK0021A010CBSMsg1List.ML_SEND_JGI_FLG);

		// 申込明細情報変更.メール送信除外理由メモ
		setTemplate(template, EKK0021C040CBSMsg.ML_SEND_JGI_RSN_MEMO, outputMap, prefix, EKK0021A010CBSMsg1List.ML_SEND_JGI_RSN_MEMO);

		// 申込明細情報変更.番ポ申込連絡先電話番号
		setTemplate(template, EKK0021C040CBSMsg.BMP_MSKM_RRKS_TLN, outputMap, prefix, EKK0021A010CBSMsg1List.BMP_MSKM_RRKS_TLN);

		// 申込明細情報変更.オプションサービス引継有無
		setTemplate(template, EKK0021C040CBSMsg.OP_SVC_HKTGI_UM, outputMap, prefix, EKK0021A010CBSMsg1List.OP_SVC_HKTGI_UM);

		// 申込明細情報変更.解約書類送付希望有無
		setTemplate(template, EKK0021C040CBSMsg.DSL_ATICLE_SOHU_KIBO_UM, outputMap, prefix, EKK0021A010CBSMsg1List.DSL_ATICLE_SOHU_KIBO_UM);

		// 申込明細情報変更.連絡手段補記
		setTemplate(template, EKK0021C040CBSMsg.RRK_WAY_HOKI, outputMap, prefix, EKK0021A010CBSMsg1List.RRK_WAY_HOKI);

		// 申込明細情報変更.新築物件コード
		setTemplate(template, EKK0021C040CBSMsg.NEWCONST_BUKKEN_CD, outputMap, prefix, EKK0021A010CBSMsg1List.NEWCONST_BUKKEN_CD);

		// 申込明細情報変更.復活案件フラグ
		setTemplate(template, EKK0021C040CBSMsg.HUKKAT_ANKEN_FLG, outputMap, prefix, EKK0021A010CBSMsg1List.HUKKAT_ANKEN_FLG);

		// 申込明細情報変更.同一設備再申込コード
		setTemplate(template, EKK0021C040CBSMsg.SAME_EQUIP_RE_MSKM_CD, outputMap, prefix, EKK0021A010CBSMsg1List.SAME_EQUIP_RE_MSKM_CD);

		// 申込明細情報変更.本人確認書類種別コード
		setTemplate(template, EKK0021C040CBSMsg.HNIN_CFM_ATICLE_SBT_CD, outputMap, prefix, EKK0021A010CBSMsg1List.HNIN_CFM_ATICLE_SBT_CD);

		// 申込明細情報変更.契約付加コード
		setTemplate(template, EKK0021C040CBSMsg.KEI_HUKA_CD, outputMap, prefix, EKK0021A010CBSMsg1List.KEI_HUKA_CD);

		// 申込明細情報変更.地図添付有無
		setTemplate(template, EKK0021C040CBSMsg.MAP_TEMP_UM, outputMap, prefix, EKK0021A010CBSMsg1List.MAP_TEMP_UM);

		// 申込明細情報変更.KCNSTB申込台数
		setTemplate(template, EKK0021C040CBSMsg.KCN_STB_MSKM_CNT, outputMap, prefix, EKK0021A010CBSMsg1List.KCN_STB_MSKM_CNT);

		// 申込明細情報変更.KCNSTB種類コード
		setTemplate(template, EKK0021C040CBSMsg.KCN_STB_KIND_CD, outputMap, prefix, EKK0021A010CBSMsg1List.KCN_STB_KIND_CD);

		// 申込明細情報変更.マンション設備システム連携用記事欄
		setTemplate(template, EKK0021C040CBSMsg.MANSSBSYS_RNKI_YO_KIJIRAN, outputMap, prefix, EKK0021A010CBSMsg1List.MANSSBSYS_RNKI_YO_KIJIRAN);

		// 申込明細情報変更.マンションID
		setTemplate(template, EKK0021C040CBSMsg.MANSION_ID, outputMap, prefix, EKK0021A010CBSMsg1List.MANSION_ID);

		// 申込明細情報変更.CAT-ID
		setTemplate(template, EKK0021C040CBSMsg.CATID, outputMap, prefix, EKK0021A010CBSMsg1List.CATID);

		// 申込明細情報変更.申込受付種別コード
		setTemplate(template, EKK0021C040CBSMsg.MKM_UK_SBT_CD, outputMap, prefix, EKK0021A010CBSMsg1List.MKM_UK_SBT_CD);

		// 申込明細情報変更.申込書取扱情報担当者名
		setTemplate(template, EKK0021C040CBSMsg.MSKMSHO_TRAT_IF_TNTSHA_NM, outputMap, prefix, EKK0021A010CBSMsg1List.MSKMSHO_TRAT_IF_TNTSHA_NM);

		// 申込明細情報変更.申込書取扱情報電話番号
		setTemplate(template, EKK0021C040CBSMsg.MSKMSHO_TRAT_IF_TELNO, outputMap, prefix, EKK0021A010CBSMsg1List.MSKMSHO_TRAT_IF_TELNO);

		// 申込明細情報変更.更新年月日時分秒(更新前)
		setTemplate(template, EKK0021C040CBSMsg.UPD_DTM_BF, outputMap, prefix, EKK0021A010CBSMsg1List.LAST_UPD_DTM);

		// 申込明細情報変更.申込書明細番号
		setTemplate(template, EKK0021C040CBSMsg.MSKMSHO_DTL_NO, outputMap, prefix, EKK0021A010CBSMsg1List.MSKMSHO_DTL_NO);

		// 申込明細情報変更.本人確認書類名
		setTemplate(template, EKK0021C040CBSMsg.HNIN_CFM_ATICLE_NM, outputMap, prefix, EKK0021A010CBSMsg1List.HNIN_CFM_ATICLE_NM);
		
		return template;
	}
	
	/**
	 * 申込明細情報変更の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputMap
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0021C040(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> outputMap)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		if (template != null)
		{
			// 世代登録年月日時分秒 ← 申込明細一意照会.世代登録年月日時分秒
			setDataMap(outputMap, "", EKK0021C040CBSMsg.GENE_ADD_DTM, template, EKK0021C040CBSMsg.GENE_ADD_DTM);

			// 登録年月日時分秒 ← 申込明細一意照会.登録年月日時分秒
			setDataMap(outputMap, "", EKK0021C040CBSMsg.ADD_DTM, template, EKK0021C040CBSMsg.ADD_DTM);

			// 登録オペレータアカウント ← 申込明細一意照会.登録オペレータアカウント
			setDataMap(outputMap, "", EKK0021C040CBSMsg.ADD_OPEACNT, template, EKK0021C040CBSMsg.ADD_OPEACNT);

			// 更新年月日時分秒 ← 申込明細一意照会.更新年月日時分秒
			setDataMap(outputMap, "", EKK0021C040CBSMsg.UPD_DTM, template, EKK0021C040CBSMsg.UPD_DTM);

			// 更新オペレータアカウント ← 申込明細一意照会.更新オペレータアカウント
			setDataMap(outputMap, "", EKK0021C040CBSMsg.UPD_OPEACNT, template, EKK0021C040CBSMsg.UPD_OPEACNT);

			// 無効フラグ ← 申込明細一意照会.無効フラグ
			setDataMap(outputMap, "", EKK0021C040CBSMsg.MK_FLG, template, EKK0021C040CBSMsg.MK_FLG);
		}
		
		// エラー情報の設定
		editErrInfoEKK0021C040(param, template, (Integer)returnCode, fixedText);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	/**
	 * 申込明細情報変更のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0021C040(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);
		
		HashMap inMap = (HashMap)param.getData(fixedText);
		
		// 申込明細情報変更.申込明細番号 → 申込明細番号のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MSKM_DTL_NO_ERR, template, EKK0021C040CBSMsg.MSKM_DTL_NO_ERR);
		
		// 申込明細情報変更.申込書番号 → 申込書番号のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MSKMSHO_NO_ERR, template, EKK0021C040CBSMsg.MSKMSHO_NO_ERR);

		// 申込明細情報変更.申込年月日 → 申込年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MSKM_YMD_ERR, template, EKK0021C040CBSMsg.MSKM_YMD_ERR);

		// 申込明細情報変更.申込形態コード → 申込形態コードのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MSKM_FORM_CD_ERR, template, EKK0021C040CBSMsg.MSKM_FORM_CD_ERR);

		// 申込明細情報変更.申込明細種別コード → 申込明細種別コードのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MSKM_DTL_SBT_CD_ERR, template, EKK0021C040CBSMsg.MSKM_DTL_SBT_CD_ERR);

		// 申込明細情報変更.連絡先携帯電話番号 → 連絡先携帯電話番号のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.RRKS_KTAI_TELNO_ERR, template, EKK0021C040CBSMsg.RRKS_KTAI_TELNO_ERR);

		// 申込明細情報変更.連絡先勤務先名 → 連絡先勤務先名のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.RRKS_OFFC_NM_ERR, template, EKK0021C040CBSMsg.RRKS_OFFC_NM_ERR);

		// 申込明細情報変更.昼間連絡先電話番号 → 昼間連絡先電話番号のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.DT_RRKS_TELNO_ERR, template, EKK0021C040CBSMsg.DT_RRKS_TELNO_ERR);

		// 申込明細情報変更.新規申込種別コード → 新規申込種別コードのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.NEW_MSKM_SBT_CD_ERR, template, EKK0021C040CBSMsg.NEW_MSKM_SBT_CD_ERR);

		// 申込明細情報変更.申込契機コード → 申込契機コードのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MSKM_OPTNTY_CD_ERR, template, EKK0021C040CBSMsg.MSKM_OPTNTY_CD_ERR);

		// 申込明細情報変更.宅内調査希望アポ期限年月日 → 宅内調査希望アポ期限年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.TAKCHO_KIBO_APO_KIGEN_YMD_ERR, template, EKK0021C040CBSMsg.TAKCHO_KIBO_APO_KIGEN_YMD_ERR);

		// 申込明細情報変更.工事アポ連絡先指定コード → 工事アポ連絡先指定コードのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.KOJI_APO_RRKS_SHITEI_CD_ERR, template, EKK0021C040CBSMsg.KOJI_APO_RRKS_SHITEI_CD_ERR);

		// 申込明細情報変更.工事アポ連絡先電話番号 → 工事アポ連絡先電話番号のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.KOJI_APO_RRKS_TELNO_ERR, template, EKK0021C040CBSMsg.KOJI_APO_RRKS_TELNO_ERR);

		// 申込明細情報変更.連絡事項登録年月日時分秒 → 連絡事項登録年月日時分秒のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.RRK_JIKO_ADD_DTM_ERR, template, EKK0021C040CBSMsg.RRK_JIKO_ADD_DTM_ERR);

		// 申込明細情報変更.申込連絡先メールアドレス → 申込連絡先メールアドレスのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MSKM_RRKS_MLAD_ERR, template, EKK0021C040CBSMsg.MSKM_RRKS_MLAD_ERR);

		// 申込明細情報変更.工事進捗通知メールアドレス → 工事進捗通知メールアドレスのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.KOJI_PRG_TCHI_MLAD_ERR, template, EKK0021C040CBSMsg.KOJI_PRG_TCHI_MLAD_ERR);

		// 申込明細情報変更.連絡事項 → 連絡事項のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.RRK_JIKO_ERR, template, EKK0021C040CBSMsg.RRK_JIKO_ERR);

		// 申込明細情報変更.最新照会年月日 → 最新照会年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.RCNT_SHOKAI_YMD_ERR, template, EKK0021C040CBSMsg.RCNT_SHOKAI_YMD_ERR);

		// 申込明細情報変更.Web照会回数 → Web照会回数のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.WEB_SHOKAI_CNT_ERR, template, EKK0021C040CBSMsg.WEB_SHOKAI_CNT_ERR);

		// 申込明細情報変更.PC照会回数 → PC照会回数のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.PC_SHOKAI_CNT_ERR, template, EKK0021C040CBSMsg.PC_SHOKAI_CNT_ERR);

		// 申込明細情報変更.携帯照会回数 → 携帯照会回数のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.KTAI_SHOKAI_CNT_ERR, template, EKK0021C040CBSMsg.KTAI_SHOKAI_CNT_ERR);

		// 申込明細情報変更.工事進捗通知携帯メールアドレス → 工事進捗通知携帯メールアドレスのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.KJSC_TCH_KTAI_MLAD_ERR, template, EKK0021C040CBSMsg.KJSC_TCH_KTAI_MLAD_ERR);

		// 申込明細情報変更.工事進捗通知PCメールアドレス変更年月日 → 工事進捗通知PCメールアドレス変更年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.KJSC_TCH_PC_MLAD_CHG_YMD_ERR, template, EKK0021C040CBSMsg.KJSC_TCH_PC_MLAD_CHG_YMD_ERR);

		// 申込明細情報変更.工事進捗通知携帯メールアドレス変更年月日 → 工事進捗通知携帯メールアドレス変更年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.KJSC_TCH_KTAI_MLAD_CHG_YMD_ERR, template, EKK0021C040CBSMsg.KJSC_TCH_KTAI_MLAD_CHG_YMD_ERR);

		// 申込明細情報変更.メール送信除外フラグ → メール送信除外フラグのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.ML_SEND_JGI_FLG_ERR, template, EKK0021C040CBSMsg.ML_SEND_JGI_FLG_ERR);

		// 申込明細情報変更.メール送信除外理由メモ → メール送信除外理由メモのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.ML_SEND_JGI_RSN_MEMO_ERR, template, EKK0021C040CBSMsg.ML_SEND_JGI_RSN_MEMO_ERR);

		// 申込明細情報変更.番ポ申込連絡先電話番号 → 番ポ申込連絡先電話番号のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.BMP_MSKM_RRKS_TLN_ERR, template, EKK0021C040CBSMsg.BMP_MSKM_RRKS_TLN_ERR);

		// 申込明細情報変更.オプションサービス引継有無 → オプションサービス引継有無のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.OP_SVC_HKTGI_UM_ERR, template, EKK0021C040CBSMsg.OP_SVC_HKTGI_UM_ERR);

		// 申込明細情報変更.解約書類送付希望有無 → 解約書類送付希望有無のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.DSL_ATICLE_SOHU_KIBO_UM_ERR, template, EKK0021C040CBSMsg.DSL_ATICLE_SOHU_KIBO_UM_ERR);

		// 申込明細情報変更.連絡手段補記 → 連絡手段補記のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.RRK_WAY_HOKI_ERR, template, EKK0021C040CBSMsg.RRK_WAY_HOKI_ERR);

		// 申込明細情報変更.新築物件コード → 新築物件コードのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.NEWCONST_BUKKEN_CD_ERR, template, EKK0021C040CBSMsg.NEWCONST_BUKKEN_CD_ERR);

		// 申込明細情報変更.復活案件フラグ → 復活案件フラグのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.HUKKAT_ANKEN_FLG_ERR, template, EKK0021C040CBSMsg.HUKKAT_ANKEN_FLG_ERR);

		// 申込明細情報変更.同一設備再申込コード → 同一設備再申込コードのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.SAME_EQUIP_RE_MSKM_CD_ERR, template, EKK0021C040CBSMsg.SAME_EQUIP_RE_MSKM_CD_ERR);

		// 申込明細情報変更.本人確認書類種別コード → 本人確認書類種別コードのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.HNIN_CFM_ATICLE_SBT_CD_ERR, template, EKK0021C040CBSMsg.HNIN_CFM_ATICLE_SBT_CD_ERR);

		// 申込明細情報変更.契約付加コード → 契約付加コードのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.KEI_HUKA_CD_ERR, template, EKK0021C040CBSMsg.KEI_HUKA_CD_ERR);

		// 申込明細情報変更.地図添付有無 → 地図添付有無のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MAP_TEMP_UM_ERR, template, EKK0021C040CBSMsg.MAP_TEMP_UM_ERR);

		// 申込明細情報変更.KCNSTB申込台数 → KCNSTB申込台数のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.KCN_STB_MSKM_CNT_ERR, template, EKK0021C040CBSMsg.KCN_STB_MSKM_CNT_ERR);

		// 申込明細情報変更.KCNSTB種類コード → KCNSTB種類コードのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.KCN_STB_KIND_CD_ERR, template, EKK0021C040CBSMsg.KCN_STB_KIND_CD_ERR);

		// 申込明細情報変更.マンション設備システム連携用記事欄 → マンション設備システム連携用記事欄のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MANSSBSYS_RNKI_YO_KIJIRAN_ERR, template, EKK0021C040CBSMsg.MANSSBSYS_RNKI_YO_KIJIRAN_ERR);

		// 申込明細情報変更.マンションID → マンションIDのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MANSION_ID_ERR, template, EKK0021C040CBSMsg.MANSION_ID_ERR);

		// 申込明細情報変更.CAT-ID → CAT-IDのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.CATID_ERR, template, EKK0021C040CBSMsg.CATID_ERR);

		// 申込明細情報変更.申込受付種別コード → 申込受付種別コードのエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MKM_UK_SBT_CD_ERR, template, EKK0021C040CBSMsg.MKM_UK_SBT_CD_ERR);

		// 申込明細情報変更.申込書取扱情報担当者名 → 申込書取扱情報担当者名のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MSKMSHO_TRAT_IF_TNTSHA_NM_ERR, template, EKK0021C040CBSMsg.MSKMSHO_TRAT_IF_TNTSHA_NM_ERR);

		// 申込明細情報変更.申込書取扱情報電話番号 → 申込書取扱情報電話番号のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MSKMSHO_TRAT_IF_TELNO_ERR, template, EKK0021C040CBSMsg.MSKMSHO_TRAT_IF_TELNO_ERR);

		// 申込明細情報変更.最終更新年月日時分秒 → 最終更新年月日時分秒のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.UPD_DTM_BF_ERR, template, EKK0021C040CBSMsg.UPD_DTM_BF_ERR);

		// 申込明細情報変更.申込書明細番号 → 申込書明細番号のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MSKMSHO_DTL_NO_ERR, template, EKK0021C040CBSMsg.MSKMSHO_DTL_NO_ERR);

		// 申込明細情報変更.本人確認書類名 → 本人確認書類名のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.HNIN_CFM_ATICLE_NM_ERR, template, EKK0021C040CBSMsg.HNIN_CFM_ATICLE_NM_ERR);

		// 申込明細情報変更.ファミリーパック解約有無 → ファミリーパック解約有無のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MSKM_DTL_NO_ERR, template, EKK0021C040CBSMsg.MSKM_DTL_NO_ERR);
		
		// 申込明細情報変更.ウイルスバスター解約有無 → ウイルスバスター解約有無のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MSKM_DTL_NO_ERR, template, EKK0021C040CBSMsg.MSKM_DTL_NO_ERR);
		
		// 申込明細情報変更.有害Webフィルター解約有無 → 有害Webフィルター解約有無のエラー情報返却
		setErrInfo(inMap, "", EKK0021C040CBSMsg.MSKM_DTL_NO_ERR, template, EKK0021C040CBSMsg.MSKM_DTL_NO_ERR);
		
		return param;
	}
	
	/**
	 * 割引サービス契約一覧照会（割引サービス指定）の上りマップ
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0451B010(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0451B010CBSMsg.class.getName());

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

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

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

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

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

		// 割引サービス契約一覧照会（割引サービス指定）.ＫＥＹ＿サービス契約番号
		setTemplate(template, EKK0451B010CBSMsg.KEY_SVC_KEI_NO, inMap, "", "svc_kei_no");
		
		// 割引サービス契約一覧照会（割引サービス指定）.ＫＥＹ＿割引サービスコード
		template.set(EKK0451B010CBSMsg.KEY_WRIB_SVC_CD, JKKStrConst.WRIB_SVC_FAMIPA);

		return template;
	}
	
	/**
	 * 割引サービス契約一覧照会（割引サービス指定）の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputList
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0451B010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, ArrayList<HashMap<String, Object>> outputList) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		templateArray = template.getCAANMsgList(EKK0451B010CBSMsg.EKK0451B010CBSMSG1LIST);
		
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				HashMap<String, Object> childMap = new HashMap<String, Object>();
				
				// 割引サービス契約番号 ← 割引サービス契約一覧照会（割引サービス指定）.割引サービス契約番号
				setDataMap(childMap, "", EKK0451B010CBSMsg1List.WRIB_SVC_KEI_NO, templateArray[i], EKK0451B010CBSMsg1List.WRIB_SVC_KEI_NO);
				
				// リストにマップを格納する
				outputList.add(childMap);
			}
		}
		
		// エラー情報の設定
		editErrInfoEKK0451B010(param, template, (Integer)returnCode, fixedText);
		
		// エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	
	/**
	 * 割引サービス契約一覧照会（割引サービス指定）のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0451B010(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		// 割引サービス契約一覧照会.ＫＥＹ＿サービス契約番号 → ＫＥＹ＿サービス契約番号のエラー情報返却
		setErrInfo(inMap, "", EKK0451B010CBSMsg.KEY_SVC_KEI_NO_ERR, template, EKK0451B010CBSMsg.KEY_SVC_KEI_NO_ERR);
		
		// 割引サービス契約一覧照会.ＫＥＹ＿割引サービスコード → ＫＥＹ＿割引サービスコードのエラー情報返却
		setErrInfo(inMap, "", EKK0451B010CBSMsg.KEY_WRIB_SVC_CD_ERR, template, EKK0451B010CBSMsg.KEY_WRIB_SVC_CD_ERR);

		return param;
	}
	
	/**
	 * 割引サービス契約一意照会の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param outputList
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	private CAANMsg editInEKK0451A010(IRequestParameterReadWrite param, String fixedText, ArrayList<HashMap<String, Object>> outputList) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0451A010CBSMsg.class.getName());
		String prefix = "";

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

		// 機能コード
		template.set(EKK0451A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

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

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

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		HashMap<String, Object> childMap = (HashMap<String, Object>) outputList.get(0);

		// 割引サービス契約一意照会.ＫＥＹ＿割引サービス契約番号
		setTemplate(template, EKK0451A010CBSMsg.KEY_WRIB_SVC_KEI_NO, childMap, prefix, EKK0451B010CBSMsg1List.WRIB_SVC_KEI_NO);

		// 割引サービス契約一意照会.ＫＥＹ＿予約適用年月日
		String gyomuOpDate = JCCBPCommon.getOpeDate(null);
		template.set(EKK0451A010CBSMsg.KEY_RSV_APLY_YMD, gyomuOpDate);

		return template;
	}
	
	/**
	 * 割引サービス契約一意照会の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputList
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0451A010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> outputMap)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		if (template != null)
		{
			templateArray = template.getCAANMsgList(EKK0451A010CBSMsg.EKK0451A010CBSMSG1LIST);
			CAANMsg childTemplate = templateArray[0];
			
			// 割引サービス契約ステータス ← 割引サービス契約一意照会.割引サービス契約ステータス
			setDataMap(outputMap, "", EKK0451A010CBSMsg1List.WRIB_SVC_KEI_STAT, childTemplate, EKK0451A010CBSMsg1List.WRIB_SVC_KEI_STAT);

			// 申込明細番号 ← 割引サービス契約一意照会.申込明細番号
			setDataMap(outputMap, "", EKK0451A010CBSMsg1List.MSKM_DTL_NO, childTemplate, EKK0451A010CBSMsg1List.MSKM_DTL_NO);

			// プラン開始年月日 ← 割引サービス契約一意照会.プラン開始年月日
			setDataMap(outputMap, "", EKK0451A010CBSMsg1List.PLAN_STAYMD, childTemplate, EKK0451A010CBSMsg1List.PLAN_STAYMD);

			// プラン課金開始年月日 ← 割引サービス契約一意照会.プラン課金開始年月日
			setDataMap(outputMap, "", EKK0451A010CBSMsg1List.PLAN_CHRG_STAYMD, childTemplate, EKK0451A010CBSMsg1List.PLAN_CHRG_STAYMD);

			// プラン課金開始年月日 ← 割引サービス契約一意照会.プラン課金開始年月日
			setDataMap(outputMap, "", EKK0451A010CBSMsg1List.PLAN_CHRG_STAYMD, childTemplate, EKK0451A010CBSMsg1List.PLAN_CHRG_STAYMD);

			// サービス開始年月日 ← 割引サービス契約一意照会.サービス開始年月日
			setDataMap(outputMap, "", EKK0451A010CBSMsg1List.SVC_STA_YMD, childTemplate, EKK0451A010CBSMsg1List.SVC_STA_YMD);

			// サービス課金開始年月日 ← 割引サービス契約一意照会.サービス課金開始年月日
			setDataMap(outputMap, "", EKK0451A010CBSMsg1List.SVC_CHRG_STAYMD, childTemplate, EKK0451A010CBSMsg1List.SVC_CHRG_STAYMD);

			// 最終更新年月日時分秒 ← 割引サービス契約一意照会.最終更新年月日時分秒
			setDataMap(outputMap, "", EKK0451A010CBSMsg1List.LAST_UPD_DTM, childTemplate, EKK0451A010CBSMsg1List.LAST_UPD_DTM);
		}
		
		// エラー情報の設定
		editErrInfoEKK0451A010(param, template, (Integer)returnCode, fixedText);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	/**
	 * 割引サービス契約一意照会のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0451A010(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		// 割引サービス契約一意照会.ＫＥＹ＿割引サービス契約番号 → 割引サービス契約番号のエラー情報返却
		setErrInfo(inMap, "", EKK0451A010CBSMsg.KEY_WRIB_SVC_KEI_NO_ERR, template, EKK0451A010CBSMsg.KEY_WRIB_SVC_KEI_NO_ERR);
		
		// 割引サービス契約一意照会.ＫＥＹ＿予約適用年月日 → 予約適用年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0451A010CBSMsg.KEY_RSV_APLY_YMD_ERR, template, EKK0451A010CBSMsg.KEY_RSV_APLY_YMD_ERR);
		
		return param;
	}
	
	/**
	 * サービス契約一意照会の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0081A010(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0081A010CBSMsg.class.getName());
		String prefix = "";

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

		// 機能コード
		template.set(EKK0081A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

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

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

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

		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

		// サービス契約一意照会.ＫＥＹ＿サービス契約番号
		setTemplate(template, EKK0081A010CBSMsg.KEY_SVC_KEI_NO, inMap, prefix, "svc_kei_no");

		// サービス契約一意照会.ＫＥＹ＿予約適用年月日
		String gyomuOpDate = JCCBPCommon.getOpeDate(null);
		template.set(EKK0081A010CBSMsg.KEY_RSV_APLY_YMD, gyomuOpDate);

		return template;
	}
	
	/**
	 * サービス契約一意照会の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputMap
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0081A010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> outputMap)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		if (template != null)
		{
			templateArray = template.getCAANMsgList(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);
			CAANMsg childTemplate = templateArray[0];
			
			// サービス契約ステータス ← サービス契約一意照会.サービス契約ステータス
			setDataMap(outputMap, "", EKK0081A010CBSMsg1List.SVC_KEI_STAT, childTemplate, EKK0081A010CBSMsg1List.SVC_KEI_STAT);
			
			// サービス課金開始年月日 ← サービス契約一意照会.サービス課金開始年月日
			setDataMap(outputMap, "", EKK0081A010CBSMsg1List.SVC_CHRG_STAYMD, childTemplate, EKK0081A010CBSMsg1List.SVC_CHRG_STAYMD);
		}

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

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

		return param;
	}
	
	/**
	 * サービス契約一意照会の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputMap
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0081A0102(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> outputMap)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		if (template != null)
		{
			templateArray = template.getCAANMsgList(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);
			CAANMsg childTemplate = templateArray[0];
			
			// SYSID ← サービス契約一意照会.SYSID
			setDataMap(outputMap, "", EKK0081A010CBSMsg1List.SYSID, childTemplate, EKK0081A010CBSMsg1List.SYSID);

		}

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

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

		return param;
	}
	
	/**
	 * サービス契約一意照会のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0081A010(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);
		
		HashMap inMap = (HashMap)param.getData(fixedText);
		
		// サービス契約一意照会.ＫＥＹ＿サービス契約番号 → サービス契約番号のエラー情報返却
		setErrInfo(inMap, "", EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR, template, EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR);
		
		// サービス契約一意照会.ＫＥＹ＿予約適用年月日 → 予約適用年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0081A010CBSMsg.KEY_RSV_APLY_YMD_ERR, template, EKK0081A010CBSMsg.KEY_RSV_APLY_YMD_ERR);
		
		return param;
	}
	
	/**
	 * 割引サービス契約キャンセルの上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param outputList
	 * @param outputMap
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0451C070(IRequestParameterReadWrite param, String fixedText, ArrayList<HashMap<String, Object>> ekk0451b010OutputList, HashMap<String, Object> ekk0451a010OutputMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0451C070CBSMsg.class.getName());
		String prefix = "";
		
		// テンプレートID
		template.set(EKK0451C070CBSMsg.TEMPLATEID, "EKK0451C070");
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		
		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// 割引サービス契約キャンセル.機能コード
		setTemplate(template, EKK0451C070CBSMsg.FUNC_CODE, inMap, prefix, "func_code");
		
		// 割引サービス契約キャンセル.申込明細番号
		setTemplate(template, EKK0451C070CBSMsg.MSKM_DTL_NO, inMap, prefix, "mskm_dtl_no");
		
		// 割引サービス契約キャンセル.異動区分
		setTemplate(template, EKK0451C070CBSMsg.IDO_DIV, inMap, prefix, "ido_div");
		
		// 割引サービス契約キャンセル.サービスキャンセル理由コード
		template.set(EKK0451C070CBSMsg.SVC_CANCEL_RSN_CD, JKKStrConst.CD01390_CL_MOUSHIDE);
		
		// 割引サービス契約キャンセル.割引解約キャンセル契機コード
		template.set(EKK0451C070CBSMsg.WRIB_DSL_CNCL_OPTY_CD, JKKStrConst.CD00874_MAN_SET);
		
		
		HashMap<String, Object> childMap = (HashMap<String, Object>) ekk0451b010OutputList.get(0);
		
		// 割引サービス契約キャンセル.割引サービス契約番号
		setTemplate(template, EKK0451C070CBSMsg.WRIB_SVC_KEI_NO, childMap, prefix, EKK0451B010CBSMsg1List.WRIB_SVC_KEI_NO);
		
		// 割引サービス契約キャンセル.最終更新年月日時分秒
		setTemplate(template, EKK0451C070CBSMsg.UPD_DTM_BF, ekk0451a010OutputMap, prefix, EKK0451A010CBSMsg1List.LAST_UPD_DTM);
		
		return template;
	}
	
	/**
	 * 割引サービス契約キャンセルの下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputMap
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0451C070(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> outputMap)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		if (template != null)
		{
			// 世代登録年月日時分秒 ← 割引サービス契約キャンセル.世代登録年月日時分秒
			setDataMap(outputMap, "", EKK0451C070CBSMsg.GENE_ADD_DTM, template, EKK0451C070CBSMsg.GENE_ADD_DTM);

			// 割引サービス契約ステータス ← 割引サービス契約キャンセル.割引サービス契約ステータス
			setDataMap(outputMap, "", EKK0451C070CBSMsg.WRIB_SVC_KEI_STAT, template, EKK0451C070CBSMsg.WRIB_SVC_KEI_STAT);

			// 予約適用年月日 ← 割引サービス契約キャンセル.予約適用年月日
			setDataMap(outputMap, "", EKK0451C070CBSMsg.RSV_APLY_YMD, template, EKK0451C070CBSMsg.RSV_APLY_YMD);

			// 予約適用コード ← 割引サービス契約キャンセル.予約適用コード
			setDataMap(outputMap, "", EKK0451C070CBSMsg.RSV_APLY_CD, template, EKK0451C070CBSMsg.RSV_APLY_CD);

			// サービスキャンセル年月日 ← 割引サービス契約キャンセル.サービスキャンセル年月日
			setDataMap(outputMap, "", EKK0451C070CBSMsg.SVC_CANCEL_YMD, template, EKK0451C070CBSMsg.SVC_CANCEL_YMD);

			// サービスキャンセル取消年月日 ← 割引サービス契約キャンセル.サービスキャンセル取消年月日
			setDataMap(outputMap, "", EKK0451C070CBSMsg.SVC_CANCEL_CL_YMD, template, EKK0451C070CBSMsg.SVC_CANCEL_CL_YMD);

			// 登録年月日時分秒 ← 割引サービス契約キャンセル.登録年月日時分秒
			setDataMap(outputMap, "", EKK0451C070CBSMsg.ADD_DTM, template, EKK0451C070CBSMsg.ADD_DTM);

			// 登録オペレータアカウント ← 割引サービス契約キャンセル.登録オペレータアカウント
			setDataMap(outputMap, "", EKK0451C070CBSMsg.ADD_OPEACNT, template, EKK0451C070CBSMsg.ADD_OPEACNT);

			// 更新年月日時分秒 ← 割引サービス契約キャンセル.更新年月日時分秒
			setDataMap(outputMap, "", EKK0451C070CBSMsg.UPD_DTM, template, EKK0451C070CBSMsg.UPD_DTM);

			// 更新オペレータアカウント ← 割引サービス契約キャンセル.更新オペレータアカウント
			setDataMap(outputMap, "", EKK0451C070CBSMsg.UPD_OPEACNT, template, EKK0451C070CBSMsg.UPD_OPEACNT);

			// 無効フラグ ← 割引サービス契約キャンセル.無効フラグ
			setDataMap(outputMap, "", EKK0451C070CBSMsg.MK_FLG, template, EKK0451C070CBSMsg.MK_FLG);
		}

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

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

		return param;
	}
	
	/**
	 * 割引サービス契約キャンセルのエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0451C070(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		// 割引サービス契約キャンセル.申込明細番号 → 申込明細番号のエラー情報返却
		setErrInfo(inMap, "", EKK0451C070CBSMsg.MSKM_DTL_NO_ERR, template, EKK0451C070CBSMsg.MSKM_DTL_NO_ERR);
		
		// 割引サービス契約キャンセル.異動区分 → 異動区分のエラー情報返却
		setErrInfo(inMap, "", EKK0451C070CBSMsg.IDO_DIV_ERR, template, EKK0451C070CBSMsg.IDO_DIV_ERR);
		
		// 割引サービス契約キャンセル.サービスキャンセル理由コード → サービスキャンセル理由コードのエラー情報返却
		setErrInfo(inMap, "", EKK0451C070CBSMsg.SVC_CANCEL_RSN_CD_ERR, template, EKK0451C070CBSMsg.SVC_CANCEL_RSN_CD_ERR);
		
		// 割引サービス契約キャンセル.割引解約キャンセル契機コード → 割引解約キャンセル契機コードのエラー情報返却
		setErrInfo(inMap, "", EKK0451C070CBSMsg.WRIB_DSL_CNCL_OPTY_CD_ERR, template, EKK0451C070CBSMsg.WRIB_DSL_CNCL_OPTY_CD_ERR);
		
		// 割引サービス契約キャンセル.割引サービス契約番号 → 割引サービス契約番号のエラー情報返却
		setErrInfo(inMap, "", EKK0451C070CBSMsg.WRIB_SVC_KEI_NO_ERR, template, EKK0451C070CBSMsg.WRIB_SVC_KEI_NO_ERR);
		
		// 割引サービス契約キャンセル.最終更新年月日時分秒 → 最終更新年月日時分秒のエラー情報返却
		setErrInfo(inMap, "", EKK0451C070CBSMsg.UPD_DTM_BF_ERR, template, EKK0451C070CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 * 割引サービス契約解約の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param outputList
	 * @param outputMap
	 * @return CAANMsg
	 * @throws Throwable 
	 */
	@SuppressWarnings("unchecked")
// IT1-2017-0000080 MOD START
//	private CAANMsg editInEKK0451C020(IRequestParameterReadWrite param, String fixedText, ArrayList<HashMap<String, Object>> ekk0451b010OutputList, HashMap<String, Object> ekk0451a010OutputMap, HashMap<String, Object> ekk0081a010OutputMap) throws RequestParameterException
	private CAANMsg editInEKK0451C020(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, ArrayList<HashMap<String, Object>> ekk0451b010OutputList, HashMap<String, Object> ekk0451a010OutputMap, HashMap<String, Object> ekk0081a010OutputMap) throws Throwable
// IT1-2017-0000080 MOD END
	{
		CAANMsg template = new CAANMsg(EKK0451C020CBSMsg.class.getName());
		String prefix = "";
		
		// テンプレートID
		template.set(EKK0451C020CBSMsg.TEMPLATEID, "EKK0451C020");
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// 割引サービス契約解約.機能コード
		setTemplate(template, EKK0451C020CBSMsg.FUNC_CODE, inMap, prefix, "func_code");
		
		// 割引サービス契約解約.申込明細番号
		setTemplate(template, EKK0451C020CBSMsg.MSKM_DTL_NO, inMap, prefix, "mskm_dtl_no");
		
		// 割引サービス契約解約.異動区分
		setTemplate(template, EKK0451C020CBSMsg.IDO_DIV, inMap, prefix, "ido_div");
		
		// 運用年月日
		String gyomuOpDate = JCCBPCommon.getOpeDate(null);
		
		// 運用年月日-１日
		String gyomuOpDateZen = JPCDateUtil.addDay(gyomuOpDate, -1);
		
		// サービス終了年月日
		template.set(EKK0451C020CBSMsg.SVC_ENDYMD, gyomuOpDate);
		
		// サービス課金終了年月日
		template.set(EKK0451C020CBSMsg.SVC_CHRG_ENDYMD, gyomuOpDateZen);
		
		// サービス解約年月日
		template.set(EKK0451C020CBSMsg.SVC_DSL_YMD, gyomuOpDate);
		
		// 割引サービス契約解約.サービス解約理由コード
		template.set(EKK0451C020CBSMsg.SVC_DLRE_CD, JKKStrConst.CD00879_TUJYO_DSL);
		
		// 割引サービス契約解約.割引解約キャンセル契機コード
		template.set(EKK0451C020CBSMsg.WRIB_DSL_CNCL_OPTY_CD, JKKStrConst.CD00874_MAN_SET);
		
		
		HashMap<String, Object> childMap = (HashMap<String, Object>) ekk0451b010OutputList.get(0);
		
		// 割引サービス契約解約.割引サービス契約番号
		setTemplate(template, EKK0451C020CBSMsg.WRIB_SVC_KEI_NO, childMap, prefix, EKK0451B010CBSMsg1List.WRIB_SVC_KEI_NO);
		
		// 割引サービス契約解約.最終更新年月日時分秒
		setTemplate(template, EKK0451C020CBSMsg.UPD_DTM_BF, ekk0451a010OutputMap, prefix, EKK0451A010CBSMsg1List.LAST_UPD_DTM);
		
		// サービス課金開始年月日
		String svcChrgStaymd = "";
// IT1-2017-0000080 MOD START
//		// 運用年月日 ≦ サービス契約.サービス課金開始年月日の場合
//		if (gyomuOpDate.compareTo((String)ekk0081a010OutputMap.get("svc_chrg_staymd")) <= 0)
//		{
//			// 運用年月日を設定
//			svcChrgStaymd = gyomuOpDate;
//		}
//		// サービス契約.サービス課金開始年月日 < 運用年月日 < 割引サービス契約.サービス課金開始年月日の場合
//		else if (((String)ekk0081a010OutputMap.get("svc_chrg_staymd")).compareTo(gyomuOpDate) < 0  && gyomuOpDate.compareTo((String)ekk0451a010OutputMap.get("svc_chrg_staymd")) < 0)
//		{
//			// 割引サービス契約.サービス開始年月日を設定
//			svcChrgStaymd = (String)ekk0451a010OutputMap.get("svc_sta_ymd");
//		}
//		// 割引サービス契約.サービス課金開始年月日 ≦ 運用年月日の場合
//		else if (((String)ekk0451a010OutputMap.get("svc_chrg_staymd")).compareTo(gyomuOpDate) <= 0)
//		{
//			// 割引サービス契約.サービス課金開始年月日を設定
//			svcChrgStaymd = (String)ekk0451a010OutputMap.get("svc_chrg_staymd");
//		}
		
		// 課金開始日を特定する
		JKKWribSvcKeiOperateCC wribCC = new JKKWribSvcKeiOperateCC();
		svcChrgStaymd = wribCC.calcSvcChrgStartymd((String)childMap.get(EKK0451B010CBSMsg1List.WRIB_SVC_KEI_NO), gyomuOpDate, "1", handle, param);
// IT1-2017-0000080 MOD END
		
		template.set(EKK0451C020CBSMsg.SVC_CHRG_STAYMD, svcChrgStaymd);

// IT2-2017-0000012 ADD START
		// プラン課金開始年月日
		template.set(EKK0451C020CBSMsg.PLAN_CHRG_STAYMD, svcChrgStaymd);

// IT1-2017-0000086 MOD START
//		// サービス開始年月日
//		template.set(EKK0451C020CBSMsg.SVC_STA_YMD, svcChrgStaymd);
//		// プラン開始年月日
//		template.set(EKK0451C020CBSMsg.PLAN_STAYMD, svcChrgStaymd);
//// IT2-2017-0000012 ADD END
		
		// 更新前のサービス課金開始日と特定した課金開始日が変更されている場合、転記を行う
		String planChrgStaymdBf = (String)ekk0451a010OutputMap.get(EKK0451A010CBSMsg1List.PLAN_CHRG_STAYMD);
		if(!svcChrgStaymd.equals(planChrgStaymdBf))
		{
			// サービス開始年月日
			template.set(EKK0451C020CBSMsg.SVC_STA_YMD, svcChrgStaymd);
			// プラン開始年月日
			template.set(EKK0451C020CBSMsg.PLAN_STAYMD, svcChrgStaymd);
		}
// IT1-2017-0000086 MOD END

		// サービス課金終了年月日算出フラグ
		template.set(EKK0451C020CBSMsg.SVC_CHRG_ENDYMD_FLG, JKKStrConst.KK0451_SVC_CHRG_ENDYMD_FLG_1);
		
		return template;
	}
	
	/**
	 * 割引サービス契約解約の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputMap
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0451C020(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> outputMap)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		if (template != null)
		{
			// 世代登録年月日時分秒 ← 割引サービス契約解約.世代登録年月日時分秒
			setDataMap(outputMap, "", EKK0451C020CBSMsg.GENE_ADD_DTM, template, EKK0451C020CBSMsg.GENE_ADD_DTM);

			// 割引サービス契約ステータス ← 割引サービス契約解約.割引サービス契約ステータス
			setDataMap(outputMap, "", EKK0451C020CBSMsg.WRIB_SVC_KEI_STAT, template, EKK0451C020CBSMsg.WRIB_SVC_KEI_STAT);

			// 予約適用コード ← 割引サービス契約解約.予約適用コード
			setDataMap(outputMap, "", EKK0451C020CBSMsg.RSV_APLY_CD, template, EKK0451C020CBSMsg.RSV_APLY_CD);

			// サービス解約手続完了フラグ ← 割引サービス契約解約.サービス解約手続完了フラグ
			setDataMap(outputMap, "", EKK0451C020CBSMsg.SVC_DSL_TTDKI_FIN_FLG, template, EKK0451C020CBSMsg.SVC_DSL_TTDKI_FIN_FLG);

			// 回復年月日 ← 割引サービス契約解約.回復年月日
			setDataMap(outputMap, "", EKK0451C020CBSMsg.KAIHK_YMD, template, EKK0451C020CBSMsg.KAIHK_YMD);

			// サービス解約取消年月日 ← 割引サービス契約解約.サービス解約取消年月日
			setDataMap(outputMap, "", EKK0451C020CBSMsg.SVC_DSL_CL_YMD, template, EKK0451C020CBSMsg.SVC_DSL_CL_YMD);

			// 登録年月日時分秒 ← 割引サービス契約解約.登録年月日時分秒
			setDataMap(outputMap, "", EKK0451C020CBSMsg.ADD_DTM, template, EKK0451C020CBSMsg.ADD_DTM);

			// 登録オペレータアカウント ← 割引サービス契約解約.登録オペレータアカウント
			setDataMap(outputMap, "", EKK0451C020CBSMsg.ADD_OPEACNT, template, EKK0451C020CBSMsg.ADD_OPEACNT);

			// 更新年月日時分秒 ← 割引サービス契約解約.更新年月日時分秒
			setDataMap(outputMap, "", EKK0451C020CBSMsg.UPD_DTM, template, EKK0451C020CBSMsg.UPD_DTM);

			// 更新オペレータアカウント ← 割引サービス契約解約.更新オペレータアカウント
			setDataMap(outputMap, "", EKK0451C020CBSMsg.UPD_OPEACNT, template, EKK0451C020CBSMsg.UPD_OPEACNT);

			// 無効フラグ ← 割引サービス契約解約.無効フラグ
			setDataMap(outputMap, "", EKK0451C020CBSMsg.MK_FLG, template, EKK0451C020CBSMsg.MK_FLG);

			// サービス課金終了年月日（出力） ← 割引サービス契約解約.サービス課金終了年月日（出力）
			setDataMap(outputMap, "", EKK0451C020CBSMsg.SVC_CHRG_ENDYMD_O, template, EKK0451C020CBSMsg.SVC_CHRG_ENDYMD_O);
		}

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

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

		return param;
	}
	
	/**
	 * 割引サービス契約解約のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0451C020(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		// 割引サービス契約解約.割引サービス契約番号 → 割引サービス契約番号のエラー情報返却
		setErrInfo(inMap, "", EKK0451C020CBSMsg.WRIB_SVC_KEI_NO_ERR, template, EKK0451C020CBSMsg.WRIB_SVC_KEI_NO_ERR);

		// 割引サービス契約解約.申込明細番号 → 申込明細番号のエラー情報返却
		setErrInfo(inMap, "", EKK0451C020CBSMsg.MSKM_DTL_NO_ERR, template, EKK0451C020CBSMsg.MSKM_DTL_NO_ERR);

		// 割引サービス契約解約.サービス終了年月日 → サービス終了年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0451C020CBSMsg.SVC_ENDYMD_ERR, template, EKK0451C020CBSMsg.SVC_ENDYMD_ERR);

		// 割引サービス契約解約.サービス課金終了年月日 → サービス課金終了年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0451C020CBSMsg.SVC_CHRG_ENDYMD_ERR, template, EKK0451C020CBSMsg.SVC_CHRG_ENDYMD_ERR);

		// 割引サービス契約解約.サービス解約年月日 → サービス解約年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0451C020CBSMsg.SVC_DSL_YMD_ERR, template, EKK0451C020CBSMsg.SVC_DSL_YMD_ERR);

		// 割引サービス契約解約.サービス解約理由コード → サービス解約理由コードのエラー情報返却
		setErrInfo(inMap, "", EKK0451C020CBSMsg.SVC_DLRE_CD_ERR, template, EKK0451C020CBSMsg.SVC_DLRE_CD_ERR);

		// 割引サービス契約解約.異動区分 → 異動区分のエラー情報返却
		setErrInfo(inMap, "", EKK0451C020CBSMsg.IDO_DIV_ERR, template, EKK0451C020CBSMsg.IDO_DIV_ERR);

		// 割引サービス契約解約.割引解約キャンセル契機コード → 割引解約キャンセル契機コードのエラー情報返却
		setErrInfo(inMap, "", EKK0451C020CBSMsg.WRIB_DSL_CNCL_OPTY_CD_ERR, template, EKK0451C020CBSMsg.WRIB_DSL_CNCL_OPTY_CD_ERR);

		// 割引サービス契約解約.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)のエラー情報返却
		setErrInfo(inMap, "", EKK0451C020CBSMsg.UPD_DTM_BF_ERR, template, EKK0451C020CBSMsg.UPD_DTM_BF_ERR);

		// 割引サービス契約解約.サービス課金開始年月日 → サービス課金開始年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0451C020CBSMsg.SVC_CHRG_STAYMD_ERR, template, EKK0451C020CBSMsg.SVC_CHRG_STAYMD_ERR);

		// 割引サービス契約解約.プラン開始年月日 → プラン開始年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0451C020CBSMsg.PLAN_STAYMD_ERR, template, EKK0451C020CBSMsg.PLAN_STAYMD_ERR);

		// 割引サービス契約解約.プラン課金開始年月日 → プラン課金開始年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0451C020CBSMsg.PLAN_CHRG_STAYMD_ERR, template, EKK0451C020CBSMsg.PLAN_CHRG_STAYMD_ERR);

		// 割引サービス契約解約.サービス開始年月日 → サービス開始年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0451C020CBSMsg.SVC_STA_YMD_ERR, template, EKK0451C020CBSMsg.SVC_STA_YMD_ERR);
		
		return param;
	}
	
	/**
	 * 割引サービス契約解約確定の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param outputList
	 * @param outputMap
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0451C030(IRequestParameterReadWrite param, String fixedText, ArrayList<HashMap<String, Object>> ekk0451b010OutputList, HashMap<String, Object> ekk0451c020OutputMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0451C030CBSMsg.class.getName());
		String prefix = "";
		
		// テンプレートID
		template.set(EKK0451C030CBSMsg.TEMPLATEID, "EKK0451C030");
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// 割引サービス契約解約確定.機能コード
		setTemplate(template, EKK0451C030CBSMsg.FUNC_CODE, inMap, prefix, "func_code");
		
		// 運用年月日
		String gyomuOpDate = JCCBPCommon.getOpeDate(null);
		
		// サービス終了年月日
		template.set(EKK0451C030CBSMsg.SVC_ENDYMD, gyomuOpDate);
		
		// サービス解約年月日
		template.set(EKK0451C030CBSMsg.SVC_DSL_YMD, gyomuOpDate);
		
		// 割引サービス契約解約確定.サービス解約理由コード
		template.set(EKK0451C030CBSMsg.SVC_DLRE_CD, JKKStrConst.CD00879_TUJYO_DSL);
		
		
		HashMap<String, Object> childMap = (HashMap<String, Object>) ekk0451b010OutputList.get(0);
		
		// 割引サービス契約解約確定.割引サービス契約番号
		setTemplate(template, EKK0451C030CBSMsg.WRIB_SVC_KEI_NO, childMap, prefix, EKK0451B010CBSMsg1List.WRIB_SVC_KEI_NO);
		
		
		// 割引サービス契約解約確定.世代登録年月日時分秒
		setTemplate(template, EKK0451C030CBSMsg.GENE_ADD_DTM, ekk0451c020OutputMap, prefix, EKK0451C020CBSMsg.GENE_ADD_DTM);
		
		// 割引サービス契約解約確定.サービス課金終了年月日（出力）
		setTemplate(template, EKK0451C030CBSMsg.SVC_CHRG_ENDYMD, ekk0451c020OutputMap, prefix, EKK0451C020CBSMsg.SVC_CHRG_ENDYMD_O);
		
		// 割引サービス契約解約確定.更新年月日時分秒
		setTemplate(template, EKK0451C030CBSMsg.UPD_DTM_BF, ekk0451c020OutputMap, prefix, EKK0451C020CBSMsg.UPD_DTM);
		
		return template;
	}
	
	/**
	 * 割引サービス契約解約確定の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputMap
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0451C030(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> outputMap)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		if (template != null)
		{
			// 予約適用コード ← 割引サービス契約解約確定.予約適用コード
			setDataMap(outputMap, "", EKK0451C030CBSMsg.RSV_APLY_CD, template, EKK0451C030CBSMsg.RSV_APLY_CD);

			// 更新年月日時分秒 ← 割引サービス契約解約確定.更新年月日時分秒
			setDataMap(outputMap, "", EKK0451C030CBSMsg.UPD_DTM, template, EKK0451C030CBSMsg.UPD_DTM);

			// 更新オペレータアカウント ← 割引サービス契約解約確定.更新オペレータアカウント
			setDataMap(outputMap, "", EKK0451C030CBSMsg.UPD_OPEACNT, template, EKK0451C030CBSMsg.UPD_OPEACNT);

			// 異動区分 ← 割引サービス契約解約確定.異動区分
			setDataMap(outputMap, "", EKK0451C030CBSMsg.IDO_DIV, template, EKK0451C030CBSMsg.IDO_DIV);

			// 申込明細番号 ← 割引サービス契約解約確定.申込明細番号
			setDataMap(outputMap, "", EKK0451C030CBSMsg.MSKM_DTL_NO, template, EKK0451C030CBSMsg.MSKM_DTL_NO);
		}

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

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

		return param;
	}
	
	/**
	 * 割引サービス契約解約確定のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0451C030(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		// 割引サービス契約解約確定.割引サービス契約番号 → 割引サービス契約番号のエラー情報返却
		setErrInfo(inMap, "", EKK0451C030CBSMsg.WRIB_SVC_KEI_NO_ERR, template, EKK0451C030CBSMsg.WRIB_SVC_KEI_NO_ERR);

		// 割引サービス契約解約確定.世代登録年月日時分秒 → 世代登録年月日時分秒のエラー情報返却
		setErrInfo(inMap, "", EKK0451C030CBSMsg.GENE_ADD_DTM_ERR, template, EKK0451C030CBSMsg.GENE_ADD_DTM_ERR);

		// 割引サービス契約解約確定.サービス終了年月日 → サービス終了年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0451C030CBSMsg.SVC_ENDYMD_ERR, template, EKK0451C030CBSMsg.SVC_ENDYMD_ERR);

		// 割引サービス契約解約確定.サービス課金終了年月日 → サービス課金終了年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0451C030CBSMsg.SVC_CHRG_ENDYMD_ERR, template, EKK0451C030CBSMsg.SVC_CHRG_ENDYMD_ERR);

		// 割引サービス契約解約確定.サービス解約年月日 → サービス解約年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0451C030CBSMsg.SVC_DSL_YMD_ERR, template, EKK0451C030CBSMsg.SVC_DSL_YMD_ERR);

		// 割引サービス契約解約確定.サービス解約理由コード → サービス解約理由コードのエラー情報返却
		setErrInfo(inMap, "", EKK0451C030CBSMsg.SVC_DLRE_CD_ERR, template, EKK0451C030CBSMsg.SVC_DLRE_CD_ERR);

		// 割引サービス契約解約確定.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)のエラー情報返却
		setErrInfo(inMap, "", EKK0451C030CBSMsg.UPD_DTM_BF_ERR, template, EKK0451C030CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 * 進捗一覧照会（異動区分）の上りマップ
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK1091B002(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK1091B002CBSMsg.class.getName());

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

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

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

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

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

		// 進捗一覧照会（異動区分）.ＫＥＹ＿サービス契約番号
		setTemplate(template, EKK1091B002CBSMsg.KEY_SVC_KEI_NO, inMap, "", "svc_kei_no");
		
		// 進捗一覧照会（異動区分）.ＫＥＹ＿異動区分
		setTemplate(template, EKK1091B002CBSMsg.KEY_IDO_DIV, inMap, "", "ido_div");
		
		// 進捗一覧照会（異動区分）.ＫＥＹ＿ソート項目
		template.set(EKK1091B002CBSMsg.KEY_SORT_ITEM_NO, SORT_ITEM_NO_IDONEN);

		return template;
	}
	
	/**
	 * 進捗一覧照会（異動区分）の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputList
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK1091B002(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, ArrayList<HashMap<String, Object>> outputList) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		templateArray = template.getCAANMsgList(EKK1091B002CBSMsg.EKK1091B002CBSMSG1LIST);
		
		if (templateArray != null)
		{
			
			for (int i = 0; i < templateArray.length; i++)
			{
				HashMap<String, Object> childMap = new HashMap<String, Object>();
				
				// 異動年月日時分秒 ← 進捗一覧照会（異動区分）.異動年月日時分秒
				setDataMap(childMap, "", EKK1091B002CBSMsg1List.IDO_DTM, templateArray[i], EKK1091B002CBSMsg1List.IDO_DTM);
				
				// リストにマップを格納する
				outputList.add(childMap);
			}
		}
		
		// エラー情報の設定
		editErrInfoEKK1091B002(param, template, (Integer)returnCode, fixedText);
		
		// エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	
	/**
	 * 進捗一覧照会（異動区分）のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK1091B002(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK1091B002CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		// 進捗一覧照会（異動区分）.ＫＥＹ＿サービス契約番号 → サービス契約番号のエラー情報返却
		setErrInfo(inMap, "", EKK1091B002CBSMsg.KEY_SVC_KEI_NO_ERR, template, EKK1091B002CBSMsg.KEY_SVC_KEI_NO_ERR);
		
		// 進捗一覧照会（異動区分）.ＫＥＹ＿異動区分 → 異動区分のエラー情報返却
		setErrInfo(inMap, "", EKK1091B002CBSMsg.KEY_IDO_DIV_ERR, template, EKK1091B002CBSMsg.KEY_IDO_DIV_ERR);
		
		// 進捗一覧照会（異動区分）.ＫＥＹ＿ソート項目 → ソート項目のエラー情報返却
		setErrInfo(inMap, "", EKK1091B002CBSMsg.KEY_SORT_ITEM_NO_ERR, template, EKK1091B002CBSMsg.KEY_SORT_ITEM_NO_ERR);
		
		return param;
	}
	
	/**
	 * 進捗登録の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param outputList
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK1091D010(IRequestParameterReadWrite param, String fixedText, ArrayList<HashMap<String, Object>> outputList) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK1091D010CBSMsg.class.getName());
		String prefix = "";
		
		// テンプレートID
		template.set(EKK1091D010CBSMsg.TEMPLATEID, "EKK1091D010");
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		
		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// 進捗登録.機能コード
		setTemplate(template, EKK1091D010CBSMsg.FUNC_CODE, inMap, prefix, "func_code");
		
		// 申込明細番号
		setTemplate(template, EKK1091D010CBSMsg.MSKM_DTL_NO, inMap, prefix, "mskm_dtl_no");
		
		// サービス契約番号
		setTemplate(template, EKK1091D010CBSMsg.SVC_KEI_NO, inMap, prefix, "svc_kei_no");
		
		// 異動区分
		setTemplate(template, EKK1091D010CBSMsg.IDO_DIV, inMap, prefix, "ido_div");
		
		// 異動理由明細
		ArrayList<HashMap<String, Object>> ekk1091d010cbsmsg1List = (ArrayList<HashMap<String, Object>>)inMap.get("EKK1091D010CBSMsg1List");
		
		CAANMsg[] templateArray = template.getCAANMsgList(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST);
		
		if (templateArray == null)
		{
			templateArray = new CAANMsg[ekk1091d010cbsmsg1List.size()];
		}
		
		for (int i = 0; i < ekk1091d010cbsmsg1List.size(); i++)
		{
			HashMap<String, Object> idoCreateMap = (HashMap)ekk1091d010cbsmsg1List.get(i);
			
			CAANMsg childTemplate = templateArray[i];
			
			if (childTemplate == null)
			{
				childTemplate = new CAANMsg(EKK1091D010CBSMsg1List.class.getName());
			}
			
			// 異動理由コード
			setTemplate(childTemplate, EKK1091D010CBSMsg1List.IDO_RSN_CD, idoCreateMap, prefix, "ido_rsn_cd");
			
			// 異動理由メモ
			setTemplate(childTemplate, EKK1091D010CBSMsg1List.IDO_RSN_MEMO, idoCreateMap, prefix, "ido_rsn_memo");
			
			templateArray[i] = childTemplate;
		}
		
		template.set(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST, templateArray);
		
		// 進捗登録.進捗ステータス
		template.set(EKK1091D010CBSMsg.PRG_STAT, JKKStrConst.CD00647_FP_TORIKESHI_KAN);
		
		HashMap<String, Object> childMap = null;
		if(0 < outputList.size())
		{
			childMap = (HashMap<String, Object>) outputList.get(0);
		}
		
		// 進捗登録.最終更新年月日時分秒
		String idoDtm = "";
		if (!JKKCommonUtil.isNull(childMap) && !JKKCommonUtil.isNull((String)childMap.get("ido_dtm")))
		{
			// 異動年月日時分秒を設定
			idoDtm = (String)childMap.get("ido_dtm");
		}
		else
		{
			// システム年月日時分秒を設定
			idoDtm = JCCBPCommon.getSysDateTimeStamp();
		}
		template.set(EKK1091D010CBSMsg.IDO_DTM, idoDtm);
		
		return template;
	}
	
	/**
	 * 進捗登録の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputList
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK1091D010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, ArrayList<HashMap<String, Object>> outputList)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		if (template != null)
		{
			HashMap<String, Object> childMap = new HashMap<String, Object>();

			// 進捗番号 ← 進捗登録.進捗番号
			setDataMap(childMap, "", EKK1091D010CBSMsg.PRG_NO, template, EKK1091D010CBSMsg.PRG_NO);

			// 進捗年月日時分秒 ← 進捗登録.進捗年月日時分秒
			setDataMap(childMap, "", EKK1091D010CBSMsg.PRG_DTM, template, EKK1091D010CBSMsg.PRG_DTM);

			// 登録年月日時分秒 ← 進捗登録.登録年月日時分秒
			setDataMap(childMap, "", EKK1091D010CBSMsg.ADD_DTM, template, EKK1091D010CBSMsg.ADD_DTM);

			// 登録オペレータアカウント ← 進捗登録.登録オペレータアカウント
			setDataMap(childMap, "", EKK1091D010CBSMsg.ADD_OPEACNT, template, EKK1091D010CBSMsg.ADD_OPEACNT);

			// 更新年月日時分秒 ← 進捗登録.更新年月日時分秒
			setDataMap(childMap, "", EKK1091D010CBSMsg.UPD_DTM, template, EKK1091D010CBSMsg.UPD_DTM);

			// 更新オペレータアカウント ← 進捗登録.更新オペレータアカウント
			setDataMap(childMap, "", EKK1091D010CBSMsg.UPD_OPEACNT, template, EKK1091D010CBSMsg.UPD_OPEACNT);

			// 無効フラグ ← 進捗登録.無効フラグ
			setDataMap(childMap, "", EKK1091D010CBSMsg.MK_FLG, template, EKK1091D010CBSMsg.MK_FLG);
			
			templateArray = template.getCAANMsgList(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST);

			if (templateArray != null)
			{
				ArrayList<HashMap<String, Object>> ekk1091d010cbsmsg1List = new ArrayList<HashMap<String, Object>>();
				
				for (int i = 0; i < templateArray.length; i++)
				{
					HashMap<String, Object> msgListMap = new HashMap<String, Object>();

					// 異動理由番号 ← 進捗登録.異動理由番号
					setDataMap(msgListMap, "", EKK1091D010CBSMsg1List.IDO_RSN_NO, templateArray[i], EKK1091D010CBSMsg1List.IDO_RSN_NO);
					
					// リストにマップを格納する
					ekk1091d010cbsmsg1List.add(childMap);
				}
				childMap.put(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST, ekk1091d010cbsmsg1List);
			}
			
			// リストにマップを格納する
			outputList.add(childMap);
		}
		
		// エラー情報の設定
		editErrInfoEKK1091D010(param, template, (Integer)returnCode, fixedText);

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

		return param;
	}
	
	/**
	 * 進捗登録のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK1091D010(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		// 進捗登録.申込明細番号 → 申込明細番号のエラー情報返却
		setErrInfo(inMap, "", EKK1091D010CBSMsg.MSKM_DTL_NO_ERR, template, EKK1091D010CBSMsg.MSKM_DTL_NO_ERR);

		// 進捗登録.サービス契約番号 → サービス契約番号のエラー情報返却
		setErrInfo(inMap, "", EKK1091D010CBSMsg.SVC_KEI_NO_ERR, template, EKK1091D010CBSMsg.SVC_KEI_NO_ERR);

		// 進捗登録.異動区分 → 異動区分のエラー情報返却
		setErrInfo(inMap, "", EKK1091D010CBSMsg.IDO_DIV_ERR, template, EKK1091D010CBSMsg.IDO_DIV_ERR);

		// 進捗登録.異動年月日時分秒 → 異動年月日時分秒のエラー情報返却
		setErrInfo(inMap, "", EKK1091D010CBSMsg.IDO_DTM_ERR, template, EKK1091D010CBSMsg.IDO_DTM_ERR);

		// 進捗登録.進捗ステータス → 進捗ステータスのエラー情報返却
		setErrInfo(inMap, "", EKK1091D010CBSMsg.PRG_STAT_ERR, template, EKK1091D010CBSMsg.PRG_STAT_ERR);
		
		
		CAANMsg[] templateArray = template.getCAANMsgList(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST);
		
		// 異動理由明細
		ArrayList<HashMap<String, Object>> ekk1091d010cbsmsg1List = (ArrayList<HashMap<String, Object>>)inMap.get("EKK1091D010CBSMsg1List");

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

				// 進捗登録.異動理由コード → 異動理由コードのエラー情報返却
				setErrInfo(childMap, "", EKK1091D010CBSMsg1List.IDO_RSN_CD_ERR, childTemplate, EKK1091D010CBSMsg1List.IDO_RSN_CD_ERR);

				// 進捗登録.異動理由メモ → 異動理由メモのエラー情報返却
				setErrInfo(childMap, "", EKK1091D010CBSMsg1List.IDO_RSN_MEMO_ERR, childTemplate, EKK1091D010CBSMsg1List.IDO_RSN_MEMO_ERR);
			}
		}
		
		return param;
	}
	
	/**
	 * 家族会員情報一覧照会の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param outputMap
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	private CAANMsg editInECK0011B003(IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> outputMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(ECK0011B003CBSMsg.class.getName());

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

		// 機能コード
		template.set(ECK0011B003CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_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);

		// 家族会員情報一覧照会.ＫＥＹ＿SYSID
		setTemplate(template, ECK0011B003CBSMsg.KEY_SYSID, outputMap, "", EKK0081A010CBSMsg1List.SYSID);

		return template;
	}
	
	/**
	 * 家族会員情報一覧照会の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputList
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetECK0011B003(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, ArrayList<String> outputList)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		templateArray = template.getCAANMsgList(ECK0011B003CBSMsg.ECK0011B003CBSMSG1LIST);
		
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				// SYSID
				outputList.add(templateArray[i].getString(ECK0011B003CBSMsg1List.SYSID));
			}
		}
		
		// エラー情報の設定
		editErrInfoECK0011B003(param, template, (Integer)returnCode, fixedText);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	/**
	 * 家族会員情報一覧照会のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoECK0011B003(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		// 家族会員情報一覧照会.ＫＥＹ＿SYSID → ＫＥＹ＿SYSIDのエラー情報返却
		setErrInfo(inMap, "", ECK0011B003CBSMsg.KEY_SYSID_ERR, template, ECK0011B003CBSMsg.KEY_SYSID_ERR);
		
		return param;
	}

// ANK-4346-00-00 DEL START
//	/**
//	 * コンテンツ契約一覧照会の上りマッピング処理を行います。
//	 * 
//	 * <br>
//	 * @param param
//	 * @param fixedText
//	 * @param inputList
//	 * @return CAANMsg
//	 * @throws RequestParameterException
//	 */
//	protected CAANMsg editInECN0021B001(IRequestParameterReadWrite param, String fixedText, ArrayList<String> inputList) throws RequestParameterException
//	{
//		CAANMsg template = new CAANMsg(ECN0021B001CBSMsg.class.getName());
//
//		// テンプレートID
//		template.set(ECN0021B001CBSMsg.TEMPLATEID, "ECN0021B001");
//
//		// 機能コード
//		template.set(ECN0021B001CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_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);
//
//		// コンテンツ契約一覧照会.ＫＥＹ＿SYSID
//		// リスト内のSYSIDを'(シングルコーテーション)付きカンマで結合
//		StringBuilder keySysid = new StringBuilder();
//		for (int i = 0; i < inputList.size(); i++)
//		{
//			keySysid.append(STR_HALF_SINGLE_QUOTATION);
//			keySysid.append(inputList.get(i));
//			keySysid.append(STR_HALF_SINGLE_QUOTATION);
//			keySysid.append(STR_HALF_COMMA);
//		}
//		// SYSID（末尾のカンマを除去）
//		keySysid.delete(keySysid.length() - STR_HALF_COMMA.length(), keySysid.length());
//		
//		// 全てのSYSIDを'(シングルコーテーション)付きカンマ区切りで設定
//		template.set(ECN0021B001CBSMsg.KEY_SYSID, keySysid.toString());
//		
//		// 運用年月日
//		String gyomuOpDate = JCCBPCommon.getOpeDate(null);
//		
//		// コンテンツ契約一覧照会.ＫＥＹ＿予約適用年月日
//		template.set(ECN0021B001CBSMsg.KEY_RSV_APLY_YMD, gyomuOpDate);
//		
//		// システム年月日時分秒
//		String gyomuOpDateTimeStamp = JCCBPCommon.getOpeDateTimeStamp(null);
//
//		// コンテンツ契約一覧照会.ＫＥＹ＿システム年月日時分秒
//		template.set(ECN0021B001CBSMsg.KEY_SYS_DTM, gyomuOpDateTimeStamp);
//
//		return template;
//	}
//	
//	/**
//	 * コンテンツ契約一覧照会の下りマッピング処理
//	 * <br>
//	 * @param msgList
//	 * @param param
//	 * @param fixedText
//	 * @param outputList
//	 * @return リクエストパラメータ
//	 * @throws Exception 
//	 */
//	@SuppressWarnings("unchecked")
//	protected IRequestParameterReadWrite editRetECN0021B001(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, ArrayList<HashMap<String, Object>> outputList)
//			throws Exception
//	{
//		// SCからの戻り値からCAANMsgを取得する。
//		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
//		CAANMsg template = templates[0];
//		CAANMsg[] templateArray = null;
//		
//		// リターンコード取得
//		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
//
//		templateArray = template.getCAANMsgList(ECN0021B001CBSMsg.ECN0021B001CBSMSGLIST);
//
//		if (templateArray != null)
//		{
//			for (int i = 0; i < templateArray.length; i++)
//			{
//				HashMap<String, Object> childMap = new HashMap<String, Object>();
//				
//				// コンテンツ契約番号 ← コンテンツ契約一覧照会.コンテンツ契約番号
//				setDataMap(childMap, "", ECN0021B001CBSMsgList.CONT_KEI_NO, templateArray[i], ECN0021B001CBSMsgList.CONT_KEI_NO);
//				
//				// コンテンツサービスコード ← コンテンツ契約一覧照会.コンテンツサービスコード
//				setDataMap(childMap, "", ECN0021B001CBSMsgList.CONT_SVC_CD, templateArray[i], ECN0021B001CBSMsgList.CONT_SVC_CD);
//				
//				// コンテンツ種別コード ← コンテンツ契約一覧照会.コンテンツ種別コード
//				setDataMap(childMap, "", ECN0021B001CBSMsgList.CONT_SBT_CD, templateArray[i], ECN0021B001CBSMsgList.CONT_SBT_CD);
//				
//				// コンテンツ契約終了年月日時分秒 ← コンテンツ契約一覧照会.コンテンツ契約終了年月日時分秒
//				setDataMap(childMap, "", ECN0021B001CBSMsgList.CONT_KEI_END_DTM, templateArray[i], ECN0021B001CBSMsgList.CONT_KEI_END_DTM);
//				
//				// リストにマップを格納する
//				outputList.add(childMap);
//			}
//		}
//		// エラー情報の設定
//		editErrInfoECN0021B001(param, template, (Integer)returnCode, fixedText);
//
//		//エラー情報のマップを取得
//		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
//		if (errList == null)
//		{
//			errList = new ArrayList<Object>();
//		}
//		// コントロールマップに設定
//		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
//
//		return param;
//	}
// ANK-4346-00-00 DEL END

// ANK-4346-00-00 ADD START
	/**
	 * コンテンツ契約一覧照会APIの処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param inputList
	 * @return CAANMsg
	 * @throws Throwable, Exception 
	 */
	@SuppressWarnings("unchecked")
	// #84105 MOD START
//	protected ArrayList<HashMap<String, Object>> execECNA0170001(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, ArrayList<String> inputList, String service_id) throws RequestParameterException
	protected ArrayList<HashMap<String, Object>> execECNA0170001(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, ArrayList<String> inputList, String service_id) throws Throwable, Exception
	// #84105 MOD END
	{
		CAANMsg template = new CAANMsg();
		ArrayList<HashMap<String, Object>> inContDetailList = new ArrayList<HashMap<String, Object>>();

		// #84105 DEL START
//		try
//		{
		// #84105 DEL END
			// コンテンツ契約一覧照会
			JCNContKeiListInfoCC contkeiInfo = new JCNContKeiListInfoCC();
			for (int i = 0; i < sysidList.size(); i++)
			{
				HashMap<String, Object> inParam = new HashMap();
				inParam.put("func_code",						"8");
				inParam.put("sysid",  							sysidList.get(i));						// SYSID
				inParam.put("cont_svc_cd", 						service_id);							// コンテンツサービスID
				inParam.put("cont_sbt_cd", 						DIVISION_1);							// コンテンツ区分
				inParam.put("return_contract",					INFO_YOHI_1);							// コンテンツ契約情報要否
				inParam.put("return_charge", 					INFO_YOHI_0);							// 直近課金情報要否
				inParam.put("return_contract_adds", 			INFO_YOHI_0);							// 契約付加情報要否
				param.setData("JCNContKeiListInfoCC", inParam);
				
				// コンテンツ契約一覧照会CC呼び出し
				IRequestParameterReadWrite eca0170001result = contkeiInfo.execute(handle, param, "JCNContKeiListInfoCC");
				HashMap<String, Object> ccMsg = (HashMap<String, Object>)eca0170001result.getData("JCNContKeiListInfoCC");
				// 処理結果判定
				if(ccMsg.get("return_code") != null && !"".equals(ccMsg.get("return_code")))
				{
					// #84105 ADD START
					HashMap inMap = (HashMap)param.getData(fixedText);
					// #84105 ADD END
					// エラーコードを取得
					Integer errCode = Integer.parseInt(ccMsg.get("return_code").toString());
					// 返却パラメータを設定
					// #84105 MOD START
//					inParam.put("return_code", ccMsg.get("return_code").toString());
					inMap.put("err_cd", ccMsg.get("return_code").toString());
					// #84105 MOD END
					
					// 処理結果が正常以外の場合
					if (errCode != 0)
					{
						// #84105 ADD START
						inMap.put("CCMG_ERR_FLG", "1");
						inMap.put("CCMG_ERR_MSG", "契約一覧情報取得");
						// #84105 ADD END
						// ステータスが単項目エラー以上であれば例外をスロー
						throw new CCException(SC_ERROR_STRING, new Exception());
					}
				}
				// リターンコードがない場合
				else
				{
					// #84105 ADD START
					HashMap inMap = (HashMap)param.getData(fixedText);
					// #84105 ADD END
					// 返却パラメータを設定し、例外をスロー
					// #84105 MOD START
//					inParam.put("return_code", "");
					inMap.put("err_cd", "");
					inMap.put("CCMG_ERR_FLG", "1");
					inMap.put("CCMG_ERR_MSG", "契約一覧情報取得");
					// #84105 MOD END
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
				
				// CC処理結果からコンテンツ契約リストを取得
				List<Map<String, Object>> inMap = (List<Map<String, Object>>)ccMsg.get("cont_kei_list");
				if (inMap != null)
				{
					String opeDate = JCCBPCommon.getOpeDate(null);
					// レスポンス設定
					for (Map<String, Object> contInfo : inMap)
					{
						HashMap<String, Object> outContList = new HashMap<String, Object>();
						
						if(JCNStrConst.CD01821_KEI.equals(contInfo.get("cont_kei_stat_cd")))
						{
							String endDate = JCNStringUtil.nullToBlank((String) contInfo.get("contract_end_date"));
							// 契約終了年月日時がNULL または 空の場合、または運用日より未来日の場合契約中
							if(opeDate.compareTo(endDate) >= 0)
							{
								// 契約中のみマッピング
								outContList.put(CONTRACT_FLG, "1");
								outContList.put("contract_no", contInfo.get("cont_kei_no"));
								outContList.put("sysid", sysidList.get(i));
								inContDetailList.add(outContList);
							}
						}
					}
				}
			}
			template.setPrivate("ECNA0170001CBSMsgList", inContDetailList);
			param.setData("ECNA0170001", template);
		// #84105 DEL START
//		}
//		catch (Throwable e)
//		{
//			new Throwable(e);
//		}
		// #84105 DEL END

		return inContDetailList;
	}
// ANK-4346-00-00 ADD END

// ANK-4346-00-00 MOD START
//	/**
//	 * コンテンツ契約変更の処理を行います。
//	 * 
//	 * <br>
//	 * @param param
//	 * @param fixedText
//	 * @param inputList
//	 * @return CAANMsg
//	 * @throws RequestParameterException
//	 */
//	protected CAANMsg editInECNA0240001(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, ArrayList<String> inputList) throws RequestParameterException
//	{
//		CAANMsg template = new CAANMsg();
//		List<HashMap<String, Object>> inContDetailList = new ArrayList<HashMap<String, Object>>();
//
//		//ECN0021A001
//
//		try
//		{
//			// コンテンツ契約一覧照会
//			JECNA0240001TPMA conKeitCng = new JECNA0240001TPMA();
//			for (int i = 0; i < sysidList.size(); i++)
//			{
//				HashMap<String, Object> inParam = new HashMap();
//				inParam.put("func_code", "7");
//				inParam.put("sysid",  sysidList.get(i));
//				inParam.put("service_id", JKKStrConst.CONT_SVC_CD_VIRUSBUSTER);
//				inParam.put("return_contract", "1");
//				inParam.put("return_charge", "0");
//				inParam.put("return_contract_adds", "0");
//				param.setData("JECNA0240001TPMA", inParam);
//				
//				// コンテンツ契約一覧照会CC呼び出し
//				conKeitCng.call_CNIFE056(handle,param, "JECNA0240001TPMA");
//				
//				Integer errCode = Integer.parseInt(inParam.get(ERRCODE).toString());
//				if (errCode > JPCModelConstant.ITEM_RELATION_ERR)
//				{ // ステータスが単項目エラー以上であれば例外をスロー
//					throw new CCException(SC_ERROR_STRING, new Exception());
//				}
//				
//				// 下り設定
//				template.set("sysid", inParam.get("sysid"));
//				template.set("service_id", inParam.get("service_id"));
//				template.set("return_contract", inParam.get("return_contract"));
//				template.set("return_charge", inParam.get("return_charge"));
//				template.set("return_contract_adds", inParam.get("return_contract_adds"));
//				
//				List<Map<String, Object>> inMap = (List<Map<String, Object>>)inParam.get("cont_svc_detail_list");
//				List<Map<String, Object>> outMap = new ArrayList<Map<String,Object>>();
//				HashMap<String, Object> retMap = new HashMap<String, Object>();
//				if (inMap != null)
//				{
//					// レスポンス設定
//					for (Map<String, Object> contInfo : inMap)
//					{
//						retMap.put("contracts_service_id", contInfo.get("contracts_service_id"));
//						retMap.put("contract_contents_division", contInfo.get("contract_contents_division"));
//	
//						if(!JCNStringUtil.isNullEmpty(contInfo.get("contract_end_date")))
//						{
//							// 契約中
//							retMap.put("contract_flg", "1");
//						}
//						else
//						{
//							// 解約済み
//							retMap.put("contract_flg", "0");
//						}
//					}
//				}
//				inContDetailList.add(retMap);
//			}
//			template.set("ECNA0170001CBSMsgList", inContDetailList);
//			param.setData("ECK0011B003", template);
//		}
//		catch (Throwable e)
//		{
//			new Throwable(e);
//		}
//
//		return template;
//	}

	/**
	 * コンテンツ契約変更の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param inputList
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	protected CAANMsg editInECNA0240001(IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> childMap, ArrayList<HashMap<String, Object>> vbMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(ECNA0240001CBSMsg.class.getName());

		for(HashMap<String, Object> updatetaDate : vbMap)
		{
			// テンプレートID
			template.set(ECN0021A001CBSMsg.TEMPLATEID, "ECNA0240001");

			// 機能コード
			template.set(ECNA0240001CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_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);

			// SYSID
			template.set(ECNA0240001CBSMsg.KEY_SYSID, (String)updatetaDate.get("sysid"));

			CAANMsg[] msgList1 = new CAANMsg[1];
			
			CAANMsg msg1 = new CAANMsg(ECNA0240001CBSMsg1List.class.getName());
			msg1.set(ECNA0240001CBSMsg1List.KEY_CONTRACT_NO, updatetaDate.get("contract_no"));
			msgList1[0] = msg1;

			template.set(ECNA0240001CBSMsg.MAIL_SEND_FLG,			"1"); 						// メール送信フラグ
			template.set(ECNA0240001CBSMsg.CANCEL_CHAIN_FLG,		"0");						// 共連れ解約実施フラグ
			template.set(ECNA0240001CBSMsg.RETURN_CONTRACT, 		INFO_YOHI_0);				// コンテンツ契約情報要否
			template.set(ECNA0240001CBSMsg.RETURN_CHARGE,			INFO_YOHI_0);				// 直近課金情報要否
			template.set(ECNA0240001CBSMsg.UPDATE_ID, 				operatorId);				// 更新者ID
			template.set(ECNA0240001CBSMsg.UPDATE_NAME,				"お客様");					// 更新者
			template.set(ECNA0240001CBSMsg.ECNA0240001CBSMSG1LIST, 	msgList1);
		}
		
		return template;
	}

	/**
	 * コンテンツ契約変更の下りマッピング処理を行います。
	 * 
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputList
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	protected IRequestParameterReadWrite editRetECNA0240001(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> outputMap)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;

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

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

		HashMap dataMap = null;
		ArrayList dataList = null;

		if (template != null)
		{
			// ステータス
			setDataMapCont(outputMap, "", ECNA0240001CBSMsg.STATUS, template, ECNA0240001CBSMsg.STATUS);

			templateArray = template.getCAANMsgList(ECNA0240001CBSMsg.ECNA0240001CBSMSG2LIST);

// ANK-4346-00-00 MOD START
//			for (int i = 0; i < templateArray.length; i++) {
//					CAANMsg childTemplate = templateArray[i];
				// コンテンツサービス解約マップ.エラーコード ← エラーコード
//				if (childTemplate.isNull(ECNA0240001CBSMsg2List.HTTPSTATUS)) {
//					outputMap.put(ECNA0240001CBSMsg2List.ERR_CD, new String());
//					break;
//				} else {
//					outputMap.put(ECNA0240001CBSMsg2List.ERR_CD, childTemplate.getString(ECNA0240001CBSMsg2List.ERR_CD));
//					break;
//				}
//			}

			// ループから条件に変更（必ず１件目参照のため）
			if (templateArray != null)
			{
				if (templateArray.length > 0)
				{
					CAANMsg childTemplate = templateArray[0];

					// コンテンツサービス解約マップ.エラーコード ← エラーコード
					if (childTemplate.isNull(ECNA0240001CBSMsg2List.ERR_CD)) {
						outputMap.put(ECNA0240001CBSMsg2List.ERR_CD, new String());
					} else {
						outputMap.put(ECNA0240001CBSMsg2List.ERR_CD, childTemplate.getString(ECNA0240001CBSMsg2List.ERR_CD));
					}
				}
			}
// ANK-4346-00-00 MOD END
		}

		// エラー情報の設定
		editErrInfoECNA0240001(param, template, (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;

	}

	/**
	 * コンテンツ契約一覧照会のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoECN0021B001(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		// コンテンツ契約一覧照会.ＫＥＹ＿SYSID → SYSIDのエラー情報返却
		setErrInfo(inMap, "", ECN0021B001CBSMsg.KEY_SYSID_ERR, template, ECN0021B001CBSMsg.KEY_SYSID_ERR);
		
		// コンテンツ契約一覧照会.ＫＥＹ＿予約適用年月日 → 予約適用年月日のエラー情報返却
		setErrInfo(inMap, "", ECN0021B001CBSMsg.KEY_RSV_APLY_YMD_ERR, template, ECN0021B001CBSMsg.KEY_RSV_APLY_YMD_ERR);
		
		// コンテンツ契約一覧照会.ＫＥＹ＿システム年月日時分秒 → システム年月日時分秒のエラー情報返却
		setErrInfo(inMap, "", ECN0021B001CBSMsg.KEY_SYS_DTM_ERR, template, ECN0021B001CBSMsg.KEY_SYS_DTM_ERR);

		return param;
	}
	
	/**
	 * コンテンツ契約一意照会の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param inputList
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	protected CAANMsg editInECN0021A001(IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> childMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(ECN0021A001CBSMsg.class.getName());

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

		// 機能コード
		template.set(ECN0021A001CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_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);
		
		// コンテンツ契約一意照会.ＫＥＹ＿コンテンツ契約番号
		setTemplate(template, ECN0021A001CBSMsg.KEY_CONT_KEI_NO, childMap, "", ECN0021B001CBSMsgList.CONT_KEI_NO);

		return template;
	}
	
	/**
	 * コンテンツ契約一意照会の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputMap
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	protected IRequestParameterReadWrite editRetECN0021A001(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> outputMap)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;

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

		if (template != null)
		{
			templateArray = template.getCAANMsgList(ECN0021A001CBSMsg.ECN0021A001CBSMSGLIST);
			CAANMsg childTemplate = templateArray[0];
			
			// コンテンツ契約番号 ← コンテンツ契約一意照会.コンテンツ契約番号
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_KEI_NO, childTemplate, ECN0021A001CBSMsgList.CONT_KEI_NO);

			// SYSID ← コンテンツ契約一意照会.SYSID
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.SYSID, childTemplate, ECN0021A001CBSMsgList.SYSID);

			// コンテンツサービスコード ← コンテンツ契約一意照会.コンテンツサービスコード
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_SVC_CD, childTemplate, ECN0021A001CBSMsgList.CONT_SVC_CD);

			// コンテンツコード ← コンテンツ契約一意照会.コンテンツコード
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_CD, childTemplate, ECN0021A001CBSMsgList.CONT_CD);

			// コンテンツ外部コード ← コンテンツ契約一意照会.コンテンツ外部コード
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_OUT_CD, childTemplate, ECN0021A001CBSMsgList.CONT_OUT_CD);

			// コンテンツ名 ← コンテンツ契約一意照会.コンテンツ名
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_NM, childTemplate, ECN0021A001CBSMsgList.CONT_NM);

			// コンテンツ種別コード ← コンテンツ契約一意照会.コンテンツ種別コード
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_SBT_CD, childTemplate, ECN0021A001CBSMsgList.CONT_SBT_CD);

			// コンテンツ契約開始年月日時分秒 ← コンテンツ契約一意照会.コンテンツ契約開始年月日時分秒
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_KEI_STA_DTM, childTemplate, ECN0021A001CBSMsgList.CONT_KEI_STA_DTM);

			// コンテンツ契約終了年月日時分秒 ← コンテンツ契約一意照会.コンテンツ契約終了年月日時分秒
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_KEI_END_DTM, childTemplate, ECN0021A001CBSMsgList.CONT_KEI_END_DTM);

			// コンテンツ支払い方法コード ← コンテンツ契約一意照会.コンテンツ支払い方法コード
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_PAYWAY_CD, childTemplate, ECN0021A001CBSMsgList.CONT_PAYWAY_CD);

			// クレジットカードID ← コンテンツ契約一意照会.クレジットカードID
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CRECARD_ID, childTemplate, ECN0021A001CBSMsgList.CRECARD_ID);

			// ISP決済サービス契約番号 ← コンテンツ契約一意照会.ISP決済サービス契約番号
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.ISP_KSSAI_SVC_KEI_NO, childTemplate, ECN0021A001CBSMsgList.ISP_KSSAI_SVC_KEI_NO);

			// 仕入先 ← コンテンツ契約一意照会.仕入先
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.SUPPLIER, childTemplate, ECN0021A001CBSMsgList.SUPPLIER);

			// コンテンツ契約状態コード ← コンテンツ契約一意照会.コンテンツ契約状態コード
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_KEI_STAT_CD, childTemplate, ECN0021A001CBSMsgList.CONT_KEI_STAT_CD);

			// 税区 ← コンテンツ契約一意照会.税区
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.TAXAREA, childTemplate, ECN0021A001CBSMsgList.TAXAREA);

			// チョイスチケット利用可能数 ← コンテンツ契約一意照会.チョイスチケット利用可能数
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CHOICETICKT_USE_PSB_CNT, childTemplate, ECN0021A001CBSMsgList.CHOICETICKT_USE_PSB_CNT);

			// コンテンツ契約継続回数 ← コンテンツ契約一意照会.コンテンツ契約継続回数
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_KEI_KEIZOKU_CNT, childTemplate, ECN0021A001CBSMsgList.CONT_KEI_KEIZOKU_CNT);

			// コンテンツ購入数量 ← コンテンツ契約一意照会.コンテンツ購入数量
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_BUY_CNT, childTemplate, ECN0021A001CBSMsgList.CONT_BUY_CNT);

			// コンテンツ単価 ← コンテンツ契約一意照会.コンテンツ単価
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_TANKA, childTemplate, ECN0021A001CBSMsgList.CONT_TANKA);

			// コンテンツ契約種別コード ← コンテンツ契約一意照会.コンテンツ契約種別コード
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_KEI_SBT_CD, childTemplate, ECN0021A001CBSMsgList.CONT_KEI_SBT_CD);

			// 契約可能数 ← コンテンツ契約一意照会.契約可能数
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.KEI_PSBSU, childTemplate, ECN0021A001CBSMsgList.KEI_PSBSU);

			// 非継続フラグ ← コンテンツ契約一意照会.非継続フラグ
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.HIKEIZOKU_FLG, childTemplate, ECN0021A001CBSMsgList.HIKEIZOKU_FLG);

			// コンテンツ契約有料無料フラグ ← コンテンツ契約一意照会.コンテンツ契約有料無料フラグ
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_KEI_YRYO_MRYO_FLG, childTemplate, ECN0021A001CBSMsgList.CONT_KEI_YRYO_MRYO_FLG);

			// 課金形態コード ← コンテンツ契約一意照会.課金形態コード
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CHRG_FORM_CD, childTemplate, ECN0021A001CBSMsgList.CHRG_FORM_CD);

			// 年齢制限 ← コンテンツ契約一意照会.年齢制限
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.OLD_LIMIT, childTemplate, ECN0021A001CBSMsgList.OLD_LIMIT);

			// 利用可能ユーザ種別コード ← コンテンツ契約一意照会.利用可能ユーザ種別コード
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.USE_PSB_USER_SBT_CD, childTemplate, ECN0021A001CBSMsgList.USE_PSB_USER_SBT_CD);

			// 連携先識別コード ← コンテンツ契約一意照会.連携先識別コード
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.RNKSAKI_CD, childTemplate, ECN0021A001CBSMsgList.RNKSAKI_CD);

			// 連携先コンテンツ識別ID ← コンテンツ契約一意照会.連携先コンテンツ識別ID
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.RNKSAKI_CONT_SKBT_ID, childTemplate, ECN0021A001CBSMsgList.RNKSAKI_CONT_SKBT_ID);

			// コンテンツマスタ存在フラグ ← コンテンツ契約一意照会.コンテンツマスタ存在フラグ
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CONT_SONZAI_FLG, childTemplate, ECN0021A001CBSMsgList.CONT_SONZAI_FLG);

			// 契約時SYSID ← コンテンツ契約一意照会.契約時SYSID
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.KEI_JI_SYSID, childTemplate, ECN0021A001CBSMsgList.KEI_JI_SYSID);

			// 契約時会員種別コード ← コンテンツ契約一意照会.契約時会員種別コード
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.KEI_JI_MMB_SBT_CD, childTemplate, ECN0021A001CBSMsgList.KEI_JI_MMB_SBT_CD);

			// 解約時会員種別コード ← コンテンツ契約一意照会.解約時会員種別コード
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.DSL_JI_MMB_SBT_CD, childTemplate, ECN0021A001CBSMsgList.DSL_JI_MMB_SBT_CD);

			// 契約処理年月日 ← コンテンツ契約一意照会.契約処理年月日
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.KEI_TRAN_YMD, childTemplate, ECN0021A001CBSMsgList.KEI_TRAN_YMD);

			// CCMG登録ユーザーID ← コンテンツ契約一意照会.CCMG登録ユーザーID
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CCMG_ADD_USER_ID, childTemplate, ECN0021A001CBSMsgList.CCMG_ADD_USER_ID);

			// CCMG更新ユーザーID ← コンテンツ契約一意照会.CCMG更新ユーザーID
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.CCMG_UPD_USER_ID, childTemplate, ECN0021A001CBSMsgList.CCMG_UPD_USER_ID);

			// 登録年月日時分秒 ← コンテンツ契約一意照会.登録年月日時分秒
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.ADD_DTM, childTemplate, ECN0021A001CBSMsgList.ADD_DTM);

			// 登録オペレータアカウント ← コンテンツ契約一意照会.登録オペレータアカウント
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.ADD_OPEACNT, childTemplate, ECN0021A001CBSMsgList.ADD_OPEACNT);

			// 更新年月日時分秒 ← コンテンツ契約一意照会.更新年月日時分秒
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.UPD_DTM, childTemplate, ECN0021A001CBSMsgList.UPD_DTM);

			// 更新オペレータアカウント ← コンテンツ契約一意照会.更新オペレータアカウント
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.UPD_OPEACNT, childTemplate, ECN0021A001CBSMsgList.UPD_OPEACNT);

			// 削除年月日時分秒 ← コンテンツ契約一意照会.削除年月日時分秒
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.DEL_DTM, childTemplate, ECN0021A001CBSMsgList.DEL_DTM);

			// 削除オペレータアカウント ← コンテンツ契約一意照会.削除オペレータアカウント
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.DEL_OPEACNT, childTemplate, ECN0021A001CBSMsgList.DEL_OPEACNT);

			// 無効フラグ ← コンテンツ契約一意照会.無効フラグ
			setDataMap(outputMap, "", ECN0021A001CBSMsgList.MK_FLG, childTemplate, ECN0021A001CBSMsgList.MK_FLG);
		}
		
		// エラー情報の設定
		editErrInfoECN0021A001(param, template, (Integer)returnCode, fixedText);

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

		return param;
	}
	
	/**
	 * コンテンツ契約一意照会のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoECN0021A001(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		// コンテンツ契約一意照会.ＫＥＹ＿コンテンツ契約番号 → コンテンツ契約番号のエラー情報返却
		setErrInfo(inMap, "", ECN0021A001CBSMsg.KEY_CONT_KEI_NO_ERR, template, ECN0021A001CBSMsg.KEY_CONT_KEI_NO_ERR);

		return param;
	}
	
	/**
	 * コンテンツサービス解約の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param outputMap
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	protected CAANMsg editInECNA0010001(IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> ecn0021a001OutputMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(ECNA0010001CBSMsg.class.getName());
		String prefix = "";
		
		// テンプレートID
		template.set(ECNA0010001CBSMsg.TEMPLATEID, "ECNA0010001");
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// コンテンツサービス解約.機能コード
		setTemplate(template, ECNA0010001CBSMsg.FUNC_CODE, inMap, prefix, "func_code");
		
		// コンテンツサービス解約.更新者ID
		setTemplate(template, ECNA0010001CBSMsg.UPD_USER_ID, inMap, prefix, "upd_user_id");
		
		// コンテンツサービス解約.更新者
		setTemplate(template, ECNA0010001CBSMsg.UPD_USER, inMap, prefix, "upd_user");
		
		// コンテンツサービス解約.メール送信フラグ
		template.set(ECNA0010001CBSMsg.MAIL_SEND_FLG, JKKStrConst.CD01354_SOUSIN);
		
		
		// コンテンツサービス解約.SYSID
		setTemplate(template, ECNA0010001CBSMsg.SYSID, ecn0021a001OutputMap, prefix, ECN0021A001CBSMsgList.SYSID);
		
		// コンテンツサービス解約.コンテンツ契約番号
		setTemplate(template, ECNA0010001CBSMsg.CONTRACT_NO, ecn0021a001OutputMap, prefix, ECN0021A001CBSMsgList.CONT_KEI_NO);
		
		// コンテンツサービス解約.更新年月日時分秒
		template.set(ECNA0010001CBSMsg.UPD_DATE, ((String)ecn0021a001OutputMap.get("upd_dtm")).substring(0, 14));
		
		return template;
	}
	
	/**
	 * コンテンツサービス解約の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputMap
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	protected IRequestParameterReadWrite editRetECNA0010001(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> outputMap)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		if (template != null)
		{
			// ステータス
			setDataMap(outputMap, "", ECNA0010001CBSMsg.STAT, template, ECNA0010001CBSMsg.STAT);

			// エラーコード
			setDataMap(outputMap, "", ECNA0010001CBSMsg.ERR_CD, template, ECNA0010001CBSMsg.ERR_CD);
			
			// SYSID(CCMG)
			setDataMap(outputMap, "", ECNA0010001CBSMsg.SYSID_CCMG, template, ECNA0010001CBSMsg.SYSID_CCMG);
		}

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

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

		return param;
	}
	
	/**
	 * コンテンツサービス解約のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoECNA0010001(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		// 申込明細情報変更.SYSID → SYSIDのエラー情報返却
		setErrInfo(inMap, "", ECNA0010001CBSMsg.SYSID_ERR, template, ECNA0010001CBSMsg.SYSID_ERR);

		// 申込明細情報変更.コンテンツ契約番号 → コンテンツ契約番号のエラー情報返却
		setErrInfo(inMap, "", ECNA0010001CBSMsg.CONTRACT_NO_ERR, template, ECNA0010001CBSMsg.CONTRACT_NO_ERR);

		// 申込明細情報変更.更新者ID → 更新者IDのエラー情報返却
		setErrInfo(inMap, "", ECNA0010001CBSMsg.UPD_USER_ID_ERR, template, ECNA0010001CBSMsg.UPD_USER_ID_ERR);

		// 申込明細情報変更.更新者 → 更新者のエラー情報返却
		setErrInfo(inMap, "", ECNA0010001CBSMsg.UPD_USER_ERR, template, ECNA0010001CBSMsg.UPD_USER_ERR);

		// 申込明細情報変更.更新日時 → 更新日時のエラー情報返却
		setErrInfo(inMap, "", ECNA0010001CBSMsg.UPD_DATE_ERR, template, ECNA0010001CBSMsg.UPD_DATE_ERR);

		// 申込明細情報変更.メール送信フラグ → メール送信フラグのエラー情報返却
		setErrInfo(inMap, "", ECNA0010001CBSMsg.MAIL_SEND_FLG_ERR, template, ECNA0010001CBSMsg.MAIL_SEND_FLG_ERR);

		return param;
	}
	
	/**
	 * 機器提供サービス契約一覧照会(サービス契約番号、回線対象サービス契約経由)の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0341B019(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341B019CBSMsg.class.getName());
		String prefix = "";

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

		// 機能コード
		template.set(EKK0341B019CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_3);

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

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

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

		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

		// 機器提供サービス契約一覧照会.ＫＥＹ＿サービス契約番号
		setTemplate(template, EKK0341B019CBSMsg.KEY_SVC_KEI_NO, inMap, prefix, "svc_kei_no");
		
		// 機器提供サービス契約一覧照会.ＫＥＹ＿基準年月日
		String gyomuOpDate = JCCBPCommon.getOpeDate(null);
		template.set(EKK0341B019CBSMsg.KEY_BASE_YMD, gyomuOpDate);

		return template;
	}
	
	/**
	 * 機器提供サービス契約一覧照会(サービス契約番号、回線対象サービス契約経由)の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputList
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0341B019(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, ArrayList<HashMap<String, Object>> outputList)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		templateArray = template.getCAANMsgList(EKK0341B019CBSMsg.EKK0341B019CBSMSG1LIST);

		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				HashMap<String, Object> childMap = new HashMap<String, Object>();
				
				// 機器提供サービス契約番号 ← 機器提供サービス契約一覧照会.機器提供サービス契約番号
				setDataMap(childMap, "", EKK0341B019CBSMsg1List.KKTK_SVC_KEI_NO, templateArray[i], EKK0341B019CBSMsg1List.KKTK_SVC_KEI_NO);
				
				// 機器提供サービスコード ← 機器提供サービス契約一覧照会.機器提供サービスコード
				setDataMap(childMap, "", EKK0341B019CBSMsg1List.KKTK_SVC_CD, templateArray[i], EKK0341B019CBSMsg1List.KKTK_SVC_CD);
				
				// 料金コースコード ← 機器提供サービス契約一覧照会.料金コースコード
				setDataMap(childMap, "", EKK0341B019CBSMsg1List.PCRS_CD, templateArray[i], EKK0341B019CBSMsg1List.PCRS_CD);
				
				// 料金プランコード ← 機器提供サービス契約一覧照会.料金プランコード
				setDataMap(childMap, "", EKK0341B019CBSMsg1List.PPLAN_CD, templateArray[i], EKK0341B019CBSMsg1List.PPLAN_CD);
				
				// 宅内機器種別コード ← 機器提供サービス契約一覧照会.宅内機器種別コード
				setDataMap(childMap, "", EKK0341B019CBSMsg1List.TAKNKIKI_SBT_CD, templateArray[i], EKK0341B019CBSMsg1List.TAKNKIKI_SBT_CD);
				
				// 機器提供サービス契約ステータス ← 機器提供サービス契約一覧照会.機器提供サービス契約ステータス
				setDataMap(childMap, "", EKK0341B019CBSMsg1List.KKTK_SVC_KEI_STAT, templateArray[i], EKK0341B019CBSMsg1List.KKTK_SVC_KEI_STAT);
				
				// リストにマップを格納する
				outputList.add(childMap);
			}
		}
		// エラー情報の設定
		editErrInfoEKK0341B019(param, template, (Integer)returnCode, fixedText);

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

		return param;
	}
	
	/**
	 * 機器提供サービス契約一覧照会(サービス契約番号、回線対象サービス契約経由)のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0341B019(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		// 機器提供サービス契約一覧照会.ＫＥＹ＿サービス契約番号 → サービス契約番号のエラー情報返却
		setErrInfo(inMap, "", EKK0341B019CBSMsg.KEY_SVC_KEI_NO_ERR, template, EKK0341B019CBSMsg.KEY_SVC_KEI_NO_ERR);
		
		// 機器提供サービス契約一覧照会.ＫＥＹ＿基準年月日 → 基準年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0341B019CBSMsg.KEY_BASE_YMD_ERR, template, EKK0341B019CBSMsg.KEY_BASE_YMD_ERR);
		
		return param;
	}
	
	/**
	 * 機器オプションサービス契約一覧照会（複合検索）の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	protected CAANMsg editInEKK2811B504(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811B504CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK2811B504CBSMsg.TEMPLATEID, "EKK2811B504");
		
		// 機能コード
		template.set(EKK2811B504CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_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(EKK2811B504CBSMsg.KEY_KKTK_SVC_KEI_NO, ekk0341b019KktkSvcKeiNo);
		
		// 運用年月日
		String gyomuOpDate = JCCBPCommon.getOpeDate(null);
		
		// 機器オプションサービス契約一覧照会.ＫＥＹ＿予約適用年月日
		template.set(EKK2811B504CBSMsg.KEY_RSV_APLY_YMD, gyomuOpDate);
		
		return template;
	}
	
	/**
	 * 機器オプションサービス契約一覧照会（複合検索）の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputList
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	protected IRequestParameterReadWrite editRetEKK2811B504(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, ArrayList<HashMap<String, Object>> outputList)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		templateArray = template.getCAANMsgList(EKK2811B504CBSMsg.EKK2811B504CBSMSG1LIST);

		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				HashMap<String, Object> childMap = new HashMap<String, Object>();
				
				// 機器オプションサービス契約番号 ← 機器オプションサービス契約一覧照会.機器オプションサービス契約番号
				setDataMap(childMap, "", EKK2811B504CBSMsg1List.KKOP_SVC_KEI_NO, templateArray[i], EKK2811B504CBSMsg1List.KKOP_SVC_KEI_NO);
				
				// 機器オプションサービス契約ステータス ← 機器オプションサービス契約一覧照会.機器オプションサービス契約ステータス
				setDataMap(childMap, "", EKK2811B504CBSMsg1List.KKOP_SVC_KEI_STAT, templateArray[i], EKK2811B504CBSMsg1List.KKOP_SVC_KEI_STAT);
				
				// 機器オプションサービスコード ← 機器オプションサービス契約一覧照会.機器オプションサービスコード
				setDataMap(childMap, "", EKK2811B504CBSMsg1List.KKOP_SVC_CD, templateArray[i], EKK2811B504CBSMsg1List.KKOP_SVC_CD);
				
				// 料金コースコード ← 機器オプションサービス契約一覧照会.料金コースコード
				setDataMap(childMap, "", EKK2811B504CBSMsg1List.PCRS_CD, templateArray[i], EKK2811B504CBSMsg1List.PCRS_CD);
				
				// リストにマップを格納する
				outputList.add(childMap);
			}
		}
		// エラー情報の設定
		editErrInfoEKK2811B504(param, template, (Integer)returnCode, fixedText);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	/**
	 * 機器オプションサービス契約一覧照会（複合検索）のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK2811B504(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		//  機器オプションサービス契約一覧照会.ＫＥＹ＿機器提供サービス契約番号 → 機器提供サービス契約番号のエラー情報返却
		setErrInfo(inMap, "", EKK2811B504CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR, template, EKK2811B504CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR);
		
		//  機器オプションサービス契約一覧照会.ＫＥＹ＿予約適用年月日 → 予約適用年月日のエラー情報返却
		setErrInfo(inMap, "", EKK2811B504CBSMsg.KEY_RSV_APLY_YMD_ERR, template, EKK2811B504CBSMsg.KEY_RSV_APLY_YMD_ERR);
		
		return param;
	}
	
	/**
	 * 機器提供サービス契約一意照会の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	protected CAANMsg editInEKK0341A010(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341A010CBSMsg.class.getName());

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

		// 機能コード
		template.set(EKK0341A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

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

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

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// 機器提供サービス契約一意照会.ＫＥＹ＿機器提供サービス契約番号
		template.set(EKK0341A010CBSMsg.KEY_KKTK_SVC_KEI_NO, ekk0341b019KktkSvcKeiNo);
		
		// 運用年月日
		String gyomuOpDate = JCCBPCommon.getOpeDate(null);
		
		// 機器提供サービス契約一意照会.ＫＥＹ＿予約適用年月日
		template.set(EKK0341A010CBSMsg.KEY_RSV_APLY_YMD, gyomuOpDate);

		return template;
	}
	
	/**
	 * 機器提供サービス契約一意照会の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputList
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	protected IRequestParameterReadWrite editRetEKK0341A010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> outputMap)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;

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

		if (template != null)
		{
			
			templateArray = template.getCAANMsgList(EKK0341A010CBSMsg.EKK0341A010CBSMSG1LIST);
			CAANMsg childTemplate = templateArray[0];
			
			// 機器提供サービス契約番号
			setDataMap(outputMap, "", EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO, childTemplate, EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO);

			// 機器製造番号
			setDataMap(outputMap, "", EKK0341A010CBSMsg1List.KIKI_SEIZO_NO, childTemplate, EKK0341A010CBSMsg1List.KIKI_SEIZO_NO);

			// 宅内機器型式コード
			setDataMap(outputMap, "", EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD, childTemplate, EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD);

// IT2-2017-0000010 ADD START
			// 機器変更番号
			setDataMap(outputMap, "", EKK0341A010CBSMsg1List.KIKI_CHG_NO, childTemplate, EKK0341A010CBSMsg1List.KIKI_CHG_NO);
// IT2-2017-0000010 ADD END
		}
		
		// エラー情報の設定
		editErrInfoEKK0341A010(param, template, (Integer)returnCode, fixedText);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	/**
	 * 機器提供サービス契約一意照会のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0341A010(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		// 機器提供サービス契約一意照会.ＫＥＹ＿機器提供サービス契約番号 → 機器提供サービス契約番号のエラー情報返却
		setErrInfo(inMap, "", EKK0341A010CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR, template, EKK0341A010CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR);
		
		// 機器提供サービス契約一意照会.ＫＥＹ＿予約適用年月日 → 予約適用年月日のエラー情報返却
		setErrInfo(inMap, "", EKK0341A010CBSMsg.KEY_RSV_APLY_YMD_ERR, template, EKK0341A010CBSMsg.KEY_RSV_APLY_YMD_ERR);
		
		return param;
	}
	
	/**
	 * オーダ設定一覧照会の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param outputMap
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	protected CAANMsg editInEKK1041B001(IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> outputMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK1041B001CBSMsg.class.getName());
		String prefix = "";

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

		// 機能コード
		template.set(EKK1041B001CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_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);

		// オーダ設定一覧照会.ＫＥＹ＿機器提供サービス契約番号
		setTemplate(template, EKK1041B001CBSMsg.KEY_KKTK_SVC_KEI_NO, outputMap, prefix, EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO);
		
		// オーダ設定一覧照会.ＫＥＹ＿宅内機器型式コード
		setTemplate(template, EKK1041B001CBSMsg.KEY_TAKNKIKI_MODEL_CD, outputMap, prefix, EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD);
		
		// オーダ設定一覧照会.ＫＥＹ＿機器製造番号
		setTemplate(template, EKK1041B001CBSMsg.KEY_KIKI_SEIZO_NO, outputMap, prefix, EKK0341A010CBSMsg1List.KIKI_SEIZO_NO);
		
		return template;
	}
	
	/**
	 * オーダ設定一覧照会の下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param outputList
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	protected IRequestParameterReadWrite editRetEKK1041B001(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, ArrayList<HashMap<String, Object>> outputList)
			throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		templateArray = template.getCAANMsgList(EKK1041B001CBSMsg.EKK1041B001CBSMSG1LIST);

		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				HashMap<String, Object> childMap = new HashMap<String, Object>();
				
				// 登録SOD送信年月日 ← オーダ設定一覧照会.登録SOD送信年月日
				setDataMap(childMap, "", EKK1041B001CBSMsg1List.ADD_SOD_SEND_YMD, templateArray[i], EKK1041B001CBSMsg1List.ADD_SOD_SEND_YMD);
				
				// 停止SOD送信年月日 ← オーダ設定一覧照会.停止SOD送信年月日
				setDataMap(childMap, "", EKK1041B001CBSMsg1List.STP_SOD_SEND_YMD, templateArray[i], EKK1041B001CBSMsg1List.STP_SOD_SEND_YMD);
				
				// リストにマップを格納する
				outputList.add(childMap);
			}
		}
		// エラー情報の設定
		editErrInfoEKK1041B001(param, template, (Integer)returnCode, fixedText);

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

		return param;
	}
	
	/**
	 * オーダ設定一覧照会のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK1041B001(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);
		
		HashMap inMap = (HashMap)param.getData(fixedText);
		
		// オーダ設定一覧照会.ＫＥＹ＿機器提供サービス契約番号 → 機器提供サービス契約番号のエラー情報返却
		setErrInfo(inMap, "", EKK1041B001CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR, template, EKK1041B001CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR);
		
		// オーダ設定一覧照会.ＫＥＹ＿宅内機器型式コード → 宅内機器型式コードのエラー情報返却
		setErrInfo(inMap, "", EKK1041B001CBSMsg.KEY_TAKNKIKI_MODEL_CD_ERR, template, EKK1041B001CBSMsg.KEY_TAKNKIKI_MODEL_CD_ERR);
		
		// オーダ設定一覧照会.ＫＥＹ＿機器製造番号 → 機器製造番号のエラー情報返却
		setErrInfo(inMap, "", EKK1041B001CBSMsg.KEY_KIKI_SEIZO_NO_ERR, template, EKK1041B001CBSMsg.KEY_KIKI_SEIZO_NO_ERR);

		return param;
	}
	
// IT2-2017-0000010 ADD START

	/**
	 * 工事案件諸変更実行
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param fixedText
	 * @throws Throwable 
	 */
	@SuppressWarnings("unchecked")
	protected void execKojiAnkenRenkei(SessionHandle handle, ServiceComponentRequestInvoker scCall, IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		HashMap<String, Object> paramMap = setSCInputCommonData(param, new HashMap<String, Object>());
		
		HashMap<String, Object> temporaryData = new HashMap<String, Object>();
		
		// サービス契約一意照会
		CAANMsg template = editInEKK0081A010(param, fixedText); // 上りマッピング
		Map<?, ?> result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
		editRetEKK0081A010KojiAnkenRenkei(result, param, fixedText, temporaryData); // 下りマッピング
		if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
		{ // ステータスが単項目エラー以上であれば例外をスロー
			throw new CCException(SC_ERROR_STRING, new Exception());
		}
		
		temporaryData.put("KIKI_OPT_SVC_KEI_SHORI_KBN", "3");
		
		HashMap<String, Object> resultMap = new HashMap<String, Object>();
		
		// 工事案件一覧照会(サービス契約番号)
		template = editInEKU0011B090(param, fixedText); // 上りマッピング
		result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
		editRetEKU0011B090(result, param, fixedText, resultMap); // 下りマッピング
		if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
		{ // ステータスが単項目エラー以上であれば例外をスロー
			throw new CCException(SC_ERROR_STRING, new Exception());
		}
		
		HashMap<String, String> kikiOptSvcKeiTakinoUpdMap = new HashMap<String, String>();
		// 工事案件番号
		kikiOptSvcKeiTakinoUpdMap.put("kojiak_no_ichiran_bf", (String)resultMap.get(EKU0011B090CBSMsg1List.KOJIAK_NO));
		// 機器提供サービス契約番号
		kikiOptSvcKeiTakinoUpdMap.put("kktk_svc_kei_no_bf", ekk0341b019KktkSvcKeiNo);
		
		// 機器提供サービス契約一意照会
		template = editInEKK0341A010(param, fixedText); // 上りマッピング
		result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
		editRetEKK0341A010(result, param, fixedText, resultMap); // 下りマッピング
		if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
		{ // ステータスが単項目エラー以上であれば例外をスロー
			throw new CCException(SC_ERROR_STRING, new Exception());
		}
		
		// 機器変更番号
		kikiOptSvcKeiTakinoUpdMap.put("kiki_chg_no", (String)resultMap.get(EKK0341A010CBSMsg1List.KIKI_CHG_NO));
		
		temporaryData.put("KIKI_OPT_SVC_KEI_TAKINO_UPD_KEY", kikiOptSvcKeiTakinoUpdMap);
		
		HashMap<String, Object> g01Map = null;
		HashMap<String, Object> g02Map = null;
		ArrayList<HashMap<String, Object>> ekk2811b504OutputList = new ArrayList<HashMap<String, Object>>();
		
		// 機器オプションサービス契約一覧照会（複合検索）
		template = editInEKK2811B504(param, fixedText); // 上りマッピング
		result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
		editRetEKK2811B504(result, param, fixedText, ekk2811b504OutputList); // 下りマッピング
		if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
		{ // ステータスが単項目エラー以上であれば例外をスロー
			throw new CCException(SC_ERROR_STRING, new Exception());
		}
		
		// ルーター機能、電話アダプター機能を特定する
		for (HashMap<String, Object> childMap : ekk2811b504OutputList)
		{
			// 機器オプションサービスコードがルーター機能、または、電話アダプター機能以外の場合
			if (!(JKKStrConst.KKOP_SVC_CD_ROUTER.equals(childMap.get(EKK2811B504CBSMsg1List.KKOP_SVC_CD))
					|| JKKStrConst.KKOP_SVC_CD_TEL_ADAPT.equals(childMap.get(EKK2811B504CBSMsg1List.KKOP_SVC_CD))))
			{
				continue;
			}
			
			// 機器オプションサービス契約ステータスが解約済以上の場合
			if (JKKStrConst.CD01616_STAT_DSLZUMI.compareTo((String)childMap.get(EKK2811B504CBSMsg1List.KKOP_SVC_KEI_STAT)) <= 0)
			{
				continue;
			}
			
			// 機器オプションサービスコードがルーター機能のレコードを保持する
			if (JKKStrConst.KKOP_SVC_CD_ROUTER.equals(childMap.get(EKK2811B504CBSMsg1List.KKOP_SVC_CD)))
			{
				g01Map = childMap;
			}
			// 機器オプションサービスコードが電話アダプター機能のレコードを保持する
			else
			{
				g02Map = childMap;
			}
		}
		
		// 機器オプションサービス一意照会
		template = editInEKK2811A010(param, fixedText, (String)g01Map.get(EKK2811B504CBSMsg1List.KKOP_SVC_KEI_NO)); // 上りマッピング
		result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
		editRetEKK2811A010(result, param, fixedText, temporaryData, "ruta_kkopt_svc_kei_data_af"); // 下りマッピング
		if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
		{ // ステータスが単項目エラー以上であれば例外をスロー
			throw new CCException(SC_ERROR_STRING, new Exception());
		}
		
		if(!JKKCommonUtil.isNull(g02Map))
		{
			// 機器オプションサービス一意照会
			template = editInEKK2811A010(param, fixedText, (String)g02Map.get(EKK2811B504CBSMsg1List.KKOP_SVC_KEI_NO)); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK2811A010(result, param, fixedText, temporaryData, "va_kkopt_svc_kei_data_bf"); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		
		// 一覧処理リスト設定
		ArrayList<HashMap<String, Object>> ichiranShoriList = new ArrayList<HashMap<String,Object>>();
		
		// ワーク領域を退避
		Map workMap = param.getMappingWorkArea();
		ArrayList<HashMap<String, Object>> bkIchiranShoriList = (ArrayList<HashMap<String, Object>>)workMap.get("IchiranShoriList");
		workMap.put("IchiranShoriList", ichiranShoriList);
		
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		inMap.put("unyo_ymd", JCCBPCommon.getOpeDate(null));
		
		JKKKikiIchiranIkkatsuCC cc = new JKKKikiIchiranIkkatsuCC();
		cc.isExecKojiAnkenRenkei(handle, scCall, param, fixedText, temporaryData);
		
		// ワーク領域再設定
		workMap.put("IchiranShoriList", bkIchiranShoriList);
		
	}
	
	/**
	 * サービス契約一意照会の下りマッピング処理（工事案件諸変更用）<br>
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param ekk0081a010Tmp
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0081A010KojiAnkenRenkei(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> temporaryData) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		if (template != null)
		{
			templateArray = template.getCAANMsgList(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);
			temporaryData.put("EKK0081A010", templateArray[0]);
		}

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

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

		return param;
	}
	
	/**
	 * 工事案件一覧照会(サービス契約番号)の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKU0011B090(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKU0011B090CBSMsg.class.getName());
		String prefix = "";

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

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

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

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

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

		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

		// サービス契約一意照会.ＫＥＹ＿サービス契約番号
		setTemplate(template, EKU0011B090CBSMsg.KEY_SVC_KEI_NO, inMap, prefix, "svc_kei_no");

		return template;
	}
	
	/**
	 * 工事案件一覧照会(サービス契約番号)の下りマッピング処理<br>
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param resultMap
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKU0011B090(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> resultMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		if (template != null)
		{
			templateArray = template.getCAANMsgList(EKU0011B090CBSMsg.EKU0011B090CBSMSG1LIST);
			CAANMsg chiledTemplate = templateArray[0];
			
			if(null != chiledTemplate)
			{
				// 工事案件一覧照会(サービス契約番号).工事案件番号 → 工事案件番号
				setDataMap(resultMap, "", EKU0011B090CBSMsg1List.KOJIAK_NO, chiledTemplate, EKU0011B090CBSMsg1List.KOJIAK_NO);
			}
		}

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

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

		return param;
	}
	
	/**
	 * 工事案件一覧照会(サービス契約番号)のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKU0011B090(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);
		
		HashMap inMap = (HashMap)param.getData(fixedText);
		
		// 工事案件一覧照会(サービス契約番号).ＫＥＹ＿サービス契約番号 → サービス契約番号のエラー情報返却
		setErrInfo(inMap, "", EKU0011B090CBSMsg.KEY_SVC_KEI_NO_ERR, template, EKU0011B090CBSMsg.KEY_SVC_KEI_NO_ERR);
		
		return param;
	}
	
	/**
	 * 機器オプションサービス契約一意照会の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	private CAANMsg editInEKK2811A010(IRequestParameterReadWrite param, String fixedText, String kkopSvcKeiNo) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811A010CBSMsg.class.getName());

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

		// 機能コード
		template.set(EKK2811A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

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

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

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

		// 機器オプションサービス契約一意照会.ＫＥＹ＿機器オプションサービス契約番号
		template.set(EKK2811A010CBSMsg.KEY_KKOP_SVC_KEI_NO, kkopSvcKeiNo);
		
		// 運用年月日
		String gyomuOpDate = JCCBPCommon.getOpeDate(null);
		
		// 機器オプションサービス契約一意照会.ＫＥＹ＿予約適用年月日
		template.set(EKK2811A010CBSMsg.KEY_RSV_APLY_YMD, gyomuOpDate);
		
		return template;
	}
	
	/**
	 * 機器オプションサービス契約一意照会の下りマッピング処理<br>
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param temporaryData
	 * @param key
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK2811A010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> temporaryData, String key) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		if (template != null)
		{
			templateArray = template.getCAANMsgList(EKK2811A010CBSMsg.EKK2811A010CBSMSG1LIST);
			temporaryData.put(key, templateArray[0]);
		}

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

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

		return param;
	}
	
	/**
	 * 機器オプションサービス契約一意照会のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK2811A010(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451B010CBSMsg.STATUS), returnCode);
		
		HashMap inMap = (HashMap)param.getData(fixedText);
		
		// 工事案件一覧照会(サービス契約番号).ＫＥＹ＿機器オプションサービス契約番号 → 機器オプションサービス契約番号のエラー情報返却
		setErrInfo(inMap, "", EKK2811A010CBSMsg.KEY_KKOP_SVC_KEI_NO_ERR, template, EKK2811A010CBSMsg.KEY_KKOP_SVC_KEI_NO_ERR);
		// 工事案件一覧照会(サービス契約番号).ＫＥＹ＿予約適用年月日 → 予約適用年月日のエラー情報返却
		setErrInfo(inMap, "", EKK2811A010CBSMsg.KEY_RSV_APLY_YMD_ERR, template, EKK2811A010CBSMsg.KEY_RSV_APLY_YMD_ERR);
		
		return param;
	}
// IT2-2017-0000010 ADD END


	/**
	 * コントロールマップエラー情報格納処理を行います。
	 * <br>
	 * @param param
	 * @param itemplateStatus
	 * @param returnCode
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	protected IRequestParameterReadWrite setControlMapErrInfo(IRequestParameterReadWrite param, int itemplateStatus, int returnCode)
			throws RequestParameterException
	{
		int templateStatus = itemplateStatus;

		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + String.format(RETURN_MESSAGE_FORMAT, templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

		if (templateStatus > bpStatus)
		{
			String formatStatus = String.format(RETURN_MESSAGE_FORMAT, templateStatus);
			String message = JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		return param;
	}

	/**
	 * CAANMsgに値を設定します。<br>
	 *  �@inMap内にデータが存在する場合、inMap内のデータを設定します。<br>
	 *  �A上記以外の場合、setNullを呼び出します。<br>
	 * @param template 値を設定するメッセージキャリア
	 * @param setKey 設定先メッセージキャリアのキー名
	 * @param inMap ユーザデータ情報
	 * @param prefix ユーザデータ情報より取得する場合に付加するプレフィックス
	 * @param getKey ユーザデータ情報より取得するキー名
	 */
	protected void setTemplate(CAANMsg template, String setKey, HashMap<String, Object> inMap, String prefix, String getKey)
	{
		
		if (null == inMap || null == inMap.get(prefix + getKey) || 0 == ((String)inMap.get(prefix + getKey)).length())
		{
			template.setNull(setKey);
		}
		else
		{
			template.set(setKey, (String)inMap.get(prefix + getKey));
		}
	}
	
	/**
	 * ユーザデータ情報に値を設定します。<br>
	 * 　�@CAANMsgにデータが存在する場合、CAANMsgのデータを設定します。<br>
	 * 　�A上記以外の場合、空文字を設定します。<br>
	 * @param dataMap 値を設定するユーザデータ情報
	 * @param prefix ユーザデータ情報に設定する際に付加するプレフィックス
	 * @param setKey ユーザデータ情報のキー名
	 * @param template メッセージキャリア
	 * @param getKey メッセージキャリアのキー名
	 */
	protected void setDataMap(HashMap<String, Object> dataMap, String prefix, String setKey, CAANMsg template, String getKey)
	{
		if (template.isNull(getKey))
		{
			dataMap.put(prefix + setKey, "");
		}
		else
		{
			dataMap.put(prefix + setKey, template.getString(getKey));
		}
	}
	
	/**
	 * エラー情報を設定します。<br>
	 * @param inMap ユーザデータ情報
	 * @param prefix ユーザデータ情報に設定する際に付加するプレフィックス
	 * @param setKey ユーザデータ情報のキー名
	 * @param template メッセージキャリア
	 * @param getKey メッセージキャリアのキー名
	 */
	protected void setErrInfo(HashMap<String, Object> inMap, String prefix, String setKey, CAANMsg template, String getKey)
	{
		if (!template.isNull(getKey))
		{
			if (!inMap.containsKey(prefix + setKey))
			{
				inMap.put(prefix + setKey, template.getString(getKey));
			}
		}
	}
// ANK-4346-00-00 ADD START

	/**
	 * コンテンツ契約サービスの下りマッピング
	 * @param map
	 * @param paramMap
	 */
	@SuppressWarnings("unchecked")
	private void editJCNContKeiListInfoCC(List<HashMap<String, Object>> map, HashMap<String, Object> paramMap)
	{
		if (paramMap != null)
		{
			List<Map<String, Object>> inMap = (List<Map<String, Object>>)paramMap.get("cont_kei_list");
			HashMap<String, Object> retMap = new HashMap<String, Object>();
			if (inMap != null)
			{
				// レスポンス設定
				for (Map<String, Object> contInfo : inMap)
				{
					retMap.put("contracts_service_id", contInfo.get("contracts_service_id"));
					retMap.put(CONTENTS_DIVISION, contInfo.get("cont_sbt_cd"));

					if(JCNStrConst.CD01821_KEI.equals(contInfo.get("cont_kei_stat_cd")))
					{
						if(!JCNStringUtil.isNullEmpty(contInfo.get("contract_end_date")))
						{
							// 契約中
							retMap.put(CONTRACT_FLG, "1");
						}
						else
						{
							// 解約済み
							retMap.put(CONTRACT_FLG, "0");
						}
					}
					else
					{
						// 契約中
						retMap.put(CONTRACT_FLG, contInfo.get("cont_kei_stat_cd"));
					}
					
				}
			}
			map.add(retMap);
		}
	}

	/**
	 * コンテンツ解約のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoECNA0240001(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(ECNA0240001CBSMsg.STATUS), returnCode);

		HashMap inMap = (HashMap)param.getData(fixedText);

		// 申込明細情報変更.SYSID → SYSIDのエラー情報返却
		setErrInfo(inMap, "", ECNA0240001CBSMsg.KEY_SYSID_ERR, template, ECNA0240001CBSMsg.KEY_SYSID_ERR);

		// 申込明細情報変更.メール送信フラグ → メール送信フラグのエラー情報返却
		setErrInfo(inMap, "", ECNA0240001CBSMsg.MAIL_SEND_FLG_ERR, template, ECNA0240001CBSMsg.MAIL_SEND_FLG_ERR);
		
		// 申込明細情報変更.更新者ID → 更新者IDのエラー情報返却
		setErrInfo(inMap, "", ECNA0240001CBSMsg.UPDATE_ID_ERR, template, ECNA0240001CBSMsg.UPDATE_ID_ERR);

		// 申込明細情報変更.更新者 → 更新者のエラー情報返却
		setErrInfo(inMap, "", ECNA0240001CBSMsg.UPDATE_NAME_ERR, template, ECNA0240001CBSMsg.UPDATE_NAME_ERR);

		return param;
	}
	
	/**
	 * ユーザデータ情報にコンテンツ解約のステータスを設定します。<br>
	 * 　�@CAANMsgにデータが存在する場合、CAANMsgのデータを設定します。<br>
	 * 　�A上記以外の場合、空文字を設定します。<br>
	 * @param dataMap 値を設定するユーザデータ情報
	 * @param prefix ユーザデータ情報に設定する際に付加するプレフィックス
	 * @param setKey ユーザデータ情報のキー名
	 * @param template メッセージキャリア
	 * @param getKey メッセージキャリアのキー名
	 */
	protected void setDataMapCont(HashMap<String, Object> dataMap, String prefix, String setKey, CAANMsg template, String getKey)
	{
		if (template.isNull(getKey))
		{
			dataMap.put(prefix + setKey, "");
		}
		else
		{
			dataMap.put(prefix + setKey, template.getInt(getKey));
		}
	}
// ANK-4346-00-00 ADD END 

}