/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：JKKAplySeiopsvcKeiCC
*   ソースファイル名：JKKAplySeiopsvcKeiCC.java
*   作成者          ：富士通
*   日付            ：2012年05月28日
*＜機能概要＞
*   請求オプションサービス契約適用コモンコンポーネント部品
*＜修正履歴＞
*   バージョン  修正日       修正者      修正内容
*   v3.00.00    2012/05/28   FJ）多田    新規作成
*   v11.00.00   2014/10/01   FJ）中山    【ANK-2248-00-00】ＮＨＫ団体一括の受付拡充
*   v11.01.00   2014/11/28   FJ）川島    【OM-2014-0003751】
*   v11.02.00   2014/12/15   FJ）川島    【OM-2014-0003937】
**********************************************************************/
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.EKK0081B526CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B526CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081B529CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B529CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0441B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0441B002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0441C210CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0441D010CBSMsg;


/**
 * 請求オプションサービス契約適用コモンコンポーネント部品.
 * <br>
 * @author 富士通
 */
public class JKKAplySeiopsvcKeiCC 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_APLY_SEIOPSVC_KEI     = "JKKAplySeiopsvcKeiCC";
	/** 作業マップ名 */
	private static final String CC_WORK_AREA_NET_NAME              = "JKKAddSvcKeiNetCCWork";
	/** 作業マップ名 */
	private static final String CC_WORK_AREA_MOBILE_NM             = "JKKAddSvcKeiMobileExeCCWork";
	/** 作業マップ名 */
	private static final String CC_WORK_AREA_ADSL_NM             = "JKKAddSvcKeiAdslExeCCWork";

	/** サービス契約用プレフィックス */
	private static final String PREFIX_SVC_KEI                     = "KK0081_";
	/** 同一請求契約サービス契約一覧照会用プレフィックス */
	private static final String PREFIX_SAMESEIOPSVC_KEI            = "KK008102_";
	/** 請求オプションサービス契約（一覧照会）用プレフィックス */
	private static final String PREFIX_SEIOPSVC_KEI_ICRN           = "kk044101_";
	/** 請求オプションサービス契約（登録）用プレフィックス */
	private static final String PREFIX_SEIOPSVC_KEI_ADD            = "kk044102_";
	/** 請求オプションサービス契約（キャンセル）用プレフィックス */
	private static final String PREFIX_SEIOPSVC_KEI_CNCL           = "kk044103_";
	/** エラー用 */
	private static final String SC_ERROR_STRING                    = "サービスコンポーネントエラー";

	/** 請求書発行要否：否 */
	private static final String SEIKYUS_HAKKO_YH_H                 = "0";
	/** 請求書発行要否：要 */
	private static final String SEIKYUS_HAKKO_YH_YO                = "1";

	/** 請求オプションサービス契約ステータス：受付済 */
	private static final String SEIOPSVC_KEI_STAT_UK_ZUMI          = "010";
	/** 請求オプションサービス契約ステータス：解約済 */
	private static final int SEIOPSVC_KEI_STAT_DSL_ZUMI           = 910;

	/** サービス契約ステータス：停止中 */
	private static final int SVC_KEI_STAT_STP_CHU                 = 220;
	/** サービス契約ステータス：サービス提供中 */
	private static final String SVC_KEI_STAT_SVCTK_CHU            = "100";
	/** サービス契約ステータス：キャンセル済 */
	private static final String SVC_KEI_STAT_CANCEL               = "920";

	/**
	 * 請求オプションサービス契約適用処理を行います。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return リクエストパラメータ
	 * @throws Exception Exception
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite aplySeiopsvcKei(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<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

		// CCに値が設定されていない場合は処理を行わない。
		if (inMap == null)
		{
			return param;
		}

		// 請求オプションサービス契約一覧照会（複合検索）
		template = editInEKK0441B002(param, fixedText, PREFIX_SEIOPSVC_KEI_ICRN); // 上りマッピング
		result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
		editRetEKK0441B002(result, param, fixedText, PREFIX_SEIOPSVC_KEI_ICRN); // 下りマッピング
		if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
		{ // ステータスが単項目エラー以上であれば例外をスロー
			throw new CCException(SC_ERROR_STRING, new Exception());
		}

		// インターネットサービス一覧照会（請求契約番号）
		template = editInEKK0081B526(param, fixedText, PREFIX_SVC_KEI); // 上りマッピング
		result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
		editRetEKK0081B526(result, param, fixedText, PREFIX_SVC_KEI); // 下りマッピング
		if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
		{ // ステータスが単項目エラー以上であれば例外をスロー
			throw new CCException(SC_ERROR_STRING, new Exception());
		}

		// 請求書発行要否
		String seikyusHakkoYh = (String)inMap.get("seikyus_hakko_yh");

		if (seikyusHakkoYh == null)
		{
			seikyusHakkoYh = "";
		}

		// 異動区分
		String idoDiv = (String)inMap.get(PREFIX_SEIOPSVC_KEI_ADD + "ido_div");
		if (idoDiv == null)
		{
			idoDiv = "";
		}
		// 支払方法引継利用
		String paywayKeizokuUse = (String)inMap.get("payway_keizoku_use");
		if (paywayKeizokuUse == null)
		{
			paywayKeizokuUse = "";
		}
		// 請求オプションのサービス追加用フラグ
		boolean seiopSvcAddFlg = false;
		boolean isSvcKeiStat = false;
		if (JKKStrConst.CD00576_00002.equals(idoDiv) && JKKStrConst.PAYWAY_KEIZOKU_USE.equals(paywayKeizokuUse))
		{
			// サービス追加 かつ 支払方法継続の場合
			seiopSvcAddFlg = true;
			
			// 同一請求契約サービス契約一覧照会
			template = editInEKK0081B529(param, fixedText, PREFIX_SAMESEIOPSVC_KEI); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK0081B529(result, param, fixedText, PREFIX_SAMESEIOPSVC_KEI); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
			
			// 同一請求契約サービス契約の存在確認
			isSvcKeiStat = isSameSeisvcSvcKei(param, inMap);
		}
		// 登録済みのサービス契約番号が設定されるリスト
		ArrayList newSvcKeiNoList = new ArrayList();
		// 新規登録されたサービス契約番号を取得
		getSvcKeiNo(param, newSvcKeiNoList);

		// 請求オプションサービス契約の存在確認
		boolean isSeiopsvcKei = isSeiopsvcKei(param, inMap);

		// サービス契約の存在確認
		boolean isSvcKei = isSvcKei(param, inMap, seiopSvcAddFlg, newSvcKeiNoList);

		// 同一請求先にインターネットサービス契約が存在するか
		boolean isInSvcKei = isSvcKei(param, inMap, false, newSvcKeiNoList);
		
		// サービス追加 かつ 支払方法継続の場合で請求オプションサービス契約の作成有無
		boolean svcAddSeiopsFlg = (
				(newSvcKeiNoList != null && newSvcKeiNoList.size() > 0) && 
				!isSvcKei && 
				SEIKYUS_HAKKO_YH_YO.equals(seikyusHakkoYh));

		// 請求オプションサービス契約登録
		boolean isAddSeiopsvcKei =
			!isSeiopsvcKei && ((!seiopSvcAddFlg && isSvcKei && SEIKYUS_HAKKO_YH_YO.equals(seikyusHakkoYh))
			|| (seiopSvcAddFlg && !isSvcKeiStat && svcAddSeiopsFlg));

		if (isAddSeiopsvcKei)
		{
			// 請求オプションサービス契約登録
			template = editInEKK0441D010(param, fixedText, PREFIX_SEIOPSVC_KEI_ADD); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK0441D010(result, param, fixedText, PREFIX_SEIOPSVC_KEI_ADD); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}

		// 請求書発行要否判定が設定されていて請求オプションサービス契約が存在し、請求契約に紐づく請求オプションサービスが存在しない場合
		// または請求書発行要否が否で請求オプション契約が受付済みの場合 
		boolean isSeiopsvcKeiCncl =
			isDelSeiopsvcKei(param, inMap) && (SEIKYUS_HAKKO_YH_H.equals(seikyusHakkoYh) || !isInSvcKei);

		// 請求オプションサービス契約キャンセル
		if (isSeiopsvcKeiCncl)
		{
			// 請求オプションサービス契約キャンセル
			template = editInEKK0441C210(param, fixedText, PREFIX_SEIOPSVC_KEI_CNCL); // 上りマッピング
			result = scCall.run(putParamMap(paramMap, template), handle); // SC呼び出し
			editRetEKK0441C210(result, param, fixedText, PREFIX_SEIOPSVC_KEI_CNCL); // 下りマッピング
			if (getReturnCode(param) >= JPCModelConstant.SINGLEDATA_ERR)
			{ // ステータスが単項目エラー以上であれば例外をスロー
				throw new CCException(SC_ERROR_STRING, new Exception());
			}
		}

		return param;
	}

	/**
	 * 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 inMapChk = (HashMap)(param.getData(fixedText));
		if (inMapChk == null)
		{
			return null;
		}

		// 請求オプションサービス契約一覧照会（複合検索）
		msgList.add(editInEKK0441B002(param, fixedText, PREFIX_SEIOPSVC_KEI_ICRN));

		// 請求オプションサービス契約一覧照会（複合検索）
		msgList.add(editInEKK0081B526(param, fixedText, PREFIX_SVC_KEI));
		
		// 同一請求契約サービス契約一覧照会
		msgList.add(editInEKK0081B529(param, fixedText, PREFIX_SAMESEIOPSVC_KEI));

		// 登録、キャンセルは上記サービスインターフェイス
		// またはワークエリアの結果から実行を判定するため
		// チェックでは動かさない。

		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;
	}

	/**
	 * エラー情報のマッピング処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param templates CAANMsg
	 * @param returnCode リターンコード
	 * @param fixedText ユーザー固定文字列
	 * @return リクエストパラメータ
	 * @throws Throwable 
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
			throws Throwable
	{
		// ユーザデータ情報
		HashMap inMapChk = (HashMap)(param.getData(fixedText));
		if (inMapChk == null)
		{
			return param;
		}

		int index = 0;

		//  請求オプションサービス契約一覧照会（複合検索）
		editErrInfoEKK0441B002(param, templates[index], (Integer)returnCode, fixedText, PREFIX_SEIOPSVC_KEI_ICRN);
		index += 1;

		// インターネットサービス一覧照会（請求契約番号）
		editErrInfoEKK0081B526(param, templates[index], (Integer)returnCode, fixedText, PREFIX_SVC_KEI);
		index += 1;

		// 請求書発行要否
		String seikyusHakkoYh = (String)inMapChk.get("seikyus_hakko_yh");

		if (seikyusHakkoYh == null)
		{
			seikyusHakkoYh = "";
		}

		// 異動区分
		String idoDiv = (String)inMapChk.get(PREFIX_SEIOPSVC_KEI_ADD + "ido_div");
		if (idoDiv == null)
		{
			idoDiv = "";
		}
		// 支払方法引継利用
		String paywayKeizokuUse = (String)inMapChk.get("payway_keizoku_use");
		if (paywayKeizokuUse == null)
		{
			paywayKeizokuUse = "";
		}
		// 請求オプションのサービス追加用フラグ
		boolean seiopSvcAddFlg = false;
		boolean isSvcKeiStat = false;
		if (JKKStrConst.CD00576_00002.equals(idoDiv) && JKKStrConst.PAYWAY_KEIZOKU_USE.equals(paywayKeizokuUse))
		{
			// サービス追加 かつ 支払方法継続の場合
			seiopSvcAddFlg = true;
			
			// 同一請求契約サービス契約一覧照会
			editErrInfoEKK0081B529(param, templates[index], (Integer)returnCode, fixedText, PREFIX_SAMESEIOPSVC_KEI);
			
			// 同一請求契約サービス契約の存在確認
			isSvcKeiStat = isSameSeisvcSvcKei(param, inMapChk);
		}
		// 登録済みのサービス契約番号が設定されるリスト
		ArrayList newSvcKeiNoList = new ArrayList();
		// 新規登録されたサービス契約番号を取得
		getSvcKeiNo(param, newSvcKeiNoList);

		// 請求オプションサービス契約の存在確認
		boolean isSeiopsvcKei = isSeiopsvcKei(param, inMapChk);

		// サービス契約の存在確認
		boolean isSvcKei = isSvcKei(param, inMapChk, seiopSvcAddFlg, newSvcKeiNoList);

		// サービス追加 かつ 支払方法継続の場合で請求オプションサービス契約の作成有無
		boolean svcAddSeiopsFlg = (
				(newSvcKeiNoList != null && newSvcKeiNoList.size() > 0) && 
				!isSvcKei && 
				SEIKYUS_HAKKO_YH_YO.equals(seikyusHakkoYh));
		
		// 請求オプションサービス契約登録
		boolean isAddSeiopsvcKei =
			(!seiopSvcAddFlg && !isSeiopsvcKei && isSvcKei && SEIKYUS_HAKKO_YH_YO.equals(seikyusHakkoYh))
			|| (seiopSvcAddFlg && !isSvcKeiStat && svcAddSeiopsFlg);
		if (isAddSeiopsvcKei)
		{
			// 請求オプションサービス契約登録
			editErrInfoEKK0441D010(param, templates[index], (Integer)returnCode, fixedText, PREFIX_SEIOPSVC_KEI_ADD);
			index += 1;
		}

		boolean isSeiopsvcKeiCncl =
			(SEIKYUS_HAKKO_YH_YO.equals(seikyusHakkoYh) || SEIKYUS_HAKKO_YH_H.equals(seikyusHakkoYh)) && isSeiopsvcKei && !isSvcKei;

		// 請求オプションサービス契約キャンセル
		if (isSeiopsvcKeiCncl)
		{
			// 請求オプションサービス契約キャンセル
			editErrInfoEKK0441C210(param, templates[index], (Integer)returnCode, fixedText, PREFIX_SEIOPSVC_KEI_CNCL);
			index += 1;
		}
		return param;
	}

	/**
	 * 請求オプションサービス契約一覧照会（複合検索）の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param      リクエストパラメータ
	 * @param fixedText  サービスメッセージ
	 * @param prefix     プレフィックス
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0441B002(
			IRequestParameterReadWrite param,
			String fixedText,
			String prefix) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0441B002CBSMsg.class.getName());

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

		// 機能コード（デフォルト：１）
		template.set(EKK0441B002CBSMsg.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<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

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

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

		/* 作業項目情報 */
		HashMap seiopsvcWorkMap = (HashMap)workMap.get(CC_WORK_AREA_APLY_SEIOPSVC_KEI);
		if (seiopsvcWorkMap == null)
		{
			seiopsvcWorkMap = new HashMap();
			workMap.put(CC_WORK_AREA_APLY_SEIOPSVC_KEI, seiopsvcWorkMap);
		}

		// ＫＥＹ＿請求契約番号
		if (seiopsvcWorkMap == null || seiopsvcWorkMap.get("seiky_kei_no") == null || "".equals(seiopsvcWorkMap.get("seiky_kei_no")))
		{
			if (inMap == null || inMap.get(prefix + "key_seiky_kei_no") == null || "".equals(inMap.get(prefix + "key_seiky_kei_no")))
			{
				template.setNull(EKK0441B002CBSMsg.KEY_SEIKY_KEI_NO);
			}
			else
			{
				template.set(EKK0441B002CBSMsg.KEY_SEIKY_KEI_NO, (String)inMap.get(prefix + "key_seiky_kei_no"));
			}
		}
		else
		{
			template.set(EKK0441B002CBSMsg.KEY_SEIKY_KEI_NO, (String)seiopsvcWorkMap.get("seiky_kei_no"));
		}

		// ＫＥＹ＿申込明細番号
		setTemplate(param, template, EKK0441B002CBSMsg.KEY_MSKM_DTL_NO, inMap, prefix,  "key_mskm_dtl_no");

		// ＫＥＹ＿サービス契約番号
		setTemplate(param, template, EKK0441B002CBSMsg.KEY_SVC_KEI_NO, inMap, prefix,  "key_svc_kei_no");

		// ＫＥＹ＿予約適用年月日
		setTemplate(param, template, EKK0441B002CBSMsg.KEY_RSV_APLY_YMD, inMap, prefix,  "key_rsv_aply_ymd");

		// ＫＥＹ＿異動区分
		setTemplate(param, template, EKK0441B002CBSMsg.KEY_IDO_DIV, inMap, prefix,  "key_ido_div");

		return template;
	}

	/**
	 * 請求オプションサービス契約一覧照会（複合検索）の下りマッピング処理
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param prefix プレフィックス
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0441B002(
			Map<?, ?> msgList,
			IRequestParameterReadWrite param,
			String fixedText,
			String prefix) 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);

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

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

		/* 作業項目情報 */
		HashMap seiopsvcWorkMap = (HashMap)workMap.get(CC_WORK_AREA_APLY_SEIOPSVC_KEI);
		if (seiopsvcWorkMap == null)
		{
			seiopsvcWorkMap = new HashMap();
			workMap.put(CC_WORK_AREA_APLY_SEIOPSVC_KEI, seiopsvcWorkMap);
		}

		CAANMsg[] templateArray = template.getCAANMsgList(EKK0441B002CBSMsg.EKK0441B002CBSMSG1LIST);
		ArrayList msg1List = (ArrayList)inMap.get(EKK0441B002CBSMsg.EKK0441B002CBSMSG1LIST);

		if (msg1List == null)
		{
			msg1List = new ArrayList();
			inMap.put(EKK0441B002CBSMsg.EKK0441B002CBSMSG1LIST, msg1List);
		}

		if (templateArray != null)
		{
			int j = 0;
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];
				
				// 請求オプションサービスコードが"請求書発行手数料"のみマッピングする
				if (!JKKStrConst.CD00131_SKSHKTSR.equals(childTemplate.getString(EKK0441B002CBSMsg1List.SEIOPSVC_CD)))
				{
					continue;
				}
				
				if (j >= msg1List.size())
				{
					msg1List.add(new HashMap());
				}
				HashMap childMap = (HashMap)msg1List.get(j);
				j++;

				// 請求オプションサービス契約番号
				setOutData(childMap, prefix + "seiopsvc_kei_no", childTemplate, EKK0441B002CBSMsg1List.SEIOPSVC_KEI_NO);

				// 世代登録年月日時分秒
				setOutData(childMap, prefix + "gene_add_dtm", childTemplate, EKK0441B002CBSMsg1List.GENE_ADD_DTM);

				// 請求オプションサービス契約ステータス
				setOutData(childMap, prefix + "seiopsvc_kei_stat", childTemplate, EKK0441B002CBSMsg1List.SEIOPSVC_KEI_STAT);

				// 請求契約番号
				setOutData(childMap, prefix + "seiky_kei_no", childTemplate, EKK0441B002CBSMsg1List.SEIKY_KEI_NO);

				// 請求オプションサービスコード
				setOutData(childMap, prefix + "seiopsvc_cd", childTemplate, EKK0441B002CBSMsg1List.SEIOPSVC_CD);

				// 料金コースコード
				setOutData(childMap, prefix + "pcrs_cd", childTemplate, EKK0441B002CBSMsg1List.PCRS_CD);

				// 料金プランコード
				setOutData(childMap, prefix + "pplan_cd", childTemplate, EKK0441B002CBSMsg1List.PPLAN_CD);

				// 申込明細番号
				setOutData(childMap, prefix + "mskm_dtl_no", childTemplate, EKK0441B002CBSMsg1List.MSKM_DTL_NO);
				seiopsvcWorkMap.put("work_kk0441_mskm_dtl_no", childTemplate.getObject(EKK0441B002CBSMsg1List.MSKM_DTL_NO));

				// サービス契約番号
				setOutData(childMap, prefix + "svc_kei_no", childTemplate, EKK0441B002CBSMsg1List.SVC_KEI_NO);

				// 予約適用年月日
				setOutData(childMap, prefix + "rsv_aply_ymd", childTemplate, EKK0441B002CBSMsg1List.RSV_APLY_YMD);

				// サービス開始年月日
				setOutData(childMap, prefix + "svc_sta_ymd", childTemplate, EKK0441B002CBSMsg1List.SVC_STA_YMD);

				// サービス課金開始年月日
				setOutData(childMap, prefix + "svc_chrg_staymd", childTemplate, EKK0441B002CBSMsg1List.SVC_CHRG_STAYMD);

				// サービス終了年月日
				setOutData(childMap, prefix + "svc_endymd", childTemplate, EKK0441B002CBSMsg1List.SVC_ENDYMD);

				// サービス課金終了年月日
				setOutData(childMap, prefix + "svc_chrg_endymd", childTemplate, EKK0441B002CBSMsg1List.SVC_CHRG_ENDYMD);

				// サービス解約年月日
				setOutData(childMap, prefix + "svc_dsl_ymd", childTemplate, EKK0441B002CBSMsg1List.SVC_DSL_YMD);

				// 異動区分
				setOutData(childMap, prefix + "ido_div", childTemplate, EKK0441B002CBSMsg1List.IDO_DIV);

				// 更新年月日時分秒
				setOutData(childMap, prefix + "upd_dtm", childTemplate, EKK0441B002CBSMsg1List.UPD_DTM);

				// 存在する請求オプションサービス契約は請求番号と1対1の関係であるため存在するデータをワークエリアに退避
				if (childTemplate.getString(EKK0441B002CBSMsg1List.SEIOPSVC_KEI_STAT) != null
						&& !(SEIOPSVC_KEI_STAT_DSL_ZUMI <= Integer.parseInt(childTemplate.getString(EKK0441B002CBSMsg1List.SEIOPSVC_KEI_STAT))))
				{
					seiopsvcWorkMap.put("seiopsvc_kei_no", childTemplate.getObject(EKK0441B002CBSMsg1List.SEIOPSVC_KEI_NO));
					seiopsvcWorkMap.put("seiopsvc_kei_stat", childTemplate.getObject(EKK0441B002CBSMsg1List.SEIOPSVC_KEI_STAT));
					seiopsvcWorkMap.put(prefix + "upd_dtm", childTemplate.getObject(EKK0441B002CBSMsg1List.UPD_DTM));
				}
			}
		}

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

		// エラー情報のマップを取得
		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 prefix プレフィックス
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0441B002(
			IRequestParameterReadWrite iparam,
			CAANMsg template,
			int returnCode,
			String fixedText,
			String prefix) throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0441B002CBSMsg.STATUS), returnCode);

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

		// ＫＥＹ＿請求契約番号 のエラー情報返却
		if (!template.isNull(EKK0441B002CBSMsg.KEY_SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_svc_kei_no_err"))
			{
				inMap.put(prefix + "key_seiky_kei_no_err", template.getString(EKK0441B002CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}

		// ＫＥＹ＿申込明細番号 のエラー情報返却
		if (!template.isNull(EKK0441B002CBSMsg.KEY_MSKM_DTL_NO_ERR))
		{
			if (!inMap.containsKey("key_mskm_dtl_no_err"))
			{
				inMap.put(prefix + "key_mskm_dtl_no_err", template.getString(EKK0441B002CBSMsg.KEY_MSKM_DTL_NO_ERR));
			}
		}

		// ＫＥＹ＿サービス契約番号
		if (!template.isNull(EKK0441B002CBSMsg.KEY_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_svc_kei_no_err"))
			{
				inMap.put(prefix + "key_svc_kei_no_err", template.getString(EKK0441B002CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}

		// ＫＥＹ＿予約適用年月日
		if (!template.isNull(EKK0441B002CBSMsg.KEY_RSV_APLY_YMD_ERR))
		{
			if (!inMap.containsKey("key_rsv_aply_ymd_err"))
			{
				inMap.put(prefix + "key_rsv_aply_ymd_err", template.getString(EKK0441B002CBSMsg.KEY_RSV_APLY_YMD_ERR));
			}
		}

		// ＫＥＹ＿異動区分
		if (!template.isNull(EKK0441B002CBSMsg.KEY_IDO_DIV_ERR))
		{
			if (!inMap.containsKey("key_ido_div_err"))
			{
				inMap.put(prefix + "key_ido_div_err", template.getString(EKK0441B002CBSMsg.KEY_IDO_DIV_ERR));
			}
		}
		return param;
	}

	/**
	 * インターネットサービス一覧照会（請求契約番号）の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param      リクエストパラメータ
	 * @param fixedText  サービスメッセージ
	 * @param prefix     プレフィックス
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0081B526(
			IRequestParameterReadWrite param,
			String fixedText,
			String prefix) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0081B526CBSMsg.class.getName());

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

		// 機能コード（デフォルト：１）
		template.set(EKK0081B526CBSMsg.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<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

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

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

		/* 作業項目情報 */
		HashMap seiopsvcWorkMap = (HashMap)workMap.get(CC_WORK_AREA_APLY_SEIOPSVC_KEI);
		if (seiopsvcWorkMap == null)
		{
			seiopsvcWorkMap = new HashMap();
			workMap.put(CC_WORK_AREA_APLY_SEIOPSVC_KEI, seiopsvcWorkMap);
		}

		// ＫＥＹ＿請求契約番号
		if (seiopsvcWorkMap == null || seiopsvcWorkMap.get("seiky_kei_no") == null || "".equals(seiopsvcWorkMap.get("seiky_kei_no")))
		{
			if (inMap == null || inMap.get(prefix + "key_seiky_kei_no") == null || "".equals(inMap.get(prefix + "key_seiky_kei_no")))
			{
				template.setNull(EKK0081B526CBSMsg.KEY_SEIKY_KEI_NO);
			}
			else
			{
				template.set(EKK0081B526CBSMsg.KEY_SEIKY_KEI_NO, (String)inMap.get(prefix + "key_seiky_kei_no"));
			}
		}
		else
		{
			template.set(EKK0081B526CBSMsg.KEY_SEIKY_KEI_NO, (String)seiopsvcWorkMap.get("seiky_kei_no"));
		}

		return template;
	}

	/**
	 * インターネットサービス一覧照会（請求契約番号）の下りマッピング処理
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param prefix プレフィックス
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0081B526(
			Map<?, ?> msgList,
			IRequestParameterReadWrite param,
			String fixedText,
			String prefix) 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);

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

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

		/* 作業項目情報 */
		HashMap seiopsvcWorkMap = (HashMap)workMap.get(CC_WORK_AREA_APLY_SEIOPSVC_KEI);
		if (seiopsvcWorkMap == null)
		{
			seiopsvcWorkMap = new HashMap();
			workMap.put(CC_WORK_AREA_APLY_SEIOPSVC_KEI, seiopsvcWorkMap);
		}

		CAANMsg[] templateArray = template.getCAANMsgList(EKK0081B526CBSMsg.EKK0081B526CBSMSG1LIST);
		ArrayList msg1List = (ArrayList)inMap.get(EKK0081B526CBSMsg.EKK0081B526CBSMSG1LIST);

		if (msg1List == null)
		{
			msg1List = new ArrayList();
			inMap.put(EKK0081B526CBSMsg.EKK0081B526CBSMSG1LIST, msg1List);
		}

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

				// サービス契約番号
				setOutData(childMap, prefix + "seiopsvc_kei_no", childTemplate, EKK0081B526CBSMsg1List.SVC_KEI_NO);

				// サービス契約ステータス
				setOutData(childMap, prefix + "svc_kei_stat", childTemplate, EKK0081B526CBSMsg1List.SVC_KEI_STAT);
			}
		}

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

		// エラー情報のマップを取得
		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 prefix プレフィックス
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0081B526(
			IRequestParameterReadWrite iparam,
			CAANMsg template,
			int returnCode,
			String fixedText,
			String prefix) throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0081B526CBSMsg.STATUS), returnCode);

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

		// ＫＥＹ＿請求契約番号 のエラー情報返却
		if (!template.isNull(EKK0081B526CBSMsg.KEY_SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_seiky_kei_no_err"))
			{
				inMap.put(prefix + "key_seiky_kei_no_err", template.getString(EKK0081B526CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}

		return param;
	}

	/**
	 * 同一請求契約サービス契約一覧照会の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param      リクエストパラメータ
	 * @param fixedText  サービスメッセージ
	 * @param prefix     プレフィックス
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0081B529(
			IRequestParameterReadWrite param,
			String fixedText,
			String prefix) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0081B529CBSMsg.class.getName());

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

		// 機能コード（デフォルト：１）
		template.set(EKK0081B529CBSMsg.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<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

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

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

		/* 作業項目情報 */
		HashMap seiopsvcWorkMap = (HashMap)workMap.get(CC_WORK_AREA_APLY_SEIOPSVC_KEI);
		if (seiopsvcWorkMap == null)
		{
			seiopsvcWorkMap = new HashMap();
			workMap.put(CC_WORK_AREA_APLY_SEIOPSVC_KEI, seiopsvcWorkMap);
		}

		// ＫＥＹ＿請求契約番号
		if (seiopsvcWorkMap == null || seiopsvcWorkMap.get("seiky_kei_no") == null || "".equals(seiopsvcWorkMap.get("seiky_kei_no")))
		{
			if (inMap == null || inMap.get(prefix + "key_seiky_kei_no") == null || "".equals(inMap.get(prefix + "key_seiky_kei_no")))
			{
				template.setNull(EKK0081B529CBSMsg.KEY_SEIKY_KEI_NO);
			}
			else
			{
				template.set(EKK0081B529CBSMsg.KEY_SEIKY_KEI_NO, (String)inMap.get(prefix + "key_seiky_kei_no"));
			}
		}
		else
		{
			template.set(EKK0081B529CBSMsg.KEY_SEIKY_KEI_NO, (String)seiopsvcWorkMap.get("seiky_kei_no"));
		}

		return template;
	}
	
	/**
	 * 同一請求契約サービス契約一覧照会の下りマッピング処理
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param prefix プレフィックス
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0081B529(
			Map<?, ?> msgList,
			IRequestParameterReadWrite param,
			String fixedText,
			String prefix) 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);

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

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

		/* 作業項目情報 */
		HashMap seiopsvcWorkMap = (HashMap)workMap.get(CC_WORK_AREA_APLY_SEIOPSVC_KEI);
		if (seiopsvcWorkMap == null)
		{
			seiopsvcWorkMap = new HashMap();
			workMap.put(CC_WORK_AREA_APLY_SEIOPSVC_KEI, seiopsvcWorkMap);
		}

		CAANMsg[] templateArray = template.getCAANMsgList(EKK0081B529CBSMsg.EKK0081B529CBSMSG1LIST);
		ArrayList msg1List = (ArrayList)inMap.get(EKK0081B529CBSMsg.EKK0081B529CBSMSG1LIST);

		if (msg1List == null)
		{
			msg1List = new ArrayList();
			inMap.put(EKK0081B529CBSMsg.EKK0081B529CBSMSG1LIST, msg1List);
		}

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

				// サービス契約番号
				setOutData(childMap, prefix + "svc_kei_no", childTemplate, EKK0081B529CBSMsg1List.SVC_KEI_NO);

				// サービス契約ステータス
				setOutData(childMap, prefix + "svc_kei_stat", childTemplate, EKK0081B529CBSMsg1List.SVC_KEI_STAT);
			}
		}

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

		// エラー情報のマップを取得
		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 prefix プレフィックス
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0081B529(
			IRequestParameterReadWrite iparam,
			CAANMsg template,
			int returnCode,
			String fixedText,
			String prefix) throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0081B529CBSMsg.STATUS), returnCode);

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

		// ＫＥＹ＿請求契約番号 のエラー情報返却
		if (!template.isNull(EKK0081B529CBSMsg.KEY_SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_seiky_kei_no_err"))
			{
				inMap.put(prefix + "key_seiky_kei_no_err", template.getString(EKK0081B529CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}

		return param;
	}

	/**
	 * 請求オプションサービス契約登録の上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param      リクエストパラメータ
	 * @param fixedText  サービスメッセージ
	 * @param prefix     プレフィックス
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0441D010(
			IRequestParameterReadWrite param,
			String fixedText,
			String prefix) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0441D010CBSMsg.class.getName());

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

		// 機能コード（デフォルト：１）
		template.set(EKK0441D010CBSMsg.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<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// 機能コード
		template.set(EKK0441D010CBSMsg.FUNC_CODE, inMap.get(JCMConstants.FUNC_CODE_KEY));

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

		/* 作業項目情報 */
		HashMap seiopsvcWorkMap = (HashMap)workMap.get(CC_WORK_AREA_APLY_SEIOPSVC_KEI);
		if (seiopsvcWorkMap == null)
		{
			seiopsvcWorkMap = new HashMap();
			workMap.put(CC_WORK_AREA_APLY_SEIOPSVC_KEI, seiopsvcWorkMap);
		}

		// 請求契約番号
		if (seiopsvcWorkMap == null || seiopsvcWorkMap.get("seiky_kei_no") == null || "".equals(seiopsvcWorkMap.get("seiky_kei_no")))
		{
			if (inMap == null || inMap.get(prefix + "seiky_kei_no") == null || "".equals(inMap.get(prefix + "seiky_kei_no")))
			{
				template.setNull(EKK0441D010CBSMsg.SEIKY_KEI_NO);
			}
			else
			{
				template.set(EKK0441D010CBSMsg.SEIKY_KEI_NO, (String)inMap.get(prefix + "seiky_kei_no"));
			}
		}
		else
		{
			
			template.set(EKK0441D010CBSMsg.SEIKY_KEI_NO, (String)seiopsvcWorkMap.get("seiky_kei_no"));
		}

		// SYSID
		if (seiopsvcWorkMap == null || seiopsvcWorkMap.get("sysid") == null || "".equals(seiopsvcWorkMap.get("sysid")))
		{
			if (inMap == null || inMap.get(prefix + "sysid") == null || "".equals(inMap.get(prefix + "sysid")))
			{
				template.setNull(EKK0441D010CBSMsg.SYSID);
			}
			else
			{
				template.set(EKK0441D010CBSMsg.SYSID, (String)inMap.get(prefix + "sysid"));
			}
		}
		else
		{
			template.set(EKK0441D010CBSMsg.SYSID, (String)seiopsvcWorkMap.get("sysid"));
		}

		// 請求オプションサービスコード
		setTemplate(param, template, EKK0441D010CBSMsg.SEIOPSVC_CD, inMap, prefix, "seiopsvc_cd");

		// 料金コースコード
		setTemplate(param, template, EKK0441D010CBSMsg.PCRS_CD, inMap, prefix, "pcrs_cd");

		// 料金プランコード
		setTemplate(param, template, EKK0441D010CBSMsg.PPLAN_CD, inMap, prefix, "pplan_cd");

		// 申込明細番号
		template.set(EKK0441D010CBSMsg.MSKM_DTL_NO, JKKBpCommon.getMskmDtlNo(param));

		// サービス契約番号
		setTemplate(param, template, EKK0441D010CBSMsg.SVC_KEI_NO, inMap, prefix, "svc_kei_no");

		// 試用加入年月日
		setTemplate(param, template, EKK0441D010CBSMsg.FTRIAL_KANYU_YMD, inMap, prefix, "ftrial_kanyu_ymd");

		// 試用期間終了年月日
		setTemplate(param, template, EKK0441D010CBSMsg.FTRIAL_PRD_ENDYMD, inMap, prefix, "ftrial_prd_endymd");

		// 本加入年月日
		setTemplate(param, template, EKK0441D010CBSMsg.HONKANYU_YMD, inMap, prefix, "honkanyu_ymd");

		// 本加入移行期限年月日
		setTemplate(param, template, EKK0441D010CBSMsg.HONKANYU_IKO_KIGEN_YMD, inMap, prefix, "honkanyu_iko_kigen_ymd");

		// サービス利用開始希望年月日
		setTemplate(param, template, EKK0441D010CBSMsg.SVC_USE_STA_KIBO_YMD, inMap, prefix, "svc_use_sta_kibo_ymd");

		// 予約適用開始希望年月日
		setTemplate(param, template, EKK0441D010CBSMsg.RSV_TSTA_KIBO_YMD, inMap, prefix, "rsv_tsta_kibo_ymd");

		// 違約金発生コード
		setTemplate(param, template, EKK0441D010CBSMsg.PNLTY_HASSEI_CD, inMap, prefix, "pnlty_hassei_cd");

		// 異動区分
		setTemplate(param, template, EKK0441D010CBSMsg.IDO_DIV, inMap, prefix, "ido_div");

		// 料金項目コード
		setTemplate(param, template, EKK0441D010CBSMsg.PRC_KMK_CD, inMap, prefix, "prc_kmk_cd");

		/**
		 *  更新年月日時分秒
		 *  請求契約の更新年月日時分秒を渡す必要があるが、他チームの共通部品を呼び出した時、
		 *  請求契約の更新年月日が更新される場合がある。
		 *  しかし、戻り値に更新年月日時分秒が存在しないため、設定することができない。
		 *  (課金先を登録した際に更新されるがサービス契約の登録時など副次的に課金先が登録された場合は更新されない。)
		 *  上記の理由により、常にNULLを設定する。
		 *  尚、更新年月日時分秒(更新前)の必須チェックは「Check.properties」で実行しないようにしている。
		 */
		template.setNull(EKK0441D010CBSMsg.UPD_DTM_BF);

		return template;
	}

	/**
	 * 請求オプションサービス契約登録の下りマッピング処理
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param prefix プレフィックス
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0441D010(
			Map<?, ?> msgList,
			IRequestParameterReadWrite param,
			String fixedText,
			String prefix) 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);

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

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

		/* 作業項目情報 */
		HashMap seiopsvcWorkMap = (HashMap)workMap.get(CC_WORK_AREA_APLY_SEIOPSVC_KEI);
		if (seiopsvcWorkMap == null)
		{
			seiopsvcWorkMap = new HashMap();
			workMap.put(CC_WORK_AREA_APLY_SEIOPSVC_KEI, seiopsvcWorkMap);
		}

		// 請求オプションサービス契約番号
		setOutData(inMap, prefix + "seiopsvc_kei_no", template, EKK0441D010CBSMsg.SEIOPSVC_KEI_NO);

		// 世代登録年月日時分秒
		setOutData(inMap, prefix + "gene_add_dtm", template, EKK0441D010CBSMsg.GENE_ADD_DTM);

		// 請求オプションサービス契約ステータス
		setOutData(inMap, prefix + "seiopsvc_kei_stat", template, EKK0441D010CBSMsg.SEIOPSVC_KEI_STAT);

		// 予約適用年月日
		setOutData(inMap, prefix + "rsv_aply_ymd", template, EKK0441D010CBSMsg.RSV_APLY_YMD);

		// 予約適用コード
		setOutData(inMap, prefix + "rsv_aply_cd", template, EKK0441D010CBSMsg.RSV_APLY_CD);

		// 登録年月日時分秒
		setOutData(inMap, prefix + "add_dtm", template, EKK0441D010CBSMsg.ADD_DTM);

		// 登録オペレータアカウント
		setOutData(inMap, prefix + "add_opeacnt", template, EKK0441D010CBSMsg.ADD_OPEACNT);

		// 更新年月日時分秒
		setOutData(inMap, prefix + "upd_dtm", template, EKK0441D010CBSMsg.UPD_DTM);

		// 更新オペレータアカウント
		setOutData(inMap, prefix + "upd_opeacnt", template, EKK0441D010CBSMsg.UPD_OPEACNT);

		// 無効フラグ
		setOutData(inMap, prefix + "mk_flg", template, EKK0441D010CBSMsg.MK_FLG);

		// 課金先番号
		setOutData(inMap, prefix + "kakins_no", template, EKK0441D010CBSMsg.KAKINS_NO);

		// 課金先適用開始年月日
		setOutData(inMap, prefix + "kakins_tstaymd", template, EKK0441D010CBSMsg.KAKINS_TSTAYMD);

		// 課金先適用終了年月日
		setOutData(inMap, prefix + "kakins_tendymd", template, EKK0441D010CBSMsg.KAKINS_TENDYMD);

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

		// エラー情報のマップを取得
		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 prefix プレフィックス
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0441D010(
			IRequestParameterReadWrite iparam,
			CAANMsg template,
			int returnCode,
			String fixedText,
			String prefix) throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0441D010CBSMsg.STATUS), returnCode);

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

		// 請求契約番号 のエラー情報返却
		setErrInfo(inMap, prefix + "seiky_kei_no_err", template, EKK0441D010CBSMsg.SEIKY_KEI_NO_ERR);

		// SYSID のエラー情報返却
		setErrInfo(inMap, prefix + "sysid_err", template, EKK0441D010CBSMsg.SYSID_ERR);

		// 請求オプションサービスコード のエラー情報返却
		setErrInfo(inMap, prefix + "seiopsvc_cd_err", template, EKK0441D010CBSMsg.SEIOPSVC_CD_ERR);

		// 料金コースコード のエラー情報返却
		setErrInfo(inMap, prefix + "pcrs_cd_err", template, EKK0441D010CBSMsg.PCRS_CD_ERR);

		// 料金プランコード のエラー情報返却
		setErrInfo(inMap, prefix + "pplan_cd_err", template, EKK0441D010CBSMsg.PPLAN_CD_ERR);

		// 申込明細番号 のエラー情報返却
		setErrInfo(inMap, prefix + "mskm_dtl_no_err", template, EKK0441D010CBSMsg.MSKM_DTL_NO_ERR);

		// サービス契約番号 のエラー情報返却
		setErrInfo(inMap, prefix + "svc_kei_no_err", template, EKK0441D010CBSMsg.SVC_KEI_NO_ERR);

		// 試用加入年月日 のエラー情報返却
		setErrInfo(inMap, prefix + "ftrial_kanyu_ymd_err", template, EKK0441D010CBSMsg.FTRIAL_KANYU_YMD_ERR);

		// 試用期間終了年月日 のエラー情報返却
		setErrInfo(inMap, prefix + "ftrial_prd_endymd_err", template, EKK0441D010CBSMsg.FTRIAL_PRD_ENDYMD_ERR);

		// 本加入年月日 のエラー情報返却
		setErrInfo(inMap, prefix + "honkanyu_ymd_err", template, EKK0441D010CBSMsg.HONKANYU_YMD_ERR);

		// 本加入移行期限年月日 のエラー情報返却
		setErrInfo(inMap, prefix + "honkanyu_iko_kigen_ymd_err", template, EKK0441D010CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR);

		// サービス利用開始希望年月日 のエラー情報返却
		setErrInfo(inMap, prefix + "svc_use_sta_kibo_ymd_err", template, EKK0441D010CBSMsg.SVC_USE_STA_KIBO_YMD_ERR);

		// 予約適用開始希望年月日 のエラー情報返却
		setErrInfo(inMap, prefix + "rsv_tsta_kibo_ymd_err", template, EKK0441D010CBSMsg.RSV_TSTA_KIBO_YMD_ERR);

		// 違約金発生コード のエラー情報返却
		setErrInfo(inMap, prefix + "pnlty_hassei_cd_err", template, EKK0441D010CBSMsg.PNLTY_HASSEI_CD_ERR);

		// 異動区分 のエラー情報返却
		setErrInfo(inMap, prefix + "ido_div_err", template, EKK0441D010CBSMsg.IDO_DIV_ERR);

		// 料金項目コード のエラー情報返却
		setErrInfo(inMap, prefix + "prc_kmk_cd_err", template, EKK0441D010CBSMsg.PRC_KMK_CD_ERR);

		// 更新年月日時分秒(更新前) のエラー情報返却
		setErrInfo(inMap, prefix + "upd_dtm_bf_err", template, EKK0441D010CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}

	/**
	 * 請求オプションサービス契約キャンセルの上りマッピング処理を行います。
	 * 
	 * <br>
	 * @param param      リクエストパラメータ
	 * @param fixedText  サービスメッセージ
	 * @param prefix     プレフィックス
	 * @return CAANMsg
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg editInEKK0441C210(
			IRequestParameterReadWrite param,
			String fixedText,
			String prefix) throws RequestParameterException
	{
		CAANMsg template = new CAANMsg(EKK0441C210CBSMsg.class.getName());

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

		// 機能コード（デフォルト：１）
		template.set(EKK0441C210CBSMsg.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<String, Object> inMap = (HashMap<String, Object>)param.getData(fixedText);

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

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

		/* 作業項目情報 */
		HashMap seiopsvcWorkMap = (HashMap)workMap.get(CC_WORK_AREA_APLY_SEIOPSVC_KEI);
		if (seiopsvcWorkMap == null)
		{
			seiopsvcWorkMap = new HashMap();
			workMap.put(CC_WORK_AREA_APLY_SEIOPSVC_KEI, seiopsvcWorkMap);
		}

		// 請求オプションサービス契約番号
		if (seiopsvcWorkMap == null || seiopsvcWorkMap.get("seiopsvc_kei_no") == null || "".equals(seiopsvcWorkMap.get("seiopsvc_kei_no")))
		{
			if (inMap == null || inMap.get(prefix + "seiopsvc_kei_no") == null || "".equals(inMap.get(prefix + "seiopsvc_kei_no")))
			{
				template.setNull(EKK0441C210CBSMsg.SEIOPSVC_KEI_NO);
			}
			else
			{
				template.set(EKK0441C210CBSMsg.SEIOPSVC_KEI_NO, (String)inMap.get(prefix + "seiopsvc_kei_no"));
			}
		}
		else
		{
			template.set(EKK0441C210CBSMsg.SEIOPSVC_KEI_NO, (String)seiopsvcWorkMap.get("seiopsvc_kei_no"));
		}

		// 申込明細番号
		if (seiopsvcWorkMap == null || seiopsvcWorkMap.get("seiopsvc_kei_no") == null || "".equals(seiopsvcWorkMap.get("seiopsvc_kei_no")))
		{
			setTemplate(param, template, EKK0441C210CBSMsg.MSKM_DTL_NO, inMap, prefix, "mskm_dtl_no");
		}
		else
		{
			template.set(EKK0441C210CBSMsg.MSKM_DTL_NO, (String)seiopsvcWorkMap.get("work_kk0441_mskm_dtl_no"));
		}

		// サービスキャンセル理由コード
		setTemplate(param, template, EKK0441C210CBSMsg.SVC_CANCEL_RSN_CD, inMap, prefix, "svc_cancel_rsn_cd");

		// 異動区分
		setTemplate(param, template, EKK0441C210CBSMsg.IDO_DIV, inMap, prefix, "ido_div");

		/**
		 *  更新年月日時分秒
		 *  請求契約の更新年月日時分秒を渡す必要があるが、他チームの共通部品を呼び出した時、
		 *  請求契約の更新年月日が更新される場合がある。
		 *  しかし、戻り値に更新年月日時分秒が存在しないため、設定することができない。
		 *  (課金先を登録した際に更新されるがサービス契約の登録時など副次的に課金先が登録された場合は更新されない。)
		 *  上記の理由により、常にNULLを設定する。
		 *  尚、更新年月日時分秒(更新前)の必須チェックは「Check.properties」で実行しないようにしている。
		 */
		template.setNull(EKK0441C210CBSMsg.UPD_DTM_BF);

		return template;
	}

	/**
	 * 請求オプションサービス契約キャンセルの下りマッピング処理
	 * <br>
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザー固定文字列
	 * @param prefix プレフィックス
	 * @return リクエストパラメータ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editRetEKK0441C210(
			Map<?, ?> msgList,
			IRequestParameterReadWrite param,
			String fixedText,
			String prefix) 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);

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

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

		/* 作業項目情報 */
		HashMap seiopsvcWorkMap = (HashMap)workMap.get(CC_WORK_AREA_APLY_SEIOPSVC_KEI);
		if (seiopsvcWorkMap == null)
		{
			seiopsvcWorkMap = new HashMap();
			workMap.put(CC_WORK_AREA_APLY_SEIOPSVC_KEI, seiopsvcWorkMap);
		}

		// 世代登録年月日時分秒
		setOutData(inMap, prefix + "gene_add_dtm", template, EKK0441C210CBSMsg.GENE_ADD_DTM);

		// 請求オプションサービス契約ステータス
		setOutData(inMap, prefix + "seiopsvc_kei_stat", template, EKK0441C210CBSMsg.SEIOPSVC_KEI_STAT);

		// 予約適用年月日
		setOutData(inMap, prefix + "rsv_aply_ymd", template, EKK0441C210CBSMsg.RSV_APLY_YMD);

		// 予約適用コード
		setOutData(inMap, prefix + "rsv_aply_cd", template, EKK0441C210CBSMsg.RSV_APLY_CD);

		// サービスキャンセル年月日
		setOutData(inMap, prefix + "svc_cancel_ymd", template, EKK0441C210CBSMsg.SVC_CANCEL_YMD);

		// サービスキャンセル取消年月日
		setOutData(inMap, prefix + "svc_cancel_cl_ymd", template, EKK0441C210CBSMsg.SVC_CANCEL_CL_YMD);

		// 登録年月日時分秒
		setOutData(inMap, prefix + "add_dtm", template, EKK0441C210CBSMsg.ADD_DTM);

		// 登録オペレータアカウント
		setOutData(inMap, prefix + "add_opeacnt", template, EKK0441C210CBSMsg.ADD_OPEACNT);

		// 更新年月日時分秒
		setOutData(inMap, prefix + "upd_dtm", template, EKK0441C210CBSMsg.UPD_DTM);

		// 更新オペレータアカウント
		setOutData(inMap, prefix + "upd_opeacnt", template, EKK0441C210CBSMsg.UPD_OPEACNT);

		// 無効フラグ
		setOutData(inMap, prefix + "mk_flg", template, EKK0441C210CBSMsg.MK_FLG);

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

		// エラー情報のマップを取得
		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 prefix プレフィックス
	 * @return リクエストパラメータ
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrInfoEKK0441C210(
			IRequestParameterReadWrite iparam,
			CAANMsg template,
			int returnCode,
			String fixedText,
			String prefix) throws RequestParameterException
	{
		IRequestParameterReadWrite param = setControlMapErrInfo(iparam, template.getInt(EKK0441C210CBSMsg.STATUS), returnCode);

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

		// 請求オプションサービス契約番号 のエラー情報返却
		setErrInfo(inMap, prefix + "seiopsvc_kei_no_err", template, EKK0441C210CBSMsg.SEIOPSVC_KEI_NO_ERR);

		// 申込明細番号 のエラー情報返却
		setErrInfo(inMap, prefix + "mskm_dtl_no_err", template, EKK0441C210CBSMsg.MSKM_DTL_NO_ERR);

		// サービスキャンセル理由コード のエラー情報返却
		setErrInfo(inMap, prefix + "svc_cancel_rsn_cd_err", template, EKK0441C210CBSMsg.SVC_CANCEL_RSN_CD_ERR);

		// 異動区分 のエラー情報返却
		setErrInfo(inMap, prefix + "ido_div_err", template, EKK0441C210CBSMsg.IDO_DIV_ERR);

		// 更新年月日時分秒(更新前) のエラー情報返却
		setErrInfo(inMap, prefix + "upd_dtm_bf_err", template, EKK0441C210CBSMsg.UPD_DTM_BF_ERR);

		return param;
	}

	/**
	 * 同一請求契約サービス契約の存在確認<br>
	 * @param  param IRequestParameterReadWrite
	 * @param  inMap ユーザデータ情報
	 * @return boolean true：存在する、false：存在しない
	 * @throws RequestParameterException 
	 */
	@SuppressWarnings("unchecked")
	private boolean isSameSeisvcSvcKei(
			IRequestParameterReadWrite param,
			HashMap<String, Object> inMap) throws RequestParameterException
	{
		boolean result = false;

		// 同一請求契約サービス契約一覧照会明細の取得
		ArrayList msg1List = (ArrayList)inMap.get(EKK0081B529CBSMsg.EKK0081B529CBSMSG1LIST);

		if (msg1List == null)
		{
			return result;
		}

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

			// サービス契約ステータス
			String svcKeiStat = (String)childMap.get(PREFIX_SAMESEIOPSVC_KEI + "svc_kei_stat");

			// キャンセル済は対象外
			if(SVC_KEI_STAT_CANCEL.equals(svcKeiStat))
			{
				continue;
			}

			// サービス提供中以降は存在する。（解約済みも含む）
			if (SVC_KEI_STAT_SVCTK_CHU.compareTo(svcKeiStat) <= 0)
			{
				result = true;
				break;
			}
		}

		return result;
	}

	/**
	 * 請求オプションサービス契約の存在確認<br>
	 * @param  param IRequestParameterReadWrite
	 * @param  inMap ユーザデータ情報
	 * @return boolean true：存在する、false：存在しない
	 * @throws RequestParameterException 
	 */
	@SuppressWarnings("unchecked")
	private boolean isSeiopsvcKei(
			IRequestParameterReadWrite param,
			HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}

		/* 作業項目情報 */
		HashMap seiopsvcWorkMap = (HashMap)workMap.get(CC_WORK_AREA_APLY_SEIOPSVC_KEI);
		if (seiopsvcWorkMap == null)
		{
			seiopsvcWorkMap = new HashMap();
			workMap.put(CC_WORK_AREA_APLY_SEIOPSVC_KEI, seiopsvcWorkMap);
		}

		if (seiopsvcWorkMap.get("seiopsvc_kei_stat") == null || "".equals("seiopsvc_kei_stat"))
		{
			return false;
		}

		if (SEIOPSVC_KEI_STAT_DSL_ZUMI <= Integer.parseInt(seiopsvcWorkMap.get("seiopsvc_kei_stat").toString()))
		{
			return false;
		}
		return true;
	}

	/**
	 * サービス契約（ネットサービス）の存在確認<br>
	 * @param  param リクエストパラメータ
	 * @param  inMap ユーザデータ情報
	 * @param  svcAddflg サービス追加用フラグ
	 * @param  newSvcKeiNoList 新規登録サービス契約番号リスト
	 * @return boolean true：存在する、false：存在しない
	 * @throws RequestParameterException 
	 */
	@SuppressWarnings("unchecked")
	private boolean isSvcKei(IRequestParameterReadWrite param, HashMap<String, Object> inMap,
			boolean svcAddflg, ArrayList newSvcKeiNoList) throws RequestParameterException
	{
		boolean result = false;

		// インターネットサービス一覧照会（請求契約番号）明細の取得
		ArrayList msg1List = (ArrayList)inMap.get(EKK0081B526CBSMsg.EKK0081B526CBSMSG1LIST);

		if (msg1List == null)
		{
			return result;
		}

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

			// サービス契約ステータス
			String svcKeiStat = (String)childMap.get(PREFIX_SVC_KEI + "svc_kei_stat");

			// サービス契約番号
			String svcKeiNo = (String)childMap.get(PREFIX_SVC_KEI + "seiopsvc_kei_no");
			
			if (svcAddflg && newSvcKeiNoList.contains(svcKeiNo))
			{
				// 追加サービスなので対象外
				continue;
			}

			// 停止中以下は存在する。
			if (SVC_KEI_STAT_STP_CHU >= Integer.parseInt(svcKeiStat))
			{
				result = true;
				break;
			}
		}

		return result;
	}

	/**
	 * 請求オプションサービス契約が削除可能かを判定<br>
	 * @param  param IRequestParameterReadWrite
	 * @param  inMap ユーザデータ情報
	 * @return boolean true：削除可能、false：削除不可能
	 * @throws RequestParameterException 
	 */
	@SuppressWarnings("unchecked")
	private boolean isDelSeiopsvcKei(
			IRequestParameterReadWrite param,
			HashMap<String, Object> inMap) throws RequestParameterException
	{
		// 作業領域のマップを取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}

		/* 作業項目情報 */
		HashMap seiopsvcWorkMap = (HashMap)workMap.get(CC_WORK_AREA_APLY_SEIOPSVC_KEI);
		if (seiopsvcWorkMap == null)
		{
			seiopsvcWorkMap = new HashMap();
			workMap.put(CC_WORK_AREA_APLY_SEIOPSVC_KEI, seiopsvcWorkMap);
		}

		if (seiopsvcWorkMap.get("seiopsvc_kei_stat") == null
				|| "".equals(seiopsvcWorkMap.get("seiopsvc_kei_stat")))
		{
			return false;
		}

		if (!SEIOPSVC_KEI_STAT_UK_ZUMI.equals(seiopsvcWorkMap.get("seiopsvc_kei_stat")))
		{
			return false;
		}
		return true;
	}

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

	/**
	 * ユーザデータ情報に値を設定します。<br>
	 * 　※CAANMsg内のデータが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));
		}
	}

	/**
	 * 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>
	 * @param paramMap パラメータマップ
	 * @param template CAANMsg
	 * @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;
	}

	/**
	 * コントロールマップエラー情報格納処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param itemplateStatus SCの実行ステータス
	 * @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));
	}
	
	/**
	 * サービス契約番号の取得処理を行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param newSvcKeiNoList サービス契約番号格納リスト
	 * @return SCの実行ステータス
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void getSvcKeiNo(IRequestParameterReadWrite param, ArrayList newSvcKeiNoList) throws Exception
	{
		// 作業領域の取得
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		// ネット登録の作業マップからサービス契約番号取得
		HashMap workNetMap = (HashMap)workMap.get(CC_WORK_AREA_NET_NAME);
		if (workNetMap != null)
		{
			newSvcKeiNoList.add((String)workNetMap.get("svc_kei_no"));
		}
		// モバイル登録の作業マップからサービス契約番号取得
		HashMap workMobileMap = (HashMap)workMap.get(CC_WORK_AREA_MOBILE_NM);
		if (workMobileMap != null)
		{
			newSvcKeiNoList.add((String)workMobileMap.get("svc_kei_no"));
		}
		// ADSL登録の作業マップからサービス契約番号取得
		HashMap workAdslMap = (HashMap)workMap.get(CC_WORK_AREA_ADSL_NM);
		if (workAdslMap != null)
		{
			newSvcKeiNoList.add((String)workAdslMap.get("svc_kei_no"));
		}

	}
}