/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：JKKCancelUsePlaceInfoCC
*   ソースファイル名：JKKCancelUsePlaceInfoCC.java
*   作成者          ：富士通
*   日付            ：2011年06月13日
*＜機能概要＞
*   利用場所情報キャンセル部品
*＜修正履歴＞
*   バージョン  修正日       修正者      修正内容
*   v1.00.00    2011/06/13   FJ）土屋    新規作成
*   v4.00.00    2012/12/18   FJ) 北浦    【ANK-1247-00-00】 申込スキーマ「工事依頼情報連絡事項」の桁数不正対応(破棄対応)
*   v5.00.00    2013/01/21   FJ) 川島    【KAD-2012-0001108】書面での受付番号の申込イメージの紐付けについて
*   v7.00.00    2013/11/08   FJ) 北浦    【ANK-1578-00-00】多機能ルーター(機器追加)
*   v7.01.00    2014/02/05   FJ) 川島    【OM-2014-0000541】機器オプションがキャンセルされない
*   v61.00.00	2023/07/12	 FJ)西窪	 【ANK-4315-00-00】【eo定期】 eoホームゲートウェイ導入対応
**********************************************************************/
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.ejb.cbs.cbsmsg.EKK0081B011CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B011CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0251C070CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C330CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811C110CBSMsg;



/**
 * 利用場所情報キャンセル部品
 * <br>
 * @author 富士通
 */
public class JKKCancelUsePlaceInfoCC extends AbstractCommonComponent
{
	/** リターンメッセージ */
	private static final String RETURN_MESSAGE_STRING = "RETURN_MESSAGE_";
	/** リターンメッセージ */
	private static final String RETURN_MESSAGE_FORMAT = "%1$04d";
	/** 作業マップ名 */
	private static final String CC_WORK_AREA_NAME = "JKKCancelUsePlaceInfoCCWork";
	/** エラー用 */
	private static final String SC_ERROR_STRING = "サービスコンポーネントエラー";
	/** ArrayList名 */
	private static final String KKTSVKEI_CANCEL_LIST = "kktsvkei_cancel_list";
	/** ArrayList名 機器オプションサービス契約キャンセルリスト */
	private static final String KKTK_OP_CANCEL_LIST = "kktk_op_cancel_list";
	/** 機器オプション情報マップ */
	private HashMap<kikiOpMapKeys, Boolean> kikiOpInfoMap = null;
	
	/** 機器オプション情報マップ用キー */
	private static enum kikiOpMapKeys
	{
		/** VAオプション キャンセル */
		VA_OP_CANCEL
		/** ルーターオプション キャンセル */
		, ROUTER_OP_CANCEL
	}
	
	/** サービス契約回線内訳に紐付くサービス契約を格納するリスト */
	private ArrayList<HashMap<String, Object>> svcKeiList = null;
	/** 機器の種類 */
	private static enum kikiKinds
	{
		/** ONU */
		ONU
		/** V-ONU */
		, VONU
		/** モデム子機(VDSL) */
		, VDSL
		/** eo光多機能ルーター */
		, TAKINORT
		/** VA */
		, VA
		/** ルーター */
		, ROUTER
		// ANK-4315-00-00 ADD START
		/** HGW */
		, HGW
		// ANK-4315-00-00 ADD END
	}

	/** サービス契約の種類 */
	private static enum svcKeiKinds
	{
		/** eo光ネット or eo光電話 */
		EOH_NT_OR_EOH_TL
		/** eo光テレビ */
		, EOH_TV
		/** eo光ネット */
		, EOH_NT
		/** eo光電話 */
		, EOH_TL
	}
	/** 機器オプションの種類 */
	private static enum kikiOpKinds
	{
		/** VAオプション */
		VAOPITON
		/** ルーターオプション */
		, ROUTEROPITON
	}
	
	/**
	 * 利用場所情報キャンセル処理を行います。
	 * <br>
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite cancelUsePlaceInfo(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		HashMap<String, Object> paramMap = setSCInputCommonData(param, new HashMap<String, Object>());
		Map<?, ?> result = null;
		CAANMsg template = null;

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

		// マップに値が設定されていない場合は処理を行わない。
		if (checkMap == null)
		{
			return param;
		}
		
		// 機器オプション情報マップ初期化
		initKikiOpMap();

		// 同一利用場所サービス契約一覧照会
		template = editInEKK0081B011(param, fixedText); // 上りマッピング
		result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
		editRetEKK0081B011(result, param, fixedText); // 下りマッピング
		// ステータスが単項目エラー以上であれば例外をスロー
		if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
		{
			throw new CCException(SC_ERROR_STRING, new Exception());
		}
		
		String kkopSvcCd = null;
		// 機器オプションサービス契約キャンセルリストを取得する。
		ArrayList<HashMap<String, Object>> kikiOpList = getList(param, fixedText, KKTK_OP_CANCEL_LIST);
		for(HashMap<String, Object> kikiOpMap : kikiOpList)
		{
			if(!JKKStrConst.CD00056_STAT_UKETSUKEZUMI.equals(String.valueOf(kikiOpMap.get("kk2811_kkop_svc_kei_stat"))))
			{
				continue;
			}
			kkopSvcCd = String.valueOf(kikiOpMap.get("kk2811_kkop_svc_cd"));
			
			
			
			if(JKKStrConst.KKOP_SVC_CD_ROUTER.equals(kkopSvcCd))
			{	//ｅｏ光多機能ルーター ルーター機能
				// が登録不要の場合、次の要素を処理する。
				if(!isCancelKikiOp(param, fixedText, kikiOpKinds.ROUTEROPITON))
				{
					continue;
				}
				kikiOpInfoMap.put(kikiOpMapKeys.ROUTER_OP_CANCEL, true);
			}
			else if(JKKStrConst.KKOP_SVC_CD_TEL_ADAPT.equals(kkopSvcCd))
			{	//ｅｏ光多機能ルーター 電話アダプター機能
				
				if(!isCancelKikiOp(param, fixedText, kikiOpKinds.VAOPITON))
				{
					continue;
				}
				kikiOpInfoMap.put(kikiOpMapKeys.VA_OP_CANCEL, true);
			}
			else
			{
				continue;
			}
			
			// 機器オプションサービス契約キャンセル
			template = editInEKK2811C110(param, fixedText, kikiOpMap);
			result = scCall.run(putParamMap(paramMap, template), handle);
			editRetEKK2811C110(result, param, kikiOpMap);
			// ステータスが単項目エラー以上であれば例外をスロー
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}
		
		// 機器提供サービス契約キャンセルリストを取得
		ArrayList<HashMap<String, Object>> kikiList = getList(param, fixedText, KKTSVKEI_CANCEL_LIST);
		String kktkSvcCd = null;
		
		if (kikiList != null && kikiList.size() > 0)	
		{
			for(HashMap<String, Object> kikiMap : kikiList)
			{
				// 機器提供サービス契約ステータスが受付済以外の場合、次の要素を処理する。
				if(!JKKStrConst.CD00056_STAT_UKETSUKEZUMI.equals(String.valueOf(kikiMap.get("kk0341_kktk_svc_kei_stat"))))
				{
					continue;
				}

				kktkSvcCd = String.valueOf(kikiMap.get("kk0341_kktk_svc_cd"));
				
				// ONUがキャンセル不可の場合、次の要素を処理する。
				if(JKKStrConst.CD00132_ONU.equals(kktkSvcCd) && !isCancelKiki(param, fixedText, kikiKinds.ONU))
				{
					continue;
				}
				// V-ONUがキャンセル不可の場合、次の要素を処理する。
				else if(JKKStrConst.CD00132_VONU.equals(kktkSvcCd) && !isCancelKiki(param, fixedText, kikiKinds.VONU))
				{
					continue;
				}
				// VDSLがキャンセル不可の場合、次の要素を処理する。
				else if(JKKStrConst.CD00132_MODEM.equals(kktkSvcCd) && !isCancelKiki(param, fixedText, kikiKinds.VDSL))
				{
					continue;
				}
				// 多機能ルーターがキャンセル不可の場合、次の要素を処理する。
				else if(JKKStrConst.KKTK_SVC_CD_TAKINORT.equals(kktkSvcCd) && !isCancelKiki(param, fixedText, kikiKinds.TAKINORT))
				{
					continue;
				}
				// ルーターがキャンセル不可の場合、次の要素を処理する。
				else if(JKKStrConst.CD00132_BBR.equals(kktkSvcCd) && !isCancelKiki(param, fixedText, kikiKinds.ROUTER))
				{
					continue;
				}
				// ＶＡがキャンセル不可の場合、次の要素を処理する。
				else if(JKKStrConst.KKTK_SVC_CD_VA.equals(kktkSvcCd) && !isCancelKiki(param, fixedText, kikiKinds.VA))
				{
					continue;
				}
				// ANK-4315-00-00 ADD START
				// HGWがキャンセル不可の場合、次の要素を処理する。
				else if(JKKStrConst.KKTK_SVC_CD_HGW.equals(kktkSvcCd) && !isCancelKiki(param, fixedText, kikiKinds.HGW))
				{
					continue;
				}
				// ANK-4315-00-00 ADD END
				
				// 機器提供サービス契約キャンセル
				template = editInEKK0341C330(param, fixedText, kikiMap); // 上りマッピング
				result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
				editRetEKK0341C330(result, param, kikiMap); // 下りマッピング
				// ステータスが単項目エラー以上であれば例外をスロー
				if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
				{
					throw new CCException(SC_ERROR_STRING, new Exception());
				}
			}
		}
		
		if(isCancelSvcKeikisuw(param, fixedText))
		{
			// サービス契約回線内訳キャンセル
			template = editInEKK0251C070(param, fixedText); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK0251C070(result, param, fixedText); // 下りマッピング
			// ステータスが単項目エラー以上であれば例外をスロー
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}

		return param;
	}

	/**
	 * 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 handle
	 * @param param
	 * @param fixedText
	 * @return パラメータマップ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public HashMap<String, Object> getInvokeCBS(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
			throws RequestParameterException
	{
		ArrayList<CAANMsg> msgList = new ArrayList<CAANMsg>();

		HashMap inMap = (HashMap)param.getData(fixedText);
		
		// マップに値が設定されていない場合は処理を行わない。
		if (inMap == null)
		{
			return null;
		}
		
		int msgCnt = msgList.size();
		CAANMsg[] templates = new CAANMsg[msgCnt];
		for (int i = 0; i < msgCnt; i++)
		{
			templates[i] = msgList.get(i);
		}

		HashMap<String, Object> paramMap = setSCInputCommonData(param, new HashMap<String, Object>());
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

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

		return paramMap;
	}

	/**
	 * SCインプット共通データ設定処理を行います。
	 * <br>
	 * @param param
	 * @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;
	}
	
	
	/**
	 * サービス契約回線内訳キャンセルの上りマッピング処理を行います。
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0251C070(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{

		CAANMsg template = new CAANMsg(EKK0251C070CBSMsg.class.getName());

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

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

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

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

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

		HashMap inMap = (HashMap)param.getData(fixedText);
		// 機能コード
		if (inMap != null)
		{
			template.set(EKK0251C070CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));
		}	
		
		// サービス契約回線内訳キャンセル.サービス契約回線内訳番号 → サービス契約回線内訳番号
		setTemplate(template, EKK0251C070CBSMsg.SVC_KEI_KAISEN_UCWK_NO, inMap, "kk0251_", EKK0251C070CBSMsg.SVC_KEI_KAISEN_UCWK_NO);	

		// サービス契約回線内訳キャンセル.申込明細番号 → 申込明細番号
		setTemplate(template, EKK0251C070CBSMsg.MSKM_DTL_NO, inMap, "kk0251_", EKK0251C070CBSMsg.MSKM_DTL_NO);	

		// サービス契約回線内訳キャンセル.サービスキャンセル理由コード → サービスキャンセル理由コード
		setTemplate(template, EKK0251C070CBSMsg.SVC_CANCEL_RSN_CD, inMap, "kk0251_", EKK0251C070CBSMsg.SVC_CANCEL_RSN_CD);
		
		// サービス契約回線内訳.最終更新年月日時分秒 → 更新年月日時分秒(更新前)
		if (inMap == null || inMap.get("kk0251_upd_dtm_bf") == null || "".equals(inMap.get("0251_upd_dtm_bf")))
		{
			template.setNull(EKK0251C070CBSMsg.UPD_DTM_BF);
		}
		else
		{
			String lastDtm = getLastUpdateDate(param, (String)inMap.get("kk0251_upd_dtm_bf"));
			template.set(EKK0251C070CBSMsg.UPD_DTM_BF, lastDtm);
		}


		return template;

	}

	/**
	 * サービス契約回線内訳キャンセルの下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0251C070(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);

		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		HashMap workDataMap = (HashMap)workMap.get(CC_WORK_AREA_NAME);
		if (workDataMap == null)
		{
			workDataMap = new HashMap();
			workMap.put(CC_WORK_AREA_NAME, workDataMap);
		}
		
		HashMap dataMap = (HashMap)param.getData(fixedText);
		
		// 世代登録年月日時分秒 ← サービス契約<eo光ネット>登録.世代登録年月日時分秒
		setDataMap(dataMap, EKK0251C070CBSMsg.GENE_ADD_DTM, template, EKK0251C070CBSMsg.GENE_ADD_DTM);

		// サービス契約回線内訳ステータス ← サービス契約<eo光ネット>登録.サービス契約回線内訳ステータス
		setDataMap(dataMap, EKK0251C070CBSMsg.SVC_KEI_KAISEN_UCWK_STAT, template, EKK0251C070CBSMsg.SVC_KEI_KAISEN_UCWK_STAT);

		// サービスキャンセル年月日 ← サービス契約<eo光ネット>登録.サービスキャンセル年月日
		setDataMap(dataMap, EKK0251C070CBSMsg.SVC_CANCEL_YMD, template, EKK0251C070CBSMsg.SVC_CANCEL_YMD);

		// サービス契約回線内訳キャンセル取消年月日 ← サービス契約<eo光ネット>登録.サービス契約回線内訳キャンセル取消年月日
		setDataMap(dataMap, EKK0251C070CBSMsg.SVKEI_KISN_UW_CNCL_CL_YMD, template, EKK0251C070CBSMsg.SVKEI_KISN_UW_CNCL_CL_YMD);

		// 登録年月日時分秒 ← サービス契約<eo光ネット>登録.登録年月日時分秒
		setDataMap(dataMap, EKK0251C070CBSMsg.ADD_DTM, template, EKK0251C070CBSMsg.ADD_DTM);

		// 登録オペレータアカウント ← サービス契約<eo光ネット>登録.登録オペレータアカウント
		setDataMap(dataMap, EKK0251C070CBSMsg.ADD_OPEACNT, template, EKK0251C070CBSMsg.ADD_OPEACNT);

		
		// 更新年月日時分秒
		if (template.isNull(EKK0251C070CBSMsg.UPD_DTM))
		{
			dataMap.put("kk0251_upd_dtm", "");
		}
		else
		{
			dataMap.put("kk0251_upd_dtm", template.getString(EKK0251C070CBSMsg.UPD_DTM));

			String lastDtm = template.getString(EKK0251C070CBSMsg.UPD_DTM);
			setLastUpdateDate(param, lastDtm);
		}		

		// 更新オペレータアカウント ← サービス契約<eo光ネット>登録.更新オペレータアカウント
		setDataMap(dataMap, EKK0251C070CBSMsg.UPD_OPEACNT, template, EKK0251C070CBSMsg.UPD_OPEACNT);

		// 無効フラグ ← サービス契約<eo光ネット>登録.無効フラグ
		setDataMap(dataMap, EKK0251C070CBSMsg.MK_FLG, template, EKK0251C070CBSMsg.MK_FLG);
		
		// エラー情報の設定
		editErrInfoEKK0251C070(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 templates
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
			throws RequestParameterException
	{
		HashMap inMap = (HashMap)param.getData(fixedText);
		
		// マップに値が設定されていない場合は処理を行わない。
		if (inMap == null)
		{
			return param;
		}
		
		return param;
	}

	/**
	 * コントロールマップエラー情報格納処理を行います。
	 * <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>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0251C070(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode, String fixedText)
			throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0341C330CBSMsg.STATUS), returnCode);

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

		// サービス契約回線内訳キャンセル.サービス契約回線内訳番号 → サービス契約回線内訳番号のエラー情報返却
		setErrInfo(inMap, EKK0251C070CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR, template, EKK0251C070CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR);

		// サービス契約回線内訳キャンセル.申込明細番号 → 申込明細番号のエラー情報返却
		setErrInfo(inMap, EKK0251C070CBSMsg.MSKM_DTL_NO_ERR, template, EKK0251C070CBSMsg.MSKM_DTL_NO_ERR);

		// サービス契約回線内訳キャンセル.サービスキャンセル理由コード → サービスキャンセル理由コードのエラー情報返却
		setErrInfo(inMap, EKK0251C070CBSMsg.SVC_CANCEL_RSN_CD_ERR, template, EKK0251C070CBSMsg.SVC_CANCEL_RSN_CD_ERR);

		// サービス契約回線内訳キャンセル.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)のエラー情報返却
		setErrInfo(inMap, EKK0251C070CBSMsg.UPD_DTM_BF_ERR, template, EKK0251C070CBSMsg.UPD_DTM_BF_ERR);


		return param;
	}
	
	/**
	 * 同一利用場所サービス契約一覧照会の上りマッピング処理を行います。
	 * <br>
	 * @param param
	 * @param fixedText
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0081B011(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0081B011CBSMsg.class.getName());

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

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

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

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

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

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

		// ＫＥＹ＿サービス契約番号
		template.setNull(EKK0081B011CBSMsg.KEY_SVC_KEI_NO);

		// 同一利用場所サービス契約一覧照会マップ.ＫＥＹ＿サービス契約回線内訳番号 → サービス契約回線内訳番号
		if (inMap == null || inMap.get("svc_kei_kaisen_ucwk_no") == null || "".equals(inMap.get("svc_kei_kaisen_ucwk_no")))
		{
			template.setNull(EKK0081B011CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO);
		}
		else
		{
			template.set(EKK0081B011CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO, (String)inMap.get("svc_kei_kaisen_ucwk_no"));
		}

		// 同一利用場所サービス契約一覧照会マップ.ＫＥＹ＿ＳＹＳＩＤ → ＳＹＳＩＤ
		if (inMap == null || inMap.get("kk0081_sysid") == null || "".equals(inMap.get("kk0081_sysid")))
		{
			template.setNull(EKK0081B011CBSMsg.KEY_SYSID);
		}
		else
		{
			template.set(EKK0081B011CBSMsg.KEY_SYSID, (String)inMap.get("kk0081_sysid"));
		}

		return template;

	}
	
	/**
	 * 機器提供サービス契約キャンセルの上りマッピング処理
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param inMap
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0341C330(IRequestParameterReadWrite param, String fixedText, HashMap inMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0341C330CBSMsg.class.getName());

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

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

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

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

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

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

		// 機能コード
		if (inData != null)
		{
			template.set(EKK0341C330CBSMsg.FUNC_CODE, inData.get(JCMConstants.FUNC_CODE_KEY));
		}

		// 機器提供サービス契約キャンセル.機器提供サービス契約番号（機器提供サービス契約） → 機器提供サービス契約番号
		if (inMap == null || inMap.get("kk0341_kktk_svc_kei_no") == null || "".equals(inMap.get("kk0341_kktk_svc_kei_no")))
		{
			template.setNull(EKK0341C330CBSMsg.KKTK_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0341C330CBSMsg.KKTK_SVC_KEI_NO, (String)inMap.get("kk0341_kktk_svc_kei_no"));
		}

		// 機器提供サービス契約キャンセル.申込明細番号（機器提供サービス契約） → 申込明細番号
		if (inMap == null || inMap.get("kk0341_mskm_dtl_no") == null || "".equals(inMap.get("kk0341_mskm_dtl_no")))
		{
			template.setNull(EKK0341C330CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			template.set(EKK0341C330CBSMsg.MSKM_DTL_NO, (String)inMap.get("kk0341_mskm_dtl_no"));
		}

		// 機器提供サービス契約キャンセル.サービスキャンセル理由コード（機器提供サービス契約） → サービスキャンセル理由コード
		if (inMap == null || inMap.get("kk0341_svc_cancel_rsn_cd") == null || "".equals(inMap.get("kk0341_svc_cancel_rsn_cd")))
		{
			template.setNull(EKK0341C330CBSMsg.SVC_CANCEL_RSN_CD);
		}
		else
		{
			template.set(EKK0341C330CBSMsg.SVC_CANCEL_RSN_CD, (String)inMap.get("kk0341_svc_cancel_rsn_cd"));
		}

		// 機器提供サービス契約キャンセル.異動区分（機器提供サービス契約） → 異動区分
		if (inMap == null || inMap.get("kk0341_ido_div") == null || "".equals(inMap.get("kk0341_ido_div")))
		{
			template.setNull(EKK0341C330CBSMsg.IDO_DIV);
		}
		else
		{
			template.set(EKK0341C330CBSMsg.IDO_DIV, (String)inMap.get("kk0341_ido_div"));
		}

		// サービス契約回線内訳.最終更新年月日時分秒 → 更新年月日時分秒(更新前)
		if (inMap == null || inMap.get("kk0341_upd_dtm_bf") == null || "".equals(inMap.get("kk0341_upd_dtm_bf")))
		{
			template.setNull(EKK0341C330CBSMsg.UPD_DTM_BF);
		}
		else
		{
			String lastDtm = getLastUpdateDate(param, (String)inMap.get("kk0341_upd_dtm_bf"));
			template.set(EKK0341C330CBSMsg.UPD_DTM_BF, lastDtm);
		}

		return template;
	}

	/**
	 * 同一利用場所サービス契約一覧照会の下りマッピング処理を行います。
	 * <br>
	 * @param msgList
	 * @param param
	 * @param fixedText
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0081B011(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);
		
		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		HashMap workDataMap = (HashMap)workMap.get(CC_WORK_AREA_NAME);
		if (workDataMap == null)
		{
			workDataMap = new HashMap();
			workMap.put(CC_WORK_AREA_NAME, workDataMap);
		}

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

		CAANMsg[] templateArray = template.getCAANMsgList(EKK0081B011CBSMsg.EKK0081B011CBSMSG1LIST);
		ArrayList dataList = (ArrayList)dataMap.get("EKK0081B011CBSMsg1List");
		
		String mskmDtlNo = null;
		String svcKeiNo = null;

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

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

				// サービス契約番号
				if (childTemplate.isNull(EKK0081B011CBSMsg1List.SVC_KEI_NO))
				{
					childMap.put("svc_kei_no", "");
				}
				else
				{
					childMap.put("svc_kei_no", childTemplate.getString(EKK0081B011CBSMsg1List.SVC_KEI_NO));
				}

				// SYSID
				if (childTemplate.isNull(EKK0081B011CBSMsg1List.SYSID))
				{
					childMap.put("sysid", "");
				}
				else
				{
					childMap.put("sysid", childTemplate.getString(EKK0081B011CBSMsg1List.SYSID));
				}

				// サービスコード
				if (childTemplate.isNull(EKK0081B011CBSMsg1List.SVC_CD))
				{
					childMap.put("svc_cd", "");
				}
				else
				{
					childMap.put("svc_cd", childTemplate.getString(EKK0081B011CBSMsg1List.SVC_CD));
				}

				// 申込明細番号
				if (childTemplate.isNull(EKK0081B011CBSMsg1List.MSKM_DTL_NO))
				{
					childMap.put("mskm_dtl_no", "");
				}
				else
				{
					childMap.put("mskm_dtl_no", childTemplate.getString(EKK0081B011CBSMsg1List.MSKM_DTL_NO));
				}

				// 料金グループコード
				if (childTemplate.isNull(EKK0081B011CBSMsg1List.PRC_GRP_CD))
				{
					childMap.put("prc_grp_cd", "");
				}
				else
				{
					childMap.put("prc_grp_cd", childTemplate.getString(EKK0081B011CBSMsg1List.PRC_GRP_CD));
				}

				// 料金コースコード
				if (childTemplate.isNull(EKK0081B011CBSMsg1List.PCRS_CD))
				{
					childMap.put("pcrs_cd", "");
				}
				else
				{
					childMap.put("pcrs_cd", childTemplate.getString(EKK0081B011CBSMsg1List.PCRS_CD));
				}

				// 料金プランコード
				if (childTemplate.isNull(EKK0081B011CBSMsg1List.PPLAN_CD))
				{
					childMap.put("pplan_cd", "");
				}
				else
				{
					childMap.put("pplan_cd", childTemplate.getString(EKK0081B011CBSMsg1List.PPLAN_CD));
				}
				
				// サービス契約ステータス
				setTmplateValue(childMap, "svc_kei_stat", childTemplate, EKK0081B011CBSMsg1List.SVC_KEI_STAT, "");

				// サービス契約回線内訳番号
				if (childTemplate.isNull(EKK0081B011CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO))
				{
					childMap.put("svc_kei_kaisen_ucwk_no", "");
				}
				else
				{
					childMap.put("svc_kei_kaisen_ucwk_no", childTemplate.getString(EKK0081B011CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO));
				}
				
				// 申込番号
				if (childTemplate.isNull(EKK0081B011CBSMsg1List.MSKM_NO))
				{
					childMap.put("mskm_no", "");
				}
				else
				{
					childMap.put("mskm_no", childTemplate.getString(EKK0081B011CBSMsg1List.MSKM_NO));
				}
				
				mskmDtlNo = childTemplate.getString(EKK0081B011CBSMsg1List.MSKM_DTL_NO);
				svcKeiNo = childTemplate.getString(EKK0081B011CBSMsg1List.SVC_KEI_NO);
				
				// 申込明細番号サービス契約番号変換マップ設定処理
				JKKKeiNewMskmWorkAreaUtil.putMskmDtlNoToSvcKeiNoMap(param, mskmDtlNo, svcKeiNo);
			}
		}

		workDataMap.put("svc_kei_list", dataList);
		svcKeiList = dataList;

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

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

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

		return param;
	}

	/**
	 * 機器提供サービス契約キャンセルの下りマッピング処理
	 * <br>
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0341C330(Map<?, ?> msgList, IRequestParameterReadWrite param, HashMap dataMap) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

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

		// 世代登録年月日時分秒
		if (template.isNull(EKK0341C330CBSMsg.GENE_ADD_DTM))
		{
			dataMap.put("kk0341_gene_add_dtm", "");
		}
		else
		{
			dataMap.put("kk0341_gene_add_dtm", template.getString(EKK0341C330CBSMsg.GENE_ADD_DTM));
		}

		// 機器提供サービス契約ステータス
		if (template.isNull(EKK0341C330CBSMsg.KKTK_SVC_KEI_STAT))
		{
			dataMap.put("kk0341_kktk_svc_kei_stat", "");
		}
		else
		{
			dataMap.put("kk0341_kktk_svc_kei_stat", template.getString(EKK0341C330CBSMsg.KKTK_SVC_KEI_STAT));
		}

		// 予約適用年月日
		if (template.isNull(EKK0341C330CBSMsg.RSV_APLY_YMD))
		{
			dataMap.put("kk0341_rsv_aply_ymd", "");
		}
		else
		{
			dataMap.put("kk0341_rsv_aply_ymd", template.getString(EKK0341C330CBSMsg.RSV_APLY_YMD));
		}

		// 予約適用コード
		if (template.isNull(EKK0341C330CBSMsg.RSV_APLY_CD))
		{
			dataMap.put("kk0341_rsv_aply_cd", "");
		}
		else
		{
			dataMap.put("kk0341_rsv_aply_cd", template.getString(EKK0341C330CBSMsg.RSV_APLY_CD));
		}

		// サービスキャンセル年月日
		if (template.isNull(EKK0341C330CBSMsg.SVC_CANCEL_YMD))
		{
			dataMap.put("kk0341_svc_cancel_ymd", "");
		}
		else
		{
			dataMap.put("kk0341_svc_cancel_ymd", template.getString(EKK0341C330CBSMsg.SVC_CANCEL_YMD));
		}

		// サービスキャンセル取消年月日
		if (template.isNull(EKK0341C330CBSMsg.SVC_CANCEL_CL_YMD))
		{
			dataMap.put("kk0341_svc_cancel_cl_ymd", "");
		}
		else
		{
			dataMap.put("kk0341_svc_cancel_cl_ymd", template.getString(EKK0341C330CBSMsg.SVC_CANCEL_CL_YMD));
		}

		// 登録年月日時分秒
		if (template.isNull(EKK0341C330CBSMsg.ADD_DTM))
		{
			dataMap.put("kk0341_add_dtm", "");
		}
		else
		{
			dataMap.put("kk0341_add_dtm", template.getString(EKK0341C330CBSMsg.ADD_DTM));
		}

		// 登録オペレータアカウント
		if (template.isNull(EKK0341C330CBSMsg.ADD_OPEACNT))
		{
			dataMap.put("kk0341_add_opeacnt", "");
		}
		else
		{
			dataMap.put("kk0341_add_opeacnt", template.getString(EKK0341C330CBSMsg.ADD_OPEACNT));
		}

		// 更新年月日時分秒
		if (template.isNull(EKK0341C330CBSMsg.UPD_DTM))
		{
			dataMap.put("kk0341_upd_dtm", "");
		}
		else
		{
			dataMap.put("kk0341_upd_dtm", template.getString(EKK0341C330CBSMsg.UPD_DTM));

			String lastDtm = template.getString(EKK0341C330CBSMsg.UPD_DTM);
			setLastUpdateDate(param, lastDtm);
		}

		// 更新オペレータアカウント
		if (template.isNull(EKK0341C330CBSMsg.UPD_OPEACNT))
		{
			dataMap.put("kk0341_upd_opeacnt", "");
		}
		else
		{
			dataMap.put("kk0341_upd_opeacnt", template.getString(EKK0341C330CBSMsg.UPD_OPEACNT));
		}

		// 無効フラグ
		if (template.isNull(EKK0341C330CBSMsg.MK_FLG))
		{
			dataMap.put("kk0341_mk_flg", "");
		}
		else
		{
			dataMap.put("kk0341_mk_flg", template.getString(EKK0341C330CBSMsg.MK_FLG));
		}

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

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

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

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

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

		// 同一利用場所サービス契約一覧照会マップ.ＫＥＹ＿サービス契約番号 → ＫＥＹ＿サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0081B011CBSMsg.KEY_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("kk0081_key_svc_kei_no_err"))
			{
				inMap.put("kk0081_key_svc_kei_no_err", template.getString(EKK0081B011CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
		// 同一利用場所サービス契約一覧照会マップ.ＫＥＹ＿サービス契約回線内訳番号 → ＫＥＹ＿サービス契約回線内訳番号 のエラー情報返却
		if (!template.isNull(EKK0081B011CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO_ERR))
		{
			if (!inMap.containsKey("kk0081_key_svc_kei_kaisen_ucwk_no_err"))
			{
				inMap.put("kk0081_key_svc_kei_kaisen_ucwk_no_err", template.getString(EKK0081B011CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO_ERR));
			}
		}
		// 同一利用場所サービス契約一覧照会マップ.ＫＥＹ＿ＳＹＳＩＤ → ＫＥＹ＿ＳＹＳＩＤ のエラー情報返却
		if (!template.isNull(EKK0081B011CBSMsg.KEY_SYSID_ERR))
		{
			if (!inMap.containsKey("kk0081_key_sysid_err"))
			{
				inMap.put("kk0081_key_sysid_err", template.getString(EKK0081B011CBSMsg.KEY_SYSID_ERR));
			}
		}

		return param;
	}


	/**
	 * 機器提供サービス契約キャンセルのエラー情報マッピング処理を行います。
	 * <br>
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrInfoEKK0341C330(IRequestParameterReadWrite iparam, CAANMsg template
			, int returnCode) throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0341C330CBSMsg.STATUS), returnCode);
		
		return param;
	}
	
	
	/**
	 * 最終更新年月日時分秒を取得します。<br>
	 * （サービス契約回線内訳に紐付くサービスの中で最大のものを返します。）
	 * @param param IRequestParameterReadWrite
	 * @param lastDtm 画面より渡された最終更新年月日時分秒
	 * @return 最大の最終更新年月日時分秒
	 * @throws RequestParameterException
	 */
	private String getLastUpdateDate(IRequestParameterReadWrite param, String lastDtm) throws RequestParameterException
	{
		String no = "";
		String lastDate = "";
		
		for(HashMap<String, Object> svcKeiMap : svcKeiList)
		{
			lastDate = JKKBpCommon.getLastDtmBySvcKeiNo(param, String.valueOf(svcKeiMap.get("svc_kei_no")), lastDtm);
			
			if(null != lastDate && no.compareTo(lastDate) < 0)
			{
				no = lastDate;
			}
		}
		
		return no;
	}
	
	/**
	 * 最終更新年月日時分秒を設定します。<br>
	 * （サービス契約回線内訳に紐付くサービスに対し設定します。）
	 * @param param IRequestParameterReadWrite
	 * @param lastDtm 最終更新年月日時分秒
	 * @throws RequestParameterException
	 */
	private void setLastUpdateDate(IRequestParameterReadWrite param, String lastDtm) throws RequestParameterException
	{
		String svcKeiNo = null;
		
		for(HashMap<String, Object> svcKeiMap : svcKeiList)
		{
			svcKeiNo = String.valueOf(svcKeiMap.get("svc_kei_no"));
			if(null == svcKeiNo)
			{
				continue;
			}
			
			JKKBpCommon.setLastDtmBySvcKeiNo(param, svcKeiNo, lastDtm);
		}
	}
	
	/**
	 * HashMapに値を設定します。<br>
	 * 　�@CAANMsgに値が設定されている場合、CAANMsgの値を設定します。
	 * 　�ACAANMsgに値が設定されていない場合、initValueを設定します。
	 * @param mp
	 * @param mpKey
	 * @param template
	 * @param tmpKey
	 * @param initValue
	 */
	private void setTmplateValue(HashMap<String, Object> mp, String mpKey, CAANMsg template, String tmpKey, String initValue)
	{
		if (template.isNull(tmpKey))
		{
			mp.put(mpKey, initValue);
		}
		else
		{
			mp.put(mpKey, template.getString(tmpKey));
		}
	}

	/**
	 * ユーザデータ情報にエラー情報を設定します。<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));
			}
		}
	}	
	
	/**
	 * パラメータから指定したキー名のリストを取得します。
	 * @param param IRequestParameterReadWrite
	 * @param fixedText ユーザ定義文字列
	 * @param listName 取得リストキー名
	 * @return listNameで指定したリスト<br>
	 *  ※リストが取得できない場合は空のリストを返却します。
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<HashMap<String, Object>> getList(IRequestParameterReadWrite param, String fixedText
			, String listName) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		ArrayList<HashMap<String, Object>> list = (ArrayList<HashMap<String, Object>>)inMap.get(listName);
		
		return null == list ? new ArrayList<HashMap<String, Object>>() : list;
	}

	/**
	 * CAANMsgに値を設定します。<br>
	 *  �@inMap内にデータが存在する場合、inMap内のデータを設定します。<br>
	 *  �A上記以外の場合、setNullを呼び出します。<br>
	 * @param template 値を設定するメッセージキャリア
	 * @param setKey 設定先メッセージキャリアのキー名
	 * @param inMap ユーザデータ情報
	 * @param prefix ユーザデータ情報より取得する場合に付加するプレフィックス 
	 * @param getKey ユーザデータ情報より取得するキー名
	 */
	private void setTemplate(CAANMsg template, String setKey, HashMap<String, Object> inMap, String prefix , String getKey)
	{
		
		if (null == inMap || null == inMap.get(prefix + getKey) || 0 == ((String)inMap.get(prefix + getKey)).length())
		{
			template.setNull(setKey);
		}
		else
		{
			template.set(setKey, (String)inMap.get(prefix + getKey));
		}
	}
	
	/**
	 * 機器をキャンセルするか判定します。
	 * @param param IRequestParameterReadWrite
	 * @param fixedText ユーザ定義文字列
	 * @param kikiKind サービス契約の種類
	 * @return true：キャンセル可能、false：キャンセル不可
	 * @throws Exception 
	 */
	private boolean isCancelKiki(IRequestParameterReadWrite param, String fixedText, kikiKinds kikiKind) throws Exception
	{
		switch(kikiKind)
		{
			case ONU:	// ONUとVDSLの場合
			case VDSL:
				// eo光ネット、eo光電話が存在する場合、キャンセル不可を返却する。
				if(isSvcKei(param, fixedText, svcKeiKinds.EOH_NT_OR_EOH_TL))
				{
					return false;
				}
				break;
				
			case VONU:
				// eo光テレビが存在する場合、キャンセル不可を返却する。
				if(isSvcKei(param, fixedText, svcKeiKinds.EOH_TV))
				{
					return false;
				}
				break;
				
			case ROUTER:
				// eo光ネットが存在する場合、キャンセル不可を返却する。
				if(isSvcKei(param, fixedText, svcKeiKinds.EOH_NT))
				{
					return false;
				}
				break;
				
			case VA:
				// eo光電話が存在する場合、キャンセル不可を返却する。
				if(isSvcKei(param, fixedText, svcKeiKinds.EOH_TL))
				{
					return false;
				}
				break;
				
			case TAKINORT:
			
				// ルーターオプションが照会あり、かつ、
				// ルーターオプションがキャンセルされていない場合
				// キャンセル不可を返却する。
				if(isKikiOp(param, fixedText, kikiOpKinds.ROUTEROPITON) && !kikiOpInfoMap.get(kikiOpMapKeys.ROUTER_OP_CANCEL))
				{
					return false;
				}
				
				// ＶＡオプションが照会あり、かつ、
				// ＶＡオプションがキャンセルされていない場合
				// キャンセル不可を返却する。
				if(isKikiOp(param, fixedText, kikiOpKinds.VAOPITON) && !kikiOpInfoMap.get(kikiOpMapKeys.VA_OP_CANCEL))
				{
					return false;
				}
			// ANK-4315-00-00 ADD START
				break;
				
			case HGW:
				
				// eo光ネット、eo光電話が存在する場合、キャンセル不可を返却する。
				if(isSvcKei(param, fixedText, svcKeiKinds.EOH_NT_OR_EOH_TL))
				{
					return false;
				}
				
				// ルーターオプションが照会あり、かつ、
				// ルーターオプションがキャンセルされていない場合
				// キャンセル不可を返却する。
				if(isKikiOp(param, fixedText, kikiOpKinds.ROUTEROPITON) && !kikiOpInfoMap.get(kikiOpMapKeys.ROUTER_OP_CANCEL))
				{
					return false;
				}
				
				// ＶＡオプションが照会あり、かつ、
				// ＶＡオプションがキャンセルされていない場合
				// キャンセル不可を返却する。
				if(isKikiOp(param, fixedText, kikiOpKinds.VAOPITON) && !kikiOpInfoMap.get(kikiOpMapKeys.VA_OP_CANCEL))
				{
					return false;
				}
			// ANK-4315-00-00 ADD END
				
				return true;
				
			default:
				return false;
			
		}
		
		return true;
	}
	
	/**
	 * 引数で指定されたサービスが存在するか判定します。
	 * <br>
	 * @param param IRequestParameterReadWrite
	 * @param fixedText ユーザ定義文字列
	 * @param svcKeiKind サービス契約の種類
	 * @return true:登録あり false:登録なし
	 * @throws RequestParameterException 
	 */
	@SuppressWarnings("unchecked")
	private boolean isSvcKei(IRequestParameterReadWrite param, String fixedText, svcKeiKinds svcKeiKind) throws RequestParameterException
	{
		String svcKeiStat = null;
		String prcGrpCd = null;
		HashMap preMap = (HashMap)param.getData(fixedText);
		String mskmNo = String.valueOf(preMap.get("mskm_no"));
		
		for (HashMap<String, Object> svcKeiMap : svcKeiList)
		{
			// 自申込は対象外
			if(mskmNo.equals(String.valueOf(svcKeiMap.get("mskm_no"))))
			{
				continue;
			}
			
			svcKeiStat = String.valueOf(svcKeiMap.get("svc_kei_stat"));
			
			// サービス契約ステータスが解約済の場合、次の要素を処理する。
			if(JKKStrConst.CD00037_DSL_ZM.equals(svcKeiStat))
			{
				continue;
			}
			
			prcGrpCd = String.valueOf(svcKeiMap.get("prc_grp_cd"));
			
			// 指定されたサービスが登録されているか判定する。
			switch(svcKeiKind)
			{
				case EOH_NT_OR_EOH_TL:
					if(JKKCtrlyUtil.getNetSvcJdg(prcGrpCd) || JKKCtrlyUtil.getTelSvcJdg(prcGrpCd))
					{
						return true;
					}
					break;
					
				case EOH_TV:
					if(JKKCtrlyUtil.getTvSvcJdg(prcGrpCd))
					{
						return true;
					}
					break;
					
				case EOH_NT:
					if(JKKCtrlyUtil.getNetSvcJdg(prcGrpCd))
					{
						return true;
					}
					break;
					
				case EOH_TL:
					if(JKKCtrlyUtil.getTelSvcJdg(prcGrpCd))
					{
						return true;
					}
					break;
					
				default:
					break;
				
			}
		}

		return false;
	}
	
	/**
	 * サービス契約回線内訳が更新可能か判定します。
	 * @param param IRequestParameterReadWrite
	 * @param fixedText ユーザ定義文字列
	 * @return true：キャンｓル可能、false：キャンセル不可
	 * @throws RequestParameterException 
	 */
	@SuppressWarnings("unchecked")
	private boolean isCancelSvcKeikisuw(IRequestParameterReadWrite param, String fixedText) throws RequestParameterException
	{
		// サービス契約リスト内にサービス契約が存在しない場合、キャンセル不可を返却する。
		if(null == svcKeiList || 0 == svcKeiList.size())
		{
			return false;
		}
		
		HashMap preMap = (HashMap)param.getData(fixedText);
		String mskmNo = String.valueOf(preMap.get("mskm_no"));
		String svcKeiStat = null;
		boolean isCancel = false;
		
		for(HashMap<String, Object> svcKeiMap : svcKeiList)
		{
			svcKeiStat = String.valueOf(svcKeiMap.get("svc_kei_stat"));
			
			// サービス契約ステータスが解約済の場合、次の要素を処理する。
			if(JKKStrConst.CD00037_DSL_ZM.equals(svcKeiStat))
			{
				continue;
			}
			// 他申込の場合、キャンセル不可を返却する。
			else if(!mskmNo.equals(String.valueOf(svcKeiMap.get("mskm_no"))))
			{
				return false;
			}
			// サービス契約ステータスが受付済以外の場合、キャンセル不可を返却する。
			else if(!JKKStrConst.CD00037_UK_ZM.equals(svcKeiStat))
			{
				return false;
			}
			// サービス契約ステータスが受付済の場合、キャンセルフラグを更新可能とする。
			else
			{
				isCancel = true;
			}
		}
		
		// サービス契約回線内訳ステータスが受付済以外の場合、キャンセル不可を返却する。
		if(!JKKStrConst.CD00054_010.equals(preMap.get("kk0251_svc_kei_kaisen_ucwk_stat")))
		{
			return false;
		}
		
		// すべて受付済の場合、true
		// すべて解約済の場合、false（サービスは１つあるはずなので返却されることはない）
		return isCancel;
	}
	
	/**
	 * 機器オプションサービス契約キャンセルの上りマッピング処理
	 * @param param
	 * @param fixedText
	 * @param inMap
	 * @return メッセージキャリア
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK2811C110(IRequestParameterReadWrite param, String fixedText, HashMap inMap) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK2811C110CBSMsg.class.getName());

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

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

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

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

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

		HashMap inData = (HashMap)param.getData(fixedText);
		
		String prefix = "kk2811_";

		// 機能コード
		if (inData != null)
		{
			template.set(EKK2811C110CBSMsg.FUNC_CODE, inData.get(JCMConstants.FUNC_CODE_KEY));
		}
		
		// 機器オプションサービス契約キャンセル.機器オプションサービス契約番号 → 機器オプションサービス契約番号
		setTemplate(template, EKK2811C110CBSMsg.KKOP_SVC_KEI_NO, inMap, prefix, EKK2811C110CBSMsg.KKOP_SVC_KEI_NO);

		// 機器オプションサービス契約キャンセル.申込明細番号 → 申込明細番号
		setTemplate(template, EKK2811C110CBSMsg.MSKM_DTL_NO, inMap, prefix, EKK2811C110CBSMsg.MSKM_DTL_NO);

		// 機器オプションサービス契約キャンセル.サービスキャンセル理由コード → サービスキャンセル理由コード
		setTemplate(template, EKK2811C110CBSMsg.SVC_CANCEL_RSN_CD, inMap, prefix, EKK2811C110CBSMsg.SVC_CANCEL_RSN_CD);

		// 機器オプションサービス契約キャンセル.異動区分 → 異動区分
		setTemplate(template, EKK2811C110CBSMsg.IDO_DIV, inMap, prefix, EKK2811C110CBSMsg.IDO_DIV);

		// 機器オプションサービス契約キャンセル.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)
		String svcKeiNo = (String)inMap.get("kk2811_svc_kei_no");
		
		template.set(EKK2811C110CBSMsg.UPD_DTM_BF, JKKBpCommon.getLastDtmBySvcKeiNo(param, svcKeiNo, (String)inMap.get("kk2811_upd_dtm_bf")));

		
		return template;
	}
	
	/**
	 * 機器オプションサービス契約キャンセルの下りマッピング処理
	 * @param msgList
	 * @param param
	 * @param dataMap
	 * @return リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK2811C110(Map<?, ?> msgList, IRequestParameterReadWrite param, HashMap dataMap) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		String prefix = "kk2811_";
		
		// 世代登録年月日時分秒 ← 機器オプションサービス契約キャンセル.世代登録年月日時分秒	
		setDataMap(dataMap, prefix, EKK2811C110CBSMsg.GENE_ADD_DTM, template, EKK2811C110CBSMsg.GENE_ADD_DTM);

		// 機器オプションサービス契約ステータス ← 機器オプションサービス契約キャンセル.機器オプションサービス契約ステータス	
		setDataMap(dataMap, prefix, EKK2811C110CBSMsg.KKOP_SVC_KEI_STAT, template, EKK2811C110CBSMsg.KKOP_SVC_KEI_STAT);

		// 予約適用年月日 ← 機器オプションサービス契約キャンセル.予約適用年月日	
		setDataMap(dataMap, prefix, EKK2811C110CBSMsg.RSV_APLY_YMD, template, EKK2811C110CBSMsg.RSV_APLY_YMD);

		// 予約適用コード ← 機器オプションサービス契約キャンセル.予約適用コード	
		setDataMap(dataMap, prefix, EKK2811C110CBSMsg.RSV_APLY_CD, template, EKK2811C110CBSMsg.RSV_APLY_CD);

		// サービスキャンセル年月日 ← 機器オプションサービス契約キャンセル.サービスキャンセル年月日	
		setDataMap(dataMap, prefix, EKK2811C110CBSMsg.SVC_CANCEL_YMD, template, EKK2811C110CBSMsg.SVC_CANCEL_YMD);

		// サービスキャンセル取消年月日 ← 機器オプションサービス契約キャンセル.サービスキャンセル取消年月日	
		setDataMap(dataMap, prefix, EKK2811C110CBSMsg.SVC_CANCEL_CL_YMD, template, EKK2811C110CBSMsg.SVC_CANCEL_CL_YMD);

		// 登録年月日時分秒 ← 機器オプションサービス契約キャンセル.登録年月日時分秒	
		setDataMap(dataMap, prefix, EKK2811C110CBSMsg.ADD_DTM, template, EKK2811C110CBSMsg.ADD_DTM);

		// 登録オペレータアカウント ← 機器オプションサービス契約キャンセル.登録オペレータアカウント	
		setDataMap(dataMap, prefix, EKK2811C110CBSMsg.ADD_OPEACNT, template, EKK2811C110CBSMsg.ADD_OPEACNT);

		// 更新年月日時分秒 ← 機器オプションサービス契約キャンセル.更新年月日時分秒	
		String svcKeiNo = (String)dataMap.get("kk2811_svc_kei_no");
		String lastDtm = template.getString(EKK2811C110CBSMsg.UPD_DTM);
		
		JKKBpCommon.setLastDtmBySvcKeiNo(param, svcKeiNo, lastDtm);
		dataMap.put(prefix + "upd_dtm", lastDtm);
		
		// 更新オペレータアカウント ← 機器オプションサービス契約キャンセル.更新オペレータアカウント	
		setDataMap(dataMap, prefix, EKK2811C110CBSMsg.UPD_OPEACNT, template, EKK2811C110CBSMsg.UPD_OPEACNT);

		// 無効フラグ ← 機器オプションサービス契約キャンセル.無効フラグ	
		setDataMap(dataMap, prefix, EKK2811C110CBSMsg.MK_FLG, template, EKK2811C110CBSMsg.MK_FLG);

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

		// エラー情報のマップを取得
		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>
	 * 　�@CAANMsgにデータが存在する場合、CAANMsgのデータを設定します。<br>
	 * 　�A上記以外の場合、空文字を設定します。<br>
	 * @param dataMap 値を設定するユーザデータ情報
	 * @param prefix ユーザデータ情報に設定する際に付加するプレフィックス
	 * @param setKey ユーザデータ情報のキー名
	 * @param template メッセージキャリア
	 * @param getKey メッセージキャリアのキー名
	 */
	private void setDataMap(HashMap<String, Object> dataMap, String prefix, String setKey, CAANMsg template, String getKey)
	{
		if (template.isNull(getKey))
		{
			dataMap.put(prefix + setKey, "");
		}
		else
		{
			dataMap.put(prefix + setKey, template.getString(getKey));
		}
	}
	
	/**
	 * ユーザデータ情報に値を設定します。<br>
	 * 　※CAANMsg内のデータがNullの場合、空文字を設定します。<br>
	 * @param dataMap ユーザデータ情報
	 * @param setKey ユーザデータ情報に設定するキー名
	 * @param template メッセージキャリア
	 * @param getKey メッセージキャリアより取得するキー名
	 */
	private void setDataMap(HashMap<String, Object> dataMap, String setKey, CAANMsg template, String getKey)
	{
		if (template.isNull(getKey))
		{
			dataMap.put(setKey, "");
		}
		else
		{
			dataMap.put(setKey, template.getString(getKey));
		}
	}
	
	/**
	 * 機器オプションサービス契約キャンセルのエラー情報マッピング処理を行います。
	 * @param iparam
	 * @param template
	 * @param returnCode
	 * @param inMap
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK2811C110(IRequestParameterReadWrite iparam, CAANMsg template, int returnCode
			, HashMap inMap) throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK2811C110CBSMsg.STATUS), returnCode);

		String prefix = "kk2811_";
		
		// 機器オプションサービス契約キャンセル.機器オプションサービス契約番号 → 機器オプションサービス契約番号のエラー情報返却
		setErrInfo(inMap, prefix + EKK2811C110CBSMsg.KKOP_SVC_KEI_NO_ERR, template, EKK2811C110CBSMsg.KKOP_SVC_KEI_NO_ERR);

		// 機器オプションサービス契約キャンセル.申込明細番号 → 申込明細番号のエラー情報返却
		setErrInfo(inMap, prefix + EKK2811C110CBSMsg.MSKM_DTL_NO_ERR, template, EKK2811C110CBSMsg.MSKM_DTL_NO_ERR);

		// 機器オプションサービス契約キャンセル.サービスキャンセル理由コード → サービスキャンセル理由コードのエラー情報返却
		setErrInfo(inMap, prefix + EKK2811C110CBSMsg.SVC_CANCEL_RSN_CD_ERR, template, EKK2811C110CBSMsg.SVC_CANCEL_RSN_CD_ERR);

		// 機器オプションサービス契約キャンセル.異動区分 → 異動区分のエラー情報返却
		setErrInfo(inMap, prefix + EKK2811C110CBSMsg.IDO_DIV_ERR, template, EKK2811C110CBSMsg.IDO_DIV_ERR);

		// 機器オプションサービス契約キャンセル.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前)のエラー情報返却
		setErrInfo(inMap, prefix + EKK2811C110CBSMsg.UPD_DTM_BF_ERR, template, EKK2811C110CBSMsg.UPD_DTM_BF_ERR);

		return param;
	}
	
	/**
	 * 機器オプションの種類で指定した機器オプションが存在するかを判定します。
	 * <br>
	 * @param param IRequestParameterReadWrite
	 * @param fixedText ユーザ定義文字列
	 * @param kikiOpKind 機器オプションの種類
	 * @return true:登録あり false:登録なし
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private boolean isKikiOp(IRequestParameterReadWrite param, String fixedText, kikiOpKinds kikiOpKind) throws Exception
	{
		ArrayList<HashMap<String, Object>> dataList = getList(param, fixedText, KKTK_OP_CANCEL_LIST);
		if (null == dataList)
		{
			return false;
		}

		String kkopSvcCd = null;
		switch(kikiOpKind)
		{
			case VAOPITON:
				kkopSvcCd = JKKStrConst.KKOP_SVC_CD_TEL_ADAPT;
				break;
				
			case ROUTEROPITON:
				kkopSvcCd = JKKStrConst.KKOP_SVC_CD_ROUTER;
				break;
				
			default:
				return false;
			
		}
		
		for(HashMap dataMap : dataList)
		{
			if(kkopSvcCd.equals(String.valueOf(dataMap.get("kk2811_kkop_svc_cd"))))
			{
				return true;
			}
		}
		
		return false;
	}
	
	/**
	 * 機器オプション情報マップを初期化します。
	 */
	private void initKikiOpMap()
	{
		kikiOpInfoMap = new HashMap<kikiOpMapKeys, Boolean>();
		for(kikiOpMapKeys key : kikiOpMapKeys.values())
		{
			kikiOpInfoMap.put(key, false);
		}
	}
	
	/**
	 * 引数で指定された機器オプションをキャンセルする必要があるかを判定します。
	 * <br>
	 * @param param IRequestParameterReadWrite
	 * @param fixedText
	 * @param kikiOpKind 機器オプションの種類
	 * @return true：キャンセル可能、false：キャンセル不可
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private boolean isCancelKikiOp(IRequestParameterReadWrite param, String fixedText, kikiOpKinds kikiOpKind) throws Exception
	{
		HashMap inMap = (HashMap)param.getData(fixedText);
		
		// 料金グループコード
		String prcGrpCd = null;
		String svcKeiStat = null;
		
		switch(kikiOpKind)
		{
			case ROUTEROPITON: //ルーターオプションの場合

				// 同一回線上にネットが存在しない場合、キャンセル可を返却する。
				if(!isSvcSameksn(svcKeiKinds.EOH_NT))
				{
					return true;
				}
				// 電話を破棄の場合、キャンセル可を返却する。
				else if("true".equals(String.valueOf(inMap.get("net_cancel_flg"))))
				{
					return true;
				}
				// 電話を破棄の場合、かつ
				// 同一回線上のeo光ネットのステータスが照査済以上解約済未満の場合
				else if("true".equals(String.valueOf(inMap.get("tel_cancel_flg"))))
				{
					for(HashMap<String, Object> mp : svcKeiList)
					{
						svcKeiStat = String.valueOf(mp.get("svc_kei_stat"));
						prcGrpCd = String.valueOf(mp.get("prc_grp_cd"));

						//  サービス契約ステータスが照査済以上かつ、解約済未満の場合
						if(JKKCtrlyUtil.getNetSvcJdg(prcGrpCd) && 
								JKKStrConst.CD00037_SHOSA_ZUMI.compareTo(svcKeiStat) <= 0 && 0 < JKKStrConst.CD00037_DSL_ZM.compareTo(svcKeiStat))
						{
							return true;
						}
					}
				}

				break;
				
			case VAOPITON: // ＶＡオプション
				
				// 同一回線上に電話が存在しない場合、キャンセル可を返却する。
				if(!isSvcSameksn(svcKeiKinds.EOH_TL))
				{
					return true;
				}
				// 電話を破棄の場合、キャンセル可を返却する。
				else if("true".equals(String.valueOf(inMap.get("tel_cancel_flg"))))
				{
					return true;
				}
				// ネットを破棄の場合、かつ
				// 同一回線上のeo光電話のステータスが照査済以上解約済未満の場合
				else if("true".equals(String.valueOf(inMap.get("net_cancel_flg"))))
				{
					for(HashMap<String, Object> mp : svcKeiList)
					{
						svcKeiStat = String.valueOf(mp.get("svc_kei_stat"));
						prcGrpCd = String.valueOf(mp.get("prc_grp_cd"));

						// 受付済 < サービス契約ステータス < 解約済の場合
						if(JKKCtrlyUtil.getTelSvcJdg(prcGrpCd) && 
								JKKStrConst.CD00037_UK_ZM.compareTo(svcKeiStat) < 0 && 0 < JKKStrConst.CD00037_DSL_ZM.compareTo(svcKeiStat))
						{
							return true;
						}
					}
				}

				break;
				
			default:
				return false;
			
		}
		
		return false;
	}
	
	/**
	 * 同一回線上に処理対象のサービスが存在するか判定します
	 * @param svcKeiKind
	 * @return true:存在 false:存在しない
	 * @throws RequestParameterException
	 */
	private boolean isSvcSameksn(svcKeiKinds svcKeiKind) throws RequestParameterException
	{
		String prcGrpCd = null;
		
		for(HashMap<String, Object> mp : svcKeiList)
		{
			prcGrpCd = String.valueOf(mp.get("prc_grp_cd"));
			
			switch(svcKeiKind)
			{
				case EOH_TL:   // 電話の場合
					
					if(JKKCtrlyUtil.getTelSvcJdg(prcGrpCd))
					{
						return true;
					}
					
					break;
					
				case EOH_NT:   // ネットの場合
					if(JKKCtrlyUtil.getNetSvcJdg(prcGrpCd))
					{
						return true;
					}
					
					break;
					
				default:
					break;
				
			}
			
		}
		return false;
	}

}