/*********************************************************************
*	All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名		：eo顧客基幹システム
*	モジュール名	：JKKSsnPrcCalcCC
*	ソースファイル名：JKKSsnPrcCalcCC.java
*	作成者			：FJ）澤田
*	日付			：2018年01月31日
*＜機能概要＞ 
*	精算金計算部品
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v36.00.00	2018/02/09	FJ）澤田	新規作成【ANK-3296-00-00】
*	v36.01.00	2018/03/13	FJ）原田	ST-2018-0000010_即割なし時の即割解約精算金項目表示不正
*	v36.02.00	2018/03/13	FJ）原田	ST-2018-0000011_標準工事費残金項目表示不正エラー
*	v36.03.00	2018/04/09	FJ）原田	OM-2018-0000353_長割表示不正
*	v37.00.00	2018/05/04	FJ) 原田	ANK-3383-00-00_標準工事費分割請求(STEP2)
*	v37.00.01	2018/05/16	FJ) 原田	ANK-3383-06-00_標準工事費分割請求(STEP2)仕様変更０６
*	v37.01.00	2018/05/23	FJ) 原田	IT1-2018-0000071_標準工事費相当額キャンペーンの精算金計算結果不備対応
*	v37.02.00	2018/05/25	FJ) 原田	IT1-2018-0000072_標準工事費相当額キャンペーンの精算金計算結果不備対応
*	v37.03.00	2018/05/28	FJ) 原田	IT1-2018-0000074_スターｃｈセット割の解約精算金計算不正対応
*	v37.04.00	2018/06/07	FJ) 原田	IT2-2018-0000050_運用日が1日〜料金計算日の期間と、料金計算日後の期間でのタブレット割賦残回数の算出値が異なる
*	v37.05.00	2018/06/07	FJ) 原田	IT2-2018-0000051_割賦初回請求前のタブレット精算金の計算時に継続月数を1で計算する仕様の漏れ対応
*	v37.06.00	2018/06/12	FJ) 原田	IT2-2018-0000056_スマートリンク精算金の結果が1ヶ月ずれる
*	v37.07.00	2018/06/13	FJ) 原田	OM-2018-0000648_即割・長割の解約精算金が旧制度なのに新制度として計算されている
*	v37.06.01	2018/06/12	FJ) 原田	IT2-2018-0000056_水平展開対応
*	v40.00.00	2019/01/11	FJ) 三原	OM-2019-0000041_長期継続割の付いた100Mライトコースの解約精算金の計算をするとエラー
*	v41.00.00	2019/02/20	FJ) 三原	ANK-3412-03-00_【５ギガ・１０ギガ】特約プログラム対応
*	v44.00.00	2019/06/05	FJ) 原田	OM-2019-0000578_精算金計算画面でサービス開始していないSTBの計算するとシステムエラー
*	v44.00.00	2019/07/11	FJ) 中原	OM-2019-0000754_精算金画面の計算ボタンでテレビエラー
*	v45.00.00	2019/07/16	FJ) 後藤	ANK-3636-00-00_消費税対応
*	v45.00.01	2019/08/01	FJ) 三原	ANK-3636-08-00_解約精算金画面で未来日解約を指定時の10%対応
*	v45.00.02	2019/08/20	FJ) 三原	IT1-2019-0000066_テレビの解約精算金画面が10%で表示されない
*	v45.00.03	2019/09/05	FJ) 三原	ANK-3636-08-00_解約精算金画面で未来日解約を指定時の10%対応_暫定対応の戻し
*	v45.00.04	2019/09/05	FJ) 三原	OM-2019-0000906_新長割の初月解約対応
*	v48.00.00	2020/02/15	FJ) Dave	ANK-3675-00-00
*	v48.00.01	2020/03/16	FJ) 星野	IT2-2020-0000010
*	v49.00.00	2020/06/04	FJ) 星野	ANK-3865-00-00
*	v50.00.00	2020/09/17	FJ) 吉田	OM-2020-000939
*	v53.00.00	2021/04/14	FJ) 平野	ANK-3951-00-00_「競争ルールの検証に関するWG」に関するシステム対応
*	v53.00.01	2021/05/27	FJ) 平野	IT1-2021-0000040_標準工事費相当額ＣＰ一括払いの残数が表示されない
*	v53.00.02	2021/06/15	FJ) 杉本	OM-2021-0000557_精算金計算画面での計算処理誤り
*	v54.00.00	2021/08/26	FJ) 上村	OM-2021-0000276：精算金詳細画面表示不正
*	v55.00.00	2021/10/26	FJ) 舘山	OM-2021-0001282 解約予定日が課金開始前で計算するとシステムエラー
*	v56.00.00	2021/01/06	FJ) 吉村	OM-2021-0002016_解約精算金計算画面(標準工事費残金の計算誤り)
*	v59.00.00	2022/05/24	FJ) 麻生	ANK-4248-00-00_消費者保護ガイドライン改正対応
*	v59.00.01	2022/05/24	FJ) 麻生	ANK-4248-03-00_消費者保護ガイドライン改正対応／【仕変03】工事費相当額割引の見直し（6末対応）
*	v59.00.02	2022/05/24	FJ) 麻生	OM-2022-0000518_精算金計算画面での相当額CP残回数表示時システムエラー対応
*	v59.00.03	2022/07/22	FJ) 鈴木	ANK-4330-01-00_消費者保護ガイドライン改正対応（Step2）
**	v60.00.00	2022/08/13	FJ) 鈴木	ANK-4330-00-00_消費者保護ガイドライン改正対応（Step2）
*	v75.00.00	2025/03/07	FJ) 吉田あ	ANK-4640-00-00_typeN：追加要件対応
*   v75.00.01   2025/05/26  FJ) 張      #87277_工事費割賦不具合対応
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Calendar;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.fujitsu.futurity.bp.x21.bpm.ServiceComponentRequestInvoker;
import com.fujitsu.futurity.bp.x21.bpm.db.SessionHandle;
import com.fujitsu.futurity.bp.x21.bpm.exception.RequestParameterException;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadWrite;
import com.fujitsu.futurity.bp.x21.cc.AbstractCommonComponent;
import com.fujitsu.futurity.bp.x21.cc.exception.SCCallException;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.SCControlMapKeys;
import com.fujitsu.futurity.mapping.bp.common.TemplateErrorUtil;
import com.fujitsu.futurity.model.base.CAANMsg;
import com.fujitsu.futurity.model.common.JCMAPLConstMgr;

import eo.common.constant.JACStrConst;
import eo.common.constant.JKKStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.util.JKKStringUtil;
import eo.common.util.JPCCheckUtil;
import eo.common.util.JPCDateUtil;
import eo.ejb.cbs.cbsmsg.EAC0221A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0221A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EAC0611B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EAC0611B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081B019CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B019CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081B029CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B029CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK2521A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2521A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECH0501B010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECH0501B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0021A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0021A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081B024CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B024CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0251B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0251B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0351B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0351B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0451A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0451A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0451B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0451B002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0481B006CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0481B006CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0711B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0711B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0861B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0861B002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK2361B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2361B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK2371A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2371A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK2541B004CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2541B004CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK3131B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK3131B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0311A020CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0311A020CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0321B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0321B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0791A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0791A010CBSMsg1List;

/**
 *精算金計算画面初期表示部品です。
 * <BR>
 * @author FJ
 */
public class JKKSsnPrcCalcCC extends AbstractCommonComponent
{
	/** テンプレートID　サービス契約一意照会 */
	private static final String TEMPLATE_ID_EKK0081A010 = "EKK0081A010";
	// 20210615 OM-2021-0000557 ADD START
	/** テンプレートID　サービス契約履歴一覧照会 */
	private static final String TEMPLATE_ID_EKK0081B024 = "EKK0081B024";
	// 20210615 OM-2021-0000557 ADD END
	/** テンプレートID　違約金一意照会 */
	private static final String TEMPLATE_ID_EAC0221A010 = "EAC0221A010";
	
	/** テンプレートID　割引サービス契約一覧照会（サービス契約番号） */
	private static final String TEMPLATE_ID_EKK0451B002 = "EKK0451B002";
	
	/** テンプレートID　割引サービス契約一意照会 */
	private static final String TEMPLATE_ID_EKK0451A010 = "EKK0451A010";
	
	/** テンプレートID　申込明細一意照会 */
	private static final String TEMPLATE_ID_EKK0021A010 = "EKK0021A010";
	
	/** テンプレートID　サービス契約回線内訳一覧照会（サービス契約番号） */
	private static final String TEMPLATE_ID_EKK0251B001 = "EKK0251B001";
	
	/** テンプレートID　工事費割賦契約一覧照会 */
	private static final String TEMPLATE_ID_EKK3131B010 = "EKK3131B010";
	
	/** テンプレートID　料金スケジュール定義一覧照会 */
	private static final String TEMPLATE_ID_ECH0501B010 = "ECH0501B010";
	
	/** テンプレートID　割引サービス単価一覧照会（割引サービスコード） */
	private static final String TEMPLATE_ID_EKK0711B001 = "EKK0711B001";
	
	/** テンプレートID　割賦料金一覧照会 */
	private static final String TEMPLATE_ID_EAC0611B010 = "EAC0611B010";
	
	// ANK-3383-00-00 ADD START
	/** 割引サービス詳細一意照会 */
	private static final String TEMPLATE_ID_EKK2371A010 = "EKK2371A010";
	
	/** 割賦契約一覧照会(サービス契約番号) */
	private static final String TEMPLATE_ID_EKK2541B004 = "EKK2541B004";
	
	/** 機器提供サービス契約一意照会 */
	private static final String TEMPLATE_ID_EKK0341A010 = "EKK0341A010";
	
	/** システムパラメータ管理一意照会（解約精算金取得用） */
	private static final String TEMPLATE_ID_EZM0311A020 = "EZM0311A020";
	
	/** オプションサービス契約一覧照会 */
	private static final String TEMPLATE_ID_EKK0351B010 = "EKK0351B010";
	
	/** 割引サービス対象契約一覧照会(機器提供サービス契約) */
	private static final String TEMPLATE_ID_EKK0481B006 = "EKK0481B006";
	// ANk-3383-00-00 ADD END
	
	// ANK-3383-06-00 ADD START
	/** テンプレートID　割賦プラン一意照会 */
	private static final String TEMPLATE_ID_EKK2521A010 = "EKK2521A010";
	// ANK-3383-06-00 ADD END
	
	// IT1-2018-0000071 ADD START
	/** テンプレートID　割引サービス単価一覧照会（割引サービスコード） */
	private static final String TEMPLATE_ID_EKK2361B010 = "EKK2361B010";
	// IT1-2018-0000071 ADD END
	
	// OM-2018-0000648 ADD START
	/** テンプレートID　サービス申込時サービス契約一覧照会 */
	private static final String TEMPLATE_ID_EKK0081B019 = "EKK0081B019";
	// OM-2018-0000648 ADD END
	
	// ST-2018-0000011 ADD START
	/** テンプレートID　割引サービス単価一覧照会（割引サービスコード） */
	private static final String TEMPLATE_ID_EZM0321A010 = "EZM0321A010";
	// ST-2018-0000011 ADD END
	
	// ANK-4248-00-00 ADD START
	/** テンプレートID　業務パラーメータ一覧照会） */
	private static final String TEMPLATE_ID_EZM0321B010 = "EZM0321B010";
	// ANK-4248-00-00 ADD END
	
	// ANK-4248-03-00 ADD START
	/** テンプレートID　同一回線内訳サービス契約一覧照会 */
	private static final String TEMPLATE_ID_EKK0081B029 = "EKK0081B029";
	// ANK-4248-03-00 ADD END
	
	/** マンション情報一覧照会 */
	private static final String TEMPLATE_ID_EKK0861B002 = "EKK0861B002";
	
	// ANK-4640-00-00 ADD START
	/** テンプレートID　料金プラン一意照会 */
	private static final String TEMPLATE_ID_EKK0791A010 = "EKK0791A010";
	// ANK-4640-00-00 ADD END
	
	/** 対象料金サービスコード＿即割精算金（ホームタイプ） */
	private static final String TRGT_PRC_SVC_CD_WST000000014 = "WST000000014";
	
	/** 対象料金サービスコード＿即割精算金（メゾンタイプ） */
	private static final String TRGT_PRC_SVC_CD_WST000000024 = "WST000000024";
	
	// ST-2018-0000010 ADD START
	/** 割引サービスコード＿長期利用割引 */
	private static final String WRIB_SVC_CD_W00000011 = "W00000011";
	// ST-2018-0000010 ADD END
	
	// ANK-4248-00-00 ADD START
	/** 割引サービスコード＿即割 */
	private static final String WRIB_SVC_CD_W00000021 = "W00000021";
	// ANK-4248-00-00 ADD END
	
	/** 割引サービスコード＿長期継続利用割引 */
	private static final String WRIB_SVC_CD_W00000041 = "W00000041";
	
	/** 工事費割賦新制度日 */
	private static final String KOJIHI_KAP_KEI_NO_NEW_DAY = "20180402";
	
	/** 即割解約精算金＿新制度＿０〜１２ヶ月（１２，９６０円） */
	private static final String SOKU_WARI_DSL_SSN_KIN_12960 = "12960";
	
	/** 即割解約精算金＿新制度＿１３〜２４ヶ月（６，４８０円） */
	private static final String SOKU_WARI_DSL_SSN_KIN_6480 = "6480";
	
	/** 解約精算金（０円） */
	private static final String DSL_SSN_KIN_0 = "0";
	
	/** 料金グループコード（ネット・ホーム） */
	private static final String PRC_GRP_CD_02 = "02";
	
	/** 料金グループコード（ネット・メゾン） */
	private static final String PRC_GRP_CD_03 = "03";
	
	/** 割引サービス契約自動継続識別コード（1:自動継続あり） */
	private static final String WRIB_SVC_KEI_AT_KEIZK_SKCD_1 = "1";
	
	/** 割引サービス契約自動継続識別コード（0:自動継続なし） */
	private static final String WRIB_SVC_KEI_AT_KEIZK_SKCD_0 = "0";
	
	/** リターンメッセージの書式指定文字列 */
	private static final String RETURN_MESSAGE_FORMAT = "%1$04d";
	
	/** エラー項目接尾辞 */
	private static final String ERRITEM_SUFFIX = "_err";
	
	/** リターンメッセージ取得キー */
	private static final String RETURN_MESSAGE_STRING = "RETURN_MESSAGE_";
	
	// ST-2018-0000011 ADD START
	/** 業務パラメータ管理_標準工事費割賦制度開始年月日 */
	protected static final String WORK_PARAM_KK_HJNKJH_KAPSD_SYMD = "KK_HJNKJH_KAPSD_SYMD";
	// ST-2018-0000011 ADD END
	
	// ANK-3636-08-00 ADD START
	/** 業務パラメータ管理_一時支払料金番号（８％）適用年月日 */
	protected static final String WORK_PARAM_KK_TPPN_STAX_APYMD08 = "KK_TPPN_STAX_APYMD08";
	
	// ↓当処理は2019年9月末リリース時に削除し、JKKStrConst.javaに定義する↓
	/** システムパラメータ分類コード（工事費旧制度違約金単価（１０％）） */
	// v45.00.03 ANK-3636-08-00 MOD START
	//protected static final String SYS_PARAM_ID_KJH_KYU_IYKKN_TNK_10 = "KJH_KYU_IYKKN_TNK_10";
	protected static final String SYS_PARAM_ID_KJH_KYU_IYKKN_TNK_10 = JKKStrConst.SYS_PARAM_ID_KJH_KYU_IYKKN_TNK_10;
	// v45.00.03 ANK-3636-08-00 MOD END
	// ↑当処理は2019年9月末リリース時に削除し、JKKStrConst.javaに定義する↑
	// ANK-3636-08-00 ADD END
	
	// ANK-3383-00-00 ADD START
	/** システムパラメータ管理_工事費旧制度違約金単価（即割） */
	protected static final String SYS_PARAM_KJH_KYUSD_IYKKN_TNK_SOKUWRI = "SOKUWARI";
	
	/** システムパラメータ管理_工事費旧制度違約金単価（旧長割） */
	protected static final String SYS_PARAM_KJH_KYUSD_IYKKN_TNK_KYUCHOWARI = "KYUCHOWARI";
	// ANK-3383-00-00 ADD END
	
	// OM-2021-0000276 ADD START
	/** "0"定数 */
	protected static final String ZERO = "0";
	// OM-2021-0000276 ADD END
	
	// ANK-4248-00-00 ADD START
	/** 経過措置違約金情報項目数*/
	private static final int KEIK_SOCH_PNLTY_INF_CNT = 7;
	
	/** 長割適用日算出月数*/
	private static final String CHO_WRI_MON_CNT = "CHO_WRT_MON_CNT";
	
	/** データタイプ数値*/
	private static final String DATA_TYPE_NUM = "1";
	// ANK-4248-00-00 ADD END
	
	// ANK-4248-03-00 ADD START
	/**
	 * 料金グループコード
	 */
	private static final String[][] PRC_GRP_CD = {
		// 料金グループコード
		{"02", "03", "04"}, //ネット
		{"10"}, //電話
		{"11", "12", "13"}//テレビ
	};
	
	/** 標準工事費割引キャンペーンリスト */
	private static final List<String> HYOJUN_KOJIHI_WRBK_CP_LIST =
		Arrays.asList(
				new String[] {
						JKKStrConst.WRIB_SVC_KOJIHI_WRBK_CP_NET_24,		// 標準工事費割引キャンペーン（２４回）（ネット用）
						// ANK-4330-00-00 ADD START
						JKKStrConst.WRIB_SVC_KOJIHI_WRBK_CP_TEL_24,		// 標準工事費割引キャンペーン（２４回）（電話用）
						// ANK-4330-00-00 ADD END
						}
				);
	// ANK-4248-03-00 ADD END
	
	/**
	 *精算金計算画面初期表示取得処理を行います。
	 * 
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite getSsnPrc(SessionHandle handle
												,IRequestParameterReadWrite param
												, String fixedText
												) throws Throwable
	{
		// ユーザデータ情報
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(fixedText);
		
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		IRequestParameterReadWrite retParam = param;
		List<HashMap<String, Object>>eKK0081A010List =  new ArrayList<HashMap<String, Object>>();
		List<HashMap<String, Object>>eKK0451A010List =  new ArrayList<HashMap<String, Object>>();
		List<HashMap<String, Object>>eKK0451B002List =  new ArrayList<HashMap<String, Object>>();
		List<HashMap<String, Object>>eKK0021A010List =  new ArrayList<HashMap<String, Object>>();
		List<HashMap<String, Object>>eKK3131B010List =  new ArrayList<HashMap<String, Object>>();
		// ANK-4640-00-00 ADD START
		List<HashMap<String, Object>>eKK0791A010List =  new ArrayList<HashMap<String, Object>>();
		// ANK-4640-00-00 ADD END
		
		String trgtPrcSvcCd = "";
		
		
		//データマップがNULLの場合、処理を終了する。
		if (dataMap == null)
		{
			return retParam;
		}
		
		//ネットの解約日が入力されているか判定する
		String dslRsvdYmdNet =  JKKStringUtil.nullToBlank((String)dataMap.get("dsl_rsvd_net"));
		//お客さまＩＤ＿ネット
		String svcKeiNoNet =  JKKStringUtil.nullToBlank((String)dataMap.get("svc_kei_no_net"));
		//電話の解約日が入力されているか判定する
		String dslRsvdYmdTel =  JKKStringUtil.nullToBlank((String)dataMap.get("dsl_rsvd_tel"));
		//お客さまＩＤ＿電話
		String svcKeiNoTel =  JKKStringUtil.nullToBlank((String)dataMap.get("svc_kei_no_tel"));
		//テレビの解約日が入力されているか判定する
		String dslRsvdYmdTv =  JKKStringUtil.nullToBlank((String)dataMap.get("dsl_rsvd_tv"));
		//お客さまＩＤ＿テレビ
		String svcKeiNoTv =  JKKStringUtil.nullToBlank((String)dataMap.get("svc_kei_no_tv"));
		
		// ANK-3383-00-00 ADD START
		// ｅｏスマートリンク明細一覧リスト
		List<HashMap<String, Object>> smtlnkInfoList = (List<HashMap<String, Object>>)dataMap.get("smtlnk_info_list");
		// ＧｏｏｇｌｅＨｏｍｅ明細一覧リスト
		List<HashMap<String, Object>> gglhmInfoList = (List<HashMap<String, Object>>)dataMap.get("gglhm_info_list");
		// ＳＴＢ明細一覧リスト
		List<HashMap<String, Object>> stbInfoList = (List<HashMap<String, Object>>)dataMap.get("stb_info_list");
		// ANK-3383-00-00 ADD END
		
		
		// 料金コースコード（ネット）
		String pcrsCdNet = "";
		// 料金コースコード（電話）
		String pcrsCdTel = "";
		// 料金コースコード（テレビ）
		String pcrsCdTv = "";
		
		
		//合計金額
		String gokei_amnt = "0";
		//即割解約精算金
		String sokuWariDslSsnKin = "0";
		//長割解約精算金
		String lenWariDslSsnKin = "0";
		//標準工事費残金
		String stdardKojihiZanKin = "0";
		//割賦残回数
		String kapPayZanCnt = "0";
		//テレビ解約精算金
		String tvDslSsnKin = "0";
		// ANK-3383-00-00 ADD START
		// 工事費相当額割引キャンペーン適用残回数
		String stdardKojihiCmpZanCnt = "0";
		// スターｃｈセット割解約精算金
		String stchSetWariSsnKin = "0";
		// eoスマートリンク−精算金（リスト分の合計額）
		String smtlnkSsnKinAllAmnt = "0";
		// Google Home−割賦残金（リスト分の合計額）
		String gglhmKapZkinAllAmnt = "0";
		// STB−精算金（リスト分の合計額）
		String stbDslSsnKinAllAmnt = "0";
		// ANK-3383-00-00 ADD END
		// ANK-3412-03-00 ADD START
		// 高速割解約精算金
		String kousokuWariDslSsnKin = "0";
		// ANK-3412-03-00 ADD END
		// ANK-4640-00-00 ADD START
		// NTT卸区分
		String nttorsDiv = "";
		// ANK-4640-00-00 ADD END
		
		// IT1-2018-0000072 ADD START
		smtlnkInfoList = clearSmtlnkInfoListAmnt(smtlnkInfoList);
		
		gglhmInfoList = clearGglhmInfoListAmnt(gglhmInfoList);
		
		stbInfoList = clearStbInfoListListAmnt(stbInfoList);
		// IT1-2018-0000072 ADD 
		
		// ST-2018-0000011 ADD START
		// 業務パラメータ管理．標準工事費割賦制度開始年月日を取得する
		String hjnkjhKapsdSymd = getHjnkjhKapsdSymd(handle, retParam, fixedText, WORK_PARAM_KK_HJNKJH_KAPSD_SYMD, JPCModelConstant.FUNC_CD_1);
		// ST-2018-0000011 ADD END
		
		// ANK-3636-08-00 ADD START
		// 業務パラメータ管理．一時支払料金番号（８％）適用年月日を取得する(業務パラメータ管理.業務パラメータID：KK_TPPN_STAX_APYMD08)
		// 取得した一時支払料金番号（８％）適用年月日は消費税の8%と10%切替日として使用する(終了日(20190930)を取得する)
		// 消費税(8%)適用終了年月日
		// ↓当処理は2019年9月末リリース時に削除する↓
		// ※当処理は暫定対応のため、業務パラメータ管理から取得せず固定値で20190930を保持する。
		// v45.00.03 ANK-3636-08-00 MOD START
		//String stax8PerTendymd = "20190930";
		String stax8PerTendymd = getEZM0321A010(handle, param, fixedText, JKKStrConst.KK_TPPN_STAX_APYMD08, JPCModelConstant.FUNC_CD_1);
		// v45.00.03 ANK-3636-08-00 MOD END
		// ↑当処理は2019年9月末リリース時に削除する↑
		// ANK-3636-08-00 ADD END
		
		// ANK-3412-03-00 ADD START
		//**************************************
		// ■業務パラメータ管理一意照会(EZM0321A010)
		//**************************************
		// 高速割料金コースを取得する
		String kosokuwariPcrs = getEZM0321A010(handle, param, fixedText, JKKStrConst.PARAM_ID_KK_KOSOKUWRI_PCRS, JPCModelConstant.FUNC_CD_1);
		// ","で料金コースコードを分割し、高速割料金コースリストに設定する
		List<String> kosokuwriPcrsList = Arrays.asList(kosokuwariPcrs.split(","));
		// ANK-3412-03-00 ADD END
		
		//ネットの解約日が入力されているか判定する
		if (!JKKStringUtil.isNullBlank(dslRsvdYmdNet))
		{
			// OM-2018-0000648 ADD START
			// サービス申込時の申込明細番号を取得する
			String firstMskmDtlNo = callEkk0081b019(handle, retParam, fixedText, svcKeiNoNet, JPCModelConstant.FUNC_CD_1);
			// OM-2018-0000648 ADD END
			
			// 20210615 OM-2021-0000557 MOD START
			// サービス契約一意照会
//			eKK0081A010List = getSvcKeiIti(handle, retParam, fixedText, svcKeiNoNet, JPCModelConstant.FUNC_CD_2);
			eKK0081A010List = getSvcKeiInfo(handle, retParam, fixedText, svcKeiNoNet, dslRsvdYmdNet);
			// 20210615 OM-2021-0000557 MOD END
			
			HashMap<String,Object> eKK0081A010Map = (HashMap<String,Object>)eKK0081A010List.get(0);
			
			// サービス開始年月日を取得
			String svcKeiStaYmd = JKKStringUtil.nullToBlank((String)eKK0081A010Map.get(EKK0081A010CBSMsg1List.SVC_STA_YMD));
			// 料金コースコードを取得
			pcrsCdNet = JKKStringUtil.nullToBlank((String)eKK0081A010Map.get(EKK0081A010CBSMsg1List.PCRS_CD));
			// 料金プランコードを取得
			String eKK0081A010PplanCd = JKKStringUtil.nullToBlank((String)eKK0081A010Map.get(EKK0081A010CBSMsg1List.PPLAN_CD));
			// 料金グループコードを取得
			String eKK0081A010PrcGrpCd = JKKStringUtil.nullToBlank((String)eKK0081A010Map.get(EKK0081A010CBSMsg1List.PRC_GRP_CD));
			// ANK-4640-00-00 ADD START
			// 料金コース一意照会
			eKK0791A010List = getEKK0791A010(handle, retParam, fixedText, pcrsCdNet, JPCModelConstant.FUNC_CD_2);
			
			HashMap<String,Object> eKK0791A010Map = (HashMap<String,Object>)eKK0791A010List.get(0);

			//NTT卸区分を取得
			nttorsDiv  = (String)eKK0791A010Map.get(EKK0791A010CBSMsg1List.NTTORS_DIV);
			// ANK-4640-00-00 ADD END
			
			// 継続月数を算出する（ネットの解約予定月 − ネットのサービス開始月）
			int keizokuGetuNum = JPCDateUtil.subtractMonth(dslRsvdYmdNet, svcKeiStaYmd);
			
			// ANK-3383-06-00 ADD START
			if (keizokuGetuNum < 0)
			{
				keizokuGetuNum = 0;
			}
			// ANK-3383-06-00 ADD END
			
			// ANK-4248-00-00 ADD START
			// 消費者保護ガイドライン＿旧制度満了日
			String kyuseidoEndymd = getEZM0321A010(handle, param, fixedText, JACStrConst.WKPRA_CSMPRT_OLDMRD, JPCModelConstant.FUNC_CD_1);
			// 経過措置違約金情報リスト
			List<Map<String, Object>> keikSochPnltyInfList = getKeikSochPnltyInfList(handle, retParam, fixedText);
			// ANK-4248-00-00 ADD END
			
			eKK0451B002List = getWribSvckei(handle, param, fixedText, svcKeiNoNet, JPCModelConstant.FUNC_CD_1);
			for (int i = 0; i < eKK0451B002List.size(); i++)
			{
				HashMap<String,Object> eKK0451B002Msg = (HashMap<String,Object>)eKK0451B002List.get(i);
				//割引サービス契約番号
				String eKK0451B002_wribSvcKeiNo = JKKStringUtil.nullToBlank((String)eKK0451B002Msg.get(EKK0451B002CBSMsg1List.WRIB_SVC_KEI_NO));
				//割引サービスコード
				String eKK0451B002_wribSvcCd = JKKStringUtil.nullToBlank((String)eKK0451B002Msg.get(EKK0451B002CBSMsg1List.WRIB_SVC_CD));
				//割引サービスステータス
				String eKK0451B002_wribSvcKeiStat = JKKStringUtil.nullToBlank((String)eKK0451B002Msg.get(EKK0451B002CBSMsg1List.WRIB_SVC_KEI_STAT));
				// ANK-3412-03-00 ADD START
				// サービス課金開始年月日
				String eKK0451B002_svcChrgStaymd = JKKStringUtil.nullToBlank((String)eKK0451B002Msg.get(EKK0451B002CBSMsg1List.SVC_CHRG_STAYMD));
				// ANK-3412-03-00 ADD END
				//割引サービスコード=即割
				if (JKKStrConst.WRIB_SVC_SOKU_WRIB.equals(eKK0451B002_wribSvcCd)
						// ST-2018-0000011 MOD START
						//&& !(JKKStrConst.CD00055_DSLZM.equals(eKK0451B002_wribSvcKeiStat) || JKKStrConst.CD00055_CSLZM.equals(eKK0451B002_wribSvcKeiStat)))
						&& JKKStrConst.CD00055_SVCTK_CHU.equals(eKK0451B002_wribSvcKeiStat))
						// ST-2018-0000011 MOD END
				{
					// OM-2018-0000648 MOD START
//					// 割引サービス契約一意照会
//					eKK0451A010List = getWribSvckeiIti(handle, retParam, fixedText, eKK0451B002_wribSvcKeiNo, JPCModelConstant.FUNC_CD_2);
//					if (null != eKK0451A010List && eKK0451A010List.size() > 0)
//					{
//						HashMap<String,Object> eKK0451A010Map = (HashMap<String,Object>)eKK0451A010List.get(0);
//						String eKK0451A010_mskmDtlNo = JKKStringUtil.nullToBlank((String)eKK0451A010Map.get(EKK0451A010CBSMsg1List.MSKM_DTL_NO));
					// ANK-4248-00-00 DEL START
////						//申込明細が存在する場合
////						if (!JKKStringUtil.isNullBlank(eKK0451A010_mskmDtlNo))
//						if (!JKKStringUtil.isNullBlank(firstMskmDtlNo))
//					// OM-2018-0000648 MOD END
//						{
//							// OM-2018-0000648 MOD START
//							//eKK0021A010List = getMskmDtlNoIti(handle, retParam, fixedText, eKK0451A010_mskmDtlNo, JPCModelConstant.FUNC_CD_2);
//							eKK0021A010List = getMskmDtlNoIti(handle, retParam, fixedText, firstMskmDtlNo, JPCModelConstant.FUNC_CD_2);
//							// OM-2018-0000648 MOD END
//							if (null != eKK0021A010List && eKK0021A010List.size() > 0)
//							{
//								HashMap<String,Object> eKK0021A010Map = (HashMap<String,Object>)eKK0021A010List.get(0);
//								String eKK0021A010_mskmYmd = JKKStringUtil.nullToBlank((String)eKK0021A010Map.get(EKK0021A010CBSMsg1List.MSKM_YMD));
//								//ネットの申込年月日が2018年4月1日以前か判定する
//								if (!JKKStringUtil.isNullBlank(eKK0021A010_mskmYmd) 
//										// ST-2018-0000011 MOD START
//										//&& KOJIHI_KAP_KEI_NO_NEW_DAY.compareTo(eKK0021A010_mskmYmd) > 0)
//										&& hjnkjhKapsdSymd.compareTo(eKK0021A010_mskmYmd) > 0)
//									// ST-2018-0000011 MOD END
//								{
//									// ANK-3383-00-00 MOD SATRT
//									//2018年4月1日以前のとき、システムパラメータ管理から情報取得するように変更
////									// 2018年4月1日以前のとき、違約金マスタから取得
////									HashMap<String,Object> eAC0221A010Map  = new HashMap<String,Object>();
////									List<HashMap<String, Object>> eAC0221A010ListSokuWari = new ArrayList<HashMap<String, Object>>();
////									
////									// 取得した料金グループコードに従って、対象料金サービスコードを判定
////									if (PRC_GRP_CD_02.equals(eKK0081A010PrcGrpCd))
////									{
////										trgtPrcSvcCd = TRGT_PRC_SVC_CD_WST000000014;
////									} else if (PRC_GRP_CD_03.equals(eKK0081A010PrcGrpCd))
////									{
////										trgtPrcSvcCd = TRGT_PRC_SVC_CD_WST000000024;
////									}
////									
////									// 違約金一意照会
////									eAC0221A010ListSokuWari = getPnltyPrcIti(handle, retParam, fixedText, pcrsCdNet, trgtPrcSvcCd, dslRsvdYmdNet, keizokuGetuNum, JPCModelConstant.FUNC_CD_1);
////									
////									if (null != eAC0221A010ListSokuWari && eAC0221A010ListSokuWari.size() > 0)
////									{
////										eAC0221A010Map = (HashMap<String,Object>)eAC0221A010ListSokuWari.get(0);
////									}
////									
////									// 違約金単価を取得
////									if (JKKStringUtil.isNullEmpty((String)eAC0221A010Map.get(EAC0221A010CBSMsg1List.PNLTY_TANKA)))
////									{
////										// 結果が取得できなかった場合、0円を設定
////										sokuWariDslSsnKin = DSL_SSN_KIN_0;
////									} else
////									{
////										// 結果が取得できた場合、取得値を設定
////										sokuWariDslSsnKin = (String)eAC0221A010Map.get(EAC0221A010CBSMsg1List.PNLTY_TANKA);
////									}
//									
//									HashMap<String,Object> eZM0311A020Map  = new HashMap<String,Object>();
//									List<HashMap<String, Object>> eZM0311A020ListSokuWari = new ArrayList<HashMap<String, Object>>();
//									
//									// システムパラメータ管理一意照会（解約精算金取得用）
//									eZM0311A020ListSokuWari = getSysParamPnltyPrc(handle, retParam, fixedText, JKKStrConst.SYS_PARAM_ID_KJH_KYUSD_IYKKN_TNK, SYS_PARAM_KJH_KYUSD_IYKKN_TNK_SOKUWRI, keizokuGetuNum, JPCModelConstant.FUNC_CD_1);
//									
//									if (null != eZM0311A020ListSokuWari && eZM0311A020ListSokuWari.size() > 0)
//									{
//										eZM0311A020Map = (HashMap<String,Object>)eZM0311A020ListSokuWari.get(0);
//									}
//									
//									// 違約金単価を取得
//									if (JKKStringUtil.isNullEmpty((String)eZM0311A020Map.get(EZM0311A020CBSMsg1List.SYS_PARAM_SETTE_VALUE_3)))
//									{
//										// 結果が取得できなかった場合、0円を設定
//										sokuWariDslSsnKin = DSL_SSN_KIN_0;
//									} else
//									{
//										// 結果が取得できた場合、取得値を設定
//										sokuWariDslSsnKin = (String)eZM0311A020Map.get(EZM0311A020CBSMsg1List.SYS_PARAM_SETTE_VALUE_3);
//									}
//									
//									// ANK-3636-08-00 ADD START
//									// 即割解約精算金の10%対応を行う
//									// 消費税(8%)適用終了年月日がnullまたは""ではない、かつ、消費税(8%)適用終了年月日 < ネットの解約予定日の場合、
//									// システムパラメータ管理.工事費旧制度違約金単価（１０％）の料金を設定する
//									if (!JKKStringUtil.isNullEmpty(stax8PerTendymd) && dslRsvdYmdNet.compareTo(stax8PerTendymd) > 0)
//									{
//										// システムパラメータ管理から工事費旧制度違約金単価（１０％）を取得する
//										HashMap<String,Object> eZM0311A020Map10Per  = new HashMap<String,Object>();
//										List<HashMap<String, Object>> eZM0311A020ListSokuWari10Per = new ArrayList<HashMap<String, Object>>();
//										
//										// システムパラメータ管理一意照会（解約精算金取得用）より工事費旧制度違約金単価（１０％）を照会する
//										eZM0311A020ListSokuWari10Per = getSysParamPnltyPrc(handle, retParam, fixedText, SYS_PARAM_ID_KJH_KYU_IYKKN_TNK_10, SYS_PARAM_KJH_KYUSD_IYKKN_TNK_SOKUWRI, keizokuGetuNum, JPCModelConstant.FUNC_CD_1);
//										
//										if (null != eZM0311A020ListSokuWari10Per && eZM0311A020ListSokuWari10Per.size() > 0)
//										{
//											eZM0311A020Map10Per = (HashMap<String,Object>)eZM0311A020ListSokuWari10Per.get(0);
//										}
//										
//										// 違約金単価を取得
//										if (JKKStringUtil.isNullEmpty((String)eZM0311A020Map10Per.get(EZM0311A020CBSMsg1List.SYS_PARAM_SETTE_VALUE_3)))
//										{
//											// 結果が取得できなかった場合、0円を設定
//											sokuWariDslSsnKin = DSL_SSN_KIN_0;
//										} else
//										{
//											// 結果が取得できた場合、取得値を設定
//											sokuWariDslSsnKin = (String)eZM0311A020Map10Per.get(EZM0311A020CBSMsg1List.SYS_PARAM_SETTE_VALUE_3);
//										}
//									}
//									// ANK-3636-08-00 ADD END
//								} else
//								{
								// ANK-4248-00-00 DEL END
									// ANK-3383-00-00 MOD START
									//違約金マスタから情報取得するように変更
//									// 2018年4月2日以降のとき、継続月数に従って即割解約精算金を返却する
//									if (0 <= keizokuGetuNum && keizokuGetuNum <= 12)
//									{
//										// 継続月数が、０ヶ月〜１２ヶ月の場合
//										sokuWariDslSsnKin = SOKU_WARI_DSL_SSN_KIN_12960;
//									} else if (13 <= keizokuGetuNum && keizokuGetuNum <= 24)
//									{
//										// 継続月数が、１３ヶ月〜２４ヶ月の場合
//										sokuWariDslSsnKin = SOKU_WARI_DSL_SSN_KIN_6480;
//									} else
//									{
//										// 継続月数が、２５ヶ月以上の場合
//										sokuWariDslSsnKin = DSL_SSN_KIN_0;
//									}
									HashMap<String,Object> eAC0221A010Map  = new HashMap<String,Object>();
									List<HashMap<String, Object>> eAC0221A010ListSokuWari = new ArrayList<HashMap<String, Object>>();
									
									// ANK-4248-00-00 MOD START
//									// 取得した料金グループコードに従って、対象料金サービスコードを判定
//									if (PRC_GRP_CD_02.equals(eKK0081A010PrcGrpCd))
//									{
//										trgtPrcSvcCd = TRGT_PRC_SVC_CD_WST000000014;
//									} else if (PRC_GRP_CD_03.equals(eKK0081A010PrcGrpCd))
//									{
//										trgtPrcSvcCd = TRGT_PRC_SVC_CD_WST000000024;
//									}
									
									// 割引サービス単価一覧照会（割引サービスコード）を実行し、対象料金サービスコードを取得する
									List<HashMap<String, Object>> eKK0711B001List = getWribSvcTankaIcrn(handle, param, fixedText, WRIB_SVC_CD_W00000021, JPCModelConstant.FUNC_CD_1);
									
									for (int j = 0; j < eKK0711B001List.size(); j++)
									{
										Map<String,Object> eKK0711B001Msg = (Map<String,Object>)eKK0711B001List.get(j);
										
										// 料金コースコード
										String eKK0711B001_pcrsCd = JKKStringUtil.nullToBlank((String)eKK0711B001Msg.get(EKK0711B001CBSMsg1List.PCRS_CD));
										// 料金プランコード
										String eKK0711B001_pplanCd = JKKStringUtil.nullToBlank((String)eKK0711B001Msg.get(EKK0711B001CBSMsg1List.PPLAN_CD));
										
										if (eKK0711B001_pcrsCd.equals(pcrsCdNet) && eKK0711B001_pplanCd.equals(eKK0081A010PplanCd))
										{
											// 対象料金サービスコードに割引サービス単価番号を設定
											trgtPrcSvcCd = JKKStringUtil.nullToBlank((String)eKK0711B001Msg.get(EKK0711B001CBSMsg1List.WRIB_SVC_TANKA_NO));
											break;
										}
									}
									// ANK-4248-00-00 MOD END
									
									// 違約金一意照会
									eAC0221A010ListSokuWari = getPnltyPrcIti(handle, retParam, fixedText, pcrsCdNet, trgtPrcSvcCd, dslRsvdYmdNet, keizokuGetuNum, JPCModelConstant.FUNC_CD_1);
									
									if (null != eAC0221A010ListSokuWari && eAC0221A010ListSokuWari.size() > 0)
									{
										eAC0221A010Map = (HashMap<String,Object>)eAC0221A010ListSokuWari.get(0);
									}
									
									// 違約金単価を取得
									if (JKKStringUtil.isNullEmpty((String)eAC0221A010Map.get(EAC0221A010CBSMsg1List.PNLTY_TANKA)))
									{
										// 結果が取得できなかった場合、0円を設定
										sokuWariDslSsnKin = DSL_SSN_KIN_0;
									} else
									{
										// 結果が取得できた場合、取得値を設定
										sokuWariDslSsnKin = (String)eAC0221A010Map.get(EAC0221A010CBSMsg1List.PNLTY_TANKA);
										// v45.00.03 ANK-3636-08-00 DEL START
//										// ANK-3636-08-00 ADD START
//										// ↓当処理は2019年9月末リリース時に削除する↓
//										// 消費税(8%)適用終了年月日がnullまたは""ではない、かつ、消費税(8%)適用終了年月日 < ネットの解約予定日の場合、
//										// 消費税10%の違約金単価を設定する
//										if (!JKKStringUtil.isNullEmpty(stax8PerTendymd) && dslRsvdYmdNet.compareTo(stax8PerTendymd) > 0)
//										{
//											// 消費税10%の料金に変換する
//											sokuWariDslSsnKin = chgStax10Per(sokuWariDslSsnKin);
//										}
//										// ↑当処理は2019年9月末リリース時に削除する↑
//										// ANK-3636-08-00 ADD END
										// v45.00.03 ANK-3636-08-00 DEL END
									}
									// ANK-3383-00-00 MOD END
								// ANK-4248-00-00 DEL START
//								}
//							}
//						}
						// ANK-4248-00-00 DEL END
					// OM-2018-0000648 DEL START
					//}
					// OM-2018-0000648 DEL END
				} 
				// ST-2018-0000010 ADD START
				else if (JKKStrConst.WRIB_SVC_CHOKI_USE_WRIB.equals(eKK0451B002_wribSvcCd)
						// ST-2018-0000011 MOD START
						//&& !(JKKStrConst.CD00055_DSLZM.equals(eKK0451B002_wribSvcKeiStat) || JKKStrConst.CD00055_CSLZM.equals(eKK0451B002_wribSvcKeiStat)))
						&& JKKStrConst.CD00055_SVCTK_CHU.equals(eKK0451B002_wribSvcKeiStat))
						// ST-2018-0000011 MOD END
				{
					// OM-2018-0000648 MOD START
//					// 割引サービス契約一意照会
//					eKK0451A010List = getWribSvckeiIti(handle, retParam, fixedText, eKK0451B002_wribSvcKeiNo, JPCModelConstant.FUNC_CD_2);
//					if (null != eKK0451A010List && eKK0451A010List.size() > 0)
//					{
//						HashMap<String,Object> eKK0451A010Map = (HashMap<String,Object>)eKK0451A010List.get(0);
//						String eKK0451A010_mskmDtlNo = JKKStringUtil.nullToBlank((String)eKK0451A010Map.get(EKK0451A010CBSMsg1List.MSKM_DTL_NO));
					// ANK-4248-00-00 DEL START
////						//申込明細が存在する場合
////						if (!JKKStringUtil.isNullBlank(eKK0451A010_mskmDtlNo))
//						if (!JKKStringUtil.isNullBlank(firstMskmDtlNo))
//					// OM-2018-0000648 MOD END
//						{
//							// OM-2018-0000648 MOD START
//							//eKK0021A010List = getMskmDtlNoIti(handle, retParam, fixedText, eKK0451A010_mskmDtlNo, JPCModelConstant.FUNC_CD_2);
//							eKK0021A010List = getMskmDtlNoIti(handle, retParam, fixedText, firstMskmDtlNo, JPCModelConstant.FUNC_CD_2);
//							// OM-2018-0000648 MOD END
//							if (null != eKK0021A010List && eKK0021A010List.size() > 0)
//							{
//								HashMap<String,Object> eKK0021A010Map = (HashMap<String,Object>)eKK0021A010List.get(0);
//								String eKK0021A010_mskmYmd = JKKStringUtil.nullToBlank((String)eKK0021A010Map.get(EKK0021A010CBSMsg1List.MSKM_YMD));
//								//ネットの申込年月日が2018年4月1日以前か判定する
//								if (!JKKStringUtil.isNullBlank(eKK0021A010_mskmYmd) 
//										// ST-2018-0000011 MOD START
//										//&& KOJIHI_KAP_KEI_NO_NEW_DAY.compareTo(eKK0021A010_mskmYmd) > 0)
//										&& hjnkjhKapsdSymd.compareTo(eKK0021A010_mskmYmd) > 0)
//										// ST-2018-0000011 MOD END
//								{
//									// ANK-3383-00-00 MOD SATRT
//									//2018年4月1日以前のとき、システムパラメータ管理から情報取得するように変更
//									// 2018年4月1日以前のとき、違約金マスタから取得
////									HashMap<String,Object> eAC0221A010Map  = new HashMap<String,Object>();
////									List<HashMap<String, Object>> eAC0221A010ListSokuWari = new ArrayList<HashMap<String, Object>>();
////									String wribSvcTankaNo = "";
////									
////									// 割引サービス単価一覧照会（割引サービスコード）を実行し、対象料金サービスコードを取得する
////									List<HashMap<String, Object>> eKK0711B001List = getWribSvcTankaIcrn(handle, param, fixedText, WRIB_SVC_CD_W00000011, JPCModelConstant.FUNC_CD_1);
////									
////									for (int j = 0; j < eKK0711B001List.size(); j++)
////									{
////										HashMap<String,Object> eKK0711B001Msg = (HashMap<String,Object>)eKK0711B001List.get(j);
////										
////										// 料金コースコード
////										String eKK0711B001_pcrsCd = JKKStringUtil.nullToBlank((String)eKK0711B001Msg.get(EKK0711B001CBSMsg1List.PCRS_CD));
////										// 料金プランコード
////										String eKK0711B001_pplanCd = JKKStringUtil.nullToBlank((String)eKK0711B001Msg.get(EKK0711B001CBSMsg1List.PPLAN_CD));
////										
////										if (eKK0711B001_pcrsCd.equals(pcrsCdNet) && eKK0711B001_pplanCd.equals(eKK0081A010PplanCd))
////										{
////											// 割引サービス単価番号を取得
////											wribSvcTankaNo = JKKStringUtil.nullToBlank((String)eKK0711B001Msg.get(EKK0711B001CBSMsg1List.WRIB_SVC_TANKA_NO));
////											break;
////										}
////									}
////									
////									// 違約金一意照会
////									eAC0221A010ListSokuWari = getPnltyPrcIti(handle, retParam, fixedText, pcrsCdNet, wribSvcTankaNo, dslRsvdYmdNet, keizokuGetuNum, JPCModelConstant.FUNC_CD_1);
////									
////									if (null != eAC0221A010ListSokuWari && eAC0221A010ListSokuWari.size() > 0)
////									{
////										eAC0221A010Map = (HashMap<String,Object>)eAC0221A010ListSokuWari.get(0);
////									}
////									
////									// 違約金単価を取得
////									if (JKKStringUtil.isNullEmpty((String)eAC0221A010Map.get(EAC0221A010CBSMsg1List.PNLTY_TANKA)))
////									{
////										// 結果が取得できなかった場合、0円を設定
////										sokuWariDslSsnKin = DSL_SSN_KIN_0;
////									} else
////									{
////										// 結果が取得できた場合、取得値を設定
////										sokuWariDslSsnKin = (String)eAC0221A010Map.get(EAC0221A010CBSMsg1List.PNLTY_TANKA);
////									}
//									
//									HashMap<String,Object> eZM0311A020Map  = new HashMap<String,Object>();
//									List<HashMap<String, Object>> eZM0311A020ListKyuTyoWari = new ArrayList<HashMap<String, Object>>();
//									
//									// システムパラメータ管理一意照会（解約精算金取得用）
//									eZM0311A020ListKyuTyoWari = getSysParamPnltyPrc(handle, retParam, fixedText, JKKStrConst.SYS_PARAM_ID_KJH_KYUSD_IYKKN_TNK, SYS_PARAM_KJH_KYUSD_IYKKN_TNK_KYUCHOWARI, keizokuGetuNum, JPCModelConstant.FUNC_CD_1);
//									
//									if (null != eZM0311A020ListKyuTyoWari && eZM0311A020ListKyuTyoWari.size() > 0)
//									{
//										eZM0311A020Map = (HashMap<String,Object>)eZM0311A020ListKyuTyoWari.get(0);
//									}
//									
//									// ANK-3636-08-00 ADD START
//									// システムパラメータ管理から工事費旧制度違約金単価（１０％）を取得する
//									HashMap<String,Object> eZM0311A020Map10Per  = new HashMap<String,Object>();
//									List<HashMap<String, Object>> eZM0311A020ListKyuTyoWari10Per = new ArrayList<HashMap<String, Object>>();
//									
//									// システムパラメータ管理一意照会（解約精算金取得用）より工事費旧制度違約金単価（１０％）を照会する
//									eZM0311A020ListKyuTyoWari10Per = getSysParamPnltyPrc(handle, retParam, fixedText, SYS_PARAM_ID_KJH_KYU_IYKKN_TNK_10, SYS_PARAM_KJH_KYUSD_IYKKN_TNK_KYUCHOWARI, keizokuGetuNum, JPCModelConstant.FUNC_CD_1);
//									
//									if (null != eZM0311A020ListKyuTyoWari10Per && eZM0311A020ListKyuTyoWari10Per.size() > 0)
//									{
//										eZM0311A020Map10Per = (HashMap<String,Object>)eZM0311A020ListKyuTyoWari10Per.get(0);
//									}
//									
//									// 消費税(8%)適用終了年月日がnullまたは""ではない、かつ、消費税(8%)適用終了年月日 < ネットの解約予定日の場合、
//									// システムパラメータ管理.工事費旧制度違約金単価（１０％）の料金を設定する
//									if (!JKKStringUtil.isNullEmpty(stax8PerTendymd) && dslRsvdYmdNet.compareTo(stax8PerTendymd) > 0)
//									{
//										// 違約金単価を取得
//										if (JKKStringUtil.isNullEmpty((String)eZM0311A020Map10Per.get(EZM0311A020CBSMsg1List.SYS_PARAM_SETTE_VALUE_3)))
//										{
//											// 結果が取得できなかった場合、0円を設定
//											sokuWariDslSsnKin = DSL_SSN_KIN_0;
//										} else
//										{
//											// 結果が取得できた場合、取得値を設定
//											sokuWariDslSsnKin = (String)eZM0311A020Map10Per.get(EZM0311A020CBSMsg1List.SYS_PARAM_SETTE_VALUE_3);
//										}
//									}
//									// 消費税(8%)適用終了年月日がnullまたは""である、または、消費税(8%)適用終了年月日 >= ネットの解約予定日の場合、
//									// システムパラメータ管理.工事費旧制度違約金単価(8%の料金)を設定する
//									else
//									{
//									// ANK-3636-08-00 ADD END
//										// 違約金単価を取得
//										if (JKKStringUtil.isNullEmpty((String)eZM0311A020Map.get(EZM0311A020CBSMsg1List.SYS_PARAM_SETTE_VALUE_3)))
//										{
//											// 結果が取得できなかった場合、0円を設定
//											sokuWariDslSsnKin = DSL_SSN_KIN_0;
//										} else
//										{
//											// 結果が取得できた場合、取得値を設定
//											sokuWariDslSsnKin = (String)eZM0311A020Map.get(EZM0311A020CBSMsg1List.SYS_PARAM_SETTE_VALUE_3);
//										}
//									// ANK-3636-08-00 ADD START
//									}
//									// ANK-3636-08-00 ADD END
//									// ANK-3383-00-00 MOD END
//								} else
//								{
					// ANK-4248-00-00 DEL END
									// ANK-3383-00-00 MOD SATRT
									//違約金マスタから情報取得するように変更
//									// 2018年4月2日以降のとき、継続月数に従って即割解約精算金を返却する
//									if (0 <= keizokuGetuNum && keizokuGetuNum <= 12)
//									{
//										// 継続月数が、０ヶ月〜１２ヶ月の場合
//										sokuWariDslSsnKin = SOKU_WARI_DSL_SSN_KIN_12960;
//									} else
//									{
//										// 継続月数が、１３ヶ月以上の場合
//										sokuWariDslSsnKin = DSL_SSN_KIN_0;
//									}
									HashMap<String,Object> eAC0221A010Map  = new HashMap<String,Object>();
									List<HashMap<String, Object>> eAC0221A010ListSokuWari = new ArrayList<HashMap<String, Object>>();
									String wribSvcTankaNo = "";
									
									// 割引サービス単価一覧照会（割引サービスコード）を実行し、対象料金サービスコードを取得する
									List<HashMap<String, Object>> eKK0711B001List = getWribSvcTankaIcrn(handle, param, fixedText, WRIB_SVC_CD_W00000011, JPCModelConstant.FUNC_CD_1);
									
									for (int j = 0; j < eKK0711B001List.size(); j++)
									{
										HashMap<String,Object> eKK0711B001Msg = (HashMap<String,Object>)eKK0711B001List.get(j);
										
										// 料金コースコード
										String eKK0711B001_pcrsCd = JKKStringUtil.nullToBlank((String)eKK0711B001Msg.get(EKK0711B001CBSMsg1List.PCRS_CD));
										// 料金プランコード
										String eKK0711B001_pplanCd = JKKStringUtil.nullToBlank((String)eKK0711B001Msg.get(EKK0711B001CBSMsg1List.PPLAN_CD));
										
										if (eKK0711B001_pcrsCd.equals(pcrsCdNet) && eKK0711B001_pplanCd.equals(eKK0081A010PplanCd))
										{
											// 割引サービス単価番号を取得
											wribSvcTankaNo = JKKStringUtil.nullToBlank((String)eKK0711B001Msg.get(EKK0711B001CBSMsg1List.WRIB_SVC_TANKA_NO));
											break;
										}
									}
									
									// 違約金一意照会
									eAC0221A010ListSokuWari = getPnltyPrcIti(handle, retParam, fixedText, pcrsCdNet, wribSvcTankaNo, dslRsvdYmdNet, keizokuGetuNum, JPCModelConstant.FUNC_CD_1);
									
									if (null != eAC0221A010ListSokuWari && eAC0221A010ListSokuWari.size() > 0)
									{
										eAC0221A010Map = (HashMap<String,Object>)eAC0221A010ListSokuWari.get(0);
									}
									
									// 違約金単価を取得
									if (JKKStringUtil.isNullEmpty((String)eAC0221A010Map.get(EAC0221A010CBSMsg1List.PNLTY_TANKA)))
									{
										// 結果が取得できなかった場合、0円を設定
										sokuWariDslSsnKin = DSL_SSN_KIN_0;
									} else
									{
										// 結果が取得できた場合、取得値を設定
										sokuWariDslSsnKin = (String)eAC0221A010Map.get(EAC0221A010CBSMsg1List.PNLTY_TANKA);
										// v45.00.03 ANK-3636-08-00 DEL START
//										// ANK-3636-08-00 ADD START
//										// ↓当処理は2019年9月末リリース時に削除する↓
//										// 消費税(8%)適用終了年月日がnullまたは""ではない、かつ、消費税(8%)適用終了年月日 < ネットの解約予定日の場合、
//										// 消費税10%の違約金単価を設定する
//										if ((!JKKStringUtil.isNullEmpty(stax8PerTendymd) && dslRsvdYmdNet.compareTo(stax8PerTendymd) > 0))
//										{
//											// 消費税10%の料金に変換する
//											sokuWariDslSsnKin = chgStax10Per(sokuWariDslSsnKin);
//										}
//										// ↑当処理は2019年9月末リリース時に削除する↑
//										// ANK-3636-08-00 ADD END
										// v45.00.03 ANK-3636-08-00 DEL END
									}
									// ANK-3383-00-00 MOD END
								// ANK-4248-00-00 DEL START
//								}
//							}
//						}
						// ANK-4248-00-00 DEL END
					// OM-2018-0000648 DEL START
					//}
					// OM-2018-0000648 DEL END
				}
				// ST-2018-0000010 ADD END
				
				//割引サービスコード=長割
				else if (JKKStrConst.WRIB_SVC_CHOKI_KEIZK_USE_WRIB.equals(eKK0451B002_wribSvcCd)
							// OM-2018-0000353 MOD START
							//&& !(JKKStrConst.CD00055_DSLZM.equals(eKK0451B002_wribSvcKeiStat) || JKKStrConst.CD00055_CSLZM.equals(eKK0451B002_wribSvcKeiStat)))
							&& JKKStrConst.CD00055_SVCTK_CHU.equals(eKK0451B002_wribSvcKeiStat))
							// OM-2018-0000353 MOD END
				{
					// ANK-4248-00-00 ADD START
					// 違約金マスタの違約金単価の長割解約精算金への設定有無
					boolean hasPnltyTanka = false;
					// 割引サービス単価番号
					String wribSvcTankaNo = "";
					// ANK-4248-00-00 ADD END
					HashMap<String,Object> eKK0451A010Map = new HashMap<String,Object>();
					
					// 割引サービス契約一意照会
					eKK0451A010List = getWribSvckeiIti(handle, retParam, fixedText, eKK0451B002_wribSvcKeiNo, JPCModelConstant.FUNC_CD_2);
					
					if (null != eKK0451A010List && eKK0451A010List.size() > 0)
					{
						eKK0451A010Map = (HashMap<String,Object>)eKK0451A010List.get(0);
					}
					
					// 割引サービス契約自動継続識別コード
					String eKK0451A010_wribSvcKeiAtKeizkSkCd = JKKStringUtil.nullToBlank((String)eKK0451A010Map.get(EKK0451A010CBSMsg1List.WRIB_SVC_KEI_AT_KEIZK_SKCD));
					
					if ( WRIB_SVC_KEI_AT_KEIZK_SKCD_1.equals(eKK0451A010_wribSvcKeiAtKeizkSkCd))
					{
						// 自動継続ありの場合、違約金を参照する
						HashMap<String,Object> eAC0221A010MapTyoWari = calcTyoWari(handle, retParam, fixedText, pcrsCdNet, eKK0081A010PplanCd, dslRsvdYmdNet, keizokuGetuNum);
						
						// 違約金単価を取得
						if (JKKStringUtil.isNullEmpty((String)eAC0221A010MapTyoWari.get(EAC0221A010CBSMsg1List.PNLTY_TANKA)))
						{
							// 結果が取得できなかった場合、0円を設定
							lenWariDslSsnKin = DSL_SSN_KIN_0;
						} else
						{
							// 結果が取得できた場合、取得値を設定
							lenWariDslSsnKin = (String)eAC0221A010MapTyoWari.get(EAC0221A010CBSMsg1List.PNLTY_TANKA);
							// ANK-4248-00-00 ADD START
							wribSvcTankaNo = (String)eAC0221A010MapTyoWari.get(EKK0711B001CBSMsg1List.WRIB_SVC_TANKA_NO);
							hasPnltyTanka = true;
							// ANK-4248-00-00 ADD END
							// v45.00.03 ANK-3636-08-00 DEL START
//							// ANK-3636-08-00 ADD START
//							// ↓当処理は2019年9月末リリース時に削除する↓
//							// 消費税(8%)適用終了年月日がnullまたは""ではない、かつ、消費税(8%)適用終了年月日 < ネットの解約予定日の場合、
//							// 消費税10%の違約金単価を設定する
//							if ((!JKKStringUtil.isNullEmpty(stax8PerTendymd) && dslRsvdYmdNet.compareTo(stax8PerTendymd) > 0))
//							{
//								// 消費税10%の料金に変換する
//								lenWariDslSsnKin = chgStax10Per(lenWariDslSsnKin);
//							}
//							// ↑当処理は2019年9月末リリース時に削除する↑
//							// ANK-3636-08-00 ADD END
							// v45.00.03 ANK-3636-08-00 DEL END
						}
					} 
					else if ( WRIB_SVC_KEI_AT_KEIZK_SKCD_0.equals(eKK0451A010_wribSvcKeiAtKeizkSkCd))
					{
						// 自動継続なしの場合、継続月数に従って長期継続利用割引が適応されているか判定する
						// 割引サービス契約自動継続識別コード
						String eKK0451A010_planStaYmd = JKKStringUtil.nullToBlank((String)eKK0451A010Map.get(EKK0451A010CBSMsg1List.PLAN_STAYMD));
						
						// ST-2018-0000011 MOD START
						//// 現在の継続月数を算出する（運用日付 − プラン開始年月日）
						//int nowKeizokuGetuNum = JPCDateUtil.subtractMonth(JPCBPCommon.getOpeDate(null), eKK0451A010_planStaYmd);
						// 現在の継続月数を算出する（運用日付 − サービス開始年月日）
						int nowKeizokuGetuNum = JPCDateUtil.subtractMonth(JPCBPCommon.getOpeDate(null), svcKeiStaYmd);
						// ST-2018-0000011 MOD END
						
						// ST-2018-0000011 DEL START
						// 解約時の継続月数を算出する（ネットの解約予定日 − プラン開始年月日）
						//int dslKeizokuGetuNum = JPCDateUtil.subtractMonth(dslRsvdYmdNet, eKK0451A010_planStaYmd);
						// ST-2018-0000011 DEL END
						
						// 現在の継続月数と解約時の継続月数それぞれ１２で割った時の商が一致した場合、長期継続利用割引適応内と判定する
						// ST-2018-0000011 MOD START
						//if (nowKeizokuGetuNum/12 == dslKeizokuGetuNum/12)
						// 運用日付時点の継続月数から長期継続利用割引契約のクォーターを算出
						nowKeizokuGetuNum -= 25;
						double month1 = Math.ceil(nowKeizokuGetuNum / 36);
						
						// 解約日時点の継続月数から長期継続利用割引契約のクォーターを算出
						int calcKeizokuGetuNum = keizokuGetuNum;
						calcKeizokuGetuNum -= 25;
						double month2 = Math.ceil(calcKeizokuGetuNum / 36);
						
						if (month1 == month2 && 0 <= month1)
						// ST-2018-0000011 MOD END
						{
							// 長期継続利用割引適応内の時、違約金を参照する
							// ST-2018-0000011 MOD START
							//HashMap<String,Object> eAC0221A010MapTyoWari = calcTyoWari(handle, retParam, fixedText, pcrsCdNet, eKK0081A010PplanCd, dslRsvdYmdNet, dslKeizokuGetuNum);
							HashMap<String,Object> eAC0221A010MapTyoWari = calcTyoWari(handle, retParam, fixedText, pcrsCdNet, eKK0081A010PplanCd, dslRsvdYmdNet, keizokuGetuNum);
							// ST-2018-0000011 MOD END
							
							// 違約金単価を取得
							if (JKKStringUtil.isNullEmpty((String)eAC0221A010MapTyoWari.get(EAC0221A010CBSMsg1List.PNLTY_TANKA)))
							{
								// 結果が取得できなかった場合、0円を設定
								lenWariDslSsnKin = DSL_SSN_KIN_0;
							} else
							{
								// 結果が取得できた場合、取得値を設定
								lenWariDslSsnKin = (String)eAC0221A010MapTyoWari.get(EAC0221A010CBSMsg1List.PNLTY_TANKA);
								// ANK-4248-00-00 ADD START
								wribSvcTankaNo = (String)eAC0221A010MapTyoWari.get(EKK0711B001CBSMsg1List.WRIB_SVC_TANKA_NO);
								hasPnltyTanka = true;
								// ANK-4248-00-00 ADD END
								// v45.00.03 ANK-3636-08-00 DEL START
//								// ANK-3636-08-00 ADD START
//								// ↓当処理は2019年9月末リリース時に削除する↓
//								// 消費税(8%)適用終了年月日がnullまたは""ではない、かつ、消費税(8%)適用終了年月日 < ネットの解約予定日の場合、
//								// 消費税10%の違約金単価を設定する
//								if ((!JKKStringUtil.isNullEmpty(stax8PerTendymd) && dslRsvdYmdNet.compareTo(stax8PerTendymd) > 0))
//								{
//									// 消費税10%の料金に変換する
//									lenWariDslSsnKin = chgStax10Per(lenWariDslSsnKin);
//								}
//								// ↑当処理は2019年9月末リリース時に削除する↑
//								// ANK-3636-08-00 ADD END
								// v45.00.03 ANK-3636-08-00 DEL END
							}
						} else
						{
							// 長期継続利用割引適応外の時、０円を設定
							lenWariDslSsnKin = DSL_SSN_KIN_0;
						}
					}
					// OM-2019-0000906 ADD START
					// 初月解約の場合、0円を設定する
					// 割引サービス契約．申込起算年月日(MSKM_KISAN_YMD)を取得する
					String eKK0451A010_mskmKisanYmd = JKKStringUtil.nullToBlank((String)eKK0451A010Map.get(EKK0451A010CBSMsg1List.MSKM_KISAN_YMD));
					
					// ネットの解約予定日と割引サービス契約．申込起算年月日がnullまたは""(空文字)ではない場合
					if (!JKKStringUtil.isNullBlank(dslRsvdYmdNet) && !JKKStringUtil.isNullBlank(eKK0451A010_mskmKisanYmd))
					{
						// 割引サービス契約．申込起算年月日とネットの解約予定日の年月が同じ場合(初月解約の場合)、
						// 割引サービス契約．申込起算年月日 > ネットの解約予定日の場合(初月以前の解約の場合)に
						// 長割解約精算金を0円とする
						if (eKK0451A010_mskmKisanYmd.substring(0,6).compareTo(dslRsvdYmdNet.substring(0,6)) >= 0)
						{
							// 長割解約精算金に0円を設定
							lenWariDslSsnKin = DSL_SSN_KIN_0;
							// ANK-4248-00-00 ADD START
							hasPnltyTanka = false;
							// ANK-4248-00-00 ADD END
						}
					}
					// OM-2019-0000906 ADD END
					// ANK-4248-00-00 ADD START
					// 違約金マスタの違約金単価が長割解約精算金へ設定されている場合
					if (hasPnltyTanka)
					{
						if (!JKKStringUtil.isNullEmpty(kyuseidoEndymd) && !JKKStringUtil.isNullEmpty(kyuseidoEndymd)
								&& keikSochPnltyInfList != null)
						{
							Map<String, Object> keikSochPnltyInf = getKeikSochPnltyInf(keikSochPnltyInfList, pcrsCdNet, wribSvcTankaNo, keizokuGetuNum);
							
							// ANK-4330-01-00 ADD START
							// 経過措置違約金情報 に サービス課金開始日を追加
							keikSochPnltyInf.put(EKK0451B002CBSMsg1List.SVC_CHRG_STAYMD, eKK0451B002_svcChrgStaymd);
							// ANK-4330-01-00 ADD END
							
							// 経過措置対象判定
							if (isKeikSochTarget(keikSochPnltyInf, kyuseidoEndymd, svcKeiStaYmd))
							{
								// 違約金を経過措置の金額に置換
								lenWariDslSsnKin = (String)keikSochPnltyInf.get(EAC0221A010CBSMsg1List.PNLTY_TANKA);
							}
						}
					}
					// ANK-4248-00-00 ADD END
				}
				
				// ANK-3412-03-00 ADD START
				// 割引サービスコード=高速割
				else if (JKKStrConst.WRIB_SVC_KOSOKU_WRIB.equals(eKK0451B002_wribSvcCd)
					&& JKKStrConst.CD00055_SVCTK_CHU.equals(eKK0451B002_wribSvcKeiStat))
				{
					// 高速割料金コース判定フラグ(true:高速割申込可能、false:高速割申込不可)
					Boolean kousokuWariPcrsCdFlg = false;
					
					// 料金コースコードが""(空文字)ではない場合
					if (!"".equals(pcrsCdNet))
					{
						// 高速割料金コースリストの要素の数だけ処理する
						for (int l = 0; kosokuwriPcrsList.size() > l; l++)
						{
							// 処理対象のサービス契約意の料金コースコードと高速割料金リスト(l番目)が等しい場合
							if (pcrsCdNet.equals(kosokuwriPcrsList.get(l)))
							{
								// 高速割の申込可能な料金コースコードのため、高速割料金コース判定フラグにtrueを設定する
								kousokuWariPcrsCdFlg = true;
							}
						}
					}
					
					// 高速割の申込可能な料金コースの場合以下の処理を行う
					if (kousokuWariPcrsCdFlg)
					{
						// 継続月数(高速割)を算出する（ネットの解約予定月 − 高速割のサービス課金開始年月日）
						int keizokuGetuNumKousokuWari = JPCDateUtil.subtractMonth(dslRsvdYmdNet, eKK0451B002_svcChrgStaymd);
						
						List<HashMap<String, Object>> eAC0221A010ListKousokuWari = new ArrayList<HashMap<String, Object>>();
						HashMap<String,Object> eAC0221A010MapKousokuWari = new HashMap<String,Object>();
						
						// 割引サービス単項目番号
						String wribSvcTankaNoKousokuWari = "";
						
						// 割引サービス単価一覧照会（割引サービスコード）を実行し、対象料金サービスコードを取得する
						List<HashMap<String, Object>> eKK0711B001List = getWribSvcTankaIcrn(handle, param, fixedText, JKKStrConst.WRIB_SVC_KOSOKU_WRIB, JPCModelConstant.FUNC_CD_1);
						
						for (int j = 0; j < eKK0711B001List.size(); j++)
						{
							HashMap<String,Object> eKK0711B001Msg = (HashMap<String,Object>)eKK0711B001List.get(j);
							
							// 料金コースコード
							String eKK0711B001_pcrsCd = JKKStringUtil.nullToBlank((String)eKK0711B001Msg.get(EKK0711B001CBSMsg1List.PCRS_CD));
							// 料金プランコード
							String eKK0711B001_pplanCd = JKKStringUtil.nullToBlank((String)eKK0711B001Msg.get(EKK0711B001CBSMsg1List.PPLAN_CD));
							
							// EKK0711B001の取得結果の料金コースコードがネットの料金コースコードと等しい、かつ、
							// EKK0711B001の取得結果の料金プランコードがネットの料金プランコードと等しい場合
							if (eKK0711B001_pcrsCd.equals(pcrsCdNet) && eKK0711B001_pplanCd.equals(eKK0081A010PplanCd))
							{
								// 割引サービス単価番号を取得
								wribSvcTankaNoKousokuWari = JKKStringUtil.nullToBlank((String)eKK0711B001Msg.get(EKK0711B001CBSMsg1List.WRIB_SVC_TANKA_NO));
								break;
							}
						}
						
						if (!"".equals(wribSvcTankaNoKousokuWari))
						{
							// 違約金一意照会の結果
							eAC0221A010ListKousokuWari = getPnltyPrcIti(handle, retParam, fixedText, pcrsCdNet, wribSvcTankaNoKousokuWari, dslRsvdYmdNet, keizokuGetuNumKousokuWari, JPCModelConstant.FUNC_CD_1);
						}
						
						if (null != eAC0221A010ListKousokuWari && eAC0221A010ListKousokuWari.size() > 0)
						{
							eAC0221A010MapKousokuWari = (HashMap<String,Object>)eAC0221A010ListKousokuWari.get(0);
						}
						
						// 違約金単価を取得
						if (JKKStringUtil.isNullEmpty((String)eAC0221A010MapKousokuWari.get(EAC0221A010CBSMsg1List.PNLTY_TANKA)))
						{
							// 結果が取得できなかった場合、高速割解約精算金に0円を設定
							kousokuWariDslSsnKin = DSL_SSN_KIN_0;
						} else
						{
							// 結果が取得できた場合、高速割解約精算金に違約金単価を設定
							kousokuWariDslSsnKin = (String)eAC0221A010MapKousokuWari.get(EAC0221A010CBSMsg1List.PNLTY_TANKA);
							// v45.00.03 ANK-3636-08-00 DEL START
//							// ANK-3636-08-00 ADD START
//							// ↓当処理は2019年9月末リリース時に削除する↓
//							// 消費税(8%)適用終了年月日がnullまたは""ではない、かつ、消費税(8%)適用終了年月日 < ネットの解約予定日の場合、
//							// 消費税10%の違約金単価を設定する
//							if ((!JKKStringUtil.isNullEmpty(stax8PerTendymd) && dslRsvdYmdNet.compareTo(stax8PerTendymd) > 0))
//							{
//								// 消費税10%の料金に変換する
//								kousokuWariDslSsnKin = chgStax10Per(kousokuWariDslSsnKin);
//							}
//							// ↑当処理は2019年9月末リリース時に削除する↑
//							// ANK-3636-08-00 ADD END
							// v45.00.03 ANK-3636-08-00 DEL END
						}
					}
					// 高速割の申込可能な料金コースではない場合
					else
					{
						// 高速割解約精算金に0円を設定
						kousokuWariDslSsnKin = DSL_SSN_KIN_0;
					}
				}
				// ANK-3412-03-00 ADD END
			}
			
			// ANK-4640-00-00 ADD START
			// type N解約精算金(最低利用期間１年未満解約)
			// NTT卸区分が設定されている場合
			if (nttorsDiv != null)
			{
				
				HashMap<String,Object> eAC0221A010Map  = new HashMap<String,Object>();
				List<HashMap<String, Object>> eAC0221A010ListTypenSokuWari = new ArrayList<HashMap<String, Object>>();
				
				// 料金プランコードに空白を詰める
				String pplanCdBlanc = String.format("%-12s", eKK0081A010PplanCd);
				
				// 違約金一意照会
				eAC0221A010ListTypenSokuWari = getPnltyPrcIti(handle, retParam, fixedText, pcrsCdNet, pplanCdBlanc, dslRsvdYmdNet, keizokuGetuNum, JPCModelConstant.FUNC_CD_1);
				
				if (null != eAC0221A010ListTypenSokuWari && eAC0221A010ListTypenSokuWari.size() > 0)
				{
					eAC0221A010Map = (HashMap<String,Object>)eAC0221A010ListTypenSokuWari.get(0);
				}
				
				// 違約金単価を取得
				if (JKKStringUtil.isNullEmpty((String)eAC0221A010Map.get(EAC0221A010CBSMsg1List.PNLTY_TANKA)))
				{
					// 結果が取得できなかった場合、0円を設定
					sokuWariDslSsnKin = DSL_SSN_KIN_0;
				} else
				{
					// 結果が取得できた場合、取得値を設定
					sokuWariDslSsnKin = (String)eAC0221A010Map.get(EAC0221A010CBSMsg1List.PNLTY_TANKA);
				}
				
			}
			// ANK-4640-00-00 ADD END
			
			// ANK-3383-00-00 ADD START
			//*******************************************
			// eoスマートリンク違約金/割賦残金計算処理
			//*******************************************
			 //eoスマートリンクのリストの件数分、違約金/割賦残金の計算を行う
			for (int j = 0; j < smtlnkInfoList.size() ; j++)
			{
				String smtlnkDslSsnKin = "0";
				HashMap<String, Object> smtlnkInfoMap = new HashMap<String, Object>();
				HashMap<String, Object> eAC0221A010MapSmtlnk = new HashMap<String, Object>();
				
				smtlnkInfoMap = smtlnkInfoList.get(j);
				
				// 機器提供サービス契約番号の取得
				String kktkSvcKeiNo = JKKStringUtil.nullToBlank((String)smtlnkInfoMap.get("smtlnk_kktk_svc_kei_no"));
				// 割賦販売形態コードの取得
				String kapHambaiFormCd = JKKStringUtil.nullToBlank((String)smtlnkInfoMap.get("smtlnk_kap_hambai_form_cd"));
				
				if (JKKStrConst.CD01467_IKKATSU.equals(kapHambaiFormCd))
				{
					// IT1-2018-0000071 DEL START
//					List<HashMap<String, Object>> eKK0351B010List = new ArrayList<HashMap<String, Object>>();
//					HashMap<String, Object> eKK0351B010Map = new HashMap<String, Object>();
//					String eAC0221A010SmtlnkDslSsnKin = "";
//					
//					// オプションサービス契約一覧照会呼び出し
//					eKK0351B010List = getOpSvcInfo(handle, retParam, fixedText, kktkSvcKeiNo, JKKStrConst.OP_SVC_CD_SMARTLINK_PREMIUM, JPCModelConstant.FUNC_CD_1);
//					
//					for (int k = 0; k < eKK0351B010List.size() ; k++)
//					{
					// IT1-2018-0000071 DEL END
						List<HashMap<String, Object>> eKK0481B006List = new ArrayList<HashMap<String, Object>>();
						HashMap<String, Object> eKK0481B006Map = new HashMap<String, Object>();
						
					// IT2-2018-0000051 ADD START
					List<HashMap<String, Object>> eKK2541B004Smtlnk = new ArrayList<HashMap<String, Object>>();
					eKK2541B004Smtlnk = getKapKeiInfo(handle, retParam, fixedText, svcKeiNoNet, JKKStrConst.KKTK_SVC_CD_TABLET, JPCModelConstant.FUNC_CD_1);
					
					for (int k = 0; k < eKK2541B004Smtlnk.size() ; k++)
					{
						HashMap<String, Object> eKK2541B004SmtlnkMap = eKK2541B004Smtlnk.get(k);
						
						String eKK2541B004KktkSvcKeiNo = JKKStringUtil.nullToBlank((String)eKK2541B004SmtlnkMap.get(EKK2541B004CBSMsg1List.KKTK_SVC_KEI_NO));
						
						if (eKK2541B004KktkSvcKeiNo.equals(kktkSvcKeiNo))
						{
							String kapSeikyStaYm = JKKStringUtil.nullToBlank((String)eKK2541B004SmtlnkMap.get(EKK2541B004CBSMsg1List.KAP_SEIKY_STA_YM));
							
							if(JKKStringUtil.isNullBlank(kapSeikyStaYm))
							{
								keizokuGetuNum = 1;
							}
							else
							{
								// IT2-2018-0000056 ADD START
								if("01".equals(dslRsvdYmdNet.substring(6, 8)))
								{
								// IT2-2018-0000056 ADD END
									keizokuGetuNum = JPCDateUtil.subtractMonth(dslRsvdYmdNet, kapSeikyStaYm + "01");
								// IT2-2018-0000056 ADD START
								}
								else
								{
									// 解約予定日」が1日以外の場合、継続月数に+1ヶ月する
									keizokuGetuNum = JPCDateUtil.subtractMonth(dslRsvdYmdNet, kapSeikyStaYm + "01") + 1;
								}
								
								if(keizokuGetuNum < 0)
								{
									// 「解約予定日」に過去日が入力される場合があるため、継続月数がマイナスとならないようにする。
									keizokuGetuNum = 0;
								}
								// IT2-2018-0000056 ADD END
							}
							
							break;
						}
					}
					// IT2-2018-0000051 ADD END
					
					// IT1-2018-0000071 DEL START
//						eKK0351B010Map = eKK0351B010List.get(k);
//						
//						String opSvcKeiNo = JKKStringUtil.nullToBlank((String)eKK0351B010Map.get(EKK0351B010CBSMsg1List.OP_SVC_KEI_NO));
//						
					// IT1-2018-0000071 DEL END
					
						// IT1-2018-0000071 MOD START
						//// 機器提供サービス契約番号とオプションサービス契約番号から割引サービス単価番号を取得するSI/F呼び出し
						//eKK0481B006List = getWribSvcTankaNo(handle, retParam, fixedText, kktkSvcKeiNo, opSvcKeiNo, JPCModelConstant.FUNC_CD_1);
						eKK0481B006List = getWribSvcTankaNo(handle, retParam, fixedText, kktkSvcKeiNo, JKKStrConst.OP_SVC_CD_SMARTLINK_PREMIUM, JPCModelConstant.FUNC_CD_1);
						// IT1-2018-0000071 MOD END
						
						if (null != eKK0481B006List && eKK0481B006List.size() > 0)
						{
							// IT1-2018-0000071 MOD START
							//eKK0481B006Map = eKK0481B006List.get(0);
							for (int m = 0; m < eKK0481B006List.size() ; m++)
							{
								eKK0481B006Map = eKK0481B006List.get(m);
								
								String wribSvcTanka = JKKStringUtil.nullToBlank((String)eKK0481B006Map.get(EKK0481B006CBSMsg1List.WRIB_SVC_TANKA_NO));
								
								if (!JKKStringUtil.isNullBlank(wribSvcTanka))
								{
									// 違約金一意照会
									List<HashMap<String, Object>> eAC0221A010ListSmtlnk = getPnltyPrcIti(handle, retParam, fixedText, pcrsCdNet, wribSvcTanka, dslRsvdYmdNet, keizokuGetuNum, JPCModelConstant.FUNC_CD_1);
									
									if (null != eAC0221A010ListSmtlnk && eAC0221A010ListSmtlnk.size() > 0)
									{
										eAC0221A010MapSmtlnk = (HashMap<String,Object>)eAC0221A010ListSmtlnk.get(0);
									}
									
									// 違約金単価を取得
									if (JKKStringUtil.isNullEmpty((String)eAC0221A010MapSmtlnk.get(EAC0221A010CBSMsg1List.PNLTY_TANKA)))
									{
										//結果が取得できなかった場合、コンテニュー
										continue;
									}
									else
									{
										// 結果が取得できた場合、取得値を設定
										int pnltyTanka = Integer.valueOf((String)eAC0221A010MapSmtlnk.get(EAC0221A010CBSMsg1List.PNLTY_TANKA));
										int upplValue = Integer.valueOf((String)eAC0221A010MapSmtlnk.get(EAC0221A010CBSMsg1List.UPPL_VALUE));
										
										int zanKikan = upplValue - keizokuGetuNum +1;
										
										smtlnkDslSsnKin = String.valueOf(pnltyTanka * zanKikan);
										// v45.00.03 ANK-3636-08-00 DEL START
//										// ANK-3636-08-00 ADD START
//										// ↓当処理は2019年9月末リリース時に削除する↓
//										// 消費税(8%)適用終了年月日がnullまたは""ではない、かつ、消費税(8%)適用終了年月日 < ネットの解約予定日の場合、
//										// 消費税10%の違約金単価を設定する
//										if ((!JKKStringUtil.isNullEmpty(stax8PerTendymd) && dslRsvdYmdNet.compareTo(stax8PerTendymd) > 0))
//										{
//											// 消費税10%の料金に変換する
//											smtlnkDslSsnKin = chgStax10Per(smtlnkDslSsnKin);
//										}
//										// ↑当処理は2019年9月末リリース時に削除する↑
//										// ANK-3636-08-00 ADD END
										// v45.00.03 ANK-3636-08-00 DEL END
										break;
									}
								}
							}
							// IT1-2018-0000071 MOD END
						}
						else
						{
							continue;
						}
						
						// IT1-2018-0000071 DEL START
//						String wribSvcTanka = JKKStringUtil.nullToBlank((String)eKK0481B006Map.get(EKK0481B006CBSMsg1List.WRIB_SVC_TANKA_NO));
//						
//						if (!JKKStringUtil.isNullBlank(wribSvcTanka))
//						{
//							// 違約金一意照会
//							List<HashMap<String, Object>> eAC0221A010ListSmtlnk = getPnltyPrcIti(handle, retParam, fixedText, pcrsCdNet, eKK0081A010PplanCd, dslRsvdYmdNet, keizokuGetuNum, JPCModelConstant.FUNC_CD_1);
//							
//							if (null != eAC0221A010ListSmtlnk && eAC0221A010ListSmtlnk.size() > 0)
//							{
//								eAC0221A010MapSmtlnk = (HashMap<String,Object>)eAC0221A010ListSmtlnk.get(0);
//							}
//							
//							// 違約金単価を取得
//							if (JKKStringUtil.isNullEmpty((String)eAC0221A010MapSmtlnk.get(EAC0221A010CBSMsg1List.PNLTY_TANKA)))
//							{
//								// IT1-2018-0000071 MOD START
//								//// 結果が取得できなかった場合、0円を設定
//								//smtlnkDslSsnKin = DSL_SSN_KIN_0;
//								//結果が取得できなかった場合、コンテニュー
//								continue;
//								// IT1-2018-0000071 MOD END
//								
//							} else
//							{
//								// 結果が取得できた場合、取得値を設定
//								smtlnkDslSsnKin = String.valueOf(Integer.valueOf((String)eAC0221A010MapSmtlnk.get(EAC0221A010CBSMsg1List.PNLTY_TANKA)));
//								// IT1-2018-0000071 ADD START
//								break;
//								// IT1-2018-0000071 ADD START
//							}
//						}
//					}
				// IT1-2018-0000071 DEL END
				}
				else
				{
					List<HashMap<String, Object>> eKK2541B004Smtlnk = new ArrayList<HashMap<String, Object>>();
					eKK2541B004Smtlnk = getKapKeiInfo(handle, retParam, fixedText, svcKeiNoNet, JKKStrConst.KKTK_SVC_CD_TABLET, JPCModelConstant.FUNC_CD_1);
					
					for (int k = 0; k < eKK2541B004Smtlnk.size() ; k++)
					{
						HashMap<String, Object> eKK2541B004SmtlnkMap = eKK2541B004Smtlnk.get(k);
						
						String eKK2541B004KktkSvcKeiNo = JKKStringUtil.nullToBlank((String)eKK2541B004SmtlnkMap.get(EKK2541B004CBSMsg1List.KKTK_SVC_KEI_NO));
						
						if (eKK2541B004KktkSvcKeiNo.equals(kktkSvcKeiNo))
						{
							int dslRsvdGetuNum = 0;
							String rsvKapPayCnt = "0";
							
							List<HashMap<String, Object>> kapPrcList = new ArrayList<HashMap<String, Object>>();
							HashMap<String,Object> eAC0611B010Map = new HashMap<String,Object>();
							
							String nowkapZanCnt = JKKStringUtil.nullToBlank((String)eKK2541B004SmtlnkMap.get(EKK2541B004CBSMsg1List.KAP_PAY_ZAN_CNT));
							String kapSeikyStaYm = JKKStringUtil.nullToBlank((String)eKK2541B004SmtlnkMap.get(EKK2541B004CBSMsg1List.KAP_SEIKY_STA_YM));
							String kapPlanCd = JKKStringUtil.nullToBlank((String)eKK2541B004SmtlnkMap.get(EKK2541B004CBSMsg1List.KAP_PLAN_CD));
							//OM-2021-0000276 ADD START
							String kapKeiStat = JKKStringUtil.nullToBlank((String)eKK2541B004SmtlnkMap.get(EKK2541B004CBSMsg1List.KAP_KEI_STAT));
							// 割賦契約ステータスが"100：完了済"の場合、下記処理を実行
							if(JKKStrConst.CD01471_KANRYOU_ZM.equals(kapKeiStat))
							{
								// ｅｏスマートリンク明細一覧リストに"0"を設定し、ループ終了
								smtlnkInfoMap.put("smtlnk_ssn_kin_gtgk", ZERO);
								smtlnkInfoMap.put("smtlnk_ssn_kin_zan_getu", ZERO);
								break;
							}
							//OM-2021-0000276 ADD END
							
							// ANK-3383-06-00 ADD START
							// 割賦プランコード一覧照会呼び出し
							String kapPayCnt = getKapPayCnt(handle, param, fixedText, kapPlanCd, JPCModelConstant.FUNC_CD_2);
							// ANK-3383-06-00 ADD END
							
							// IT2-2018-0000050 ADD START
							// 料金スケジュール定義一覧照会
							List<HashMap<String, Object>> eCH0501B010List  = callPrcSchdlTeigiSc(handle, param, fixedText, JPCModelConstant.FUNC_CD_4);
							
							String seikyYm = "";
							
							if (null != eCH0501B010List && eCH0501B010List.size() > 0)
							{
								// 料金スケジュール定義一覧照会結果
								HashMap<String,Object> eCH0501B010Map = (HashMap<String,Object>)eCH0501B010List.get(0);
								
								// 請求年月
								seikyYm = JKKStringUtil.nullToBlank((String)eCH0501B010Map.get(ECH0501B010CBSMsg1List.SEIKY_YM));
							}
							// IT2-2018-0000050 ADD END
							
							// 解約予定日時点の継続月数
							// IT2-2018-0000050 MOD START
							//dslRsvdGetuNum = JPCDateUtil.subtractMonth(dslRsvdYmdNet, JPCBPCommon.getOpeDate(null));
							dslRsvdGetuNum = Integer.valueOf(JPCDateUtil.subtractMonth(dslRsvdYmdNet, seikyYm + "01"));
							// IT2-2018-0000050 MOD END
							
							// 解約予定日時点での支払い残回数
							rsvKapPayCnt = String.valueOf(Integer.valueOf(nowkapZanCnt) - dslRsvdGetuNum);
							
							if (Integer.valueOf(rsvKapPayCnt) < 0)
							{
								rsvKapPayCnt = "0";
							}
							// ANK-3383-06-00 ADD START
							else if (Integer.valueOf(kapPayCnt) < Integer.valueOf(rsvKapPayCnt))
							{
								// 支払い残回数が、上限値を超えた場合は、上限値を設定。
								rsvKapPayCnt = kapPayCnt;
							}
							// ANK-3383-06-00 ADD END
							
							// 割賦料金一覧照会を実行
							kapPrcList = callGetKapPcrsSc(handle, param, fixedText, pcrsCdNet, kapPlanCd, dslRsvdYmdNet, JPCModelConstant.FUNC_CD_1);
							
							if (null != kapPrcList && kapPrcList.size() > 0)
							{
								eAC0611B010Map = (HashMap<String,Object>)kapPrcList.get(0);
							}
							
							// 初回料金を取得
							String firstPrc = JKKStringUtil.nullToBlank((String)eAC0611B010Map.get(EAC0611B010CBSMsg1List.FIRST_PRC));
							// 継続料金を取得
							String keizokuPrc = JKKStringUtil.nullToBlank((String)eAC0611B010Map.get(EAC0611B010CBSMsg1List.KEIZOKU_PRC));
							
							if (JKKStringUtil.isNullBlank(kapSeikyStaYm))
							{
								// 割賦請求開始年月が未設定の場合
								smtlnkDslSsnKin = String.valueOf(Integer.valueOf(firstPrc) + (Integer.valueOf(keizokuPrc) * (Integer.valueOf(rsvKapPayCnt) - 1)));
							}
							else
							{
								// 割賦請求開始年月が設定済の場合
								smtlnkDslSsnKin = String.valueOf(Integer.valueOf(keizokuPrc) * Integer.valueOf(rsvKapPayCnt));
							}
							
							// ｅｏスマートリンク明細一覧リストに情報を設定
							smtlnkInfoMap.put("smtlnk_ssn_kin_gtgk", keizokuPrc);
							smtlnkInfoMap.put("smtlnk_ssn_kin_zan_getu", rsvKapPayCnt);
							
							// IT1-2018-0000071 ADD START
							break;
							// IT1-2018-0000071 ADD START
						}
					}
				}
				
				// 合計金額に加算
				smtlnkSsnKinAllAmnt = String.valueOf(Integer.valueOf(smtlnkSsnKinAllAmnt) + Integer.valueOf(smtlnkDslSsnKin));
				// ｅｏスマートリンク明細一覧リストに情報を設定
				smtlnkInfoMap.put("smtlnk_ssn_kin_all_amnt", smtlnkDslSsnKin);
			}
			
			
			//*******************************************
			// googleHome違約金/割賦残金計算処理
			//*******************************************
			List<HashMap<String, Object>> eKK2541B004 = new ArrayList<HashMap<String, Object>>();
			
			// 割賦契約一覧照会(サービス契約番号)呼び出し
			eKK2541B004 = getKapKeiInfo(handle, retParam, fixedText, svcKeiNoNet, JKKStrConst.KKTK_SVC_CD_TABLET, JPCModelConstant.FUNC_CD_1);
			
			//googleHomeのリストの件数分、違約金/割賦残金の計算を行う
			for (int k = 0; k < gglhmInfoList.size() ; k++)
			{
				String gglhmDslSsnKin = "0";
				HashMap<String, Object> gglhmInfoMap = new HashMap<String, Object>();
				List<HashMap<String, Object>> kapPrcList = new ArrayList<HashMap<String, Object>>();
				HashMap<String,Object> eAC0611B010Map = new HashMap<String,Object>();
				
				gglhmInfoMap = gglhmInfoList.get(k);
				
				// 機器提供サービス契約番号の取得
				String kktkSvcKeiNo = JKKStringUtil.nullToBlank((String)gglhmInfoMap.get("gglhm_kktk_svc_kei_no"));
				String tnmtBuyWay = JKKStringUtil.nullToBlank((String)gglhmInfoMap.get("gglhm_kap_hambai_form_cd"));
				
				for (int m = 0; m < eKK2541B004.size() ; m++)
				{
					int dslRsvdGetuNum = 0;
					String rsvKapPayCnt = "0";
					HashMap<String, Object> eKK2541B004Map = eKK2541B004.get(m);
					
					String eKK2541B004KktkSvcKeiNo = JKKStringUtil.nullToBlank((String)eKK2541B004Map.get(EKK2541B004CBSMsg1List.KKTK_SVC_KEI_NO));
					
					if (eKK2541B004KktkSvcKeiNo.equals(kktkSvcKeiNo))
					{
						String nowkapZanCnt = JKKStringUtil.nullToBlank((String)eKK2541B004Map.get(EKK2541B004CBSMsg1List.KAP_PAY_ZAN_CNT));
						String kapSeikyStaYm = JKKStringUtil.nullToBlank((String)eKK2541B004Map.get(EKK2541B004CBSMsg1List.KAP_SEIKY_STA_YM));
						String kapPlanCd = JKKStringUtil.nullToBlank((String)eKK2541B004Map.get(EKK2541B004CBSMsg1List.KAP_PLAN_CD));
						//OM-2021-0000276 ADD START
						String kapKeiStat = JKKStringUtil.nullToBlank((String)eKK2541B004Map.get(EKK2541B004CBSMsg1List.KAP_KEI_STAT));
						// 割賦契約ステータスが"100：完了済"の場合、下記処理を実行
						if(JKKStrConst.CD01471_KANRYOU_ZM.equals(kapKeiStat))
						{
							// ＧｏｏｇｌｅＨｏｍｅ明細一覧リストに"0"を設定し、ループ終了
							gglhmInfoMap.put("gglhm_kap_zkin_gtgk", ZERO);
							gglhmInfoMap.put("gglhm_kap_zkin_zan_getu", ZERO);
							// 合計金額に加算
							gglhmKapZkinAllAmnt = String.valueOf(Integer.valueOf(gglhmKapZkinAllAmnt) + Integer.valueOf(ZERO));
							// ＧｏｏｇｌｅＨｏｍｅ明細一覧リストに情報を設定
							gglhmInfoMap.put("gglhm_kap_zkin_all_amnt", gglhmDslSsnKin);
							break;
						}
						//OM-2021-0000276 ADD END
						
						// ANK-3383-06-00 ADD START
						// 割賦プランコード一覧照会呼び出し
						String kapPayCnt = getKapPayCnt(handle, param, fixedText, kapPlanCd, JPCModelConstant.FUNC_CD_2);
						// ANK-3383-06-00 ADD END
						
						// IT2-2018-0000050 ADD START
						// 料金スケジュール定義一覧照会
						List<HashMap<String, Object>> eCH0501B010List  = callPrcSchdlTeigiSc(handle, param, fixedText, JPCModelConstant.FUNC_CD_4);
						
						String seikyYm = "";
						
						if (null != eCH0501B010List && eCH0501B010List.size() > 0)
						{
							// 料金スケジュール定義一覧照会結果
							HashMap<String,Object> eCH0501B010Map = (HashMap<String,Object>)eCH0501B010List.get(0);
							
							// 請求年月
							seikyYm = JKKStringUtil.nullToBlank((String)eCH0501B010Map.get(ECH0501B010CBSMsg1List.SEIKY_YM));
						}
						// IT2-2018-0000050 ADD END
						
						// 解約予定日時点の継続月数
						// IT2-2018-0000050 MOD START
						//dslRsvdGetuNum = JPCDateUtil.subtractMonth(dslRsvdYmdNet, JPCBPCommon.getOpeDate(null));
						dslRsvdGetuNum = Integer.valueOf(JPCDateUtil.subtractMonth(dslRsvdYmdNet, seikyYm + "01"));
						// IT2-2018-0000050 MOD END
						
						// 解約予定日時点での支払い残回数
						rsvKapPayCnt = String.valueOf(Integer.valueOf(nowkapZanCnt) - dslRsvdGetuNum);
						
						if (Integer.valueOf(rsvKapPayCnt) < 0)
						{
							rsvKapPayCnt = "0";
						}
						// ANK-3383-06-00 ADD START
						else if (Integer.valueOf(kapPayCnt) < Integer.valueOf(rsvKapPayCnt))
						{
							// 支払い残回数が、上限値を超えた場合は、上限値を設定。
							rsvKapPayCnt = kapPayCnt;
						}
						// ANK-3383-06-00 ADD END
						
						// 割賦料金一覧照会を実行
						kapPrcList = callGetKapPcrsSc(handle, param, fixedText, pcrsCdNet, kapPlanCd, dslRsvdYmdNet, JPCModelConstant.FUNC_CD_1);
						
						if (JKKStrConst.CD01467_IKKATSU.equals(tnmtBuyWay))
						{
							// 端末購入方法が「一括」の場合
							if (null != kapPrcList && kapPrcList.size() > 0)
							{
								eAC0611B010Map = (HashMap<String,Object>)kapPrcList.get(0);
							}
							
							// 初回料金を取得
							String firstPrc = JKKStringUtil.nullToBlank((String)eAC0611B010Map.get(EAC0611B010CBSMsg1List.FIRST_PRC));
							
							gglhmDslSsnKin = String.valueOf(Integer.valueOf(firstPrc) * Integer.valueOf(rsvKapPayCnt));
							
						}
						else
						{
							// 端末購入方法が「分割」の場合
							if (null != kapPrcList && kapPrcList.size() > 0)
							{
								eAC0611B010Map = (HashMap<String,Object>)kapPrcList.get(0);
							}
							
							// 初回料金を取得
							String firstPrc = JKKStringUtil.nullToBlank((String)eAC0611B010Map.get(EAC0611B010CBSMsg1List.FIRST_PRC));
							// 継続料金を取得
							String keizokuPrc = JKKStringUtil.nullToBlank((String)eAC0611B010Map.get(EAC0611B010CBSMsg1List.KEIZOKU_PRC));
							
							if (JKKStringUtil.isNullBlank(kapSeikyStaYm))
							{
								// 割賦請求開始年月が未設定の場合
								gglhmDslSsnKin = String.valueOf(Integer.valueOf(firstPrc) + (Integer.valueOf(keizokuPrc) * (Integer.valueOf(rsvKapPayCnt) - 1)));
							}
							else
							{
								// 割賦請求開始年月が設定済の場合
								gglhmDslSsnKin = String.valueOf(Integer.valueOf(keizokuPrc) * Integer.valueOf(rsvKapPayCnt));
							}
							
							// ＧｏｏｇｌｅＨｏｍｅ明細一覧リストに情報を設定
							gglhmInfoMap.put("gglhm_kap_zkin_gtgk", keizokuPrc);
							gglhmInfoMap.put("gglhm_kap_zkin_zan_getu", rsvKapPayCnt);
						}
						
						// 合計金額に加算
						gglhmKapZkinAllAmnt = String.valueOf(Integer.valueOf(gglhmKapZkinAllAmnt) + Integer.valueOf(gglhmDslSsnKin));
						// ＧｏｏｇｌｅＨｏｍｅ明細一覧リストに情報を設定
						gglhmInfoMap.put("gglhm_kap_zkin_all_amnt", gglhmDslSsnKin);
					}
				}
			}
			// ANk-3383-00-00 ADD END
		}
		
		//ネットまたは電話の解約日が入力されているか判定する
		// ANK-3383-00-00 MOD START
		// テレビ追加
		//if (!JKKStringUtil.isNullBlank(dslRsvdYmdNet) || !JKKStringUtil.isNullBlank(dslRsvdYmdTel))
		if (!JKKStringUtil.isNullBlank(dslRsvdYmdNet) || !JKKStringUtil.isNullBlank(dslRsvdYmdTel) || !JKKStringUtil.isNullBlank(dslRsvdYmdTv))
		// ANK-3383-00-00 MOD END
		{
			String trgtSvcKeiNo = "";
			String trgtdslRsvYmd = "";
			String trgtPcrsCd = "";
			
			// 解約日が入力されているサービスのサービス契約番号を取得（どちらとも入力されていた場合、ネットを優先）
			// ANK-3383-00-00 ADD START
			if (!JKKStringUtil.isNullBlank(dslRsvdYmdTv))
			{
				HashMap<String,Object> eKK0081A010MapTv = new HashMap<String,Object>();
				
				trgtSvcKeiNo = svcKeiNoTv;
				trgtdslRsvYmd = dslRsvdYmdTv;
				
				if (!JKKStringUtil.isNullBlank(svcKeiNoTel))
				{
					HashMap<String,Object> eKK0081A010MapTel = new HashMap<String,Object>();
					
					// 20210615 OM-2021-0000557 MOD START
					// サービス契約一意照会
//					List<HashMap<String, Object>> eKK0081A010ListTel = getSvcKeiIti(handle, retParam, fixedText, svcKeiNoTel, JPCModelConstant.FUNC_CD_2);
					List<HashMap<String, Object>> eKK0081A010ListTel = getSvcKeiInfo(handle, retParam, fixedText, svcKeiNoTel, dslRsvdYmdTv);
					// 20210615 OM-2021-0000557 MOD END
					
					if (null != eKK0081A010ListTel && eKK0081A010ListTel.size() > 0)
					{
						eKK0081A010MapTel = (HashMap<String,Object>)eKK0081A010ListTel.get(0);
					}
					
					// 料金コースコードを取得
					trgtPcrsCd = JKKStringUtil.nullToBlank((String)eKK0081A010MapTel.get(EKK0081A010CBSMsg1List.PCRS_CD));
					
					// IT1-2018-0000071 ADD START
					trgtSvcKeiNo = svcKeiNoTel;
					// IT1-2018-0000071 ADD END
				}
				if (!JKKStringUtil.isNullBlank(svcKeiNoNet))
				{
					HashMap<String,Object> eKK0081A010MapNet = new HashMap<String,Object>();
					
					// 20210615 OM-2021-0000557 MOD START
					// サービス契約一意照会
//					List<HashMap<String, Object>> eKK0081A010ListNet = getSvcKeiIti(handle, retParam, fixedText, svcKeiNoNet, JPCModelConstant.FUNC_CD_2);
					List<HashMap<String, Object>> eKK0081A010ListNet = getSvcKeiInfo(handle, retParam, fixedText, svcKeiNoNet, dslRsvdYmdTv);
					// 20210615 OM-2021-0000557 MOD END
					
					if (null != eKK0081A010ListNet && eKK0081A010ListNet.size() > 0)
					{
						eKK0081A010MapNet = (HashMap<String,Object>)eKK0081A010ListNet.get(0);
					}
					
					// 料金コースコードを取得
					trgtPcrsCd = JKKStringUtil.nullToBlank((String)eKK0081A010MapNet.get(EKK0081A010CBSMsg1List.PCRS_CD));
					
					// IT1-2018-0000071 ADD START
					trgtSvcKeiNo = svcKeiNoNet;
					// IT1-2018-0000071 ADD END
				}
			}
			// ANK-3383-00-00 ADD END
			if (!JKKStringUtil.isNullBlank(dslRsvdYmdTel))
			{
				HashMap<String,Object> eKK0081A010MapTel = new HashMap<String,Object>();
				
				trgtSvcKeiNo = svcKeiNoTel;
				trgtdslRsvYmd = dslRsvdYmdTel;
				
				// 20210615 OM-2021-0000557 MOD START
				// サービス契約一意照会
//				List<HashMap<String, Object>> eKK0081A010ListTel = getSvcKeiIti(handle, retParam, fixedText, svcKeiNoTel, JPCModelConstant.FUNC_CD_2);
				List<HashMap<String, Object>> eKK0081A010ListTel = getSvcKeiInfo(handle, retParam, fixedText, svcKeiNoTel, dslRsvdYmdTel);
				// 20210615 OM-2021-0000557 MOD END
				
				if (null != eKK0081A010ListTel && eKK0081A010ListTel.size() > 0)
				{
					eKK0081A010MapTel = (HashMap<String,Object>)eKK0081A010ListTel.get(0);
				}
				
				// 料金コースコードを取得
				trgtPcrsCd = JKKStringUtil.nullToBlank((String)eKK0081A010MapTel.get(EKK0081A010CBSMsg1List.PCRS_CD));
				
				// IT1-2018-0000072 ADD START
				if (!JKKStringUtil.isNullBlank(svcKeiNoNet))
				{
					HashMap<String,Object> eKK0081A010MapNet = new HashMap<String,Object>();
					
					// 20210615 OM-2021-0000557 MOD START
					// サービス契約一意照会
//					List<HashMap<String, Object>> eKK0081A010ListNet = getSvcKeiIti(handle, retParam, fixedText, svcKeiNoNet, JPCModelConstant.FUNC_CD_2);
					List<HashMap<String, Object>> eKK0081A010ListNet = getSvcKeiInfo(handle, retParam, fixedText, svcKeiNoNet, dslRsvdYmdTel);
					// 20210615 OM-2021-0000557 MOD END
					
					if (null != eKK0081A010ListNet && eKK0081A010ListNet.size() > 0)
					{
						eKK0081A010MapNet = (HashMap<String,Object>)eKK0081A010ListNet.get(0);
					}
					
					// 料金コースコードを取得
					trgtPcrsCd = JKKStringUtil.nullToBlank((String)eKK0081A010MapNet.get(EKK0081A010CBSMsg1List.PCRS_CD));
					
					trgtSvcKeiNo = svcKeiNoNet;
					
				}
				// IT1-2018-0000072 ADD END
			}
			
			if (!JKKStringUtil.isNullBlank(dslRsvdYmdNet))
			{
				trgtSvcKeiNo = svcKeiNoNet;
				trgtdslRsvYmd = dslRsvdYmdNet;
				trgtPcrsCd = pcrsCdNet;
			}
			
			// OM-2019-0000754 MOD START
			if ( trgtPcrsCd != null && !"".equals(trgtPcrsCd ))
			{
				//サービス契約回線内訳一覧照会（サービス契約番号）を取得
				String svcKeiKaisenUcwkNo = callGetKaisenTgSvkei(handle, retParam, scCall, fixedText, trgtSvcKeiNo);
				
				// 工事費割賦契約一覧照会
				eKK3131B010List = callGetKojihiKapKeiSc(handle, retParam, fixedText, svcKeiKaisenUcwkNo, JPCModelConstant.FUNC_CD_2);
				
				if (null != eKK3131B010List && eKK3131B010List.size() > 0)
				{
					List<HashMap<String, Object>> kapPrcList = new ArrayList<HashMap<String, Object>>();
					String kapPlanCd = "";
					String nowKapPayZanCnt = "";
					String kapSeikyStaYm = "";
					String kapKeiSvcStaYmd = "";
					// ST-2018-0000011 ADD START
					String kapKeiChrgStaYmd = "";
					// ST-2018-0000011 ADD END
					
					HashMap<String,Object> eKK3131B010Map = (HashMap<String,Object>)eKK3131B010List.get(0);
					
					// 工事費割賦契約一覧照会より割賦プランコードを取得
					kapPlanCd = JKKStringUtil.nullToBlank((String)eKK3131B010Map.get(EKK3131B010CBSMsg1List.KAP_PLAN_CD));
					nowKapPayZanCnt = JKKStringUtil.nullToBlank((String)eKK3131B010Map.get(EKK3131B010CBSMsg1List.KAP_PAY_ZAN_CNT));
					kapSeikyStaYm = JKKStringUtil.nullToBlank((String)eKK3131B010Map.get(EKK3131B010CBSMsg1List.KAP_SEIKY_STA_YM));
					kapKeiSvcStaYmd = JKKStringUtil.nullToBlank((String)eKK3131B010Map.get(EKK3131B010CBSMsg1List.KAP_KEI_SVC_STAYMD));
					// ST-2018-0000011 ADD START
					kapKeiChrgStaYmd = JKKStringUtil.nullToBlank((String)eKK3131B010Map.get(EKK3131B010CBSMsg1List.KAP_KEI_CHRG_STAYMD));
					// ST-2018-0000011 ADD END
					//OM-2021-0000276 ADD START
					String kapKeiStat = JKKStringUtil.nullToBlank((String)eKK3131B010Map.get(EKK3131B010CBSMsg1List.KAP_KEI_STAT));
					// OM-2021-0002016 ADD START
					String kapPayCnt = getKapPayCnt(handle, param, fixedText, kapPlanCd, JPCModelConstant.FUNC_CD_2);	// 割賦支払い総回数
					// OM-2021-0002016 ADD END
					// 割賦契約ステータスが"100：完了済"の場合、下記処理を実行
					if(JKKStrConst.CD01471_KANRYOU_ZM.equals(kapKeiStat))
					{
						// ０円を設定
						stdardKojihiZanKin = DSL_SSN_KIN_0;
					} 
					else 
					{
					//OM-2021-0000276 ADD END
						// IT1-2018-0000072 ADD START
						if (!JKKStringUtil.isNullBlank(kapKeiChrgStaYmd))
						{
						// IT1-2018-0000072 ADD END
							// 割賦支払い残回数の算出を行う
							// ST-2018-0000011 MOD START
							//kapPayZanCnt = calckapZanNum(handle, retParam, fixedText, trgtPcrsCd, kapPlanCd, kapKeiSvcStaYmd, nowKapPayZanCnt, trgtdslRsvYmd);
							kapPayZanCnt = calckapZanNum(handle, retParam, fixedText, trgtPcrsCd, kapPlanCd, kapKeiSvcStaYmd, nowKapPayZanCnt, trgtdslRsvYmd, kapKeiChrgStaYmd);
							// ST-2018-0000011 MOD END
						// IT1-2018-0000072 ADD START
						}
						// IT1-2018-0000072 ADD END
						
						// ANK-3636-00-00 MOD START
						// ANK-3951-00-00 MOD START
//						if (JKKStrConst.KAP_PLAN_CD_BUNKATSU.equals(kapPlanCd) || JKKStrConst.KAP_PLAN_CD_BUNKATSU_10_PERCENT.equals(kapPlanCd))
						if (JKKStrConst.KAP_PLAN_CD_BUNKATSU.equals(kapPlanCd) || JKKStrConst.KAP_PLAN_CD_BUNKATSU_10_PERCENT.equals(kapPlanCd)
								|| JKKStrConst.KAP_PLAN_CD_BUNKATSU_24_10PER.equals(kapPlanCd))
						// ANK-3951-00-00 MOD END
						// ANK-3636-00-00 MOD END
						{
							HashMap<String,Object> eAC0611B010Map = new HashMap<String,Object>();
							
							// 割賦料金一覧照会を実行
							// ANK-3636-00-00 MOD START
							kapPrcList = callGetKapPcrsSc(handle, param, fixedText, trgtPcrsCd, kapPlanCd ,trgtdslRsvYmd, JPCModelConstant.FUNC_CD_1);
							// ANK-3636-00-00 MOD END
							
							if (null != kapPrcList && kapPrcList.size() > 0)
							{
								eAC0611B010Map = (HashMap<String,Object>)kapPrcList.get(0);
							}
							//#87277 ADD START 
							if(null != eAC0611B010Map && eAC0611B010Map.size() > 0){
							//#87277 ADD END
							
							    // 初回料金を取得
							    String firstPrc = JKKStringUtil.nullToBlank((String)eAC0611B010Map.get(EAC0611B010CBSMsg1List.FIRST_PRC));
							    // 継続料金を取得
							    String keizokuPrc = JKKStringUtil.nullToBlank((String)eAC0611B010Map.get(EAC0611B010CBSMsg1List.KEIZOKU_PRC));
							
							    // OM-2021-0002016 MOD START
						    //	if (JKKStringUtil.isNullBlank(kapSeikyStaYm))
							    if (kapPayZanCnt.equals(kapPayCnt))
							    // OM-2021-0002016 MOD END
							    {
								    // 「割賦残回数」が「割賦総回数」と同じ場合（ 初回料金 ＋ 継続料金 × （割賦残回数 − １））
								    stdardKojihiZanKin = String.valueOf( Integer.parseInt(firstPrc) + Integer.parseInt(keizokuPrc) * (Integer.parseInt(kapPayZanCnt) - 1) );
							    } else
							    {
								    // 「割賦残回数」が「割賦総回数」と異なる場合（ 継続料金 × 割賦残回数 ）
								    stdardKojihiZanKin = String.valueOf( Integer.parseInt(keizokuPrc) * Integer.parseInt(kapPayZanCnt) );
							    }
							//#87277 ADD START
							}
							//#87277 ADD END
						// ANK-3636-00-00 MOD START
						} else if (JKKStrConst.KAP_PLAN_CD_IKKATSU.equals(kapPlanCd) || JKKStrConst.KAP_PLAN_CD_IKKATSU_10_PERCENT.equals(kapPlanCd))
						// ANK-3636-00-00 MOD END
						{
							HashMap<String,Object> eAC0611B010Map = new HashMap<String,Object>();
							
							// 割賦料金一覧照会を実行
							// ANK-3636-00-00 MOD START
							kapPrcList = callGetKapPcrsSc(handle, param, fixedText, trgtPcrsCd, kapPlanCd ,trgtdslRsvYmd, JPCModelConstant.FUNC_CD_1);
							// ANK-3636-00-00 MOD END
							
							if (null != kapPrcList && kapPrcList.size() > 0)
							{
								eAC0611B010Map = (HashMap<String,Object>)kapPrcList.get(0);
							}
							//#87277 ADD START 
							if(null != eAC0611B010Map && eAC0611B010Map.size() > 0){
							//#87277 ADD END
							    // 初回料金を取得
							    String firstPrc = JKKStringUtil.nullToBlank((String)eAC0611B010Map.get(EAC0611B010CBSMsg1List.FIRST_PRC));
							
							    if (JKKStringUtil.isNullBlank(kapSeikyStaYm) 
									    || trgtdslRsvYmd.compareTo(kapSeikyStaYm) < 0)
							    {
								    // 割賦請求開始年月が未設定または、割賦請求開始年月が解約予定日よりも後の場合（ 初回料金 ）
								    // ST-2018-0000011 MOD START
								    //stdardKojihiZanKin = firstPrc;
								    stdardKojihiZanKin = String.valueOf( Integer.valueOf(firstPrc) * Integer.valueOf(kapPayZanCnt));
								    // ST-2018-0000011 MOD END
							    } else
							    {
								    // 割賦請求開始年月が解約予定日以前の場合、０円
								    stdardKojihiZanKin = DSL_SSN_KIN_0;
							    }
						    //#87277 ADD START
						    }
						    //#87277 ADD END
						}
					//OM-2021-0000276 ADD START
					}
					//OM-2021-0000276 ADD END
				}
			}
			// OM-2019-0000754 MOD END
			
			// ANK-4248-03-00 DEL START
//			// ANK-3383-00-00 ADD START
//			Boolean kojihiKapCpFlg = false;
			// ANK-4248-03-00 DEL END
			// IT1-2018-0000071 ADD START
			String wribSvcKeiNo = "";
			String wribSvcChrgStaYmd = "";
			// IT1-2018-0000071 ADD END
			// ANK-4248-03-00 DEL START
//			// ANK-3951-00-00 ADD START
//			Boolean kojihiKapCp24Flg = false;
//			Boolean kojihiKapCpIktFlg = false;
//			// ANK-3951-00-00 ADD END
			// ANK-4248-03-00 DEL END
			// OM-2022-0000518 ADD START
			boolean hasHyojunKojihiCp = false;
			// OM-2022-0000518 ADD END
			eKK0451B002List = getWribSvckei(handle, param, fixedText, trgtSvcKeiNo, JPCModelConstant.FUNC_CD_1);
			for (int k = 0; k < eKK0451B002List.size(); k++)
			{
				HashMap<String, Object> eKK0451B002Msg = (HashMap<String, Object>)eKK0451B002List.get(k);
				
				// IT1-2018-0000071 ADD START
				//割引サービス契約番号
				wribSvcKeiNo = JKKStringUtil.nullToBlank((String)eKK0451B002Msg.get(EKK0451B002CBSMsg1List.WRIB_SVC_KEI_NO));
				wribSvcChrgStaYmd = JKKStringUtil.nullToBlank((String)eKK0451B002Msg.get(EKK0451B002CBSMsg1List.SVC_CHRG_STAYMD));
				// IT1-2018-0000071 ADD END
				//割引サービスコード
				String eKK0451B002_wribSvcCd = JKKStringUtil.nullToBlank((String)eKK0451B002Msg.get(EKK0451B002CBSMsg1List.WRIB_SVC_CD));
				//割引サービスステータス
				String eKK0451B002_wribSvcKeiStat = JKKStringUtil.nullToBlank((String)eKK0451B002Msg.get(EKK0451B002CBSMsg1List.WRIB_SVC_KEI_STAT));
				
				// 標準工事費相当額キャンペーンの情報取得
				// 適用回数が30回の割引サービスコードの場合
				if((JKKStrConst.WRIB_SVC_KOJIHI_KAP_CP_TEL.equals(eKK0451B002_wribSvcCd) || JKKStrConst.WRIB_SVC_KOJIHI_KAP_CP_NET.equals(eKK0451B002_wribSvcCd))
					&& (JKKStrConst.CD00055_UKZM.equals(eKK0451B002_wribSvcKeiStat) || JKKStrConst.CD00055_SVCTK_CHU.equals(eKK0451B002_wribSvcKeiStat)))
				{
					// OM-2022-0000518 MOD START
//						kojihiKapCpFlg = true;
					hasHyojunKojihiCp = true;
					// OM-2022-0000518 MOD END
					break;
				}
				// ANK-3951-00-00 ADD START
				// 取得した割引サービスコードが適用回数24回のものであれば
				if((JKKStrConst.WRIB_SVC_KOJIHI_KAP_CP_TEL_24.equals(eKK0451B002_wribSvcCd) || JKKStrConst.WRIB_SVC_KOJIHI_KAP_CP_NET_24.equals(eKK0451B002_wribSvcCd))
							&& (JKKStrConst.CD00055_UKZM.equals(eKK0451B002_wribSvcKeiStat) || JKKStrConst.CD00055_SVCTK_CHU.equals(eKK0451B002_wribSvcKeiStat)))
				{
					// OM-2022-0000518 MOD START
//						kojihiKapCp24Flg = true;
					hasHyojunKojihiCp = true;
					// OM-2022-0000518 MOD END
					break;
				}
				// ANK-3951-00-00 ADD END
				// IT1-2021-0000040 ADD START
				// 取得した割引サービスコードが適用回数1回のものであれば
				if((JKKStrConst.WRIB_SVC_KOJIHI_KAP_CP_TEL_IKT.equals(eKK0451B002_wribSvcCd))
							&& (JKKStrConst.CD00055_UKZM.equals(eKK0451B002_wribSvcKeiStat) || JKKStrConst.CD00055_SVCTK_CHU.equals(eKK0451B002_wribSvcKeiStat)))
				{
					// OM-2022-0000518 MOD START
//						kojihiKapCpIktFlg = true;
					hasHyojunKojihiCp = true;
					// OM-2022-0000518 MOD END
					break;
				}
				// IT1-2021-0000040 ADD END
			}
			// ANK-4248-03-00 ADD START
			// 標準工事費割引ＣＰサービス契約番号リスト
			List<String> kojihiCpSvcKeiNoList = new ArrayList<String>();
			// 同回線のサービス契約を取得
			List<Map<String, Object>> eKK0081B029List = getSvcKeiInfoEKK0081B029(handle, retParam, fixedText, trgtSvcKeiNo, JPCModelConstant.FUNC_CD_2);
			for (int i = 0; eKK0081B029List != null && i < eKK0081B029List.size(); i++)
			{
				HashMap<String, Object> eKK0081B029Msg = (HashMap<String, Object>)eKK0081B029List.get(i);
				//サービス契約番号
				String eKK0081B029_svcKeiNo = JKKStringUtil.nullToBlank((String)eKK0081B029Msg.get(EKK0081B029CBSMsg1List.SVC_KEI_NO));
				//サービス契約一意照会
				eKK0081A010List = getSvcKeiIti(handle, retParam, fixedText, eKK0081B029_svcKeiNo, JPCModelConstant.FUNC_CD_2);
				HashMap<String, Object> eKK0081A010Msg = (HashMap<String, Object>)eKK0081A010List.get(0);
				//料金グループコード
				String eKK0081A010_prcGrpCd = JKKStringUtil.nullToBlank((String)eKK0081A010Msg.get(EKK0081A010CBSMsg1List.PRC_GRP_CD));
				// 同一回線のネットと電話は全て標準工事費割引ＣＰサービス契約番号リストに追加
				if (checkArray(PRC_GRP_CD, 0, eKK0081A010_prcGrpCd) || checkArray(PRC_GRP_CD, 1, eKK0081A010_prcGrpCd))
				{
					kojihiCpSvcKeiNoList.add(eKK0081B029_svcKeiNo);
				}
			}
			
			//**********************************************
			// 標準工事費割引キャンペーン情報取得処理
			//**********************************************
			if (kojihiCpSvcKeiNoList != null && kojihiCpSvcKeiNoList.size() > 0)
			{
				// 工事費割引CP割引サービス契約番号
				String kojihiCpWribSvcKeiNo = "";
				// 工事費割引CP割引サービス契約ステータス
				String kojihiCpWribSvcChrgStaYmd = "";
				for (int i = 0; i < kojihiCpSvcKeiNoList.size(); i++)
				{
					String svcKeiNo = JKKStringUtil.nullToBlank(kojihiCpSvcKeiNoList.get(i));
					eKK0451B002List = getWribSvckei(handle, param, fixedText, svcKeiNo, JPCModelConstant.FUNC_CD_1);
					for (int j = 0; j < eKK0451B002List.size(); j++)
					{
						Map<String, Object> eKK0451B002Msg = (Map<String, Object>)eKK0451B002List.get(j);
						
						// 割引サービスコード
						String eKK0451B002_wribSvcCd = JKKStringUtil.nullToBlank((String)eKK0451B002Msg.get(EKK0451B002CBSMsg1List.WRIB_SVC_CD));
						// 割引サービスステータス
						String eKK0451B002_wribSvcKeiStat = JKKStringUtil.nullToBlank((String)eKK0451B002Msg.get(EKK0451B002CBSMsg1List.WRIB_SVC_KEI_STAT));
						// 割引サービス契約番号
						String eKK0451B002_wribSvcKeiNo = JKKStringUtil.nullToBlank((String)eKK0451B002Msg.get(EKK0451B002CBSMsg1List.WRIB_SVC_KEI_NO));
						// サービス課金開始年月日
						String eKK0451B002_wribSvcChrgStaYmd = JKKStringUtil.nullToBlank((String)eKK0451B002Msg.get(EKK0451B002CBSMsg1List.SVC_CHRG_STAYMD));
						
						// 受付済かサービス提供中の標準工事費割引キャンペーンがあれば割引サービス契約の内容を取得
						if(HYOJUN_KOJIHI_WRBK_CP_LIST.contains(eKK0451B002_wribSvcCd)
							&& (JKKStrConst.CD00055_UKZM.equals(eKK0451B002_wribSvcKeiStat) || JKKStrConst.CD00055_SVCTK_CHU.equals(eKK0451B002_wribSvcKeiStat)))
						{
							if (!JKKStringUtil.isNullBlank(eKK0451B002_wribSvcKeiNo))
							{
								if (JKKStringUtil.isNullBlank(kojihiCpWribSvcKeiNo))
								{
									// 工事費割引CPが未設定なら設定する
									kojihiCpWribSvcKeiNo = eKK0451B002_wribSvcKeiNo;
									kojihiCpWribSvcChrgStaYmd = eKK0451B002_wribSvcChrgStaYmd;
								}
								else if (Integer.parseInt(eKK0451B002_wribSvcKeiNo) > Integer.parseInt(kojihiCpWribSvcKeiNo))
								{
									// 退避した工事費割引CPより新しければ設定し直す
									kojihiCpWribSvcKeiNo = eKK0451B002_wribSvcKeiNo;
									kojihiCpWribSvcChrgStaYmd = eKK0451B002_wribSvcChrgStaYmd;
								}
							}
						}
					}
				}
				
				// 標準工事費割引ＣＰがある場合
				if (!JKKStringUtil.isNullBlank(kojihiCpWribSvcKeiNo))
				{
					String sotogkCpWribSvcKeiNo = wribSvcKeiNo;
					// 標準工事費相当額割引ＣＰが見つかっていない場合は標準工事費割引ＣＰを設定
					if (!hasHyojunKojihiCp)
					{
						wribSvcKeiNo = kojihiCpWribSvcKeiNo;
						wribSvcChrgStaYmd = kojihiCpWribSvcChrgStaYmd;
						hasHyojunKojihiCp = true;
					}
					// 標準工事費相当額割引ＣＰが見つかっている場合は割引サービス契約番号を比較して新しければＣＰを置き換える
					else if (Integer.parseInt(sotogkCpWribSvcKeiNo) < Integer.parseInt(kojihiCpWribSvcKeiNo))
					{
						wribSvcKeiNo = kojihiCpWribSvcKeiNo;
						wribSvcChrgStaYmd = kojihiCpWribSvcChrgStaYmd;
					}
				}
			}
			// ANK-4248-03-00 ADD END
			// OM-2022-0000518 ADD START
			if(hasHyojunKojihiCp && !JKKStringUtil.isNullBlank(wribSvcChrgStaYmd))
			{
				// キャンペーンの適用回数計算処理
				stdardKojihiCmpZanCnt = getKojihiWribCampainZkaisu(handle, param, fixedText, wribSvcKeiNo, wribSvcChrgStaYmd, trgtdslRsvYmd);
			}
			// OM-2022-0000518 ADD END
		}
			
			
			// OM-2022-0000518 DEL START
//			// IT1-2018-0000071 MOD START
//			//if(kojihiKapCpFlg)
//			if(kojihiKapCpFlg && !JKKStringUtil.isNullBlank(wribSvcChrgStaYmd))
//			// IT1-2018-0000071 MOD END
//			{
//				//*******************************************
//				// 工事費相当額キャンペーンの適用残回数計算処理
//				//*******************************************
//				//工事費相当額キャンペーンの適用残回数の計算（ネット＞電話＞テレビの優先順位）
//				String wribSvcDtlCd = "";
//				if (!JKKStringUtil.isNullBlank(dslRsvdYmdTv))
//				{
//					wribSvcDtlCd = JKKStrConst.WRIB_SVC_DTL_CD_WS5000000003;
//				}
//				if (!JKKStringUtil.isNullBlank(dslRsvdYmdTel))
//				{
//					wribSvcDtlCd = JKKStrConst.WRIB_SVC_DTL_CD_WS5000000003;
//				}
//				if (!JKKStringUtil.isNullBlank(dslRsvdYmdNet))
//				{
//					wribSvcDtlCd = JKKStrConst.WRIB_SVC_DTL_CD_WS5000000001;
//				}
//				
//				// キャンペーンの適用回数計算処理
//				// IT1-2018-0000071 MOD START
//				//stdardKojihiCmpZanCnt = getKojihiWribCampainZkaisu(handle, param, fixedText, wribSvcDtlCd, trgtdslRsvYmd);
//				stdardKojihiCmpZanCnt = getKojihiWribCampainZkaisu(handle, param, fixedText, wribSvcDtlCd, wribSvcKeiNo, wribSvcChrgStaYmd, trgtdslRsvYmd);
//				// IT1-2018-0000071 MOD END
//			}
//			// ANK-3383-00-00 ADD END
//			// ANK-3951-00-00 ADD START
//			// 割賦24回の割引サービスコードの場合
//			if(kojihiKapCp24Flg && !JKKStringUtil.isNullBlank(wribSvcChrgStaYmd))
//			{
//				//*******************************************
//				// 工事費相当額キャンペーンの適用残回数計算処理
//				//*******************************************
//				//工事費相当額キャンペーンの適用残回数の計算（ネット＞電話＞テレビの優先順位）
//				String wribSvcDtlCd24 = "";
//				if (!JKKStringUtil.isNullBlank(dslRsvdYmdTv))
//				{
//					wribSvcDtlCd24 = JKKStrConst.WRIB_SVC_DTL_CD_WS5000000007;
//				}
//				if (!JKKStringUtil.isNullBlank(dslRsvdYmdTel))
//				{
//					wribSvcDtlCd24 = JKKStrConst.WRIB_SVC_DTL_CD_WS5000000007;
//				}
//				if (!JKKStringUtil.isNullBlank(dslRsvdYmdNet))
//				{
//					wribSvcDtlCd24 = JKKStrConst.WRIB_SVC_DTL_CD_WS5000000005;
//				}
//				
//				// キャンペーンの適用回数計算処理
//				stdardKojihiCmpZanCnt = getKojihiWribCampainZkaisu(handle, param, fixedText, wribSvcDtlCd24, wribSvcKeiNo, wribSvcChrgStaYmd, trgtdslRsvYmd);
//			}
//			// IT1-2021-0000040 ADD START
//			// 割賦一括払いの割引サービスコードの場合
//			if(kojihiKapCpIktFlg && !JKKStringUtil.isNullBlank(wribSvcChrgStaYmd))
//			{
//				//*******************************************
//				// 工事費相当額キャンペーンの適用残回数計算処理
//				//*******************************************
//				//工事費相当額キャンペーンの適用残回数の計算
//				String wribSvcDtlCdIkt = "";
//				if (!JKKStringUtil.isNullBlank(dslRsvdYmdTv))
//				{
//					wribSvcDtlCdIkt = JKKStrConst.WRIB_SVC_DTL_CD_WS5000000008;
//				}
//				if (!JKKStringUtil.isNullBlank(dslRsvdYmdTel))
//				{
//					wribSvcDtlCdIkt = JKKStrConst.WRIB_SVC_DTL_CD_WS5000000008;
//				}
//				
//				// キャンペーンの適用回数計算処理
//				stdardKojihiCmpZanCnt = getKojihiWribCampainZkaisu(handle, param, fixedText, wribSvcDtlCdIkt, wribSvcKeiNo, wribSvcChrgStaYmd, trgtdslRsvYmd);
//			}
//			// IT1-2021-0000040 ADD END
//		}
		// OM-2022-0000518 DEL END
		
		
		//テレビの解約日が入力されているか判定する
		if (!JKKStringUtil.isNullBlank(dslRsvdYmdTv))
		{
			HashMap<String,Object> eKK0081A010MapTv = new HashMap<String,Object>();
			HashMap<String,Object> eAC0221A010MapTv = new HashMap<String,Object>();
			
			// 20210615 OM-2021-0000557 MOD START
			// サービス契約一意照会
//			List<HashMap<String, Object>>eKK0081A010ListTv = getSvcKeiIti(handle, retParam, fixedText, svcKeiNoTv, JPCModelConstant.FUNC_CD_2);
			List<HashMap<String, Object>>eKK0081A010ListTv = getSvcKeiInfo(handle, retParam, fixedText, svcKeiNoTv, dslRsvdYmdTv);
			// 20210615 OM-2021-0000557 MOD END
			
			if (null != eKK0081A010ListTv && eKK0081A010ListTv.size() > 0)
			{
				eKK0081A010MapTv = (HashMap<String,Object>)eKK0081A010ListTv.get(0);
				
			}
			
			// サービス開始年月日を取得
			String svcKeiStaYmdTv = JKKStringUtil.nullToBlank((String)eKK0081A010MapTv.get(EKK0081A010CBSMsg1List.SVC_STA_YMD));
			// 料金コースコードを取得
			pcrsCdTv = JKKStringUtil.nullToBlank((String)eKK0081A010MapTv.get(EKK0081A010CBSMsg1List.PCRS_CD));
			// 料金プランコードを取得
			String pplanCdTv = JKKStringUtil.nullToBlank((String)eKK0081A010MapTv.get(EKK0081A010CBSMsg1List.PPLAN_CD));
			// OM-2020-0000939 ADD START
			// サービス課金開始年月日を取得
			String svcChrgStaYmdTv = JKKStringUtil.nullToBlank((String)eKK0081A010MapTv.get(EKK0081A010CBSMsg1List.SVC_CHRG_STAYMD));
			// 継続月数を算出する（この値は後続のＳＴＢの継続月数の設定条件に使用する。）
			// 計算式(テレビの解約予定月-テレビのサービス課金開始月)+1ヵ月
			int tmpKeizokuGetuNumTv = JPCDateUtil.subtractMonth(dslRsvdYmdTv, svcChrgStaYmdTv)+1;
			// OM-2020-0000939 ADD END
			
			// 20210615 OM-2021-0000557 MOD START
			//マンション情報検索
//			String mansionBukkenCd = selectEkk0861(handle, retParam, fixedText, svcKeiNoTv, JPCModelConstant.FUNC_CD_2);
			String mansionBukkenCd;
			mansionBukkenCd = selectEkk0861(handle, retParam, fixedText, svcKeiNoTv, dslRsvdYmdTv, JPCModelConstant.FUNC_CD_3);
			
			// 提供方式契約番号を取得
			String tkHshkKeiNo = JKKStringUtil.nullToBlank((String)eKK0081A010MapTv.get(EKK0081A010CBSMsg1List.TK_HOSHIKI_KEI_NO));
			
			// サービス契約．提供方式契約番号が存在する かつ マンション物件コードが取得できなかった場合
			if (!JKKStringUtil.isNullBlank(tkHshkKeiNo) && JKKStringUtil.isNullEmpty(mansionBukkenCd))
			{
				mansionBukkenCd = selectEkk0861(handle, retParam, fixedText, svcKeiNoTv, dslRsvdYmdTv, JPCModelConstant.FUNC_CD_2);
			}
			// 20210615 OM-2021-0000557 MOD END
			
			// 違約金一覧照会実行時に使用する料金プランコードの特定を行う
			String pnltyPplanCdTv = selectPnltyPplanCdTv(pcrsCdTv, pplanCdTv, mansionBukkenCd);
			
			// 継続月数を算出する（テレビの解約予定月 − テレビのサービス開始月）
			int keizokuGetuNumTv = JPCDateUtil.subtractMonth(dslRsvdYmdTv, svcKeiStaYmdTv);
			
			// 違約金一意照会
			List<HashMap<String, Object>> eAC0221A010ListTv = getPnltyPrcIti(handle, retParam, fixedText, pcrsCdTv, pnltyPplanCdTv, dslRsvdYmdTv, keizokuGetuNumTv, JPCModelConstant.FUNC_CD_1);
			
			if (null != eAC0221A010ListTv && eAC0221A010ListTv.size() > 0)
			{
				eAC0221A010MapTv = (HashMap<String,Object>)eAC0221A010ListTv.get(0);
			}
			
			// 違約金単価を取得
			if (JKKStringUtil.isNullEmpty((String)eAC0221A010MapTv.get(EAC0221A010CBSMsg1List.PNLTY_TANKA)))
			{
				// 結果が取得できなかった場合、0円を設定
				tvDslSsnKin = DSL_SSN_KIN_0;
			} else
			{
				// 結果が取得できた場合、取得値を設定
				tvDslSsnKin = (String)eAC0221A010MapTv.get(EAC0221A010CBSMsg1List.PNLTY_TANKA);
				// v45.00.03 ANK-3636-08-00 DEL START
//				// ANK-3636-08-00 ADD START
//				// ↓当処理は2019年9月末リリース時に削除する↓
//				// 消費税(8%)適用終了年月日がnullまたは""ではない、かつ、消費税(8%)適用終了年月日 < ネットの解約予定日の場合、
//				// 消費税10%の違約金単価を設定する
//				// IT1-2019-0000066 MOD START
//				//if ((!JKKStringUtil.isNullEmpty(stax8PerTendymd) && dslRsvdYmdNet.compareTo(stax8PerTendymd) > 0))
//				if ((!JKKStringUtil.isNullEmpty(stax8PerTendymd) && dslRsvdYmdTv.compareTo(stax8PerTendymd) > 0))
//				// IT1-2019-0000066 MOD END
//				{
//					// 消費税10%の料金に変換する
//					tvDslSsnKin = chgStax10Per((String)eAC0221A010MapTv.get(EAC0221A010CBSMsg1List.PNLTY_TANKA));
//				}
//				// ↑当処理は2019年9月末リリース時に削除する↑
//				// ANK-3636-08-00 ADD END
				// v45.00.03 ANK-3636-08-00 DEL END
			}
			
			// ANK-3383-00-00 ADD START
			//*************************************
			// スターｃｈセット割解約精算金計算処理
			//*************************************
			// テレビの割引サービス契約一覧照会（サービス契約番号）(EKK0451B002)
			eKK0451B002List = getWribSvckei(handle, param, fixedText, svcKeiNoTv, JPCModelConstant.FUNC_CD_1);
			
			for (int i = 0; i < eKK0451B002List.size(); i++)
			{
				HashMap<String, Object> eKK0451B002Msg = (HashMap<String, Object>)eKK0451B002List.get(i);
				//割引サービス契約番号
				String eKK0451B002_wribSvcKeiNo = JKKStringUtil.nullToBlank((String)eKK0451B002Msg.get(EKK0451B002CBSMsg1List.WRIB_SVC_KEI_NO));
				//割引サービスコード
				String eKK0451B002_wribSvcCd = JKKStringUtil.nullToBlank((String)eKK0451B002Msg.get(EKK0451B002CBSMsg1List.WRIB_SVC_CD));
				//割引サービスステータス
				String eKK0451B002_wribSvcKeiStat = JKKStringUtil.nullToBlank((String)eKK0451B002Msg.get(EKK0451B002CBSMsg1List.WRIB_SVC_KEI_STAT));
				
				// スターｃｈセット割の情報取得
				if(JKKStrConst.WRIB_SVC_BS_STAR_CHANNEL_SET.equals(eKK0451B002_wribSvcCd)
					// IT1-2018-0000074 MOD START
					//&& (JKKStrConst.CD00055_UKZM.equals(eKK0451B002_wribSvcKeiStat) || JKKStrConst.CD00055_SVCTK_CHU.equals(eKK0451B002_wribSvcKeiStat)))
						&& JKKStrConst.CD00055_SVCTK_CHU.equals(eKK0451B002_wribSvcKeiStat))
					// IT1-2018-0000074 MOD END
				{
					HashMap<String,Object> eKK0451A010Map = new HashMap<String,Object>();
					
					// 割引サービス契約一意照会
					eKK0451A010List = getWribSvckeiIti(handle, retParam, fixedText, eKK0451B002_wribSvcKeiNo, JPCModelConstant.FUNC_CD_2);
					
					if (null != eKK0451A010List && eKK0451A010List.size() > 0)
					{
						eKK0451A010Map = (HashMap<String,Object>)eKK0451A010List.get(0);
						
						String eKK0451A010PplanCd = JKKStringUtil.nullToBlank((String)eKK0451A010Map.get(EKK0451A010CBSMsg1List.PPLAN_CD));
						String eKK0451A010SvcStaYmd = JKKStringUtil.nullToBlank((String)eKK0451A010Map.get(EKK0451A010CBSMsg1List.SVC_STA_YMD));
						
						// 継続月数を算出する（テレビの解約予定月 − 割引サービス契約のサービス開始月）
						int keizokuGetuNum = JPCDateUtil.subtractMonth(dslRsvdYmdTv, eKK0451A010SvcStaYmd);
						
						// ANK-3383-06-00 ADD START
						if (keizokuGetuNum < 0)
						{
							// マイナス値になった場合、０を設定
							keizokuGetuNum = 0;
						}
						// ANK-3383-06-00 ADD END
						
						List<HashMap<String, Object>> stchSetWariSsnKinList = getPnltyPrcIti(handle, retParam, fixedText, pcrsCdTv, eKK0451A010PplanCd, dslRsvdYmdTv, keizokuGetuNum, JPCModelConstant.FUNC_CD_1);
						
						
						HashMap<String,Object> stchSetWariSsnKinMap = new HashMap<String,Object>();
						if (null != stchSetWariSsnKinList && stchSetWariSsnKinList.size() > 0)
						{
							stchSetWariSsnKinMap = (HashMap<String,Object>)stchSetWariSsnKinList.get(0);
						}
						
						String pnltyTanka = "";
						
						// 違約金単価を取得
						if (JKKStringUtil.isNullEmpty((String)stchSetWariSsnKinMap.get(EAC0221A010CBSMsg1List.PNLTY_TANKA)))
						{
							// 結果が取得できなかった場合、0円を設定
							stchSetWariSsnKin = DSL_SSN_KIN_0;
						} else
						{
							String upplValue = "";
							
							// 結果が取得できた場合、取得値を設定
							pnltyTanka = (String)stchSetWariSsnKinMap.get(EAC0221A010CBSMsg1List.PNLTY_TANKA);
							upplValue = (String)stchSetWariSsnKinMap.get(EAC0221A010CBSMsg1List.UPPL_VALUE);
							
							// IT2-2018-0000056 MOD START
							//// スターｃｈ解約精算金 ＝ 違約金単価 × （上限値 − 継続月数 ＋ １）
							//stchSetWariSsnKin = String.valueOf(Integer.valueOf(pnltyTanka) * (Integer.valueOf(upplValue) - Integer.valueOf(keizokuGetuNum) + 1));
							// スターｃｈ解約精算金 ＝ 違約金単価 × （上限値 − 継続月数）（解約月も精算金計算の対象とするため）
							stchSetWariSsnKin = String.valueOf(Integer.valueOf(pnltyTanka) * (Integer.valueOf(upplValue) - Integer.valueOf(keizokuGetuNum)));
							// IT2-2018-0000056 MOD END
							// v45.00.03 ANK-3636-08-00 DEL START
//							// ANK-3636-08-00 ADD START
//							// ↓当処理は2019年9月末リリース時に削除する↓
//							// 消費税(8%)適用終了年月日がnullまたは""ではない、かつ、消費税(8%)適用終了年月日 < ネットの解約予定日の場合、
//							// 消費税10%の違約金単価を設定する
//							if ((!JKKStringUtil.isNullEmpty(stax8PerTendymd) && dslRsvdYmdTv.compareTo(stax8PerTendymd) > 0))
//							{
//								// 消費税10%の料金に変換する
//								stchSetWariSsnKin = chgStax10Per(stchSetWariSsnKin);
//							}
//							// ↑当処理は2019年9月末リリース時に削除する↑
//							// ANK-3636-08-00 ADD END
							// v45.00.03 ANK-3636-08-00 DEL END
						}
					}
					
					break;
				}
			}
			
			//*************************************
			// ＳＴＢ解約精算金の計算処理
			//*************************************
			// ＳＴＢのリスト分、解約精算金の計算を行う
			for (int i = 0;  i < stbInfoList.size(); i++)
			{
				List<HashMap<String, Object>> eKK0341A010List = new ArrayList<HashMap<String, Object>>();
				HashMap<String, Object> eKK0341A010Map = new HashMap<String, Object>();
				HashMap <String, Object> stbInfoMap = new HashMap <String, Object>();
				List<HashMap<String, Object>> stbSsnKinList = new ArrayList<HashMap<String, Object>>();
				HashMap<String, Object>  stbSsnKinMap = new HashMap<String, Object>();
				String stbSsnKin = "0";
				
				stbInfoMap = stbInfoList.get(i);
				
				String kktkSvcKeiNo = JKKStringUtil.nullToBlank((String)stbInfoMap.get("stb_kktk_svc_kei_no"));
				eKK0341A010List = getKktkSvcKeiInfo(handle, retParam, fixedText, kktkSvcKeiNo, JPCModelConstant.FUNC_CD_2);
				
				if (null != eKK0341A010List && eKK0341A010List.size() > 0)
				{
					eKK0341A010Map = eKK0341A010List.get(0);
					
					String pplanCd = JKKStringUtil.nullToBlank((String)eKK0341A010Map.get(EKK0341A010CBSMsg1List.PPLAN_CD));
					//ANK-3675-00-00 MOD START
					//String svcStaYmd = JKKStringUtil.nullToBlank((String)eKK0341A010Map.get(EKK0341A010CBSMsg1List.SVC_STA_YMD));
					String planChrgStaYmd = JKKStringUtil.nullToBlank((String)eKK0341A010Map.get(EKK0341A010CBSMsg1List.PLAN_CHRG_STAYMD));
					String svcChrgStaYmd = JKKStringUtil.nullToBlank((String)eKK0341A010Map.get(EKK0341A010CBSMsg1List.SVC_CHRG_STAYMD));
					//ANK-3675-00-00 MOD END
					
					// OM-2019-0000578 MOD START
					// 継続月数を算出する（テレビの解約予定月 − 機器提供サービス契約のサービス開始月）
					//int keizokuGetuNum = JPCDateUtil.subtractMonth(dslRsvdYmdTv, svcStaYmd);
					//ANK-3675-00-00 MOD START
					//if (!JKKStringUtil.isNullBlank(svcStaYmd))
					if (!JKKStringUtil.isNullBlank(planChrgStaYmd))
					//ANK-3675-00-00 MOD END
					{
						int keizokuGetuNum = 0;
// ANK-3865-00-00対応 20200604 星野 MOD START
//						//ANK-3675-00-00 MOD START
//						//keizokuGetuNum = JPCDateUtil.subtractMonth(dslRsvdYmdTv, svcStaYmd);
//						keizokuGetuNum = JPCDateUtil.subtractMonth(JPCDateUtil.addDay(dslRsvdYmdTv, -1), planChrgStaYmd)+1;
//						//ANK-3675-00-00 MOD END
						
						// 継続期間算出の終点は課金終了日ではなく解約起算日
						keizokuGetuNum = JPCDateUtil.subtractMonth(dslRsvdYmdTv, planChrgStaYmd)+1;
// ANK-3865-00-00対応 20200604 星野 MOD END
					// OM-2019-0000578 MOD END
						//ANK-3675-00-00 MOD START
						// ANK-3383-06-00 ADD START
//						if (keizokuGetuNum < 0)
//						{
//							// マイナス値になった場合、０を設定
//							keizokuGetuNum = 0;
//						}
						// ANK-3383-06-00 ADD END
						
						if (keizokuGetuNum < 1 && planChrgStaYmd.equals(svcChrgStaYmd)){
							// OM-2020-0000939 ADD START
							// 機器がサービス課金開始前の場合
							if (tmpKeizokuGetuNumTv >= 1){
								// サービスが課金開始後の場合
								// OM-2020-0000939 ADD END
								// 1回レンタル料が発生することを見越して継続月数1か月とする
								keizokuGetuNum = 1;
								// OM-2020-0000939 ADD START
							}
							// OM-2020-0000939 ADD END
						}
						//ANK-3675-00-00 MOD END
// IT2-2020-0000010対応 20200316 ADD START
						if (keizokuGetuNum < 0)
						{
							// マイナス値になった場合、０を設定
							keizokuGetuNum = 0;
						}
// IT2-2020-0000010対応 20200316 ADD END
						
						stbSsnKinList = getPnltyPrcIti(handle, retParam, fixedText, pcrsCdTv, pplanCd, dslRsvdYmdTv, keizokuGetuNum, JPCModelConstant.FUNC_CD_1);
						
						if (null != stbSsnKinList && stbSsnKinList.size() > 0)
						{
							stbSsnKinMap = (HashMap<String,Object>)stbSsnKinList.get(0);
						}
						
						// 違約金単価を取得
						if (JKKStringUtil.isNullEmpty((String)stbSsnKinMap.get(EAC0221A010CBSMsg1List.PNLTY_TANKA)))
						{
							// 結果が取得できなかった場合、0円を設定
							stbSsnKin = DSL_SSN_KIN_0;
						}
// IT2-2020-0000010対応 20200316 DEL START
//						//ANK-3675-00-00 ADD START
//						else if(keizokuGetuNum <= 0){
//							// 継続月数0以下の場合、0円を設定（違約金12か月分は発生しない）
//							stbSsnKin = DSL_SSN_KIN_0;
//						}
//						//ANK-3675-00-00 ADD END
// IT2-2020-0000010対応 20200316 DEL END
						else
						{
							String pnltyTanka = "";
							String upplValue = "";
							
							// 結果が取得できた場合、取得値を設定
							pnltyTanka = (String)stbSsnKinMap.get(EAC0221A010CBSMsg1List.PNLTY_TANKA);
							upplValue = (String)stbSsnKinMap.get(EAC0221A010CBSMsg1List.UPPL_VALUE);
							
							// ＳＴＢ解約精算金 ＝ 違約金単価 × （上限値 − 継続月数 ＋ １）
							stbSsnKin = String.valueOf(Integer.valueOf(pnltyTanka) * (Integer.valueOf(upplValue) - Integer.valueOf(keizokuGetuNum) + 1));
							// v45.00.03 ANK-3636-08-00 DEL START
//							// ANK-3636-08-00 ADD START
//							// ↓当処理は2019年9月末リリース時に削除する↓
//							// 消費税(8%)適用終了年月日がnullまたは""ではない、かつ、消費税(8%)適用終了年月日 < ネットの解約予定日の場合、
//							// 消費税10%の違約金単価を設定する
//							if ((!JKKStringUtil.isNullEmpty(stax8PerTendymd) && dslRsvdYmdTv.compareTo(stax8PerTendymd) > 0))
//							{
//								// 消費税10%の料金に変換する
//								stbSsnKin = chgStax10Per(stbSsnKin);
//							}
//							// ↑当処理は2019年9月末リリース時に削除する↑
//							// ANK-3636-08-00 ADD END
							// v45.00.03 ANK-3636-08-00 DEL END
						}
					
					// OM-2019-0000578 ADD START
					}
					else
					{
						// サービス開始日が取得できなかった場合、0円を設定
						stbSsnKin = DSL_SSN_KIN_0;
					}
					// OM-2019-0000578 ADD END
					
					// 合計金額に加算
					stbDslSsnKinAllAmnt = String.valueOf(Integer.valueOf(stbDslSsnKinAllAmnt) + Integer.valueOf(stbSsnKin));
					
				}
				
				// ＳＴＢ明細一覧リストに情報を設定
				stbInfoMap.put("stb_dsl_ssn_kin", stbSsnKin);
			}
			// ANK-3383-00-00 ADD END
		}
		
		
		// 最後に解約精算金の合計金額を算出する
		gokei_amnt = String.valueOf( Integer.valueOf(sokuWariDslSsnKin)				// 即割解約精算金
										+ Integer.valueOf(lenWariDslSsnKin) 		// 長割解約精算金
										+ Integer.valueOf(stdardKojihiZanKin)		// 標準工事費割賦残金
										+ Integer.valueOf(tvDslSsnKin)				// テレビ解約精算金
										// ANK-3383-00-00 ADD START
										+ Integer.valueOf(smtlnkSsnKinAllAmnt)		// eoスマートリンク精算金（割賦残金）
										+ Integer.valueOf(gglhmKapZkinAllAmnt)		// Google Haome割賦残金
										+ Integer.valueOf(stchSetWariSsnKin)		// スターｃｈセット解約精算金
										+ Integer.valueOf(stbDslSsnKinAllAmnt)		// ＳＴＢ解約精算金
										// ANK-3383-00-00 ADD END
										// ANK-3412-03-00 ADD START
										+ Integer.valueOf(kousokuWariDslSsnKin)
										// ANK-3412-03-00 ADD END
										);
		
		//合計金額
		dataMap.put("gokei_amnt", gokei_amnt);
		//即割解約精算金
		dataMap.put("soku_wari_dsl_ssn_kin", sokuWariDslSsnKin);
		//長割解約精算金
		dataMap.put("len_wari_dsl_ssn_kin", lenWariDslSsnKin);
		//標準工事費残金
		dataMap.put("stdard_kojihi_zan_kin", stdardKojihiZanKin);
		//割賦残回数
		dataMap.put("kap_pay_zan_cnt", kapPayZanCnt);
		//テレビ解約精算金
		dataMap.put("tv_dsl_ssn_kin", tvDslSsnKin);
		// ANK-3383-00-00 ADD START
		//工事費相当額割引キャンペーン適用残回数
		dataMap.put("kojihi_wrib_campaign_zan_cnt", stdardKojihiCmpZanCnt);
		//スターｃｈセット解約精算金
		dataMap.put("stch_set_dsl_ssn_kin", stchSetWariSsnKin);
		//ｅｏスマートリンク明細一覧リスト
		dataMap.put("smtlnk_info_list", smtlnkInfoList);
		//ＧｏｏｇｌｅＨｏｍｅ明細一覧リスト
		dataMap.put("gglhm_info_list", gglhmInfoList);
		//ＳＴＢ明細一覧リスト
		dataMap.put("stb_info_list", stbInfoList);
		// ANK-3383-00-00 ADD END
		// ANK-3412-03-00 ADD START
		//高速解約精算金
		dataMap.put("kousoku_wari_dsl_ssn_kin", kousokuWariDslSsnKin);
		// ANK-3412-03-00 ADD END
		
		return retParam;
	}
	
	// ST-2018-0000011 ADD START
	/**
	 * サービス契約一意照会を行うサービスインターフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param svcKeiNo サービス契約番号
	 * @param func_cd 機能コード
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private List<HashMap<String, Object>> getSvcKeiIti(SessionHandle handle
															, IRequestParameterReadWrite param
															, String fixedText
															, String svcKeiNo
															, String func_cd)throws Throwable
	{
		// サービス契約一意照会
		List<HashMap<String, Object>> eKK0081A010List = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// サービス契約一意照会の上りマッピング
		Object[][] EKK0081A010In =
		{
			{EKK0081A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0081A010}
			// 機能コード："1"
			, {EKK0081A010CBSMsg.FUNC_CODE, func_cd}
			// ＫＥＹ＿サービス契約番号
			, {EKK0081A010CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}
			// ＫＥＹ＿予約適用年月日
			, {EKK0081A010CBSMsg.KEY_RSV_APLY_YMD, JPCBPCommon.getOpeDate(null)}
		};
		
		// サービスIF実行
		CAANMsg[] EKK0081A010Msg1List = callSC(handle, scCall, param, fixedText, EKK0081A010In,
				new EKK0081A010CBSMsg().getContents()).getCAANMsgList(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);
		
		if (null != EKK0081A010Msg1List)
		{
			for (CAANMsg EKK0081A010Msg : EKK0081A010Msg1List)
			{
				HashMap<String, Object> eKK0081A010Map = new HashMap<String, Object>();
				eKK0081A010Map.put(EKK0081A010CBSMsg1List.SVC_STA_YMD, EKK0081A010Msg.getString(EKK0081A010CBSMsg1List.SVC_STA_YMD));
				eKK0081A010Map.put(EKK0081A010CBSMsg1List.PCRS_CD, EKK0081A010Msg.getString(EKK0081A010CBSMsg1List.PCRS_CD));
				eKK0081A010Map.put(EKK0081A010CBSMsg1List.PRC_GRP_CD, EKK0081A010Msg.getString(EKK0081A010CBSMsg1List.PRC_GRP_CD));
				eKK0081A010Map.put(EKK0081A010CBSMsg1List.PPLAN_CD, EKK0081A010Msg.getString(EKK0081A010CBSMsg1List.PPLAN_CD));
				// OM-2020-0000939 ADD START
				eKK0081A010Map.put(EKK0081A010CBSMsg1List.SVC_CHRG_STAYMD, EKK0081A010Msg.getString(EKK0081A010CBSMsg1List.SVC_CHRG_STAYMD));
				// OM-2020-0000939 ADD END
				eKK0081A010List.add(eKK0081A010Map);
			}
		}
		return eKK0081A010List;
	}
	// ST-2018-0000011 ADD END
	
	/**
	 * 違約金一意照会を行うサービスインターフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param pcrsCd 料金コースコード
	 * @param trgtPrcSvcCd 対象料金サービスコード
	 * @param dslRsvYmd 解約予定日
	 * @param keizokuGetuNum 継続月数
	 * @param func_cd 機能コード
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private List<HashMap<String, Object>> getPnltyPrcIti(SessionHandle handle
															, IRequestParameterReadWrite param
															, String fixedText
															, String pcrsCd
															, String trgtPrcSvcCd
															, String dslRsvYmd
															, int keizokuGetuNum
															, String func_cd)throws Throwable
	{
		// 違約金一意照会
		List<HashMap<String, Object>> eAC0221A010List = new ArrayList<HashMap<String, Object>>();
		
		// OM-2019-0000041 ADD START
		// 対象料金対象サービスコード(trgtPrcSvcCd)がnullまたは空ではない場合、違約金一意照会を実行する
		if (!JKKStringUtil.isNullBlank(trgtPrcSvcCd))
		{
		// OM-2019-0000041 ADD END
			// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
			ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
			
			// int形の型をString型へ変換
			String keizokuGetuNumString = String.valueOf(keizokuGetuNum);
			
			// 違約金一意照会の上りマッピング
			Object[][] EAC0221A010In =
			{
				{EAC0221A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EAC0221A010}
				// 機能コード："1"
				, {EAC0221A010CBSMsg.FUNC_CODE, func_cd}
				// ＫＥＹ＿対象料金コースコード
				, {EAC0221A010CBSMsg.KEY_TRGT_PCRS_CD, pcrsCd}
				// ＫＥＹ＿解約日
				, {EAC0221A010CBSMsg.KEY_DSL_YMD, dslRsvYmd}
				// ＫＥＹ＿継続月数
				, {EAC0221A010CBSMsg.KEY_KEIZOKU_GETU_NUM, keizokuGetuNumString}
				// ＫＥＹ＿サービス解約理由識別コード
				, {EAC0221A010CBSMsg.KEY_SVC_DSL_RSN_SKBT_CD, "0001"}
				// ＫＥＹ＿対象料金対象サービスコード
				, {EAC0221A010CBSMsg.KEY_TRGT_PRC_SVC_CD, trgtPrcSvcCd}
			};
			
			// サービスIF実行
			CAANMsg[] EAC0221A010Msg1List = callSC(handle, scCall, param, fixedText, EAC0221A010In,
					new EAC0221A010CBSMsg().getContents()).getCAANMsgList(EAC0221A010CBSMsg.EAC0221A010CBSMSG1LIST);
			
			if (null != EAC0221A010Msg1List)
			{
				for (CAANMsg EAC0221A010Msg : EAC0221A010Msg1List)
				{
					HashMap<String, Object> eAC0221A010Map = new HashMap<String, Object>();
					eAC0221A010Map.put(EAC0221A010CBSMsg1List.PNLTY_TANKA, EAC0221A010Msg.getString(EAC0221A010CBSMsg1List.PNLTY_TANKA));
					// ANK-3383-00-00 ADD START
					eAC0221A010Map.put(EAC0221A010CBSMsg1List.UPPL_VALUE, EAC0221A010Msg.getString(EAC0221A010CBSMsg1List.UPPL_VALUE));
					// ANK-3383-00-00 ADD END
					eAC0221A010List.add(eAC0221A010Map);
				}
			}
		// OM-2019-0000041 ADD START
		}
		// OM-2019-0000041 ADD END
		
		return eAC0221A010List;
	}
	
	
	/**
	 * 割引サービス単価一覧照会（割引サービスコード）を行うサービスインターフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param svcKeiNo サービス契約番号
	 * @param wribSvcCd 割引サービスコード
	 * @return 割引サービス単価一覧照会（割引サービスコード）結果
	 * @throws Throwable 例外が発生した場合
	 */
	private List<HashMap<String, Object>> getWribSvcTankaIcrn(SessionHandle handle
															, IRequestParameterReadWrite param
															, String fixedText
															, String wribSvcCd
															, String func_cd)throws Throwable
	{
		// 割引サービス単価一覧照会（割引サービスコード）
		List<HashMap<String, Object>> eKK0711B001List = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 割引サービス単価一覧照会（割引サービスコード）の上りマッピング
		Object[][] EKK0711B001In =
		{
			{EKK0711B001CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0711B001}
			// 機能コード："1"
			, {EKK0711B001CBSMsg.FUNC_CODE, func_cd}
			// ＫＥＹ＿サービス契約番号
			, {EKK0711B001CBSMsg.KEY_WRIB_SVC_CD, wribSvcCd}
		};
		
		// サービスIF実行
		CAANMsg[] EKK0711B001Msg1List = callSC(handle, scCall, param, fixedText, EKK0711B001In,
				new EKK0711B001CBSMsg().getContents()).getCAANMsgList(EKK0711B001CBSMsg.EKK0711B001CBSMSG1LIST);
		
		if (null != EKK0711B001Msg1List)
		{
			for (CAANMsg EKK0711B001Msg : EKK0711B001Msg1List)
			{
				HashMap<String, Object> eKK0711B001Map = new HashMap<String, Object>();
				eKK0711B001Map.put(EKK0711B001CBSMsg1List.WRIB_SVC_TANKA_NO, EKK0711B001Msg.getString(EKK0711B001CBSMsg1List.WRIB_SVC_TANKA_NO));
				eKK0711B001Map.put(EKK0711B001CBSMsg1List.PCRS_CD, EKK0711B001Msg.getString(EKK0711B001CBSMsg1List.PCRS_CD));
				eKK0711B001Map.put(EKK0711B001CBSMsg1List.PPLAN_CD, EKK0711B001Msg.getString(EKK0711B001CBSMsg1List.PPLAN_CD));
				
				eKK0711B001List.add(eKK0711B001Map);
			}
		}
		return eKK0711B001List;
	}
	
	
	/**
	 * サービス契約一意照会を行うサービスインターフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param svcKeiNo サービス契約番号
	 * @param func_cd 機能コード
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private String getHjnkjhKapsdSymd(SessionHandle handle
										, IRequestParameterReadWrite param
										, String fixedText
										, String workParamId
										, String func_cd
										)throws Throwable
	{
		String hjnkjhKapsdSymd = "";
		
		// 業務パラメータ管理一意照会
		List<HashMap<String, Object>> eZM0321A010List = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// サービス契約一意照会の上りマッピング
		Object[][] EZM0321A010In =
		{
			{EZM0321A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0321A010}
			// 機能コード："1"
			, {EZM0321A010CBSMsg.FUNC_CODE, func_cd}
			// ＫＥＹ＿サービス契約番号
			, {EZM0321A010CBSMsg.KEY_WORK_PARAM_ID, workParamId}
		};
		
		// サービスIF実行
		CAANMsg[] EZM0321A010Msg1List = callSC(handle, scCall, param, fixedText, EZM0321A010In,
				new EZM0321A010CBSMsg().getContents()).getCAANMsgList(EZM0321A010CBSMsg.EZM0321A010CBSMSG1LIST);
		
		if (null != EZM0321A010Msg1List)
		{
			for (CAANMsg EZM0321A010Msg : EZM0321A010Msg1List)
			{
				return hjnkjhKapsdSymd = EZM0321A010Msg.getString(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE);
			}
		}
		return "";
	}
	
	
	/**
	 * 割引サービス契約一覧照会（サービス契約番号）を行うサービスインターフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param svcKeiNo サービス契約番号
	 * @param func_cd 機能コード
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private List<HashMap<String, Object>> getWribSvckei(SessionHandle handle
															, IRequestParameterReadWrite param
															, String fixedText
															, String svcKeiNo
															, String func_cd)throws Throwable
	{
		//割引サービス契約一覧照会（サービス契約番号）
		List<HashMap<String, Object>> eKK0451B002List = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		//割引サービス契約一覧照会（サービス契約番号）の上りマッピング
		Object[][] EKK0451B002In =
		{
			{EKK0451B002CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0451B002}
			// 機能コード："1"
			, {EKK0451B002CBSMsg.FUNC_CODE, func_cd}
			// ＫＥＹ＿サービス契約番号
			, {EKK0451B002CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}
		};
		
		// サービスIF実行
		CAANMsg[] EKK0451B002Msg1List = callSC(handle, scCall, param, fixedText, EKK0451B002In,
				new EKK0451B002CBSMsg().getContents()).getCAANMsgList(EKK0451B002CBSMsg.EKK0451B002CBSMSG1LIST);
		
		if (null != EKK0451B002Msg1List)
		{
			for (CAANMsg EKK0451B002Msg : EKK0451B002Msg1List)
			{
				HashMap<String, Object> eKK0451B002Map = new HashMap<String, Object>();
				eKK0451B002Map.put(EKK0451B002CBSMsg1List.WRIB_SVC_KEI_NO, EKK0451B002Msg.getString(EKK0451B002CBSMsg1List.WRIB_SVC_KEI_NO));
				eKK0451B002Map.put(EKK0451B002CBSMsg1List.WRIB_SVC_CD, EKK0451B002Msg.getString(EKK0451B002CBSMsg1List.WRIB_SVC_CD));
				eKK0451B002Map.put(EKK0451B002CBSMsg1List.WRIB_SVC_KEI_STAT, EKK0451B002Msg.getString(EKK0451B002CBSMsg1List.WRIB_SVC_KEI_STAT));
				// IT1-2018-0000071 ADD START
				eKK0451B002Map.put(EKK0451B002CBSMsg1List.SVC_CHRG_STAYMD, EKK0451B002Msg.getString(EKK0451B002CBSMsg1List.SVC_CHRG_STAYMD));
				// IT1-2018-0000071 ADD END
				eKK0451B002List.add(eKK0451B002Map);
			}
		}
		return eKK0451B002List;
	}
	
	
	/**
	 * 割引サービス契約一意照会を行うサービスインターフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param wribKeiNo 割引サービス契約番号
	 * @param func_cd 機能コード
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private List<HashMap<String, Object>> getWribSvckeiIti(SessionHandle handle
															, IRequestParameterReadWrite param
															, String fixedText
															, String wribKeiNo
															, String func_cd)throws Throwable
	{
		// 割引サービス契約一意照会
		List<HashMap<String, Object>> eKK0451A010List = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 割引サービス契約一意照会の上りマッピング
		Object[][] EKK0451A010In =
		{
			{EKK0451A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0451A010}
			// 機能コード
			, {EKK0451A010CBSMsg.FUNC_CODE, func_cd}
			// ＫＥＹ＿割引サービス契約番号
			, {EKK0451A010CBSMsg.KEY_WRIB_SVC_KEI_NO, wribKeiNo}
			// ＫＥＹ＿予約適応年月日
			, {EKK0451A010CBSMsg.KEY_RSV_APLY_YMD, JPCBPCommon.getOpeDate(null)}
		};
		
		// サービスIF実行
		CAANMsg[] EKK0451A010Msg1List = callSC(handle, scCall, param, fixedText, EKK0451A010In,
				new EKK0451A010CBSMsg().getContents()).getCAANMsgList(EKK0451A010CBSMsg.EKK0451A010CBSMSG1LIST);
		
		if (null != EKK0451A010Msg1List)
		{
			for (CAANMsg EKK0451A010Msg : EKK0451A010Msg1List)
			{
				HashMap<String, Object> eKK0451A010Map = new HashMap<String, Object>();
				eKK0451A010Map.put(EKK0451A010CBSMsg1List.WRIB_SVC_CD, EKK0451A010Msg.getString(EKK0451A010CBSMsg1List.WRIB_SVC_CD));
				eKK0451A010Map.put(EKK0451A010CBSMsg1List.WRIB_SVC_KEI_STAT, EKK0451A010Msg.getString(EKK0451A010CBSMsg1List.WRIB_SVC_KEI_STAT));
				eKK0451A010Map.put(EKK0451A010CBSMsg1List.MSKM_DTL_NO, EKK0451A010Msg.getString(EKK0451A010CBSMsg1List.MSKM_DTL_NO));
				eKK0451A010Map.put(EKK0451A010CBSMsg1List.WRIB_SVC_KEI_AT_KEIZK_SKCD, EKK0451A010Msg.getString(EKK0451A010CBSMsg1List.WRIB_SVC_KEI_AT_KEIZK_SKCD));
				eKK0451A010Map.put(EKK0451A010CBSMsg1List.PLAN_STAYMD, EKK0451A010Msg.getString(EKK0451A010CBSMsg1List.PLAN_STAYMD));
				// ANK-3383-00-00 ADD START
				eKK0451A010Map.put(EKK0451A010CBSMsg1List.PPLAN_CD, EKK0451A010Msg.getString(EKK0451A010CBSMsg1List.PPLAN_CD));
				eKK0451A010Map.put(EKK0451A010CBSMsg1List.SVC_STA_YMD, EKK0451A010Msg.getString(EKK0451A010CBSMsg1List.SVC_STA_YMD));
				// ANK-3383-00-00 ADD END
				// OM-2019-0000906 ADD START
				eKK0451A010Map.put(EKK0451A010CBSMsg1List.MSKM_KISAN_YMD, EKK0451A010Msg.getString(EKK0451A010CBSMsg1List.MSKM_KISAN_YMD));
				// OM-2019-0000906 ADD END
				eKK0451A010List.add(eKK0451A010Map);
			}
		}
		return eKK0451A010List;
	}
	
	
	/**
	 * 申込明細一意照会を行うサービスインターフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param MskmDtlNo 申込明細番号
	 * @param func_cd 機能コード
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private List<HashMap<String, Object>> getMskmDtlNoIti(SessionHandle handle
															, IRequestParameterReadWrite param
															, String fixedText
															, String MskmDtlNo
															, String func_cd)throws Throwable
	{
		//申込明細一意照会
		List<HashMap<String, Object>> eKK0021A010List = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		//申込明細一意照会の上りマッピング
		Object[][] EKK0021A010In =
		{
			{EKK0021A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0021A010}
			// 機能コード："1"
			, {EKK0021A010CBSMsg.FUNC_CODE, func_cd}
			// ＫＥＹ＿申込明細
			, {EKK0021A010CBSMsg.KEY_MSKM_DTL_NO, MskmDtlNo}
		};
		
		// サービスIF実行
		CAANMsg[] EKK0021A010Msg1List = callSC(handle, scCall, param, fixedText, EKK0021A010In,
				new EKK0021A010CBSMsg().getContents()).getCAANMsgList(EKK0021A010CBSMsg.EKK0021A010CBSMSG1LIST);
		
		if (null != EKK0021A010Msg1List)
		{
			for (CAANMsg EKK0021A010Msg : EKK0021A010Msg1List)
			{
				HashMap<String, Object> eKK0021A010Map = new HashMap<String, Object>();
				eKK0021A010Map.put(EKK0021A010CBSMsg1List.MSKM_YMD, EKK0021A010Msg.getString(EKK0021A010CBSMsg1List.MSKM_YMD));
				eKK0021A010List.add(eKK0021A010Map);
			}
		}
		return eKK0021A010List;
	}
	
	
	/**
	 * サービス契約回線内訳一覧照会（サービス契約番号）を呼び出す。
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param scCall SC呼出部品のインスタンス
 	 * @param fixedText ユーザ定義文字列
	 * @param svcKeiNo サービス契約番号
	 * @param func_cd 機能コード
	 * @return 回線対象サービス契約番号
	 * @throws Throwable 
	 */
	private String callGetKaisenTgSvkei(SessionHandle handle, 
			IRequestParameterReadWrite param, 
			ServiceComponentRequestInvoker scCall,
			String fixedText,
			String svcKeiNo) throws Throwable
	{
		// サービス契約回線内訳一覧照会（サービス契約番号）の検索パラメータを設定
		Object[][] EKK0251B001IN = {
				{EKK0251B001CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0251B001},
				// 機能コード："1"
				 {EKK0251B001CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1},
				{EKK0251B001CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}	// ＫＥＹ＿サービス契約番号
			};
		
		// ◇ SC呼出実行
		CAANMsg[] eKK0251B001MsgList = callSC(handle, scCall, param, fixedText, EKK0251B001IN,
				new EKK0251B001CBSMsg().getContents()).getCAANMsgList(EKK0251B001CBSMsg.EKK0251B001CBSMSG1LIST);
		
		if (null != eKK0251B001MsgList)
		{
			for (CAANMsg cAANMsg : eKK0251B001MsgList)
			{
				return cAANMsg.getString(EKK0251B001CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO);
			}
		}
		
		// 処理結果
		return "";
	}
	
	
	/**
	 * マンション情報一覧照会
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param svcKeiNo サービス契約番号
// 20210615 OM-2021-0000557 ADD START
	 * @param dslRsvdYmd 解約予定日
// 20210615 OM-2021-0000557 ADD END
	 * @param func_cd 機能コード
	 * @return メッセージ
	 * @throws Throwable 
	 */
	private String selectEkk0861(SessionHandle handle, 
			IRequestParameterReadWrite param, 
			String fixedText,
			String svcKeiNo,
			// 20210615 OM-2021-0000557 ADD START
			String dslRsvdYmd,
			// 20210615 OM-2021-0000557 ADD END
			String func_cd) throws Throwable
	{
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 20210615 OM-2021-0000557 ADD START
		Object[][] ekk0861b002 = null;
		if (func_cd.equals(JPCModelConstant.FUNC_CD_2))
		{
		// 20210615 OM-2021-0000557 ADD END
			// マンション情報一覧照会の検索パラメータを設定
			// 20210615 OM-2021-0000557 MOD START
//			Object[][] ekk0861b002 = {
			Object[][] tmpekk0861b002 = {
			// 20210615 OM-2021-0000557 MOD END
				{EKK0341B002CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0861B002},
				{EKK0341B002CBSMsg.FUNC_CODE, func_cd},			// 機能コード："2"
				{EKK0861B002CBSMsg.KEY_SVC_KEI_NO, svcKeiNo},	// ＫＥＹ＿サービス契約番号
				{EKK0861B002CBSMsg.KEY_RSV_APLY_YMD, JPCBPCommon.getOpeDate(null)}	// ＫＥＹ＿予約適用年月日
			};
		// 20210615 OM-2021-0000557 ADD START
			ekk0861b002 = tmpekk0861b002;
		} else
		{
			// マンション情報一覧照会の検索パラメータを設定
			Object[][] tmpekk0861b002 = {
					{EKK0341B002CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0861B002},
					{EKK0341B002CBSMsg.FUNC_CODE, func_cd},			// 機能コード："3"
					{EKK0861B002CBSMsg.KEY_SVC_KEI_NO, svcKeiNo},	// ＫＥＹ＿サービス契約番号
					{EKK0861B002CBSMsg.KEY_RSV_APLY_YMD, JPCBPCommon.getOpeDate(null)},	// ＫＥＹ＿予約適用年月日
					{EKK0861B002CBSMsg.KEY_DSL_RSVD_YMD, dslRsvdYmd}	// ＫＥＹ＿解約予定日
			};
			
			ekk0861b002 = tmpekk0861b002;
		}
		// 20210615 OM-2021-0000557 ADD END
		
		// ◇ SC呼出実行
		CAANMsg[] ekk0861b002Msg1List = callSC(handle, scCall, param, fixedText, ekk0861b002,
				new EKK0861B002CBSMsg().getContents()).getCAANMsgList(EKK0861B002CBSMsg.EKK0861B002CBSMSG1LIST);
		
		
		if (null != ekk0861b002Msg1List)
		{
			for (CAANMsg Ekk0861b002Msg : ekk0861b002Msg1List)
			{
				return Ekk0861b002Msg.getString(EKK0861B002CBSMsg1List.MANSION_BUKKEN_CD);
			}
		}
		
		return "";
	}
	
	
	/**
	 * 工事費割賦契約一覧照会SC(EKK3131B010)を呼び出す。
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param scCall SC呼出部品のインスタンス
	 * @param svcKeiKaisenUcwkNo サービス契約回線内訳番号
	 * @param func_cd 機能コード
	 * @return 工事費割賦契約一覧照会の結果
	 * @throws Exception SC実行時の例外
	 */
	private List<HashMap<String, Object>> callGetKojihiKapKeiSc(SessionHandle handle
															, IRequestParameterReadWrite param
															, String fixedText
															, String svcKeiKaisenUcwkNo
															, String func_cd)throws Throwable
	{
		//工事費割賦契約一覧照会
		List<HashMap<String, Object>> eKK3131B010List = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		//工事費割賦契約一覧照会の上りマッピング
		Object[][] EKK3131B010In =
		{
			{EKK3131B010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK3131B010}
			// 機能コード："2"
			, {EKK3131B010CBSMsg.FUNC_CODE, func_cd}
			// ＫＥＹ＿サービス契約回線内訳番号
			, {EKK3131B010CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO, svcKeiKaisenUcwkNo}
		};
		
		// サービスIF実行
		CAANMsg[] EKK3131B010Msg1List = callSC(handle, scCall, param, fixedText, EKK3131B010In,
				new EKK3131B010CBSMsg().getContents()).getCAANMsgList(EKK3131B010CBSMsg.EKK3131B010CBSMSG1LIST);
		
		if (null != EKK3131B010Msg1List)
		{
			for (CAANMsg EKK3131B010Msg : EKK3131B010Msg1List)
			{
				HashMap<String, Object> eKK3131B010Map = new HashMap<String, Object>();
				eKK3131B010Map.put(EKK3131B010CBSMsg1List.KOJIHI_KAP_KEI_NO, EKK3131B010Msg.getString(EKK3131B010CBSMsg1List.KOJIHI_KAP_KEI_NO));
				eKK3131B010Map.put(EKK3131B010CBSMsg1List.KAP_PLAN_CD, EKK3131B010Msg.getString(EKK3131B010CBSMsg1List.KAP_PLAN_CD));
				eKK3131B010Map.put(EKK3131B010CBSMsg1List.KAP_SEIKY_STA_YM, EKK3131B010Msg.getString(EKK3131B010CBSMsg1List.KAP_SEIKY_STA_YM));
				eKK3131B010Map.put(EKK3131B010CBSMsg1List.KAP_PAY_ZAN_CNT, EKK3131B010Msg.getString(EKK3131B010CBSMsg1List.KAP_PAY_ZAN_CNT));
				eKK3131B010Map.put(EKK3131B010CBSMsg1List.KAP_KEI_SVC_STAYMD, EKK3131B010Msg.getString(EKK3131B010CBSMsg1List.KAP_KEI_SVC_STAYMD));
				// ST-2018-0000011 ADD START
				eKK3131B010Map.put(EKK3131B010CBSMsg1List.KAP_KEI_CHRG_STAYMD, EKK3131B010Msg.getString(EKK3131B010CBSMsg1List.KAP_KEI_CHRG_STAYMD));
				// ST-2018-0000011 ADD END
				// OM-2021-0000276 ADD START
				eKK3131B010Map.put(EKK3131B010CBSMsg1List.KAP_KEI_STAT, EKK3131B010Msg.getString(EKK3131B010CBSMsg1List.KAP_KEI_STAT));
				// OM-2021-0000276 ADD END
				eKK3131B010List.add(eKK3131B010Map);
			}
		}
		
		return eKK3131B010List;
	}
	
	
	/**
	 * 料金スケジュール定義一覧照会SC(ECH0501B010)を呼び出す。
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param scCall SC呼出部品のインスタンス
	 * @param func_cd 機能コード
	 * @return 料金スケジュール定義一覧照会の結果
	 * @throws Exception SC実行時の例外
	 */
	private List<HashMap<String, Object>> callPrcSchdlTeigiSc(SessionHandle handle
															, IRequestParameterReadWrite param
															, String fixedText
															, String func_cd)throws Throwable
	{
		// 料金スケジュール定義一覧照会
		List<HashMap<String, Object>> eCH0501B010List = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 料金スケジュール定義一覧照会の上りマッピング
		Object[][] eCH0501B010In = {
				{ECH0501B010CBSMsg.TEMPLATEID, TEMPLATE_ID_ECH0501B010},
				{ECH0501B010CBSMsg.FUNC_CODE, func_cd},	// 機能コード
				{ECH0501B010CBSMsg.KEY_EVENT_CD, "03"},	// ＫＥＹ＿イベントコード
				{ECH0501B010CBSMsg.KEY_STDARDYMD, JPCBPCommon.getOpeDate(null)},	// ＫＥＹ＿基準年月日
		};
		
		// サービスIF実行
		CAANMsg[] ECH0501B010Msg1List = callSC(handle, scCall, param, fixedText, eCH0501B010In,
				new ECH0501B010CBSMsg().getContents()).getCAANMsgList(ECH0501B010CBSMsg.ECH0501B010CBSMSG1LIST);
		
		if (null != ECH0501B010Msg1List)
		{
			for (CAANMsg ECH0501B010Msg : ECH0501B010Msg1List)
			{
				HashMap<String, Object> eCH0501B010Map = new HashMap<String, Object>();
				eCH0501B010Map.put(ECH0501B010CBSMsg1List.SEIKY_YM, ECH0501B010Msg.getString(ECH0501B010CBSMsg1List.SEIKY_YM));
				eCH0501B010Map.put(ECH0501B010CBSMsg1List.EVENT_YMD, ECH0501B010Msg.getString(ECH0501B010CBSMsg1List.EVENT_YMD));
				eCH0501B010List.add(eCH0501B010Map);
			}
		}
		
		return eCH0501B010List;
	}
	
	
	/**
	 * 割賦料金一覧照会SC(EAC0611B010)を呼び出す。
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText
	 * @param pcrsCd
	 * @param prcSvcCd
	 * @param dslRsvYmd
	 * @param func_cd 機能コード
	 * @return 割賦料金一覧照会の結果
	 * @throws Exception SC実行時の例外
	 */
	private List<HashMap<String, Object>> callGetKapPcrsSc(SessionHandle handle
															, IRequestParameterReadWrite param
															, String fixedText
															, String pcrsCd
															, String prcSvcCd
															, String dslRsvYmd
															, String func_cd)throws Throwable
	{
		//工事費割賦契約一覧照会
		List<HashMap<String, Object>> eAC0611B010List = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		//工事費割賦契約一覧照会の上りマッピング
		Object[][] EAC0611B010In =
		{
			{EAC0611B010CBSMsg.TEMPLATEID, TEMPLATE_ID_EAC0611B010}
			, {EAC0611B010CBSMsg.FUNC_CODE, func_cd}	// 機能コード："1"
			, {EAC0611B010CBSMsg.KEY_SYS_CD, "AC"}	// ＫＥＹ＿システムコード
			, {EAC0611B010CBSMsg.KEY_PCRS_CD, pcrsCd}	// ＫＥＹ＿料金コースコード
			, {EAC0611B010CBSMsg.KEY_PRC_SVC_CD, prcSvcCd}	// ＫＥＹ＿料金サービスコード
			, {EAC0611B010CBSMsg.KEY_BASE_YMD, dslRsvYmd}	// ＫＥＹ＿基準年月日
			
		};
		
		// サービスIF実行
		CAANMsg[] EAC0611B010Msg1List = callSC(handle, scCall, param, fixedText, EAC0611B010In,
				new EAC0611B010CBSMsg().getContents()).getCAANMsgList(EAC0611B010CBSMsg.EAC0611B010CBSMSG1LIST);
		
		if (null != EAC0611B010Msg1List)
		{
			for (CAANMsg EAC0611B010Msg : EAC0611B010Msg1List)
			{
				HashMap<String, Object> eAC0611B010Map = new HashMap<String, Object>();
				eAC0611B010Map.put(EAC0611B010CBSMsg1List.FIRST_PRC, EAC0611B010Msg.getString(EAC0611B010CBSMsg1List.FIRST_PRC));
				eAC0611B010Map.put(EAC0611B010CBSMsg1List.KEIZOKU_PRC, EAC0611B010Msg.getString(EAC0611B010CBSMsg1List.KEIZOKU_PRC));
				eAC0611B010List.add(eAC0611B010Map);
			}
		}
		return eAC0611B010List;
	}
	
	// ANK-3383-00-00 ADD START
	/**
	 * 割引サービス詳細一意照会SC(EKK2371A010)を呼び出す。
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText
	 * @param pcrsCd
	 * @param wribSvcDtlCd
	 * @param func_cd 機能コード
	 * @return 割賦料金一覧照会の結果
	 * @throws Exception SC実行時の例外
	 */
	private List<HashMap<String, Object>> getKikiInfoEKK2371A010(SessionHandle handle
																, IRequestParameterReadWrite param
																, String fixedText
																, String wribSvcDtlCd
																, String func_cd
																) throws Throwable
	{
		// 割引サービス詳細一意照会
		List<HashMap<String, Object>> eKK2371A010List = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 割引サービス詳細一意照会の上りマッピング
		Object[][] EKK2371A010In =
		{
			{EKK2371A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK2371A010}
			, {EKK2371A010CBSMsg.FUNC_CODE, func_cd}	// 機能コード
			, {EKK2371A010CBSMsg.KEY_WRIB_SVC_DTL_CD, wribSvcDtlCd}	// ＫＥＹ＿割引サービス詳細コード
			, {EKK2371A010CBSMsg.KEY_RSV_APLY_YMD, JPCBPCommon.getOpeDate(null)}	// ＫＥＹ＿予約適用年月日
			
		};
		
		// サービスIF実行
		CAANMsg[] EKK2371A010Msg1List = callSC(handle, scCall, param, fixedText, EKK2371A010In,
				new EKK2371A010CBSMsg().getContents()).getCAANMsgList(EKK2371A010CBSMsg.EKK2371A010CBSMSG1LIST);
		
		if (null != EKK2371A010Msg1List)
		{
			for (CAANMsg EKK2371A010Msg : EKK2371A010Msg1List)
			{
				HashMap<String, Object> eKK2371A010Map = new HashMap<String, Object>();
				eKK2371A010Map.put(EKK2371A010CBSMsg1List.APLY_CNT, EKK2371A010Msg.getString(EKK2371A010CBSMsg1List.APLY_CNT));
				eKK2371A010List.add(eKK2371A010Map);
			}
		}
		return eKK2371A010List;
	}
	
	/**
	 * 割賦契約一覧照会(サービス契約番号) SC(KK2541B004)を呼び出す。
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText
	 * @param svcKeiNo
	 * @param kktkSvcCd
	 * @param func_cd 機能コード
	 * @return 割賦料金一覧照会の結果
	 * @throws Exception SC実行時の例外
	 */
	private List<HashMap<String, Object>> getKapKeiInfo(SessionHandle handle
																, IRequestParameterReadWrite param
																, String fixedText
																, String svcKeiNo
																, String kktkSvcCd
																, String func_cd
																) throws Throwable
	{
		// 割賦契約一覧照会(サービス契約番号) 
		List<HashMap<String, Object>> eKK2541B004List = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 割賦契約一覧照会(サービス契約番号) の上りマッピング
		Object[][] EKK2541B004In =
		{
			{EKK2541B004CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK2541B004}
			, {EKK2541B004CBSMsg.FUNC_CODE, func_cd}	// 機能コード
			, {EKK2541B004CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}	// ＫＥＹ＿サービス契約番号
			, {EKK2541B004CBSMsg.KEY_KKTK_SVC_CD, kktkSvcCd}	// ＫＥＹ＿機器提供サービスコード
		};
		
		// サービスIF実行
		CAANMsg[] EKK2541B004Msg1List = callSC(handle, scCall, param, fixedText, EKK2541B004In,
				new EKK2541B004CBSMsg().getContents()).getCAANMsgList(EKK2541B004CBSMsg.EKK2541B004CBSMSG1LIST);
		
		if (null != EKK2541B004Msg1List)
		{
			for (CAANMsg EKK2541B004Msg : EKK2541B004Msg1List)
			{
				HashMap<String, Object> eKK2541B004Map = new HashMap<String, Object>();
				eKK2541B004Map.put(EKK2541B004CBSMsg1List.KKTK_SVC_KEI_NO, EKK2541B004Msg.getString(EKK2541B004CBSMsg1List.KKTK_SVC_KEI_NO));
				eKK2541B004Map.put(EKK2541B004CBSMsg1List.KAP_KEI_NO, EKK2541B004Msg.getString(EKK2541B004CBSMsg1List.KAP_KEI_NO));
				eKK2541B004Map.put(EKK2541B004CBSMsg1List.KAP_PLAN_CD, EKK2541B004Msg.getString(EKK2541B004CBSMsg1List.KAP_PLAN_CD));
				eKK2541B004Map.put(EKK2541B004CBSMsg1List.KAP_SEIKY_STA_YM, EKK2541B004Msg.getString(EKK2541B004CBSMsg1List.KAP_SEIKY_STA_YM));
				eKK2541B004Map.put(EKK2541B004CBSMsg1List.KAP_PAY_ZAN_CNT, EKK2541B004Msg.getString(EKK2541B004CBSMsg1List.KAP_PAY_ZAN_CNT));
				//OM-2021-0000276 ADD START
				eKK2541B004Map.put(EKK2541B004CBSMsg1List.KAP_KEI_STAT, EKK2541B004Msg.getString(EKK2541B004CBSMsg1List.KAP_KEI_STAT));
				//OM-2021-0000276 ADD END
				eKK2541B004List.add(eKK2541B004Map);
			}
		}
		return eKK2541B004List;
	}
	
	/**
	 * 割引サービス詳細一意照会SC(EKK2371A010)を呼び出す。
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText
	 * @param kktkSvcKeiNo
	 * @param func_cd 機能コード
	 * @return 割賦料金一覧照会の結果
	 * @throws Exception SC実行時の例外
	 */
	private List<HashMap<String, Object>> getKktkSvcKeiInfo(SessionHandle handle
																, IRequestParameterReadWrite param
																, String fixedText
																, String kktkSvcKeiNo
																, String func_cd
																) throws Throwable
	{
		// 割引サービス詳細一意照会
		List<HashMap<String, Object>> eKK0341A010List = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 割引サービス詳細一意照会の上りマッピング
		Object[][] EKK0341A010In =
		{
			{EKK0341A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0341A010}
			, {EKK0341A010CBSMsg.FUNC_CODE, func_cd}					// 機能コード
			, {EKK0341A010CBSMsg.KEY_KKTK_SVC_KEI_NO, kktkSvcKeiNo}		// ＫＥＹ＿サービス契約番号
			, {EKK0341A010CBSMsg.KEY_RSV_APLY_YMD, JPCBPCommon.getOpeDate(null)}		// ＫＥＹ＿予約適用年月日
		};
		
		// サービスIF実行
		CAANMsg[] EKK0341A010Msg1List = callSC(handle, scCall, param, fixedText, EKK0341A010In,
				new EKK0341A010CBSMsg().getContents()).getCAANMsgList(EKK0341A010CBSMsg.EKK0341A010CBSMSG1LIST);
		
		if (null != EKK0341A010Msg1List)
		{
			for (CAANMsg EKK0341A010Msg : EKK0341A010Msg1List)
			{
				HashMap<String, Object> eKK0341A010Map = new HashMap<String, Object>();
				eKK0341A010Map.put(EKK0341A010CBSMsg1List.SVC_STA_YMD, EKK0341A010Msg.getString(EKK0341A010CBSMsg1List.SVC_STA_YMD));
				eKK0341A010Map.put(EKK0341A010CBSMsg1List.PPLAN_CD, EKK0341A010Msg.getString(EKK0341A010CBSMsg1List.PPLAN_CD));
				//ANK-3675-00-00 ADD START
				eKK0341A010Map.put(EKK0341A010CBSMsg1List.PLAN_CHRG_STAYMD, EKK0341A010Msg.getString(EKK0341A010CBSMsg1List.PLAN_CHRG_STAYMD));
				eKK0341A010Map.put(EKK0341A010CBSMsg1List.SVC_CHRG_STAYMD, EKK0341A010Msg.getString(EKK0341A010CBSMsg1List.SVC_CHRG_STAYMD));
				//ANK-3675-00-00 ADD END
				eKK0341A010List.add(eKK0341A010Map);
			}
		}
		return eKK0341A010List;
	}
	
	/**
	 * システムパラメータ管理一意照会（解約精算金取得用）を行うサービスインターフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param sysParamBunruiCd システムパラメータ分類コード
	 * @param sysParamID システムパラメータID
	 * @param keizokuGetuNum 継続月数
	 * @param func_cd 機能コード
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private List<HashMap<String, Object>> getSysParamPnltyPrc(SessionHandle handle
															, IRequestParameterReadWrite param
															, String fixedText
															, String sysParamBunruiCd
															, String sysParamID
															, int keizokuGetuNum
															, String func_cd)throws Throwable
	{
		// システムパラメータ管理一意照会（解約精算金取得用）
		List<HashMap<String, Object>> eZM0311A020List = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// int形の型をString型へ変換
		String keizokuGetuNumString = String.valueOf(keizokuGetuNum);
		
		// 違約金一意照会の上りマッピング
		Object[][] EZM0311A020In =
		{
			{EZM0311A020CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0311A020}
			// 機能コード："1"
			, {EZM0311A020CBSMsg.FUNC_CODE, func_cd}
			// ＫＥＹ＿システムパラメータ分類コード
			, {EZM0311A020CBSMsg.KEY_SYS_PARAM_BUNRUI_CD, sysParamBunruiCd}
			// ＫＥＹ＿システムパラメータID
			, {EZM0311A020CBSMsg.KEY_SYS_PARAM_ID, sysParamID}
			// ＫＥＹ＿継続月数
			, {EZM0311A020CBSMsg.KEY_KEIZOKU_GETU_NUM, keizokuGetuNumString}
		};
		
		// サービスIF実行
		CAANMsg[] EZM0311A020Msg1List = callSC(handle, scCall, param, fixedText, EZM0311A020In,
				new EZM0311A020CBSMsg().getContents()).getCAANMsgList(EZM0311A020CBSMsg.EZM0311A020CBSMSG1LIST);
		
		if (null != EZM0311A020Msg1List)
		{
			for (CAANMsg EZM0311A020Msg : EZM0311A020Msg1List)
			{
				HashMap<String, Object> eZM0311A020Map = new HashMap<String, Object>();
				eZM0311A020Map.put(EZM0311A020CBSMsg1List.SYS_PARAM_SETTE_VALUE_3, EZM0311A020Msg.getString(EZM0311A020CBSMsg1List.SYS_PARAM_SETTE_VALUE_3));
				eZM0311A020List.add(eZM0311A020Map);
			}
		}
		return eZM0311A020List;
	}
	
	/**
	 * オプションサービス契約一覧照会を行うサービスインターフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param sysParamBunruiCd システムパラメータ分類コード
	 * @param sysParamID システムパラメータID
	 * @param keizokuGetuNum 継続月数
	 * @param func_cd 機能コード
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private List<HashMap<String, Object>> getOpSvcInfo(SessionHandle handle
															, IRequestParameterReadWrite param
															, String fixedText
															, String kktkSvcKeiNo
															// IT1-2018-0000071 ADD START
															, String svcKeiNo
															// IT1-2018-0000071 ADD END
															, String opSvcCd
															, String func_cd)throws Throwable
	{
		// システムパラメータ管理一意照会（解約精算金取得用）
		List<HashMap<String, Object>> eKK0351B010List = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 違約金一意照会の上りマッピング
		Object[][] EKK0351B010In =
		{
			{EKK0351B010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0351B010}
			// 機能コード："1"
			, {EKK0351B010CBSMsg.FUNC_CODE, func_cd}
			// ＫＥＹ＿機器提供サービス契約番号
			, {EKK0351B010CBSMsg.KEY_KKTK_SVC_KEI_NO, kktkSvcKeiNo}
			// IT1-2018-0000071 ADD START
			// ＫＥＹ＿機器提供サービス契約番号
			, {EKK0351B010CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}
			// IT1-2018-0000071 ADD END
			// ＫＥＹ＿オプションサービスコード
			, {EKK0351B010CBSMsg.KEY_OP_SVC_CD, opSvcCd}
		};
		
		// サービスIF実行
		CAANMsg[] EKK0351B010Msg1List = callSC(handle, scCall, param, fixedText, EKK0351B010In,
				new EKK0351B010CBSMsg().getContents()).getCAANMsgList(EKK0351B010CBSMsg.EKK0351B010CBSMSG1LIST);
		
		if (null != EKK0351B010Msg1List)
		{
			for (CAANMsg EKK0351B010Msg : EKK0351B010Msg1List)
			{
				HashMap<String, Object> eKK0351B010Map = new HashMap<String, Object>();
				eKK0351B010Map.put(EKK0351B010CBSMsg1List.OP_SVC_KEI_NO, EKK0351B010Msg.getString(EKK0351B010CBSMsg1List.OP_SVC_KEI_NO));
				eKK0351B010List.add(eKK0351B010Map);
			}
		}
		return eKK0351B010List;
	}
	
	/**
	 * 割引サービス対象契約一覧照会(機器提供サービス契約)を行うサービスインターフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param kktkSvcKeiNo 機器提供サービス契約番号
	 * @param opSvcKeiNo オプションサービス契約番号
	 * @param func_cd 機能コード
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private List<HashMap<String, Object>> getWribSvcTankaNo(SessionHandle handle
															, IRequestParameterReadWrite param
															, String fixedText
															, String kktkSvcKeiNo
															// IT1-2018-0000071 MOD START
															//, String opSvcKeiNo
															, String opSvcCd
															// IT1-2018-0000071 MOD END
															, String func_cd)throws Throwable
	{
		// 割引サービス対象契約一覧照会(機器提供サービス契約)
		List<HashMap<String, Object>> eKK0481B006List = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 違約金一意照会の上りマッピング
		Object[][] EKK0481B006In =
		{
			{EKK0481B006CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0481B006}
			// 機能コード："1"
			, {EKK0481B006CBSMsg.FUNC_CODE, func_cd}
			// ＫＥＹ＿機器提供サービス契約番号
			, {EKK0481B006CBSMsg.KEY_KKTK_SVC_KEI_NO, kktkSvcKeiNo}
			// IT1-2018-0000071 MOD START
			//// ＫＥＹ＿オプションサービスコード
			//, {EKK0481B006CBSMsg.KEY_OP_SVC_KEI_NO, opSvcKeiNo}
			// ＫＥＹ＿機器提供サービス契約番号
			, {EKK0481B006CBSMsg.KEY_OP_SVC_CD, opSvcCd}
		};
		
		// サービスIF実行
		CAANMsg[] EKK0481B006Msg1List = callSC(handle, scCall, param, fixedText, EKK0481B006In,
				new EKK0481B006CBSMsg().getContents()).getCAANMsgList(EKK0481B006CBSMsg.EKK0481B006CBSMSG1LIST);
		
		if (null != EKK0481B006Msg1List)
		{
			for (CAANMsg EKK0481B006Msg : EKK0481B006Msg1List)
			{
				HashMap<String, Object> eKK0481B006Map = new HashMap<String, Object>();
				eKK0481B006Map.put(EKK0481B006CBSMsg1List.WRIB_SVC_TANKA_NO, EKK0481B006Msg.getString(EKK0481B006CBSMsg1List.WRIB_SVC_TANKA_NO));
				eKK0481B006List.add(eKK0481B006Map);
			}
		}
		return eKK0481B006List;
	}
	// ANK-3383-00-00 ADD END S呼び出し
	
	// ANK-3383-06-00 ADD START
	/**
	 * 割賦プラン一意照会
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param kapPlanCd 割賦プランコード
	 * @param funcCd 機能コード
	 * @return メッセージ
	 * @throws Throwable 
	 */
	private String getKapPayCnt(SessionHandle handle
											, IRequestParameterReadWrite param
											, String fixedText
											, String kapPlanCd
											, String funcCd
											) throws Throwable
	{
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		// 割賦プラン一意照会の検索パラメータを設定
		Object[][] eKK2521A010 = {
				{EKK2521A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK2521A010}
				,{EKK2521A010CBSMsg.FUNC_CODE, funcCd}									// 機能コード
				,{EKK2521A010CBSMsg.KEY_KAP_PLAN_CD, kapPlanCd}							// ＫＥＹ＿割賦プランコード
				,{EKK2521A010CBSMsg.KEY_RSV_APLY_YMD, JPCBPCommon.getOpeDate(null)}		// ＫＥＹ＿予約適用年月日
		};

		// ◇ SC呼出実行
		CAANMsg[] eKK2521A010Msg1List = callSC(handle, scCall, param, fixedText, eKK2521A010,
				new EKK2521A010CBSMsg().getContents()).getCAANMsgList(EKK2521A010CBSMsg.EKK2521A010CBSMSG1LIST);
		
		
		if (null != eKK2521A010Msg1List)
		{
			for (CAANMsg eKK2521A010Msg : eKK2521A010Msg1List)
			{
				return eKK2521A010Msg.getString(EKK2521A010CBSMsg1List.KAP_PAY_CNT);
			}
		}

		return "";
	}
	// ANK-3383-06-00 ADD END
	
	// IT1-2018-0000071 ADD START
	/**
	 * 割引サービス契約内訳一覧照会を行うサービスインターフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param wribSvcKeiNo 割引サービス契約番号
	 * @param func_cd 機能コード
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private List<HashMap<String, Object>> getWribSvcKeiUcwk(SessionHandle handle
															, IRequestParameterReadWrite param
															, String fixedText
															, String wribSvcKeiNo
															, String func_cd)throws Throwable
	{
		// 割引サービス契約内訳一覧照会
		List<HashMap<String, Object>> eKK2361B010List = new ArrayList<HashMap<String, Object>>();

		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		// 割引サービス契約内訳一覧照会の上りマッピング
		Object[][] eKK2361B010In =
		{
			{EKK2361B010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK2361B010}
			// 機能コード："1"
			, {EKK2361B010CBSMsg.FUNC_CODE, func_cd}
			// ＫＥＹ＿サービス契約番号
			, {EKK2361B010CBSMsg.KEY_WRIB_SVC_KEI_NO, wribSvcKeiNo}
		};

		// サービスIF実行
		CAANMsg[] eKK2361B010Msg1List = callSC(handle, scCall, param, fixedText, eKK2361B010In,
				new EKK2361B010CBSMsg().getContents()).getCAANMsgList(EKK2361B010CBSMsg.EKK2361B010CBSMSG1LIST);
		
		if (null != eKK2361B010Msg1List)
		{
			for (CAANMsg eKK2361B010Msg : eKK2361B010Msg1List)
			{
				HashMap<String, Object> eKK2361B010Map = new HashMap<String, Object>();
				eKK2361B010Map.put(EKK2361B010CBSMsg1List.WRIB_APLY_CNT, eKK2361B010Msg.getString(EKK2361B010CBSMsg1List.WRIB_APLY_CNT));
				eKK2361B010Map.put(EKK2361B010CBSMsg1List.SVC_CHRG_STAYMD, eKK2361B010Msg.getString(EKK2361B010CBSMsg1List.SVC_CHRG_STAYMD));
				// OM-2022-0000518 ADD START
				eKK2361B010Map.put(EKK2361B010CBSMsg1List.WRIB_SVC_DTL_CD, eKK2361B010Msg.getString(EKK2361B010CBSMsg1List.WRIB_SVC_DTL_CD));
				// OM-2022-0000518 ADD END
				eKK2361B010List.add(eKK2361B010Map);
			}
		}
		return eKK2361B010List;
	}
	// IT1-2018-0000071 ADD END
	
	// OM-2018-0000648 ADD START
	/**
	 * サービス申込時サービス契約一覧照会を行うサービスインターフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param svcKeiNo サービス契約番号
	 * @param func_cd 機能コード
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private String callEkk0081b019(SessionHandle handle
										, IRequestParameterReadWrite param
										, String fixedText
										, String svcKeiNo
										, String func_cd)throws Throwable
	{
		// サービス申込時サービス契約一覧照照会結果.申込明細番号
		String mskmDtlNo = "";

		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		// サービス申込時サービス契約一覧照会の上りマッピング
		Object[][] eKK0081B019In =
		{
			{EKK0081B019CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0081B019}
			// 機能コード："1"
			, {EKK0081B019CBSMsg.FUNC_CODE, func_cd}
			// ＫＥＹ＿サービス契約番号
			, {EKK0081B019CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}
		};

		// サービスIF実行
		CAANMsg[] eKK0081B019Msg1List = callSC(handle, scCall, param, fixedText, eKK0081B019In,
				new EKK0081B019CBSMsg().getContents()).getCAANMsgList(EKK0081B019CBSMsg.EKK0081B019CBSMSG1LIST);
		
		if (null != eKK0081B019Msg1List)
		{
			for (CAANMsg eKK0081B019Msg : eKK0081B019Msg1List)
			{
				HashMap<String, Object> eKK0081B019Map = new HashMap<String, Object>();
				mskmDtlNo = eKK0081B019Msg.getString(EKK0081B019CBSMsg1List.MSKM_DTL_NO);
			}
		}
		return mskmDtlNo;
	}
	// OM-2018-0000648 ADD END
	
	/**
	 * SC(サービスインターフェイス）を呼び出す。
	 * @param handle セッションハンドル
	 * @param scCall SC呼び出し部品
	 * @param param リクエストパラメータ
	 * @param dataMapKey パラメータキー
	 * @param mappingData マッピングデータ
	 * @param contents CAANMsgのコンテンツ
	 * @return CAANMsg
	 * @throws Throwable 例外が発生した場合
	 */
	private CAANMsg callSC(SessionHandle handle
								, ServiceComponentRequestInvoker scCall
								, IRequestParameterReadWrite param
								, String dataMapKey
								, Object[][] mappingData
								, Object[][] contents) throws Throwable
	{
		HashMap<String, Object> paramMap = editInMsg(param, mappingData);
		
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		CAANMsg msg = templates[0];
		
		// リターンコード取得
		Object return_code = result.get(JCMConstants.RET_CD_INT_KEY);
		
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		editErrorInfoCom(param, templates, (Integer)return_code, dataMapKey, mappingData, contents);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		
		if (null == errList)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(return_code.toString()) && 0 == status))
		{
			throw new SCCallException("戻り値不正", return_code.toString(), status);
		}
		
		return msg;
	}
	
	
	/**
	 * エラー情報を取得します。
	 * @param param リクエストパラメータ
	 * @param templates CAANMsgクラス
	 * @param returnCode リターンコード
	 * @param dataMapKey パラメータキー
	 * @param mappingData マッピングデータ
	 * @param contents CAANMsgのコンテンツ
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException リクエストパラメータの操作でエラーが発生した場合
	 */
	private IRequestParameterReadWrite editErrorInfoCom(IRequestParameterReadWrite param
															, CAANMsg[] templates
															, int returnCode
															, String dataMapKey
															, Object[][] mappingData
															, Object[][] contents) throws RequestParameterException
	{
		CAANMsg template = templates[0];
		
		int templateStatus = template.getInt(JCMConstants.STATUS_INT_KEY);
		
		if (0 != returnCode)
		{
			templateStatus = 9000;
		}
		
		if (null == JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + String.format(RETURN_MESSAGE_FORMAT, templateStatus)))
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		if (null == obj)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}
		
		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format(RETURN_MESSAGE_FORMAT, templateStatus);
			
			String message = JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + formatStatus);
			
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap<String, String> inMap = null;
		
		// ユーザデータ情報
		inMap = (HashMap<String, String>)param.getData(dataMapKey);
		
		for (int i = 0; null != contents && i < contents.length ; i++)
		{
			String itemNm = (String)contents[i][0];
			if (itemNm.endsWith(ERRITEM_SUFFIX))
			{
				String errCd = (String)template.getString(itemNm);
				if (!JKKStringUtil.isNullBlank(errCd))
				{
					inMap.put(itemNm, errCd);
				}
			}
		}
		
		return param;
	}
	
	
	/**
	 * <dl>
	 * <dt>処理概要：
	 * <dd>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする<br>
	 * <dt>処理補足：
	 * <dd>
	 * </dl>
	 * 
	 * @param msgList
	 * @param param
	 * @param mapName
	 * @return IRequestParameterReadWrite
	 * @throws Throwable
	 */
	@SuppressWarnings({ "unchecked", "cast", "boxing" })
	public IRequestParameterReadWrite editResultRP(Map<?, ?> msgList,
			@SuppressWarnings("hiding") IRequestParameterReadWrite param,
			String mapName) throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = (Map)param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// 結果を詰めるマップを取得。
		HashMap dataMap = null;
		
		// 業務データ設定
		dataMap = (HashMap)param.getData(mapName);
		if (dataMap == null)
		{
			dataMap = new HashMap();
			param.setData(mapName, dataMap);
		}
		
		// エラー情報の設定
		param = editErrorInfo(param, templates, (Integer)return_code, mapName);
		
		// エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	
	/**
	 * <dl>
	 * <dt>処理概要：
	 * <dd>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする<br>
	 * <dt>処理補足：
	 * <dd>
	 * </dl>
	 * 
	 * @param param      業務データ取得・書込用I/F
	 * @param templates  CAANMsgクラス配列
	 * @param returnCode リターンコード
	 * @param mapName    SCマップ名
	 * @return IRequestParameterReadWrite
	 * @throws Throwable
	 */
	@SuppressWarnings({ "unchecked", "cast", "null", "boxing" })
	public IRequestParameterReadWrite editErrorInfo(@SuppressWarnings("hiding") IRequestParameterReadWrite param,
			CAANMsg[] templates,
			int returnCode,
			String mapName) throws Throwable
	{
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK3131B010CBSMsg.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 inMap = null;
		
		// 作業項目領域
		Map workMap = (Map)param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// ユーザデータ情報
		inMap = (HashMap)param.getData(mapName);
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData(mapName, inMap);
		}
		
		String svcIf = null;
		if (svcIf == null)
		{
			return param;
		}
		else
		{
			// 処理なし
		}
		
		return param;
	}
	
	/**
	 * <dl>
	 * <dt>処理概要：
	 * <dd>呼び出したサービスIFの処理結果を判定する.<br>
	 * <dt>処理補足：
	 * <dd>
	 * </dl>
	 * 
	 * @param result
	 * @throws Throwable
	 */
	@SuppressWarnings("boxing")
	private void checkExecutionResult(Map<?, ?> result) throws Throwable
	{
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		Integer status = templates[0].getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if (!("0".equals(rtnCode) && 0 == status.intValue()))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
	}
	
	
	/**
	 * チェック処理です。<br>
	 * <br>
	 * 
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return HashMap
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public HashMap getInvokeCBS(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
			throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		
		List<CAANMsg> templates = new ArrayList<CAANMsg>();
		
		// チェック用サービスインターフェイス
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, Arrays.asList(templates));
		
		return paramMap;
	}
	
	
	/**
	 * 共通項目のメッセージを作成します。
	 * @param param リクエストパラメータ
	 * @param mappingData マッピングデータ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException リクエストパラメータの操作でエラーが発生した場合
	 */
	private HashMap<String, Object> editInMsg(IRequestParameterReadWrite param,
			Object[][] mappingData) 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));
		
		// サービスインターフェイスID
		String svcIf = (String)mappingData[0][1];
		CAANMsg template = new CAANMsg(String.format("eo.ejb.cbs.cbsmsg.%sCBSMsg", svcIf));
		
		// オペレータID
		template.set(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		// 運用日付
		template.set(JCMConstants.OPERATE_DATE_KEY, param.getControlMapData(SCControlMapKeys.OPE_DATE));
		// 運用日時
		template.set(JCMConstants.OPERATE_DATETIME_KEY, param.getControlMapData(SCControlMapKeys.OPE_TIME));
		
		for (int i = 0; i < mappingData.length; i++)
		{
			if ("".equals(mappingData[i][1]))
			{
				template.setNull((String)mappingData[i][0]);
			}
			else
			{
				template.set((String)mappingData[i][0], mappingData[i][1]);
			}
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		
		templates[0] = template;
		
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	
	/**
	 * 配列の比較処理を行います。<br>
	 * <br>
	 * @param	workArray
	 * @param	syoriKbn
	 * @param	prcGrpCd
	 * @return	true:正常
	 * @throws	Exception
	 */
	public boolean checkArray(String[][] workArray, int syoriKbn, String prcGrpCd) throws Exception
	{
		for (int i = 0; i < workArray[syoriKbn].length; i++)
		{
			if (workArray[syoriKbn][i].equals(prcGrpCd))
			{
				return true;
			}
		}
		return false;
	}
	
	
	/**
	 * 長割解約精算金の計算を行います。<br>
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param pcrsCd 料金コースコード
	 * @param pplanCd 料金プランコード
	 * @param dslRsvYmd 解約予定日
	 * @param keizokuGetuNum 継続月数
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	public HashMap<String, Object> calcTyoWari(SessionHandle handle
													, IRequestParameterReadWrite param
													, String fixedText
													, String pcrsCd
													, String pplanCd
													, String dslRsvYmd
													, int keizokuGetuNum)throws Throwable
	{
		List<HashMap<String, Object>> eAC0221A010ListTyoWari = new ArrayList<HashMap<String, Object>>();
		HashMap<String,Object> eAC0221A010MapTyoWari = new HashMap<String,Object>();
		
		// 割引サービス単価番号の初期値
		String wribSvcTankaNo = "";
		
		// 割引サービス単価一覧照会
		List<HashMap<String, Object>> eKK0711B001List = getWribSvcTankaIcrn(handle, param, fixedText, WRIB_SVC_CD_W00000041, JPCModelConstant.FUNC_CD_1);
		
		for (int j = 0; j < eKK0711B001List.size(); j++)
		{
			HashMap<String,Object> eKK0711B001Msg = (HashMap<String,Object>)eKK0711B001List.get(j);
			
			// 料金コースコード
			String eKK0711B001_pcrsCd = JKKStringUtil.nullToBlank((String)eKK0711B001Msg.get(EKK0711B001CBSMsg1List.PCRS_CD));
			// 料金プランコード
			String eKK0711B001_pplanCd = JKKStringUtil.nullToBlank((String)eKK0711B001Msg.get(EKK0711B001CBSMsg1List.PPLAN_CD));
			
			if (eKK0711B001_pcrsCd.equals(pcrsCd) && eKK0711B001_pplanCd.equals(pplanCd))
			{
				// 割引サービス単価番号を取得
				wribSvcTankaNo = JKKStringUtil.nullToBlank((String)eKK0711B001Msg.get(EKK0711B001CBSMsg1List.WRIB_SVC_TANKA_NO));
				break;
			}
		}
		
		// 違約金一意照会
		eAC0221A010ListTyoWari = getPnltyPrcIti(handle, param, fixedText, pcrsCd, wribSvcTankaNo, dslRsvYmd, keizokuGetuNum, JPCModelConstant.FUNC_CD_1);
		
		if (null != eAC0221A010ListTyoWari && eAC0221A010ListTyoWari.size() > 0)
		{
			eAC0221A010MapTyoWari = (HashMap<String,Object>)eAC0221A010ListTyoWari.get(0);
			// ANK-4248-00-00 ADD START
			eAC0221A010MapTyoWari.put(EKK0711B001CBSMsg1List.WRIB_SVC_TANKA_NO, wribSvcTankaNo);
			// ANK-4248-00-00 ADD END
		}
		
		return eAC0221A010MapTyoWari;
	}
	
	
	/**
	 * 割賦支払残回数の計算を行います。<br>
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param pcrsCd 料金コースコード
	 * @param kapPlanCd 割賦プランコード
	 * @param kapKeiSvcStaYmd 割賦契約サービス開始年月日
	 * @param nowKapZanCnt 現在の割賦支払残回数
	 * @param dslRsvYmd 解約予定日
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	public String calckapZanNum(SessionHandle handle
									, IRequestParameterReadWrite param
									, String fixedText
									, String pcrsCd
									, String kapPlanCd
									, String kapKeiSvcStaYmd
									, String nowKapZanCnt
									// ST-2018-0000011 MOD START
									//, String dslRsvYmd)throws Throwable
									, String dslRsvYmd
									, String kapKeiChrgStaYmd
									)throws Throwable
									// ST-2018-0000011 MOD END
	{
		String kapZanCnt = "";
		String seikyYm = "";
		
		// 料金スケジュール定義一覧照会
		List<HashMap<String, Object>> eCH0501B010List  = callPrcSchdlTeigiSc(handle, param, fixedText, JPCModelConstant.FUNC_CD_4);
		
		if (null != eCH0501B010List && eCH0501B010List.size() > 0)
		{
			// 
			HashMap<String,Object> eCH0501B010Map = (HashMap<String,Object>)eCH0501B010List.get(0);
			
			// 請求年月
			seikyYm = JKKStringUtil.nullToBlank((String)eCH0501B010Map.get(ECH0501B010CBSMsg1List.SEIKY_YM));
		}
		
		// ANK-3636-00-00 MOD START
		// ANK-3951-00-00 MOD START
//		if (JKKStrConst.KAP_PLAN_CD_BUNKATSU.equals(kapPlanCd) || JKKStrConst.KAP_PLAN_CD_BUNKATSU_10_PERCENT.equals(kapPlanCd))
		if (JKKStrConst.KAP_PLAN_CD_BUNKATSU.equals(kapPlanCd) || JKKStrConst.KAP_PLAN_CD_BUNKATSU_10_PERCENT.equals(kapPlanCd)
				|| JKKStrConst.KAP_PLAN_CD_BUNKATSU_24_10PER.equals(kapPlanCd) )
		// ANK-3951-00-00 MOD END
		// ANK-3636-00-00 MOD END
		{
			// ST-2018-0000011 ADD START
			
			String opeMonth = JPCBPCommon.getOpeDate(null).substring(0,6);
			
			String kapKeiChrgStaYm = kapKeiChrgStaYmd.substring(0,6);
			
			if (opeMonth.compareTo(kapKeiChrgStaYm) <= 0)
			{
				int minusCnt = 0;
				
				// 運用日付時点で課金開始されていない場合
				minusCnt = JPCDateUtil.subtractMonth(dslRsvYmd, kapKeiChrgStaYmd);
				
				if (Integer.valueOf(minusCnt) < 0)
				{
					// 0より小さい数字になった場合、0回引く
					minusCnt = 0;
				}
				
				kapZanCnt = String.valueOf( Integer.valueOf(nowKapZanCnt)  - Integer.valueOf(minusCnt));
				
				// ANK-3383-00-00 ADD START
				if (Integer.valueOf(kapZanCnt) < 0)
				{
					// 割賦残回数が0より小さい数字になった場合、支払済と判断し残回数に０回を設定する。
					kapZanCnt = "0";
				}
				
				// ANK-3383-00-00 ADD END
				
			} else
			{
			// ST-2018-0000011 ADD END
				// 割賦残回数
				kapZanCnt = String.valueOf( Integer.valueOf(nowKapZanCnt)  - Integer.valueOf(JPCDateUtil.subtractMonth(dslRsvYmd, seikyYm + "01")));
				
				if (Integer.valueOf(kapZanCnt) < 0)
				{
					// 割賦残回数が0より小さい数字になった場合、支払済と判断する
					kapZanCnt = "0";
				}
			// ST-2018-0000011 ADD START
			}
			// ST-2018-0000011 ADD END
		}
		// ANK-3636-00-00 MOD START
		else if (JKKStrConst.KAP_PLAN_CD_IKKATSU.equals(kapPlanCd) || JKKStrConst.KAP_PLAN_CD_IKKATSU_10_PERCENT.equals(kapPlanCd))
		// ANK-3636-00-00 MOD END
		{
			if (!JKKStringUtil.isNullBlank(kapKeiSvcStaYmd))
			{
				String kapKeiSvcStaYm = kapKeiSvcStaYmd.substring(0, 6);
				String dslRsvYm = dslRsvYmd.substring(0, 6);
				
				if (dslRsvYm.equals(kapKeiSvcStaYm))
				{
					// 解約予定日時点で、請求がまだ行われていない
					kapZanCnt = "1";
				}
				else
				{
					// 解約予定日時点で、請求が行われた
					kapZanCnt = "0";
				}
			}
			else
			{
				// 割賦契約サービス開始年月日を取得できなかった場合、請求がまだ行われていないと判断する
				kapZanCnt = "1";
			}
		}
		
		return kapZanCnt;
	}
	
	// IT1-2018-0000071 MOD START
//	// ANK-3383-00-00 ADD START
//	/**
//	 * 工事費相当額キャンペーンの適用残回数を返却する。
//	 * <br>
//	 * @param	handle handle
//	 * @param	param 共通パラメータ
//	 * @param	fixedText fixedText
//	 * @param	wribSvcDtlCd 割引サービス詳細コード
//	 * @param	dslAplyYmd 解約予定年月日
//	 * @return	kojihiWribCampainZkaisu 工事費相当額キャンペーンの適用残回数
//	 * @throws Throwable 
//	 */
//	private String getKojihiWribCampainZkaisu(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String wribSvcDtlCd, String dslAplyYmd) throws Throwable
//	{
//		List<HashMap<String, Object>> eKK2371A010List  = new ArrayList<HashMap<String, Object>>();
//		
//		String kojihiWribCampainZkaisu  ="";
//		Integer minusCnt = 0;
//		Integer calcZkaisu = 0;
//		
//		// 割引サービス一意照会の呼び出し
//		eKK2371A010List = getKikiInfoEKK2371A010(handle, param, fixedText, wribSvcDtlCd, JPCModelConstant.FUNC_CD_2);
//		
//		if (eKK2371A010List.size() > 0)
//		{
//			HashMap<String, Object> eKK0841A010Map = (HashMap<String, Object>)eKK2371A010List.get(0);
//			
//			String aplyCnt = (String)eKK0841A010Map.get(EKK2371A010CBSMsg1List.APLY_CNT);
//			
//			// 解約日時点での継続月数を計算
//			minusCnt = JPCDateUtil.subtractMonth(dslAplyYmd, JPCBPCommon.getOpeDate(null));
//			
//			// ANK-3383-06-00 ADD START
//			if (minusCnt < 0)
//			{
//				// マイナス値になった場合、０を設定
//				minusCnt = 0;
//			}
//			// ANK-3383-06-00 ADD END
//			
//			// 現在の残り適用回数＝キャンペーン適用数から割引適用回数の減算
//			calcZkaisu = Integer.valueOf(aplyCnt) - Integer.valueOf(minusCnt);
//			
//			if (calcZkaisu < 0)
//			{
//				// ０未満の値になった場合、適用終了と判断し、０を設定
//				kojihiWribCampainZkaisu = "0";
//			}
//			else
//			{
//				kojihiWribCampainZkaisu = String.valueOf(calcZkaisu);
//			}
//		}
//		
//		return kojihiWribCampainZkaisu;
//	}
//	// ANk-3383-00-00 ADD END
	/**
	 * 工事費相当額キャンペーンの適用残回数を返却する。
	 * <br>
	 * @param	handle handle
	 * @param	param 共通パラメータ
	 * @param	fixedText fixedText
	 * @param	wribSvcKeiNo 割引サービス契約番号
	 * @param	wribSvcChrgStaYmd 割引サービス契約課金開始年月日
	 * @param	dslAplyYmd 解約予定年月日
	 * @return	kojihiWribCampainZkaisu 工事費相当額キャンペーンの適用残回数
	 * @throws Throwable 
	 */
	private String getKojihiWribCampainZkaisu(SessionHandle handle
												, IRequestParameterReadWrite param
												, String fixedText
												// OM-2022-0000518 DEL START
//												, String wribSvcDtlCd
												// OM-2022-0000518 DEL END
												, String wribSvcKeiNo
												, String wribSvcChrgStaYmd
												, String dslAplyYmd) throws Throwable
	{
	
		String aplyCnt = "";
		String zanCnt = "";
		String seikyYm = "";
		String calcZkaisu = "";
		String nowZanCnt = "";
		
		List<HashMap<String, Object>> eKK2371A010List  = new ArrayList<HashMap<String, Object>>();
		List<HashMap<String, Object>> eKK2361B010List =  new ArrayList<HashMap<String, Object>>();
		
		//*******************************
		// 現在の適用残回数を算出する
		//*******************************
		// OM-2022-0000518 DEL START
//		// 割引サービス一意照会の呼び出し
//		eKK2371A010List = getKikiInfoEKK2371A010(handle, param, fixedText, wribSvcDtlCd, JPCModelConstant.FUNC_CD_2);
//		
//		if (eKK2371A010List.size() > 0)
//		{
//			HashMap<String, Object> eKK0841A010Map = (HashMap<String, Object>)eKK2371A010List.get(0);
//			
//			aplyCnt = (String)eKK0841A010Map.get(EKK2371A010CBSMsg1List.APLY_CNT);
//		}
		// OM-2022-0000518 DEL END
		
		// EKK2361B010_割引サービス契約内訳一覧照会呼び出し
		eKK2361B010List = getWribSvcKeiUcwk(handle, param, fixedText, wribSvcKeiNo, JPCModelConstant.FUNC_CD_1);
		String nowAplyCnt = (String)eKK2361B010List.get(0).get(EKK2361B010CBSMsg1List.WRIB_APLY_CNT);
		
		// OM-2022-0000518 ADD START
		String wribSvcDtlCd = (String)eKK2361B010List.get(0).get(EKK2361B010CBSMsg1List.WRIB_SVC_DTL_CD);
		// 割引サービス一意照会の呼び出し
		eKK2371A010List = getKikiInfoEKK2371A010(handle, param, fixedText, wribSvcDtlCd, JPCModelConstant.FUNC_CD_2);
		
		if (eKK2371A010List.size() > 0)
		{
			HashMap<String, Object> eKK0841A010Map = (HashMap<String, Object>)eKK2371A010List.get(0);
			
			aplyCnt = (String)eKK0841A010Map.get(EKK2371A010CBSMsg1List.APLY_CNT);
		}
		// OM-2022-0000518 ADD END
		
		// 現在の残り適用回数＝キャンペーン適用数から割引適用回数の減算
		calcZkaisu = String.valueOf(Integer.valueOf(aplyCnt) - Integer.valueOf(nowAplyCnt));
		
		if (Integer.valueOf(calcZkaisu) < 0)
		{
			// ０未満の値になった場合、適用終了と判断し、０を設定
			nowZanCnt = "0";
		}
		else
		{
			nowZanCnt = String.valueOf(calcZkaisu);
		}
		
		//*********************************************
		// ここから解約予定日時点の適用残回数の計算
		//*********************************************
		// 料金スケジュール定義一覧照会
		List<HashMap<String, Object>> eCH0501B010List  = callPrcSchdlTeigiSc(handle, param, fixedText, JPCModelConstant.FUNC_CD_4);
		
		if (null != eCH0501B010List && eCH0501B010List.size() > 0)
		{
			HashMap<String,Object> eCH0501B010Map = (HashMap<String,Object>)eCH0501B010List.get(0);
			
			// 請求年月
			seikyYm = JKKStringUtil.nullToBlank((String)eCH0501B010Map.get(ECH0501B010CBSMsg1List.SEIKY_YM));
		}
		
		String opeMonth = JPCBPCommon.getOpeDate(null).substring(0,6);
		
		String wribSvcChrgStaYm =wribSvcChrgStaYmd.substring(0,6);
		
		if (opeMonth.compareTo(wribSvcChrgStaYm) <= 0)
		{
			int minusCnt = 0;
			
			// 運用日付時点で課金開始されてい場合
			minusCnt = JPCDateUtil.subtractMonth(dslAplyYmd, wribSvcChrgStaYmd);
			
			if (Integer.valueOf(minusCnt) < 0)
			{
				// 0より小さい数字になった場合、0回引く
				minusCnt = 0;
			}
			
			zanCnt = String.valueOf( Integer.valueOf(nowZanCnt)  - Integer.valueOf(minusCnt));
			
			if (Integer.valueOf(zanCnt) < 0)
			{
				// 適用残回数が0より小さい数字になった場合、適用済と判断し残回数に０回を設定する。
				zanCnt = "0";
			}
			
		} else
		{
			// 適用残回数
			zanCnt = String.valueOf( Integer.valueOf(nowZanCnt)  - Integer.valueOf(JPCDateUtil.subtractMonth(dslAplyYmd, seikyYm + "01")));
			
			if (Integer.valueOf(zanCnt) < 0)
			{
				// 適用残回数が0より小さい数字になった場合、適用済と判断する
				zanCnt = "0";
			}
		}
		
		return zanCnt;
	}
	// IT1-2018-0000071 MOD END
	
	/**
	 * テレビの解約精算金を求める際の料金プランコードの特定を行います。<br>
	 * <br>
	 * @param pcrsCdTv テレビの料金コースコード
	 * @param pplanCdTv テレビの料金プランコード
	 * @param mansionBukkenCd マンション物件コード
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	public String selectPnltyPplanCdTv(String pcrsCdTv, String pplanCdTv, String mansionBukkenCd)throws Throwable
	{
		String pnltyPplanCdTv = "";
		
		if (JKKStringUtil.isNullBlank(mansionBukkenCd))
		{
			// ホームタイプの場合
			if ("A38".equals(pcrsCdTv))
			{
				// ST-2018-0000011 MOD START
				//pnltyPplanCdTv = "PA2491";
				pnltyPplanCdTv = "PA3891";
				// ST-2018-0000011 MOD END
			}
			else if ("A39".equals(pcrsCdTv))
			{
				pnltyPplanCdTv = "PA3991";
			}
			else if ("A24".equals(pcrsCdTv))
			{
				pnltyPplanCdTv = "PA2491";
			}
			else if ("A64".equals(pcrsCdTv))
			{
				pnltyPplanCdTv = "PA6491";
			}
		}
		else if (JKKStrConst.MANSION_BUKKEN_CD_MEZON.equals(mansionBukkenCd))
		{
			// メゾンタイプの場合
			if ("A38".equals(pcrsCdTv))
			{
				// ST-2018-0000011 MOD START
				//pnltyPplanCdTv = "PA2493";
				pnltyPplanCdTv = "PA3893";
				// ST-2018-0000011 MOD END
			}
			else if ("A39".equals(pcrsCdTv))
			{
				pnltyPplanCdTv = "PA3993";
			}
			else if ("A24".equals(pcrsCdTv))
			{
				pnltyPplanCdTv = "PA2493";
			}
			else if ("A64".equals(pcrsCdTv))
			{
				pnltyPplanCdTv = "PA6493";
			}
		}
		
		if (JKKStringUtil.isNullBlank(pnltyPplanCdTv))
		{
			pnltyPplanCdTv = pplanCdTv;
		}
		
		return pnltyPplanCdTv;
	}
	
	// IT1-2018-0000072 ADD START
	/**
	 * smtlnkInfoListに設定されている解約精算金情報をクリアする<br>
	 * <br>
	 * @param smtlnkInfoList smtlnkInfoList
	 */
	public List<HashMap<String, Object>> clearSmtlnkInfoListAmnt(List<HashMap<String, Object>> smtlnkInfoList)
	{
		for (int j = 0; j < smtlnkInfoList.size() ; j++)
		{
			HashMap<String, Object> smtlnkInfoMap = new HashMap<String, Object>();
			
			smtlnkInfoMap = smtlnkInfoList.get(j);
			
			smtlnkInfoMap.put("smtlnk_ssn_kin_gtgk", "");
			smtlnkInfoMap.put("smtlnk_ssn_kin_zan_getu", "");
			smtlnkInfoMap.put("smtlnk_ssn_kin_all_amnt", "");
		}
		
		return smtlnkInfoList;
	}
	
	/**
	 * gglhmInfoListに設定されている解約精算金情報をクリアする<br>
	 * <br>
	 * @param gglhmInfoList gglhmInfoList
	 */
	public List<HashMap<String, Object>> clearGglhmInfoListAmnt(List<HashMap<String, Object>> gglhmInfoList)
	{
		for (int j = 0; j < gglhmInfoList.size() ; j++)
		{
			HashMap<String, Object> gglhmInfoMap = new HashMap<String, Object>();
			
			gglhmInfoMap = gglhmInfoList.get(j);
			
			gglhmInfoMap.put("gglhm_kap_zkin_gtgk", "");
			gglhmInfoMap.put("gglhm_kap_zkin_zan_getu", "");
			gglhmInfoMap.put("gglhm_kap_zkin_all_amnt", "");
		}
		
		return gglhmInfoList;
	}
	
	/**
	 * stbInfoListに設定されている解約精算金情報をクリアする<br>
	 * <br>
	 * @param stbInfoList stbInfoList
	 */
	public List<HashMap<String, Object>> clearStbInfoListListAmnt(List<HashMap<String, Object>> stbInfoList)
	{
		for (int j = 0; j < stbInfoList.size() ; j++)
		{
			HashMap<String, Object> stbInfoMap = new HashMap<String, Object>();
			
			stbInfoMap = stbInfoList.get(j);
			
			stbInfoMap.put("stb_dsl_ssn_kin", "");
		}
		
		return stbInfoList;
	}
	
	// ANK-3412-03-00 ADD START
	/**
	 * 業務パラメータ管理一意照会を行うサービスインターフェイスを実行し、
	 * 業務パラメータ設定値を返却します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param workParamId 業務パラメータID
	 * @param funcCd 機能コード
	 * @return workParamSetteValue 業務パラメータ設定値
	 * @throws Throwable 例外が発生した場合
	 */
	private String getEZM0321A010(SessionHandle handle
								, IRequestParameterReadWrite param
								, String fixedText
								, String workParamId
								, String funcCd
	)throws Throwable
	{
		String workParamSetteValue = "";
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 業務パラメータ管理一意照会の上りマッピング
		Object[][] EZM0321A010In =
		{
			{EZM0321A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0321A010}
			// 機能コード："1"
			, {EZM0321A010CBSMsg.FUNC_CODE, funcCd}
			// ＫＥＹ＿業務パラメータＩＤ
			, {EZM0321A010CBSMsg.KEY_WORK_PARAM_ID, workParamId}
		};
		
		// サービスIF実行
		CAANMsg[] EZM0321A010Msg1List = callSC(handle, scCall, param, fixedText, EZM0321A010In,
				new EZM0321A010CBSMsg().getContents()).getCAANMsgList(EZM0321A010CBSMsg.EZM0321A010CBSMSG1LIST);
		
		if (null != EZM0321A010Msg1List)
		{
			for (CAANMsg EZM0321A010Msg : EZM0321A010Msg1List)
			{
				if (EZM0321A010Msg != null)
				{
					// 業務パラメータ設定値を取得する
					workParamSetteValue = EZM0321A010Msg.getString(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE);
				}
			}
		}
		
		// 業務パラメータ設定値を返却する
		return workParamSetteValue;
	}
	// ANK-3412-03-00 ADD END

	// v45.00.03 ANK-3636-08-00 DEL START
//	// ANK-3636-08-00 ADD START
//	/**
//	 * 引数の8%の解約精算金を10%の解約精算金に変換します。
//	 * <br>
//	 * @param dslSsnKin8Per 消費税8%の解約精算金
//	 * @return dslSsnKin10Per 消費税10%の解約精算金
//	 * @throws Throwable 例外が発生した場合
//	 */
//	private String chgStax10Per(String dslSsnKin8Per)
//	{
//		// 解約精算金を1.08で割り、小数点以下を切り上げる
//		double dslSsnKin = Math.ceil((Double.parseDouble(dslSsnKin8Per)) / 1.08);
//		// 解約精算金を1.10倍し、小数点以下を切り捨て、消費税10%の解約精算金にする
//		String dslSsnKin10Per = String.valueOf((int)Math.floor(dslSsnKin * 1.10));
//		
//		return dslSsnKin10Per;
//	}
//	// ANK-3636-08-00 ADD END
	// v45.00.03 ANK-3636-08-00 DEL END

	// 20210615 OM-2021-0000557 ADD START
	/**
	 * 解約予定日がプラン課金開始年月日〜プラン課金終了年月日に当てはまっているサービス契約情報を
	 * <br>
	 * サービス契約履歴一覧照会を行うサービスインターフェイスを実行して取得する。
	 * <br>
	 * 当てはまるものがない場合は、
	 * サービス契約一意照会を行うサービスインターフェイスを実行して取得する。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param svcKeiNo サービス契約番号
	 * @param dslRsvdYmd 解約予定日
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private List<HashMap<String, Object>> getSvcKeiInfo(SessionHandle handle
														, IRequestParameterReadWrite param
														, String fixedText
														, String svcKeiNo
														, String dslRsvdYmd)throws Throwable
	{
		// 対象サービス契約情報
		List<HashMap<String, Object>> eKK0081InfoList = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// サービス契約履歴一覧照会の上りマッピング
		Object[][] EKK0081B024In =
		{
			{EKK0081B024CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0081B024}
			// 機能コード："3"
			, {EKK0081B024CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_3}
			// ＫＥＹ＿サービス契約番号
			, {EKK0081B024CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}
		};
		
		// サービスIF実行
		CAANMsg[] EKK0081B024Msg1List = callSC(handle, scCall, param, fixedText, EKK0081B024In,
				new EKK0081B024CBSMsg().getContents()).getCAANMsgList(EKK0081B024CBSMsg.EKK0081B024CBSMSG1LIST);
		
		if (null != EKK0081B024Msg1List)
		{
			for (CAANMsg EKK0081B024Msg : EKK0081B024Msg1List)
			{
				// プラン課金開始年月日、プラン課金終了年月日を取得
				String eKK0081B024_planChrgStaYmd = EKK0081B024Msg.getString(EKK0081B024CBSMsg1List.PLAN_CHRG_STAYMD);
				String eKK0081B024_planChrgEndYmd = EKK0081B024Msg.getString(EKK0081B024CBSMsg1List.PLAN_CHRG_ENDYMD);
				
// ▽▽▽ OM-2021-0001282 ADD START
				// プラン課金開始日、プラン課金終了日に値が入っていない場合はスキップする
				if (JKKStringUtil.isNullBlank(eKK0081B024_planChrgStaYmd) || JKKStringUtil.isNullBlank(eKK0081B024_planChrgEndYmd))
				{
					continue;
				}
// △△△ OM-2021-0001282 ADD END
				// プラン課金終了年月日の当月末日を算出
				Calendar cal = Calendar.getInstance();
				int iYYYY = Integer.parseInt(eKK0081B024_planChrgEndYmd.substring(0, 4));
				int iMM = Integer.parseInt(eKK0081B024_planChrgEndYmd.substring(4, 6));
				cal.clear();
				cal.set(iYYYY, iMM, 1);
				int iDD = cal.getActualMaximum(Calendar.DATE);
				eKK0081B024_planChrgEndYmd = String.valueOf(iYYYY) + String.format("%02d", iMM) + String.format("%02d", iDD);
				
				// 「プラン課金開始年月日 ≦ 解約予定日 ≦ プラン課金終了年月日」かどうかを判定する
				if (eKK0081B024_planChrgStaYmd.compareTo(dslRsvdYmd) <= 0 && dslRsvdYmd.compareTo(eKK0081B024_planChrgEndYmd) <= 0)
				{
					HashMap<String, Object> eKK0081B024Map = new HashMap<String, Object>();
					eKK0081B024Map.put(EKK0081B024CBSMsg1List.SVC_STA_YMD, EKK0081B024Msg.getString(EKK0081B024CBSMsg1List.SVC_STA_YMD));
					eKK0081B024Map.put(EKK0081B024CBSMsg1List.PCRS_CD, EKK0081B024Msg.getString(EKK0081B024CBSMsg1List.PCRS_CD));
					eKK0081B024Map.put(EKK0081B024CBSMsg1List.PRC_GRP_CD, EKK0081B024Msg.getString(EKK0081B024CBSMsg1List.PRC_GRP_CD));
					eKK0081B024Map.put(EKK0081B024CBSMsg1List.PPLAN_CD, EKK0081B024Msg.getString(EKK0081B024CBSMsg1List.PPLAN_CD));
					eKK0081B024Map.put(EKK0081B024CBSMsg1List.SVC_CHRG_STAYMD, EKK0081B024Msg.getString(EKK0081B024CBSMsg1List.SVC_CHRG_STAYMD));
					eKK0081B024Map.put(EKK0081B024CBSMsg1List.TK_HOSHIKI_KEI_NO, EKK0081B024Msg.getString(EKK0081B024CBSMsg1List.TK_HOSHIKI_KEI_NO));
					eKK0081InfoList.add(eKK0081B024Map);
					
					// 条件に合致するレコードが見つかったらループ処理を抜ける
					break;
				}
			}
		}
		
		// サービス契約履歴一覧照会にて対象のレコードがなかった場合、サービス契約一意照会を実行する
		if (eKK0081InfoList.size() <= 0)
		{
			eKK0081InfoList = getSvcKeiIti(handle, param, fixedText, svcKeiNo, JPCModelConstant.FUNC_CD_2);
		}
		return eKK0081InfoList;
	}
	// 20210615 OM-2021-0000557 ADD END
	
	// ANK-4248-00-00 ADD START
	/**
	 * 業務パラメータ管理一覧照会を行うサービスインターフェイスを実行し、
	 * 業務パラメータの一覧を返却します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param workParamId 業務パラメータID(正規表現)
	 * @param funcCd 機能コード
	 * @return Map<String, String> 業務パラメータの一覧
	 * @throws Throwable 例外が発生した場合
	 */
	private Map<String, String> getEZM0321B010(SessionHandle handle
								, IRequestParameterReadWrite param
								, String fixedText
								, String workParamId
								, String funcCd
	) throws Throwable
	{
		// 業務パラメータの一覧
		Map<String, String> ezm0321b010Map = new HashMap<String, String>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 業務パラメータ管理一覧照会の上りマッピング
		Object[][] EZM0321B010In =
		{
			{EZM0321B010CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0321B010}
			// 機能コード："1"
			, {EZM0321B010CBSMsg.FUNC_CODE, funcCd}
			// ＫＥＹ＿業務パラメータＩＤ
			, {EZM0321B010CBSMsg.KEY_WORK_PARAM_ID, workParamId}
		};
		
		// サービスIF実行
		CAANMsg[] EZM0321B010Msg1List = callSC(handle, scCall, param, fixedText, EZM0321B010In,
				new EZM0321B010CBSMsg().getContents()).getCAANMsgList(EZM0321B010CBSMsg.EZM0321B010CBSMSG1LIST);
		
		if (null != EZM0321B010Msg1List)
		{
			for (CAANMsg EZM0321B010Msg : EZM0321B010Msg1List)
			{
				if (EZM0321B010Msg != null)
				{
					// 業務パラメータ設定値を取得する
					ezm0321b010Map.put(JKKStringUtil.nullToBlank(EZM0321B010Msg.getString(EZM0321B010CBSMsg1List.WORK_PARAM_ID))
							, JKKStringUtil.nullToBlank(EZM0321B010Msg.getString(EZM0321B010CBSMsg1List.WORK_PARAM_SETTE_VALUE)));
				}
			}
		}
		
		// 業務パラメータの一覧を返却する
		return ezm0321b010Map;
	}
	
	/**
	 * 経過措置違約金情報リストの取得処理
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @return List<Map<String, Object>> 経過措置違約金情報リスト
	 * @throws Throwable 例外が発生した場合
	 */
	private List<Map<String, Object>> getKeikSochPnltyInfList(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		// 経過措置違約金情報リスト
		List<Map<String, Object>> ezm0321b010List = new ArrayList<Map<String, Object>>();
		
		// 業務パラメータ取得
		Map<String, String> workPamamMap = getEZM0321B010(handle, param, fixedText, JACStrConst.WKPRA_KIK_SOCHI_PLT_ + ".*", JPCModelConstant.FUNC_CD_1);
		
		if (workPamamMap != null && workPamamMap.size() > 0)
		{
			for (Map.Entry<String, String> entry : workPamamMap.entrySet())
			{
				String workParamSetteValue = entry.getValue();
				if (!JKKStringUtil.isNullBlank(workParamSetteValue))
				{
					// 経過措置違約金情報リスト設定
					String[] params = workParamSetteValue.split(JACStrConst.COMMA);
					if (params.length == KEIK_SOCH_PNLTY_INF_CNT)
					{
						try
						{
							new BigDecimal(params[5]);
							Integer.parseInt(params[6]);
						}
						catch (NumberFormatException e)
						{
							// 違約金単価、長割適用日算出月数が数値変換できないレコードはスキップ
							continue;
						}
						Map<String, Object> ezm0321b010 = new HashMap<String, Object>();
						ezm0321b010.put(EAC0221A010CBSMsg1List.TRGT_PCRS_CD, params[0]);
						ezm0321b010.put(EAC0221A010CBSMsg1List.TRGT_PRC_SVC_CD, params[1]);
						ezm0321b010.put(EAC0221A010CBSMsg1List.SVC_DSL_RSN_SKBT_CD, params[2]);
						ezm0321b010.put(EAC0221A010CBSMsg1List.LOWL_VALUE, params[3]);
						ezm0321b010.put(EAC0221A010CBSMsg1List.UPPL_VALUE, params[4]);
						ezm0321b010.put(EAC0221A010CBSMsg1List.PNLTY_TANKA, params[5]);
						ezm0321b010.put(CHO_WRI_MON_CNT, params[6]);
						ezm0321b010List.add(ezm0321b010);
					}
				}
			}
		}
		
		return ezm0321b010List;
	}
	
	/**
	 * 経過措置違約金情報の取得処理
	 * <br>
	 * @param keikSochPnltyInfList 経過措置違約金情報リスト
	 * @param pcrsCd 料金コースコード
	 * @param prcSvcCd 料金サービスコード
	 * @param keizkPrd 継続期間
	 * @return Map<String, Object> 経過措置違約金情報
	 */
	private Map<String, Object> getKeikSochPnltyInf(List<Map<String, Object>> keikSochPnltyInfList, String pcrsCd, String prcSvcCd, int keizkPrd)
	{
		Map<String, Object> inf = null;

		if (keikSochPnltyInfList != null)
		{
			//
			// 下記条件で経過措置違約金情報を検索
			// 
			// 経過措置違約金情報リスト．料金コースコード           ＝ 入力．料金コースコード
			// 経過措置違約金情報リスト．料金サービスコード         ＝ 入力．料金サービスコード
			// 経過措置違約金情報リスト．サービス解約理由識別コード ＝ "0001"（申出解約）
			// 経過措置違約金情報リスト．下限値                     ≦ 入力．継続期間
			// 経過措置違約金情報リスト．上限値                     ≧ 入力．継続期間
			//
			for (Map<String, Object> keikSochPnltyInf: keikSochPnltyInfList)
			{
				if (JKKStringUtil.isNullBlank((String)keikSochPnltyInf.get(EAC0221A010CBSMsg1List.TRGT_PCRS_CD))
						|| JKKStringUtil.isNullBlank((String)keikSochPnltyInf.get(EAC0221A010CBSMsg1List.TRGT_PRC_SVC_CD))
						|| JKKStringUtil.isNullBlank((String)keikSochPnltyInf.get(EAC0221A010CBSMsg1List.SVC_DSL_RSN_SKBT_CD))
						|| JKKStringUtil.isNullBlank((String)keikSochPnltyInf.get(EAC0221A010CBSMsg1List.LOWL_VALUE))
						|| JKKStringUtil.isNullBlank((String)keikSochPnltyInf.get(EAC0221A010CBSMsg1List.UPPL_VALUE))
						|| JKKStringUtil.isNullBlank(pcrsCd)
						|| JKKStringUtil.isNullBlank(prcSvcCd))
				{
					continue;
				}
				if (keikSochPnltyInf.get(EAC0221A010CBSMsg1List.TRGT_PCRS_CD).equals(pcrsCd)
						&& keikSochPnltyInf.get(EAC0221A010CBSMsg1List.TRGT_PRC_SVC_CD).equals(prcSvcCd)
						&& keikSochPnltyInf.get(EAC0221A010CBSMsg1List.SVC_DSL_RSN_SKBT_CD).equals(JKKStrConst.SVC_DLRE_MOUSIDE)
						&& JPCCheckUtil.rangeCheck((String)keikSochPnltyInf.get(EAC0221A010CBSMsg1List.UPPL_VALUE),
								(String)keikSochPnltyInf.get(EAC0221A010CBSMsg1List.LOWL_VALUE), String.valueOf(keizkPrd), DATA_TYPE_NUM))
				{
					inf = new HashMap<String, Object>();
					inf.putAll(keikSochPnltyInf);
					break;
				}
			}
		}
		
		return inf;
	}
	
	/**
	 * 経過措置対象の判定処理
	 * <br>
	 * @param keikSochPnltyInf 経過措置違約金情報
	 * @param kyuseidoEndymd 旧制度満了日
	 * @param svcStaymd サービス開始日
	 * @return boolean 判定結果
	 * @throws Exception 日付の加減算時の例外
	 */
	private boolean isKeikSochTarget(Map<String, Object> keikSochPnltyInf, String kyuseidoEndymd, String svcStaymd) throws Exception
	{
		// ANK-4330-01-00 ADD START
		//長割のサービス課金開始日が未設定または2022年7月1日以降か判定する
		String svcChrgStaymd = JKKStringUtil.nullToBlank((String) keikSochPnltyInf.get(EKK0451B002CBSMsg1List.SVC_CHRG_STAYMD));
		if (kyuseidoEndymd.compareTo(svcChrgStaymd) < 0)
		{
			return false;
		}
		// ANK-4330-01-00 ADD END
		if (keikSochPnltyInf != null)
		{
			if (!JKKStringUtil.isNullBlank(svcStaymd)
					&& keikSochPnltyInf.get(CHO_WRI_MON_CNT) != null)
			{
				//
				// 下記条件で経過措置対象かを判定
				// 
				// サービス開始日 ＋ 経過措置違約金情報．長割適用開始月数 ≦ 旧制度満了日
				//
				int choWriMonCnt = Integer.parseInt((String)keikSochPnltyInf.get(CHO_WRI_MON_CNT));
				String judgeYmd = JPCDateUtil.addMonth(svcStaymd, choWriMonCnt);
				if (judgeYmd.compareTo(kyuseidoEndymd) <= 0)
				{
					return true;
				}
			}
		}
		
		return false;
	}
	// ANK-4248-00-00 ADD END
	
	// ANK-4248-03-00 ADD START
	/**
	 *同一回線内訳サービス契約一覧照会を行うサービスインターフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param svcKeiNo サービス契約番号
	 * @param func_cd 機能コード
	 * @return 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private List<Map<String, Object>> getSvcKeiInfoEKK0081B029(SessionHandle handle
															, IRequestParameterReadWrite param
															, String fixedText
															, String svcKeiNo
															, String func_cd)throws Throwable
	{
		//同一回線内訳サービス契約一覧照会
		List<Map<String, Object>> eKK0081B029List = new ArrayList<Map<String, Object>>();

		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		//同一回線内訳サービス契約一覧照会の上りマッピング
		Object[][] eKK0081B029In =
		{
			{EKK0081B029CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0081B029}
			// 機能コード
			, {EKK0081B029CBSMsg.FUNC_CODE, func_cd}
			// ＫＥＹ＿サービス契約番号
			, {EKK0081B029CBSMsg.KEY_SVC_KEI_NO, svcKeiNo}
			// ＫＥＹ＿回線内訳基準年月日
			, {EKK0081B029CBSMsg.KEY_KISUW_STDARDYMD, JPCBPCommon.getOpeDate(null)}
		};

		// サービスIF実行
		CAANMsg[] eKK0081B029Msg1List = callSC(handle, scCall, param, fixedText, eKK0081B029In,
				new EKK0081B029CBSMsg().getContents()).getCAANMsgList(EKK0081B029CBSMsg.EKK0081B029CBSMSG1LIST);
		
		if (null != eKK0081B029Msg1List)
		{
			for (CAANMsg eKK0081B029Msg : eKK0081B029Msg1List)
			{
				HashMap<String, Object> eKK0081B029Map = new HashMap<String, Object>();
				eKK0081B029Map.put(EKK0081B029CBSMsg1List.SVC_KEI_NO, eKK0081B029Msg.getString(EKK0081B029CBSMsg1List.SVC_KEI_NO));
				eKK0081B029List.add(eKK0081B029Map);
			}
		}
		return eKK0081B029List;
	}
	// ANK-4248-03-00 ADD END
	
	// ANK-4640-00-00 ADD START
	/**
	 * 料金プラン一意照会を行うサービスインターフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText ユーザ定義文字列
	 * @param pcrsCdNet 料金コースコード
	 * @param funcCd 機能コード
	 * @return Map<String, String> 結果
	 * @throws Throwable 例外が発生した場合
	 */
	private List<HashMap<String, Object>> getEKK0791A010(SessionHandle handle
														, IRequestParameterReadWrite param
														, String fixedText
														, String pcrsCdNet
														, String funcCd)throws Throwable
	{
		// 料金プラン一意照会
		List<HashMap<String, Object>> eKK0791InfoList = new ArrayList<HashMap<String, Object>>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 料金プラン一意照会の上りマッピング
		Object[][] EKK0791A010In =
		{
			{EKK0791A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0791A010}
			// 機能コード："2"
			, {EKK0791A010CBSMsg.FUNC_CODE, funcCd}
			// ＫＥＹ＿予約適用年月日を指定
			, {EKK0791A010CBSMsg.KEY_RSV_APLY_YMD, JPCBPCommon.getOpeDate(null)}
			// ＫＥＹ＿予約適用年月日を指定
			, {EKK0791A010CBSMsg.KEY_RSV_APLY_YMD, JPCBPCommon.getOpeDate(null)}
			// ＫＥＹ＿予約適用年月日を指定
			, {EKK0791A010CBSMsg.KEY_RSV_APLY_YMD, JPCBPCommon.getOpeDate(null)}
			// ＫＥＹ＿料金コースコード
			, {EKK0791A010CBSMsg.KEY_PCRS_CD, pcrsCdNet}
			// ＫＥＹ＿予約適用年月日を指定
			, {EKK0791A010CBSMsg.KEY_RSV_APLY_YMD, JPCBPCommon.getOpeDate(null)}
		};
		
		// サービスIF実行
		CAANMsg[] eKK0791A010CBSMsg1List = callSC(handle, scCall, param, fixedText, EKK0791A010In,
				new EKK0791A010CBSMsg().getContents()).getCAANMsgList(EKK0791A010CBSMsg.EKK0791A010CBSMSG1LIST);
		
		if (null != eKK0791A010CBSMsg1List)
		{
			for (CAANMsg EKK0791A010Msg : eKK0791A010CBSMsg1List)
			{
				HashMap<String, Object> eKK0791A010Map = new HashMap<String, Object>();
				
				// NTT卸区分を取得する
				eKK0791A010Map.put(EKK0791A010CBSMsg1List.NTTORS_DIV, EKK0791A010Msg.getString(EKK0791A010CBSMsg1List.NTTORS_DIV));
				eKK0791InfoList.add(eKK0791A010Map);
			}
		}
		return eKK0791InfoList;
	}
	// ANK-4640-00-00 ADD END
}
