/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：JKKManAplyWribSvcKeiCC
*   ソースファイル名：JKKManAplyWribSvcKeiCC.java
*   作成者          ：富士通
*   日付            ：2013年02月28日
*＜機能概要＞
*   割引サービス契約手動適用部品
*＜修正履歴＞
*   バージョン  修正日       修正者      修正内容
*   v5.00.00    2013/02/08   FJ）多田    【IT1-2013-0000337】割引集約対応
*   v6.00.00    2013/11/26   FJ) 中山    【OM-2013-0004488】住変確定後の工事連携までのサービス追加対応
*   v6.01.00    2013/11/27   FJ) 中山    【IT2-2013-0000768】照査前のキャンセル回線機器の回復対応
*   v7.00.00    2013/11/08   FJ）松田    【ANK-1578-00-00】多機能ルーター(機器追加)
*   v7.01.00    2014/01/22   FJ）松田    【TAI-2014-0000001】多機能ルーター(機器追加)強化試験：割引
*   v72.00.00   2025/01/29   FJ) 舘山    【#83584】HGW瑕疵内対応（grep対応洩れ）
*
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.util.ArrayList;
import java.util.HashMap;
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.CCException;
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.JKKStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.util.JKKCommonUtil;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0161B512CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0161B512CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341B516CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341B516CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341B508CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341B508CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0351B512CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0351B512CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0451C070CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0451D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0451D010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1391C040CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1391D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1401D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811B502CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811B502CBSMsg1List;

/**
 * 割引サービス契約手動適用部品
 * <br>
 * @author 富士通
 */
public class JKKManAplyWribSvcKeiCC extends AbstractCommonComponent
{
	/** リターンメッセージ */
	private static final String RETURN_MESSAGE_STRING = "RETURN_MESSAGE_";
	/** リターンメッセージ */
	private static final String RETURN_MESSAGE_FORMAT = "%1$04d";

	/** エラー用 */
	private static final String SC_ERROR_STRING = "サービスコンポーネントエラー";
	
	/** 割引サービス契約手動適用CCワーク名 */
	private static final String CC_WORK_AREA_NAME_WRIB = "JKKManAplyWribSvcKeiCCWork";
	
	/** 作業ＫＥＹ名：サービス契約情報作業用リスト */
	private static final String SVC_KEI_INFO_LIST_WORK = "svcKeiInfoListWork";
	/** 作業ＫＥＹ名：サービス契約内訳情報作業用リスト */
	private static final String SVC_KEI_UCWK_INFO_LIST_WORK = "svcKeiUcwkInfoListWork";
	/** 作業ＫＥＹ名：オプションサービス契約情報作業用リスト */
	private static final String OP_SVC_KEI_INFO_LIST_WORK = "opSvcKeiInfoListWork";
	/** 作業ＫＥＹ名：サブオプションサービス契約情報作業用リスト */
	private static final String SBOP_SVC_KEI_INFO_LIST_WORK = "sbopSvcKeiInfoListWork";
	/** 作業ＫＥＹ名：機器提供サービス契約情報作業用リスト */
	private static final String KKTK_SVC_KEI_INFO_LIST_WORK = "kktkSvcKeiInfoListWork";
	/** 作業ＫＥＹ名：機器オプションサービス契約情報作業用リスト */
	private static final String KKOP_SVC_KEI_INFO_LIST_WORK = "kkopSvcKeiInfoListWork";
	
	/** 作業ＫＥＹ名：全サービス契約内訳情報作業用リスト */
	private static final String ALL_SVC_KEI_UCWK_INFO_LIST_WK = "allSvcKeiUcwkInfoListWork";
	/** 作業ＫＥＹ名：全オプションサービス契約情報作業用リスト */
	private static final String ALL_OP_SVC_KEI_INFO_LIST_WK = "allOpSvcKeiInfoListWork";
	/** 作業ＫＥＹ名：全サブオプションサービス契約情報作業用リスト */
	private static final String ALL_SBOP_SVC_KEI_INFO_LIST_WK = "allSbopSvcKeiInfoListWork";
	/** 作業ＫＥＹ名：全機器提供サービス契約情報作業用リスト */
	private static final String ALL_KKTK_SVC_KEI_INFO_LIST_WK = "allKktkSvcKeiInfoListWork";
	/** 作業ＫＥＹ名：全サブオプションサービス契約情報作業用リスト */
	private static final String ALL_KKOP_SVC_KEI_INFO_LIST_WK = "allKkopSvcKeiInfoListWork";
	
	/** 作業ＫＥＹ名：割引サービス登録マップリスト */
	private static final String WRIB_SVC_KEI_ADD_LIST_WORK = "wribSvcKeiAddListWork";
	/** 作業ＫＥＹ名：割引サービス登録マップリスト */
	private static final String DCHSKMST_TG_KEI_ADD_LIST_WORK = "dchskmstTgKeiAddListWork";
	/** 作業ＫＥＹ名：割引サービス登録マップリスト */
	private static final String DCHSKMST_ADD_LIST_WORK = "dchskmstAddListWork";
	/** 作業ＫＥＹ名：更新年月日更新対象マップ */
	private static final String UPD_YMD_TG_MAP_WORK = "updYmdTgMapWork";
	/** 作業ＫＥＹ名：更新対象サービス契約番号リスト */
	private static final String UPD_TG_SVC_KEI_NO_LIST = "updTgSvcKeiNoList";
	
	/** サービス契約対象割引整合性チェック情報格納マップ */
	private HashMap<String, Object> svcTgWribSeigoMap = null;
	
	/** 割引が何に紐付くかをあらわす列挙型 */
	private static enum WRIB_TYPE
	{
		NONE,			// 対象外
		SVC_KEI,		// サービス契約に紐付く
		SVC_KEI_UCWK,	// サービス契約内訳に紐付く
		OP_SVC_KEI,		// オプションサービス契約に紐付く
		SBOP_SVC_KEI,	// サブオプションサービス契約に紐付く
		KKTK_SVC_KEI,	// 機器提供サービス契約に紐付く
		KKOP_SVC_KEI;	// 機器オプションサービス契約に紐付く
	}
	
	/** 割引がどのサービスの種類に紐付くかをあらわす列挙型 */
	private static enum WRIB_KIND_CD
	{
		NET				// eo光ネット
		, TEL			// eo光電話
		, TV			// eo光テレビ
		, MBL			// eoモバイル
		, ADSL			// eoADSL
		, KISN_KEI_KIKI	// 回線系機器
		, KIKI_OP;		// 機器オプション
	}

	/**
	 * 割引手動適用メイン処理
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @return リクエストパラメータ
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite manAplyWribSvcKei(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		HashMap<String, Object> paramMap = setSCInputCommonData(param, new HashMap<String, Object>());
		Map<?, ?> result = null;
		CAANMsg template = null;

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

		// サービス契約番号リスト
		ArrayList<String> svcKeiNoList = getSvcKeiNoList(param, (ArrayList)inMap.get("svc_kei_no_list"));

		// サービス契約番号が設定されていなければ処理を終了する
		if (svcKeiNoList.size() == 0)
		{
			return param;
		}

		for (String svcKeiNo : svcKeiNoList)
		{
			if (JKKBpCommon.isNull(svcKeiNo))
			{
				continue;
			}
			
			svcTgWribSeigoMap = null;
			
			// サービス契約一意照会
			template = editInEKK0081A010Msg(param, fixedText, svcKeiNo); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editOutEKK0081A010Msg(result, param, fixedText); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
			
			// サービス契約内訳一覧照会（サービス契約番号）
			template = editInEKK0161B512Msg(param, fixedText, svcKeiNo); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editOutEKK0161B512Msg(result, param, fixedText); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
			
			// 照査前オプション一覧照会
			template = editInEKK0351B512Msg(param, fixedText, svcKeiNo); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editOutEKK0351B512Msg(result, param, fixedText); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
			
			// 照査前機器提供サービス契約一覧照会
			template = editInEKK0341B508Msg(param, fixedText, svcKeiNo); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editOutEKK0341B508Msg(result, param, fixedText); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		
		String svcKeiKaisenUcwkNo = getSvcKeiKaisenUcwkNo(param, fixedText);
		if (!JKKBpCommon.isNull(svcKeiKaisenUcwkNo))
		{
			// 照査前回線機器提供サービス契約一覧照会
			template = editInEKK0341B516Msg(param, fixedText, svcKeiKaisenUcwkNo); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editOutEKK0341B516Msg(result, param, fixedText); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		
		for (String kktkSvcKeiNo : getKktkSvcKeiNoList(param))
		{
			// 照査前機器オプションサービス契約一覧照会
			template = editInEKK2811B502Msg(param, fixedText, kktkSvcKeiNo); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editOutEKK2811B502Msg(result, param, fixedText, kktkSvcKeiNo); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}

		// 割引情報の設定
		setWribInfo(param, fixedText);

		// 割引削除用マップリスト
		ArrayList delList = (ArrayList)inMap.get("del_wrib_svc_kei_no_list");

		for (HashMap delWribSvcMap : (ArrayList<HashMap>)delList)
		{
			// 割引サービス契約キャンセル
			template = editInEKK0451C070(param, fixedText, delWribSvcMap); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK0451C070(result, param, fixedText, delWribSvcMap); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}

		// 割引登録用マップリスト
		ArrayList addListWork = getWribSvcKeiAddListWork(param);
		for (HashMap addWribSvcMap : (ArrayList<HashMap>)addListWork)
		{
			// 割引サービス契約登録
			template = editInEKK0451D010(param, fixedText, addWribSvcMap);
			result = scCall.run(putParamMap(paramMap, template), handle);
			editRetEKK0451D010(result, param, fixedText);
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}

		// 汎用情報の設定
		setHanyoInfo(param, fixedText);

		// 汎用削除用マップリスト
		delList = (ArrayList)inMap.get("del_dchskmst_no_list");
		for (HashMap delHanyoSvcMap : (ArrayList<HashMap>)delList)
		{
			// データ抽出項目設定完了
			template = editInEKK1391C040(param, fixedText, delHanyoSvcMap); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK1391C040(result, param, fixedText, delHanyoSvcMap); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}

		// 汎用登録用マップリスト
		addListWork = getDchskmstAddListWork(param);
		for (HashMap addDchskmstMap : (ArrayList<HashMap>)addListWork)
		{
			// データ抽出項目設定登録
			template = editInEKK1391D010(param, fixedText, addDchskmstMap);
			result = scCall.run(putParamMap(paramMap, template), handle);
			editRetEKK1391D010(result, param, fixedText);
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}

			ArrayList dchskmstTgKeiAddListWork = (ArrayList)addDchskmstMap.get(DCHSKMST_TG_KEI_ADD_LIST_WORK);
			for (HashMap dchskmstTgKeiAddMap : (ArrayList<HashMap>)dchskmstTgKeiAddListWork)
			{
				// データ抽出項目設定対象契約登録
				template = editInEKK1401D010(param, fixedText, dchskmstTgKeiAddMap);
				result = scCall.run(putParamMap(paramMap, template), handle);
				editRetEKK1401D010(result, param, fixedText);
				if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
				{ // ステータスが単項目エラー以上であれば例外をスロー
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}

			// 作業領域の取得
			HashMap workMap = getWorkMap(param);
			String updDtm = (String)workMap.get("1391_upd_dtm");
			// 更新年月日を更新する対象のサービスリストを設定
			setUpdUpdYmdTgSvcKeiNoWork(param, dchskmstTgKeiAddListWork);
			// サービスリストの最終更新年月日を更新
			setUpdSvcUpdYmd(param, updDtm);

		}

		return param;
	}

	/**
	 * サービス契約回線内訳番号を取得します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return サービス契約回線内訳番号
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private String getSvcKeiKaisenUcwkNo(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		HashMap inMap = (HashMap)param.getData(fixedText);
		if (null == inMap)
		{
			return null;
		}
		
		if (null != inMap.get("key_svc_kei_kaisen_ucwk_no") && !"".equals(inMap.get("key_svc_kei_kaisen_ucwk_no")))
		{
			return (String)inMap.get("key_svc_kei_kaisen_ucwk_no");
		}
		
		String svcKeiKaisenUcwkNo = getWorkMapValue(param, "JKKAddUsePlaceInfoCCWork", "svc_kei_kaisen_ucwk_no");
		if (null != svcKeiKaisenUcwkNo && !"".equals(svcKeiKaisenUcwkNo))
		{
			return svcKeiKaisenUcwkNo;
		}
		
		return null;
	}

	/**
	 * ＢＰチェック用の入力パラメータを作成します。
	 * <br />
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return BPチェックパラメータマップ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public HashMap getInvokeCBS(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{

		String ccName = this.getClass().getSimpleName();
		HashMap<String, Object> bpCheckParam = null;
		Map<String, Object> ccParam = (Map<String, Object>)param.getData(ccName);
		if (null == ccParam)
		{
			return JKKBpCommon.createBpNotCheckParam();
		}
		
		// 登録時にBPチェックを行う場合はここを編集して下さい。
		bpCheckParam = JKKBpCommon.createBpNotCheckParam();
		
		return bpCheckParam;
	}

	/**
	 * ＢＰチェック結果を編集します。
	 * <br />
	 * @param param リクエストパラメータ
	 * @param caanMsgs サービスインターフェイス用のパラメータ配列
	 * @param returnCode リターンコード
	 * @return リクエストパラメータ
	 * @throws Throwable 
	 */
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] caanMsgs, Integer returnCode) throws Throwable
	{
		return JKKBpCommon.editErrorInfo(param, caanMsgs, returnCode);
	}

	/**
	 * ＢＰチェック結果を編集します。
	 * <br />
	 * @param param リクエストパラメータ
	 * @param caanMsgs サービスインターフェイス用のパラメータ配列
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws Throwable 
	 */
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] caanMsgs, Integer returnCode, String fixedText)
			throws Throwable
	{
		return editErrorInfo(param, caanMsgs, returnCode);
	}

	/**
	 * サービス契約一意照会の上りマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param svcKeiNo サービス契約番号
	 * @return CAANMsg 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0081A010Msg(
			IRequestParameterReadWrite param,
			String fixedText,
			String svcKeiNo) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0081A010CBSMsg.class.getName());

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

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

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

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

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

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

		// ＫＥＹ＿サービス契約番号
		template.set(EKK0081A010CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);
		// ＫＥＹ＿世代登録年月日時分秒
		template.setNull(EKK0081A010CBSMsg.KEY_GENE_ADD_DTM);
		// ＫＥＹ＿予約適用年月日
		setTemplate(param, template, EKK0081A010CBSMsg.KEY_RSV_APLY_YMD, inMap, "key_rsv_aply_ymd");

		return template;
	}

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

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

		// サービス情報作業用リストの取得
		ArrayList svcKeiInfoListWork = getWorkList(param, SVC_KEI_INFO_LIST_WORK);

		/* 業務データ設定 */
		HashMap dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		CAANMsg[] templateArray = template.getCAANMsgList(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);

		if (templateArray != null)
		{
			for (CAANMsg childTemplate : templateArray)
			{
				HashMap childMap = new HashMap();
				svcKeiInfoListWork.add(childMap);

				// SYSID
				setOutData(childMap, "sysid", childTemplate, EKK0081A010CBSMsg1List.SYSID);
				// サービス契約番号
				setOutData(childMap, "svc_kei_no", childTemplate, EKK0081A010CBSMsg1List.SVC_KEI_NO);
				// サービス契約ステータス
				setOutData(childMap, "svc_kei_stat", childTemplate, EKK0081A010CBSMsg1List.SVC_KEI_STAT);
				// サービスコード
				setOutData(childMap, "svc_cd", childTemplate, EKK0081A010CBSMsg1List.SVC_CD);
				// 申込明細番号
				setOutData(childMap, "mskm_dtl_no", childTemplate, EKK0081A010CBSMsg1List.MSKM_DTL_NO);
				// 料金グループコード
				setOutData(childMap, "prc_grp_cd", childTemplate, EKK0081A010CBSMsg1List.PRC_GRP_CD);
				// 料金コースコード
				setOutData(childMap, "pcrs_cd", childTemplate, EKK0081A010CBSMsg1List.PCRS_CD);
				// 料金プランコード
				setOutData(childMap, "pplan_cd", childTemplate, EKK0081A010CBSMsg1List.PPLAN_CD);
				// 最終更新年月日時分秒
				setOutData(childMap, "last_upd_dtm", childTemplate, EKK0081A010CBSMsg1List.LAST_UPD_DTM);
				
				// 割引整合性チェック情報から照会したサービス契約に合致するマップを取得する。
				svcTgWribSeigoMap = getWribSeigoMap(param, fixedText, childMap);
			}
		}

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

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

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

		return param;
	}
	
	/**
	 * 検索条件に合致するサービス契約対象割引整合性チェック情報を取得します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param svcKeiMap 検索対象のサービス契約情報マップ
	 * @return 検索されたサービス契約対象割引整合性チェック情報マップ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> getWribSeigoMap(IRequestParameterReadWrite param, String fixedText,
			HashMap<String, String> svcKeiMap) throws RequestParameterException
	{
		// マッピング情報
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		if (null == inMap)
		{
			return null;
		}
		
		HashMap<String, Object> wribSeigoMap = (HashMap<String, Object>)inMap.get("wrib_seigo_map");
		if (null == wribSeigoMap)
		{
			return null;
		}
		
		for (String key : wribSeigoMap.keySet())
		{
			// 回線に紐付く機器の情報はスキップ
			if ((WRIB_KIND_CD.KISN_KEI_KIKI.name()).equals(key))
			{
				continue;
			}
			
			HashMap<String, Object> dataMap = (HashMap<String, Object>)wribSeigoMap.get(key);
			
			// サービスコード
			if (!((String)svcKeiMap.get("svc_cd")).equals((String)dataMap.get("svc_cd")))
			{
				continue;
			}
			
			// 料金グループコード
			if (!((String)svcKeiMap.get("prc_grp_cd")).equals((String)dataMap.get("prc_grp_cd")))
			{
				continue;
			}
			
			// 料金コースコード
			if (!((String)svcKeiMap.get("pcrs_cd")).equals((String)dataMap.get("pcrs_cd")))
			{
				continue;
			}
			
			// 料金プランコード
			if (!((String)svcKeiMap.get("pplan_cd")).equals((String)dataMap.get("pplan_cd")))
			{
				continue;
			}
			
			return dataMap;
		}
		
		return null;
	}

	/**
	 * サービス契約一意照会のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0081A010(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0081A010CBSMsg.STATUS), returnCode);

		HashMap dataMap = (HashMap)param.getData(fixedText);
		ArrayList dataList = (ArrayList)dataMap.get("EKK0081A010ERRLIST");

		if (dataList == null)
		{
			dataList = new ArrayList();
			dataMap.put("EKK0081A010ERRLIST", dataList);
		}

		HashMap errMap = new HashMap();
		dataList.add(errMap);

		// ＫＥＹ＿サービス契約番号
		setErrInfo(errMap, "key_svc_kei_no", template, EKK0081A010CBSMsg.KEY_SVC_KEI_NO);
		// ＫＥＹ＿世代登録年月日時分秒
		setErrInfo(errMap, "key_gene_add_dtm", template, EKK0081A010CBSMsg.KEY_GENE_ADD_DTM);
		// ＫＥＹ＿予約適用年月日
		setErrInfo(errMap, "key_rsv_aply_ymd", template, EKK0081A010CBSMsg.KEY_RSV_APLY_YMD);
		// ＫＥＹ＿サービス契約番号エラー
		setErrInfo(errMap, "key_svc_kei_no_err", template, EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR);
		// ＫＥＹ＿世代登録年月日時分秒エラー
		setErrInfo(errMap, "key_gene_add_dtm_err", template, EKK0081A010CBSMsg.KEY_GENE_ADD_DTM_ERR);
		// ＫＥＹ＿予約適用年月日エラー
		setErrInfo(errMap, "key_rsv_aply_ymd_err", template, EKK0081A010CBSMsg.KEY_RSV_APLY_YMD_ERR);

		return param;
	}

	/**
	 * 割引サービス契約キャンセルの上りマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param delWribSvcMap 割引削除用マップ
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0451C070(IRequestParameterReadWrite param,
			String fixedText,
			HashMap delWribSvcMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0451C070CBSMsg.class.getName());

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

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

		// 機能コード
		template.set(EKK0451C070CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));

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

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

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

		// 割引サービス契約番号
		setTemplate(param, template, EKK0451C070CBSMsg.WRIB_SVC_KEI_NO, delWribSvcMap, "wrib_svc_kei_no");
		// 申込明細番号
		setTemplate(param, template, EKK0451C070CBSMsg.MSKM_DTL_NO, delWribSvcMap, "mskm_dtl_no");
		// サービスキャンセル理由コード
		setTemplate(param, template, EKK0451C070CBSMsg.SVC_CANCEL_RSN_CD, delWribSvcMap, "svc_cancel_rsn_cd");
		// 異動区分
		setTemplate(param, template, EKK0451C070CBSMsg.IDO_DIV, delWribSvcMap, "ido_div");
		// 割引解約キャンセル契機コード
		setTemplate(param, template, EKK0451C070CBSMsg.WRIB_DSL_CNCL_OPTY_CD, delWribSvcMap, "wrib_dsl_cncl_opty_cd");

		// 割引サービス契約に紐づいているサービス契約番号を取得
		ArrayList svcKeiList = (ArrayList)delWribSvcMap.get("svc_kei_no_list");
		// 最終更新日が最大のサービス契約番号を取得
		String maxDtm = getDtmMax(param, svcKeiList);
		template.set(EKK0451C070CBSMsg.UPD_DTM_BF, maxDtm);

		// 更新年月日を更新する対象のサービスリストを設定
		setUpdUpdYmdTgSvcKeiNoWork(param, svcKeiList);

		return template;
	}

	/**
	 * 割引サービス契約キャンセルの下りマッピング処理を行います。
	 * <br>
	 * @param msgList SCからの戻り値
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param delWribSvcMap 割引削除用マップ
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0451C070(
			Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap delWribSvcMap) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// 結果を詰めるマップを取得。
		HashMap dataMap = null;

		dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		// 登録結果は必要ないためマッピングしない

		// サービスリストの最終更新年月日を更新
		setUpdSvcUpdYmd(param, template.getString(EKK0451C070CBSMsg.UPD_DTM));

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

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

		return param;
	}

	/**
	 * 割引サービス契約キャンセルのエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @param delWribSvcMap 割引削除用マップ
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0451C070(
			IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText, HashMap delWribSvcMap)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451C070CBSMsg.STATUS), returnCode);

		// 割引サービス契約番号エラー
		setErrInfo(delWribSvcMap, "wrib_svc_kei_no_err", template, EKK0451C070CBSMsg.WRIB_SVC_KEI_NO_ERR);
		// 申込明細番号エラー
		setErrInfo(delWribSvcMap, "mskm_dtl_no_err", template, EKK0451C070CBSMsg.MSKM_DTL_NO_ERR);
		// サービスキャンセル理由コードエラー
		setErrInfo(delWribSvcMap, "svc_cancel_rsn_cd_err", template, EKK0451C070CBSMsg.SVC_CANCEL_RSN_CD_ERR);
		// 異動区分エラー
		setErrInfo(delWribSvcMap, "ido_div_err", template, EKK0451C070CBSMsg.IDO_DIV_ERR);
		// 割引解約キャンセル契機コードエラー
		setErrInfo(delWribSvcMap, "wrib_dsl_cncl_opty_cd_err", template, EKK0451C070CBSMsg.WRIB_DSL_CNCL_OPTY_CD_ERR);
		// 更新年月日時分秒(更新前)エラー
		setErrInfo(delWribSvcMap, "upd_dtm_bf_err", template, EKK0451C070CBSMsg.UPD_DTM_BF_ERR);

		return param;
	}

	/**
	 * 割引サービス契約登録の上りマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー定義文字列
	 * @param wribSvcCdMap 登録割引サービス情報マップ
	 * @param wribSvcCdList 割引サービス情報リスト
	 * @param keizokuInfo 継続情報
	 * @return CAANMsg
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0451D010(IRequestParameterReadWrite param, String fixedText, HashMap wribSvcCdMap) throws Exception
	{
		CAANMsg template = new CAANMsg(EKK0451D010CBSMsg.class.getName());

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

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

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

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

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

		// 機能コード
		template.set(EKK0451D010CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));

		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		// SYSID
		setTemplate(param, template, EKK0451D010CBSMsg.SYSID, wribSvcCdMap,  "sysid");
		// 割引サービスコード
		setTemplate(param, template, EKK0451D010CBSMsg.WRIB_SVC_CD, wribSvcCdMap,  "wrib_svc_cd");
		// 申込明細番号
		setTemplate(param, template, EKK0451D010CBSMsg.MSKM_DTL_NO, wribSvcCdMap,  "mskm_dtl_no");
		// 料金コースコード
		setTemplate(param, template, EKK0451D010CBSMsg.PCRS_CD, wribSvcCdMap,  "pcrs_cd");
		// 料金プランコード
		setTemplate(param, template, EKK0451D010CBSMsg.PPLAN_CD, wribSvcCdMap,  "pplan_cd");
		// サービス利用開始希望年月日
		setTemplate(param, template, EKK0451D010CBSMsg.SVC_USE_STA_KIBO_YMD, wribSvcCdMap,  "svc_use_sta_kibo_ymd");
		// 予約適用開始希望年月日
		setTemplate(param, template, EKK0451D010CBSMsg.RSV_TSTA_KIBO_YMD, wribSvcCdMap,  "rsv_tsta_kibo_ymd");
		// 即時適用フラグ
		setTemplate(param, template, EKK0451D010CBSMsg.APLY_JUN, wribSvcCdMap,  "aply_jun");
		// 違約金発生コード
		setTemplate(param, template, EKK0451D010CBSMsg.PNLTY_HASSEI_CD, wribSvcCdMap,  "pnlty_hassei_cd");
		// 異動区分
		setTemplate(param, template, EKK0451D010CBSMsg.IDO_DIV, wribSvcCdMap,  "ido_div");
		// 申込起算年月日
		setTemplate(param, template, EKK0451D010CBSMsg.MSKM_KISAN_YMD, wribSvcCdMap,  "mskm_kisan_ymd");
		// 割引登録契機コード
		setTemplate(param, template, EKK0451D010CBSMsg.WRIB_ADD_OPTY_CD, wribSvcCdMap,  "wrib_add_opty_cd");

		ArrayList inList = (ArrayList)wribSvcCdMap.get("EKK0451D010CBSMsg1List");
		CAANMsg[] templateArray = template.getCAANMsgList(EKK0451D010CBSMsg.EKK0451D010CBSMSG1LIST);

		if (templateArray == null)
		{
			templateArray = new CAANMsg[inList.size()];
			template.set(EKK0451D010CBSMsg.EKK0451D010CBSMSG1LIST, templateArray);
		}

		for (int i = 0; i < inList.size(); i++)
		{
			HashMap childMap = (HashMap)inList.get(i);

			CAANMsg childTemplate = templateArray[i];
			if (childTemplate == null)
			{
				childTemplate = new CAANMsg(EKK0451D010CBSMsg1List.class.getName());
				templateArray[i] = childTemplate;
			}

			// 対象契約識別コード
			setTemplate(param, childTemplate, EKK0451D010CBSMsg1List.TG_KEI_SKBT_CD, childMap,  "tg_kei_skbt_cd");
			// サービス契約番号
			setTemplate(param, childTemplate, EKK0451D010CBSMsg1List.SVC_KEI_NO, childMap,  "svc_kei_no");
			// サービス契約内訳番号
			setTemplate(param, childTemplate, EKK0451D010CBSMsg1List.SVC_KEI_UCWK_NO, childMap,  "svc_kei_ucwk_no");
			// オプションサービス契約番号
			setTemplate(param, childTemplate, EKK0451D010CBSMsg1List.OP_SVC_KEI_NO, childMap,  "op_svc_kei_no");
			// サブオプションサービス契約番号
			setTemplate(param, childTemplate, EKK0451D010CBSMsg1List.SBOP_SVC_KEI_NO, childMap,  "sbop_svc_kei_no");
			// 機器提供サービス契約番号
			setTemplate(param, childTemplate, EKK0451D010CBSMsg1List.KKTK_SVC_KEI_NO, childMap,  "kktk_svc_kei_no");
			// 割引サービス対象サービスコード
			setTemplate(param, childTemplate, EKK0451D010CBSMsg1List.WRIB_SVC_TRGT_SVC_CD, childMap,  "wrib_svc_trgt_svc_cd");
			// 設定登録年月日
			setTemplate(param, childTemplate, EKK0451D010CBSMsg1List.SET_ADD_YMD, childMap,  "set_add_ymd");
			// 割引サービス対象契約適用開始年月日
			setTemplate(param, childTemplate, EKK0451D010CBSMsg1List.WRISVC_TG_KEI_TSTAYMD, childMap,  "wrisvc_tg_kei_tstaymd");
			// 割引サービス対象契約適用終了年月日
			setTemplate(param, childTemplate, EKK0451D010CBSMsg1List.WRISVC_TG_KEI_TENDYMD, childMap,  "wrisvc_tg_kei_tendymd");
			// 機器オプションサービス契約番号
			setTemplate(param, childTemplate, EKK0451D010CBSMsg1List.KKOP_SVC_KEI_NO, childMap,  "kkop_svc_kei_no");
		}

		// 最終更新日が最大のサービス契約番号を取得
		String maxDtm = getDtmMax(param, inList);
		template.set(EKK0451D010CBSMsg.UPD_DTM_BF, maxDtm);

		// 更新年月日を更新する対象のサービスリストを設定
		setUpdUpdYmdTgSvcKeiNoWork(param, inList);

		return template;
	}

	/**
	 * 割引サービス契約登録の下りマッピング処理を行います。
	 * <br>
	 * @param msgList SCからの戻り値
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0451D010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 結果は必要ないためマッピングを行わない

		// サービスリストの最終更新年月日を更新
		setUpdSvcUpdYmd(param, template.getString(EKK0451D010CBSMsg.UPD_DTM));

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

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

		return param;
	}

	/**
	 * 割引サービス契約登録のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0451D010(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0451D010CBSMsg.STATUS), returnCode);

		HashMap dataMap = (HashMap)param.getData(fixedText);
		ArrayList dataList = (ArrayList)dataMap.get("EKK0451D010ERRLIST");

		if (dataList == null)
		{
			dataList = new ArrayList();
			dataMap.put("EKK0451D010ERRLIST", dataList);
		}

		HashMap errMap = new HashMap();
		dataList.add(errMap);

		// SYSIDエラー
		setErrInfo(errMap, "sysid_err", template, EKK0451D010CBSMsg.SYSID_ERR);
		// 割引サービスコードエラー
		setErrInfo(errMap, "wrib_svc_cd_err", template, EKK0451D010CBSMsg.WRIB_SVC_CD_ERR);
		// 料金コースコードエラー
		setErrInfo(errMap, "pcrs_cd_err", template, EKK0451D010CBSMsg.PCRS_CD_ERR);
		// 料金プランコードエラー
		setErrInfo(errMap, "pplan_cd_err", template, EKK0451D010CBSMsg.PPLAN_CD_ERR);
		// サービス利用開始希望年月日エラー
		setErrInfo(errMap, "svc_use_sta_kibo_ymd_err", template, EKK0451D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR);
		// 予約適用開始希望年月日エラー
		setErrInfo(errMap, "rsv_tsta_kibo_ymd_err", template, EKK0451D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR);
		// 申込明細番号エラー
		setErrInfo(errMap, "mskm_dtl_no_err", template, EKK0451D010CBSMsg.MSKM_DTL_NO_ERR);
		// 即時適用フラグエラー
		setErrInfo(errMap, "aply_jun_err", template, EKK0451D010CBSMsg.APLY_JUN_ERR);
		// 違約金発生コードエラー
		setErrInfo(errMap, "pnlty_hassei_cd_err", template, EKK0451D010CBSMsg.PNLTY_HASSEI_CD_ERR);
		// 異動区分エラー
		setErrInfo(errMap, "ido_div_err", template, EKK0451D010CBSMsg.IDO_DIV_ERR);
		// 申込起算年月日エラー
		setErrInfo(errMap, "mskm_kisan_ymd_err", template, EKK0451D010CBSMsg.MSKM_KISAN_YMD_ERR);
		// 割引登録契機コードエラー
		setErrInfo(errMap, "wrib_add_opty_cd_err", template, EKK0451D010CBSMsg.WRIB_ADD_OPTY_CD_ERR);
		// 割引サービス対象契約明細エラー
		setErrInfo(errMap, "EKK0451D010CBSMsg1List_err", template, EKK0451D010CBSMsg.EKK0451D010CBSMSG1LIST_ERR);

		return param;
	}

	/**
	 * データ抽出項目設定完了の上りマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param delHanyoSvcMap 汎用削除用マップ
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK1391C040(IRequestParameterReadWrite param,
			String fixedText,
			HashMap delHanyoSvcMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK1391C040CBSMsg.class.getName());

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

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

		// 機能コード
		template.set(EKK1391C040CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));

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

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

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

		// データ抽出項目設定番号
		setTemplate(param, template, EKK1391C040CBSMsg.DCHSKMST_NO, delHanyoSvcMap, "dchskmst_no");
		// データ抽出項目設定完了種別コード
		setTemplate(param, template, EKK1391C040CBSMsg.DCHSKMST_FIN_SBT_CD, delHanyoSvcMap, "dchskmst_fin_sbt_cd");
		// データ抽出項目設定終了年月日
		setTemplate(param, template, EKK1391C040CBSMsg.DCHSKMST_END_YMD, delHanyoSvcMap, "dchskmst_end_ymd");
		// 異動区分
		setTemplate(param, template, EKK1391C040CBSMsg.IDO_DIV, delHanyoSvcMap, "ido_div");
		// データ抽出項目設定完了契機コード
		setTemplate(param, template, EKK1391C040CBSMsg.DCHSKMST_FIN_OPTY_CD, delHanyoSvcMap, "dchskmst_fin_opty_cd");

		// 割引サービス契約に紐づいているサービス契約番号を取得
		ArrayList svcKeiList = (ArrayList)delHanyoSvcMap.get("svc_kei_no_list");
		// 最終更新日が最大のサービス契約番号を取得
		String maxDtm = getDtmMax(param, svcKeiList);
		template.set(EKK1391C040CBSMsg.UPD_DTM_BF, maxDtm);
		// 申込明細番号
		setTemplate(param, template, EKK1391C040CBSMsg.MSKM_DTL_NO, delHanyoSvcMap, "mskm_dtl_no");

		// 更新年月日を更新する対象のサービスリストを設定
		setUpdUpdYmdTgSvcKeiNoWork(param, svcKeiList);

		return template;
	}

	/**
	 * データ抽出項目設定完了の下りマッピング処理を行います。
	 * <br>
	 * @param msgList SCからの戻り値
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param delHanyoSvcMap 汎用削除用マップ
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK1391C040(
			Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, HashMap delHanyoSvcMap) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// 結果を詰めるマップを取得。
		HashMap dataMap = null;

		dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		// 登録結果は必要ないためマッピングしない

		// サービスリストの最終更新年月日を更新
		setUpdSvcUpdYmd(param, template.getString(EKK1391C040CBSMsg.UPD_DTM));

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

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

		return param;
	}

	/**
	 * データ抽出項目設定完了のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @param delHanyoSvcMap 汎用削除用マップ
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK1391C040(
			IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText, HashMap delHanyoSvcMap)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK1391C040CBSMsg.STATUS), returnCode);

		// データ抽出項目設定番号エラー
		setErrInfo(delHanyoSvcMap, "dchskmst_no_err", template, EKK1391C040CBSMsg.DCHSKMST_NO_ERR);
		// データ抽出項目設定完了種別コードエラー
		setErrInfo(delHanyoSvcMap, "dchskmst_fin_sbt_cd_err", template, EKK1391C040CBSMsg.DCHSKMST_FIN_SBT_CD_ERR);
		// データ抽出項目設定終了年月日エラー
		setErrInfo(delHanyoSvcMap, "dchskmst_end_ymd_err", template, EKK1391C040CBSMsg.DCHSKMST_END_YMD_ERR);
		// 異動区分エラー
		setErrInfo(delHanyoSvcMap, "ido_div_err", template, EKK1391C040CBSMsg.IDO_DIV_ERR);
		// データ抽出項目設定完了契機コードエラー
		setErrInfo(delHanyoSvcMap, "dchskmst_fin_opty_cd_err", template, EKK1391C040CBSMsg.DCHSKMST_FIN_OPTY_CD_ERR);
		// 更新年月日時分秒(更新前)エラー
		setErrInfo(delHanyoSvcMap, "upd_dtm_bf_err", template, EKK1391C040CBSMsg.UPD_DTM_BF_ERR);
		// 申込明細番号エラー
		setErrInfo(delHanyoSvcMap, "mskm_dtl_no_err", template, EKK1391C040CBSMsg.MSKM_DTL_NO_ERR);

		return param;
	}

	/**
	 * データ抽出項目設定登録の上りマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー定義文字列
	 * @param addDchskmstMap データ抽出項目設定登録マップ
	 * @return CAANMsg
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK1391D010(IRequestParameterReadWrite param, String fixedText, HashMap addDchskmstMap) throws Exception
	{
		CAANMsg template = new CAANMsg(EKK1391D010CBSMsg.class.getName());

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

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

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

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

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

		// 機能コード
		template.set(EKK1391D010CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));

		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		// SYSID
		setTemplate(param, template, EKK1391D010CBSMsg.SYSID, addDchskmstMap,  "sysid");
		// データ抽出項目コード
		setTemplate(param, template, EKK1391D010CBSMsg.DCHSKM_CD, addDchskmstMap,  "dchskm_cd");
		// 申込明細番号
		setTemplate(param, template, EKK1391D010CBSMsg.MSKM_DTL_NO, addDchskmstMap,  "mskm_dtl_no");
		// 即時適用フラグ
		setTemplate(param, template, EKK1391D010CBSMsg.APLY_JUN, addDchskmstMap,  "aply_jun");
		// データ抽出項目設定年月日
		setTemplate(param, template, EKK1391D010CBSMsg.DCHSKMST_YMD, addDchskmstMap,  "dchskmst_ymd");
		// データ抽出項目設定開始年月日
		setTemplate(param, template, EKK1391D010CBSMsg.DCHSKMST_STA_YMD, addDchskmstMap,  "dchskmst_sta_ymd");
		// データ抽出項目設定終了年月日
		setTemplate(param, template, EKK1391D010CBSMsg.DCHSKMST_END_YMD, addDchskmstMap,  "dchskmst_end_ymd");
		// 異動区分
		setTemplate(param, template, EKK1391D010CBSMsg.IDO_DIV, addDchskmstMap,  "ido_div");
		// グループコード
		setTemplate(param, template, EKK1391D010CBSMsg.GRP_CD, addDchskmstMap,  "grp_cd");
		// 紹介コード
		setTemplate(param, template, EKK1391D010CBSMsg.INTR_CD, addDchskmstMap,  "intr_cd");
		// 申込起算年月日
		setTemplate(param, template, EKK1391D010CBSMsg.MSKM_KISAN_YMD, addDchskmstMap,  "mskm_kisan_ymd");
		// データ抽出項目設定登録契機コード
		setTemplate(param, template, EKK1391D010CBSMsg.DCHSKMST_ADD_OPTY_CD, addDchskmstMap,  "dchskmst_add_opty_cd");

		// 最終更新日が最大のサービス契約番号を取得
		String maxDtm = getDtmMax(param, (ArrayList)addDchskmstMap.get(DCHSKMST_TG_KEI_ADD_LIST_WORK));
		template.set(EKK1391D010CBSMsg.UPD_DTM_BF, maxDtm);

		return template;
	}

	/**
	 * データ抽出項目設定登録の下りマッピング処理を行います。
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK1391D010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		// 作業領域の取得
		HashMap workMap = getWorkMap(param);

		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// データ抽出項目設定番号
		setOutData(workMap, "dchskmst_no", template, EKK1391D010CBSMsg.DCHSKMST_NO);
		// 更新年月日時分秒
		setOutData(workMap, "1391_upd_dtm", template, EKK1391D010CBSMsg.UPD_DTM);

//		// サービスリストの最終更新年月日を更新
//		setUpdSvcUpdYmd(param, template.getString(EKK1391D010CBSMsg.UPD_DTM));

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

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

		return param;
	}

	/**
	 * データ抽出項目設定登録のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK1391D010(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK1391D010CBSMsg.STATUS), returnCode);

		HashMap dataMap = (HashMap)param.getData(fixedText);
		ArrayList dataList = (ArrayList)dataMap.get("EKK1391D010ERRLIST");

		if (dataList == null)
		{
			dataList = new ArrayList();
			dataMap.put("EKK1391D010ERRLIST", dataList);
		}

		HashMap errMap = new HashMap();
		dataList.add(errMap);

		// SYSIDエラー
		setErrInfo(errMap, "sysid_err", template, EKK1391D010CBSMsg.SYSID_ERR);
		// データ抽出項目コードエラー
		setErrInfo(errMap, "dchskm_cd_err", template, EKK1391D010CBSMsg.DCHSKM_CD_ERR);
		// 申込明細番号エラー
		setErrInfo(errMap, "mskm_dtl_no_err", template, EKK1391D010CBSMsg.MSKM_DTL_NO_ERR);
		// 即時適用フラグエラー
		setErrInfo(errMap, "aply_jun_err", template, EKK1391D010CBSMsg.APLY_JUN_ERR);
		// データ抽出項目設定年月日エラー
		setErrInfo(errMap, "dchskmst_ymd_err", template, EKK1391D010CBSMsg.DCHSKMST_YMD_ERR);
		// データ抽出項目設定開始年月日エラー
		setErrInfo(errMap, "dchskmst_sta_ymd_err", template, EKK1391D010CBSMsg.DCHSKMST_STA_YMD_ERR);
		// データ抽出項目設定終了年月日エラー
		setErrInfo(errMap, "dchskmst_end_ymd_err", template, EKK1391D010CBSMsg.DCHSKMST_END_YMD_ERR);
		// 異動区分エラー
		setErrInfo(errMap, "ido_div_err", template, EKK1391D010CBSMsg.IDO_DIV_ERR);
		// グループコードエラー
		setErrInfo(errMap, "grp_cd_err", template, EKK1391D010CBSMsg.GRP_CD_ERR);
		// 紹介コードエラー
		setErrInfo(errMap, "intr_cd_err", template, EKK1391D010CBSMsg.INTR_CD_ERR);
		// 申込起算年月日エラー
		setErrInfo(errMap, "mskm_kisan_ymd_err", template, EKK1391D010CBSMsg.MSKM_KISAN_YMD_ERR);
		// データ抽出項目設定登録契機コードエラー
		setErrInfo(errMap, "dchskmst_add_opty_cd_err", template, EKK1391D010CBSMsg.DCHSKMST_ADD_OPTY_CD_ERR);
		// 更新年月日時分秒(更新前)エラー
		setErrInfo(errMap, "upd_dtm_bf_err", template, EKK1391D010CBSMsg.UPD_DTM_BF_ERR);

		return param;
	}

	/**
	 * データ抽出項目設定対象契約登録の上りマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー定義文字列
	 * @param dchskmstTgKeiAddMap データ抽出項目設定対象契約登録マップ
	 * @return CAANMsg
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK1401D010(IRequestParameterReadWrite param, String fixedText, HashMap dchskmstTgKeiAddMap) throws Exception
	{
		CAANMsg template = new CAANMsg(EKK1401D010CBSMsg.class.getName());

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

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

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

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

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

		// 機能コード
		template.set(EKK1401D010CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));

		// 作業領域の取得
		HashMap workMap = getWorkMap(param);

		// データ抽出項目設定番号
		setTemplate(param, template, EKK1401D010CBSMsg.DCHSKMST_NO, workMap,  "dchskmst_no");
		// 対象契約識別コード
		setTemplate(param, template, EKK1401D010CBSMsg.TG_KEI_SKBT_CD, dchskmstTgKeiAddMap,  "tg_kei_skbt_cd");
		// サービス契約番号
		setTemplate(param, template, EKK1401D010CBSMsg.SVC_KEI_NO, dchskmstTgKeiAddMap,  "svc_kei_no");
		// サービス契約内訳番号
		template.setNull(EKK1401D010CBSMsg.SVC_KEI_UCWK_NO);
		// オプションサービス契約番号
		template.setNull(EKK1401D010CBSMsg.OP_SVC_KEI_NO);
		// サブオプションサービス契約番号
		template.setNull(EKK1401D010CBSMsg.SBOP_SVC_KEI_NO);
		// 機器提供サービス契約番号
		template.setNull(EKK1401D010CBSMsg.KKTK_SVC_KEI_NO);
		// 請求オプションサービス契約番号
		template.setNull(EKK1401D010CBSMsg.SEIOPSVC_KEI_NO);
		// 設定登録年月日
		setTemplate(param, template, EKK1401D010CBSMsg.SET_ADD_YMD, dchskmstTgKeiAddMap,  "set_add_ymd");
		// データ抽出項目設定対象契約適用開始年月日
		setTemplate(param, template, EKK1401D010CBSMsg.DCHSKMST_TG_KEI_TSTAYMD, dchskmstTgKeiAddMap,  "dchskmst_tg_kei_tstaymd");
		// データ抽出項目設定対象契約適用終了年月日
		setTemplate(param, template, EKK1401D010CBSMsg.DCHSKMST_TG_KEI_TENDYMD, dchskmstTgKeiAddMap,  "dchskmst_tg_kei_tendymd");
		// データ抽出項目コード
		setTemplate(param, template, EKK1401D010CBSMsg.DCHSKM_CD, dchskmstTgKeiAddMap,  "dchskm_cd");

		ArrayList svcKeiList = new ArrayList();
		svcKeiList.add(dchskmstTgKeiAddMap);
		// 最終更新日が最大のサービス契約番号を取得
		String maxDtm = getDtmMax(param, svcKeiList);
		template.set(EKK1401D010CBSMsg.UPD_DTM_BF, maxDtm);

		// 更新年月日を更新する対象のサービスリストを設定
		setUpdUpdYmdTgSvcKeiNoWork(param, svcKeiList);

		return template;
	}

	/**
	 * データ抽出項目設定対象契約登録の下りマッピング処理を行います。
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK1401D010(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		// 作業領域の取得
		HashMap workMap = getWorkMap(param);

		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);

		// 更新年月日時分秒
		setOutData(workMap, "1391_upd_dtm", template, EKK1401D010CBSMsg.UPD_DTM);
		// サービスリストの最終更新年月日を更新
		setUpdSvcUpdYmd(param, template.getString(EKK1401D010CBSMsg.UPD_DTM));

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

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

		return param;
	}

	/**
	 * データ抽出項目設定対象契約登録のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template CAANMsg[]
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK1401D010(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK1401D010CBSMsg.STATUS), returnCode);

		HashMap dataMap = (HashMap)param.getData(fixedText);
		ArrayList dataList = (ArrayList)dataMap.get("EKK1401D010ERRLIST");

		if (dataList == null)
		{
			dataList = new ArrayList();
			dataMap.put("EKK1401D010ERRLIST", dataList);
		}

		HashMap errMap = new HashMap();
		dataList.add(errMap);

		// データ抽出項目設定番号エラー
		setErrInfo(errMap, "dchskmst_no_err", template, EKK1401D010CBSMsg.DCHSKMST_NO_ERR);
		// 対象契約識別コードエラー
		setErrInfo(errMap, "tg_kei_skbt_cd_err", template, EKK1401D010CBSMsg.TG_KEI_SKBT_CD_ERR);
		// サービス契約番号エラー
		setErrInfo(errMap, "svc_kei_no_err", template, EKK1401D010CBSMsg.SVC_KEI_NO_ERR);
		// サービス契約内訳番号エラー
		setErrInfo(errMap, "svc_kei_ucwk_no_err", template, EKK1401D010CBSMsg.SVC_KEI_UCWK_NO_ERR);
		// オプションサービス契約番号エラー
		setErrInfo(errMap, "op_svc_kei_no_err", template, EKK1401D010CBSMsg.OP_SVC_KEI_NO_ERR);
		// サブオプションサービス契約番号エラー
		setErrInfo(errMap, "sbop_svc_kei_no_err", template, EKK1401D010CBSMsg.SBOP_SVC_KEI_NO_ERR);
		// 機器提供サービス契約番号エラー
		setErrInfo(errMap, "kktk_svc_kei_no_err", template, EKK1401D010CBSMsg.KKTK_SVC_KEI_NO_ERR);
		// 請求オプションサービス契約番号エラー
		setErrInfo(errMap, "seiopsvc_kei_no_err", template, EKK1401D010CBSMsg.SEIOPSVC_KEI_NO_ERR);
		// 設定登録年月日エラー
		setErrInfo(errMap, "set_add_ymd_err", template, EKK1401D010CBSMsg.SET_ADD_YMD_ERR);
		// データ抽出項目設定対象契約適用開始年月日エラー
		setErrInfo(errMap, "dchskmst_tg_kei_tstaymd_err", template, EKK1401D010CBSMsg.DCHSKMST_TG_KEI_TSTAYMD_ERR);
		// データ抽出項目設定対象契約適用終了年月日エラー
		setErrInfo(errMap, "dchskmst_tg_kei_tendymd_err", template, EKK1401D010CBSMsg.DCHSKMST_TG_KEI_TENDYMD_ERR);
		// 更新年月日時分秒(更新前)エラー
		setErrInfo(errMap, "upd_dtm_bf_err", template, EKK1401D010CBSMsg.UPD_DTM_BF_ERR);
		// データ抽出項目コードエラー
		setErrInfo(errMap, "dchskm_cd_err", template, EKK1401D010CBSMsg.DCHSKM_CD_ERR);

		return param;
	}

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

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

		return paramMap;
	}

	/**
	 * CAANMsgに値を設定します。<br>
	 *  �@inMap内にデータが存在する場合、inMap内のデータを設定します。<br>
	 *  �A上記以外の場合、setNullを呼び出します。<br>
	 * @param param IRequestParameterReadWrite
	 * @param template 値を設定するメッセージキャリア
	 * @param setKey 設定先メッセージキャリアのキー名
	 * @param inMap ユーザデータ情報
	 * @param getKey ユーザデータ情報より取得するキー名
	 */
	private void setTemplate(
			IRequestParameterReadWrite param,
			CAANMsg template,
			String setKey,
			HashMap<String, Object> inMap,
			String getKey)
	{
		
		if (null == inMap || null == inMap.get(getKey) || 0 == ((String)inMap.get(getKey)).length())
		{
			template.setNull(setKey);
		}
		else
		{
			template.set(setKey, (String)inMap.get(getKey));
		}
	}

	/**
	 * ユーザデータ情報に値を設定します。<br>
	 * 　※CAANMsg内のデータがNullの場合、空文字を設定します。<br>
	 * @param dataMap ユーザデータ情報
	 * @param setKey ユーザデータ情報に設定するキー名
	 * @param template メッセージキャリア
	 * @param getKey メッセージキャリアより取得するキー名
	 */
	private void setOutData(HashMap<String, Object> dataMap, String setKey, CAANMsg template, String getKey)
	{
		if (template.isNull(getKey))
		{
			dataMap.put(setKey, "");
		}
		else
		{
			dataMap.put(setKey, template.getString(getKey));
		}
	}

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

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

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

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

	/**
	 * ユーザデータ情報にエラー情報を設定します。<br>
	 * 　※ユーザデータ情報内にすでにキーが存在する場合、値は設定されません。<br>
	 * @param inMap	 ユーザデータ情報
	 * @param setKey ユーザデータ情報に設定するキー名
	 * @param template メッセージキャリア
	 * @param getKey メッセージキャリアより取得するキー名
	 */
	private void setErrInfo(HashMap<String, Object> inMap, String setKey, CAANMsg template, String getKey)
	{
		if (!template.isNull(getKey))
		{
			if (!inMap.containsKey(setKey))
			{
				inMap.put(setKey, template.getString(getKey));
			}
		}
	}

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

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

		return paramMap;
	}

	/**
	 * 作業マップの取得。<br>
	 * @param param リクエストパラメータ
	 * @return 作業マップ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private HashMap getWorkMap(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}

		HashMap jkkManAplyWribSvcKeiCCWork = (HashMap)workMap.get(CC_WORK_AREA_NAME_WRIB);

		if (jkkManAplyWribSvcKeiCCWork == null)
		{
			jkkManAplyWribSvcKeiCCWork = new HashMap();
			workMap.put(CC_WORK_AREA_NAME_WRIB, jkkManAplyWribSvcKeiCCWork);
		}

		return jkkManAplyWribSvcKeiCCWork;
	}

	/**
	 * 作業用リストの取得。<br>
	 * @param param リクエストパラメータ
	 * @param listName 作業用リスト名
	 * @return 作業マップ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList getWorkList(IRequestParameterReadWrite param, String listName) throws RequestParameterException
	{
		// 作業領域の取得
		HashMap workMap = getWorkMap(param);

		ArrayList workList = (ArrayList)workMap.get(listName);

		if (workList == null)
		{
			workList = new ArrayList();
			workMap.put(listName, workList);
		}

		return workList;
	}

	/**
	 * 割引サービス登録マップリストの取得。<br>
	 * @param param リクエストパラメータ
	 * @return 作業マップ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList getWribSvcKeiAddListWork(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// 作業領域の取得
		HashMap workMap = getWorkMap(param);

		ArrayList wribSvcKeiAddListWork = (ArrayList)workMap.get(WRIB_SVC_KEI_ADD_LIST_WORK);

		if (wribSvcKeiAddListWork == null)
		{
			wribSvcKeiAddListWork = new ArrayList();
			workMap.put(WRIB_SVC_KEI_ADD_LIST_WORK, wribSvcKeiAddListWork);
		}

		return wribSvcKeiAddListWork;
	}

	/**
	 * データ抽出項目マップリストの取得。<br>
	 * @param param リクエストパラメータ
	 * @return 作業マップ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList getDchskmstAddListWork(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// 作業領域の取得
		HashMap workMap = getWorkMap(param);

		ArrayList dchskmstAddListWork = (ArrayList)workMap.get(DCHSKMST_ADD_LIST_WORK);

		if (dchskmstAddListWork == null)
		{
			dchskmstAddListWork = new ArrayList();
			workMap.put(DCHSKMST_ADD_LIST_WORK, dchskmstAddListWork);
		}

		return dchskmstAddListWork;
	}

	/**
	 * 更新年月日更新対象サービス契約番号の設定。<br>
	 * @param param リクエストパラメータ
	 * @param svcKeiList サービスリスト
	 * @return 作業マップ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private void setUpdUpdYmdTgSvcKeiNoWork(IRequestParameterReadWrite param, ArrayList svcKeiList) throws RequestParameterException
	{
		// 作業領域の取得
		HashMap workMap = getWorkMap(param);

		HashMap updYmdTgMapWork = (HashMap)workMap.get(UPD_YMD_TG_MAP_WORK);

		if (updYmdTgMapWork == null)
		{
			updYmdTgMapWork = new HashMap();
			workMap.put(UPD_YMD_TG_MAP_WORK, updYmdTgMapWork);
		}

		if (svcKeiList == null)
		{
			updYmdTgMapWork.put(UPD_TG_SVC_KEI_NO_LIST, new ArrayList());
		}
		else
		{
			updYmdTgMapWork.put(UPD_TG_SVC_KEI_NO_LIST, svcKeiList);
		}
	}

	/**
	 * サービスの更新年月日を設定。<br>
	 * @param param リクエストパラメータ
	 * @param updYmdDtm 更新年月日時分秒
	 * @return 作業マップ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private void setUpdSvcUpdYmd(IRequestParameterReadWrite param, String updYmdDtm) throws RequestParameterException
	{
		// 作業領域の取得
		HashMap workMap = getWorkMap(param);

		HashMap updYmdTgMapWork = (HashMap)workMap.get(UPD_YMD_TG_MAP_WORK);

		if (updYmdTgMapWork == null || updYmdTgMapWork.size() == 0)
		{
			return;
		}

		if (updYmdDtm == null)
		{
			return;
		}

		// サービス情報作業用リストの取得
		ArrayList<HashMap<String, String>> svcKeiInfoListWork = getWorkList(param, SVC_KEI_INFO_LIST_WORK);
		HashMap<String, Object> svcKeiNoGetMap = new HashMap<String, Object>();
		ArrayList<HashMap> svcKeiList = (ArrayList<HashMap>)updYmdTgMapWork.get(UPD_TG_SVC_KEI_NO_LIST);

		for (HashMap svcKeiMap : svcKeiList)
		{
			ArrayList<String> svcKeiNoList = null;
			
			String svcKeiNo = (String)svcKeiMap.get("svc_kei_no");
			if (null == svcKeiNo || "".equals(svcKeiNo))
			{
				// サービス契約番号が取得できないものはサービス契約回線内訳に紐つくとみなし、
				// サービス契約回線内訳に紐つく全サービス契約に対して処理を行う
				svcKeiNoList = getKaisenSvcKeiNoList(param);
			}
			else
			{
				svcKeiNoList = new ArrayList<String>();
				svcKeiNoList.add(svcKeiNo);
			}
			
			for (String childSvcKeiNo : svcKeiNoList)
			{
				if (svcKeiNoGetMap.containsKey(childSvcKeiNo))
				{
					continue;
				}
	
				for (HashMap<String, String> svcKeiMapWork : svcKeiInfoListWork)
				{
					if (childSvcKeiNo.equals(svcKeiMapWork.get("svc_kei_no")))
					{
						String lastDtm = svcKeiMapWork.get("last_upd_dtm");
	
						// 設定されている最終更新年月日より更新年月日が大きかった場合更新する
						if (0 < updYmdDtm.compareTo(lastDtm))
						{
							svcKeiMapWork.put("last_upd_dtm", updYmdDtm);
						}
					}
				}
				
				// 同一のサービス契約番号を処理しないように格納する
				svcKeiNoGetMap.put(childSvcKeiNo, null);
			}
		}
	}

	/**
	 * サービス契約リスト設定。<br>
	 * @param param リクエストパラメータ
	 * @param svcKeiNoMapList サービス契約マップリスト
	 * @return サービス契約リスト
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<String> getSvcKeiNoList(IRequestParameterReadWrite param, ArrayList<HashMap> svcKeiNoMapList) throws RequestParameterException
	{
		ArrayList<String> svcKeiNoList = new ArrayList<String>();

		// マップ情報で送られたサービス契約番号を格納する
		for (HashMap svcMap : svcKeiNoMapList)
		{
			if (svcMap.containsKey("svc_kei_no") && !JKKBpCommon.isNull(svcMap.get("svc_kei_no")))
			{
				if (!svcKeiNoList.contains(svcMap.get("svc_kei_no")))
				{
					svcKeiNoList.add((String)svcMap.get("svc_kei_no"));
				}
			}
		}

		// 光回線に紐つくサービスのサービス契約番号を取得
		ArrayList<String> kaisenSvcKeiNoList = getKaisenSvcKeiNoList(param);
		if (null != kaisenSvcKeiNoList)
		{
			for (String svcKeiNo : kaisenSvcKeiNoList)
			{
				if (!svcKeiNoList.contains(svcKeiNo))
				{
					svcKeiNoList.add(svcKeiNo);
				}
			}
		}

		// モバイルサービス契約番号の設定
		if (!JKKBpCommon.isNull(JKKBpCommon.getWkSvcKeiNoMbl(param)))
		{
			if (!svcKeiNoList.contains(JKKBpCommon.getWkSvcKeiNoMbl(param)))
			{
				svcKeiNoList.add(JKKBpCommon.getWkSvcKeiNoMbl(param));
			}
		}

		// ＡＤＳＬサービス契約番号の設定
		if (!JKKBpCommon.isNull(JKKBpCommon.getWkSvcKeiNoAdsl(param)))
		{
			if (!svcKeiNoList.contains(JKKBpCommon.getWkSvcKeiNoAdsl(param)))
			{
				svcKeiNoList.add(JKKBpCommon.getWkSvcKeiNoAdsl(param));
			}
		}

		return svcKeiNoList;
	}
	
	/**
	 * サービス契約回線内訳に紐つくサービス契約リストを取得します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @return サービス契約リスト
	 * @throws RequestParameterException
	 */
	private ArrayList<String> getKaisenSvcKeiNoList(IRequestParameterReadWrite param) throws RequestParameterException
	{
		ArrayList<String> svcKeiNoList = new ArrayList<String>();
		
		// ネットサービス契約番号の設定
		if (!JKKBpCommon.isNull(JKKBpCommon.getWkSvcKeiNoNet(param)))
		{
			if (!svcKeiNoList.contains(JKKBpCommon.getWkSvcKeiNoNet(param)))
			{
				svcKeiNoList.add(JKKBpCommon.getWkSvcKeiNoNet(param));
			}
		}

		// 電話サービス契約番号の設定
		if (!JKKBpCommon.isNull(JKKBpCommon.getWkSvcKeiNoTel(param)))
		{
			if (!svcKeiNoList.contains(JKKBpCommon.getWkSvcKeiNoTel(param)))
			{
				svcKeiNoList.add(JKKBpCommon.getWkSvcKeiNoTel(param));
			}
		}

		// テレビサービス契約番号の設定
		if (!JKKBpCommon.isNull(JKKBpCommon.getWkSvcKeiNoTv(param)))
		{
			if (!svcKeiNoList.contains(JKKBpCommon.getWkSvcKeiNoTv(param)))
			{
				svcKeiNoList.add(JKKBpCommon.getWkSvcKeiNoTv(param));
			}
		}
		
		return svcKeiNoList;
	}

	
	/**
	 * 機器提供サービス契約リスト設定。<br>
	 * @param param リクエストパラメータ
	 * @return サービス契約リスト
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<String> getKktkSvcKeiNoList(IRequestParameterReadWrite param) throws RequestParameterException
	{
		ArrayList<String> kktkSvcKeiNoList = new ArrayList<String>();

		// 作業領域の取得
		HashMap<String, Object> workMap = getWorkMap(param);
		
		ArrayList<HashMap<String, Object>> allDataList = (ArrayList<HashMap<String, Object>>)workMap.get(ALL_KKTK_SVC_KEI_INFO_LIST_WK);
		
		if (allDataList == null)
		{
			allDataList = new ArrayList<HashMap<String, Object>>();
			workMap.put(ALL_KKTK_SVC_KEI_INFO_LIST_WK, allDataList);
		}
		
		for (HashMap<String, Object> kktkMap : allDataList)
		{
			String kktkSvcCd = (String)kktkMap.get("kktk_svc_cd");
			// 多機能ルーターに紐付く機器オプションのみを処理対象とするため、
			// 機器提供サービスコードが多機能ルーターのデータのみを取得する。
// ▽▽▽ #83584 Modify START
//			if (JKKStrConst.KKTK_SVC_CD_TAKINORT.equals(kktkSvcCd))
			if (JKKStrConst.KKTK_SVC_CD_TAKINORT.equals(kktkSvcCd) || JKKStrConst.KKTK_SVC_CD_HGW.equals(kktkSvcCd))
// △△△ #83584 Modify END
			{
				kktkSvcKeiNoList.add((String)kktkMap.get("kktk_svc_kei_no"));
			}
		}
		
		return kktkSvcKeiNoList;
	}

	/**
	 * サービス契約リスト設定。<br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private void setWribInfo(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		/* ユーザデータ情報 */
		HashMap inMap = (HashMap)(param.getData(fixedText));

		// 割引サービス対象リスト
		ArrayList<HashMap> wribSvcTrgtList = (ArrayList<HashMap>)inMap.get("wrib_svc_trgt_list");
		// 削除用マップリスト
		ArrayList delWribSvcKeiList = (ArrayList)inMap.get("del_wrib_svc_kei_no_list");

		// 割引情報がない場合、処理をしない
		if (wribSvcTrgtList == null || wribSvcTrgtList.size() == 0)
		{
			return;
		}
		
		for (HashMap wribSvcTrgtMap : wribSvcTrgtList)
		{
			// マップが存在しない場合処理をしない
			if (wribSvcTrgtMap == null || wribSvcTrgtMap.size() == 0)
			{
				continue;
			}

			// 割引サービス対象サービスリスト
			ArrayList<HashMap> wribSvcTrgtSvcList = (ArrayList<HashMap>)wribSvcTrgtMap.get("wrib_svc_trgt_svc_list");

			if (wribSvcTrgtSvcList == null || wribSvcTrgtSvcList.size() == 0)
			{
				continue;
			}

			boolean delFlg = false;
			boolean newAddFlg = false;
			boolean teiseiFlg = false;

			HashMap parentMap = new HashMap();
			String sysid = "";
			String mskmDtlNo = "";
			int wribType = WRIB_TYPE.NONE.ordinal();
			// 割引削除対象サービスリスト
			ArrayList delWribSvcKeiTrgtList = new ArrayList();
			// 最終更新年月日取得用サービス契約リスト
			ArrayList updDtmSvcKeiNoList = new ArrayList();

			for (HashMap wribSvcTrgtSvcMap : wribSvcTrgtSvcList)
			{
				// 登録済みの契約番号が設定されるリスト
				ArrayList<String> wribSvcTrgtKeiNoList = new ArrayList<String>();

				// マップが存在しない場合処理をしない
				if (wribSvcTrgtSvcMap == null || wribSvcTrgtSvcMap.size() == 0)
				{
					continue;
				}
				
				String listName = "";	// 対象リスト名
				String keyName = "";	// 対象キー名
				
				// 割引タイプを取得
				wribType = (Integer)wribSvcTrgtSvcMap.get("wrib_type");
				
				if (WRIB_TYPE.SVC_KEI.ordinal() == wribType)
				{
					// 割引タイプが"サービス契約"の場合
					listName = "svc_kei_no_list";
					keyName = "svc_kei_no";
				}
				else if (WRIB_TYPE.SVC_KEI_UCWK.ordinal() == wribType)
				{
					// 割引タイプが"サービス契約内訳"の場合
					listName = "svc_kei_ucwk_no_list";
					keyName = "svc_kei_ucwk_no";
				}
				else if (WRIB_TYPE.OP_SVC_KEI.ordinal() == wribType)
				{
					// 割引タイプが"オプションサービス契約"の場合
					listName = "op_svc_kei_no_list";
					keyName = "op_svc_kei_no";
				}
				else if (WRIB_TYPE.SBOP_SVC_KEI.ordinal() == wribType)
				{
					// 割引タイプが"サブオプションサービス契約"の場合
					listName = "sbop_svc_kei_no_list";
					keyName = "sbop_svc_kei_no";
				}
				else if (WRIB_TYPE.KKTK_SVC_KEI.ordinal() == wribType)
				{
					// 割引タイプが"機器提供サービス契約"の場合
					listName = "kktk_svc_kei_no_list";
					keyName = "kktk_svc_kei_no";
				}
				else if (WRIB_TYPE.KKOP_SVC_KEI.ordinal() == wribType)
				{
					// 割引タイプが"機器オプションサービス契約"の場合
					listName = "kkop_svc_kei_no_list";
					keyName = "kkop_svc_kei_no";
				}
				else
				{
					// 割引タイプが"対象外"の場合、次の要素を処理する。
					continue;
				}
				
				// 割引サービスに紐付く更新前の割引サービス対象サービス情報を取得。
				ArrayList<HashMap> keiNoList = (ArrayList<HashMap>)wribSvcTrgtSvcMap.get(listName);

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

				delWribSvcKeiTrgtList.addAll(keiNoList);
				updDtmSvcKeiNoList.addAll(keiNoList);

				for (HashMap keiNoMap : keiNoList)
				{
					String keiNo = (String)keiNoMap.get(keyName);

					if (JKKBpCommon.isNull(keiNo))
					{
						continue;
					}

					// 割引対象契約範囲で契約番号を集める
					if (!wribSvcTrgtKeiNoList.contains(keiNo))
					{
						wribSvcTrgtKeiNoList.add(keiNo);
					}
				}
				
				ArrayList<HashMap> aplyKeiList = null;
				
				// 割引サービスの対象となる契約番号を取得する
				if (WRIB_TYPE.SVC_KEI.ordinal() == wribType)
				{
					aplyKeiList = getAplySvcKeiList(param, wribSvcTrgtSvcMap);
				}
				else if (WRIB_TYPE.SVC_KEI_UCWK.ordinal() == wribType)
				{
					aplyKeiList = getAplySvcKeiUcwkList(param, wribSvcTrgtSvcMap);
				}
				else if (WRIB_TYPE.OP_SVC_KEI.ordinal() == wribType)
				{
					aplyKeiList = getAplyOpSvcKeiList(param, wribSvcTrgtSvcMap);
				}
				else if (WRIB_TYPE.SBOP_SVC_KEI.ordinal() == wribType)
				{
					aplyKeiList = getAplySbopSvcKeiList(param, wribSvcTrgtSvcMap);
				}
				else if (WRIB_TYPE.KKTK_SVC_KEI.ordinal() == wribType)
				{
					aplyKeiList = getAplyKktkSvcKeiList(param, wribSvcTrgtSvcMap);
				}
				else if (WRIB_TYPE.KKOP_SVC_KEI.ordinal() == wribType)
				{
					aplyKeiList = getAplyKkopSvcKeiList(param, wribSvcTrgtSvcMap);
				}
				
				// 更新前のサービス対象サービス情報がなく、更新後のサービス対象サービス情報も存在しない場合は割引対象外
				if (wribSvcTrgtKeiNoList.size() == 0 && aplyKeiList.size() == 0)
				{
					continue;
				}

				// 申込明細番号の取得
				if (JKKBpCommon.isNull(mskmDtlNo) && aplyKeiList.size() > 0)
				{
					HashMap newKeiMap = (HashMap)aplyKeiList.get(0);
					mskmDtlNo = (String)newKeiMap.get("mskm_dtl_no");
					if (null == mskmDtlNo || "".equals(mskmDtlNo))
					{
						// 申込明細番号が取得できない場合はサービス契約回線内訳に紐つく機器とみなし、
						// サービス契約から申込明細番号を取り直す。
						mskmDtlNo = getMskmDtlNoFromSvcKei(param);
					}
					
					newKeiMap = (HashMap)getWorkList(param, SVC_KEI_INFO_LIST_WORK).get(0);
					sysid = (String)newKeiMap.get("sysid");
				}
				
				ArrayList<String> aplyKeiNoList = new ArrayList<String>();
				
				for (HashMap newKeiMap : aplyKeiList)
				{
					aplyKeiNoList.add((String)newKeiMap.get(keyName));
				}

				// 現在登録されている割引の契約番号が削除されていないかを判定する
				for (String zumiKeiNo : wribSvcTrgtKeiNoList)
				{
					if (!aplyKeiNoList.contains(zumiKeiNo))
					{
						delFlg = true;
					}
				}

				// 新たな対象となるサービス契約番号が作製されているか判定する
				for (HashMap newKeiMap : aplyKeiList)
				{
					String newKeiNo = (String)newKeiMap.get(keyName);
					if (!wribSvcTrgtKeiNoList.contains(newKeiNo))
					{
						newAddFlg = true;
					}
					else if (delFlg)
					{
						teiseiFlg = true;
					}
					else if (WRIB_TYPE.KKTK_SVC_KEI.ordinal() == wribType || WRIB_TYPE.KKOP_SVC_KEI.ordinal() == wribType)
					{
						//
						// 契約番号に変更はないが、申込明細番号が変更になった場合
						//
						
						// 画面から渡された機器、機器オプションに紐付く割引の申込明細番号を取得
						String oldMskmDtlNo = (String)wribSvcTrgtMap.get("mskm_dtl_no");
						
						// 回線に紐付く機器、機器オプションを持つサービスの申込明細番号を取得
						String newMskmDtlNoNet = JKKBpCommon.getWkMskmDtlNoNet(param);
						String newMskmDtlNoTel = JKKBpCommon.getWkMskmDtlNoTel(param);
						String newMskmDtlNoTv = JKKBpCommon.getWkMskmDtlNoTv(param);
						
						if (!JKKCommonUtil.isNull(oldMskmDtlNo)
								&& !oldMskmDtlNo.equals(newMskmDtlNoNet)
								&& !oldMskmDtlNo.equals(newMskmDtlNoTel)
								&& !oldMskmDtlNo.equals(newMskmDtlNoTv))
						{
							teiseiFlg = true;
						}
					}
					
					if ((newAddFlg || teiseiFlg) &&  WRIB_TYPE.KKOP_SVC_KEI.ordinal() == wribType)
					{
						// 回線に紐付く機器オプションを持つサービスの申込明細番号を取得
						String newMskmDtlNoNet = JKKBpCommon.getWkMskmDtlNoNet(param);
						String newMskmDtlNoTel = JKKBpCommon.getWkMskmDtlNoTel(param);
						
						// 登録用の申込明細番号を置き換える。
						if (!JKKCommonUtil.isNull(newMskmDtlNoNet))
						{
							mskmDtlNo = newMskmDtlNoNet;
						}
						else if (!JKKCommonUtil.isNull(newMskmDtlNoTel))
						{
							mskmDtlNo = newMskmDtlNoTel;
						}
					}

					// 割引に紐付く対象条件が変更になった場合で
					// 契約番号に変更がない場合
					if (newAddFlg && delWribSvcKeiTrgtList.size() != 0)
					{
						teiseiFlg = true;
					}

					ArrayList ekk0451DList = (ArrayList)parentMap.get("EKK0451D010CBSMsg1List");
					if (ekk0451DList == null)
					{
						ekk0451DList = new ArrayList();
						parentMap.put("EKK0451D010CBSMsg1List", ekk0451DList);
					}

					HashMap childMap = new HashMap();
					ekk0451DList.add(childMap);

					if (WRIB_TYPE.SVC_KEI.ordinal() == wribType)
					{
						// 対象契約識別コード
						childMap.put("tg_kei_skbt_cd", JKKStrConst.CD_DIV_OYAKEISKBTCD_SVCKEI);
						// サービス契約番号
						childMap.put("svc_kei_no", newKeiNo);
					}
					else if (WRIB_TYPE.SVC_KEI_UCWK.ordinal() == wribType)
					{
						// 対象契約識別コード
						childMap.put("tg_kei_skbt_cd", JKKStrConst.CD_DIV_OYAKEISKBTCD_SVKEIUW);
						// サービス契約内訳番号
						childMap.put("svc_kei_ucwk_no", newKeiNo);
					}
					else if (WRIB_TYPE.OP_SVC_KEI.ordinal() == wribType)
					{
						// 対象契約識別コード
						childMap.put("tg_kei_skbt_cd", JKKStrConst.CD_DIV_OYAKEISKBTCD_OPSVKEI);
						// オプションサービス契約番号
						childMap.put("op_svc_kei_no", newKeiNo);
					}
					else if (WRIB_TYPE.SBOP_SVC_KEI.ordinal() == wribType)
					{
						// 対象契約識別コード
						childMap.put("tg_kei_skbt_cd", JKKStrConst.CD_DIV_OYAKEISKBTCD_SBOPSVKEI);
						// オプションサービス契約番号
						childMap.put("op_svc_kei_no", (String)newKeiMap.get("op_svc_kei_no"));
						// サブオプションサービス契約内訳番号
						childMap.put("sbop_svc_kei_no", newKeiNo);
					}
					else if (WRIB_TYPE.KKTK_SVC_KEI.ordinal() == wribType)
					{
						// 対象契約識別コード
						childMap.put("tg_kei_skbt_cd", JKKStrConst.CD_DIV_OYAKEISKBTCD_KKTKSVKEI);
						// 機器提供サービス契約番号
						childMap.put("kktk_svc_kei_no", newKeiNo);
					}
					else if (WRIB_TYPE.KKOP_SVC_KEI.ordinal() == wribType)
					{
						// 対象契約識別コード
						childMap.put("tg_kei_skbt_cd", JKKStrConst.CD_DIV_OYAKEISKBTCD_KKOPSVKEI);
						// 機器オプションサービス契約番号
						childMap.put("kkop_svc_kei_no", newKeiNo);
					}
					// 割引サービス対象サービスコード
					childMap.put("wrib_svc_trgt_svc_cd", wribSvcTrgtSvcMap.get("wrib_svc_trgt_svc_cd"));
					// 設定登録年月日
					childMap.put("set_add_ymd", wribSvcTrgtSvcMap.get("set_add_ymd"));
					// 割引サービス対象契約適用開始年月日
					childMap.put("wrisvc_tg_kei_tstaymd", wribSvcTrgtSvcMap.get("wrisvc_tg_kei_tstaymd"));
					// 割引サービス対象契約適用終了年月日
					childMap.put("wrisvc_tg_kei_tendymd", wribSvcTrgtSvcMap.get("wrisvc_tg_kei_tendymd"));
				}
			}

			if (newAddFlg || teiseiFlg)
			{
				// SYSID
				parentMap.put("sysid", sysid);
				// 割引サービスコード
				parentMap.put("wrib_svc_cd", wribSvcTrgtMap.get("wrib_svc_cd"));
				// 料金コースコード
				parentMap.put("pcrs_cd", wribSvcTrgtMap.get("pcrs_cd"));
				// 料金プランコード
				parentMap.put("pplan_cd", wribSvcTrgtMap.get("pplan_cd"));
				// サービス利用開始希望年月日
				parentMap.put("svc_use_sta_kibo_ymd", wribSvcTrgtMap.get("svc_use_sta_kibo_ymd"));
				// 予約適用開始希望年月日
				parentMap.put("rsv_tsta_kibo_ymd", wribSvcTrgtMap.get("rsv_tsta_kibo_ymd"));
				// 申込明細番号
				parentMap.put("mskm_dtl_no", mskmDtlNo);
				// 即時適用フラグ
				parentMap.put("aply_jun", wribSvcTrgtMap.get("aply_jun"));
				// 違約金発生コード
				parentMap.put("pnlty_hassei_cd", wribSvcTrgtMap.get("pnlty_hassei_cd"));
				// 異動区分
				parentMap.put("ido_div", wribSvcTrgtMap.get("ido_div"));
				// 申込起算年月日
				parentMap.put("mskm_kisan_ymd", wribSvcTrgtMap.get("mskm_kisan_ymd"));
				// 割引登録契機コード
				parentMap.put("wrib_add_opty_cd", wribSvcTrgtMap.get("wrib_add_opty_cd"));
				// 更新年月日時分秒(更新前)
				parentMap.put("upd_dtm_bf", wribSvcTrgtMap.get("kk0841_upd_dtm"));
				// 割引サービス契約自動継続識別コード
				parentMap.put("wrib_svc_kei_at_keizk_skcd", wribSvcTrgtMap.get("wrib_svc_kei_at_keizk_skcd"));

				ArrayList wribSvcKeiAddListWork = getWribSvcKeiAddListWork(param);
				wribSvcKeiAddListWork.add(parentMap);
			}

			// 削除用のマッピング処理
			if (delFlg || teiseiFlg)
			{
				// 割引サービス契約番号がマッピングされていない場合は、
				// 登録済みデータでないため削除対象外
				if (JKKBpCommon.isNull(wribSvcTrgtMap.get("wrib_svc_kei_no")))
				{
					continue;
				}

				if (delWribSvcKeiList == null)
				{
					delWribSvcKeiList = new ArrayList();
					inMap.put("del_wrib_svc_kei_no_list", delWribSvcKeiList);
				}

				HashMap delWribMap = new HashMap();
				delWribSvcKeiList.add(delWribMap);

				// 割引サービス契約番号
				delWribMap.put("wrib_svc_kei_no", wribSvcTrgtMap.get("wrib_svc_kei_no"));
				// 申込明細番号
				delWribMap.put("mskm_dtl_no", wribSvcTrgtMap.get("mskm_dtl_no"));
				// サービスキャンセル理由コード
				delWribMap.put("svc_cancel_rsn_cd", wribSvcTrgtMap.get("svc_cancel_rsn_cd"));
				// 異動区分
				delWribMap.put("ido_div", wribSvcTrgtMap.get("ido_div"));
				// 割引解約キャンセル契機コード
				delWribMap.put("wrib_dsl_cncl_opty_cd", wribSvcTrgtMap.get("wrib_dsl_cncl_opty_cd"));
				// 削除対象サービス契約番号
				delWribMap.put("svc_kei_no_list", updDtmSvcKeiNoList);
			}
		}
	}
	
	/**
	 * サービス契約回線内訳にひもつくサービス契約の申込明細番号を取得します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @return 申込明細番号
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private String getMskmDtlNoFromSvcKei(IRequestParameterReadWrite param) throws RequestParameterException
	{
		ArrayList<String> svcKeiNoList = getKaisenSvcKeiNoList(param);
		if (null == svcKeiNoList)
		{
			return null;
		}
		
		for (String svcKeiNo : svcKeiNoList)
		{
			// サービス情報作業用リストの取得
			ArrayList<HashMap<String, String>> dataList = getWorkList(param, SVC_KEI_INFO_LIST_WORK);
			
			for (HashMap<String, String> dataMap : dataList)
			{
				if (svcKeiNo.equals(dataMap.get("svc_kei_no")))
				{
					return dataMap.get("mskm_dtl_no");
				}
			}
		}
		return null;
	}

	/**
	 * 汎用情報設定。<br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private void setHanyoInfo(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		/* ユーザデータ情報 */
		HashMap inMap = (HashMap)(param.getData(fixedText));

		// 汎用コード対象リスト
		ArrayList hanyoTrgtList = (ArrayList)inMap.get("hanyo_trgt_list");
		// 削除用マップリスト
		ArrayList delDchskmstNoList = (ArrayList)inMap.get("del_dchskmst_no_list");

		// 汎用情報がない場合、処理をしない
		if (hanyoTrgtList == null || hanyoTrgtList.size() == 0)
		{
			return;
		}

		for (HashMap hanyoTrgtMap : (ArrayList<HashMap>)hanyoTrgtList)
		{
			// マップが存在しない場合処理をしない
			if (hanyoTrgtMap == null || hanyoTrgtMap.size() == 0)
			{
				continue;
			}

			// データ抽出項目設定対象契約リスト
			ArrayList dchskmstTgKeiList = (ArrayList)hanyoTrgtMap.get("dchskmst_tg_kei_list");

			if (dchskmstTgKeiList == null || dchskmstTgKeiList.size() == 0)
			{
				continue;
			}

			// データ抽出項目単位に紐づくサービス契約番号を設定する
			ArrayList dchskmstTrgtSvcKeiList = new ArrayList();
			// 登録済みのサービス契約番号が設定されるリスト
			ArrayList hanyoTrgtSvcKeiNoList = new ArrayList();
			// サービス契約番号の取得
			ArrayList svckeiNoList = (ArrayList)hanyoTrgtMap.get("svc_kei_no_list");
			String sysid = "";
			String mskmDtlNo = "";

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

			for (HashMap svcKeiNoMap : (ArrayList<HashMap>)svckeiNoList)
			{
				// マップが存在しない場合処理をしない
				if (svcKeiNoMap == null || svcKeiNoMap.size() == 0)
				{
					continue;
				}

				String svcKeiNo = (String)svcKeiNoMap.get("svc_kei_no");

				if (JKKBpCommon.isNull(svcKeiNo))
				{
					continue;
				}

				// 割引対象契約範囲で割引サービス契約番号を集める
				if (!svckeiNoList.contains(svcKeiNo))
				{
					hanyoTrgtSvcKeiNoList.add(svcKeiNo);
				}
			}

			boolean delFlg = false;
			boolean newAddFlg = false;

			HashMap parentMap = new HashMap();

			for (HashMap dchskmstTgKeiMap : (ArrayList<HashMap>)dchskmstTgKeiList)
			{
				// データ抽出項目対処に紐づくサービス契約番号を格納する
				ArrayList aplySvcKeiNoList = new ArrayList();
				// 割引サービスの対象となるサービス契約番号を取得する
				ArrayList aplySvcKeiList = getAplySvcKeiList(param, dchskmstTgKeiMap);

				// 申込明細番号の取得
				if (JKKBpCommon.isNull(mskmDtlNo) && aplySvcKeiList.size() > 0)
				{
					HashMap newSvcKeiMap = (HashMap)aplySvcKeiList.get(0);
					sysid = (String)newSvcKeiMap.get("sysid");
					mskmDtlNo = (String)newSvcKeiMap.get("mskm_dtl_no");
				}

				for (HashMap newSvcKeiMap : (ArrayList<HashMap>)aplySvcKeiList)
				{
					if (!aplySvcKeiNoList.contains(newSvcKeiMap.get("svc_kei_no")))
					{
						aplySvcKeiNoList.add(newSvcKeiMap.get("svc_kei_no"));
					}
				}

				// 新たな対象となるサービス契約番号が作製されているか判定する
				for (String newSvcKeiNo : (ArrayList<String>)aplySvcKeiNoList)
				{
					if (!dchskmstTrgtSvcKeiList.contains(newSvcKeiNo))
					{
						// データ抽出項目に紐づくサービス契約番号を設定する
						dchskmstTrgtSvcKeiList.add(newSvcKeiNo);
					}
					else
					{
						// 既にマッピング済みのため処理を行わない
						continue;
					}

					// 新たなサービス契約番号が追加された場合
					if (!hanyoTrgtSvcKeiNoList.contains(newSvcKeiNo))
					{
						newAddFlg = true;
					}

					ArrayList ekk1401DList = (ArrayList)parentMap.get(DCHSKMST_TG_KEI_ADD_LIST_WORK);
					if (ekk1401DList == null)
					{
						ekk1401DList = new ArrayList();
						parentMap.put(DCHSKMST_TG_KEI_ADD_LIST_WORK, ekk1401DList);
					}

					HashMap childMap = new HashMap();
					ekk1401DList.add(childMap);

					// 対象契約識別コード
					childMap.put("tg_kei_skbt_cd", dchskmstTgKeiMap.get("tg_kei_skbt_cd"));
					// サービス契約番号
					childMap.put("svc_kei_no", newSvcKeiNo);
					// 設定登録年月日
					childMap.put("set_add_ymd", dchskmstTgKeiMap.get("set_add_ymd"));
					// データ抽出項目設定対象契約適用開始年月日
					childMap.put("dchskmst_tg_kei_tstaymd", dchskmstTgKeiMap.get("dchskmst_tg_kei_tstaymd"));
					// データ抽出項目設定対象契約適用終了年月日
					childMap.put("dchskmst_tg_kei_tendymd", dchskmstTgKeiMap.get("dchskmst_tg_kei_tendymd"));
					// データ抽出項目コード
					childMap.put("dchskm_cd", hanyoTrgtMap.get("dchskm_cd"));
				}
			}

			// 現在登録されている割引のサービス契約番号が削除されていないかを判定する
			for (String zumiSvcKeiNo : (ArrayList<String>)hanyoTrgtSvcKeiNoList)
			{
				if (!dchskmstTrgtSvcKeiList.contains(zumiSvcKeiNo))
				{
					delFlg = true;
				}

				// 削除対象だが、設定対象のサービス契約番号が取得されている
				if (delFlg && 0 < dchskmstTrgtSvcKeiList.size())
				{
					newAddFlg = true;
					break;
				}

				// データ抽出に新たなサービス契約が紐づく場合
				if (newAddFlg && hanyoTrgtSvcKeiNoList.size() != 0)
				{
					delFlg = true;
				}
			}

			// 抽出項目は対象コードの登録が存在しないため作り直しが発生した場合、
			// サービス契約番号の付け替えが必ず発生する。
			if (newAddFlg)
			{
				// データ抽出項目コード
				parentMap.put("dchskm_cd", hanyoTrgtMap.get("dchskm_cd"));
				// SYSID
				parentMap.put("sysid", sysid);
				// 申込明細番号
				parentMap.put("mskm_dtl_no", mskmDtlNo);
				// 即時適用フラグ
				parentMap.put("aply_jun", hanyoTrgtMap.get("aply_jun"));
				// データ抽出項目設定年月日
				parentMap.put("dchskmst_ymd", hanyoTrgtMap.get("dchskmst_ymd"));
				// データ抽出項目設定開始年月日
				parentMap.put("dchskmst_sta_ymd", hanyoTrgtMap.get("dchskmst_sta_ymd"));
				// データ抽出項目設定終了年月日
				parentMap.put("dchskmst_end_ymd", hanyoTrgtMap.get("dchskmst_end_ymd"));
				// 異動区分
				parentMap.put("ido_div", hanyoTrgtMap.get("ido_div"));
				// グループコード
				parentMap.put("grp_cd", hanyoTrgtMap.get("grp_cd"));
				// 紹介コード
				parentMap.put("intr_cd", hanyoTrgtMap.get("intr_cd"));
				// 申込起算年月日
				parentMap.put("mskm_kisan_ymd", hanyoTrgtMap.get("mskm_kisan_ymd"));
				// データ抽出項目設定登録契機コード
				parentMap.put("dchskmst_add_opty_cd", hanyoTrgtMap.get("dchskmst_add_opty_cd"));

				ArrayList wribSvcKeiAddListWork = getDchskmstAddListWork(param);
				wribSvcKeiAddListWork.add(parentMap);
			}

			if (delFlg)
			{
				// 削除用のマッピング処理

				if (delDchskmstNoList == null || delDchskmstNoList.size() == 0)
				{
					delDchskmstNoList = new ArrayList();
					inMap.put("del_dchskmst_no_list", delDchskmstNoList);
				}

				HashMap delDchskmstMap = new HashMap();
				delDchskmstNoList.add(delDchskmstMap);

				// データ抽出項目設定番号
				delDchskmstMap.put("dchskmst_no", hanyoTrgtMap.get("dchskmst_no"));
				// 申込明細番号
				delDchskmstMap.put("mskm_dtl_no", hanyoTrgtMap.get("mskm_dtl_no"));
				// データ抽出項目設定完了種別コード
				delDchskmstMap.put("dchskmst_fin_sbt_cd", hanyoTrgtMap.get("dchskmst_fin_sbt_cd"));
				// データ抽出項目設定終了年月日
				delDchskmstMap.put("dchskmst_end_ymd", inMap.get("ope_date"));
				// 異動区分
				delDchskmstMap.put("ido_div", hanyoTrgtMap.get("ido_div"));
				// データ抽出項目設定完了契機コード
				delDchskmstMap.put("dchskmst_fin_opty_cd", hanyoTrgtMap.get("dchskmst_fin_opty_cd"));
				// 申込明細番号
				delDchskmstMap.put("mskm_dtl_no", hanyoTrgtMap.get("mskm_dtl_no"));
				// 削除対象サービス契約番号
				ArrayList delSvcKeiNoMap = new ArrayList();
				for (String svcKeiNo : (ArrayList<String>)hanyoTrgtSvcKeiNoList)
				{
					HashMap svcKeiNoMap = new HashMap();
					svcKeiNoMap.put("svc_kei_no", svcKeiNo);
					delSvcKeiNoMap.add(svcKeiNoMap);
				}
				delDchskmstMap.put("svc_kei_no_list", delSvcKeiNoMap);
			}
		}
	}

	/**
	 * 指定のサービス契約に紐つく割引サービス契約情報リスト内の割引サービス契約情報を取得します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param wribSvcMap 割引サービス契約情報マップ
	 * @return 引数wribSvcMapに紐つくサービス契約情報マップリスト
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList getAplySvcKeiList(IRequestParameterReadWrite param,
			HashMap<String, String> wribSvcMap) throws RequestParameterException
	{
		ArrayList resultList = new ArrayList();

		// サービス情報作業用リストの取得
		ArrayList<HashMap<String, String>> dataList = getWorkList(param, SVC_KEI_INFO_LIST_WORK);

		for (HashMap<String, String> dataMap : dataList)
		{
			// 受付済みの契約のみ取得する
			if (!JKKStrConst.CD00037_UK_ZM.equals(dataMap.get("svc_kei_stat")))
			{
				continue;
			}

			// サービスコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("svc_cd")) && !wribSvcMap.get("svc_cd").equals(dataMap.get("svc_cd")))
			{
				continue;
			}

			// 料金グループコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("prc_grp_cd")) && !wribSvcMap.get("prc_grp_cd").equals(dataMap.get("prc_grp_cd")))
			{
				continue;
			}

			// 料金コースコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("pcrs_cd")) && !wribSvcMap.get("pcrs_cd").equals(dataMap.get("pcrs_cd")))
			{
				continue;
			}

			// 料金プランコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("pplan_cd")) && !wribSvcMap.get("pplan_cd").equals(dataMap.get("pplan_cd")))
			{
				continue;
			}

			resultList.add(dataMap);
		}

		return resultList;
	}

	/**
	 * 指定のサービス契約内訳に紐つく割引サービス契約情報リスト内の割引サービス契約情報を取得します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param wribSvcMap 割引サービス契約情報マップ
	 * @return 引数wribSvcMapに紐つくサービス契約内訳情報マップリスト
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList getAplySvcKeiUcwkList(IRequestParameterReadWrite param, HashMap<String, String> wribSvcMap) throws RequestParameterException
	{
		ArrayList resultList = new ArrayList();

		// サービス情報作業用リストの取得
		ArrayList<HashMap<String, String>> dataList = getWorkList(param, SVC_KEI_UCWK_INFO_LIST_WORK);

		for (HashMap<String, String> dataMap : dataList)
		{
			// 受付済みの契約のみ取得する
			if (!JKKStrConst.CD00037_UK_ZM.equals(dataMap.get("svc_kei_ucwk_stat")))
			{
				continue;
			}

			// 料金コースコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("pcrs_cd")) && !wribSvcMap.get("pcrs_cd").equals(dataMap.get("pcrs_cd")))
			{
				continue;
			}

			// 料金プランコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("pplan_cd")) && !wribSvcMap.get("pplan_cd").equals(dataMap.get("pplan_cd")))
			{
				continue;
			}

			resultList.add(dataMap);
		}

		return resultList;
	}

	/**
	 * 指定のオプションサービス契約に紐つく割引サービス契約情報リスト内の割引サービス契約情報を取得します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param wribSvcMap 割引サービス契約情報マップ
	 * @return 引数wribSvcMapに紐つくオプションサービス契約情報マップリスト
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList getAplyOpSvcKeiList(IRequestParameterReadWrite param, HashMap<String, String> wribSvcMap) throws RequestParameterException
	{
		ArrayList resultList = new ArrayList();

		// オプションサービス契約情報作業用リストの取得
		ArrayList<HashMap<String, String>> dataList = getWorkList(param, OP_SVC_KEI_INFO_LIST_WORK);

		for (HashMap<String, String> dataMap : dataList)
		{
			// 受付済みの契約のみ取得する
			if (!JKKStrConst.CD00037_UK_ZM.equals(dataMap.get("op_svc_kei_stat")))
			{
				continue;
			}

			// オプションサービスコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("op_svc_cd")) && !wribSvcMap.get("op_svc_cd").equals(dataMap.get("op_svc_cd")))
			{
				continue;
			}

			// 料金コースコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("pcrs_cd")) && !wribSvcMap.get("pcrs_cd").equals(dataMap.get("pcrs_cd")))
			{
				continue;
			}

			// 料金プランコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("pplan_cd")) && !wribSvcMap.get("pplan_cd").equals(dataMap.get("pplan_cd")))
			{
				continue;
			}

			resultList.add(dataMap);
		}

		return resultList;
	}

	/**
	 * 指定のサブオプションサービス契約に紐つく割引サービス契約情報リスト内の割引サービス契約情報を取得します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param wribSvcMap 割引サービス契約情報マップ
	 * @return 引数wribSvcMapに紐つくサブオプションサービス契約情報マップリスト
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList getAplySbopSvcKeiList(IRequestParameterReadWrite param, HashMap<String, String> wribSvcMap) throws RequestParameterException
	{
		ArrayList resultList = new ArrayList();

		// サブオプションサービス契約情報作業用リストの取得
		ArrayList<HashMap<String, String>> dataList = getWorkList(param, SBOP_SVC_KEI_INFO_LIST_WORK);

		for (HashMap<String, String> dataMap : dataList)
		{
			// 受付済みの契約のみ取得する
			if (!JKKStrConst.CD00037_UK_ZM.equals(dataMap.get("sbop_svc_kei_stat")))
			{
				continue;
			}

			// サブオプションサービスコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("sbop_svc_cd")) && !wribSvcMap.get("sbop_svc_cd").equals(dataMap.get("sbop_svc_cd")))
			{
				continue;
			}

			// 料金コースコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("pcrs_cd")) && !wribSvcMap.get("pcrs_cd").equals(dataMap.get("pcrs_cd")))
			{
				continue;
			}

			// 料金プランコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("pplan_cd")) && !wribSvcMap.get("pplan_cd").equals(dataMap.get("pplan_cd")))
			{
				continue;
			}

			resultList.add(dataMap);
		}

		return resultList;
	}

	/**
	 * 指定の機器提供サービス契約に紐つく割引サービス契約情報リスト内の割引サービス契約情報を取得します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param wribSvcMap 割引サービス契約情報マップ
	 * @return 引数wribSvcMapに紐つく機器提供サービス契約情報マップリスト
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList getAplyKktkSvcKeiList(IRequestParameterReadWrite param, HashMap<String, String> wribSvcMap) throws RequestParameterException
	{
		ArrayList resultList = new ArrayList();

		// 機器提供サービス契約情報作業用リストの取得
		ArrayList<HashMap<String, String>> dataList = getWorkList(param, KKTK_SVC_KEI_INFO_LIST_WORK);

		for (HashMap<String, String> dataMap : dataList)
		{
			// 受付済みの契約のみ取得する
			if (!JKKStrConst.CD00037_UK_ZM.equals(dataMap.get("kktk_svc_kei_stat")))
			{
				continue;
			}

			// 機器提供サービスコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("kktk_svc_cd")) && !wribSvcMap.get("kktk_svc_cd").equals(dataMap.get("kktk_svc_cd")))
			{
				continue;
			}

			// 料金コースコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("pcrs_cd")) && !wribSvcMap.get("pcrs_cd").equals(dataMap.get("pcrs_cd")))
			{
				continue;
			}

			// 料金プランコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("pplan_cd")) && !wribSvcMap.get("pplan_cd").equals(dataMap.get("pplan_cd")))
			{
				continue;
			}

			// 機器提供種別コード
			if (!JKKBpCommon.isNull(wribSvcMap.get("kktk_sbt_cd")) && !wribSvcMap.get("kktk_sbt_cd").equals(dataMap.get("kktk_sbt_cd")))
			{
				continue;
			}

			resultList.add(dataMap);
		}

		return resultList;
	}

	/**
	 * 指定の機器オプションサービス契約に紐つく割引サービス契約情報リスト内の割引サービス契約情報を取得します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param wribSvcMap 割引サービス契約情報マップ
	 * @return 引数wribSvcMapに紐つく機器オプションサービス契約情報マップリスト
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<HashMap> getAplyKkopSvcKeiList(IRequestParameterReadWrite param, HashMap<String, String> wribSvcMap)
	throws RequestParameterException
	{
		ArrayList<HashMap> resultList = new ArrayList<HashMap>();

		// 機器オプションサービス契約情報作業用リストの取得
		ArrayList<HashMap<String, String>> dataList = getWorkList(param, KKOP_SVC_KEI_INFO_LIST_WORK);

		for (HashMap<String, String> dataMap : dataList)
		{
			// 受付済みの契約のみ取得する
			if (!JKKStrConst.CD00037_UK_ZM.equals(dataMap.get("kkop_svc_kei_stat")))
			{
				continue;
			}

			// 機器オプションサービスコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("kkop_svc_cd")) && !wribSvcMap.get("kkop_svc_cd").equals(dataMap.get("kkop_svc_cd")))
			{
				continue;
			}

			// 料金コースコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("pcrs_cd")) && !wribSvcMap.get("pcrs_cd").equals(dataMap.get("pcrs_cd")))
			{
				continue;
			}

			// 料金プランコード
			if (!JKKBpCommon.isNull(wribSvcMap.get("pplan_cd")) && !wribSvcMap.get("pplan_cd").equals(dataMap.get("pplan_cd")))
			{
				continue;
			}

			resultList.add(dataMap);
		}

		return resultList;
	}

	/**
	 * 最終更新日が最大のサービス契約番号を取得
	 * <br>
	 * @param param リクエストパラメータ
	 * @param svcKeiList サービスリスト
	 * @return 最終更新日
	 * @throws RequestParameterException 
	 */
	@SuppressWarnings("unchecked")
	private String getDtmMax(IRequestParameterReadWrite param, ArrayList<HashMap> svcKeiList) throws RequestParameterException
	{
		String maxDtm = "";
		HashMap<String, Object> svcKeiGetMap = new HashMap<String, Object>();
		
		// 削除対象の割引サービスに紐づくサービス分ループする
		for (HashMap svcKeiMap : svcKeiList)
		{
			String svcKeiNo = (String)svcKeiMap.get("svc_kei_no");
			if (null == svcKeiNo || "".equals(svcKeiNo))
			{
				// サービス契約番号がなければその他のキーからサービス契約番号を取得する。
				String svcKeiUcwkNo = (String)svcKeiMap.get("svc_kei_ucwk_no");
				String opSvcKeiNo = (String)svcKeiMap.get("op_svc_kei_no");
				String sbopSvcKeiNo = (String)svcKeiMap.get("sbop_svc_kei_no");
				String kktkSvcKeiNo = (String)svcKeiMap.get("kktk_svc_kei_no");
				String kkopSvcKeiNo = (String)svcKeiMap.get("kkop_svc_kei_no");
				
				ArrayList<String> svcKeiNoList = null;
				
				if (null != kkopSvcKeiNo && !"".equals(kkopSvcKeiNo))
				{
					// 機器オプションサービス契約からサービス契約番号を取得
					svcKeiNoList = getSvcKeiNoInAllDataList(param, getWorkList(param, ALL_KKOP_SVC_KEI_INFO_LIST_WK),
							"kkop_svc_kei_no", kkopSvcKeiNo);
				}
				else if (null != kktkSvcKeiNo && !"".equals(kktkSvcKeiNo))
				{
					// 機器提供サービス契約からサービス契約番号を取得
					svcKeiNoList = getSvcKeiNoInAllDataList(param, getWorkList(param, ALL_KKTK_SVC_KEI_INFO_LIST_WK),
							"kktk_svc_kei_no", kktkSvcKeiNo);
				}
				else if (null != sbopSvcKeiNo && !"".equals(sbopSvcKeiNo))
				{
					// サブオプションサービス契約からサービス契約番号を取得
					svcKeiNoList = getSvcKeiNoInAllDataList(param, getWorkList(param, ALL_SBOP_SVC_KEI_INFO_LIST_WK),
							"sbop_svc_kei_no", sbopSvcKeiNo);
				}
				else if (null != opSvcKeiNo && !"".equals(opSvcKeiNo))
				{
					// オプションサービス契約からサービス契約番号を取得
					svcKeiNoList = getSvcKeiNoInAllDataList(param, getWorkList(param, ALL_OP_SVC_KEI_INFO_LIST_WK),
							"op_svc_kei_no", opSvcKeiNo);
				}
				else if (null != svcKeiUcwkNo && !"".equals(svcKeiUcwkNo))
				{
					// サービス契約内訳からサービス契約番号を取得
					svcKeiNoList = getSvcKeiNoInAllDataList(param, getWorkList(param, ALL_SVC_KEI_UCWK_INFO_LIST_WK),
							"svc_kei_ucwk_no", svcKeiUcwkNo);
				}
				
				// サービスＩＦ呼び出し前後で更新年月日時分秒の更新対象となるサービス契約を判断するのに使用するため
				// サービス契約番号をマップに追加しておく(紐つくサービス契約が単一の場合のみ)
				if (svcKeiNoList.size() == 1)
				{
					svcKeiMap.put("svc_kei_no", svcKeiNoList.get(0));
				}
				
				for (String childSvcKeiNo : svcKeiNoList)
				{
					maxDtm = getDtmMaxSub(param, maxDtm, svcKeiGetMap, childSvcKeiNo);
				}
			}
			else
			{
				maxDtm = getDtmMaxSub(param, maxDtm, svcKeiGetMap, svcKeiNo);
			}
		}
		
		return maxDtm;
	}
	
	/**
	 * 全作業用リストからキー契約番号に紐付くサービス契約番号を取得します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param allDataList 全作業用リスト
	 * @param keyName キー名称
	 * @param keyNo キー契約番号
	 * @return サービス契約番号リスト
	 * @throws RequestParameterException 
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<String> getSvcKeiNoInAllDataList(IRequestParameterReadWrite param, ArrayList<HashMap> allDataList,
			String keyName, String keyNo) throws RequestParameterException
	{
		if (null == allDataList)
		{
			return null;
		}
		
		// 全作業リストからサービス契約番号を取得する.
		for (HashMap dataMap : allDataList)
		{
			if (!keyNo.equals(dataMap.get(keyName)))
			{
				continue;
			}
			
			// データにサービス契約回線内訳番号が設定されていれば、
			// サービス契約回線内訳番号に紐ついているサービス契約の番号すべてを取得する。
			if (null != dataMap.get("svc_kei_kaisen_ucwk_no")
					&& !"".equals((String)dataMap.get("svc_kei_kaisen_ucwk_no")))
			{
				return getKaisenSvcKeiNoList(param);
			}
			
			// DB照会したデータから、サービス契約番号を取得する。
			ArrayList<String> svcKeiNoList = new ArrayList<String>();
			svcKeiNoList.add((String)dataMap.get("svc_kei_no"));
			return svcKeiNoList;
		}
		
		return null;
	}
	
	/**
	 * サービス契約の更新年月日時分秒と、渡された更新年月日時分秒を比較しより大きいほうを取得します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param maxDtm 更新年月日時分秒
	 * @param svcKeiGetMap 照会済サービス契約番号マップ
	 * @param svcKeiNo サービス契約番号
	 * @return 更新年月日時分秒
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private String getDtmMaxSub(IRequestParameterReadWrite param, String maxDtm, HashMap<String, Object> svcKeiGetMap,
			String svcKeiNo) throws RequestParameterException
	{
		String maxDtmTmp = maxDtm;
		
		if (svcKeiGetMap.containsKey(svcKeiNo))
		{
			return maxDtmTmp;
		}
		
		// サービス情報作業用リストの取得
		ArrayList<HashMap<String, String>> svcKeiInfoListWork = getWorkList(param, SVC_KEI_INFO_LIST_WORK);
		
		for (HashMap<String, String> svcKeiMapWork : svcKeiInfoListWork)
		{
			if (svcKeiNo.equals(svcKeiMapWork.get("svc_kei_no")))
			{
				String lastDtm = svcKeiMapWork.get("last_upd_dtm");
				
				// 更新日が最大のサービス契約番号を取得するため、前レコードの更新日と比較する
				if (0 < lastDtm.compareTo(maxDtm))
				{
					// 最大の更新日を持つサービス契約番号として保存する
					maxDtmTmp = lastDtm;
				}
			}
		}
		
		// 同一のサービス契約番号を処理しないように格納する
		svcKeiGetMap.put(svcKeiNo, null);
		
		return maxDtmTmp;
	}
	
	/**
	 * サービス契約一意照会の上りマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param svcKeiNo サービス契約番号
	 * @return CAANMsg 
	 * @throws RequestParameterException
	 */
	private CAANMsg editInEKK0161B512Msg(IRequestParameterReadWrite param, String fixedText, String svcKeiNo) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0161B512CBSMsg.class.getName());

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

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

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

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

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

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

		return template;
	}
	
	/**
	 * サービス契約内訳一覧照会（サービス契約番号）の下りマッピング処理を行います。
	 * <br>
	 * @param msgList SCからの戻り値
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return CAANMsg
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutEKK0161B512Msg(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

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

		// サービス契約内訳情報作業用リストの取得
		ArrayList svcKeiUcwkInfoListWork = getWorkList(param, SVC_KEI_UCWK_INFO_LIST_WORK);
		// 全サービス契約内訳情報作業用リストの取得
		ArrayList allSvcKeiUcwkInfoListWork = getWorkList(param, ALL_SVC_KEI_UCWK_INFO_LIST_WK);

		/* 業務データ設定 */
		HashMap dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		CAANMsg[] templateArray = template.getCAANMsgList(EKK0161B512CBSMsg.EKK0161B512CBSMSG1LIST);

		if (templateArray != null)
		{
			for (CAANMsg childTemplate : templateArray)
			{
				// サービス契約内訳番号からサービス契約番号を引き当てるためにリストへ設定する。
				HashMap childMap = new HashMap();
				allSvcKeiUcwkInfoListWork.add(childMap);
				
				// サービス契約内訳番号
				setOutData(childMap, "svc_kei_ucwk_no", childTemplate, EKK0161B512CBSMsg1List.SVC_KEI_UCWK_NO);
				// サービス契約番号
				setOutData(childMap, "svc_kei_no", childTemplate, EKK0161B512CBSMsg1List.SVC_KEI_NO);
				
				
				// 受付済以外 or 料金コースコードがnullの場合は次の要素を処理する。
				if(!JKKStrConst.CD00037_UK_ZM.equals(childTemplate.getString(EKK0161B512CBSMsg1List.SVC_KEI_UCWK_STAT))
						|| childTemplate.isNull(EKK0161B512CBSMsg1List.PCRS_CD))
				{
					continue;
				}
				
				childMap = new HashMap();
				
				// サービス契約内訳番号
				setOutData(childMap, "svc_kei_ucwk_no", childTemplate, EKK0161B512CBSMsg1List.SVC_KEI_UCWK_NO);
				// サービス契約内訳ステータス
				setOutData(childMap, "svc_kei_ucwk_stat", childTemplate, EKK0161B512CBSMsg1List.SVC_KEI_UCWK_STAT);
				// サービス契約番号
				setOutData(childMap, "svc_kei_no", childTemplate, EKK0161B512CBSMsg1List.SVC_KEI_NO);
				// 申込明細番号
				setOutData(childMap, "mskm_dtl_no", childTemplate, EKK0161B512CBSMsg1List.MSKM_DTL_NO);
				// 料金コースコード
				setOutData(childMap, "pcrs_cd", childTemplate, EKK0161B512CBSMsg1List.PCRS_CD);
				// 料金プランコード
				setOutData(childMap, "pplan_cd", childTemplate, EKK0161B512CBSMsg1List.PPLAN_CD);
				
				// 画面の整合性チェックにかけれられた契約のみサービス対象サービス契約の登録対象とする。
				if (null != svcTgWribSeigoMap)
				{
					ArrayList<HashMap<String, Object>> seigoList = (ArrayList<HashMap<String, Object>>)svcTgWribSeigoMap.get("svc_kei_ucwk_list");
					if (null != seigoList)
					{
						for (HashMap<String, Object> seigoMap : seigoList)
						{
							// 料金コースコード
							if (!((String)childMap.get("pcrs_cd")).equals((String)seigoMap.get("pcrs_cd")))
							{
								continue;
							}
							
							// 料金プランコード
							if (!((String)childMap.get("pplan_cd")).equals((String)seigoMap.get("pplan_cd")))
							{
								continue;
							}
							
							svcKeiUcwkInfoListWork.add(childMap);
							break;
						}
					}
				}
			}
		}

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

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

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

		return param;
	}

	/**
	 * サービス契約内訳一覧照会（サービス契約番号）のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0161B512(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0161B512CBSMsg.STATUS), returnCode);

		HashMap dataMap = (HashMap)param.getData(fixedText);
		ArrayList dataList = (ArrayList)dataMap.get("EKK0161B512ERRLIST");

		if (dataList == null)
		{
			dataList = new ArrayList();
			dataMap.put("EKK0161B512ERRLIST", dataList);
		}

		HashMap errMap = new HashMap();
		dataList.add(errMap);

		// ＫＥＹ＿サービス契約番号
		setErrInfo(errMap, "key_svc_kei_no", template, EKK0161B512CBSMsg.KEY_SVC_KEI_NO);
		// ＫＥＹ＿サービス契約番号エラー
		setErrInfo(errMap, "key_svc_kei_no_err", template, EKK0161B512CBSMsg.KEY_SVC_KEI_NO_ERR);

		return param;
	}
	
	/**
	 * 照査前オプション一覧照会の上りマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param svcKeiNo サービス契約番号
	 * @return CAANMsg 
	 * @throws RequestParameterException
	 */
	private CAANMsg editInEKK0351B512Msg(IRequestParameterReadWrite param, String fixedText, String svcKeiNo) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0351B512CBSMsg.class.getName());

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

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

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

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

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

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

		return template;
	}
	
	/**
	 * 照査前オプション一覧照会の下りマッピング処理を行います。
	 * <br>
	 * @param msgList SCからの戻り値
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return CAANMsg
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutEKK0351B512Msg(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

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

		// オプションサービス契約情報作業用リストの取得
		ArrayList opList = getWorkList(param, OP_SVC_KEI_INFO_LIST_WORK);
		// サブオプションサービス契約情報作業用リストの取得
		ArrayList sbopList = getWorkList(param, SBOP_SVC_KEI_INFO_LIST_WORK);
		// 全オプションサービス契約情報作業用リストの取得
		ArrayList allOpList = getWorkList(param, ALL_OP_SVC_KEI_INFO_LIST_WK);
		// 全サブオプションサービス契約情報作業用リストの取得
		ArrayList allSbopList = getWorkList(param, ALL_SBOP_SVC_KEI_INFO_LIST_WK);

		/* 業務データ設定 */
		HashMap dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		CAANMsg[] templateArray = template.getCAANMsgList(EKK0351B512CBSMsg.EKK0351B512CBSMSG1LIST);

		if (templateArray != null)
		{
			// 全オプションサービス契約情報作業用リストに追加したオプションサービス契約番号を格納するマップ
			HashMap<String, Object> opAddMap = new HashMap<String, Object>();
			HashMap childMap = null;
			
			for (CAANMsg childTemplate : templateArray)
			{
				// 照会済みのオプションサービス契約はスキップ
				if (!opAddMap.containsKey(childTemplate.getString(EKK0351B512CBSMsg1List.KK0351_OP_SVC_KEI_NO)))
				{
					// オプションサービス契約番号からサービス契約番号を引き当てるためにリストへ設定する。
					childMap = new HashMap();
					allOpList.add(childMap);
					
					// オプションサービス契約番号
					setOutData(childMap, "op_svc_kei_no", childTemplate, EKK0351B512CBSMsg1List.KK0351_OP_SVC_KEI_NO);
					// サービス契約番号
					childMap.put("svc_kei_no", template.getString(EKK0351B512CBSMsg.KEY_SVC_KEI_NO));
					
					// 受付済以外 かつ オプションサービスコードがnullでない場合は要素に追加する。
					if (JKKStrConst.CD00037_UK_ZM.equals(childTemplate.getString(EKK0351B512CBSMsg1List.KK0351_OP_SVC_KEI_STAT))
							&& !childTemplate.isNull(EKK0351B512CBSMsg1List.KK0351_OP_SVC_CD))
					{
						childMap = new HashMap();
						
						// オプションサービス契約番号
						setOutData(childMap, "op_svc_kei_no", childTemplate, EKK0351B512CBSMsg1List.KK0351_OP_SVC_KEI_NO);
						// オプションサービスステータス
						setOutData(childMap, "op_svc_kei_stat", childTemplate, EKK0351B512CBSMsg1List.KK0351_OP_SVC_KEI_STAT);
						// オプションサービスコード
						setOutData(childMap, "op_svc_cd", childTemplate, EKK0351B512CBSMsg1List.KK0351_OP_SVC_CD);
						// 申込明細番号
						setOutData(childMap, "mskm_dtl_no", childTemplate, EKK0351B512CBSMsg1List.KK0351_MSKM_DTL_NO);
						// 料金コースコード
						setOutData(childMap, "pcrs_cd", childTemplate, EKK0351B512CBSMsg1List.KK0351_PCRS_CD);
						// 料金プランコード
						setOutData(childMap, "pplan_cd", childTemplate, EKK0351B512CBSMsg1List.KK0351_PPLAN_CD);
						
						// 画面の整合性チェックにかけれられた契約のみサービス対象サービス契約の登録対象とする。
						if (null != svcTgWribSeigoMap)
						{
							ArrayList<HashMap<String, Object>> seigoList = (ArrayList<HashMap<String, Object>>)svcTgWribSeigoMap.get("op_list");
							if (null != seigoList)
							{
								for (HashMap<String, Object> seigoMap : seigoList)
								{
									// オプションサービスコード
									if (!((String)childMap.get("op_svc_cd")).equals((String)seigoMap.get("op_svc_cd")))
									{
										continue;
									}
									
									// 料金コースコード
									if (!((String)childMap.get("pcrs_cd")).equals((String)seigoMap.get("pcrs_cd")))
									{
										continue;
									}
									
									// 料金プランコード
									if (!((String)childMap.get("pplan_cd")).equals((String)seigoMap.get("pplan_cd")))
									{
										continue;
									}
									
									opList.add(childMap);
									break;
								}
							}
						}
					}
					
					opAddMap.put(childTemplate.getString(EKK0351B512CBSMsg1List.KK0351_OP_SVC_KEI_NO), null);
				}
				
				
				// サブオプションサービスコードがnullでない場合は要素に追加する。
				if (!childTemplate.isNull(EKK0351B512CBSMsg1List.KK0401_SBOP_SVC_CD))
				{
					// サブオプションサービス契約番号からサービス契約番号を引き当てるためにリストへ設定する。
					childMap = new HashMap();
					allSbopList.add(childMap);
					
					// サブオプションサービス契約番号
					setOutData(childMap, "sbop_svc_kei_no", childTemplate, EKK0351B512CBSMsg1List.KK0401_SBOP_SVC_KEI_NO);
					// サービス契約番号
					childMap.put("svc_kei_no", template.getString(EKK0351B512CBSMsg.KEY_SVC_KEI_NO));
					
					// 受付済以外の場合は要素に追加する。
					if (JKKStrConst.CD00037_UK_ZM.equals(childTemplate.getString(EKK0351B512CBSMsg1List.KK0401_SBOP_SVC_KEI_STAT)))
					{
						childMap = new HashMap();
						
						// オプションサービス契約番号
						setOutData(childMap, "op_svc_kei_no", childTemplate, EKK0351B512CBSMsg1List.KK0351_OP_SVC_KEI_NO);
						// サブオプションサービス契約番号
						setOutData(childMap, "sbop_svc_kei_no", childTemplate, EKK0351B512CBSMsg1List.KK0401_SBOP_SVC_KEI_NO);
						// サブオプションサービスステータス
						setOutData(childMap, "sbop_svc_kei_stat", childTemplate, EKK0351B512CBSMsg1List.KK0401_SBOP_SVC_KEI_STAT);
						// サブオプションサービスコード
						setOutData(childMap, "sbop_svc_cd", childTemplate, EKK0351B512CBSMsg1List.KK0401_SBOP_SVC_CD);
						// 申込明細番号
						setOutData(childMap, "mskm_dtl_no", childTemplate, EKK0351B512CBSMsg1List.KK0401_MSKM_DTL_NO);
						// 料金コースコード
						setOutData(childMap, "pcrs_cd", childTemplate, EKK0351B512CBSMsg1List.KK0401_PCRS_CD);
						// 料金プランコード
						setOutData(childMap, "pplan_cd", childTemplate, EKK0351B512CBSMsg1List.KK0401_PPLAN_CD);
						
						// 画面の整合性チェックにかけれられた契約のみサービス対象サービス契約の登録対象とする。
						if (null != svcTgWribSeigoMap)
						{
							ArrayList<HashMap<String, Object>> seigoList = (ArrayList<HashMap<String, Object>>)svcTgWribSeigoMap.get("sbop_list");
							if (null != seigoList)
							{
								for (HashMap<String, Object> seigoMap : seigoList)
								{
									// サブオプションサービスコード
									if (!((String)childMap.get("sbop_svc_cd")).equals((String)seigoMap.get("sbop_svc_cd")))
									{
										continue;
									}
									
									// 料金コースコード
									if (!((String)childMap.get("pcrs_cd")).equals((String)seigoMap.get("pcrs_cd")))
									{
										continue;
									}
									
									// 料金プランコード
									if (!((String)childMap.get("pplan_cd")).equals((String)seigoMap.get("pplan_cd")))
									{
										continue;
									}
									
									sbopList.add(childMap);
									break;
								}
							}
						}
					}
				}
			}
		}

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

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

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

		return param;
	}

	/**
	 * 照査前オプション一覧照会のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0351B512(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0351B512CBSMsg.STATUS), returnCode);
		
		HashMap dataMap = (HashMap)param.getData(fixedText);
		ArrayList dataList = (ArrayList)dataMap.get("EKK0351B512ERRLIST");
		
		if (dataList == null)
		{
			dataList = new ArrayList();
			dataMap.put("EKK0351B512ERRLIST", dataList);
		}
		
		HashMap errMap = new HashMap();
		dataList.add(errMap);
		
		// ＫＥＹ＿サービス契約番号エラー
		setErrInfo(errMap, "key_svc_kei_no_err", template, EKK0351B512CBSMsg.KEY_SVC_KEI_NO_ERR);
		// ＫＥＹ＿サービス契約内訳番号エラー
		setErrInfo(errMap, "key_svc_kei_ucwk_no_err", template, EKK0351B512CBSMsg.KEY_SVC_KEI_UCWK_NO_ERR);
		
		return param;
	}
	
	/**
	 * 照査前機器提供サービス契約一覧照会の上りマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param svcKeiNo サービス契約番号
	 * @return CAANMsg 
	 * @throws RequestParameterException
	 */
	private CAANMsg editInEKK0341B508Msg(IRequestParameterReadWrite param, String fixedText, String svcKeiNo) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341B508CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK0341B508CBSMsg.TEMPLATEID, "EKK0341B508");
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// 機能コード
		template.set(EKK0341B508CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);
		
		// ＫＥＹ＿サービス契約番号
		template.set(EKK0341B508CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);
		
		return template;
	}
	
	/**
	 * 照査前機器提供サービス契約一覧照会の下りマッピング処理を行います。
	 * <br>
	 * @param msgList SCからの戻り値
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return CAANMsg
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutEKK0341B508Msg(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

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

		// 機器提供サービス契約情報作業用リストの取得
		ArrayList dataList = getWorkList(param, KKTK_SVC_KEI_INFO_LIST_WORK);
		// 全機器提供サービス契約情報作業用リストの取得
		ArrayList allDataList = getWorkList(param, ALL_KKTK_SVC_KEI_INFO_LIST_WK);

		/* 業務データ設定 */
		HashMap dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}

		CAANMsg[] templateArray = template.getCAANMsgList(EKK0341B508CBSMsg.EKK0341B508CBSMSG1LIST);

		if (templateArray != null)
		{
			for (CAANMsg childTemplate : templateArray)
			{
				// 機器提供サービス契約番号からサービス契約番号を引き当てるためにリストへ設定する。
				HashMap childMap = new HashMap();
				allDataList.add(childMap);
				
				// 機器提供サービス契約番号
				setOutData(childMap, "kktk_svc_kei_no", childTemplate, EKK0341B508CBSMsg1List.KKTK_SVC_KEI_NO);
				// サービス契約番号
				setOutData(childMap, "svc_kei_no", childTemplate, EKK0341B508CBSMsg1List.SVC_KEI_NO);
				// 機器提供サービスコード
				setOutData(childMap, "kktk_svc_cd", childTemplate, EKK0341B508CBSMsg1List.KKTK_SVC_CD);
				
				// 受付済以外 or 料金コースコードがnullの場合は次の要素を処理する。
				if(!JKKStrConst.CD00037_UK_ZM.equals(childTemplate.getString(EKK0341B508CBSMsg1List.KKTK_SVC_KEI_STAT))
						|| childTemplate.isNull(EKK0341B508CBSMsg1List.KKTK_SVC_CD))
				{
					continue;
				}
				
				childMap = new HashMap();
				
				// 機器提供サービス契約番号
				setOutData(childMap, "kktk_svc_kei_no", childTemplate, EKK0341B508CBSMsg1List.KKTK_SVC_KEI_NO);
				// 機器提供サービス契約ステータス
				setOutData(childMap, "kktk_svc_kei_stat", childTemplate, EKK0341B508CBSMsg1List.KKTK_SVC_KEI_STAT);
				// 申込明細番号
				setOutData(childMap, "mskm_dtl_no", childTemplate, EKK0341B508CBSMsg1List.MSKM_DTL_NO);
				// 機器提供サービスコード
				setOutData(childMap, "kktk_svc_cd", childTemplate, EKK0341B508CBSMsg1List.KKTK_SVC_CD);
				// 料金コースコード
				setOutData(childMap, "pcrs_cd", childTemplate, EKK0341B508CBSMsg1List.PCRS_CD);
				// 料金プランコード
				setOutData(childMap, "pplan_cd", childTemplate, EKK0341B508CBSMsg1List.PPLAN_CD);
				// 機器提供種別コード
				setOutData(childMap, "kktk_sbt_cd", childTemplate, EKK0341B508CBSMsg1List.KKTK_SBT_CD);
				// 最終更新年月日時分秒
				setOutData(childMap, "last_upd_dtm", childTemplate, EKK0341B508CBSMsg1List.LAST_UPD_DTM);
				
				// 画面の整合性チェックにかけれられた契約のみサービス対象サービス契約の登録対象とする。
				if (null != svcTgWribSeigoMap)
				{
					ArrayList<HashMap<String, Object>> seigoList = (ArrayList<HashMap<String, Object>>)svcTgWribSeigoMap.get("kktk_list");
					if (null != seigoList)
					{
						for (HashMap<String, Object> seigoMap : seigoList)
						{
							// 機器提供サービスコード
							if (!((String)childMap.get("kktk_svc_cd")).equals((String)seigoMap.get("kktk_svc_cd")))
							{
								continue;
							}
							
							// 料金コースコード
							if (!((String)childMap.get("pcrs_cd")).equals((String)seigoMap.get("pcrs_cd")))
							{
								continue;
							}
							
							// 料金プランコード
							if (!((String)childMap.get("pplan_cd")).equals((String)seigoMap.get("pplan_cd")))
							{
								continue;
							}
							
							// 機器提供種別コード
							if (!((String)childMap.get("kktk_sbt_cd")).equals((String)seigoMap.get("kktk_sbt_cd")))
							{
								continue;
							}
							
							dataList.add(childMap);
							break;
						}
					}
				}
			}
		}

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

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

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

		return param;
	}

	/**
	 * 照査前機器提供サービス契約一覧照会のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0341B508(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0351B512CBSMsg.STATUS), returnCode);
		
		HashMap dataMap = (HashMap)param.getData(fixedText);
		ArrayList dataList = (ArrayList)dataMap.get("EKK0341B508ERRLIST");
		
		if (dataList == null)
		{
			dataList = new ArrayList();
			dataMap.put("EKK0341B508ERRLIST", dataList);
		}
		
		HashMap errMap = new HashMap();
		dataList.add(errMap);
		
		// ＫＥＹ＿サービス契約番号エラー
		setErrInfo(errMap, "key_svc_kei_no_err", template, EKK0341B508CBSMsg.KEY_SVC_KEI_NO_ERR);
		
		return param;
	}
	
	/**
	 * 照査前回線機器提供サービス契約一覧照会の上りマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param svcKeiKaisenUcwkNo サービス契約回線内訳番号
	 * @return CAANMsg 
	 * @throws RequestParameterException
	 */
	private CAANMsg editInEKK0341B516Msg(IRequestParameterReadWrite param, String fixedText,
			String svcKeiKaisenUcwkNo) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341B516CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK0341B508CBSMsg.TEMPLATEID, "EKK0341B516");
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// 機能コード
		template.set(EKK0341B516CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		
		// ＫＥＹ＿サービス契約回線内訳番号
		template.set(EKK0341B516CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO, svcKeiKaisenUcwkNo);
		
		return template;
	}
	
	/**
	 * 照査前回線機器提供サービス契約一覧照会の下りマッピング処理を行います。
	 * <br>
	 * @param msgList SCからの戻り値
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @return CAANMsg
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutEKK0341B516Msg(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 機器提供サービス契約情報作業用リストの取得
		ArrayList dataList = getWorkList(param, KKTK_SVC_KEI_INFO_LIST_WORK);
		// 全機器提供サービス契約情報作業用リストの取得
		ArrayList allDataList = getWorkList(param, ALL_KKTK_SVC_KEI_INFO_LIST_WK);
		
		/* 業務データ設定 */
		HashMap dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}
		
		// 回線に紐付く機器の割引整合性チェック情報を取得する。
		svcTgWribSeigoMap = null;
		HashMap<String, Object> wribSeigoMap = (HashMap<String, Object>)dataMap.get("wrib_seigo_map");
		if (null != wribSeigoMap)
		{
			svcTgWribSeigoMap = (HashMap<String, Object>)wribSeigoMap.get(WRIB_KIND_CD.KISN_KEI_KIKI.name());
		}
		
		CAANMsg[] templateArray = template.getCAANMsgList(EKK0341B516CBSMsg.EKK0341B516CBSMSG1LIST);
		
		if (templateArray != null)
		{
			for (CAANMsg childTemplate : templateArray)
			{
				// 機器提供サービス契約番号からサービス契約番号を引き当てるためにリストへ設定する。
				HashMap childMap = new HashMap();
				allDataList.add(childMap);
				
				// 機器提供サービス契約番号
				setOutData(childMap, "kktk_svc_kei_no", childTemplate, EKK0341B516CBSMsg1List.KKTK_SVC_KEI_NO);
				// サービス契約回線内訳番号
				setOutData(childMap, "svc_kei_kaisen_ucwk_no", childTemplate, EKK0341B516CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO);
				// 機器提供サービスコード
				setOutData(childMap, "kktk_svc_cd", childTemplate, EKK0341B516CBSMsg1List.KKTK_SVC_CD);
				
				// 受付済以外 or 料金コースコードがnullの場合は次の要素を処理する。
				if (!JKKStrConst.CD00037_UK_ZM.equals(childTemplate.getString(EKK0341B516CBSMsg1List.KKTK_SVC_KEI_STAT))
						|| childTemplate.isNull(EKK0341B516CBSMsg1List.KKTK_SVC_CD))
				{
					continue;
				}
				
				childMap = new HashMap();
				
				// 機器提供サービス契約番号
				setOutData(childMap, "kktk_svc_kei_no", childTemplate, EKK0341B508CBSMsg1List.KKTK_SVC_KEI_NO);
				// 機器提供サービス契約ステータス
				setOutData(childMap, "kktk_svc_kei_stat", childTemplate, EKK0341B508CBSMsg1List.KKTK_SVC_KEI_STAT);
				
				// 申込明細番号
				//   回線機器の申込明細番号は機器提供サービス契約のレコードを新規に登録した時点のままで
				//   登録訂正では更新されていないため使用しない。
				
				// 機器提供サービスコード
				setOutData(childMap, "kktk_svc_cd", childTemplate, EKK0341B508CBSMsg1List.KKTK_SVC_CD);
				// 料金コースコード
				setOutData(childMap, "pcrs_cd", childTemplate, EKK0341B508CBSMsg1List.PCRS_CD);
				// 料金プランコード
				setOutData(childMap, "pplan_cd", childTemplate, EKK0341B508CBSMsg1List.PPLAN_CD);
				// 機器提供種別コード
				setOutData(childMap, "kktk_sbt_cd", childTemplate, EKK0341B508CBSMsg1List.KKTK_SBT_CD);
				// 最終更新年月日時分秒
				setOutData(childMap, "last_upd_dtm", childTemplate, EKK0341B508CBSMsg1List.LAST_UPD_DTM);
				// サービス契約回線内訳番号
				setOutData(childMap, "svc_kei_kaisen_ucwk_no", childTemplate, EKK0341B516CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO);
				
				// 画面の整合性チェックにかけれられた契約のみサービス対象サービス契約の登録対象とする。
				if (null != svcTgWribSeigoMap)
				{
					ArrayList<HashMap<String, Object>> seigoList = (ArrayList<HashMap<String, Object>>)svcTgWribSeigoMap.get("kktk_list");
					if (null != seigoList)
					{
						for (HashMap<String, Object> seigoMap : seigoList)
						{
							// 機器提供サービスコード
							if (!((String)childMap.get("kktk_svc_cd")).equals((String)seigoMap.get("kktk_svc_cd")))
							{
								continue;
							}
							
							// 料金コースコード
							if (!((String)childMap.get("pcrs_cd")).equals((String)seigoMap.get("pcrs_cd")))
							{
								continue;
							}
							
							// 料金プランコード
							if (!((String)childMap.get("pplan_cd")).equals((String)seigoMap.get("pplan_cd")))
							{
								continue;
							}
							
							// 機器提供種別コード
							if (!((String)childMap.get("kktk_sbt_cd")).equals((String)seigoMap.get("kktk_sbt_cd")))
							{
								continue;
							}
							
							dataList.add(childMap);
							break;
						}
					}
				}
			}
		}

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

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

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

		return param;
	}

	/**
	 * 照査前回線機器提供サービス契約一覧照会のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0341B516(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0351B512CBSMsg.STATUS), returnCode);
		
		HashMap dataMap = (HashMap)param.getData(fixedText);
		ArrayList dataList = (ArrayList)dataMap.get("EKK0341B516ERRLIST");
		
		if (dataList == null)
		{
			dataList = new ArrayList();
			dataMap.put("EKK0341B516ERRLIST", dataList);
		}
		
		HashMap errMap = new HashMap();
		dataList.add(errMap);
		
		// ＫＥＹ＿サービス契約回線内訳番号エラー
		setErrInfo(errMap, "key_svc_kei_kaisen_ucwk_no_err", template, EKK0341B516CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO_ERR);
		
		return param;
	}
	
	/**
	 * 照査前機器オプションサービス契約一覧照会の上りマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @return CAANMsg 
	 * @throws RequestParameterException
	 */
	private CAANMsg editInEKK2811B502Msg(IRequestParameterReadWrite param, String fixedText,
			String kktkSvcKeiNo) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811B502CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EKK2811B502CBSMsg.TEMPLATEID, "EKK2811B502");
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		// 機能コード
		template.set(EKK2811B502CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
		
		// ＫＥＹ＿機器提供サービス契約番号
		template.set(EKK2811B502CBSMsg.KEY_KKTK_SVC_KEI_NO, kktkSvcKeiNo);
		
		return template;
	}
	
	/**
	 * 照査前機器オプションサービス契約一覧照会の下りマッピング処理を行います。
	 * <br>
	 * @param msgList SCからの戻り値
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @return CAANMsg
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutEKK2811B502Msg(Map<?, ?> msgList, IRequestParameterReadWrite param, String fixedText, String kktkSvcKeiNo)
	throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 機器オプションサービス契約情報作業用リストの取得
		ArrayList dataList = getWorkList(param, KKOP_SVC_KEI_INFO_LIST_WORK);
		// 全機器オプションサービス契約情報作業用リストの取得
		ArrayList allDataList = getWorkList(param, ALL_KKOP_SVC_KEI_INFO_LIST_WK);
		
		/* 業務データ設定 */
		HashMap dataMap = (HashMap)param.getData(fixedText);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(fixedText, dataMap);
		}
		
		// 機器オプションサービス契約に紐付く機器の割引整合性チェック情報を取得する。
		svcTgWribSeigoMap = null;
		HashMap<String, Object> wribSeigoMap = (HashMap<String, Object>)dataMap.get("wrib_seigo_map");
		if (null != wribSeigoMap)
		{
			svcTgWribSeigoMap = (HashMap<String, Object>)wribSeigoMap.get(WRIB_KIND_CD.KIKI_OP.name());
		}
		
		CAANMsg[] templateArray = template.getCAANMsgList(EKK2811B502CBSMsg.EKK2811B502CBSMSG1LIST);
		
		if (templateArray != null)
		{
			for (CAANMsg childTemplate : templateArray)
			{
				// 機器提供サービス契約番号からサービス契約番号を引き当てるためにリストへ設定する。
				HashMap childMap = new HashMap();
				allDataList.add(childMap);
				
				// 機器オプションサービス契約番号
				setOutData(childMap, "kkop_svc_kei_no", childTemplate, EKK2811B502CBSMsg1List.KKOP_SVC_KEI_NO);
				
				// サービス契約番号
				// ─────────────────────────────────────
				//  �@ 連帯ありの場合、登録契機となったサービスのサービス契約番号を設定する。
				//  �A 上記以外の場合、照会値を設定する。
				// ─────────────────────────────────────
				String rntaiFlg = childTemplate.getString(EKK2811B502CBSMsg1List.KIKI_RNTAI_KEI_CHGECHU_FLG);
				if (JKKStrConst.KEI_CHGECHU_FLG_ON.equals(rntaiFlg))
				{
					// �@
					String kkopSvcCd = childTemplate.getString(EKK2811B502CBSMsg1List.KKOP_SVC_CD);
					if (JKKStrConst.KKOP_SVC_CD_ROUTER.equals(kkopSvcCd))
					{
						// ルーターオプションが連帯の場合は、登録契機は電話なので電話のサービス契約番号を設定する。
						childMap.put("svc_kei_no", JKKBpCommon.getWkSvcKeiNoTel(param));
					}
					else if (JKKStrConst.KKOP_SVC_CD_TEL_ADAPT.equals(kkopSvcCd))
					{
						// 電話アダプターオプションが連帯の場合は、登録契機はネットなのでネットのサービス契約番号を設定する。
						childMap.put("svc_kei_no", JKKBpCommon.getWkSvcKeiNoNet(param));
					}
				}
				else
				{
					// �A
					// 連帯でない場合、機器オプションサービス契約の申込明細番号をサービス契約番号に変換して設定する。
					childMap.put("svc_kei_no", JKKBpCommon.cvtMskmDtlNoToSvcKeiNo(param, childTemplate.getString(EKK2811B502CBSMsg1List.MSKM_DTL_NO)));
				}
				
				
				// 受付済以外 or 機器オプションサービスコードがnullの場合は次の要素を処理する。
				if (!JKKStrConst.CD00037_UK_ZM.equals(childTemplate.getString(EKK2811B502CBSMsg1List.KKOP_SVC_KEI_STAT))
						|| childTemplate.isNull(EKK2811B502CBSMsg1List.KKOP_SVC_CD))
				{
					continue;
				}
				
				childMap = new HashMap();
				
				// 機器オプションサービス契約番号
				setOutData(childMap, "kkop_svc_kei_no", childTemplate, EKK2811B502CBSMsg1List.KKOP_SVC_KEI_NO);
				// 機器オプション供サービス契約ステータス
				setOutData(childMap, "kkop_svc_kei_stat", childTemplate, EKK2811B502CBSMsg1List.KKOP_SVC_KEI_STAT);
				// 機器オプションサービスコード
				setOutData(childMap, "kkop_svc_cd", childTemplate, EKK2811B502CBSMsg1List.KKOP_SVC_CD);
				// 料金コースコード
				setOutData(childMap, "pcrs_cd", childTemplate, EKK2811B502CBSMsg1List.PCRS_CD);
				// 料金プランコード
				setOutData(childMap, "pplan_cd", childTemplate, EKK2811B502CBSMsg1List.PPLAN_CD);
				
				// 申込明細番号
				// ─────────────────────────────────────
				//  �@ 連帯ありの場合、登録契機となったサービスの申込明細番号を設定する。
				//  �A 上記以外の場合、照会値を設定する。
				// ─────────────────────────────────────
				String kikiRntaiKeiChgechuFlg = childTemplate.getString(EKK2811B502CBSMsg1List.KIKI_RNTAI_KEI_CHGECHU_FLG);
				if(JKKStrConst.KEI_CHGECHU_FLG_ON.equals(kikiRntaiKeiChgechuFlg))
				{	// �@
					ArrayList<HashMap<String, String>> svcKeiInfoListWork = getWorkList(param, SVC_KEI_INFO_LIST_WORK);
					String prcGrpCd = null;
					String mskmDtlNo = null;
					
					for(HashMap<String, String> mp : svcKeiInfoListWork)
					{
						prcGrpCd = mp.get("prc_grp_cd");
						if(JKKCtrlyUtil.getNetSvcJdg(prcGrpCd) || JKKCtrlyUtil.getTelSvcJdg(prcGrpCd))
						{
							mskmDtlNo = mp.get("mskm_dtl_no");
							break;
						}
					}
					
					childMap.put("mskm_dtl_no", mskmDtlNo);
				}
				else
				{	// �A
					setOutData(childMap, "mskm_dtl_no", childTemplate, EKK2811B502CBSMsg1List.MSKM_DTL_NO);
				}
				
				// 最終更新年月日時分秒
				setOutData(childMap, "last_upd_dtm", childTemplate, EKK2811B502CBSMsg1List.LAST_UPD_DTM);
				
				// 画面の整合性チェックにかけれられた契約のみサービス対象サービス契約の登録対象とする。
				if (null != svcTgWribSeigoMap)
				{
					ArrayList<HashMap<String, Object>> seigoList = (ArrayList<HashMap<String, Object>>)svcTgWribSeigoMap.get("kkop_list");
					if (null != seigoList)
					{
						for (HashMap<String, Object> seigoMap : seigoList)
						{
							// 機器オプションサービスコード
							if (!((String)childMap.get("kkop_svc_cd")).equals((String)seigoMap.get("kkop_svc_cd")))
							{
								continue;
							}
							
							// 料金コースコード
							if (!((String)childMap.get("pcrs_cd")).equals((String)seigoMap.get("pcrs_cd")))
							{
								continue;
							}
							
							// 料金プランコード
							if (!((String)childMap.get("pplan_cd")).equals((String)seigoMap.get("pplan_cd")))
							{
								continue;
							}
							
							dataList.add(childMap);
							break;
						}
					}
				}
			}
		}

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

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

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

		return param;
	}

	/**
	 * 照査前機器オプションサービス契約一覧照会のエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam リクエストパラメータ
	 * @param template CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK2811B502(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0351B512CBSMsg.STATUS), returnCode);
		
		HashMap dataMap = (HashMap)param.getData(fixedText);
		ArrayList dataList = (ArrayList)dataMap.get("EKK2811B502ERRLIST");
		
		if (dataList == null)
		{
			dataList = new ArrayList();
			dataMap.put("EKK2811B502ERRLIST", dataList);
		}
		
		HashMap errMap = new HashMap();
		dataList.add(errMap);
		
		// ＫＥＹ＿機器提供サービス契約番号エラー
		setErrInfo(errMap, "key_kktk_svc_kei_no_err", template, EKK2811B502CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR);
		
		return param;
	}

	/**
	 * ワーク領域に格納されている項目値の取得を行います。
	 * <br>
	 * @param param
	 * @param mapName マップ名
	 * @param key マップの項目キー
	 * @return 指定されたマップに格納されている項目値
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private String getWorkMapValue(IRequestParameterReadWrite param, String mapName, String key) throws RequestParameterException
	{
		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			return null;
		}

		HashMap ccWorkMap = (HashMap)workMap.get(mapName);
		if (ccWorkMap == null)
		{
			return null;
		}
		
		String workValue = (String)ccWorkMap.get(key);
		if ("".equals(workValue))
		{
			return null;
		}
		
		return workValue;
	}

}