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

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

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

import eo.common.constant.JPCModelConstant;
import eo.common.util.JCRUtilCommon;
import eo.common.util.JPCUtilCommon;
import eo.ejb.cbs.cbsmsg.ECR0011C080CBSMsg;
import eo.ejb.cbs.cbsmsg.ECR0011D010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECR0021D020CBSMsg;
import eo.ejb.cbs.cbsmsg.ECR0111B020CBSMsg;
import eo.ejb.cbs.cbsmsg.ECR0111B020CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0321B011CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0321B011CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0171B020CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0171B020CBSMsg1List;

/**
 * 対応記録登録料金用CC部品クラス
 * @author   富士通
 */
public class JACTaioKirokAddCC extends AbstractCommonComponent
{
	/** オブジェクトNULL */
	private Object objNull = null;
	
	/** マップCCID */
	private static final String MAP_CC_ID = "TAIOKIROKADDCC";

	/** マップCCID */
	private static final String MAP_CC_ID2 = "ADDHOTVOICCC";

	/**
	/**
	 * 対応記録登録チェック処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException RequestParameterException
	 */
	public  HashMap<String, Object> getInvokeCBS(SessionHandle handle
			, IRequestParameterReadWrite param, String fixedText) throws RequestParameterException 
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);
		
		HashMap<String, Object> resultMap = null;
		CAANMsg[] templates = null;
		List<CAANMsg> list = new ArrayList<CAANMsg>();
		
		// 入力データ情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		
		// 対応記録登録リスト件数分繰り返す
		ArrayList<HashMap<String, Object>> taioKirokAddList = (ArrayList<HashMap<String, Object>>)inMap.get("taio_kirok_add_list");
		for (HashMap<String, Object> taioKirokAddMap : taioKirokAddList)
		{
			// 引継項目を設定
			taioKirokAddMap.put("mybox_no", "0000000000");
			taioKirokAddMap.put("taio_kirok_no", "0000000000");
			taioKirokAddMap.put("upd_dtm", "20120206204057000");
			
			//キューBOXMYBOX現在格納数一覧照会の実行
			resultMap = editInMsgMyBox(param, taioKirokAddMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
			
			// 対応記録登録の実行
			resultMap = editInMsgTaioKirokAdd(param, taioKirokAddMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
			
			// 対応記録明細登録（コール）の実行
			resultMap = editInMsgTaioKirokDtlCall(param, taioKirokAddMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
			
			// 対応記録明クローズの実行
			resultMap = editInMsgTaioKirokClose(param, taioKirokAddMap);
			templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
			list.addAll(Arrays.asList(templates));
			
			// 応対区分カテゴリーリスト件数分繰り返す
			ArrayList<HashMap<String, Object>> ctgrList = (ArrayList<HashMap<String, Object>>)taioKirokAddMap.get("rsp_ctgr_list");
			for (HashMap<String, Object> ctgrMap : ctgrList)
			{
				// コード名称管理コード区分前方一致一覧照会の実行
				resultMap = editInMsgCdNmKanri(param, ctgrMap);
				templates = (CAANMsg[])resultMap.get(JCMConstants.TEMPLATE_LIST_KEY);
				list.addAll(Arrays.asList(templates));
			}
		}
		
		templates = list.toArray(new CAANMsg[list.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}

	/**
	 * <p>
	 * 対応記録登録処理
	 * </p>
	 * @param handle セッションマネージャなどを持ったハンドル
	 * @param param モデルグループ、コントロールマップを含むパラメータオブジェクト
	 * @param fixedText ユーザ任意文字列
	 * @return 業務データ取得I/F
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite addTaioKirok(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		// 上りマッピングの処理結果を取得するためのマップを生成
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		// SC実行結果を格納するマップ
		Map<?, ?> result = null;

		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 入力データ情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

		// ホットボイス用マップを作成
		HashMap<String, Object> addHotVoiceMap = new HashMap<String, Object>();
		ArrayList<HashMap<String, Object>> rspCtgrList = new ArrayList<HashMap<String, Object>>();
		inMap.put(MAP_CC_ID2, addHotVoiceMap);
		addHotVoiceMap.put("func_code", "1");
		addHotVoiceMap.put("RSP_CTGR_List", rspCtgrList);

		// サービス契約番号一覧照会実行
		paramMap = editInMsgEKK0321B011(param, inMap);
		result = scCall.run(paramMap, handle);
		editOutMsgEKK0321B011(result, param, inMap);

		// webのマッピングクラスから引継いだ対応履歴登録リスト
		ArrayList<HashMap<String, Object>> hktgTaioKirokAddList = (ArrayList<HashMap<String, Object>>)inMap.get("taio_kirok_add_list");

		// 対応記録登録リスト
		List<HashMap<String, Object>> taioKirokAddList = new ArrayList<HashMap<String, Object>>();
		inMap.put("taio_kirok_add_list", taioKirokAddList);

		// サービス契約番号リスト件数分繰り返し、対応記録登録リストを作成する
		ArrayList<HashMap<String, Object>> svcKeiNoList = (ArrayList<HashMap<String, Object>>)inMap.get("EKK0321B011CBSMsg1List");

		for (HashMap<String, Object> hktgTaiokirokMap : hktgTaioKirokAddList)
		{
			for (HashMap<String, Object> svcKeiNoMap : svcKeiNoList)
			{
				// webのマッピングクラスから引継いだ対応履歴登録リストマップのクローン
				HashMap<String, Object> taioKirokAddMap = (HashMap<String, Object>) hktgTaiokirokMap.clone();

				// サービス契約番号を設定
				taioKirokAddMap.put("svc_kei_no", (String) svcKeiNoMap.get("svc_kei_no"));

				// 対応記録登録リストに追加
				taioKirokAddList.add(taioKirokAddMap);
			}
		}

		// 請求書再発行画面で作成された内訳印刷用のリスト
		// webのマッピングクラスから引継いだ対応履歴登録リスト
		ArrayList<HashMap<String, Object>> hktgTaioKirokAddList2 = (ArrayList<HashMap<String, Object>>)inMap.get("taio_kirok_add_list2");

		// 対応記録登録リストに追加
		if (hktgTaioKirokAddList2 != null && !hktgTaioKirokAddList2.isEmpty())
		{
			taioKirokAddList.addAll(hktgTaioKirokAddList2);
		}

		// 対応記録登録リスト件数分繰り返す
		for (HashMap<String, Object> taioKirokAddMap : taioKirokAddList)
		{
			//キューBOXMYBOX現在格納数一覧照会の実行
			paramMap = editInMsgMyBox(param, taioKirokAddMap);
			result = scCall.run(paramMap, handle);
			editOutMsgMyBox(result, param, taioKirokAddMap);
			
			// 対応記録登録の実行
			paramMap = editInMsgTaioKirokAdd(param, taioKirokAddMap);
			result = scCall.run(paramMap, handle);
			editOutMsgTaioKirokAdd(result, param, taioKirokAddMap);
			
			// 対応記録明細登録（コール）の実行
			paramMap = editInMsgTaioKirokDtlCall(param, taioKirokAddMap);
			result = scCall.run(paramMap, handle);
			editOutMsgTaioKirokDtlCall(result, param, taioKirokAddMap);
			
			// 対応記録明クローズの実行
			paramMap = editInMsgTaioKirokClose(param, taioKirokAddMap);
			result = scCall.run(paramMap, handle);
			editOutMsgTaioKirokClose(result, param, taioKirokAddMap);

			// 応対区分カテゴリーリスト件数分繰り返す
			int index = 1;
			ArrayList<HashMap<String, Object>> ctgrList = (ArrayList<HashMap<String, Object>>)taioKirokAddMap.get("rsp_ctgr_list");
			for (HashMap<String, Object> ctgrMap : ctgrList)
			{
				// コード名称管理コード区分前方一致一覧照会の実行
				paramMap = editInMsgCdNmKanri(param, ctgrMap);
				result = scCall.run(paramMap, handle);
				editOutMsgCdNmKanri(result, param, ctgrMap);
				rspCtgrList.add(getCategoryLevel(ctgrMap, taioKirokAddMap, index));
				index += 1;
			}
		}

		param.setData(MAP_CC_ID2, inMap.get(MAP_CC_ID2));

		// 結果を返却する。
		return param;
	}

	/**
	 * IRequestParameterReadWriteにエラー情報をマッピングする。<br>
	 * 
	 * @param param モデルグループ、コントロールマップを含むパラメータオブジェクト
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @throws RequestParameterException
	 * @return パラメータオブジェクト
	 */
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
																							throws RequestParameterException
	{
		if (templates == null || templates.length == 0)
		{
			return param;
		}
		
		int index = 0;
		
		// 入力データ情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

		// サービス契約番号一覧照会
		editErrorInfoEKK0321B011(param, templates, returnCode);

		// 対応記録登録リスト件数分繰り返す
		ArrayList<HashMap<String, Object>> taioKirokAddList = (ArrayList<HashMap<String, Object>>)inMap.get("taio_kirok_add_list");
		for (HashMap<String, Object> taioKirokAddMap : taioKirokAddList)
		{
			editErrorInfoMyBox(param, taioKirokAddMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
			editErrorInfoTaioKirokAdd(param, taioKirokAddMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
			editErrorInfoTaioKirokDtlCall(param, taioKirokAddMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
			editErrorInfoTaioKirokClose(param, taioKirokAddMap, new CAANMsg[]{templates[index]}, returnCode);
			index++;
			// 応対区分カテゴリーリスト件数分繰り返す
			ArrayList<HashMap<String, Object>> ctgrList = (ArrayList<HashMap<String, Object>>)taioKirokAddMap.get("rsp_ctgr_list");
			for (HashMap<String, Object> ctgrMap : ctgrList)
			{
				editErrorInfoCdNmKanri(param, ctgrMap, new CAANMsg[]{templates[index]}, returnCode);
				index++;
			}
		}
		return param;
	
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoMyBox(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

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

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

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// ユーザーＩＤエラー → キューBOXMYBOX現在格納数一覧照会.ユーザーＩＤエラー
		if (!template.isNull(ECR0111B020CBSMsg.KEY_USER_ID_ERR))
		{
			if (!inMap.containsKey(ECR0111B020CBSMsg.KEY_USER_ID_ERR))
			{
				inMap.put(ECR0111B020CBSMsg.KEY_USER_ID_ERR, template.getString(ECR0111B020CBSMsg.KEY_USER_ID_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoTaioKirokAdd(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

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

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

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// 対応ユーザーＩＤエラー → 対応記録登録.対応ユーザーＩＤエラー
		if (!template.isNull(ECR0011D010CBSMsg.TAIO_USER_ID_ERR))
		{
			if (!inMap.containsKey(ECR0011D010CBSMsg.TAIO_USER_ID_ERR))
			{
				inMap.put(ECR0011D010CBSMsg.TAIO_USER_ID_ERR, template.getString(ECR0011D010CBSMsg.TAIO_USER_ID_ERR));
			}
		}
		
		// サービス契約番号エラー → 対応記録登録.サービス契約番号エラー
		if (!template.isNull(ECR0011D010CBSMsg.SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(ECR0011D010CBSMsg.SVC_KEI_NO_ERR))
			{
				inMap.put(ECR0011D010CBSMsg.SVC_KEI_NO_ERR, template.getString(ECR0011D010CBSMsg.SVC_KEI_NO_ERR));
			}
		}
		
		// MYBOX番号エラー → 対応記録登録.MYBOX番号エラー
		if (!template.isNull(ECR0011D010CBSMsg.MYBOX_NO_ERR))
		{
			if (!inMap.containsKey(ECR0011D010CBSMsg.MYBOX_NO_ERR))
			{
				inMap.put(ECR0011D010CBSMsg.MYBOX_NO_ERR, template.getString(ECR0011D010CBSMsg.MYBOX_NO_ERR));
			}
		}
		
		// 対応開始年月日時分秒エラー → 対応記録登録.対応開始年月日時分秒エラー
		if (!template.isNull(ECR0011D010CBSMsg.TAIO_STA_DTM_ERR))
		{
			if (!inMap.containsKey(ECR0011D010CBSMsg.TAIO_STA_DTM_ERR))
			{
				inMap.put(ECR0011D010CBSMsg.TAIO_STA_DTM_ERR, template.getString(ECR0011D010CBSMsg.TAIO_STA_DTM_ERR));
			}
		}
		
		// タイトルエラー → 対応記録登録.タイトルエラー
		if (!template.isNull(ECR0011D010CBSMsg.TITLE_ERR))
		{
			if (!inMap.containsKey(ECR0011D010CBSMsg.TITLE_ERR))
			{
				inMap.put(ECR0011D010CBSMsg.TITLE_ERR, template.getString(ECR0011D010CBSMsg.TITLE_ERR));
			}
		}
		
		// 受付年月日時分秒エラー → 対応記録登録.受付年月日時分秒エラー
		if (!template.isNull(ECR0011D010CBSMsg.UK_DTM_ERR))
		{
			if (!inMap.containsKey(ECR0011D010CBSMsg.UK_DTM_ERR))
			{
				inMap.put(ECR0011D010CBSMsg.UK_DTM_ERR, template.getString(ECR0011D010CBSMsg.UK_DTM_ERR));
			}
		}
		
		// ログインユーザーＩＤエラー → 対応記細登録.ログインユーザーＩＤエラー
		if (!template.isNull(ECR0011D010CBSMsg.LOGIN_USER_ID_ERR))
		{
			if (!inMap.containsKey(ECR0011D010CBSMsg.LOGIN_USER_ID_ERR))
			{
				inMap.put(ECR0011D010CBSMsg.LOGIN_USER_ID_ERR, template.getString(ECR0011D010CBSMsg.LOGIN_USER_ID_ERR));
			}
		}
		
		// ログインユーザー名エラー → 対応記録登録.ログインユーザー名エラー
		if (!template.isNull(ECR0011D010CBSMsg.LOGIN_USER_NM_ERR))
		{
			if (!inMap.containsKey(ECR0011D010CBSMsg.LOGIN_USER_NM_ERR))
			{
				inMap.put(ECR0011D010CBSMsg.LOGIN_USER_NM_ERR, template.getString(ECR0011D010CBSMsg.LOGIN_USER_NM_ERR));
			}
		}
		
		// 業務個別設定組織コードエラー → 対応記録登録.業務個別設定組織コードエラー
		if (!template.isNull(ECR0011D010CBSMsg.WKKBT_ORG_CD_ERR))
		{
			if (!inMap.containsKey(ECR0011D010CBSMsg.WKKBT_ORG_CD_ERR))
			{
				inMap.put(ECR0011D010CBSMsg.WKKBT_ORG_CD_ERR, template.getString(ECR0011D010CBSMsg.WKKBT_ORG_CD_ERR));
			}
		}
		
		// 業務個別設定組織名エラー → 対応記録登録.業務個別設定組織名エラー
		if (!template.isNull(ECR0011D010CBSMsg.WKKBT_ORG_NM_ERR))
		{
			if (!inMap.containsKey(ECR0011D010CBSMsg.WKKBT_ORG_NM_ERR))
			{
				inMap.put(ECR0011D010CBSMsg.WKKBT_ORG_NM_ERR, template.getString(ECR0011D010CBSMsg.WKKBT_ORG_NM_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoTaioKirokDtlCall(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

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

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

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// 対応記録番号エラー → 対応記録明細登録（コール）.対応記録番号エラー
		if (!template.isNull(ECR0021D020CBSMsg.TAIO_KIROK_NO_ERR))
		{
			if (!inMap.containsKey(ECR0021D020CBSMsg.TAIO_KIROK_NO_ERR))
			{
				inMap.put(ECR0021D020CBSMsg.TAIO_KIROK_NO_ERR, template.getString(ECR0021D020CBSMsg.TAIO_KIROK_NO_ERR));
			}
		}
		
		// アクション開始年月日時分秒エラー → 対応記録明細登録（コール）.アクション開始年月日時分秒エラー
		if (!template.isNull(ECR0021D020CBSMsg.ACTION_STA_DTM_ERR))
		{
			if (!inMap.containsKey(ECR0021D020CBSMsg.ACTION_STA_DTM_ERR))
			{
				inMap.put(ECR0021D020CBSMsg.ACTION_STA_DTM_ERR, template.getString(ECR0021D020CBSMsg.ACTION_STA_DTM_ERR));
			}
		}
		
		// アクション完了年月日時分秒エラー → 対応記録明細登録（コール）.アクション完了年月日時分秒エラー
		if (!template.isNull(ECR0021D020CBSMsg.ACTION_FIN_DTM_ERR))
		{
			if (!inMap.containsKey(ECR0021D020CBSMsg.ACTION_FIN_DTM_ERR))
			{
				inMap.put(ECR0021D020CBSMsg.ACTION_FIN_DTM_ERR, template.getString(ECR0021D020CBSMsg.ACTION_FIN_DTM_ERR));
			}
		}
		
		// 対応ユーザーＩＤエラー → 対応記録明細登録（コール）.対応ユーザーＩＤエラー
		if (!template.isNull(ECR0021D020CBSMsg.TAIO_USER_ID_ERR))
		{
			if (!inMap.containsKey(ECR0021D020CBSMsg.TAIO_USER_ID_ERR))
			{
				inMap.put(ECR0021D020CBSMsg.TAIO_USER_ID_ERR, template.getString(ECR0021D020CBSMsg.TAIO_USER_ID_ERR));
			}
		}
		
		// 問合せ内容エラー → 対応記録明細登録（コール）.問合せ内容エラー
		if (!template.isNull(ECR0021D020CBSMsg.TOIAWASE_NAIYO_ERR))
		{
			if (!inMap.containsKey(ECR0021D020CBSMsg.TOIAWASE_NAIYO_ERR))
			{
				inMap.put(ECR0021D020CBSMsg.TOIAWASE_NAIYO_ERR, template.getString(ECR0021D020CBSMsg.TOIAWASE_NAIYO_ERR));
			}
		}
		
		// ログインユーザーＩＤエラー → 対応記録明細登録（コール）.ログインユーザーＩＤエラー
		if (!template.isNull(ECR0021D020CBSMsg.LOGIN_USER_ID_ERR))
		{
			if (!inMap.containsKey(ECR0021D020CBSMsg.LOGIN_USER_ID_ERR))
			{
				inMap.put(ECR0021D020CBSMsg.LOGIN_USER_ID_ERR, template.getString(ECR0021D020CBSMsg.LOGIN_USER_ID_ERR));
			}
		}
		
		// ログインユーザー名エラー → 対応記録明細登録（コール）.ログインユーザー名エラー
		if (!template.isNull(ECR0021D020CBSMsg.LOGIN_USER_NM_ERR))
		{
			if (!inMap.containsKey(ECR0021D020CBSMsg.LOGIN_USER_NM_ERR))
			{
				inMap.put(ECR0021D020CBSMsg.LOGIN_USER_NM_ERR, template.getString(ECR0021D020CBSMsg.LOGIN_USER_NM_ERR));
			}
		}
		
		// 業務個別設定組織コードエラー → 対応記録明細登録（コール）.業務個別設定組織コードエラー
		if (!template.isNull(ECR0021D020CBSMsg.WKKBT_ORG_CD_ERR))
		{
			if (!inMap.containsKey(ECR0021D020CBSMsg.WKKBT_ORG_CD_ERR))
			{
				inMap.put(ECR0021D020CBSMsg.WKKBT_ORG_CD_ERR, template.getString(ECR0021D020CBSMsg.WKKBT_ORG_CD_ERR));
			}
		}
		
		// 業務個別設定組織名エラー → 対応記録明細登録（コール）.業務個別設定組織名エラー
		if (!template.isNull(ECR0021D020CBSMsg.WKKBT_ORG_NM_ERR))
		{
			if (!inMap.containsKey(ECR0021D020CBSMsg.WKKBT_ORG_NM_ERR))
			{
				inMap.put(ECR0021D020CBSMsg.WKKBT_ORG_NM_ERR, template.getString(ECR0021D020CBSMsg.WKKBT_ORG_NM_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoTaioKirokClose(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

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

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

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// 対応記録番号エラー → 対応記録クローズ.対応記録番号エラー
		if (!template.isNull(ECR0011C080CBSMsg.TAIO_KIROK_NO_ERR))
		{
			if (!inMap.containsKey(ECR0011C080CBSMsg.TAIO_KIROK_NO_ERR))
			{
				inMap.put(ECR0011C080CBSMsg.TAIO_KIROK_NO_ERR, template.getString(ECR0011C080CBSMsg.TAIO_KIROK_NO_ERR));
			}
		}
		
		// 対応完了年月日時分秒エラー → 対応記録クローズ.対応完了年月日時分秒エラー
		if (!template.isNull(ECR0011C080CBSMsg.TAIO_FIN_DTM_ERR))
		{
			if (!inMap.containsKey(ECR0011C080CBSMsg.TAIO_FIN_DTM_ERR))
			{
				inMap.put(ECR0011C080CBSMsg.TAIO_FIN_DTM_ERR, template.getString(ECR0011C080CBSMsg.TAIO_FIN_DTM_ERR));
			}
		}
		
		// 対応クローズ年月日時分秒エラー → 対応記録クローズ.対応クローズ年月日時分秒エラー
		if (!template.isNull(ECR0011C080CBSMsg.LAST_END_DTM_ERR))
		{
			if (!inMap.containsKey(ECR0011C080CBSMsg.LAST_END_DTM_ERR))
			{
				inMap.put(ECR0011C080CBSMsg.LAST_END_DTM_ERR, template.getString(ECR0011C080CBSMsg.LAST_END_DTM_ERR));
			}
		}
		
		// アクション開始年月日時分秒エラー → 対応記録クローズ.アクション開始年月日時分秒エラー
		if (!template.isNull(ECR0011C080CBSMsg.ACTION_STA_DTM_ERR))
		{
			if (!inMap.containsKey(ECR0011C080CBSMsg.ACTION_STA_DTM_ERR))
			{
				inMap.put(ECR0011C080CBSMsg.ACTION_STA_DTM_ERR, template.getString(ECR0011C080CBSMsg.ACTION_STA_DTM_ERR));
			}
		}
		
		// アクション完了年月日時分秒エラー → 対応記録クローズ.アクション完了年月日時分秒エラー
		if (!template.isNull(ECR0011C080CBSMsg.ACTION_FIN_DTM_ERR))
		{
			if (!inMap.containsKey(ECR0011C080CBSMsg.ACTION_FIN_DTM_ERR))
			{
				inMap.put(ECR0011C080CBSMsg.ACTION_FIN_DTM_ERR, template.getString(ECR0011C080CBSMsg.ACTION_FIN_DTM_ERR));
			}
		}
		
		// 対応ユーザーＩＤエラー → 対応記録クローズ.対応ユーザーＩＤエラー
		if (!template.isNull(ECR0011C080CBSMsg.TAIO_USER_ID_ERR))
		{
			if (!inMap.containsKey(ECR0011C080CBSMsg.TAIO_USER_ID_ERR))
			{
				inMap.put(ECR0011C080CBSMsg.TAIO_USER_ID_ERR, template.getString(ECR0011C080CBSMsg.TAIO_USER_ID_ERR));
			}
		}
		
		// 更新前更新年月日時分秒エラー → 対応記録クローズ.更新前更新年月日時分秒エラー
		if (!template.isNull(ECR0011C080CBSMsg.UPD_DTM_BF_ERR))
		{
			if (!inMap.containsKey(ECR0011C080CBSMsg.UPD_DTM_BF_ERR))
			{
				inMap.put(ECR0011C080CBSMsg.UPD_DTM_BF_ERR, template.getString(ECR0011C080CBSMsg.UPD_DTM_BF_ERR));
			}
		}
		
		// 業務個別設定組織コードエラー → 対応記録クローズ.業務個別設定組織コードエラー
		if (!template.isNull(ECR0011C080CBSMsg.WKKBT_ORG_CD_ERR))
		{
			if (!inMap.containsKey(ECR0011C080CBSMsg.WKKBT_ORG_CD_ERR))
			{
				inMap.put(ECR0011C080CBSMsg.WKKBT_ORG_CD_ERR, template.getString(ECR0011C080CBSMsg.WKKBT_ORG_CD_ERR));
			}
		}
		
		// 業務個別設定組織名エラー → 対応記録クローズ.業務個別設定組織名エラー
		if (!template.isNull(ECR0011C080CBSMsg.WKKBT_ORG_NM_ERR))
		{
			if (!inMap.containsKey(ECR0011C080CBSMsg.WKKBT_ORG_NM_ERR))
			{
				inMap.put(ECR0011C080CBSMsg.WKKBT_ORG_NM_ERR, template.getString(ECR0011C080CBSMsg.WKKBT_ORG_NM_ERR));
			}
		}
		
		// ログインユーザー名エラー → 対応記録クローズ.ログインユーザー名エラー
		if (!template.isNull(ECR0011C080CBSMsg.LOGIN_USER_NM_ERR))
		{
			if (!inMap.containsKey(ECR0011C080CBSMsg.LOGIN_USER_NM_ERR))
			{
				inMap.put(ECR0011C080CBSMsg.LOGIN_USER_NM_ERR, template.getString(ECR0011C080CBSMsg.LOGIN_USER_NM_ERR));
			}
		}
		
		// ＰＡＲ＿対応ログインユーザー名エラー → 対応記録クローズ.ＰＡＲ＿対応ログインユーザー名エラー
		if (!template.isNull(ECR0011C080CBSMsg.PAR_TAIO_USER_ID_ERR))
		{
			if (!inMap.containsKey(ECR0011C080CBSMsg.PAR_TAIO_USER_ID_ERR))
			{
				inMap.put(ECR0011C080CBSMsg.PAR_TAIO_USER_ID_ERR, template.getString(ECR0011C080CBSMsg.PAR_TAIO_USER_ID_ERR));
			}
		}
		
		// 対応開始年月日時分秒エラー → 対応記録クローズ.対応開始年月日時分秒エラー
		if (!template.isNull(ECR0011C080CBSMsg.TAIO_STA_DTM_ERR))
		{
			if (!inMap.containsKey(ECR0011C080CBSMsg.TAIO_STA_DTM_ERR))
			{
				inMap.put(ECR0011C080CBSMsg.TAIO_STA_DTM_ERR, template.getString(ECR0011C080CBSMsg.TAIO_STA_DTM_ERR));
			}
		}
		
		return param;
	}
	
	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoCdNmKanri(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

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

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

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

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		// ＫＥＹ＿コード種別コードエラー → コード名称管理コード区分前方一致一覧照会.ＫＥＹ＿コード種別コードエラー
		if (!template.isNull(EZM0171B020CBSMsg.KEY_CD_SBT_CD_ERR))
		{
			if (!inMap.containsKey(EZM0171B020CBSMsg.KEY_CD_SBT_CD_ERR))
			{
				inMap.put(EZM0171B020CBSMsg.KEY_CD_SBT_CD_ERR, template.getString(EZM0171B020CBSMsg.KEY_CD_SBT_CD_ERR));
			}
		}
		
		// ＫＥＹ＿コード区分エラー → コード名称管理コード区分前方一致一覧照会.ＫＥＹ＿コード区分エラー
		if (!template.isNull(EZM0171B020CBSMsg.KEY_CD_DIV_ERR))
		{
			if (!inMap.containsKey(EZM0171B020CBSMsg.KEY_CD_DIV_ERR))
			{
				inMap.put(EZM0171B020CBSMsg.KEY_CD_DIV_ERR, template.getString(EZM0171B020CBSMsg.KEY_CD_DIV_ERR));
			}
		}
		
		// ＫＥＹ＿基準年月日 → コード名称管理コード区分前方一致一覧照会.ＫＥＹ＿基準年月日
		if (!template.isNull(EZM0171B020CBSMsg.KEY_STDARDYMD_ERR))
		{
			if (!inMap.containsKey(EZM0171B020CBSMsg.KEY_STDARDYMD_ERR))
			{
				inMap.put(EZM0171B020CBSMsg.KEY_STDARDYMD_ERR, template.getString(EZM0171B020CBSMsg.KEY_STDARDYMD_ERR));
			}
		}
		
		return param;
	}

	/**
	 * サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0321B011(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0321B011CBSMsg.STATUS);

		if (returnCode != 0)
		{
			templateStatus = 9000;
		}

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

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

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

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

		// サービス契約番号一覧照会マップ.ＫＥＹ＿請求契約番号エラー → ＫＥＹ＿請求契約番号エラー
		if (!template.isNull(EKK0321B011CBSMsg.KEY_SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_seiky_kei_no_err"))
			{
				inMap.put("key_seiky_kei_no_err", template.getString(EKK0321B011CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}

		return param;
	}

	/**
	 * 共通領域の設定
	 * 
	 * @param param
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsg(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

		// 【取得元：電文ヘッダ(ヘッダ)】
		// 電文ID
		paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID());
		// ユースケースID
		paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID());
		// オペレーションID
		paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID());
		// サービス呼び出し区分
		paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType());

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

		return paramMap;
	}

	/**
	 * キューBOXMYBOX現在格納数一覧照会用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgMyBox(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

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

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

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

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

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

		// キューBOXMYBOX現在格納数一覧照会.ユーザーID → ユーザーID
		if (JCRUtilCommon.isNull(inMap.get("user_id")))
		{
			template.setNull(ECR0111B020CBSMsg.KEY_USER_ID);
		}
		else
		{
			template.set(ECR0111B020CBSMsg.KEY_USER_ID, (String)inMap.get("user_id"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	/**
	 * 対応記録登録用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgTaioKirokAdd(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

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

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

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

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

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

		// 対応記録登録.ユーザーID → ユーザーID
		if (JCRUtilCommon.isNull(inMap.get("user_id")))
		{
			template.setNull(ECR0011D010CBSMsg.TAIO_USER_ID);
		}
		else
		{
			template.set(ECR0011D010CBSMsg.TAIO_USER_ID, (String)inMap.get("user_id"));
		}
		
		// 対応記録登録.サービス契約番号 → サービス契約番号
		if (JCRUtilCommon.isNull(inMap.get("svc_kei_no")))
		{
			template.setNull(ECR0011D010CBSMsg.SVC_KEI_NO);
		}
		else
		{
			template.set(ECR0011D010CBSMsg.SVC_KEI_NO, (String)inMap.get("svc_kei_no"));
		}
		
		// 対応記録登録.ＭＹＢＯＸ番号 → ＭＹＢＯＸ番号
		if (JCRUtilCommon.isNull(inMap.get("mybox_no")))
		{
			template.setNull(ECR0011D010CBSMsg.MYBOX_NO);
		}
		else
		{
			template.set(ECR0011D010CBSMsg.MYBOX_NO, (String)inMap.get("mybox_no"));
		}
		
		// 対応記録登録.年月日時分秒 → 対応開始年月日時分秒
		if (JCRUtilCommon.isNull(inMap.get("dtm")))
		{
			template.setNull(ECR0011D010CBSMsg.TAIO_STA_DTM);
		}
		else
		{
			template.set(ECR0011D010CBSMsg.TAIO_STA_DTM, (String)inMap.get("dtm"));
		}
		
		// 対応記録登録.タイトル → タイトル
		if (JCRUtilCommon.isNull(inMap.get("title")))
		{
			template.setNull(ECR0011D010CBSMsg.TITLE);
		}
		else
		{
			template.set(ECR0011D010CBSMsg.TITLE, (String)inMap.get("title"));
		}
		
		// 対応記録登録.年月日時分秒 → 受付年月日時分秒
		if (JCRUtilCommon.isNull(inMap.get("dtm")))
		{
			template.setNull(ECR0011D010CBSMsg.UK_DTM);
		}
		else
		{
			template.set(ECR0011D010CBSMsg.UK_DTM, (String)inMap.get("dtm"));
		}
		
		// 対応記録登録.ユーザーID → ログインユーザーID
		if (JCRUtilCommon.isNull(inMap.get("user_id")))
		{
			template.setNull(ECR0011D010CBSMsg.LOGIN_USER_ID);
		}
		else
		{
			template.set(ECR0011D010CBSMsg.LOGIN_USER_ID, (String)inMap.get("user_id"));
		}
		
		// 対応記録登録.ユーザー名 → ログインユーザー名
		if (JCRUtilCommon.isNull(inMap.get("user_nm")))
		{
			template.setNull(ECR0011D010CBSMsg.LOGIN_USER_NM);
		}
		else
		{
			template.set(ECR0011D010CBSMsg.LOGIN_USER_NM, (String)inMap.get("user_nm"));
		}
		
		// 対応記録登録.業務個別設定組織コード → 業務個別設定組織コード
		if (JCRUtilCommon.isNull(inMap.get("wkkbt_org_cd")))
		{
			template.setNull(ECR0011D010CBSMsg.WKKBT_ORG_CD);
		}
		else
		{
			template.set(ECR0011D010CBSMsg.WKKBT_ORG_CD, (String)inMap.get("wkkbt_org_cd"));
		}
		
		// 対応記録登録.業務個別設定組織名 → 業務個別設定組織名
		if (JCRUtilCommon.isNull(inMap.get("wkkbt_org_nm")))
		{
			template.setNull(ECR0011D010CBSMsg.WKKBT_ORG_NM);
		}
		else
		{
			template.set(ECR0011D010CBSMsg.WKKBT_ORG_NM, (String)inMap.get("wkkbt_org_nm"));
		}
		
		// 対応記録登録.クローズ不可コードの設定
		template.set(ECR0011D010CBSMsg.CLOSE_FAIL_CD, "0");
		// 対応記録登録.一時保存有無の設定
		template.set(ECR0011D010CBSMsg.TMP_SAVE_UM, "0");
		
		// null項目の設定
		template.set(ECR0011D010CBSMsg.PROSCST_NO, objNull);
		template.set(ECR0011D010CBSMsg.MYBOX_KAKNO_DTM, objNull);
		template.set(ECR0011D010CBSMsg.TOIAWASE_STAT_CD, objNull);
		template.set(ECR0011D010CBSMsg.TOIAWASE_UK_SBT_CD, objNull);
		template.set(ECR0011D010CBSMsg.EASY_MEMO, objNull);
		template.set(ECR0011D010CBSMsg.CALLBK_KIBO_YMD, objNull);
		template.set(ECR0011D010CBSMsg.CALLBK_KIBO_TIME, objNull);
		template.set(ECR0011D010CBSMsg.CALLBK_SHITEI_TYPE_CD, objNull);
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * 対応記録明細登録（コール）用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgTaioKirokDtlCall(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

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

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

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

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

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

		// 対応記録明細登録（コール）.対応記録番号 → 対応記録番号
		if (JCRUtilCommon.isNull(inMap.get("taio_kirok_no")))
		{
			template.setNull(ECR0021D020CBSMsg.TAIO_KIROK_NO);
		}
		else
		{
			template.set(ECR0021D020CBSMsg.TAIO_KIROK_NO, (String)inMap.get("taio_kirok_no"));
		}
		
		// 対応記録明細登録（コール）.年月日時分秒 → アクション開始年月日時分秒
		if (JCRUtilCommon.isNull(inMap.get("dtm")))
		{
			template.setNull(ECR0021D020CBSMsg.ACTION_STA_DTM);
		}
		else
		{
			template.set(ECR0021D020CBSMsg.ACTION_STA_DTM, (String)inMap.get("dtm"));
		}
		
		// 対応記録明細登録（コール）.年月日時分秒 → アクション完了年月日時分秒
		if (JCRUtilCommon.isNull(inMap.get("dtm")))
		{
			template.setNull(ECR0021D020CBSMsg.ACTION_FIN_DTM);
		}
		else
		{
			template.set(ECR0021D020CBSMsg.ACTION_FIN_DTM, (String)inMap.get("dtm"));
		}
		
		// 対応記録明細登録（コール）.ユーザーID → 対応ユーザーID
		if (JCRUtilCommon.isNull(inMap.get("user_id")))
		{
			template.setNull(ECR0021D020CBSMsg.TAIO_USER_ID);
		}
		else
		{
			template.set(ECR0021D020CBSMsg.TAIO_USER_ID, (String)inMap.get("user_id"));
		}
		
		// 対応記録明細登録（コール）.問合せ内容 → 問合せ内容
		if (JCRUtilCommon.isNull(inMap.get("toiawase_naiyo")))
		{
			template.setNull(ECR0021D020CBSMsg.TOIAWASE_NAIYO);
		}
		else
		{
			template.set(ECR0021D020CBSMsg.TOIAWASE_NAIYO, (String)inMap.get("toiawase_naiyo"));
		}
		
		// 対応記録明細登録（コール）.ユーザーID → ログインユーザーID
		if (JCRUtilCommon.isNull(inMap.get("user_id")))
		{
			template.setNull(ECR0021D020CBSMsg.LOGIN_USER_ID);
		}
		else
		{
			template.set(ECR0021D020CBSMsg.LOGIN_USER_ID, (String)inMap.get("user_id"));
		}
		
		// 対応記録明細登録（コール）.ユーザー名 → ログインユーザー名
		if (JCRUtilCommon.isNull(inMap.get("user_nm")))
		{
			template.setNull(ECR0021D020CBSMsg.LOGIN_USER_NM);
		}
		else
		{
			template.set(ECR0021D020CBSMsg.LOGIN_USER_NM, (String)inMap.get("user_nm"));
		}
		
		// 対応記録明細登録（コール）.業務個別設定組織コード → 業務個別設定組織コード
		if (JCRUtilCommon.isNull(inMap.get("wkkbt_org_cd")))
		{
			template.setNull(ECR0021D020CBSMsg.WKKBT_ORG_CD);
		}
		else
		{
			template.set(ECR0021D020CBSMsg.WKKBT_ORG_CD, (String)inMap.get("wkkbt_org_cd"));
		}
		
		// 対応記録明細登録（コール）.業務個別設定組織名 → 業務個別設定組織名
		if (JCRUtilCommon.isNull(inMap.get("wkkbt_org_nm")))
		{
			template.setNull(ECR0021D020CBSMsg.WKKBT_ORG_NM);
		}
		else
		{
			template.set(ECR0021D020CBSMsg.WKKBT_ORG_NM, (String)inMap.get("wkkbt_org_nm"));
		}
		
		// 対応記録明細登録（コール）.編集状態フラグの設定
		template.set(ECR0021D020CBSMsg.HENSHU_STAT_FLG, "0");
		
		// null項目の設定
		template.set(ECR0021D020CBSMsg.TOIAWASE_MOTO_NM, objNull);
		template.set(ECR0021D020CBSMsg.ANS_NAIYO, objNull);
		template.set(ECR0021D020CBSMsg.CONTACT_SAKI_CD, objNull);
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * 対応記録クローズ用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgTaioKirokClose(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

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

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

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

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

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

		// 対応記録クローズ.対応記録番号 → 対応記録番号
		if (JCRUtilCommon.isNull(inMap.get("taio_kirok_no")))
		{
			template.setNull(ECR0011C080CBSMsg.TAIO_KIROK_NO);
		}
		else
		{
			template.set(ECR0011C080CBSMsg.TAIO_KIROK_NO, (String)inMap.get("taio_kirok_no"));
		}
		
		// 対応記録クローズ.年月日時分秒 → 対応完了年月日時分秒
		if (JCRUtilCommon.isNull(inMap.get("dtm")))
		{
			template.setNull(ECR0011C080CBSMsg.TAIO_FIN_DTM);
		}
		else
		{
			template.set(ECR0011C080CBSMsg.TAIO_FIN_DTM, (String)inMap.get("dtm"));
		}
		
		// 対応記録クローズ.年月日時分秒 → 対応クローズ年月日時分秒
		if (JCRUtilCommon.isNull(inMap.get("dtm")))
		{
			template.setNull(ECR0011C080CBSMsg.LAST_END_DTM);
		}
		else
		{
			template.set(ECR0011C080CBSMsg.LAST_END_DTM, (String)inMap.get("dtm"));
		}
		
		// 対応記録クローズ.年月日時分秒 → アクション開始年月日時分秒
		if (JCRUtilCommon.isNull(inMap.get("dtm")))
		{
			template.setNull(ECR0011C080CBSMsg.ACTION_STA_DTM);
		}
		else
		{
			template.set(ECR0011C080CBSMsg.ACTION_STA_DTM, (String)inMap.get("dtm"));
		}
		
		// 対応記録クローズ.年月日時分秒 → アクション完了年月日時分秒
		if (JCRUtilCommon.isNull(inMap.get("dtm")))
		{
			template.setNull(ECR0011C080CBSMsg.ACTION_FIN_DTM);
		}
		else
		{
			template.set(ECR0011C080CBSMsg.ACTION_FIN_DTM, (String)inMap.get("dtm"));
		}
		
		// 対応記録クローズ.ユーザーID → 対応ユーザーID
		if (JCRUtilCommon.isNull(inMap.get("user_id")))
		{
			template.setNull(ECR0011C080CBSMsg.TAIO_USER_ID);
		}
		else
		{
			template.set(ECR0011C080CBSMsg.TAIO_USER_ID, (String)inMap.get("user_id"));
		}
		
		// 対応記録クローズ.更新年月日時分秒 → 更新前更新年月日時分秒
		if (JCRUtilCommon.isNull(inMap.get("upd_dtm")))
		{
			template.setNull(ECR0011C080CBSMsg.UPD_DTM_BF);
		}
		else
		{
			template.set(ECR0011C080CBSMsg.UPD_DTM_BF, (String)inMap.get("upd_dtm"));
		}
		
		// 対応記録クローズ.業務個別設定組織コード → 業務個別設定組織コード
		if (JCRUtilCommon.isNull(inMap.get("wkkbt_org_cd")))
		{
			template.setNull(ECR0011C080CBSMsg.WKKBT_ORG_CD);
		}
		else
		{
			template.set(ECR0011C080CBSMsg.WKKBT_ORG_CD, (String)inMap.get("wkkbt_org_cd"));
		}
		
		// 対応記録クローズ.業務個別設定組織名 → 業務個別設定組織名
		if (JCRUtilCommon.isNull(inMap.get("wkkbt_org_nm")))
		{
			template.setNull(ECR0011C080CBSMsg.WKKBT_ORG_NM);
		}
		else
		{
			template.set(ECR0011C080CBSMsg.WKKBT_ORG_NM, (String)inMap.get("wkkbt_org_nm"));
		}
		
		// 対応記録クローズ.ユーザー名 → ログインユーザー名
		if (JCRUtilCommon.isNull(inMap.get("user_nm")))
		{
			template.setNull(ECR0011C080CBSMsg.LOGIN_USER_NM);
		}
		else
		{
			template.set(ECR0011C080CBSMsg.LOGIN_USER_NM, (String)inMap.get("user_nm"));
		}
		
		// 対応記録クローズ.ユーザーID → ＰＡＲ＿対応ユーザーID
		if (JCRUtilCommon.isNull(inMap.get("user_id")))
		{
			template.setNull(ECR0011C080CBSMsg.PAR_TAIO_USER_ID);
		}
		else
		{
			template.set(ECR0011C080CBSMsg.PAR_TAIO_USER_ID, (String)inMap.get("user_id"));
		}
		
		// 対応記録クローズ.年月日時分秒 → 対応開始年月日時分秒
		if (JCRUtilCommon.isNull(inMap.get("dtm")))
		{
			template.setNull(ECR0011C080CBSMsg.TAIO_STA_DTM);
		}
		else
		{
			template.set(ECR0011C080CBSMsg.TAIO_STA_DTM, (String)inMap.get("dtm"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	/**
	 * コード名称管理コード区分前方一致一覧照会用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgCdNmKanri(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

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

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

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

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

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

		// コード名称管理コード区分前方一致一覧照会.ＫＥＹ＿コード種別コード → ＫＥＹ＿コード種別コード
		template.set(EZM0171B020CBSMsg.KEY_CD_SBT_CD, "CD01255");
		
		// コード名称管理コード区分前方一致一覧照会.ＫＥＹ＿コード区分 → ＫＥＹ＿コード区分
		String prcTaioKirokSbtCd = (String)inMap.get("prc_taio_kirok_sbt_cd");
		String prcTaioKirokDtlBunruiCd = (String)inMap.get("prc_taio_kirok_dtl_bunrui_cd");
		String tkskst = (String)inMap.get("tkskst");
		String cdDiv = getCdDiv(prcTaioKirokSbtCd, prcTaioKirokDtlBunruiCd, tkskst);
		if (JCRUtilCommon.isNull(cdDiv))
		{
			template.setNull(EZM0171B020CBSMsg.KEY_CD_DIV);
		}
		else
		{
			template.set(EZM0171B020CBSMsg.KEY_CD_DIV, cdDiv);
		}
		
		// コード名称管理コード区分前方一致一覧照会.ＫＥＹ＿基準年月日 → ＫＥＹ＿基準年月日
		String stdardYmd = (String)param.getControlMapData(SCControlMapKeys.OPE_DATE);
		if (JCRUtilCommon.isNull(stdardYmd))
		{
			template.setNull(EZM0171B020CBSMsg.KEY_STDARDYMD);
		}
		else
		{
			template.set(EZM0171B020CBSMsg.KEY_STDARDYMD, stdardYmd);
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * サービス契約番号一覧照会用メッセージ設定処理.<br>
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEKK0321B011(IRequestParameterReadWrite param, HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

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

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

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

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

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

		// 請求契約番号
		String seikyKeiNo = (String)inMap.get("seiky_kei_no");
		if (JCRUtilCommon.isNull(seikyKeiNo))
		{
			template.setNull(EKK0321B011CBSMsg.KEY_SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK0321B011CBSMsg.KEY_SEIKY_KEI_NO, seikyKeiNo);
		}

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

		return paramMap;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgMyBox(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoMyBox(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}
		
		CAANMsg[] myBoxList = templates[0].getCAANMsgList(ECR0111B020CBSMsg.ECR0111B020CBSMSG1LIST);
		if (myBoxList.length > 0)
		{
			dataMap.put("mybox_no", myBoxList[0].getString(ECR0111B020CBSMsg1List.MYBOX_NO));
		}
		else
		{
			throw new SCCallException("キューBOXMYBOX現在格納数一覧照会取得結果0件", returnCode.toString(), Integer.parseInt(status));
		}
		
		return retParam;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgTaioKirokAdd(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg taioKirok = templates[0];
		// 対応記録番号を設定
		String taioKirokNo = taioKirok.getString(ECR0011D010CBSMsg.TAIO_KIROK_NO);
		dataMap.put("taio_kirok_no", taioKirokNo);
		// 更新年月日時分秒を設定
		String updDtm = taioKirok.getString(ECR0011D010CBSMsg.UPD_DTM);
		dataMap.put("upd_dtm", updDtm);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoTaioKirokAdd(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}
		
		return retParam;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgTaioKirokDtlCall(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoTaioKirokDtlCall(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}
		
		return retParam;
	}
	
	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgTaioKirokClose(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoTaioKirokClose(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}
		
		return retParam;
	}

	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgCdNmKanri(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		ArrayList cdNmKanriList = new ArrayList();
		
		CAANMsg[] outMsgLst = templates[0].getCAANMsgList(EZM0171B020CBSMsg.EZM0171B020CBSMSG1LIST);
		for (CAANMsg outMsg : outMsgLst)
		{
			HashMap cdNmKanriMap = new HashMap();
			cdNmKanriMap.put(EZM0171B020CBSMsg1List.CD_DIV, outMsg.getString(EZM0171B020CBSMsg1List.CD_DIV));
			cdNmKanriMap.put(EZM0171B020CBSMsg1List.CD_DIV_NM, outMsg.getString(EZM0171B020CBSMsg1List.CD_DIV_NM));
			cdNmKanriList.add(cdNmKanriMap);
		}
		dataMap.put(EZM0171B020CBSMsg.EZM0171B020CBSMSG1LIST, cdNmKanriList);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoCdNmKanri(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}
		
		return retParam;
	}

	/**
	 * 
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0321B011(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		ArrayList<HashMap<String, String>> svcKeiNoList = new ArrayList();
		
		CAANMsg[] outMsgLst = templates[0].getCAANMsgList(EKK0321B011CBSMsg.EKK0321B011CBSMSG1LIST);

		if (outMsgLst != null)
		{
			for (CAANMsg outMsg : outMsgLst)
			{
				HashMap<String, String> svckeiNoMap = new HashMap<String, String>();
				svckeiNoMap.put(EKK0321B011CBSMsg1List.SVC_KEI_NO, outMsg.getString(EKK0321B011CBSMsg1List.SVC_KEI_NO));
				svcKeiNoList.add(svckeiNoMap);
			}
			dataMap.put(EKK0321B011CBSMsg.EKK0321B011CBSMSG1LIST, svcKeiNoList);
		}
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEKK0321B011(param, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}
		
		return retParam;
	}

	/**
	 * カテゴリリスト作成
	 * <br>
	 * @param inMap 入力マップ
	 * @param taioKirokAddMap 対応記録登録マップ
	 * @param index インデックス
	 * @return Map<?, ?> ＳＣ呼出結果
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private HashMap<String, Object> getCategoryLevel(HashMap<String, Object> ctgrMap, HashMap<String, Object> taioKirokAddMap, int index) throws Exception
	{
		// 応対区分カテゴリーリストマップ
		HashMap<String, Object> rspCtgrMap = new HashMap<String, Object>();
		rspCtgrMap.put("taio_kirok_no", taioKirokAddMap.get("taio_kirok_no"));
		rspCtgrMap.put("taio_kirok_ucwk_no", Integer.toString(index));
		rspCtgrMap.put("toiawase_rsp_div", "01");
		rspCtgrMap.put("cust_koe", objNull);
		rspCtgrMap.put("csr_koe", objNull);
		rspCtgrMap.put("dsp_jun", Integer.toString(index));
		rspCtgrMap.put("tiokr_uw_cst_wk_add_div", "5");
		rspCtgrMap.put("henshu_stat_flg", "0");
		
		ArrayList<HashMap<String, Object>> cdNmKanriList = (ArrayList<HashMap<String, Object>>)ctgrMap.get(EZM0171B020CBSMsg.EZM0171B020CBSMSG1LIST);

		//カテゴリーＮリスト
		ArrayList<HashMap<String, Object>> uwCtgrnList = new ArrayList<HashMap<String, Object>>();
		
		String joiCtgr = "";
		int cnt = 0;
		
		for (HashMap<String, Object> cdNmKanriMap : cdNmKanriList)
		{
			cnt++;
			HashMap<String, Object> ctgrnMap = new HashMap<String, Object>();
			
			String level = ((String)cdNmKanriMap.get(EZM0171B020CBSMsg1List.CD_DIV)).substring(9);
			
			ctgrnMap.put("taio_kirok_no", taioKirokAddMap.get("taio_kirok_no"));
			ctgrnMap.put("taio_kirok_ucwk_no", Integer.toString(index));
			ctgrnMap.put("taiokrk_uw_ctgr_lv", JPCUtilCommon.fillZero(level, 3, false));
			if("1".equals(level))
			{
				ctgrnMap.put("joi_rnkt_ctgr_nm", JPCUtilCommon.adjustCharSize((String) taioKirokAddMap.get("wkkbt_org_cd"), 160, ""));
			}
			else
			{
				ctgrnMap.put("joi_rnkt_ctgr_nm", JPCUtilCommon.adjustCharSize(joiCtgr, 160, ""));
			}
			
			joiCtgr += (String)cdNmKanriMap.get(EZM0171B020CBSMsg1List.CD_DIV_NM);
			if(cnt == cdNmKanriList.size())
			{
				ctgrnMap.put("kai_ctgr_um", "0");
			}
			else
			{
				ctgrnMap.put("kai_ctgr_um", "1");
			}
			ctgrnMap.put("taiokrk_uw_ctgr_nm", (String)cdNmKanriMap.get(EZM0171B020CBSMsg1List.CD_DIV_NM));
			ctgrnMap.put("close_fail_cd", "0");
			ctgrnMap.put("henshu_stat_flg", "0");
			ctgrnMap.put("login_user_id", taioKirokAddMap.get("user_id"));
			ctgrnMap.put("login_user_nm", taioKirokAddMap.get("user_nm"));
			ctgrnMap.put("wkkbt_org_cd", taioKirokAddMap.get("wkkbt_org_cd"));
			ctgrnMap.put("wkkbt_org_nm", taioKirokAddMap.get("wkkbt_org_nm"));
			ctgrnMap.put("syrzm_flg", "0");

			uwCtgrnList.add(ctgrnMap);
		}
		
		rspCtgrMap.put("UW_CTGRN_List", uwCtgrnList);

		return rspCtgrMap;
	}
	
	/**
	 * コード区分を取得
	 * @param prcTaioKirokSbtCd 料金対応記録種別コード
	 * @param prcTaioKirokDtlBunruiCd 料金対応記録明細分類コード
	 * @param tkskst 督促ステータス
	 * @return コード区分
	 */
	private String getCdDiv(String prcTaioKirokSbtCd, String prcTaioKirokDtlBunruiCd, String tkskst)
	{
		//コード区分作成
		String cdDiv = null;
		if (nullOrEmpty(prcTaioKirokSbtCd))
		{
			cdDiv = "ZZZ";
		}
		else
		{
			cdDiv = prcTaioKirokSbtCd;
		}
		
		if (nullOrEmpty(prcTaioKirokDtlBunruiCd))
		{
			cdDiv += "ZZZZ";
		}
		else
		{
			cdDiv += prcTaioKirokDtlBunruiCd;
		}
		
		if (nullOrEmpty(tkskst))
		{
			cdDiv += "ZZ";
		}
		else
		{
			cdDiv += tkskst;
		}
		return cdDiv;
	}
	
	
	
	/**
	 * 文字の空白チェック。<BR>
	 * @param val 検査文字
	 * @return boolean 空白またはNullのときtrue
	 */
	private boolean nullOrEmpty(String val)
	{
		if (val == null)
		{
			return true;
		}
		return "".equals(val);
	}

}