/*********************************************************************
*	All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名		：eo顧客基幹システム
*   モジュール名    ：JKKVhMskmInfoUpdCC
*   ソースファイル名：JKKVhMskmInfoUpdCC.java
*	作成者			：FJ
*	日付			：2017年04月11日
*＜機能概要＞
*	訪販申込情報更新受付CC
*＜修正履歴＞
*   バージョン  修正日       修正者      修正内容
*   v1.00.00    2017/04/11   FJ）宮下    新規作成 
*   v29.00.00	2017/04/28   FJ)舘山	【IT2-2017-0000004】電気の申込書番号で更新できない
*   v29.00.01	2017/05/08   FJ)舘山	【IT1-2017-0000037】１つ前の値が引き継がれない
*   v33.00.00	2017/10/18   FJ)柳		【ANK-3307-00-00】訪販申込情報閲覧システム向けAPIへの工事進捗・キャンセル状況取得機能追加
*	v52.00.00   2021/01/17   FJ)星野 	【ANK-3910-00-00】定額サービスリース品追加対応
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

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

import com.fujitsu.futurity.bp.custom.constant.JKKSvcConst;
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.ErrorLevel;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadWrite;
import com.fujitsu.futurity.bp.x21.bpm.parameter.StatusArea;
import com.fujitsu.futurity.bp.x21.bpm.parameter.StatusInfo;
import com.fujitsu.futurity.bp.x21.cc.AbstractCommonComponent;
import com.fujitsu.futurity.bp.x21.cc.exception.SCCallException;
import com.fujitsu.futurity.bp.x21.values.OUTBREAK_AREA;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.SCControlMapKeys;
import com.fujitsu.futurity.mapping.bp.common.TemplateErrorUtil;
import com.fujitsu.futurity.model.base.CAANMsg;
import com.fujitsu.futurity.model.common.JCMAPLConstMgr;
import com.fujitsu.futurity.model.common.check.CharacterCheck;
import com.fujitsu.futurity.model.common.check.HalfCharCheck;
import com.fujitsu.futurity.model.common.check.LengthCheck;
import com.fujitsu.futurity.model.ejb.common.JSYejbLog;

import eo.common.constant.JPCModelConstant;
import eo.common.util.JKKCommonUtil;

import eo.ejb.cbs.cbsmsg.EKK0011A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0011A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0011B504CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0011B504CBSMsg4List;
import eo.ejb.cbs.cbsmsg.EKK0011D020CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0011D020CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0021B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0021B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B526CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B526CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0011C020CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081C060CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0321B005CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0441A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0441A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0441B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0441B002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK3101B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK3101B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK3101C010CBSMsg;


/**
 * 訪販申込情報更新受付CC
 * @author FJ
 *
 */
public class JKKVhMskmInfoUpdCC extends AbstractCommonComponent 
{
	/**
	 * テンプレートID
	 */
	private static final String TEMPLATE_ID_MSKM_ICHIRAN_SHOKAI = "EKK0011B504";
	
// ▼▼▼ IT2-2017-0000004 2017-04-28 ADD START
	/**
	 * テンプレートID 申込書番号指定一覧照会
	 */	
	private static final String TEMPLATE_ID_EKK0021B001 = "EKK0021B001";
	
// △△△ IT2-2017-0000004 2017-04-28 ADD END
	/**
	 * テンプレートID
	 */
	private static final String TEMPLATE_ID_MSKM_ICHI_SHOKAI = "EKK0011A010";
	/**
	 * テンプレートID
	 */
	private static final String TEMPLATE_ID_MSKM_NAIYO_HENKO = "EKK0011C020";
	
	// ANK-3307-00-00 2017/10/18 ADD START
	/** テンプレートID　他システム連携用申込実績一覧照会 */
	private static final String TEMPLATE_ID_EKK3101B010 = "EKK3101B010";
	
	/** テンプレートID　他システム連携用申込実績更新 */
	private static final String TEMPLATE_ID_EKK3101C010 = "EKK3101C010";
	// ANK-3307-00-00 2017/10/18 ADD END
	
	/** IN 機能コード */
	private static final String IN_FUNC_CD = "func_code";
	
	/** IN 受付番号 */
	private static final String IN_UK_NO = "uk_no";
	
	/** IN 更新対象項目 */
	private static final String IN_UPD_TRGT_KMK = "upd_trgt_kmk";
	
	/** 機能コード 桁数 1桁 */
	private static final int FUNC_CODE_LEN = 1;
	
	/** 受付番号 桁数 10桁 */
	private static final int UK_NO_LEN = 10;
	
	/** 更新対象項目 桁数 1桁 */
	private static final int UPD_TRGT_KMK_LEN  = 1;
	
	/** 結果コード パラメータ不正エラー */
	private static final String RETURN_CD_92 = "92";
	
	/** ステータス パラメータ不正エラー */
	private static final String STAT_92 = "パラメータ不正エラー";
	
	/** エラー項目の末尾文字列 */
	private static final String ITEM_ERR_END = "_err";
	
	/** 必須チェックエラーフラグ */
	private static final String INDI_ERR = "E1";
	
	/** ドメインチェックエラーフラグ */
	private static final String DMN_ERR = "E2";
	
	/** 桁数チェックエラーフラグ  */
	private static final String KETA_ERR = "E3";
	
	/** リファレンスチェックエラーフラグ  */
	private static final String RIFA_ERR = "E4";
	
	// ANK-3307-00-00 2017/10/18 ADD START
	/** 正常 */
	private static final String NORMAL = "0000";
	// ANK-3307-00-00 2017/10/18 ADD END
	
	/** 単項目チェックエラー */
	private static final String SINGLE_ITEM_ERR = "1000";
	
	/**	単項目関連チェックエラー	*/
	public static final String ITEM_RELATION_ERR = "1050";
	
	/** エラーメッセージ 単項目チェックエラー */
	private static final String MSG_SINGLE_ITEM_ERR = "単項目チェックエラー";
	
	/** エラーメッセージ 単項目関連チェックエラー */
	private static final String MSG_ITEM_RELATION_ERR = "単項目関連チェックエラー";
	
	/** OUT リターンコード */
	private static final String OUT_RETURN_CODE = "return_code";

	/**
	 * 訪販申込情報更新受付
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws Throwable 
	 */
	public IRequestParameterReadWrite updVhMskmInfo(SessionHandle handle, 
			IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		HashMap<String, Object> workMap = new HashMap<String, Object>();
		
		// データを取得する。
		HashMap inParamMap = (HashMap)param.getData(fixedText);

		// 単項目チェック、単項目関連チェック処理
		if(errCheck(handle, param, fixedText, inParamMap))
		{
			// ANK-3307-00-00 2017/10/18 ADD START
			// 更新対象項目
			String updTrgtKmk = (String)inParamMap.get(IN_UPD_TRGT_KMK);
			
			// 更新対象項目が1：サンキューコール実施年月日の場合
			if ("1".equals(updTrgtKmk))
			{
			// ANK-3307-00-00 2017/10/18 ADD END
				// 申込番号取得処理
				getMskmNo(handle, param, fixedText, workMap);
				
				// 引き渡された受付番号（申込書番号）に紐付くデータが存在するかの確認
				if(CharacterCheck.isNotNullCheck((String)workMap.get("mskm_no")))
				{
					// 申込情報取得処理
					shokaiMskmInfo(handle, param, fixedText, workMap);
					
					// 申込内容変更処理
					chgMskmNaiyo(handle, param, fixedText, workMap);
					
					// 訪販申込情報閲覧システム返却パラメータ設定処理
					setHomskmRtnParam(param, fixedText, workMap);
				}
				// 存在しなかった場合、ＫＥＹ＿受付番号のリファレンスエラーとする
				else
				{
					// E4設定する
					inParamMap.put(IN_UK_NO + ITEM_ERR_END, RIFA_ERR);
					
					// ステータスエリア編集
					StatusArea sa = param.getStatusArea();
					StatusInfo si = new StatusInfo(ErrorLevel.EL888, OUTBREAK_AREA.CC);
					sa.setCurrent(si);
					
					// リターンコード編集
					param.setControlMapData(SCControlMapKeys.RETURN_CODE, SINGLE_ITEM_ERR);
					
					// リターンメッセージ編集
					param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, MSG_SINGLE_ITEM_ERR);
					
					// リクエストパラメータに結果を格納
					param.removeData(fixedText);
					param.setData(fixedText, inParamMap);
				}
			// ANK-3307-00-00 2017/10/18 ADD START
			}
			else
			{
				// 他システム連携用申込実績情報取得処理
				stkuTsyrnYoMsjkInfo(handle, param, inParamMap, fixedText, workMap);
				
				// 他システム連携用申込実績更新処理
				updTsyrnYoMsjkInfo(handle, param, inParamMap, fixedText, workMap);
				
				// 訪販申込情報閲覧システム返却パラメータ設定処理
				setHomskmRtnParam(param, fixedText, workMap);
			}
			// ANK-3307-00-00 2017/10/18 ADD END
		}
		
		return param;
	}

	/**
	 * 
	 * @param param
	 * @param handle
	 * @param template
	 * @return
	 * @throws Throwable
	 */
	private CAANMsg[] callScCmn(
			IRequestParameterReadWrite param,
			SessionHandle handle,
			CAANMsg template,
			JKKSIFMapperBase mapper,
			String fixedText
	) throws Throwable
	{
		HashMap<String, Object> sIFRequest = null;
		CAANMsg[] resultMsgs = null;
		Map<?, ?> sIFResult = null;

		//テンプレート共通情報を設定
		mapper.editTemplateCommon(param, template);
		
		// サービスIF共通の情報を設定
		sIFRequest = mapper.editInMsgCmn(param);

		// リクエスト用クラスの設定
		sIFRequest.put(JCMConstants.TEMPLATE_LIST_KEY, new CAANMsg[]{template});

		// SIFの呼び出し
		sIFResult = (new ServiceComponentRequestInvoker()).run(sIFRequest, handle);

		// 結果の取得
		resultMsgs = (CAANMsg[])sIFResult.get(JCMConstants.TEMPLATE_LIST_KEY);

		// エラー情報のマッピング
		editResultRP(sIFResult, param, fixedText);

		errChk(sIFResult);

		// リターンコード取得
		int returnCode = (Integer)sIFResult.get(JCMConstants.RET_CD_INT_KEY);
		if (returnCode != 0) {
			throw new Exception();
		}

		return resultMsgs;
	}


	/**
	 * <pre>
	 * サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 * 
	 * </pre>
	 * @param msgList CAANMsgクラス
	 * @param param 業務データ取得・書込用I/F
	 * @param fixedText ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editResultRP(
			Map<?, ?> msgList,
			IRequestParameterReadWrite param, String fixedText) 
			throws Throwable 
	{
		/* ユーザデータ情報 */
		HashMap<String, Object> inMap = (HashMap<String, Object>) param.getData(fixedText);
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

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

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

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

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

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

		// ユーザデータ情報にエラー情報をマッピング
		Map<String, Object> contentsMap = template.getMsgData();
		Object[] contents = contentsMap.keySet().toArray();
		for(int i = 0 ; contents != null && i < contents.length ; i++)
		{
			String element = null;
			element = (String)contents[i];
			if (element.indexOf("_err") > 0)
			{
				if (!template.isNull(element))
				{
					//‘key_’を除く
					String e = element.replaceFirst("key_", "");
					// エラーフラグのセット
					inMap.put(e, template.getString(element));
				}
			}
		}

		return param;
	}


	/**
	 * エラーチェック処理です。
	 * <br>
	 * @param msgList サービスインタフェース実行結果
	 * @return void
	 * @throws Exception 
	 */
	private void errChk(Map<?, ?> msgList) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		// リターンコード取得
		Integer returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// ステータス取得
		int templateStatus = template.getInt(JCMConstants.STATUS_INT_KEY);
		
		if ((0 != returnCode.intValue()) || (0 != templateStatus))
		{
			String errMsg = "INVALID_ERROR_OCCURED";
			throw new SCCallException(errMsg, String.valueOf(returnCode), templateStatus);
		}
	}


	/**
	 * メッセージ共通部設定処理
	 * @param param
	 * @param paramMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsg(IRequestParameterReadWrite param, HashMap<String, Object> paramMap) throws RequestParameterException
	{
		// 電文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;
	}
	
	/**
	 * <pre>
	 * サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 * 
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @param workMap 
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode, HashMap<String, Object> workMap) throws RequestParameterException
	{
		CAANMsg template = templates[0];
		
		int templateStatus = template.getInt(JCMConstants.STATUS_INT_KEY);
		
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}
		
		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		
		return param;
	}
	
	
	/**
	 * 
	 * 単項目チェック、単項目関連チェックを実施する
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param workMap
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private boolean errCheck(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> workMap) throws Exception
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(fixedText);
		if (null == ccMsg)
		{
			ccMsg = new HashMap<String, Object>();
			param.setData(fixedText, ccMsg);
		}
		
		// 機能コードの取得
		String funcCode = "";
		if (ccMsg.containsKey("func_code"))
		{
			funcCode = (String)ccMsg.get("func_code");
		}
		
		// 受付番号の取得
		String ukNo = "";
		if (ccMsg.containsKey("uk_no"))
		{
			ukNo = (String)ccMsg.get("uk_no");
		}
		
		// 更新対象項目の取得
		String updTrgtKmk = "";
		if (ccMsg.containsKey("upd_trgt_kmk"))
		{
			updTrgtKmk = (String)ccMsg.get("upd_trgt_kmk");
		}
		/** 単項目チェック */
		if (isErrInParam(funcCode, ukNo, updTrgtKmk, workMap))
		{	
//			// パラメータ不正エラーを設定
//			workMap.put(OUT_RETURN_CODE, RETURN_CD_92);
//			// ログ出力(パラメータ不正エラー)
//			outputBusLog(workMap, STAT_92);
//			
			// ステータスエリア編集
			StatusArea sa = param.getStatusArea();
			StatusInfo si = new StatusInfo(ErrorLevel.EL888, OUTBREAK_AREA.CC);
			sa.setCurrent(si);
			
			// リターンコード編集
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, SINGLE_ITEM_ERR);
			
			// リターンメッセージ編集
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, MSG_SINGLE_ITEM_ERR);
			
			// リクエストパラメータに結果を格納
			param.removeData(fixedText);
			param.setData(fixedText, workMap);
			
			return false;
		}
		
		/** 単項目関連チェック */
		if (isErrInParam2(updTrgtKmk, workMap))
		{
//			// パラメータ不正エラーを設定
//			workMap.put(OUT_RETURN_CODE, RETURN_CD_92);
//			// ログ出力(パラメータ不正エラー)
//			outputBusLog(workMap, STAT_92);
			
			// ステータスエリア編集
			StatusArea sa = param.getStatusArea();
			StatusInfo si = new StatusInfo(ErrorLevel.EL888, OUTBREAK_AREA.CC);
			sa.setCurrent(si);
			
			// リターンコード編集
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, ITEM_RELATION_ERR);
			
			// リターンメッセージ編集
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, MSG_ITEM_RELATION_ERR);
			
			// リクエストパラメータに結果を格納
			param.removeData(fixedText);
			param.setData(fixedText, workMap);
			
			return false;
		}
		
		return true;
	}
	
	/**
	 * 
	 * 申込番号の取得を行う
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param workMap
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void getMskmNo(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> workMap) throws Exception
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		
// ▼▼▼ IT2-2017-0000004 2017-04-28 Modify START 
//		// 申込一意照会上りマッピング
//		paramMap = editEKK0011B504InMsg(param, paramMap, fixedText);
		// 申込一意照会上りマッピング
		paramMap = editEKK0021B001InMsg(param, paramMap, fixedText);
// △△△ IT2-2017-0000004 2017-04-28 Modify END 
		
		// SC呼び出しクラスの生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// SIFの呼び出し
		Map<?, ?> result = scCall.run(paramMap, handle);
		
// ▼▼▼ IT2-2017-0000004 2017-04-28 Modify START 
//		// 申込情報一意照会下りマッピング
//		IRequestParameterReadWrite rtnParam = editEKK0011B504OutMsg(result, param, fixedText, workMap);
		// 申込書番号指定一覧照会下りマッピング
		IRequestParameterReadWrite rtnParam = editEKK0021B001OutMsg(result, param, fixedText, workMap);
// △△△ IT2-2017-0000004 2017-04-28 Modify END 
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)rtnParam.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}
	}
	
	/**
	 * 申込情報一意照会上りマッピング
	 * @param param
	 * @param paramMap
	 * @param fixedText
	 * @param workMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editEKK0011B504InMsg(IRequestParameterReadWrite param, HashMap<String, Object> paramMap, 
			String fixedText) throws RequestParameterException
	{
		// メッセージ共通部設定処理
		paramMap = editInMsg(param, paramMap);
		
		/* ユーザデータ情報 */
		HashMap inMap = (HashMap)param.getData(fixedText);
		
		CAANMsg template = new CAANMsg(EKK0011B504CBSMsg.class.getName());
		// テンプレートID
		template.set(EKK0011B504CBSMsg.TEMPLATEID, TEMPLATE_ID_MSKM_ICHIRAN_SHOKAI);
		// 機能コード（"1"固定）
		template.set(EKK0011B504CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		// 検索処理パターン
		template.set(EKK0011B504CBSMsg.SEARCH_TYPE, inMap.get(EKK0011B504CBSMsg.SEARCH_TYPE));
		// 最大検索件数
		template.set(EKK0011B504CBSMsg.MAX_SEARCH_NUM, "10");
		// 表示件数
		template.set(EKK0011B504CBSMsg.DISPLAY_NUM, "10");
		// 表示ページ番号
		template.set(EKK0011B504CBSMsg.DISPLAY_PAGE_NUM, "1");
		// オペレータID
		template.set(EKK0011B504CBSMsg.OPERATORID, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		// 運用日付
		template.set(EKK0011B504CBSMsg.OPERATEDATE, param.getControlMapData(SCControlMapKeys.OPE_DATE));
		// 運用日時
		template.set(EKK0011B504CBSMsg.OPERATEDATETIME,  param.getControlMapData(SCControlMapKeys.OPE_TIME));
		
		// ＫＥＹ＿申込書番号
		template.set(EKK0011B504CBSMsg.KEY_MSKMSHO_NO, inMap.get("uk_no"));
		// ＫＥＹ＿運用日付
		template.set(EKK0011B504CBSMsg.KEY_UNYO_YMD, JKKBpCommon.getOpeDate(null));
		// ＫＥＹ＿ソート項目No
		template.set(EKK0011B504CBSMsg.KEY_SORT_ITEM_NO, "0");
		// ＫＥＹ＿ソート区分
		template.set(EKK0011B504CBSMsg.KEY_SORT_DIV, "1");
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	/**
	 * 申込情報一意照会下りマッピング
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param workMap
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editEKK0011B504OutMsg(Map<?, ?> msgList, IRequestParameterReadWrite param, 
			String fixedText, HashMap<String, Object> workMap) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 結果を詰めるマップを取得。
		HashMap<String, Object> dataMap = null;
		ArrayList dataList = null;

		/* 業務データ設定 */
		dataMap = (HashMap<String, Object>)param.getData(fixedText);
		
		if(dataMap == null) 
		{
			dataMap = new HashMap<String, Object>();
			param.setData(fixedText, dataMap);
		}
		
		templateArray = parentTemplate.getCAANMsgList(EKK0011B504CBSMsg.EKK0011B504CBSMSG4LIST);
		dataList = (ArrayList)dataMap.get("EKK0011B504CBSMsg4List");

		if (dataList == null) 
		{
			dataList = new ArrayList();
		}
		
		if (templateArray != null) 
		{
			for(int i = 0; i < templateArray.length; i++) 
			{
				
				CAANMsg childTemplate = templateArray[i];
				if(i >= dataList.size())
				{
					dataList.add(new HashMap<String, Object>());
				}
				HashMap<String, Object> childMap = (HashMap<String, Object>)dataList.get(i);
				
				// 申込番号
				if (childTemplate.isNull(EKK0011B504CBSMsg4List.MSKM_NO)) 
				{
					workMap.put("mskm_no", "");
				} 
				else 
				{
					workMap.put("mskm_no", childTemplate.getString(EKK0011B504CBSMsg4List.MSKM_NO));
				}

			}
		}

		// エラー情報の設定
		IRequestParameterReadWrite rtnParam = editErrorInfo(param, templates, (Integer)return_code, workMap);
		rtnParam = editEKK0011B504ErrorInfo(rtnParam, templates, fixedText);

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

		return rtnParam;
	}
	
	/**
	 * <pre>
	 * 申込情報一意照会のエラー情報マッピング処理
	 * 
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	public IRequestParameterReadWrite editEKK0011B504ErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, String fixedText)
			throws Exception
	{
		CAANMsg template = templates[0];
		
		// テンプレートID取得
		String templateId = template.getString(JCMConstants.TEMPLATE_ID_KEY);
		
		/* ユーザデータ情報 */
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// ユーザデータ情報にエラー情報をマッピング
		Object[][] contents = null;
		
		if (TEMPLATE_ID_MSKM_ICHIRAN_SHOKAI.equals(templateId))
		{
			contents = new EKK0011B504CBSMsg().getContents();
		}
		
		for (int i = 0; contents != null && i < contents.length; i++)
		{
			String element = null;
			element = (String)contents[i][0];
			if (element.indexOf("_err") > 0)
			{
				if (!template.isNull(element))
				{
					if (!inMap.containsKey(element))
					{
						String e = element.replaceFirst("key_", "");
						inMap.put(e, template.getString(element));
					}
				}
			}
		}
		
		return param;
	}
	
	/**
	 * 
	 * 申込情報取得処理を行う
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param workMap
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void shokaiMskmInfo(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> workMap) throws Exception
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		
		// 申込情報取得上りマッピング
		paramMap = editEKK0011A010InMsg(param, paramMap, fixedText, workMap);
		
		// SC呼び出しクラスの生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// SIFの呼び出し
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// 申込情報取得下りマッピング
		IRequestParameterReadWrite rtnParam = editEKK0011A010OutMsg(result, param, fixedText, workMap);
		
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)rtnParam.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}
	}

	/**
	 * 申込一意照会上りマッピング
	 * @param param
	 * @param paramMap
	 * @param fixedText
	 * @param workMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editEKK0011A010InMsg(IRequestParameterReadWrite param, HashMap<String, Object> paramMap, 
			String fixedText, HashMap<String, Object> workMap) throws RequestParameterException
	{
		// メッセージ共通部設定処理
		paramMap = editInMsg(param, paramMap);
		
		/* ユーザデータ情報 */
		HashMap inMap = (HashMap)param.getData(fixedText);
		
		CAANMsg template = new CAANMsg(EKK0011A010CBSMsg.class.getName());
		// テンプレートID
		template.set(EKK0011A010CBSMsg.TEMPLATEID, TEMPLATE_ID_MSKM_ICHI_SHOKAI);
		// 機能コード：("2"固定)
		template.set(EKK0011A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);
		// オペレータID
		template.set(EKK0011A010CBSMsg.OPERATORID, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		// 運用日付
		template.set(EKK0011A010CBSMsg.OPERATEDATE, param.getControlMapData(SCControlMapKeys.OPE_DATE));
		// 運用日時
		template.set(EKK0011A010CBSMsg.OPERATEDATETIME,  param.getControlMapData(SCControlMapKeys.OPE_TIME));
		
		// ＫＥＹ＿申込番号
		template.set(EKK0011A010CBSMsg.KEY_MSKM_NO, workMap.get("mskm_no"));
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}

	/**
	 * 申込一意照会下りマッピング
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param workMap
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editEKK0011A010OutMsg(Map<?, ?> msgList, IRequestParameterReadWrite param, 
			String fixedText, HashMap<String, Object> workMap) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 結果を詰めるマップを取得。
		HashMap<String, Object> dataMap = null;
		ArrayList dataList = null;

		/* 業務データ設定 */
		dataMap = (HashMap<String, Object>)param.getData(fixedText);
		
		if(dataMap == null) 
		{
			dataMap = new HashMap<String, Object>();
			param.setData(fixedText, dataMap);
		}
		
		templateArray = parentTemplate.getCAANMsgList(EKK0011A010CBSMsg.EKK0011A010CBSMSG1LIST);
		dataList = (ArrayList)dataMap.get("EKK0011A010CBSMsg1List");

		if (dataList == null) 
		{
			dataList = new ArrayList();
		}
		
		if (templateArray != null) 
		{
			for(int i = 0; i < templateArray.length; i++) 
			{
				
				CAANMsg childTemplate = templateArray[i];
				if(i >= dataList.size())
				{
					dataList.add(new HashMap<String, Object>());
				}
				HashMap<String, Object> childMap = (HashMap<String, Object>)dataList.get(i);
				
				// 申込種別コード
				if (childTemplate.isNull(EKK0011A010CBSMsg1List.MSKM_SBT_CD)) 
				{
					workMap.put("mskm_sbt_cd", "");
				} 
				else 
				{
					workMap.put("mskm_sbt_cd", childTemplate.getString(EKK0011A010CBSMsg1List.MSKM_SBT_CD));
				}
				
				// 申込受付年月日時分秒
				if (childTemplate.isNull(EKK0011A010CBSMsg1List.MSKM_UK_DTM)) 
				{
					workMap.put("mskm_uk_dtm", "");
				} 
				else 
				{
					workMap.put("mskm_uk_dtm", childTemplate.getString(EKK0011A010CBSMsg1List.MSKM_UK_DTM));
				}
				
				// 申込年月日
				if (childTemplate.isNull(EKK0011A010CBSMsg1List.MSKM_YMD)) 
				{
					workMap.put("mskm_ymd", "");
				} 
				else 
				{
					workMap.put("mskm_ymd", childTemplate.getString(EKK0011A010CBSMsg1List.MSKM_YMD));
				}
				
				// 	更新年月日時分秒
				if (childTemplate.isNull(EKK0011A010CBSMsg1List.UPD_DTM)) 
				{
					workMap.put("upd_dtm", "");
				} 
				else 
				{
					workMap.put("upd_dtm", childTemplate.getString(EKK0011A010CBSMsg1List.UPD_DTM));
				}
				
			 	// サンキューコール実施日
				if (childTemplate.isNull(EKK0011A010CBSMsg1List.THNX_CALL_JSSI_YMD)) 
				{
					workMap.put("thnx_call_jssi_ymd", "");
				} 
				else 
				{
					workMap.put("thnx_call_jssi_ymd", childTemplate.getString(EKK0011A010CBSMsg1List.THNX_CALL_JSSI_YMD));
				}
				
// ANK-3307-00-00 2017/10/18 DEL START
//				// 申込キャンセル除外承認申請年月日
//				if (childTemplate.isNull(EKK0011A010CBSMsg1List.MSKM_CNCL_JGI_SNN_SHIN_YMD)) 
//				{
//					workMap.put("mskm_cncl_jgi_snn_shin_ymd", "");
//				} 
//				else 
//				{
//					workMap.put("mskm_cncl_jgi_snn_shin_ymd", childTemplate.getString(EKK0011A010CBSMsg1List.MSKM_CNCL_JGI_SNN_SHIN_YMD));
//				}
//				
//				// 申込キャンセル除外承認年月日
//				if (childTemplate.isNull(EKK0011A010CBSMsg1List.MSKM_CNCL_JGI_SNN_YMD)) 
//				{
//					workMap.put("mskm_cncl_jgi_snn_ymd", "");
//				} 
//				else 
//				{
//					workMap.put("mskm_cncl_jgi_snn_ymd", childTemplate.getString(EKK0011A010CBSMsg1List.MSKM_CNCL_JGI_SNN_YMD));
//				}
//				
//				// 申込キャンセル除外否認年月日
//				if (childTemplate.isNull(EKK0011A010CBSMsg1List.MSKM_CNCL_JGI_HNN_YMD)) 
//				{
//					workMap.put("mskm_cncl_jgi_hnn_ymd", "");
//				} 
//				else 
//				{
//					workMap.put("mskm_cncl_jgi_hnn_ymd", childTemplate.getString(EKK0011A010CBSMsg1List.MSKM_CNCL_JGI_HNN_YMD));
//				}
// ANK-3307-00-00 2017/10/18 DEL END
// ▼▼▼ IT1-2017-0000037 ADD START
				// 申込書到着年月日	MSKMSHO_ARIV_YMD
				workMap.put(EKK0011A010CBSMsg1List.MSKMSHO_ARIV_YMD, getValue(childTemplate, EKK0011A010CBSMsg1List.MSKMSHO_ARIV_YMD));
				// 申込受付担当ユーザーID	MSKM_UK_TNT_USER_ID
				workMap.put(EKK0011A010CBSMsg1List.MSKM_UK_TNT_USER_ID, getValue(childTemplate, EKK0011A010CBSMsg1List.MSKM_UK_TNT_USER_ID));
				// 総合営業申込契機コード	TTL_BUSINESS_MSKM_OPT_CD
				workMap.put(EKK0011A010CBSMsg1List.TTL_BUSINESS_MSKM_OPT_CD, getValue(childTemplate, EKK0011A010CBSMsg1List.TTL_BUSINESS_MSKM_OPT_CD));
				// 申込連絡先電話番号	MSKM_RRKS_TELNO
				workMap.put(EKK0011A010CBSMsg1List.MSKM_RRKS_TELNO, getValue(childTemplate, EKK0011A010CBSMsg1List.MSKM_RRKS_TELNO));
				// 申込実施者種別コード	MSKM_JSSIS_SBT_CD
				workMap.put(EKK0011A010CBSMsg1List.MSKM_JSSIS_SBT_CD, getValue(childTemplate, EKK0011A010CBSMsg1List.MSKM_JSSIS_SBT_CD));
				// お客様ご要望事項	CUST_YOBO_JIKO
				workMap.put(EKK0011A010CBSMsg1List.CUST_YOBO_JIKO, getValue(childTemplate, EKK0011A010CBSMsg1List.CUST_YOBO_JIKO));
				// 電話連絡希望日種別コード	TEL_RRK_KIBOD_SBT_CD
				workMap.put(EKK0011A010CBSMsg1List.TEL_RRK_KIBOD_SBT_CD, getValue(childTemplate, EKK0011A010CBSMsg1List.TEL_RRK_KIBOD_SBT_CD));
				// 電話連絡希望時間帯コード	TEL_RRK_KIBO_TIME_CD
				workMap.put(EKK0011A010CBSMsg1List.TEL_RRK_KIBO_TIME_CD, getValue(childTemplate, EKK0011A010CBSMsg1List.TEL_RRK_KIBO_TIME_CD));
				// 宅内調査希望日種別コード	TAKCHO_KIBOD_SBT_CD
				workMap.put(EKK0011A010CBSMsg1List.TAKCHO_KIBOD_SBT_CD, getValue(childTemplate, EKK0011A010CBSMsg1List.TAKCHO_KIBOD_SBT_CD));
				// 宅内調査希望時間帯コード	TAKCHO_KIBO_TIME_CD
				workMap.put(EKK0011A010CBSMsg1List.TAKCHO_KIBO_TIME_CD, getValue(childTemplate, EKK0011A010CBSMsg1List.TAKCHO_KIBO_TIME_CD));
				// リファラー	REFERER
				workMap.put(EKK0011A010CBSMsg1List.REFERER, getValue(childTemplate, EKK0011A010CBSMsg1List.REFERER));
				// 関西電力お客様情報授受同意有無	KEPCO_CUSTINFO_JUJU_DOI_UM
				workMap.put(EKK0011A010CBSMsg1List.KEPCO_CUSTINFO_JUJU_DOI_UM, getValue(childTemplate, EKK0011A010CBSMsg1List.KEPCO_CUSTINFO_JUJU_DOI_UM));
				// 照査前連絡事項要否	SHOSA_BF_RRK_JIKO_YH
				workMap.put(EKK0011A010CBSMsg1List.SHOSA_BF_RRK_JIKO_YH, getValue(childTemplate, EKK0011A010CBSMsg1List.SHOSA_BF_RRK_JIKO_YH));
				// 照査前連絡事項	SHOSA_BF_RRK_JIKO
				workMap.put(EKK0011A010CBSMsg1List.SHOSA_BF_RRK_JIKO, getValue(childTemplate, EKK0011A010CBSMsg1List.SHOSA_BF_RRK_JIKO));
				// 利用サービス継続種別コード	USE_SVC_KEIZK_SBT_CD
				workMap.put(EKK0011A010CBSMsg1List.USE_SVC_KEIZK_SBT_CD, getValue(childTemplate, EKK0011A010CBSMsg1List.USE_SVC_KEIZK_SBT_CD));
				// 受付担当者識別コード	UK_TNTSHA_SKBT_CD
				workMap.put(EKK0011A010CBSMsg1List.UK_TNTSHA_SKBT_CD, getValue(childTemplate, EKK0011A010CBSMsg1List.UK_TNTSHA_SKBT_CD));
				// 工事依頼情報連絡事項	KOJI_REQ_INFO_RRK_JIKO
				workMap.put(EKK0011A010CBSMsg1List.KOJI_REQ_INFO_RRK_JIKO, getValue(childTemplate, EKK0011A010CBSMsg1List.KOJI_REQ_INFO_RRK_JIKO));
				// 提携住宅会社コード	TKJCP_CD
				workMap.put(EKK0011A010CBSMsg1List.TKJCP_CD, getValue(childTemplate, EKK0011A010CBSMsg1List.TKJCP_CD));
				// 提携住宅会社名	TKJCP_NM
				workMap.put(EKK0011A010CBSMsg1List.TKJCP_NM, getValue(childTemplate, EKK0011A010CBSMsg1List.TKJCP_NM));
				// 提携住宅会社支店・営業所名	TKJCP_STNEGS_NM
				workMap.put(EKK0011A010CBSMsg1List.TKJCP_STNEGS_NM, getValue(childTemplate, EKK0011A010CBSMsg1List.TKJCP_STNEGS_NM));
				// 提携住宅会社担当者名	TKJCPTTS_NM
				workMap.put(EKK0011A010CBSMsg1List.TKJCPTTS_NM, getValue(childTemplate, EKK0011A010CBSMsg1List.TKJCPTTS_NM));
				// 提携住宅会社担当者職種名	TKJCPTTS_SHKSNM
				workMap.put(EKK0011A010CBSMsg1List.TKJCPTTS_SHKSNM, getValue(childTemplate, EKK0011A010CBSMsg1List.TKJCPTTS_SHKSNM));
				// 提携住宅会社担当者電話番号	TKJCPTTS_TLN
				workMap.put(EKK0011A010CBSMsg1List.TKJCPTTS_TLN, getValue(childTemplate, EKK0011A010CBSMsg1List.TKJCPTTS_TLN));
				// 分譲地名	BUNJOCHI_NM
				workMap.put(EKK0011A010CBSMsg1List.BUNJOCHI_NM, getValue(childTemplate, EKK0011A010CBSMsg1List.BUNJOCHI_NM));
				// 分譲地区画番号メモ	BUNJOCHI_KKK_NO_MEMO
				workMap.put(EKK0011A010CBSMsg1List.BUNJOCHI_KKK_NO_MEMO, getValue(childTemplate, EKK0011A010CBSMsg1List.BUNJOCHI_KKK_NO_MEMO));
				// 入居予定時期	NYUKYO_RSV_JK
				workMap.put(EKK0011A010CBSMsg1List.NYUKYO_RSV_JK, getValue(childTemplate, EKK0011A010CBSMsg1List.NYUKYO_RSV_JK));
				// 代理店申込受付EOスタッフユーザーＩＤ	AGNT_MKM_UK_EOSTF_USER_ID
				workMap.put(EKK0011A010CBSMsg1List.AGNT_MKM_UK_EOSTF_USER_ID, getValue(childTemplate, EKK0011A010CBSMsg1List.AGNT_MKM_UK_EOSTF_USER_ID));
				// 代理店申込受付量販店員カナ名（姓）	AGNT_MKM_UK_RHSTF_KANA_SEI
				workMap.put(EKK0011A010CBSMsg1List.AGNT_MKM_UK_RHSTF_KANA_SEI, getValue(childTemplate, EKK0011A010CBSMsg1List.AGNT_MKM_UK_RHSTF_KANA_SEI));
// △△△ IT1-2017-0000037 ADD END
// ANK-3910-00-00対応 20210117 星野 ADD START
				// 定額サービス申込機器	TEGAK_SVC_MSKM_KIKI
				workMap.put(EKK0011A010CBSMsg1List.TEGAK_SVC_MSKM_KIKI, getValue(childTemplate, EKK0011A010CBSMsg1List.TEGAK_SVC_MSKM_KIKI));
// ANK-3910-00-00対応 20210117 星野 ADD END
			}
		}

		// エラー情報の設定
		IRequestParameterReadWrite rtnParam = editErrorInfo(param, templates, (Integer)return_code, workMap);
		rtnParam = editEKK0011A010ErrorInfo(rtnParam, templates, fixedText);

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

		return rtnParam;
	}
	
	/**
	 * <pre>
	 * 申込一意照会のエラー情報マッピング処理
	 * 
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	public IRequestParameterReadWrite editEKK0011A010ErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, String fixedText)
			throws Exception
	{
		CAANMsg template = templates[0];
		
		// テンプレートID取得
		String templateId = template.getString(JCMConstants.TEMPLATE_ID_KEY);
		
		/* ユーザデータ情報 */
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		
		
		// ユーザデータ情報にエラー情報をマッピング
		Object[][] contents = null;
		
		if (TEMPLATE_ID_MSKM_ICHIRAN_SHOKAI.equals(templateId))
		{
			contents = new EKK0011B504CBSMsg().getContents();
		}
		
		for (int i = 0; contents != null && i < contents.length; i++)
		{
			String element = null;
			element = (String)contents[i][0];
			if (element.indexOf("_err") > 0)
			{
				if (!template.isNull(element))
				{
					if (!inMap.containsKey(element))
					{
						String e = element.replaceFirst("key_", "");
						inMap.put(e, template.getString(element));
					}
				}
			}
		}
		
		return param;
	}

	/**
	 * 
	 * 申込内容変更を行う
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param workMap
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void chgMskmNaiyo(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> workMap) throws Exception
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		
		// 申込内容変更上りマッピング
		paramMap = editEKK0011C020InMsg(param, paramMap, fixedText, workMap);
		
		// SC呼び出しクラスの生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// SIFの呼び出し
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// 申込内容変更下りマッピング
		IRequestParameterReadWrite rtnParam = editEKK0011C020OutMsg(result, param, fixedText, workMap);
		
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)rtnParam.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}
	}

	/**
	 * 申込内容変更上りマッピング
	 * @param param
	 * @param paramMap
	 * @param fixedText
	 * @param workMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editEKK0011C020InMsg(IRequestParameterReadWrite param, HashMap<String, Object> paramMap, 
			String fixedText, HashMap<String, Object> workMap) throws RequestParameterException
	{
		// メッセージ共通部設定処理
		paramMap = editInMsg(param, paramMap);
		
		/* ユーザデータ情報 */
		HashMap inMap = (HashMap)param.getData(fixedText);
		
//		// 機能コードの取得
//		String funcCode = "";
//		if (inMap.containsKey(IN_FUNC_CD))
//		{
//			funcCode = (String)inMap.get(IN_FUNC_CD);
//			inMap.put(IN_FUNC_CD, funcCode);
//		}
//		
//		// 受付番号の取得
//		String ukNo = "";
//		if (inMap.containsKey(IN_UK_NO))
//		{
//			ukNo = (String)inMap.get(IN_UK_NO);
//			inMap.put(IN_UK_NO, ukNo);
//		}
//		
//		// 更新対象項目の取得
//		String updTrgtKmk = "";
//		if (inMap.containsKey(IN_UPD_TRGT_KMK))
//		{
//			updTrgtKmk = (String)inMap.get(IN_UPD_TRGT_KMK);
//			inMap.put(IN_UPD_TRGT_KMK, updTrgtKmk);
//		}
		
//		/** 単項目チェック */
//		if (isErrInParam(funcCode, ukNo, updTrgtKmk, inMap))
//		{	
//			// パラメータ不正エラーを設定
//			inMap.put(OUT_RETURN_CODE, RETURN_CD_92);
//			// ログ出力(パラメータ不正エラー)
//			outputBusLog(inMap, STAT_92);
//			
//			// ステータスエリア編集
//			StatusArea sa = param.getStatusArea();
//			StatusInfo si = new StatusInfo(ErrorLevel.EL888, OUTBREAK_AREA.CC);
//			sa.setCurrent(si);
//			
//			// リターンコード編集
//			param.setControlMapData(SCControlMapKeys.RETURN_CODE, SINGLE_ITEM_ERR);
//			
//			// リターンメッセージ編集
//			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, MSG_SINGLE_ITEM_ERR);
//		}
//		
//		/** 単項目関連チェック */
//		if (isErrInParam2(updTrgtKmk, inMap))
//		{
//			// パラメータ不正エラーを設定
//			inMap.put(OUT_RETURN_CODE, RETURN_CD_92);
//			// ログ出力(パラメータ不正エラー)
//			outputBusLog(inMap, STAT_92);
//			
//			// ステータスエリア編集
//			StatusArea sa = param.getStatusArea();
//			StatusInfo si = new StatusInfo(ErrorLevel.EL888, OUTBREAK_AREA.CC);
//			sa.setCurrent(si);
//			
//			// リターンコード編集
//			param.setControlMapData(SCControlMapKeys.RETURN_CODE, ITEM_RELATION_ERR);
//			
//			// リターンメッセージ編集
//			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, MSG_ITEM_RELATION_ERR);
//		}
		
		CAANMsg template = new CAANMsg(EKK0011C020CBSMsg.class.getName());
		// テンプレートID
		template.set(EKK0011C020CBSMsg.TEMPLATEID, TEMPLATE_ID_MSKM_NAIYO_HENKO);
		// 機能コード：訪販申込情報より取得した機能コードを格納する（"3"固定）
		template.set(EKK0011C020CBSMsg.FUNC_CODE, inMap.get(EKK0011C020CBSMsg.FUNC_CODE));
		// オペレータID
		template.set(EKK0011C020CBSMsg.OPERATORID, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		// 運用日付
		template.set(EKK0011C020CBSMsg.OPERATEDATE, param.getControlMapData(SCControlMapKeys.OPE_DATE));
		// 運用日時
		template.set(EKK0011C020CBSMsg.OPERATEDATETIME,  param.getControlMapData(SCControlMapKeys.OPE_TIME));
		// 申込番号
		template.set(EKK0011C020CBSMsg.MSKM_NO, workMap.get("mskm_no"));
		// 申込種別コード
		template.set(EKK0011C020CBSMsg.MSKM_SBT_CD, workMap.get("mskm_sbt_cd"));
		// 申込受付年月日時分秒
		template.set(EKK0011C020CBSMsg.MSKM_UK_DTM, workMap.get("mskm_uk_dtm"));
		// 申込年月日
		template.set(EKK0011C020CBSMsg.MSKM_YMD, workMap.get("mskm_ymd"));
		// 更新年月日時分秒(更新前)
		template.set(EKK0011C020CBSMsg.UPD_DTM_BF, workMap.get("upd_dtm"));
// ▼▼▼ IT1-2017-0000037 ADD START
		// 申込書到着年月日	MSKMSHO_ARIV_YMD
		template.set(EKK0011C020CBSMsg.MSKMSHO_ARIV_YMD, workMap.get(EKK0011A010CBSMsg1List.MSKMSHO_ARIV_YMD));
		// 申込受付担当ユーザーID	MSKM_UK_TNT_USER_ID
		template.set(EKK0011C020CBSMsg.MSKM_UK_TNT_USER_ID, workMap.get(EKK0011A010CBSMsg1List.MSKM_UK_TNT_USER_ID));
		// 総合営業申込契機コード	TTL_BUSINESS_MSKM_OPT_CD
		template.set(EKK0011C020CBSMsg.TTL_BUSINESS_MSKM_OPT_CD, workMap.get(EKK0011A010CBSMsg1List.TTL_BUSINESS_MSKM_OPT_CD));
		// 申込連絡先電話番号	MSKM_RRKS_TELNO
		template.set(EKK0011C020CBSMsg.MSKM_RRKS_TELNO, workMap.get(EKK0011A010CBSMsg1List.MSKM_RRKS_TELNO));
		// 申込実施者種別コード	MSKM_JSSIS_SBT_CD
		template.set(EKK0011C020CBSMsg.MSKM_JSSIS_SBT_CD, workMap.get(EKK0011A010CBSMsg1List.MSKM_JSSIS_SBT_CD));
		// お客様ご要望事項	CUST_YOBO_JIKO
		template.set(EKK0011C020CBSMsg.CUST_YOBO_JIKO, workMap.get(EKK0011A010CBSMsg1List.CUST_YOBO_JIKO));
		// 電話連絡希望日種別コード	TEL_RRK_KIBOD_SBT_CD
		template.set(EKK0011C020CBSMsg.TEL_RRK_KIBOD_SBT_CD, workMap.get(EKK0011A010CBSMsg1List.TEL_RRK_KIBOD_SBT_CD));
		// 電話連絡希望時間帯コード	TEL_RRK_KIBO_TIME_CD
		template.set(EKK0011C020CBSMsg.TEL_RRK_KIBO_TIME_CD, workMap.get(EKK0011A010CBSMsg1List.TEL_RRK_KIBO_TIME_CD));
		// 宅内調査希望日種別コード	TAKCHO_KIBOD_SBT_CD
		template.set(EKK0011C020CBSMsg.TAKCHO_KIBOD_SBT_CD, workMap.get(EKK0011A010CBSMsg1List.TAKCHO_KIBOD_SBT_CD));
		// 宅内調査希望時間帯コード	TAKCHO_KIBO_TIME_CD
		template.set(EKK0011C020CBSMsg.TAKCHO_KIBO_TIME_CD, workMap.get(EKK0011A010CBSMsg1List.TAKCHO_KIBO_TIME_CD));
		// リファラー	REFERER
		template.set(EKK0011C020CBSMsg.REFERER, workMap.get(EKK0011A010CBSMsg1List.REFERER));
		// 関西電力お客様情報授受同意有無	KEPCO_CUSTINFO_JUJU_DOI_UM
		template.set(EKK0011C020CBSMsg.KEPCO_CUSTINFO_JUJU_DOI_UM, workMap.get(EKK0011A010CBSMsg1List.KEPCO_CUSTINFO_JUJU_DOI_UM));
		// 照査前連絡事項要否	SHOSA_BF_RRK_JIKO_YH
		template.set(EKK0011C020CBSMsg.SHOSA_BF_RRK_JIKO_YH, workMap.get(EKK0011A010CBSMsg1List.SHOSA_BF_RRK_JIKO_YH));
		// 照査前連絡事項	SHOSA_BF_RRK_JIKO
		template.set(EKK0011C020CBSMsg.SHOSA_BF_RRK_JIKO, workMap.get(EKK0011A010CBSMsg1List.SHOSA_BF_RRK_JIKO));
		// 利用サービス継続種別コード	USE_SVC_KEIZK_SBT_CD
		template.set(EKK0011C020CBSMsg.USE_SVC_KEIZK_SBT_CD, workMap.get(EKK0011A010CBSMsg1List.USE_SVC_KEIZK_SBT_CD));
		// 受付担当者識別コード	UK_TNTSHA_SKBT_CD
		template.set(EKK0011C020CBSMsg.UK_TNTSHA_SKBT_CD, workMap.get(EKK0011A010CBSMsg1List.UK_TNTSHA_SKBT_CD));
		// 工事依頼情報連絡事項	KOJI_REQ_INFO_RRK_JIKO
		template.set(EKK0011C020CBSMsg.KOJI_REQ_INFO_RRK_JIKO, workMap.get(EKK0011A010CBSMsg1List.KOJI_REQ_INFO_RRK_JIKO));
		// 提携住宅会社コード	TKJCP_CD
		template.set(EKK0011C020CBSMsg.TKJCP_CD, workMap.get(EKK0011A010CBSMsg1List.TKJCP_CD));
		// 提携住宅会社名	TKJCP_NM
		template.set(EKK0011C020CBSMsg.TKJCP_NM, workMap.get(EKK0011A010CBSMsg1List.TKJCP_NM));
		// 提携住宅会社支店・営業所名	TKJCP_STNEGS_NM
		template.set(EKK0011C020CBSMsg.TKJCP_STNEGS_NM, workMap.get(EKK0011A010CBSMsg1List.TKJCP_STNEGS_NM));
		// 提携住宅会社担当者名	TKJCPTTS_NM
		template.set(EKK0011C020CBSMsg.TKJCPTTS_NM, workMap.get(EKK0011A010CBSMsg1List.TKJCPTTS_NM));
		// 提携住宅会社担当者職種名	TKJCPTTS_SHKSNM
		template.set(EKK0011C020CBSMsg.TKJCPTTS_SHKSNM, workMap.get(EKK0011A010CBSMsg1List.TKJCPTTS_SHKSNM));
		// 提携住宅会社担当者電話番号	TKJCPTTS_TLN
		template.set(EKK0011C020CBSMsg.TKJCPTTS_TLN, workMap.get(EKK0011A010CBSMsg1List.TKJCPTTS_TLN));
		// 分譲地名	BUNJOCHI_NM
		template.set(EKK0011C020CBSMsg.BUNJOCHI_NM, workMap.get(EKK0011A010CBSMsg1List.BUNJOCHI_NM));
		// 分譲地区画番号メモ	BUNJOCHI_KKK_NO_MEMO
		template.set(EKK0011C020CBSMsg.BUNJOCHI_KKK_NO_MEMO, workMap.get(EKK0011A010CBSMsg1List.BUNJOCHI_KKK_NO_MEMO));
		// 入居予定時期	NYUKYO_RSV_JK
		template.set(EKK0011C020CBSMsg.NYUKYO_RSV_JK, workMap.get(EKK0011A010CBSMsg1List.NYUKYO_RSV_JK));
		// 代理店申込受付EOスタッフユーザーＩＤ	AGNT_MKM_UK_EOSTF_USER_ID
		template.set(EKK0011C020CBSMsg.AGNT_MKM_UK_EOSTF_USER_ID, workMap.get(EKK0011A010CBSMsg1List.AGNT_MKM_UK_EOSTF_USER_ID));
		// 代理店申込受付量販店員カナ名（姓）	AGNT_MKM_UK_RHSTF_KANA_SEI
		template.set(EKK0011C020CBSMsg.AGNT_MKM_UK_RHSTF_KANA_SEI, workMap.get(EKK0011A010CBSMsg1List.AGNT_MKM_UK_RHSTF_KANA_SEI));
// △△△ IT1-2017-0000037 ADD END
// ANK-3910-00-00対応 20210117 星野 ADD START
		// 定額サービス申込機器	TEGAK_SVC_MSKM_KIKI
		template.set(EKK0011C020CBSMsg.TEGAK_SVC_MSKM_KIKI, workMap.get(EKK0011A010CBSMsg1List.TEGAK_SVC_MSKM_KIKI));
// ANK-3910-00-00対応 20210117 星野 ADD END
		// 更新対象項目
		if(inMap.get("upd_trgt_kmk") == null || inMap.get("upd_trgt_kmk").equals(""))
		{

		}
		
		else {
			if (inMap.get("upd_trgt_kmk").equals("1"))
			{
				// サンキューコール実施日
				template.set(EKK0011C020CBSMsg.THNX_CALL_JSSI_YMD, JCCBPCommon.getOpeDate(null));
			}
// ANK-3307-00-00 2017/10/18 DEL START
//			else if(inMap.get("upd_trgt_kmk").equals("2")) 
//			{
//				// 申込キャンセル除外承認申請年月日
//				template.set(EKK0011C020CBSMsg.MSKM_CNCL_JGI_SNN_SHIN_YMD, JCCBPCommon.getOpeDate(null));
//			}
//			else if(inMap.get("upd_trgt_kmk").equals("3")) 
//			{
//				// 申込キャンセル除外承認年月日
//				template.set(EKK0011C020CBSMsg.MSKM_CNCL_JGI_SNN_YMD, JCCBPCommon.getOpeDate(null));
//			}
//			else if(inMap.get("upd_trgt_kmk").equals("4")) 
//			{
//				// 申込キャンセル除外承認年月日
//				template.set(EKK0011C020CBSMsg.MSKM_CNCL_JGI_HNN_YMD, JCCBPCommon.getOpeDate(null));
//			}
// ANK-3307-00-00 2017/10/18 DEL END
		}
		
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}

	/**
	 * 申込内容変更下りマッピング
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param workMap
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editEKK0011C020OutMsg(Map<?, ?> msgList, IRequestParameterReadWrite param, 
			String fixedText, HashMap<String, Object> workMap) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 結果を詰めるマップを取得。
		HashMap<String, Object> dataMap = null;
		ArrayList dataList = null;
		ArrayList msg1List = null;

		/* 業務データ設定 */
		dataMap = (HashMap<String, Object>)param.getData(fixedText);
		
		if(dataMap == null) 
		{
			dataMap = new HashMap<String, Object>();
			param.setData(fixedText, dataMap);
		}
		
		dataList = (ArrayList)dataMap.get("EKK0011C020CBSMsg");
		if (dataList == null)
		{
			dataList = new ArrayList();
		}
		
		for (int i = 0; i < templates.length; i++) 
		{
			
			HashMap childMap = new HashMap();
			
			CAANMsg parentTemplate = templates[i];
			CAANMsg[] templateArray = null;
			
			// サンキューコール実施日
			if (!parentTemplate.isNull(EKK0011C020CBSMsg.THNX_CALL_JSSI_YMD))
			{
				childMap.put("thnx_call_jssi_ymd", parentTemplate.getString(EKK0011C020CBSMsg.THNX_CALL_JSSI_YMD));
			}
// ANK-3307-00-00 2017/10/18 DEL START
//			// 申込キャンセル除外承認申請年月日
//			else if(!parentTemplate.isNull(EKK0011C020CBSMsg.MSKM_CNCL_JGI_SNN_SHIN_YMD))
//			{
//				childMap.put("mskm_cncl_jgi_snn_shin_ymd", parentTemplate.getString(EKK0011C020CBSMsg.MSKM_CNCL_JGI_SNN_SHIN_YMD));
//			}
//			
//			// 申込キャンセル除外承認年月日
//			else if(!parentTemplate.isNull(EKK0011C020CBSMsg.MSKM_CNCL_JGI_SNN_YMD))
//			{
//				childMap.put("mskm_cncl_jgi_snn_ymd", parentTemplate.getString(EKK0011C020CBSMsg.MSKM_CNCL_JGI_SNN_YMD));
//			}
//			
//			// 申込キャンセル除外否認年月日
//			else if(!parentTemplate.isNull(EKK0011C020CBSMsg.MSKM_CNCL_JGI_HNN_YMD))
//			{
//				childMap.put("mskm_cncl_jgi_hnn_ymd", parentTemplate.getString(EKK0011C020CBSMsg.MSKM_CNCL_JGI_HNN_YMD));
//			}
// ANK-3307-00-00 2017/10/18 DEL END
			templateArray = parentTemplate.getCAANMsgList(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);
			msg1List = (ArrayList)childMap.get("EKK0011C020CBSMsg");

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

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

		dataMap.put("EKK0011C020CBSMsg", dataList);

		// エラー情報の設定
		IRequestParameterReadWrite rtnParam = editErrorInfo(param, templates, (Integer)return_code, workMap);
		rtnParam = editEKK0011C020ErrorInfo(rtnParam, templates, fixedText);

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

		return rtnParam;
	}

	/**
	 * <pre>
	 * 申込内容変更のエラー情報マッピング処理
	 * 
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	public IRequestParameterReadWrite editEKK0011C020ErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, String fixedText)
			throws Exception
	{
		CAANMsg template = templates[0];

		// テンプレートID取得
		String templateId = template.getString(JCMConstants.TEMPLATE_ID_KEY);

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

		// ユーザデータ情報にエラー情報をマッピング
		Object[][] contents = null;

		if (TEMPLATE_ID_MSKM_NAIYO_HENKO.equals(templateId))
		{
			contents = new EKK0011C020CBSMsg().getContents();
		}

		for (int i = 0; contents != null && i < contents.length; i++)
		{
			String element = null;
			element = (String)contents[i][0];
			if (element.indexOf("_err") > 0)
			{
				if (!template.isNull(element))
				{
					if (!inMap.containsKey(element))
					{
						inMap.put(element, template.getString(element));
					}
				}
			}
		}

		return param;
	}
	
	/**
	 * 
	 * 訪販申込情報閲覧システム返却パラメータ設定を行う
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param workMap
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void setHomskmRtnParam(IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> workMap)
	 throws RequestParameterException
	{
		/* ユーザデータ情報 */
		HashMap dataMap = (HashMap)param.getData(fixedText);
		
		// ANK-3307-00-00 2017/10/18 ADD START
		// リターンコードが正常である場合
		if (NORMAL.equals(param.getControlMapData(SCControlMapKeys.RETURN_CODE)))
		{
		// ANK-3307-00-00 2017/10/18 ADD END
			//更新日付
			dataMap.put("upd_ymd",JCCBPCommon.getOpeDate(null));
		// ANK-3307-00-00 2017/10/18 ADD START
		}
		// ANK-3307-00-00 2017/10/18 ADD END
		
		//エラーレベル
		dataMap.put("errorLevel",workMap.get("errorLevel"));
		//リターンコード
		dataMap.put("returnCode",workMap.get("returnCode"));
		//リターンメッセージ
		dataMap.put("returnMessage",workMap.get("returnMessage"));
	}


	/**
	 * 単項目チェックエラーかどうかを判定する。
	 * 
	 * @param funcCode 機能コード
	 * @param ukNo 受付番号
	 * @param updTrgtKmk 更新対象項目
	 * @param inMap 結果格納マップ
	 * @return true パラメータ不正エラー
	 */
	private boolean isErrInParam(String funcCode, String ukNo, String updTrgtKmk,
			Map<String, Object> workMap) 
		{
			/** 必須チェック */
			// 機能コード
			if (!CharacterCheck.isNotNullCheck(funcCode))
			{
				workMap.put(IN_FUNC_CD + ITEM_ERR_END, INDI_ERR);
			
				return true;
			}
		
			// 受付番号
			if (!CharacterCheck.isNotNullCheck(ukNo))
			{
				workMap.put(IN_UK_NO + ITEM_ERR_END, INDI_ERR);
			
				return true;
			}
		
			// 更新対象項目
			if (!CharacterCheck.isNotNullCheck(updTrgtKmk))
			{
				workMap.put(IN_UPD_TRGT_KMK + ITEM_ERR_END, INDI_ERR);
				
				return true;
			}
			
			/** 属性チェック */
			// 機能コード
			if (!HalfCharCheck.isEnNumber1Check(funcCode))
			{
				workMap.put(IN_FUNC_CD + ITEM_ERR_END, DMN_ERR);
				
				return true;
			}
		
			// 受付番号
			if (!HalfCharCheck.isEnNumber1Check(ukNo))
			{
				workMap.put(IN_UK_NO + ITEM_ERR_END, DMN_ERR);
				
				return true;
			}
		
			// 更新対象項目
// ANK-3307-00-00 2017/10/18 MOD START
//			if (!HalfCharCheck.isNumber1Check(updTrgtKmk))
			if (!HalfCharCheck.isEnNumber1Check(updTrgtKmk))
// ANK-3307-00-00 2017/10/18 MOD END
			{
				workMap.put(IN_UPD_TRGT_KMK + ITEM_ERR_END, DMN_ERR);
				
				return true;
			}
			
			/** 桁数チェック */
			// 機能コード
			if (!LengthCheck.isLength1Check(funcCode, FUNC_CODE_LEN))
			{
				workMap.put(IN_FUNC_CD + ITEM_ERR_END, KETA_ERR);
				
				return true;
			}
			
			// 受付番号
			if (!LengthCheck.isLength1Check(ukNo, UK_NO_LEN))
			{
				workMap.put(IN_UK_NO + ITEM_ERR_END, KETA_ERR);
				
				return true;
			}
			
			// 更新対象項目
			if (!LengthCheck.isLength1Check(updTrgtKmk, UPD_TRGT_KMK_LEN))
			{
				workMap.put(IN_UPD_TRGT_KMK + ITEM_ERR_END, KETA_ERR);
				
				return true;
			}
			
			return false;
		}	

	/**
	 * 単項目関連チェックエラーかどうかを判定する。
	 * 
	 * @param updTrgtKmk 更新対象項目
	 * @param inMap 結果格納マップ
	 * @return true パラメータ不正エラー
	 */
	private boolean isErrInParam2(String updTrgtKmk,Map<String, Object> workMap) 
		{
			/** 更新対象項目エラーチェック */
			// 更新対象項目
			if (!( updTrgtKmk.equals("1") 
					|| updTrgtKmk.equals("2")
					|| updTrgtKmk.equals("3")
// ANK-3307-00-00 2017/10/18 MOD START
//					|| updTrgtKmk.equals("4")))
					|| updTrgtKmk.equals("4")
					|| updTrgtKmk.equals("5")
					|| updTrgtKmk.equals("6")
					|| updTrgtKmk.equals("7")
					|| updTrgtKmk.equals("8")
					|| updTrgtKmk.equals("9")
					|| updTrgtKmk.equals("A")
					|| updTrgtKmk.equals("B")
					|| updTrgtKmk.equals("C")
					|| updTrgtKmk.equals("D")
					|| updTrgtKmk.equals("E")
					|| updTrgtKmk.equals("F")
					|| updTrgtKmk.equals("G")))
// ANK-3307-00-00 2017/10/18 MOD END
			{
				workMap.put(IN_UPD_TRGT_KMK + ITEM_ERR_END, INDI_ERR);
			
				return true;
			}
			return false;
		}

//	/**
//	 * ビジネスログを出力する。
//	 *
//	 * @param inMap 結果格納マップ
//	 * @param keiStat 契約状態
//	 */
//	private void outputBusLog(Map<String, Object> inMap, String keiStat)
//	{
//		// ログメッセージの組み立て
//		String logMsg = "--- 訪販申込情報更新受付CC " + keiStat + " 機能コード：" + inMap.get(IN_FUNC_CD)
//				+ " 受付番号：" + inMap.get(IN_UK_NO) + " 更新対象項目：" + inMap.get(IN_UPD_TRGT_KMK)
//				+ " リターンコード：" + inMap.get(OUT_RETURN_CODE);
//		// ログ出力
//		JSYejbLog.println(JSYejbLog.EXECUTION, this.getClass(), logMsg);
//	}
// ▼▼▼ 2017-04-28 IT2-2017-0000004 ADD START
	/**
	 * <pre>
	 * 申込明細一意照会のエラー情報マッピング処理
	 * 
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editEKK0021B001ErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, String fixedText)
			throws Exception
	{
		CAANMsg template = templates[0];
		
		// テンプレートID取得
		String templateId = template.getString(JCMConstants.TEMPLATE_ID_KEY);
		
		/* ユーザデータ情報 */
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// ユーザデータ情報にエラー情報をマッピング
		Object[][] contents = new Object[0][0];
		
		contents = new EKK0021B001CBSMsg().getContents();
		
		for (int i = 0; contents != null && i < contents.length; i++)
		{
			String element = null;
			element = (String)contents[i][0];
			if (element.indexOf("_err") > 0)
			{
				if (!template.isNull(element))
				{
					if (!inMap.containsKey(element))
					{
						String e = element.replaceFirst("key_", "");
						inMap.put(e, template.getString(element));
					}
				}
			}
		}
		
		return param;
	}
	
	/**
	 * 申込書番号指定一覧照会上りマッピング
	 * @param param
	 * @param paramMap
	 * @param fixedText
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editEKK0021B001InMsg(IRequestParameterReadWrite param, HashMap<String, Object> paramMap, 
			String fixedText) throws RequestParameterException
	{
		// メッセージ共通部設定処理
		paramMap = editInMsg(param, paramMap);
		
		/* ユーザデータ情報 */
		HashMap inMap = (HashMap)param.getData(fixedText);
		
		CAANMsg template = new CAANMsg(EKK0021B001CBSMsg.class.getName());
		// テンプレートID
		template.set(EKK0021B001CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0021B001);
		// 機能コード：("1"固定)
		template.set(EKK0021B001CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		// オペレータID
		template.set(EKK0021B001CBSMsg.OPERATORID, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		// 運用日付
		template.set(EKK0021B001CBSMsg.OPERATEDATE, param.getControlMapData(SCControlMapKeys.OPE_DATE));
		// 運用日時
		template.set(EKK0021B001CBSMsg.OPERATEDATETIME,  param.getControlMapData(SCControlMapKeys.OPE_TIME));
		
		// ＫＥＹ＿申込書番号
		template.set(EKK0021B001CBSMsg.KEY_MSKMSHO_NO, inMap.get("uk_no"));
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}

	/**
	 * 申込書番号指定一覧照会下りマッピング
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @param workMap
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editEKK0021B001OutMsg(Map<?, ?> msgList, IRequestParameterReadWrite param, 
			String fixedText, HashMap<String, Object> workMap) throws Exception
	{

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 結果を詰めるマップを取得。
		HashMap<String, Object> dataMap = null;
		ArrayList dataList = null;

		/* 業務データ設定 */
		dataMap = (HashMap<String, Object>)param.getData(fixedText);
		
		if(dataMap == null) 
		{
			dataMap = new HashMap<String, Object>();
			param.setData(fixedText, dataMap);
		}
		
		templateArray = parentTemplate.getCAANMsgList(EKK0021B001CBSMsg.EKK0021B001CBSMSG1LIST);
		dataList = (ArrayList)dataMap.get("EKK0021B001CBSMsg1List");

		if (dataList == null) 
		{
			dataList = new ArrayList();
		}
		
		if (templateArray != null) 
		{
			for(int i = 0; i < templateArray.length; i++) 
			{
				
				CAANMsg childTemplate = templateArray[i];
				if(i >= dataList.size())
				{
					dataList.add(new HashMap<String, Object>());
				}
				
				// 申込番号コード
				if (!childTemplate.isNull(EKK0021B001CBSMsg1List.MSKM_NO)) 
				{
					workMap.put("mskm_no", childTemplate.getString(EKK0021B001CBSMsg1List.MSKM_NO));
				}
			}
		}

		// エラー情報の設定
		IRequestParameterReadWrite rtnParam = editErrorInfo(param, templates, (Integer)return_code, workMap);
		rtnParam = editEKK0021B001ErrorInfo(rtnParam, templates, fixedText);

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

		return rtnParam;
	}

// △△△ 2017-04-28 IT2-2017-0000004 ADD END
	// ▼▼▼ IT1-2017-0000037 ADD START
	/**
	 * 返却レコードから値を取り出す。
	 * <br>
	 * @param childTemplate 返却レコード
	 * @param key 取得キー
	 * @return 値
	 */
	private String getValue(CAANMsg childTemplate, String key)
	{
		if (childTemplate.isNull(key)) 
		{
			return ""; 
		} 
		else 
		{
			return childTemplate.getString(key);
		}
	}
// △△△ IT1-2017-0000037 ADD END
	// ANK-3307-00-00 2017/10/18 ADD START
	/**
	 * 他システム連携用申込実績一覧照会を行う。
	 * @param handle
	 * @param param
	 * @param inParamMap
	 * @param fixedText
	 * @param workMap
	 * @throws Exception
	 */
	private void stkuTsyrnYoMsjkInfo(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, Object> inParamMap, String fixedText, HashMap<String, Object> workMap) throws Exception
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		
		// 他システム連携用申込実績一覧照会上りマッピング
		paramMap = editEKK3101B010InMsg(param, paramMap, inParamMap);
		
		// SC呼び出しクラスの生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// SIFの呼び出し
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// 他システム連携用申込実績一覧照会下りマッピング
		IRequestParameterReadWrite rtnParam = editEKK3101B010OutMsg(result, param, inParamMap, fixedText, workMap);
		
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)rtnParam.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}
	}
	
	/**
	 * 他システム連携用申込実績一覧照会上りマッピングです。
	 * @param param
	 * @param paramMap
	 * @param inParamMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editEKK3101B010InMsg(IRequestParameterReadWrite param, HashMap<String, Object> paramMap,
			HashMap<String, Object> inParamMap) throws RequestParameterException
	{
		// メッセージ共通部設定処理
		paramMap = editInMsg(param, paramMap);
		
		CAANMsg template = new CAANMsg(EKK3101B010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK3101B010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK3101B010);
		// 機能コード：("1"固定)
		template.set(EKK3101B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		// オペレータID
		template.set(EKK3101B010CBSMsg.OPERATORID, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		// 運用日付
		template.set(EKK3101B010CBSMsg.OPERATEDATE, param.getControlMapData(SCControlMapKeys.OPE_DATE));
		// 運用日時
		template.set(EKK3101B010CBSMsg.OPERATEDATETIME,  param.getControlMapData(SCControlMapKeys.OPE_TIME));
		
		// ＫＥＹ＿申込書番号
		template.set(EKK3101B010CBSMsg.KEY_MSKMSHO_NO, inParamMap.get("uk_no"));
		// ＫＥＹ＿更新対象項目
		template.set(EKK3101B010CBSMsg.KEY_UPD_TRGT_KMK, inParamMap.get("upd_trgt_kmk"));
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	/**
	 * 他システム連携用申込実績一覧照会下りマッピングです。
	 * @param msgList
	 * @param param
	 * @param inParamMap
	 * @param fixedText
	 * @param workMap
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editEKK3101B010OutMsg(Map<?, ?> msgList, IRequestParameterReadWrite param,
			HashMap<String, Object> inParamMap, String fixedText, HashMap<String, Object> workMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 結果を詰めるマップを取得。
		ArrayList dataList = null;
		
		if (inParamMap == null)
		{
			inParamMap = new HashMap<String, Object>();
			param.setData(fixedText, inParamMap);
		}
		
		templateArray = parentTemplate.getCAANMsgList(EKK3101B010CBSMsg.EKK3101B010CBSMSG1LIST);
		dataList = (ArrayList)inParamMap.get(EKK3101B010CBSMsg.EKK3101B010CBSMSG1LIST);
		
		if (dataList == null)
		{
			dataList = new ArrayList();
		}
		
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];
				
				if (i >= dataList.size())
				{
					dataList.add(new HashMap<String, Object>());
				}
				
				// 申込明細番号
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.MSKM_DTL_NO))
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKM_DTL_NO, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKM_DTL_NO, childTemplate.getString(EKK3101B010CBSMsg1List.MSKM_DTL_NO));
				}
				
				// 申込年月日
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.MSKM_YMD))
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKM_YMD, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKM_YMD, childTemplate.getString(EKK3101B010CBSMsg1List.MSKM_YMD));
				}
				
				// 申込番号
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.MSKM_NO))
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKM_NO, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKM_NO, childTemplate.getString(EKK3101B010CBSMsg1List.MSKM_NO));
				}
				
				// 代理店コード
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.AGNT_CD))
				{
					workMap.put(EKK3101B010CBSMsg1List.AGNT_CD, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.AGNT_CD, childTemplate.getString(EKK3101B010CBSMsg1List.AGNT_CD));
				}
				
				// 申込＿代理店番号
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.MSKM_AGNT_NO))
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKM_AGNT_NO, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKM_AGNT_NO, childTemplate.getString(EKK3101B010CBSMsg1List.MSKM_AGNT_NO));
				}
				
				// 申込書番号
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.MSKMSHO_NO))
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKMSHO_NO, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKMSHO_NO, childTemplate.getString(EKK3101B010CBSMsg1List.MSKMSHO_NO));
				}
				
				// 申込書種別コード
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.MSKMSHO_SBT_CD))
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKMSHO_SBT_CD, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKMSHO_SBT_CD, childTemplate.getString(EKK3101B010CBSMsg1List.MSKMSHO_SBT_CD));
				}
				
				// サービス契約番号
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.SVC_KEI_NO))
				{
					workMap.put(EKK3101B010CBSMsg1List.SVC_KEI_NO, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.SVC_KEI_NO, childTemplate.getString(EKK3101B010CBSMsg1List.SVC_KEI_NO));
				}
				
				// 料金グループコード
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.PRC_GRP_CD))
				{
					workMap.put(EKK3101B010CBSMsg1List.PRC_GRP_CD, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.PRC_GRP_CD, childTemplate.getString(EKK3101B010CBSMsg1List.PRC_GRP_CD));
				}
				
				// マンションＩＤ
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.MANSION_ID))
				{
					workMap.put(EKK3101B010CBSMsg1List.MANSION_ID, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.MANSION_ID, childTemplate.getString(EKK3101B010CBSMsg1List.MANSION_ID));
				}
				
				// ＳＹＳＩＤ
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.SYSID))
				{
					workMap.put(EKK3101B010CBSMsg1List.SYSID, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.SYSID, childTemplate.getString(EKK3101B010CBSMsg1List.SYSID));
				}
				
				// お客様カナ名
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.CUST_KANA))
				{
					workMap.put(EKK3101B010CBSMsg1List.CUST_KANA, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.CUST_KANA, childTemplate.getString(EKK3101B010CBSMsg1List.CUST_KANA));
				}
				
				// 契約者電話番号
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.KEISHA_TELNO))
				{
					workMap.put(EKK3101B010CBSMsg1List.KEISHA_TELNO, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.KEISHA_TELNO, childTemplate.getString(EKK3101B010CBSMsg1List.KEISHA_TELNO));
				}
				
				// 更新年月日時分秒
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.UPD_DTM))
				{
					workMap.put(EKK3101B010CBSMsg1List.UPD_DTM, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.UPD_DTM, childTemplate.getString(EKK3101B010CBSMsg1List.UPD_DTM));
				}
				
				// 申込キャンセル除外承認申請年月日
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.MSKM_CNCL_JGI_SNN_SHIN_YMD))
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKM_CNCL_JGI_SNN_SHIN_YMD, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKM_CNCL_JGI_SNN_SHIN_YMD, childTemplate.getString(EKK3101B010CBSMsg1List.MSKM_CNCL_JGI_SNN_SHIN_YMD));
				}
				
				// 申込キャンセル除外承認年月日
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.MSKM_CNCL_JGI_SNN_YMD))
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKM_CNCL_JGI_SNN_YMD, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKM_CNCL_JGI_SNN_YMD, childTemplate.getString(EKK3101B010CBSMsg1List.MSKM_CNCL_JGI_SNN_YMD));
				}
				
				// 申込キャンセル除外否認年月日
				if (childTemplate.isNull(EKK3101B010CBSMsg1List.MSKM_CNCL_JGI_HNN_YMD))
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKM_CNCL_JGI_HNN_YMD, "");
				}
				else
				{
					workMap.put(EKK3101B010CBSMsg1List.MSKM_CNCL_JGI_HNN_YMD, childTemplate.getString(EKK3101B010CBSMsg1List.MSKM_CNCL_JGI_HNN_YMD));
				}
			}
		}
		
		// エラー情報の設定
		IRequestParameterReadWrite rtnParam = editErrorInfo(param, templates, (Integer)returnCode, workMap);
		rtnParam = editEKK3101B010ErrorInfo(rtnParam, templates, inParamMap, fixedText);
		
		// エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)rtnParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		rtnParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return rtnParam;
	}
	
	/**
	 * 他システム連携用申込実績一覧照会のエラー情報マッピング処理です。
	 * @param param
	 * @param templates
	 * @param inParamMap
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editEKK3101B010ErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates,
			HashMap<String, Object> inParamMap, String fixedText) throws Exception
	{
		CAANMsg template = templates[0];
		
		// テンプレートID取得
		String templateId = template.getString(JCMConstants.TEMPLATE_ID_KEY);
		
		// ユーザデータ情報にエラー情報をマッピング
		Object[][] contents = null;
		
		if (TEMPLATE_ID_EKK3101B010.equals(templateId))
		{
			contents = new EKK3101B010CBSMsg().getContents();
		}
		
		for (int i = 0; contents != null && i < contents.length; i++)
		{
			String element = null;
			element = (String)contents[i][0];
			
			if (element.indexOf("_err") > 0)
			{
				if (!template.isNull(element))
				{
					if (!inParamMap.containsKey(element))
					{
						String e = element.replaceFirst("key_", "");
						inParamMap.put(e, template.getString(element));
					}
				}
			}
		}
		
		return param;
	}
	
	/**
	 * 他システム連携用申込実績更新を行う。
	 * @param handle
	 * @param param
	 * @param inParamMap
	 * @param fixedText
	 * @param workMap
	 * @throws Exception
	 */
	private void updTsyrnYoMsjkInfo(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, Object> inParamMap, String fixedText, HashMap<String, Object> workMap) throws Exception
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		
		// 他システム連携用申込実績更新上りマッピング
		paramMap = editEKK3101C010InMsg(param, paramMap, inParamMap, workMap);
		
		// SC呼び出しクラスの生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// SIFの呼び出し
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// 他システム連携用申込実績更新下りマッピング
		IRequestParameterReadWrite rtnParam = editEKK3101C010OutMsg(result, param, inParamMap, fixedText, workMap);
		
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)rtnParam.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}
	}
	
	/**
	 * 他システム連携用申込実績更新上りマッピングです。
	 * @param param
	 * @param paramMap
	 * @param inParamMap
	 * @param workMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editEKK3101C010InMsg(IRequestParameterReadWrite param, HashMap<String, Object> paramMap,
			HashMap<String, Object> inParamMap, HashMap<String, Object> workMap) throws RequestParameterException
	{
		// メッセージ共通部設定処理
		paramMap = editInMsg(param, paramMap);
		
		CAANMsg template = new CAANMsg(EKK3101C010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK3101C010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK3101C010);
		// 機能コード：（"1"固定）
		template.set(EKK3101C010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		// オペレータID
		template.set(EKK3101C010CBSMsg.OPERATORID, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		// 運用日付
		template.set(EKK3101C010CBSMsg.OPERATEDATE, param.getControlMapData(SCControlMapKeys.OPE_DATE));
		// 運用日時
		template.set(EKK3101C010CBSMsg.OPERATEDATETIME,  param.getControlMapData(SCControlMapKeys.OPE_TIME));
		
		// 申込明細番号
		template.set(EKK3101C010CBSMsg.MSKM_DTL_NO, workMap.get(EKK3101B010CBSMsg1List.MSKM_DTL_NO));
		// 申込年月日
		template.set(EKK3101C010CBSMsg.MSKM_YMD, workMap.get(EKK3101B010CBSMsg1List.MSKM_YMD));
		// 申込番号
		template.set(EKK3101C010CBSMsg.MSKM_NO, workMap.get(EKK3101B010CBSMsg1List.MSKM_NO));
		// 代理店コード
		template.set(EKK3101C010CBSMsg.AGNT_CD, workMap.get(EKK3101B010CBSMsg1List.AGNT_CD));
		// 申込_代理店番号
		template.set(EKK3101C010CBSMsg.MSKM_AGNT_NO, workMap.get(EKK3101B010CBSMsg1List.MSKM_AGNT_NO));
		// 申込書番号
		template.set(EKK3101C010CBSMsg.MSKMSHO_NO, workMap.get(EKK3101B010CBSMsg1List.MSKMSHO_NO));
		// 申込書種別コード
		template.set(EKK3101C010CBSMsg.MSKMSHO_SBT_CD, workMap.get(EKK3101B010CBSMsg1List.MSKMSHO_SBT_CD));
		// サービス契約番号
		template.set(EKK3101C010CBSMsg.SVC_KEI_NO, workMap.get(EKK3101B010CBSMsg1List.SVC_KEI_NO));
		// 料金グループコード
		template.set(EKK3101C010CBSMsg.PRC_GRP_CD, workMap.get(EKK3101B010CBSMsg1List.PRC_GRP_CD));
		// マンションID
		template.set(EKK3101C010CBSMsg.MANSION_ID, workMap.get(EKK3101B010CBSMsg1List.MANSION_ID));
		// SYSID
		template.set(EKK3101C010CBSMsg.SYSID, workMap.get(EKK3101B010CBSMsg1List.SYSID));
		// お客様カナ名
		template.set(EKK3101C010CBSMsg.CUST_KANA, workMap.get(EKK3101B010CBSMsg1List.CUST_KANA));
		// 契約者電話番号
		template.set(EKK3101C010CBSMsg.KEISHA_TELNO, workMap.get(EKK3101B010CBSMsg1List.KEISHA_TELNO));
		
		// 更新対象項目
		String updTrgtKmk = (String)inParamMap.get(IN_UPD_TRGT_KMK);
		
		// 更新対象項目が'2', '5', '8', 'B', 'E'である場合
		// 申込キャンセル除外承認申請年月日に運用日付を設定
		if ("2".equals(updTrgtKmk) || "5".equals(updTrgtKmk) ||
				"8".equals(updTrgtKmk) || "B".equals(updTrgtKmk) || "E".equals(updTrgtKmk))
		{
			template.set(EKK3101C010CBSMsg.MSKM_CNCL_JGI_SNN_SHIN_YMD, JCCBPCommon.getOpeDate(null));
		}
		// 更新対象項目が'3', '6', '9', 'C', 'F'である場合
		// 申込キャンセル除外承認年月日に運用日付を設定
		else if ("3".equals(updTrgtKmk) || "6".equals(updTrgtKmk) ||
				"9".equals(updTrgtKmk) || "C".equals(updTrgtKmk) || "F".equals(updTrgtKmk))
		{
			template.set(EKK3101C010CBSMsg.MSKM_CNCL_JGI_SNN_YMD, JCCBPCommon.getOpeDate(null));
		}
		// 更新対象項目が'4', '7', 'A', 'D', 'G'である場合
		// 申込キャンセル除外否認年月日に運用日付を設定
		else if("4".equals(updTrgtKmk) || "7".equals(updTrgtKmk) ||
				"A".equals(updTrgtKmk) || "D".equals(updTrgtKmk) || "G".equals(updTrgtKmk))
		{
			template.set(EKK3101C010CBSMsg.MSKM_CNCL_JGI_HNN_YMD, JCCBPCommon.getOpeDate(null));
		}
		
		// 更新年月日時分秒(更新前)
		template.set(EKK3101C010CBSMsg.UPD_DTM_BF, workMap.get(EKK3101B010CBSMsg1List.UPD_DTM));
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	/**
	 * 他システム連携用申込実績更新下りマッピングです。
	 * @param msgList
	 * @param param
	 * @param inParamMap
	 * @param fixedText
	 * @param workMap
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	private IRequestParameterReadWrite editEKK3101C010OutMsg(Map<?, ?> msgList, IRequestParameterReadWrite param,
			HashMap<String, Object> inParamMap, String fixedText, HashMap<String, Object> workMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		if (inParamMap == null)
		{
			inParamMap = new HashMap<String, Object>();
			param.setData(fixedText, inParamMap);
		}
		
		// エラー情報の設定
		IRequestParameterReadWrite rtnParam = editErrorInfo(param, templates, (Integer)returnCode, workMap);
		rtnParam = editEKK3101C010ErrorInfo(rtnParam, templates, inParamMap, fixedText);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)rtnParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		rtnParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return rtnParam;
	}
	
	/**
	 * 他システム連携用申込実績更新のエラー情報マッピング処理です。
	 * @param param
	 * @param templates
	 * @param inParamMap
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editEKK3101C010ErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates,
			HashMap<String, Object> inParamMap, String fixedText) throws Exception
	{
		CAANMsg template = templates[0];
		
		// テンプレートID取得
		String templateId = template.getString(JCMConstants.TEMPLATE_ID_KEY);
		
		// ユーザデータ情報にエラー情報をマッピング
		Object[][] contents = null;
		
		if (TEMPLATE_ID_EKK3101C010.equals(templateId))
		{
			contents = new EKK0011C020CBSMsg().getContents();
		}
		
		for (int i = 0; contents != null && i < contents.length; i++)
		{
			String element = null;
			element = (String)contents[i][0];
			
			if (element.indexOf("_err") > 0)
			{
				if (!template.isNull(element))
				{
					if (!inParamMap.containsKey(element))
					{
						inParamMap.put(element, template.getString(element));
					}
				}
			}
		}
		
		return param;
	}
	// ANK-3307-00-00 2017/10/18 ADD END
}