/*********************************************************************
 *	All Rights reserved,Copyright (c) K-Opticom
 **********************************************************************
 *＜プログラム内容＞
 *   システム名      ：eo顧客基幹システム
 *   モジュール名    ：JCHSeikySakiInfoStkuCC
 *   ソースファイル名：JCHSeikySakiInfoStkuCC.java
 *   作成者          ：富士通
 *   日付            ：2011年11月09日
 *＜機能概要＞
 *   請求先情報取得CC部品です。
 *＜修正履歴＞
 *	バージョン	修正日		修正者		修正内容
 *	v1.00		2011/11/09	富士通		新規作成
 *	v2.01		2012/05/10	FJ）岡田	【ST2-2012-0000504】連絡先コードの指定を04から01へ変更
 *	v5.00		2013/07/19	FJ）文元	【IT1-2013-0001412】督促スキーマに存在しない場合「督促なし」の名称を表示する為コード名称管理一意照会を追加
 *	v5.01		2013/08/05	FJ）垣内	【IT1-2013-0001504】連絡先メールに表示されない
 *	v5.02		2013/08/23	FJ）垣内	【OM-2013-0000783】督促状態の表示不正対応
 *  v5.03		2013/09/03  FJ) 垣内    【OM-2013-0001517】サービス契約ステータスの変換条件修正
 *  v5.04		2013/09/03  FJ) 垣内    【随時-2013-000XXX2】未請求状態の場合にメッセージを表示する対応
 *  v5.05		2013/09/05  FJ) 垣内    【OM-2013-0001680】請求情報がない場合のシステムエラー対応
 *  v5.06		2013/09/13  FJ) 垣内    【OM-2013-0002061】請求処理日の取得方法修正
 *  v8.00		2014/02/14  FJ) 林      【OM-2013-0005255】料金調整画面、請求作成機能追加
 *  v41.0.0		2019/01/30  FJ) 杉本    【ANK-3396-00-00】利用停止スケジュールの変更
 *  v41.00.01	2019/03/19  FJ) 大崎    【IT1-2019-0000043】卸２社目の考慮漏れ対応
 *
 **********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Map;
import java.util.SortedMap;
import java.util.TreeMap;

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.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.JACStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.constant.JZM0171Constant;
import eo.common.util.JCHCommonFormatUtil;
import eo.common.util.JCHStringUtil;
import eo.common.util.JCRUtilCommon;
import eo.ejb.cbs.cbsmsg.ECH0231A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0231A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0501B010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0501B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0501B020CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0501B020CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECK0011A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0011A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECK0201B001CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0201B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081B514CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B514CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0491A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0491A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0501A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0501A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0521A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0521A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0541B501CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0541B501CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0171A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0171A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0171B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg1List;

/**
 * 請求収納の各サービスより呼び出される請求先情報取得CC部品です。
 * <p>
 * <BR>
 * 
 * @author 富士通
 */
public class JCHSeikySakiInfoStkuCC extends AbstractCommonComponent
{

	/** マップID */
	private static final String MAP_CC_ID = "SEIKYSAKIINFOSTKUCC";

	/** テンプレートID(請求契約一意照会) */
	private static final String TEMPLATE_ID_EKK0491A010 = "EKK0491A010";
// ANK-3396-00-00 2019/01/30 ADD START
	/** テンプレートID(業務パラメータ照会) */
	private static final String TEMPLATE_ID_EZM0321A010 = "EZM0321A010";
// ANK-3396-00-00 2019/01/30 ADD END

	/** テンプレートID(督促一意照会) */
	private static final String TEMPLATE_ID_ECH0231A010 = "ECH0231A010";

	/** テンプレートID(口座一意照会) */
	private static final String TEMPLATE_ID_EKK0501A010 = "EKK0501A010";

	/** テンプレートID(サービス契約(ヘッダ情報)一覧照会) */
	private static final String TEMPLATE_ID_EKK0081B514 = "EKK0081B514";

	/** テンプレートID(お客様一意照会) */
	private static final String TEMPLATE_ID_ECK0011A010 = "ECK0011A010";

	/** テンプレートID(連絡先一覧照会) */
	private static final String TEMPLATE_ID_ECK0201B001 = "ECK0201B001";
	
	/** テンプレートID(コード名称管理一意照会) */
	private static final String TEMPLATE_ID_EZM0171A010 = "EZM0171A010";

	/** テンプレートID(コード名称管理一覧照会) */
	private static final String TEMPLATE_ID_EZM0171B010 = "EZM0171B010";

	/** テンプレートID(料金スケジュール定義イベント一覧照会) */
	private static final String TEMPLATE_ID_ECH0501B020 = "ECH0501B020";

	/** テンプレートID(料金スケジュール定義一覧照会) */
	private static final String TEMPLATE_ID_ECH0501B010 = "ECH0501B010";

	/** テンプレートID(クレジットカード一意照会) */
	private static final String TEMPLATE_ID_EKK0521A010 = "EKK0521A010";

	/** テンプレートID(請求抑止一覧照会) */
	private static final String TEMPLATE_ID_EKK0541B501 = "EKK0541B501";

	/** 請求先情報取得マップキー(ＫＥＹ＿請求契約番号) */
	private static final String MAP_KEY_SEIKY_KEI_NO = "key_seiky_kei_no";

	/** 請求先情報取得マップキー(請求契約ステータス名称) */
	private static final String MAP_KEY_SEIKY_KEI_STAT_NM = "seiky_kei_stat_nm";

	/** 請求先情報取得マップキー(請求方法コード名称) */
	private static final String MAP_KEY_SEIKY_WAY_CD_NM = "seiky_way_cd_nm";

	/** 請求先情報取得マップキー(請求方法番号（口座）) */
	private static final String MAP_KEY_SEIKY_WAY_NO_KOZA = "seiky_way_no_koza";

	/** 請求先情報取得マップキー(請求書発行要否名称) */
	private static final String MAP_KEY_SEIKYUS_HAKKO_YH_NM = "seikyus_hakko_yh_nm";

	/** 請求先情報取得マップキー(送付先カナ名) */
	private static final String MAP_KEY_SHS_KANA = "shs_kana";

	/** 請求先情報取得マップキー(送付先名) */
	private static final String MAP_KEY_SOHUS_NM = "sohus_nm";

	/** 請求先情報取得マップキー(送付先郵便番号) */
	private static final String MAP_KEY_SOHUS_PCD = "sohus_pcd";

	/** 請求先情報取得マップキー(送付先都道府県名) */
	private static final String MAP_KEY_SOHUS_STATE_NM = "sohus_state_nm";

	/** 請求先情報取得マップキー(送付先市区町村名) */
	private static final String MAP_KEY_SOHUS_CITY_NM = "sohus_city_nm";

	/** 請求先情報取得マップキー(送付先大字通称名) */
	private static final String MAP_KEY_SOHUS_OAZTSU_NM = "sohus_oaztsu_nm";

	/** 請求先情報取得マップキー(送付先字丁目名) */
	private static final String MAP_KEY_SOHUS_AZCHO_NM = "sohus_azcho_nm";

	/** 請求先情報取得マップキー(送付先住所補記・建物名) */
	private static final String MAP_KEY_SOHUS_ADRTTM = "sohus_adrttm";

	/** 請求先情報取得マップキー(送付先住所補記・部屋番号) */
	private static final String MAP_KEY_SOHUS_ADRRM = "sohus_adrrm";

	/** 請求先情報取得マップキー(送付先番地号) */
	private static final String MAP_KEY_SOHUS_BNCHIGO = "sohus_bnchigo";

	/** 請求先情報取得マップキー(督促ステータス) */
	private static final String MAP_KEY_TOKUSOKU_STAT = "tokusoku_stat";

	/** 請求先情報取得マップキー(督促ステータス名称) */
	private static final String MAP_KEY_TOKUSOKU_STAT_NM = "tokusoku_stat_nm";

	/** 請求先情報取得マップキー(支払約束履行判定日) */
	private static final String MAP_KEY_PAY_YAKUSOKU_RIKO_YMD = "pay_yakusoku_riko_ymd";

	/** 請求先情報取得マップキー(未収金額合計) */
	private static final String MAP_KEY_MSU_AMNT_SUM = "msu_amnt_sum";

	/** 請求先情報取得マップキー(支払い審査結果コード) */
	private static final String MAP_KEY_PAY_SKEKKA_CD = "pay_skekka_cd";

	/** 請求先情報取得マップキー(契約状態) */
	private static final String MAP_KEY_KEI_STAT = "kei_stat";

	/** 請求先情報取得マップキー(サービス契約ステータス) */
	private static final String MAP_KEY_SVC_KEI_STAT = "svc_kei_stat";

	/** 請求先情報取得マップキー(ＳＹＳＩＤ) */
	private static final String MAP_KEY_SYSID = "sysid";

	/** 請求先情報取得マップキー(契約者タイプコード名称) */
	private static final String MAP_KEY_KEISHA_TYPE_CD_NM = "keisha_type_cd_nm";

	/** 請求先情報取得マップキー(連絡先メール) */
	private static final String MAP_KEY_RRKS_MLAD = "rrks_mlad";

	/** 請求先情報取得マップキー(連絡先電話番号) */
	private static final String MAP_KEY_RRKS_TELNO = "rrks_telno";

	/** 請求先情報取得マップキー(日中連絡先電話番号) */
	private static final String MAP_KEY_NCHU_RRKS_TELNO = "nchu_rrks_telno";

	/** 請求先情報取得マップキー(サービス契約ステータス) */
	private static final String SEIKY_ADD_KEY_SVC_KEI_STAT = "seiky_add_svc_kei_stat";

	/** 請求先情報取得マップキー(請求方法番号（口座）) */
	private static final String SEIKY_ADD_KEY_SEIKY_WAY_NO_KOZA = "seiky_add_seiky_way_no_koza";

	/** 請求先情報取得マップキー(請求方法番号（クレジットカード）) */
	private static final String SEIKY_ADD_KEY_SEIKY_WAY_NO_CRECARD = "seiky_add_seiky_way_no_crecard";

	/** 請求先情報取得マップキー(請求方法コード) */
	private static final String SEIKY_ADD_KEY_SEIKY_WAY_CD = "seiky_add_seiky_way_cd";

	/** 請求先情報取得マップキー(請求方法適用調整年月日) */
	private static final String SEIKY_ADD_KEY_SEIKY_WAY_APLY_ADJ_YMD= "seiky_add_seiky_way_aply_adj_ymd";

	/** 請求先情報取得マップキー(強制窓口フラグ) */
	private static final String SEIKY_ADD_KEY_KYOSEI_MADOGUCHI_FLG = "seiky_add_kyosei_madoguchi_flg";

	/** 請求先情報取得マップキー(口座ステータス) */
	private static final String SEIKY_ADD_KEY_KOZA_STAT = "seiky_add_koza_stat";

	/** 請求先情報取得マップキー(クレジットカードステータス) */
	private static final String SEIKY_ADD_KEY_CRECARD_STAT = "seiky_add_crecard_stat";

	/** 請求先情報取得マップキー(クレジットカード無効年月) */
	private static final String SEIKY_ADD_KEY_CRECA_MK_YM = "seiky_add_creca_mk_ym";

	/** 請求先情報取得マップキー(請求抑止フラグ) */
	private static final String SEIKY_ADD_KEY_SEIKY_YOKSI_FLG = "seiky_add_seiky_yoksi_flg";

	/** 請求先情報取得マップキー(督促番号) */
	private static final String SEIKY_ADD_KEY_TOKUSOKU_NO = "seiky_add_tokusoku_no";

	/** 請求先情報取得マップキー(督促ステータス) */
	private static final String SEIKY_ADD_KEY_TOKUSOKU_STAT = "seiky_add_tokusoku_stat";

	/** 請求先情報取得マップキー(契約者タイプコード) */
	private static final String SEIKY_ADD_KEY_KEISHA_TYPE_CD = "seiky_add_keisha_type_cd";

	/** 請求先情報取得マップキー(請求契約配下サービス契約状態コード) */
	private static final String SEIKY_ADD_KEY_SKHK_SVKEI_STAT_CD = "seiky_add_skhk_svkei_stat_cd";

	/** 請求先情報取得マップキー(請求契約配下サービス契約解約理由識別コード) */
	private static final String SEIKY_ADD_KEY_SKHK_SVKEI_DLRE_SKBT_CD = "seiky_add_skhk_svkei_dlre_skbt_cd";

	/** 請求先情報取得マップキー(サービス課金終了年月日) */
	private static final String SEIKY_ADD_KEY_SVC_CHRG_ENDYMD = "seiky_add_svc_chrg_endymd";

	/** 請求先情報取得マップキー(請求作成ボタン非活性制御値) */
	private static final String SEIKY_ADD_KEY_DSBL_CTL_JSF_BTN_SEIKY_ADD = "dsbl_ctl_jsf_btn_seiky_add";

	/** 請求先情報取得マップキー(コード区分名) */
	private static final String CD_DIV_NM = "cd_div_nm";
// ANK-3396-00-00 2019/01/30 ADD START

	/** 請求先情報取得マップキー(強制解約予告回数) */
	private static final String MAP_KEY_KYOSEI_DSL_YKK_CNT = "kyosei_dsl_ykk_cnt";

	/** 請求先情報取得マップキー(早期利用停止対象フラグ) */
	private static final String MAP_KEY_EARLY_USE_STP_TG_FLG = "early_use_stp_tg_flg";
	
	/** 請求先情報取得マップキー(強制解約予告規定回数) */
	private static final String MAP_KEY_KYOSEI_DSL_YKK_KT_CNT = "kyosei_dsl_ykk_kt_cnt";
// ANK-3396-00-00 2019/01/30 ADD END

// IT1-2019-0000043 ADD START

	/** 請求先情報取得マップキー(卸先事業者コード) */
	private static final String ORSJGS_CD = "orsjgs_cd";
// IT1-2019-0000043 ADD END

	/** 請求内訳_請求一覧照会 */
	private static final String CHSV000701SC = "CHSV000701SC";

	/** 請求内訳_債権一意照会 */
	private static final String CHSV000703SC = "CHSV000703SC";

	/** 請求内訳_請求一覧照会リスト */
	private static final String ECH0051B010CBSMSG1LIST = "ECH0051B010CBSMsg1List";

	/** 請求年月 */
	private static final String SEIKY_YM = "seiky_ym";
	
	/** ＫＥＹ＿請求年月 */
	private static final String KEY_SEIKY_YM = "key_seiky_ym";
	
	/** 請求処理日 */
	private static final String MAP_KEY_SEIKY_TRN_DAY = "seiky_trn_day";
// ANK-3396-00-00 2019/01/30 ADD START

	/** 強制解約予告規定回数の業務パラメータＩＤ */
	private static final String KYOSEI_DSL_YKK_KITEI_CNT_ID = "KK_KYOSEI_DSL_YKKCNT";
// ANK-3396-00-00 2019/01/30 ADD END
	
	/* TODO : 暫定対応リスト */
	/*
	 * 暫定対応�A 連絡先の取得ロジックが不明。 
	 * 連絡方法コードが一致し、かつ連絡先種別コードが一番若い値をマッピングする。 ＜個別の前提条件＞ 
	 * ・連絡先種別コードが"自宅"である電話番号を「連絡先電話番号」とする。 
	 * ・連絡先種別コードが"自宅"である電話番号は、１件のみ設定されている想定。
	 * ・連絡先種別コードが"自宅"以外(空を除く)を「日中連絡電話番号」とする。 ＜共通の前提条件＞ 
	 * ・連絡方法コードは必ず値が設定されている想定。 ・連絡先種別コードが設定されていない明細がある場合、若い値を特定する判定が保証されない。
	 */

	/**
	 * 請求先情報取得マップに指定されたキー情報を基に請求先情報を取得します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	public IRequestParameterReadWrite getInfo(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		setEmptyOutItems(param);

		/* ◇請求契約一意照会サービスインターフェイス */
		execEKK0491A010(handle, param);

		/* ◇判定：請求契約情報 */
		if (isExistSeikyKeiInfo(param))
		{
// ANK-3396-00-00 2019/01/30 ADD START
			/* ◇業務パラメータ照会サービスインターフェイス */
			execEZM0321A010(handle, param);

// ANK-3396-00-00 2019/01/30 ADD END
			/* ◇督促一意照会サービスインターフェイス */
			execECH0231A010(handle, param);

			/* ◇判定：請求方法番号（口座） */
			if (isExistSeikyWayNoKoza(param))
			{
				/* ◇口座一意照会サービスインターフェイス */
				execEKK0501A010(handle, param);
			}

			/* ◇サービス契約(ヘッダ情報)一覧照会サービスインターフェイス */
			execEKK0081B514(handle, param);
			/* ◇判定：ＳＹＳＩＤ */
			if (isExistSysIdMulti(param))
			{
				/* ◇お客様一意照会サービスインターフェイス(複数呼び出し) */
				execECK0011A01001(handle, param);
			}
			else if (isExistSysId(param))
			{
				/* ◇お客様一意照会サービスインターフェイス */
				execECK0011A010(handle, param);

				/* ◇連絡先一覧照会サービスインターフェイス */
				execECK0201B001(handle, param);
			}
			
			/* ◇督促データなしの場合、「督促なし」名称取得処理 */
			if (!isExistTokusokuData(param))
			{
				String cdSbtCd = JACStrConst.CD_SBT_CD_CD00184;
				String cdDiv = JACStrConst.TOKUSOKU_STAT_NASHI;
				/* ◇コード名称管理一意照会サービスインターフェイス */
				execEZM0171A010(handle, param, cdSbtCd, cdDiv);
				// 「督促なし」名称設定
				setTokusokuStatNm(param);
			}
			
			/* 請求処理日取得 */
			if (isExistSeikyYm(param))
			{
				/* ◇料金スケジュール定義イベント一覧照会サービスインターフェイス */
				execECH0501B020(handle, param);
			}
			
			/* 請求作成情報取得 */
			getSeikyAddInfo(handle, param);
		}

		return param;
	}

	/**
	 * 請求先情報取得処理チェック処理.<br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException RequestParameterException
	 */
	public HashMap<String, Object> getInvokeCBS(SessionHandle handle, IRequestParameterReadWrite param,
						String fixedText) throws RequestParameterException
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 請求契約一意照会サービスIF用メッセージ設定処理
		ArrayList<CAANMsg> templateEKK0491A010 = editInMsgEKK0491A010(param);

		for (CAANMsg msg : templateEKK0491A010)
		{
			templateList.add(msg);
		}

		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	// ▼▼ サービスIF呼び出し ▼▼

	/**
	 * 請求契約一意照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK0491A010(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEKK0491A010 = editInMsgEKK0491A010(param);
		for (CAANMsg msg : templateEKK0491A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEKK0491A010(result, param);
	}
// ANK-3396-00-00 2019/01/30 ADD START

	/**
	 * 業務パラメータ照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEZM0321A010(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEZM0321A010 = editInMsgEZM0321A010(param);
		for (CAANMsg msg : templateEZM0321A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEZM0321A010(result, param);
		
	}
// ANK-3396-00-00 2019/01/30 ADD END

	/**
	 * 督促一意照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0231A010(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0231A010 = editInMsgECH0231A010(param);
		for (CAANMsg msg : templateECH0231A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0231A010(result, param);
	}

	/**
	 * 口座一意照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK0501A010(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEKK0501A010 = editInMsgEKK0501A010(param);
		for (CAANMsg msg : templateEKK0501A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEKK0501A010(result, param);
	}

	/**
	 * サービス契約(ヘッダ情報)一覧照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK0081B514(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEKK0081B514 = editInMsgEKK0081B514(param, JPCModelConstant.FUNC_CD_1);
		for (CAANMsg msg : templateEKK0081B514)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEKK0081B514(result, param);
	}

	/**
	 * お客様一意照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECK0011A010(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECK0011A010 = editInMsgECK0011A010(param);
		for (CAANMsg msg : templateECK0011A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECK0011A010(result, param);
	}

	/**
	 * 連絡先一覧照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execECK0201B001(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECK0201B001 = editInMsgECK0201B001(param);
		for (CAANMsg msg : templateECK0201B001)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// コード名称管理一覧情報取得
		HashMap<String, Object> rrksCdNmMap = new HashMap<String, Object>();
		rrksCdNmMap = execEZM0171B010(handle, param);

		// 下りマッピング
		editOutMsgECK0201B001(result, param, rrksCdNmMap);
	}

	/**
	 * お客様一意照会サービスインタフェイス(複数)を実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private void execECK0011A01001(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		
		String sysId = (String)dataMap.get(MAP_KEY_SYSID);
		String[] sysIds = sysId.split(",");

		// 契約者タイプコード名称リスト 
		ArrayList<String> keishaTypeCdNmList = new ArrayList<String>();
		
		for (int i = 0; i < sysIds.length; i++)
		{
			// ＳＹＳＩＤ設定
			dataMap.put(MAP_KEY_SYSID, sysIds[i]);

			/* ◇テンプレートリスト生成 */
			ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();
			
			// 上りマッピング
			ArrayList<CAANMsg> templateECK0011A010 = editInMsgECK0011A010(param);
			for (CAANMsg msg : templateECK0011A010)
			{
				templateList.add(msg);
			}
			CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
			paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

			// ＳＣ呼出実行
			ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
			Map<?, ?> result = scCall.run(paramMap, handle);

			// 下りマッピング
			editOutMsgECK0011A010(result, param);

			// 契約者タイプコード名称取得
			String keishaTypeCdNm = (String)dataMap.get(MAP_KEY_KEISHA_TYPE_CD_NM);
			if (keishaTypeCdNm != null && keishaTypeCdNm.length() > 0 && keishaTypeCdNmList.indexOf(keishaTypeCdNm) < 0)
			{
				// お客様一意照会明細.契約者タイプコード名称を追加
				keishaTypeCdNmList.add((String)dataMap.get(MAP_KEY_KEISHA_TYPE_CD_NM));
			}
		}
		
		// 請求先情報取得マップ.契約者タイプコード名称設定
		if (keishaTypeCdNmList.size() == 1)
		{
			dataMap.put(MAP_KEY_KEISHA_TYPE_CD_NM, keishaTypeCdNmList.get(0));
		}
		else
		{
			dataMap.put(MAP_KEY_KEISHA_TYPE_CD_NM, new String());
		}
		// 取得マップ.連絡先電話番号設定
		dataMap.put(MAP_KEY_RRKS_TELNO, new String());

	}

	/**
	 * コード名称管理一意照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param cdSbtCd コード種別コード
	 * @param cdDiv コード区分
	 * @throws Exception 例外が発生した場合
	 */
	private void execEZM0171A010(SessionHandle handle, IRequestParameterReadWrite param, String cdSbtCd, String cdDiv) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEZM0171A010 = editInMsgEZM0171A010(param, cdSbtCd, cdDiv);
		for (CAANMsg msg : templateEZM0171A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEZM0171A010(result, param);
		
	}

	/**
	 * コード名称管理一覧照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws Exception 例外が発生した場合
	 */
	private HashMap<String, Object> execEZM0171B010(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEZM0171B010 = editInMsgEZM0171B010(param);
		for (CAANMsg msg : templateEZM0171B010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		return editOutMsgEZM0171B010(result, param);
		
	}

	/**
	 * 料金スケジュール定義イベント一覧照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return HashMap<String, Object>
	 * @throws Exception 例外が発生した場合
	 */
	private void execECH0501B020(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0501B020 = editInMsgECH0501B020(param);
		for (CAANMsg msg : templateECH0501B020)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgECH0501B020(result, param);
		
	}

	/**
	 * 料金スケジュール定義一覧照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param eventCd イベントコード
	 * @return boolean
	 * @throws Exception 例外が発生した場合
	 */
	private boolean execECH0501B010(SessionHandle handle, IRequestParameterReadWrite param, String eventCd) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0501B010 = editInMsgECH0501B010(param, eventCd);
		for (CAANMsg msg : templateECH0501B010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		return editOutMsgECH0501B010(result, param, eventCd);
	}

	/**
	 * 料金スケジュール定義イベント一覧照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param eventCd イベントコード
	 * @return boolean
	 * @throws Exception 例外が発生した場合
	 */
	private boolean execECH0501B020_2(SessionHandle handle, IRequestParameterReadWrite param, String eventCd) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateECH0501B020 = editInMsgECH0501B020_2(param, eventCd);
		for (CAANMsg msg : templateECH0501B020)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		return editOutMsgECH0501B020_2(result, param, eventCd);
	}

	/**
	 * サービス契約(ヘッダ情報)一覧照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK0081B514_2(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEKK0081B514 = editInMsgEKK0081B514(param, JPCModelConstant.FUNC_CD_2);
		for (CAANMsg msg : templateEKK0081B514)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEKK0081B514_2(result, param);
	}

	/**
	 * 請求契約一意照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param standardDay 基準日
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK0491A010_2(SessionHandle handle, IRequestParameterReadWrite param, String standardDay) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEKK0491A010 = editInMsgEKK0491A010_2(param, standardDay);
		for (CAANMsg msg : templateEKK0491A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEKK0491A010_2(result, param, standardDay);
	}

	/**
	 * 口座一意照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK0501A010_2(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEKK0501A010 = editInMsgEKK0501A010_2(param);
		for (CAANMsg msg : templateEKK0501A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEKK0501A010_2(result, param);
	}

	/**
	 * クレジットカード一意照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK0521A010(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEKK0521A010 = editInMsgEKK0521A010(param);
		for (CAANMsg msg : templateEKK0521A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEKK0521A010(result, param);
	}

	/**
	 * 請求抑止一覧照会サービスインタフェイスを実行します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param seikyYoksiCd 請求抑止コード
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK0541B501(SessionHandle handle, IRequestParameterReadWrite param, String seikyYoksiCd) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEKK0541B501 = editInMsgEKK0541B501(param, MAP_CC_ID);
		for (CAANMsg msg : templateEKK0541B501)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEKK0541B501(result, param, seikyYoksiCd);
	}
	// ▲▲ サービスIF呼び出し ▲▲

	// ▼▼ サービスIF用メッセージ設定処理 ▼▼

	/**
	 * 請求契約一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgEKK0491A010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EKK0491A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, EKK0491A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0491A010, EKK0491A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EKK0491A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// 請求先情報取得マップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号
		if (inMap == null || inMap.get(MAP_KEY_SEIKY_KEI_NO) == null || "".equals(inMap.get(MAP_KEY_SEIKY_KEI_NO)))
		{
			template.setNull(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO, (String)inMap.get(MAP_KEY_SEIKY_KEI_NO));
		}

		// NULL → ＫＥＹ＿世代登録年月日時分秒
		template.setNull(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM);

		// 部品呼び出し → ＫＥＹ＿予約適用年月日
		template.set(EKK0491A010CBSMsg.KEY_RSV_APLY_YMD, com.fujitsu.futurity.bp.custom.common.JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH));

		templateList.add(template);

		return templateList;
	}
// ANK-3396-00-00 2019/01/30 ADD START

	/**
	 * 業務パラメータ照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEZM0321A010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EZM0321A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, EZM0321A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0321A010, EZM0321A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EZM0321A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 業務パラメータＩＤ → ＫＥＹ＿業務パラメータＩＤ
		template.set(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID, KYOSEI_DSL_YKK_KITEI_CNT_ID);
		templateList.add(template);

		return templateList;
	}
// ANK-3396-00-00 2019/01/30 ADD END

	/**
	 * 督促一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECH0231A010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0231A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECH0231A010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0231A010, ECH0231A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0231A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// NULL → ＫＥＹ＿督促番号
		template.setNull(ECH0231A010CBSMsg.KEY_TOKUSOKU_NO);

		// 請求先情報取得マップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号
		if (inMap == null || inMap.get(MAP_KEY_SEIKY_KEI_NO) == null || "".equals(inMap.get(MAP_KEY_SEIKY_KEI_NO)))
		{
			template.setNull(ECH0231A010CBSMsg.KEY_SEIKY_KEI_NO);
		}
		else
		{
			template.set(ECH0231A010CBSMsg.KEY_SEIKY_KEI_NO, (String)inMap.get(MAP_KEY_SEIKY_KEI_NO));
		}

		// 部品呼び出し → ＫＥＹ＿督促管理年月日
		template.set(ECH0231A010CBSMsg.KEY_TOKUSOKU_KANRI_YMD, com.fujitsu.futurity.bp.custom.common.JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH));

		templateList.add(template);

		return templateList;
	}

	/**
	 * 口座一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgEKK0501A010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EKK0501A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, EKK0501A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0501A010, EKK0501A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EKK0501A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// 請求先情報取得マップ.請求方法番号(口座) → ＫＥＹ＿請求方法番号(口座)
		if (inMap == null || inMap.get(MAP_KEY_SEIKY_WAY_NO_KOZA) == null || "".equals(inMap.get(MAP_KEY_SEIKY_WAY_NO_KOZA)))
		{
			template.setNull(EKK0501A010CBSMsg.KEY_SEIKY_WAY_NO_KOZA);
		}
		else
		{
			template.set(EKK0501A010CBSMsg.KEY_SEIKY_WAY_NO_KOZA, (String)inMap.get(MAP_KEY_SEIKY_WAY_NO_KOZA));
		}

		// NULL → ＫＥＹ＿世代登録年月日時分秒
		template.setNull(EKK0501A010CBSMsg.KEY_GENE_ADD_DTM);

		templateList.add(template);

		return templateList;
	}

	/**
	 * サービス契約(ヘッダ情報)一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param funcCd 機能コード
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgEKK0081B514(IRequestParameterReadWrite param, String funcCd) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EKK0081B514CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, EKK0081B514CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0081B514, EKK0081B514CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EKK0081B514CBSMsg.FUNC_CODE, funcCd);

		// 請求先情報取得マップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号
		if (inMap == null || inMap.get(MAP_KEY_SEIKY_KEI_NO) == null || "".equals(inMap.get(MAP_KEY_SEIKY_KEI_NO)))
		{
			template.setNull(EKK0081B514CBSMsg.KEY_SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK0081B514CBSMsg.KEY_SEIKY_KEI_NO, (String)inMap.get(MAP_KEY_SEIKY_KEI_NO));
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * お客様一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECK0011A010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECK0011A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECK0011A010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECK0011A010, ECK0011A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECK0011A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// 請求先情報取得マップ.ＳＹＳＩＤ → ＫＥＹ＿SYSID
		if (inMap == null || inMap.get(MAP_KEY_SYSID) == null || "".equals(inMap.get(MAP_KEY_SYSID)))
		{
			template.setNull(ECK0011A010CBSMsg.KEY_SYSID);
		}
		else
		{
			template.set(ECK0011A010CBSMsg.KEY_SYSID, (String)inMap.get(MAP_KEY_SYSID));
		}

		// 部品呼び出し → ＫＥＹ＿予約適用年月日
		template.set(ECK0011A010CBSMsg.KEY_RSV_APLY_YMD, com.fujitsu.futurity.bp.custom.common.JCCBPCommon.getOpeDate(JACStrConst.SYS_CD_CH));

		// NULL → ＫＥＹ＿世代登録年月日時分秒
		template.setNull(ECK0011A010CBSMsg.KEY_GENE_ADD_DTM);

		templateList.add(template);

		return templateList;
	}

	/**
	 * 連絡先一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECK0201B001(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECK0201B001CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECK0201B001CBSMsg.TEMPLATEID, TEMPLATE_ID_ECK0201B001, ECK0201B001CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECK0201B001CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 請求先情報取得マップ.ＳＹＳＩＤ → ＫＥＹ＿SYSID
		if (inMap == null || inMap.get(MAP_KEY_SYSID) == null || "".equals(inMap.get(MAP_KEY_SYSID)))
		{
			template.setNull(ECK0201B001CBSMsg.KEY_SYSID);
		}
		else
		{
			template.set(ECK0201B001CBSMsg.KEY_SYSID, (String)inMap.get(MAP_KEY_SYSID));
		}

		// NULL → ＫＥＹ＿連絡先コード
		template.setNull(ECK0201B001CBSMsg.KEY_RRKS_CD);

		// NULL → ＫＥＹ＿連絡方法コード
		template.setNull(ECK0201B001CBSMsg.KEY_RRK_WAY_CD);

		// NULL → ＫＥＹ＿連絡先種別コード
		template.setNull(ECK0201B001CBSMsg.KEY_RRKS_SBT_CD);

		templateList.add(template);

		return templateList;
	}
	
	/**
	 * コード名称管理一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param cdSbtCd コード種別コード
	 * @param cdDiv コード区分
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgEZM0171A010(IRequestParameterReadWrite param, String cdSbtCd, String cdDiv) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EZM0171A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECK0201B001CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0171A010, EZM0171A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECK0201B001CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// コード種別コード → ＫＥＹ＿コード種別コード
		if (JCRUtilCommon.isNull(cdSbtCd))
		{
			template.setNull(EZM0171A010CBSMsg.KEY_CD_SBT_CD);
		}
		else
		{
			template.set(EZM0171A010CBSMsg.KEY_CD_SBT_CD, cdSbtCd);
		}

		// コード区分 → ＫＥＹ＿コード区分
		if (JCRUtilCommon.isNull(cdDiv))
		{
			template.setNull(EZM0171A010CBSMsg.KEY_CD_DIV);
		}
		else
		{
			template.set(EZM0171A010CBSMsg.KEY_CD_DIV, cdDiv);
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * コード名称管理一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param cdSbtCd コード種別コード
	 * @param cdDiv コード区分
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECH0501B020(IRequestParameterReadWrite param) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0501B020CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECH0501B020CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0501B020, ECH0501B020CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0501B020CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// イベントコード:"04"（請求処理日） → ＫＥＹ＿イベントコード
		template.set(ECH0501B020CBSMsg.KEY_EVENT_CD, JACStrConst.EVENT_CD_SIKY_TRN_DAY);

		// サービスより請求年月取得
		HashMap<String, Object> seikyMap = (HashMap<String, Object>)param.getData(CHSV000703SC);
		
		// 請求一覧照会マップ.請求年月 → 請求年月
		if (seikyMap == null || seikyMap.get(KEY_SEIKY_YM) == null || "".equals(seikyMap.get(KEY_SEIKY_YM)))
		{
			HashMap<String, Object> seikyUwMap = (HashMap<String, Object>)param.getData(CHSV000701SC);
			
			if(seikyUwMap != null && seikyUwMap.size() != 0)
			{
				ArrayList<HashMap<String, Object>> seikyUwList = (ArrayList<HashMap<String, Object>>)seikyUwMap.get(ECH0051B010CBSMSG1LIST);
				if(seikyUwList != null && seikyUwList.size() != 0)
				{
					HashMap<String, Object> childMap = seikyUwList.get(0);
					
					// 請求一覧照会マップ.請求年月 → 請求年月
					if (childMap == null || childMap.get(SEIKY_YM) == null || "".equals(childMap.get(SEIKY_YM)))
					{
						template.setNull(ECH0501B020CBSMsg.KEY_SEIKY_YM);
					}
					else
					{
						template.set(ECH0501B020CBSMsg.KEY_SEIKY_YM, (String) childMap.get(SEIKY_YM));
					}
				}
			}
		}
		else
		{
			template.set(ECH0501B020CBSMsg.KEY_SEIKY_YM, (String) seikyMap.get(KEY_SEIKY_YM));
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * 料金スケジュール定義イベント一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param cdSbtCd コード種別コード
	 * @param cdDiv コード区分
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEZM0171B010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EZM0171B010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, EZM0171B010CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0171A010, EZM0171B010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EZM0171B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// コード種別コード → ＫＥＹ＿コード種別コード
		template.set(EZM0171A010CBSMsg.KEY_CD_SBT_CD, JZM0171Constant.CD00254);
		templateList.add(template);

		return templateList;
	}

	/**
	 * 料金スケジュール定義一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param eventCd イベントコード
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgECH0501B010(IRequestParameterReadWrite param, String eventCd) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0501B010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECH0501B010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0501B010, EZM0171B010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0501B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// イベントコード → ＫＥＹ＿イベントコード
		template.set(ECH0501B010CBSMsg.KEY_EVENT_CD, eventCd);

		// オンライン運用日 → ＫＥＹ＿基準年月日
		template.set(ECH0501B010CBSMsg.KEY_STDARDYMD, JCCBPCommon.getOpeDate(null));

		templateList.add(template);

		return templateList;
	}
	
	/**
	 * 料金スケジュール定義イベント一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param eventCd イベントコード
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgECH0501B020_2(IRequestParameterReadWrite param, String eventCd) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(ECH0501B020CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, ECH0501B020CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0501B020, ECH0501B020CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(ECH0501B020CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// イベントコード → ＫＥＹ＿イベントコード
		template.set(ECH0501B020CBSMsg.KEY_EVENT_CD, eventCd);

		// 請求年月 → ＫＥＹ＿請求年月
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		template.set(ECH0501B020CBSMsg.KEY_SEIKY_YM, dataMap.get("schdl_teigi_seiky_ym"));

		templateList.add(template);

		return templateList;
	}

	/**
	 * 請求契約一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param standardDay 基準日
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgEKK0491A010_2(IRequestParameterReadWrite param, String standardDay) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EKK0491A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, EKK0491A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0491A010, EKK0491A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EKK0491A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// 請求先情報取得マップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号
		if (inMap == null || inMap.get(MAP_KEY_SEIKY_KEI_NO) == null || "".equals(inMap.get(MAP_KEY_SEIKY_KEI_NO)))
		{
			template.setNull(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO, (String)inMap.get(MAP_KEY_SEIKY_KEI_NO));
		}

		// NULL → ＫＥＹ＿世代登録年月日時分秒
		template.setNull(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM);

		// 部品呼び出し → ＫＥＹ＿予約適用年月日
		template.set(EKK0491A010CBSMsg.KEY_RSV_APLY_YMD, standardDay);

		templateList.add(template);

		return templateList;
	}

	/**
	 * 口座一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgEKK0501A010_2(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EKK0501A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, EKK0501A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0501A010, EKK0501A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EKK0501A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// 請求先情報取得マップ.請求方法番号(口座) → ＫＥＹ＿請求方法番号(口座)
		if (inMap == null || inMap.get(SEIKY_ADD_KEY_SEIKY_WAY_NO_KOZA) == null || "".equals(inMap.get(SEIKY_ADD_KEY_SEIKY_WAY_NO_KOZA)))
		{
			template.setNull(EKK0501A010CBSMsg.KEY_SEIKY_WAY_NO_KOZA);
		}
		else
		{
			template.set(EKK0501A010CBSMsg.KEY_SEIKY_WAY_NO_KOZA, (String)inMap.get(SEIKY_ADD_KEY_SEIKY_WAY_NO_KOZA));
		}

		// NULL → ＫＥＹ＿世代登録年月日時分秒
		template.setNull(EKK0501A010CBSMsg.KEY_GENE_ADD_DTM);

		templateList.add(template);

		return templateList;
	}

	/**
	 * クレジットカード一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgEKK0521A010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EKK0521A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, EKK0521A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0521A010, EKK0521A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EKK0521A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// 請求先情報取得マップ.請求方法番号(クレジットカード) → ＫＥＹ＿請求方法番号(クレジットカード)
		if (inMap == null || inMap.get(SEIKY_ADD_KEY_SEIKY_WAY_NO_CRECARD) == null || "".equals(inMap.get(SEIKY_ADD_KEY_SEIKY_WAY_NO_CRECARD)))
		{
			template.setNull(EKK0521A010CBSMsg.KEY_SEIKY_WAY_NO_CRECARD);
		}
		else
		{
			template.set(EKK0521A010CBSMsg.KEY_SEIKY_WAY_NO_CRECARD, (String)inMap.get(SEIKY_ADD_KEY_SEIKY_WAY_NO_CRECARD));
		}

		// NULL → ＫＥＹ＿世代登録年月日時分秒
		template.setNull(EKK0521A010CBSMsg.KEY_GENE_ADD_DTM);

		templateList.add(template);

		return templateList;
	}

	/**
	 * 請求抑止一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * 
	 * @param param リクエストパラメータ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<CAANMsg> editInMsgEKK0541B501(IRequestParameterReadWrite param, String mapId) throws RequestParameterException
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(mapId);
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EKK0541B501CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, EKK0541B501CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0541B501, EKK0541B501CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EKK0541B501CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 請求先情報取得マップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号
		if (inMap == null || inMap.get(MAP_KEY_SEIKY_KEI_NO) == null || "".equals(inMap.get(MAP_KEY_SEIKY_KEI_NO)))
		{
			template.setNull(EKK0541B501CBSMsg.KEY_SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK0541B501CBSMsg.KEY_SEIKY_KEI_NO, (String)inMap.get(MAP_KEY_SEIKY_KEI_NO));
		}

		template.set(EKK0541B501CBSMsg.KEY_SEIKY_YOKSI_FLG, JACStrConst.YOKSI_FLG_ARI);

		templateList.add(template);

		return templateList;
	}
	// ▲▲ サービスIF用メッセージ設定処理 ▲▲

	// ▼▼ サービスIF用メッセージ取得処理 ▼▼

	/**
	 * 請求一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0491A010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

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

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}
		templateArray = parentTemplate.getCAANMsgList(EKK0491A010CBSMsg.EKK0491A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 請求契約情報取得マップ.請求契約ステータス名称 ← 請求契約一意照会明細.請求契約ステータス名称
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SEIKY_KEI_STAT_NM))
				{
					dataMap.put(MAP_KEY_SEIKY_KEI_STAT_NM, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_SEIKY_KEI_STAT_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SEIKY_KEI_STAT_NM));
				}

				// 請求契約情報取得マップ.請求方法コード名称 ← 請求契約一意照会明細.請求方法コード名称
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SEIKY_WAY_CD_NM))
				{
					dataMap.put(MAP_KEY_SEIKY_WAY_CD_NM, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_SEIKY_WAY_CD_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SEIKY_WAY_CD_NM));
				}

				// 請求契約情報取得マップ.請求方法番号（口座） ← 請求契約一意照会明細.請求方法番号(口座)
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SEIKY_WAY_NO_KOZA))
				{
					dataMap.put(MAP_KEY_SEIKY_WAY_NO_KOZA, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_SEIKY_WAY_NO_KOZA, childTemplate.getString(EKK0491A010CBSMsg1List.SEIKY_WAY_NO_KOZA));
				}

				// 請求契約情報取得マップ.請求書発行要否名称 ← 請求契約一意照会明細.請求書発行要否名称
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SEIKYUS_HAKKO_YH_NM))
				{
					dataMap.put(MAP_KEY_SEIKYUS_HAKKO_YH_NM, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_SEIKYUS_HAKKO_YH_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SEIKYUS_HAKKO_YH_NM));
				}

				// 請求契約情報取得マップ.送付先カナ名 ← 請求契約一意照会明細.送付先カナ名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SHS_KANA))
				{
					dataMap.put(MAP_KEY_SHS_KANA, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_SHS_KANA, childTemplate.getString(EKK0491A010CBSMsg1List.SHS_KANA));
				}

				// 請求契約情報取得マップ.送付先名 ← 請求契約一意照会明細.送付先名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_NM))
				{
					dataMap.put(MAP_KEY_SOHUS_NM, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_SOHUS_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_NM));
				}

				// 請求契約情報取得マップ.送付先郵便番号 ← 請求契約一意照会明細.送付先郵便番号
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_PCD))
				{
					dataMap.put(MAP_KEY_SOHUS_PCD, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_SOHUS_PCD, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_PCD));
				}

				// 請求契約情報取得マップ.送付先都道府県名 ← 請求契約一意照会明細.送付先都道府県名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_STATE_NM))
				{
					dataMap.put(MAP_KEY_SOHUS_STATE_NM, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_SOHUS_STATE_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_STATE_NM));
				}

				// 請求契約情報取得マップ.送付先市区町村名 ← 請求契約一意照会明細.送付先市区町村名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_CITY_NM))
				{
					dataMap.put(MAP_KEY_SOHUS_CITY_NM, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_SOHUS_CITY_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_CITY_NM));
				}

				// 請求契約情報取得マップ.送付先大字通称名 ← 請求契約一意照会明細.送付先大字通称名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_OAZTSU_NM))
				{
					dataMap.put(MAP_KEY_SOHUS_OAZTSU_NM, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_SOHUS_OAZTSU_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_OAZTSU_NM));
				}

				// 請求契約情報取得マップ.送付先字丁目名 ← 請求契約一意照会明細.送付先字丁目名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_AZCHO_NM))
				{
					dataMap.put(MAP_KEY_SOHUS_AZCHO_NM, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_SOHUS_AZCHO_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_AZCHO_NM));
				}

				// 請求契約情報取得マップ.送付先住所補記・建物名 ← 請求契約一意照会明細.送付先住所補記・建物名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_ADRTTM))
				{
					dataMap.put(MAP_KEY_SOHUS_ADRTTM, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_SOHUS_ADRTTM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_ADRTTM));
				}

				// 請求契約情報取得マップ.送付先住所補記・部屋番号 ← 請求契約一意照会明細.送付先住所補記・部屋番号
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_ADRRM))
				{
					dataMap.put(MAP_KEY_SOHUS_ADRRM, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_SOHUS_ADRRM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_ADRRM));
				}

				// 請求契約情報取得マップ.送付先番地号 ← 請求契約一意照会明細.送付先番地号
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_BNCHIGO))
				{
					dataMap.put(MAP_KEY_SOHUS_BNCHIGO, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_SOHUS_BNCHIGO, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_BNCHIGO));
				}
// ANK-3396-00-00 2019/01/30 ADD START
				// 請求契約情報取得マップ.強制解約予告回数 ← 請求契約一意照会明細.強制解約予告回数
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.KYOSEI_DSL_YKK_CNT))
				{
					dataMap.put(MAP_KEY_KYOSEI_DSL_YKK_CNT, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_KYOSEI_DSL_YKK_CNT, childTemplate.getString(EKK0491A010CBSMsg1List.KYOSEI_DSL_YKK_CNT));
				}
// ANK-3396-00-00 2019/01/30 ADD END
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}

		return param;
	}
// ANK-3396-00-00 2019/01/30 ADD START

	/**
	 * EZM0321A010_業務パラメータ照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEZM0321A010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

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

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(EZM0321A010CBSMsg.EZM0321A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 請求先情報取得マップ.コード区分名 ← コード名称管理一意照会明細.コード名称管理一意照会明細
				if (childTemplate.isNull(EZM0321A010CBSMsg1List.WORK_PARAM_ID))
				{
					dataMap.put(MAP_KEY_KYOSEI_DSL_YKK_KT_CNT, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_KYOSEI_DSL_YKK_KT_CNT, childTemplate.getString(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return param;
	}
// ANK-3396-00-00 2019/01/30 ADD END

	/**
	 * 督促一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECH0231A010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

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

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}
		templateArray = parentTemplate.getCAANMsgList(ECH0231A010CBSMsg.ECH0231A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 請求契約情報取得マップ.督促番号 ← 督促一意明細.督促番号
				if (childTemplate.isNull(ECH0231A010CBSMsg1List.TOKUSOKU_NO))
				{
					dataMap.put(SEIKY_ADD_KEY_TOKUSOKU_NO, new String());
				}
				else
				{
					dataMap.put(SEIKY_ADD_KEY_TOKUSOKU_NO, childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_NO));
				}

				// 請求契約情報取得マップ.督促ステータス ← 督促一意明細.督促ステータス
				if (childTemplate.isNull(ECH0231A010CBSMsg1List.TOKUSOKU_STAT))
				{
					dataMap.put(SEIKY_ADD_KEY_TOKUSOKU_STAT, new String());
				}
				else
				{
					dataMap.put(SEIKY_ADD_KEY_TOKUSOKU_STAT, childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_STAT));
				}

				// 請求契約情報取得マップ.督促ステータス ← 督促一意明細.督促ステータス
				if (childTemplate.isNull(ECH0231A010CBSMsg1List.TOKUSOKU_STAT))
				{
					dataMap.put(MAP_KEY_TOKUSOKU_STAT, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_TOKUSOKU_STAT, childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_STAT));
					String tokuStat = childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_STAT);
					StringBuffer sb = new StringBuffer();
					String dspTokuStatNm = sb.append(tokuStat).append(":").toString();
					dataMap.put(MAP_KEY_TOKUSOKU_STAT_NM, dspTokuStatNm);
				}

				// 請求契約情報取得マップ.督促ステータス名称 ← 督促一意明細.督促ステータス名称
				if (!childTemplate.isNull(ECH0231A010CBSMsg1List.TOKUSOKU_STAT_NM))
				{
// ANK-3396-00-00 2019/01/30 MOD START
//					String tokuStat = childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_STAT);
//					String tokuStatNm = childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_STAT_NM);
//					StringBuffer sb2 = new StringBuffer();
//					String dspTokuStatNm2 = sb2.append(tokuStat).append(":").append(tokuStatNm).toString();
//					dataMap.put(MAP_KEY_TOKUSOKU_STAT_NM, dspTokuStatNm2);
					String tokuStat = childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_STAT);
					String tokuStatNm = childTemplate.getString(ECH0231A010CBSMsg1List.TOKUSOKU_STAT_NM);
					String earlyUseStpTgFlg = childTemplate.getString(ECH0231A010CBSMsg1List.EARLY_USE_STP_TG_FLG);
					int kyoseiDslYkkCnt = 
						JCHStringUtil.isNullBlank((String)dataMap.get(MAP_KEY_KYOSEI_DSL_YKK_CNT)) ?
								0 : Integer.parseInt((String)dataMap.get(MAP_KEY_KYOSEI_DSL_YKK_CNT));
					int wkPrmKyoseiDslYkkKtCnt = 
						JCHStringUtil.isNullBlank((String)dataMap.get(MAP_KEY_KYOSEI_DSL_YKK_KT_CNT)) ?
								0 : Integer.parseInt((String)dataMap.get(MAP_KEY_KYOSEI_DSL_YKK_KT_CNT));

					dataMap.put(MAP_KEY_EARLY_USE_STP_TG_FLG, earlyUseStpTgFlg);

					StringBuffer sb2 = new StringBuffer();
					sb2.append(tokuStat).append(":").append(tokuStatNm);

					//早期利用停止フラグの文言付加
					if ("1".equals(earlyUseStpTgFlg))
					{
						sb2.append("／早期利停");
					}

					//ST15回数の文言付加
					if (kyoseiDslYkkCnt > wkPrmKyoseiDslYkkKtCnt)
					{
						sb2.append("／事務手要");
					}
					else
					{
						sb2.append("／ST15:").append(kyoseiDslYkkCnt).append("回");
					}

					String dspTokuStatNm2 = sb2.toString();
					dataMap.put(MAP_KEY_TOKUSOKU_STAT_NM, dspTokuStatNm2);
// ANK-3396-00-00 2019/01/30 MOD END
				}

				// 請求契約情報取得マップ.支払約束履行判定日 ← 督促一意明細.支払約束履行判定日
				if (!childTemplate.isNull(ECH0231A010CBSMsg1List.PAY_YAKUSOKU_RIKO_YMD))
				{
					dataMap.put(MAP_KEY_PAY_YAKUSOKU_RIKO_YMD, childTemplate.getString(ECH0231A010CBSMsg1List.PAY_YAKUSOKU_RIKO_YMD));
				}

				// 請求契約情報取得マップ.未収金額合計 ← 督促一意明細.未収金額合計
				if (!childTemplate.isNull(ECH0231A010CBSMsg1List.MSU_AMNT_SUM))
				{
					dataMap.put(MAP_KEY_MSU_AMNT_SUM, childTemplate.getString(ECH0231A010CBSMsg1List.MSU_AMNT_SUM));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}

		return param;
	}

	/**
	 * 口座一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0501A010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

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

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}
		templateArray = parentTemplate.getCAANMsgList(EKK0501A010CBSMsg.EKK0501A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 請求契約情報取得マップ.支払い審査結果コード ← 口座一意照会明細.支払い審査結果コード
				if (childTemplate.isNull(EKK0501A010CBSMsg1List.PAY_SKEKKA_CD))
				{
					dataMap.put(MAP_KEY_PAY_SKEKKA_CD, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_PAY_SKEKKA_CD, childTemplate.getString(EKK0501A010CBSMsg1List.PAY_SKEKKA_CD));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}

		return param;
	}

	/**
	 * サービス契約(ヘッダ情報)一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0081B514(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

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

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}
		// 契約状態情報リスト
		SortedMap<String, HashMap<String, String>> keiStatInfoList = new TreeMap<String, HashMap<String, String>>();
		// ＳＹＳＩＤリスト 
		ArrayList<String> sysIdList = new ArrayList<String>();

		templateArray = parentTemplate.getCAANMsgList(EKK0081B514CBSMsg.EKK0081B514CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// サービス契約ステータス、サービス契約ステータス名称、サービス解約理由コード
				String svcKeiStat = JACStrConst.KARA_MOJI;
				String svcKeiStatNm = JACStrConst.KARA_MOJI;
				String svcDlreCdNm = JACStrConst.KARA_MOJI;

				// サービス契約番号一覧照会明細.サービス契約ステータス
				if (!childTemplate.isNull(EKK0081B514CBSMsg1List.SVC_KEI_STAT))
				{
					svcKeiStat = childTemplate.getString(EKK0081B514CBSMsg1List.SVC_KEI_STAT);
					// サービス契約番号一覧照会明細.サービス契約ステータス名称
					if (!childTemplate.isNull(EKK0081B514CBSMsg1List.SVC_KEI_STAT_NM))
					{
						svcKeiStatNm = childTemplate.getString(EKK0081B514CBSMsg1List.SVC_KEI_STAT_NM);
					}
					// 契約状態リストの生成
					HashMap<String, String> keiStatInfo = new HashMap<String, String>();
					keiStatInfo.put(EKK0081B514CBSMsg1List.SVC_KEI_STAT_NM, svcKeiStatNm);
					keiStatInfoList.put(svcKeiStat, keiStatInfo);
				}

				// サービス契約番号一覧照会明細.ＳＹＳＩＤ
				if (!childTemplate.isNull(EKK0081B514CBSMsg1List.SYSID))
				{
					String sysid = childTemplate.getString(EKK0081B514CBSMsg1List.SYSID);
					if (!sysIdList.contains(sysid))
					{
						sysIdList.add(sysid);
					}
				}
			}
		}
		/* ◇請求先情報取得マップへの設定 */
		// ＳＹＳＩＤ
		if (sysIdList.size() == 1)
		{
			dataMap.put(MAP_KEY_SYSID, sysIdList.get(0));
		}
		// ＳＹＳＩＤが複数存在する場合
		else if (sysIdList.size() > 1)
		{
			StringBuffer sysId = new StringBuffer();
			for (int i = 0; i < sysIdList.size(); i++)
			{
				if (i != 0)
				{
					sysId.append(",");
				}
				sysId.append(sysIdList.get(i));
			}
			dataMap.put(MAP_KEY_SYSID, sysId.toString());
		}
		else
		{
			dataMap.put(MAP_KEY_SYSID, JACStrConst.KARA_MOJI);
		}
		// 契約状態
		String keiStat = JACStrConst.KARA_MOJI;
		String svcKeiStat = JACStrConst.KARA_MOJI;
		if (keiStatInfoList.size() > 0)
		{
			svcKeiStat = keiStatInfoList.firstKey();
			HashMap<String, String> info = keiStatInfoList.get(svcKeiStat);

			keiStat = info.get(EKK0081B514CBSMsg1List.SVC_KEI_STAT_NM);
		}
		dataMap.put(MAP_KEY_KEI_STAT, keiStat);
		dataMap.put(MAP_KEY_SVC_KEI_STAT, svcKeiStat);

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}

		return param;
	}

	/**
	 * サービス契約(ヘッダ情報)一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0081B514_2(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

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

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}
		templateArray = parentTemplate.getCAANMsgList(EKK0081B514CBSMsg.EKK0081B514CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 請求先情報取得マップ.サービス契約ステータス ← サービス契約番号一覧照会明細.サービス契約ステータス
				if (childTemplate.isNull(EKK0081B514CBSMsg1List.SVC_KEI_STAT))
				{
					dataMap.put(SEIKY_ADD_KEY_SVC_KEI_STAT, new String());
				}
				else
				{
					dataMap.put(SEIKY_ADD_KEY_SVC_KEI_STAT, childTemplate.getString(EKK0081B514CBSMsg1List.SVC_KEI_STAT));
				}
				
				// 請求先情報取得マップ.請求契約配下サービス契約状態コード ← サービス契約番号一覧照会明細.請求契約配下サービス契約状態コード
				if (childTemplate.isNull(EKK0081B514CBSMsg1List.SKHK_SVKEI_STAT_CD))
				{
					dataMap.put(SEIKY_ADD_KEY_SKHK_SVKEI_STAT_CD, new String());
				}
				else
				{
					dataMap.put(SEIKY_ADD_KEY_SKHK_SVKEI_STAT_CD, childTemplate.getString(EKK0081B514CBSMsg1List.SKHK_SVKEI_STAT_CD));
				}
				
				// 請求先情報取得マップ.請求契約配下サービス契約解約理由識別コード ← サービス契約番号一覧照会明細.請求契約配下サービス契約解約理由識別コード
				if (childTemplate.isNull(EKK0081B514CBSMsg1List.SKHK_SVKEI_DLRE_SKBT_CD))
				{
					dataMap.put(SEIKY_ADD_KEY_SKHK_SVKEI_DLRE_SKBT_CD, new String());
				}
				else
				{
					dataMap.put(SEIKY_ADD_KEY_SKHK_SVKEI_DLRE_SKBT_CD, childTemplate.getString(EKK0081B514CBSMsg1List.SKHK_SVKEI_DLRE_SKBT_CD));
				}
				
				// 請求先情報取得マップ.サービス課金終了年月日 ← サービス契約番号一覧照会明細.サービス課金終了年月日
				if (childTemplate.isNull(EKK0081B514CBSMsg1List.SVC_CHRG_ENDYMD))
				{
					dataMap.put(SEIKY_ADD_KEY_SVC_CHRG_ENDYMD, new String());
				}
				else
				{
					dataMap.put(SEIKY_ADD_KEY_SVC_CHRG_ENDYMD, childTemplate.getString(EKK0081B514CBSMsg1List.SVC_CHRG_ENDYMD));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}

		return param;
	}

	/**
	 * お客様一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECK0011A010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

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

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}
		templateArray = parentTemplate.getCAANMsgList(ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 請求先情報取得マップ.契約者タイプコード ← お客様一意照会明細.契約者タイプコード
				if (childTemplate.isNull(ECK0011A010CBSMsg1List.KEISHA_TYPE_CD))
				{
					dataMap.put(SEIKY_ADD_KEY_KEISHA_TYPE_CD, new String());
				}
				else
				{
					dataMap.put(SEIKY_ADD_KEY_KEISHA_TYPE_CD, childTemplate.getString(ECK0011A010CBSMsg1List.KEISHA_TYPE_CD));
				}

				// 請求先情報取得マップ.契約者タイプコード名称 ← お客様一意照会明細.契約者タイプコード名称
				if (childTemplate.isNull(ECK0011A010CBSMsg1List.KEISHA_TYPE_CD_NM))
				{
					dataMap.put(MAP_KEY_KEISHA_TYPE_CD_NM, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_KEISHA_TYPE_CD_NM, childTemplate.getString(ECK0011A010CBSMsg1List.KEISHA_TYPE_CD_NM));
				}

				// 請求先情報取得マップ.連絡先電話番号 ← お客様一意照会明細.電話番号
				if (childTemplate.isNull(ECK0011A010CBSMsg1List.KEISHA_TELNO))
				{
					dataMap.put(MAP_KEY_RRKS_TELNO, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_RRKS_TELNO, childTemplate.getString(ECK0011A010CBSMsg1List.KEISHA_TELNO));
				}

// IT1-2019-0000043 ADD START
				// 請求先情報取得マップ.卸先事業者コード ← お客様一意照会明細.卸先事業者コード
				if (childTemplate.isNull(ECK0011A010CBSMsg1List.ORSJGS_CD))
				{
					dataMap.put(ORSJGS_CD, new String());
				}
				else
				{
					dataMap.put(ORSJGS_CD, childTemplate.getString(ECK0011A010CBSMsg1List.ORSJGS_CD));
				}
// IT1-2019-0000043 ADD END
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}

		return param;
	}

	/**
	 * 連絡先一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param rrksCdNmMap 連絡先種別コード名称マップ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgECK0201B001(Map<?, ?> msgList, IRequestParameterReadWrite param,
							HashMap<String, Object> rrksCdNmMap) throws Exception
	{

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

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}
		
		// 連絡先メールアドレスリスト
		SortedMap<String, String> rrksMladList = new TreeMap<String, String>();
		// 日中連絡先電話番号リスト
		SortedMap<String, String> nchuRrksTelnoList = new TreeMap<String, String>();

		templateArray = parentTemplate.getCAANMsgList(ECK0201B001CBSMsg.ECK0201B001CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				//連絡先一覧照会明細.連絡方法コード
				String rrkWayCd = JACStrConst.KARA_MOJI;
				if (!childTemplate.isNull(ECK0201B001CBSMsg1List.RRK_WAY_CD))
				{
					rrkWayCd = childTemplate.getString(ECK0201B001CBSMsg1List.RRK_WAY_CD);
				}
				//連絡先一覧照会明細.連絡先種別コード
				String rrksSbtCd = JACStrConst.KARA_MOJI;
				if (!childTemplate.isNull(ECK0201B001CBSMsg1List.RRKS_SBT_CD))
				{
					rrksSbtCd = childTemplate.getString(ECK0201B001CBSMsg1List.RRKS_SBT_CD);
				}

				if (JACStrConst.RRK_WAY_CD_MLAD.equals(rrkWayCd))
				{
					// 連絡先メールアドレスリスト ← 連絡先一覧照会明細.メールアドレス
					if (!childTemplate.isNull(ECK0201B001CBSMsg1List.MLAD))
					{
						if(rrksCdNmMap.containsKey(rrksSbtCd))
						{
							// 表示順取得
							String rrksMladValue = (String)rrksCdNmMap.get(rrksSbtCd);
							// 表示順をキーにマップに格納
							rrksMladList.put(rrksMladValue, childTemplate.getString(ECK0201B001CBSMsg1List.MLAD));
						}
					}
				}

				if (JACStrConst.RRK_WAY_CD_TELNO.equals(rrkWayCd))
				{
					// 日中連絡先電話番号リスト ← 連絡先一覧照会明細.電話番号
					if (!childTemplate.isNull(ECK0201B001CBSMsg1List.TELNO))
					{
						if(rrksCdNmMap.containsKey(rrksSbtCd))
						{
							// 表示順取得
							String rrksTelNoValue = (String)rrksCdNmMap.get(rrksSbtCd);
							// 表示順をキーにマップに格納
							nchuRrksTelnoList.put(rrksTelNoValue, childTemplate.getString(ECK0201B001CBSMsg1List.TELNO));
						}
					}
				}
			}
		}
		
		/* ◇請求先取得マップへ設定 */
		// 連絡先メール
		if (rrksMladList.size() > 0)
		{
			for(String rrksMladKey : rrksMladList.keySet())
			{
				dataMap.put(MAP_KEY_RRKS_MLAD, rrksMladList.get(rrksMladKey));
				if(dataMap.get(MAP_KEY_RRKS_MLAD) != null && !JACStrConst.KARA_MOJI.equals(dataMap.get(MAP_KEY_RRKS_MLAD)))
				{
					break;
				}
			}
		}
		// 日中連絡先電話番号
		if (nchuRrksTelnoList.size() > 0)
		{
			for(String rrksTelNoKey : nchuRrksTelnoList.keySet())
			{
				dataMap.put(MAP_KEY_NCHU_RRKS_TELNO, nchuRrksTelnoList.get(rrksTelNoKey));
				if(dataMap.get(MAP_KEY_NCHU_RRKS_TELNO) != null && !JACStrConst.KARA_MOJI.equals(dataMap.get(MAP_KEY_NCHU_RRKS_TELNO)))
				{
					break;
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}

		return param;
	}
	
	/**
	 * EZM0171A010_コード名称管理一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEZM0171A010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

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

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(EZM0171A010CBSMsg.EZM0171A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 請求先情報取得マップ.コード区分名 ← コード名称管理一意照会明細.コード名称管理一意照会明細
				if (childTemplate.isNull(EZM0171A010CBSMsg1List.CD_DIV_NM))
				{
					dataMap.put(CD_DIV_NM, new String());
				}
				else
				{
					dataMap.put(CD_DIV_NM, childTemplate.getString(EZM0171A010CBSMsg1List.CD_DIV_NM));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}

		return param;
	}

	/**
	 * EZM0171B010_コード名称管理一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> editOutMsgEZM0171B010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

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

		// 業務データ設定
		HashMap<String, HashMap<String, Object>> dataMap = (HashMap<String, HashMap<String, Object>>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, HashMap<String, Object>>();
			param.setData(MAP_CC_ID, dataMap);
		}

		// 連絡先コードマップ
		HashMap<String, Object> rrksCdMap = new HashMap<String, Object>();

		templateArray = parentTemplate.getCAANMsgList(EZM0171B010CBSMsg.EZM0171B010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// コード区分 ← コード名称管理一意照会明細.コード名称管理一意照会明細
				String cdDiv = childTemplate.getString(EZM0171A010CBSMsg1List.CD_DIV);
				
				// 表示順
				String dspJun = childTemplate.getString(EZM0171A010CBSMsg1List.DSP_JUN);
				
				rrksCdMap.put(cdDiv, dspJun);
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}

		return rrksCdMap;
	}

	/**
	 * ECH0501B020_料金スケジュール定義イベント一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void editOutMsgECH0501B020(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(ECH0501B020CBSMsg.ECH0501B020CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 請求先情報取得マップ.請求処理日 ← 料金スケジュール定義イベント一覧照会.イベント年月日
				if (childTemplate.isNull(ECH0501B020CBSMsg1List.EVENT_YMD))
				{
					dataMap.put(MAP_KEY_SEIKY_TRN_DAY, new String());
				}
				else
				{
					dataMap.put(MAP_KEY_SEIKY_TRN_DAY, childTemplate.getString(ECH0501B020CBSMsg1List.EVENT_YMD));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}
	}

	/**
	 * ECH0501B010_料金スケジュール定義一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param eventCd イベントコード
	 * @return boolean
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private boolean editOutMsgECH0501B010(Map<?, ?> msgList, IRequestParameterReadWrite param, String eventCd) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

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

		boolean existSeikyYm = false;
		
		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(ECH0501B010CBSMsg.ECH0501B010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 請求先情報取得マップ.スケジュール定義請求年月 ← 料金スケジュール定義一覧照会明細.請求年月
				if (childTemplate.isNull(ECH0501B010CBSMsg1List.SEIKY_YM))
				{
					dataMap.put("schdl_teigi_seiky_ym", new String());
				}
				else
				{
					dataMap.put("schdl_teigi_seiky_ym", childTemplate.getString(ECH0501B010CBSMsg1List.SEIKY_YM));
					existSeikyYm = true;
					break;
				}
				// 請求先情報取得マップ.契約異動料金計算開始日 ← 料金スケジュール定義イベント一覧照会.イベント年月日
				if (childTemplate.isNull(ECH0501B010CBSMsg1List.EVENT_YMD))
				{
					dataMap.put("event_ymd_" + eventCd, new String());
				}
				else
				{
					dataMap.put("event_ymd_" + eventCd, childTemplate.getString(ECH0501B010CBSMsg1List.EVENT_YMD));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}

		return existSeikyYm;
	}

	/**
	 * ECH0501B020_料金スケジュール定義イベント一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param eventCd イベントコード
	 * @return boolean
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private boolean editOutMsgECH0501B020_2(Map<?, ?> msgList, IRequestParameterReadWrite param, String eventCd) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

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

		boolean existEventYmd = false;
		
		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(ECH0501B020CBSMsg.ECH0501B020CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 請求先情報取得マップ.請求処理日 ← 料金スケジュール定義イベント一覧照会.イベント年月日
				if (childTemplate.isNull(ECH0501B020CBSMsg1List.EVENT_YMD))
				{
					dataMap.put("event_ymd_" + eventCd, new String());
				}
				else
				{
					dataMap.put("event_ymd_" + eventCd, childTemplate.getString(ECH0501B020CBSMsg1List.EVENT_YMD));
					existEventYmd = true;
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}
		return existEventYmd;
	}

	/**
	 * 請求契約一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param standardDay 基準日
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0491A010_2(Map<?, ?> msgList, IRequestParameterReadWrite param, String standardDay) throws Exception
	{

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

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}
		templateArray = parentTemplate.getCAANMsgList(EKK0491A010CBSMsg.EKK0491A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 請求契約情報取得マップ.請求方法コード ← 請求契約一意照会明細.請求方法コード 
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SEIKY_WAY_CD))
				{
					dataMap.put(SEIKY_ADD_KEY_SEIKY_WAY_CD, new String());
				}
				else
				{
					dataMap.put(SEIKY_ADD_KEY_SEIKY_WAY_CD, childTemplate.getString(EKK0491A010CBSMsg1List.SEIKY_WAY_CD));
				}
				
				// 請求契約情報取得マップ.請求方法番号（口座） ← 請求契約一意照会明細.請求方法番号(口座)
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SEIKY_WAY_NO_KOZA))
				{
					dataMap.put(SEIKY_ADD_KEY_SEIKY_WAY_NO_KOZA, new String());
				}
				else
				{
					dataMap.put(SEIKY_ADD_KEY_SEIKY_WAY_NO_KOZA, childTemplate.getString(EKK0491A010CBSMsg1List.SEIKY_WAY_NO_KOZA));
				}
				
				// 請求契約情報取得マップ.請求方法番号(クレジットカード) ← 請求契約一意照会明細.請求方法番号(クレジットカード)
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SEIKY_WAY_NO_CRECARD))
				{
					dataMap.put(SEIKY_ADD_KEY_SEIKY_WAY_NO_CRECARD, new String());
				}
				else
				{
					dataMap.put(SEIKY_ADD_KEY_SEIKY_WAY_NO_CRECARD, childTemplate.getString(EKK0491A010CBSMsg1List.SEIKY_WAY_NO_CRECARD));
				}
				
				// 請求契約情報取得マップ.強制窓口フラグ ← 請求契約一意照会明細.強制窓口フラグ
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.KYOSEI_MADOGUCHI_FLG))
				{
					dataMap.put(SEIKY_ADD_KEY_KYOSEI_MADOGUCHI_FLG, new String());
				}
				else
				{
					dataMap.put(SEIKY_ADD_KEY_KYOSEI_MADOGUCHI_FLG, childTemplate.getString(EKK0491A010CBSMsg1List.KYOSEI_MADOGUCHI_FLG));
				}
				
				// 請求契約情報取得マップ.請求方法適用調整年月日 ← 請求契約一意照会明細.請求方法適用調整年月日
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SEIKY_WAY_APLY_ADJ_YMD))
				{
					dataMap.put(SEIKY_ADD_KEY_SEIKY_WAY_APLY_ADJ_YMD, new String());
				}
				else
				{
					dataMap.put(SEIKY_ADD_KEY_SEIKY_WAY_APLY_ADJ_YMD, childTemplate.getString(EKK0491A010CBSMsg1List.SEIKY_WAY_APLY_ADJ_YMD));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}

		return param;
	}

	/**
	 * 口座一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0501A010_2(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

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

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}
		templateArray = parentTemplate.getCAANMsgList(EKK0501A010CBSMsg.EKK0501A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];
				
				// 請求契約情報取得マップ.口座ステータス ← 口座一意照会明細.口座ステータス
				if (childTemplate.isNull(EKK0501A010CBSMsg1List.KOZA_STAT))
				{
					dataMap.put(SEIKY_ADD_KEY_KOZA_STAT, new String());
				}
				else
				{
					dataMap.put(SEIKY_ADD_KEY_KOZA_STAT, childTemplate.getString(EKK0501A010CBSMsg1List.KOZA_STAT));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}

		return param;
	}

	/**
	 * クレジットカード一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0521A010(Map<?, ?> msgList, IRequestParameterReadWrite param) throws Exception
	{

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

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}
		templateArray = parentTemplate.getCAANMsgList(EKK0521A010CBSMsg.EKK0521A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 請求契約情報取得マップ.クレジットカードステータス ← クレジットカード一意照会明細.クレジットカードステータス
				if (childTemplate.isNull(EKK0521A010CBSMsg1List.CRECARD_STAT))
				{
					dataMap.put(SEIKY_ADD_KEY_CRECARD_STAT, new String());
				}
				else
				{
					dataMap.put(SEIKY_ADD_KEY_CRECARD_STAT, childTemplate.getString(EKK0521A010CBSMsg1List.CRECARD_STAT));
				}
				
				// 請求契約情報取得マップ.クレジットカード無効年月 ← クレジットカード一意照会明細.クレジットカード無効年月
				if (childTemplate.isNull(EKK0521A010CBSMsg1List.CRECA_MK_YM))
				{
					dataMap.put(SEIKY_ADD_KEY_CRECA_MK_YM, new String());
				}
				else
				{
					dataMap.put(SEIKY_ADD_KEY_CRECA_MK_YM, childTemplate.getString(EKK0521A010CBSMsg1List.CRECA_MK_YM));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}

		return param;
	}

	/**
	 * 請求抑止一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @param seikyYoksiCd 請求抑止コード
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0541B501(Map<?, ?> msgList, IRequestParameterReadWrite param, String seikyYoksiCd) throws Exception
	{

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

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

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}
		templateArray = parentTemplate.getCAANMsgList(EKK0541B501CBSMsg.EKK0541B501CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				String targetCd = "";
				if (!childTemplate.isNull(EKK0541B501CBSMsg1List.SEIKY_YOKSI_CD))
				{
					targetCd = childTemplate.getString(EKK0541B501CBSMsg1List.SEIKY_YOKSI_CD);
				}

				if (seikyYoksiCd.equals(targetCd))
				{
					// 請求契約情報取得マップ.請求抑止フラグ ← 請求抑止一覧照会明細.請求抑止フラグ
					if (childTemplate.isNull(EKK0541B501CBSMsg1List.SEIKY_YOKSI_FLG))
					{
						dataMap.put(SEIKY_ADD_KEY_SEIKY_YOKSI_FLG, new String());
					}
					else
					{
						dataMap.put(SEIKY_ADD_KEY_SEIKY_YOKSI_FLG, childTemplate.getString(EKK0541B501CBSMsg1List.SEIKY_YOKSI_FLG));
					}
					break;
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		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));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			/* TODO : 例外通知を見直し */
			throw new Exception();
			//			throw new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, (Integer)return_code);
		}

		return param;
	}
	// ▲▲ サービスIF用メッセージ取得処理 ▲▲

	// ▼▼ エラー情報マッピング処理 ▼▼

	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param
						, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{

		for (CAANMsg template : templates)
		{
			String templateId = template.getString("templateID");
			CAANMsg[] workTemplates = { template };
			if (TEMPLATE_ID_EKK0491A010.equals(templateId))
			{
				// 請求契約一意照会
				editErrorInfoEKK0491A010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_ECH0231A010.equals(templateId))
			{
				// 督促一意照会
				editErrorInfoECH0231A010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EKK0501A010.equals(templateId))
			{
				// 口座一意照会
				editErrorInfoEKK0501A010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EKK0081B514.equals(templateId))
			{
				// サービス契約(ヘッダ情報)一覧照会
				editErrorInfoEKK0081B514(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_ECK0011A010.equals(templateId))
			{
				// お客様一意照会
				editErrorInfoECK0011A010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_ECK0201B001.equals(templateId))
			{
				// 連絡先一覧照会
				editErrorInfoECK0201B001(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EZM0171A010.equals(templateId))
			{
				// コード名称管理
				editErrorInfoEZM0171A010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EZM0171B010.equals(templateId))
			{
				// コード名称管理
				editErrorInfoEZM0171B010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_ECH0501B020.equals(templateId))
			{
				//  料金スケジュール定義イベント一覧照会
				editErrorInfoECH0501B020(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_ECH0501B010.equals(templateId))
			{
				//  料金スケジュール定義一覧照会
				editErrorInfoECH0501B010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EKK0521A010.equals(templateId))
			{
				//  クレジットカード一意照会
				editErrorInfoEKK0521A010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EKK0541B501.equals(templateId))
			{
				//  請求抑止一覧照会
				editErrorInfoEKK0541B501(param, workTemplates, returnCode);
			}
		}

		return param;
	}

	/**
	 * 請求契約一意照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoEKK0491A010(IRequestParameterReadWrite param
						, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

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

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

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

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

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

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

		// 請求契約一意照会マップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号 のエラー情報返却
		if (!template.isNull(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR))
			{
				inMap.put(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR, template.getString(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}
		// 請求契約一意照会マップ.ＫＥＹ＿世代登録年月日時分秒 → ＫＥＹ＿世代登録年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
			{
				inMap.put(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR, template.getString(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}

		return param;
	}

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

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

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

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

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

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

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

		// 督促一意照会マップ.ＫＥＹ＿督促番号 → ＫＥＹ＿督促番号 のエラー情報返却
		if (!template.isNull(ECH0231A010CBSMsg.KEY_TOKUSOKU_NO_ERR))
		{
			if (!inMap.containsKey(ECH0231A010CBSMsg.KEY_TOKUSOKU_NO_ERR))
			{
				inMap.put(ECH0231A010CBSMsg.KEY_TOKUSOKU_NO_ERR, template.getString(ECH0231A010CBSMsg.KEY_TOKUSOKU_NO_ERR));
			}
		}
		// 督促一意照会マップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号 のエラー情報返却
		if (!template.isNull(ECH0231A010CBSMsg.KEY_SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(ECH0231A010CBSMsg.KEY_SEIKY_KEI_NO_ERR))
			{
				inMap.put(ECH0231A010CBSMsg.KEY_SEIKY_KEI_NO_ERR, template.getString(ECH0231A010CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}

		return param;
	}

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

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

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

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

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

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

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

		// 口座一意照会マップ.ＫＥＹ＿世代登録年月日時分秒 → ＫＥＹ＿世代登録年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK0501A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey(EKK0501A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
			{
				inMap.put(EKK0501A010CBSMsg.KEY_GENE_ADD_DTM_ERR, template.getString(EKK0501A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}

		return param;
	}

	/**
	 * サービス契約(ヘッダ情報)一覧照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoEKK0081B514(IRequestParameterReadWrite param
						, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

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

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

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

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

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

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

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

		return param;
	}

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

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

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

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

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

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

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

		// お客様一意照会マップ.ＫＥＹ＿世代登録年月日時分秒 → ＫＥＹ＿世代登録年月日時分秒 のエラー情報返却
		if (!template.isNull(ECK0011A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey(ECK0011A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
			{
				inMap.put(ECK0011A010CBSMsg.KEY_GENE_ADD_DTM_ERR, template.getString(ECK0011A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}

		return param;
	}

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

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

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

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

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

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

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

		// 連絡先一覧照会マップ.ＫＥＹ＿SYSID → ＫＥＹ＿SYSID のエラー情報返却
		if (!template.isNull(ECK0201B001CBSMsg.KEY_SYSID_ERR))
		{
			if (!inMap.containsKey(ECK0201B001CBSMsg.KEY_SYSID_ERR))
			{
				inMap.put(ECK0201B001CBSMsg.KEY_SYSID_ERR, template.getString(ECK0201B001CBSMsg.KEY_SYSID_ERR));
			}
		}

		// 連絡先一覧照会マップ.ＫＥＹ＿連絡先コード → ＫＥＹ＿連絡先コード のエラー情報返却
		if (!template.isNull(ECK0201B001CBSMsg.KEY_RRKS_CD_ERR))
		{
			if (!inMap.containsKey(ECK0201B001CBSMsg.KEY_RRKS_CD_ERR))
			{
				inMap.put(ECK0201B001CBSMsg.KEY_RRKS_CD_ERR, template.getString(ECK0201B001CBSMsg.KEY_RRKS_CD_ERR));
			}
		}

		// 連絡先一覧照会マップ.ＫＥＹ＿連絡方法コード → ＫＥＹ＿連絡方法コード のエラー情報返却
		if (!template.isNull(ECK0201B001CBSMsg.KEY_RRK_WAY_CD_ERR))
		{
			if (!inMap.containsKey(ECK0201B001CBSMsg.KEY_RRK_WAY_CD_ERR))
			{
				inMap.put(ECK0201B001CBSMsg.KEY_RRK_WAY_CD_ERR, template.getString(ECK0201B001CBSMsg.KEY_RRK_WAY_CD_ERR));
			}
		}

		// 連絡先一覧照会マップ.ＫＥＹ＿連絡先種別コード → ＫＥＹ＿連絡先種別コード のエラー情報返却
		if (!template.isNull(ECK0201B001CBSMsg.KEY_RRKS_SBT_CD_ERR))
		{
			if (!inMap.containsKey(ECK0201B001CBSMsg.KEY_RRKS_SBT_CD_ERR))
			{
				inMap.put(ECK0201B001CBSMsg.KEY_RRKS_SBT_CD_ERR, template.getString(ECK0201B001CBSMsg.KEY_RRKS_SBT_CD_ERR));
			}
		}

		return param;
	}

	/**
	 * コード名称管理一意照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoEZM0171A010(IRequestParameterReadWrite param
						, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EZM0171A010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

		// コード名称管理一意照会.ＫＥＹ＿コード種別コード → ＫＥＹ＿コード種別コード のエラー情報返却
		if (!template.isNull(EZM0171A010CBSMsg.KEY_CD_SBT_CD_ERR))
		{
			if (!inMap.containsKey("key_cd_sbt_cd_err"))
			{
				inMap.put("key_cd_sbt_cd_err", template.getString(EZM0171A010CBSMsg.KEY_CD_SBT_CD_ERR));
			}
		}
		// コード名称管理一意照会.ＫＥＹ＿コード区分 → ＫＥＹ＿コード区分 のエラー情報返却
		if (!template.isNull(EZM0171A010CBSMsg.KEY_CD_DIV_ERR))
		{
			if (!inMap.containsKey("key_cd_div_err"))
			{
				inMap.put("key_cd_div_err", template.getString(EZM0171A010CBSMsg.KEY_CD_DIV_ERR));
			}
		}

		return param;
	}

	/**
	 * コード名称管理一覧照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoEZM0171B010(IRequestParameterReadWrite param
						, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EZM0171B010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

		// コード名称管理一意照会.ＫＥＹ＿コード種別コード → ＫＥＹ＿コード種別コード のエラー情報返却
		if (!template.isNull(EZM0171B010CBSMsg.KEY_CD_SBT_CD_ERR))
		{
			if (!inMap.containsKey("key_cd_sbt_cd_err"))
			{
				inMap.put("key_cd_sbt_cd_err", template.getString(EZM0171B010CBSMsg.KEY_CD_SBT_CD_ERR));
			}
		}

		return param;
	}

	/**
	 * 料金スケジュール定義イベント一覧照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoECH0501B020(IRequestParameterReadWrite param
						, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0501B020CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

		// 料金スケジュール定義イベント一覧照会.ＫＥＹ＿イベントコードエラー → ＫＥＹ＿イベントコード のエラー情報返却
		if (!template.isNull(ECH0501B020CBSMsg.KEY_EVENT_CD_ERR))
		{
			if (!inMap.containsKey("key_event_cd_err"))
			{
				inMap.put("key_event_cd_err", template.getString(ECH0501B020CBSMsg.KEY_EVENT_CD_ERR));
			}
		}

		// 料金スケジュール定義イベント一覧照会.ＫＥＹ＿請求年月エラー → ＫＥＹ＿請求年月 のエラー情報返却
		if (!template.isNull(ECH0501B020CBSMsg.KEY_SEIKY_YM_ERR))
		{
			if (!inMap.containsKey("key_seiky_ym_err"))
			{
				inMap.put("key_seiky_ym_err", template.getString(ECH0501B020CBSMsg.KEY_SEIKY_YM_ERR));
			}
		}

		return param;
	}

	/**
	 * 料金スケジュール定義一覧照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoECH0501B010(IRequestParameterReadWrite param
						, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECH0501B010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

		// 料金スケジュール定義一覧照会.ＫＥＹ＿イベントコードエラー → ＫＥＹ＿イベントコード のエラー情報返却
		if (!template.isNull(ECH0501B010CBSMsg.KEY_EVENT_CD_ERR))
		{
			if (!inMap.containsKey("key_event_cd_err"))
			{
				inMap.put("key_event_cd_err", template.getString(ECH0501B010CBSMsg.KEY_EVENT_CD_ERR));
			}
		}

		// 料金スケジュール定義一覧照会.ＫＥＹ＿基準年月日 → ＫＥＹ＿基準年月日 のエラー情報返却
		if (!template.isNull(ECH0501B010CBSMsg.KEY_STDARDYMD_ERR))
		{
			if (!inMap.containsKey("key_stdardymd_err"))
			{
				inMap.put("key_stdardymd_err", template.getString(ECH0501B010CBSMsg.KEY_STDARDYMD_ERR));
			}
		}

		return param;
	}

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

		int templateStatus = template.getInt(EKK0521A010CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

		// クレジットカード一意照会.ＫＥＹ＿請求方法番号(クレジットカード)エラー → ＫＥＹ＿請求方法番号(クレジットカード) のエラー情報返却
		if (!template.isNull(EKK0521A010CBSMsg.KEY_SEIKY_WAY_NO_CRECARD_ERR))
		{
			if (!inMap.containsKey("key_seiky_way_no_crecard_err"))
			{
				inMap.put("key_seiky_way_no_crecard_err", template.getString(EKK0521A010CBSMsg.KEY_SEIKY_WAY_NO_CRECARD_ERR));
			}
		}

		// クレジットカード一意照会.ＫＥＹ＿世代登録年月日時分秒エラー → ＫＥＹ＿世代登録年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK0521A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey("key_gene_add_dtm_err"))
			{
				inMap.put("key_gene_add_dtm_err", template.getString(EKK0521A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}

		return param;
	}

	/**
	 * 請求抑止一覧照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoEKK0541B501(IRequestParameterReadWrite param
						, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0541B501CBSMsg.STATUS);
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

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

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

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

		// 請求抑止一覧照会.ＫＥＹ＿請求契約番号エラー → ＫＥＹ＿請求契約番号 のエラー情報返却
		if (!template.isNull(EKK0541B501CBSMsg.KEY_SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey("key_seiky_kei_no_err"))
			{
				inMap.put("key_seiky_kei_no_err", template.getString(EKK0541B501CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}

		// 請求抑止一覧照会.ＫＥＹ＿請求抑止フラグエラー → ＫＥＹ＿請求抑止フラグ のエラー情報返却
		if (!template.isNull(EKK0541B501CBSMsg.KEY_SEIKY_YOKSI_FLG_ERR))
		{
			if (!inMap.containsKey("key_seiky_yoksi_flg_err"))
			{
				inMap.put("key_seiky_yoksi_flg_err", template.getString(EKK0541B501CBSMsg.KEY_SEIKY_YOKSI_FLG_ERR));
			}
		}

		return param;
	}
	// ▼▼ 判定処理 ▼▼

	/**
	 * 請求契約情報が存在するか判定します。 <br>
	 * 
	 * @param param リクエストパラメータ
	 * @return isExist
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private boolean isExistSeikyKeiInfo(IRequestParameterReadWrite param) throws RequestParameterException
	{
		boolean isExist = false;

		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap.get(MAP_KEY_SEIKY_KEI_STAT_NM) != null && JACStrConst.KARA_MOJI.equals(dataMap.get(MAP_KEY_SEIKY_KEI_STAT_NM)) == false)
		{
			isExist = true;
		}

		return isExist;
	}

	/**
	 * 請求方法番号（口座）が存在するか判定します。 <br>
	 * 
	 * @param param リクエストパラメータ
	 * @return isExist
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private boolean isExistSeikyWayNoKoza(IRequestParameterReadWrite param) throws RequestParameterException
	{
		boolean isExist = false;

		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap.get(MAP_KEY_SEIKY_WAY_NO_KOZA) != null 
				&& JACStrConst.KARA_MOJI.equals(dataMap.get(MAP_KEY_SEIKY_WAY_NO_KOZA).toString().trim()) == false)
		{
			isExist = true;
		}

		return isExist;
	}

	/**
	 * ＳＹＳＩＤが存在するか判定します。 <br>
	 * @return isExist
	 * @param param リクエストパラメータ
	 * 
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private boolean isExistSysId(IRequestParameterReadWrite param) throws RequestParameterException
	{
		boolean isExist = false;

		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap.get(MAP_KEY_SYSID) != null && JACStrConst.KARA_MOJI.equals(dataMap.get(MAP_KEY_SYSID)) == false)
		{
			isExist = true;
		}

		return isExist;
	}

	/**
	 * ＳＹＳＩＤが複数存在するか判定します。 <br>
	 * 
	 * @param param リクエストパラメータ
	 * @return isExist
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private boolean isExistSysIdMulti(IRequestParameterReadWrite param) throws RequestParameterException
	{
		boolean isExist = false;

		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap.get(MAP_KEY_SYSID) != null && JACStrConst.KARA_MOJI.equals(dataMap.get(MAP_KEY_SYSID)) == false)
		{
			String sysId = (String)dataMap.get(MAP_KEY_SYSID);
			String[] sysIds = sysId.split(",");
			
			if (sysIds.length > 1)
			{
				isExist = true;
			}
		}

		return isExist;
	}

	/**
	 * 督促データが存在するか判定します。 <br>
	 * 
	 * @param param リクエストパラメータ
	 * @return isExist
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private boolean isExistTokusokuData(IRequestParameterReadWrite param) throws RequestParameterException
	{
		boolean isExist = false;

		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
		if (dataMap.get(MAP_KEY_TOKUSOKU_STAT) != null && JACStrConst.KARA_MOJI.equals(dataMap.get(MAP_KEY_TOKUSOKU_STAT)) == false)
		{
			isExist = true;
		}

		return isExist;
	}

	/**
	 * 請求年月が存在するか判定します。 <br>
	 * 
	 * @param param リクエストパラメータ
	 * @return isExist
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private boolean isExistSeikyYm(IRequestParameterReadWrite param) throws RequestParameterException
	{
		boolean isExist = false;

		HashMap<String, Object> data1Map = (HashMap<String, Object>)param.getData(CHSV000701SC);
		HashMap<String, Object> data3Map = (HashMap<String, Object>)param.getData(CHSV000703SC);
		
		if (data3Map != null)
		{
			String keySeikyYm = (String)data3Map.get(KEY_SEIKY_YM);
			if (keySeikyYm != null && !JACStrConst.KARA_MOJI.equals(keySeikyYm))
			{
				isExist = true;
			}
			else if (data1Map != null)
			{
				ArrayList ech0051B010List = (ArrayList)data1Map.get(ECH0051B010CBSMSG1LIST);
				if (ech0051B010List != null && ech0051B010List.size() > 0)
				{
					isExist = true;
				}
			}
		}

		return isExist;
	}
	// ▲▲ 判定処理 ▲▲

	// ▼▼ クラス内共通処理 ▼▼

	/**
	 * サービスインタフェースに渡すパラメータマップを新規に作成します。 マップには共通項目である電文ヘッダ、コントロールマップを設定します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return paramMap
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	private HashMap<String, Object> createNewParamMap(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

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

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

		return paramMap;
	}

	/**
	 * テンプレートの共通項目を設定します。 <br>
	 * 
	 * @param param リクエストパラメータ
	 * @param template テンプレート
	 * @param templateIdKey テンプレートIDキー名
	 * @param templateIdVal テンプレートID値
	 * @param templateFuncCdKey テンプレート機能コードキー名
	 * @return template
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	private CAANMsg setTemplateCommonItem(IRequestParameterReadWrite param, CAANMsg template
						, String templateIdKey, String templateIdVal, String templateFuncCdKey)
			throws RequestParameterException
	{
		// テンプレートID
		template.set(templateIdKey, templateIdVal);

		// 機能コード（デフォルト：１）
		template.set(templateFuncCdKey, "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);

		return template;
	}

	/**
	 * 請求先情報取得マップのOUT項目全てに空文字を設定します。 <br>
	 * 
	 * @param param リクエストパラメータ
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private void setEmptyOutItems(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

		// 請求契約ステータス名称
		dataMap.put(MAP_KEY_SEIKY_KEI_STAT_NM, JACStrConst.KARA_MOJI);
		// 請求方法コード名称
		dataMap.put(MAP_KEY_SEIKY_WAY_CD_NM, JACStrConst.KARA_MOJI);
		// 請求方法番号（口座）
		dataMap.put(MAP_KEY_SEIKY_WAY_NO_KOZA, JACStrConst.KARA_MOJI);
		// 請求書発行要否名称
		dataMap.put(MAP_KEY_SEIKYUS_HAKKO_YH_NM, JACStrConst.KARA_MOJI);
		// 送付先カナ名
		dataMap.put(MAP_KEY_SHS_KANA, JACStrConst.KARA_MOJI);
		// 送付先名
		dataMap.put(MAP_KEY_SOHUS_NM, JACStrConst.KARA_MOJI);
		// 送付先郵便番号
		dataMap.put(MAP_KEY_SOHUS_PCD, JACStrConst.KARA_MOJI);
		// 送付先都道府県名
		dataMap.put(MAP_KEY_SOHUS_STATE_NM, JACStrConst.KARA_MOJI);
		// 送付先市区町村名
		dataMap.put(MAP_KEY_SOHUS_CITY_NM, JACStrConst.KARA_MOJI);
		// 送付先大字通称名
		dataMap.put(MAP_KEY_SOHUS_OAZTSU_NM, JACStrConst.KARA_MOJI);
		// 送付先字丁目名
		dataMap.put(MAP_KEY_SOHUS_AZCHO_NM, JACStrConst.KARA_MOJI);
		// 送付先住所補記・建物名
		dataMap.put(MAP_KEY_SOHUS_ADRTTM, JACStrConst.KARA_MOJI);
		// 送付先住所補記・部屋番号
		dataMap.put(MAP_KEY_SOHUS_ADRRM, JACStrConst.KARA_MOJI);
		// 送付先番地号
		dataMap.put(MAP_KEY_SOHUS_BNCHIGO, JACStrConst.KARA_MOJI);
		// 督促ステータス
		dataMap.put(MAP_KEY_TOKUSOKU_STAT, JACStrConst.KARA_MOJI);
		// 督促ステータス名称
		dataMap.put(MAP_KEY_TOKUSOKU_STAT_NM, JACStrConst.KARA_MOJI);
		// 支払約束履行判定日
		dataMap.put(MAP_KEY_PAY_YAKUSOKU_RIKO_YMD, JACStrConst.KARA_MOJI);
		// 未収金額合計
		dataMap.put(MAP_KEY_MSU_AMNT_SUM, JACStrConst.KARA_MOJI);
		// 支払い審査結果コード
		dataMap.put(MAP_KEY_PAY_SKEKKA_CD, JACStrConst.KARA_MOJI);
		// 契約状態
		dataMap.put(MAP_KEY_KEI_STAT, JACStrConst.KARA_MOJI);
		// 契約状態
		dataMap.put(MAP_KEY_SVC_KEI_STAT, JACStrConst.KARA_MOJI);
		// ＳＹＳＩＤ
		dataMap.put(MAP_KEY_SYSID, JACStrConst.KARA_MOJI);
		// 契約者タイプコード名称
		dataMap.put(MAP_KEY_KEISHA_TYPE_CD_NM, JACStrConst.KARA_MOJI);
		// 連絡先メール
		dataMap.put(MAP_KEY_RRKS_MLAD, JACStrConst.KARA_MOJI);
		// 連絡先電話番号
		dataMap.put(MAP_KEY_RRKS_TELNO, JACStrConst.KARA_MOJI);
		// 日中連絡先電話番号
		dataMap.put(MAP_KEY_NCHU_RRKS_TELNO, JACStrConst.KARA_MOJI);
		// 督促番号
		dataMap.put(SEIKY_ADD_KEY_TOKUSOKU_NO, JACStrConst.KARA_MOJI);
		// 契約者タイプコード
		dataMap.put(SEIKY_ADD_KEY_KEISHA_TYPE_CD, JACStrConst.KARA_MOJI);
		// 請求契約配下サービス契約状態コード
		dataMap.put(SEIKY_ADD_KEY_SKHK_SVKEI_STAT_CD, JACStrConst.KARA_MOJI);
		// 請求契約配下サービス契約解約理由識別コード
		dataMap.put(SEIKY_ADD_KEY_SKHK_SVKEI_DLRE_SKBT_CD, JACStrConst.KARA_MOJI);
		// サービス課金終了年月日
		dataMap.put(SEIKY_ADD_KEY_SVC_CHRG_ENDYMD, JACStrConst.KARA_MOJI);
		// 請求作成ボタン非活性制御値
		dataMap.put(SEIKY_ADD_KEY_DSBL_CTL_JSF_BTN_SEIKY_ADD, JACStrConst.KARA_MOJI);
	}
	
	/**
	 * 「督促なし」名称を設定します。 <br>
	 * 
	 * @param param リクエストパラメータ
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private void setTokusokuStatNm(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);

		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_CC_ID, dataMap);
		}

		// コード区分 + ":" + 請求先情報取得マップキー(コード区分名)
		StringBuffer sb = new StringBuffer();
// ANK-3396-00-00 2019/02/08 MOD START
//		String tokusokuNm = sb.append(JACStrConst.TOKUSOKU_STAT_NASHI).append(":").append(dataMap.get(CD_DIV_NM)).toString();
		sb.append(JACStrConst.TOKUSOKU_STAT_NASHI).append(":").append(dataMap.get(CD_DIV_NM));

		int kyoseiDslYkkCnt = 
			JCHStringUtil.isNullBlank((String)dataMap.get(MAP_KEY_KYOSEI_DSL_YKK_CNT)) ?
					0 : Integer.parseInt((String)dataMap.get(MAP_KEY_KYOSEI_DSL_YKK_CNT));
		int wkPrmKyoseiDslYkkKtCnt = 
			JCHStringUtil.isNullBlank((String)dataMap.get(MAP_KEY_KYOSEI_DSL_YKK_KT_CNT)) ?
					0 : Integer.parseInt((String)dataMap.get(MAP_KEY_KYOSEI_DSL_YKK_KT_CNT));

		//ST15回数の文言付加
		if (kyoseiDslYkkCnt > wkPrmKyoseiDslYkkKtCnt)
		{
			sb.append("／事務手要");
		}
		else
		{
			sb.append("／ST15:").append(kyoseiDslYkkCnt).append("回");
		}

		String tokusokuNm = sb.toString();
// ANK-3396-00-00 2019/02/08 MOD END

		// 請求先情報取得マップキー(督促ステータス名称) 
		dataMap.put(MAP_KEY_TOKUSOKU_STAT_NM, tokusokuNm);
	}

	/**
	 *  請求作成情報を取得します。 <br>
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return isExist
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	private void getSeikyAddInfo(SessionHandle handle, IRequestParameterReadWrite param) throws Exception
	{
		// 料金調整画面(請求作成)の場合のみ処理実施
		HashMap<String, Object> in25Map = (HashMap<String, Object>)param.getData("CHSV002501SC");
		HashMap<String, Object> in78Map = (HashMap<String, Object>)param.getData("CHSV007801SC");
		
		if (in25Map != null)
		{
			String dsblCtlValue = JACStrConst.CTL_VALUE_TRUE;
			String kyoseiMadoguchiYoksiFlg = JACStrConst.CTL_VALUE_FALSE;
			
			// ◇料金スケジュール定義一覧照会サービスインターフェイス(対象年月取得)
			if (execECH0501B010(handle, param, JACStrConst.EVENT_CD_IDO_CALC_STAYMD))
			{
				// ◇料金スケジュール定義イベント一覧照会サービスインターフェイス(料金計算日取得)
				if (execECH0501B020_2(handle, param, JACStrConst.EVENT_CD_PRC_CALC_DAY))
				{
					// ◇料金スケジュール定義イベント一覧照会サービスインターフェイス(請求処理日取得)
					if (execECH0501B020_2(handle, param, JACStrConst.EVENT_CD_SIKY_TRN_DAY))
					{
						HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
						
						// 料金計算日
						String prcCalcDay = (String)dataMap.get("event_ymd_" + JACStrConst.EVENT_CD_PRC_CALC_DAY);
						// 請求処理日
						String seikyTrnDay = (String)dataMap.get("event_ymd_" + JACStrConst.EVENT_CD_SIKY_TRN_DAY);
						// 請求年月
						String seikyYm = (String)dataMap.get("schdl_teigi_seiky_ym");
						// 運用日
						String opeDate = JCCBPCommon.getOpeDate(null);
						
						/* 請求作成ボタン活性制御判定 */
						// 料金計算日 < 運用日 かつ 運用日<= 請求処理日の場合
						if (prcCalcDay.compareTo(opeDate) < 0 && opeDate.compareTo(seikyTrnDay) <= 0)
						{
							dsblCtlValue = JACStrConst.CTL_VALUE_FALSE;
						}
						
						/* 強制窓口抑止判定 */
						if (JACStrConst.CTL_VALUE_FALSE.equals(dsblCtlValue))
						{
							// ◇請求契約一意照会サービスインターフェイス
							execEKK0491A010_2(handle, param, prcCalcDay);
							// ◇請求抑止一覧照会
							execEKK0541B501(handle, param, JACStrConst.SEIKY_YOKSI_CD_KYOSEI_MDGC);
							
							if (!JCHCommonFormatUtil.isNull(dataMap.get(SEIKY_ADD_KEY_SEIKY_WAY_NO_KOZA)))
							{
								// ◇口座一意照会サービスインターフェイス */
								execEKK0501A010_2(handle, param);
							}
							else if (!JCHCommonFormatUtil.isNull(dataMap.get(SEIKY_ADD_KEY_SEIKY_WAY_NO_CRECARD)))
							{
								// ◇クレジットカード一意照会サービスインターフェイス */
								execEKK0521A010(handle, param);
							}
							
							// 請求方法コード判定
							String seikyWayCd = JCHCommonFormatUtil.seikyWayJudge((String)dataMap.get(SEIKY_ADD_KEY_SEIKY_WAY_CD)
																				, (String)dataMap.get(SEIKY_ADD_KEY_KOZA_STAT)
																				, (String)dataMap.get(SEIKY_ADD_KEY_CRECARD_STAT)
																				, (String)dataMap.get(SEIKY_ADD_KEY_CRECA_MK_YM)
																				, seikyYm
																				, (String)dataMap.get(SEIKY_ADD_KEY_SEIKY_WAY_APLY_ADJ_YMD));
							
							String ret[] = JCHCommonFormatUtil.seikyWayJudge(seikyWayCd
																		  , (String)dataMap.get(SEIKY_ADD_KEY_SEIKY_YOKSI_FLG)
																		  , (String)dataMap.get(SEIKY_ADD_KEY_KYOSEI_MADOGUCHI_FLG));
							
							kyoseiMadoguchiYoksiFlg = ret[1];
						}
					}
				}
			}
			
			HashMap<String, Object> outMap = (HashMap<String, Object>)param.getData(MAP_CC_ID);
			// 請求作成ボタン活性制御値
			outMap.put("dsbl_ctl_jsf_btn_seiky_add", dsblCtlValue); 
			// 強制窓口抑止フラグ
			outMap.put("kyosei_madoguchi_yoksi_flg", kyoseiMadoguchiYoksiFlg); 
		}
		else if (in78Map != null)
		{
			// ◇サービス契約(ヘッダ情報)一覧照会(請求契約配下情報取得)
			execEKK0081B514_2(handle, param);
		}
	}
	
	// ▲▲ クラス内共通処理 ▲▲

}