/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom					 *
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatSaiInfChtUtil
*	ソースファイル名	：JBSbatSaiInfChtUtil.java
*	作成者				：富士通　
*	作成日				：2011年06月01日
*＜機能概要＞
*　差分情報抽出共通部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2011/06/01  富士通		新規作成
*	v2.00.01	2013/04/30  AS)新居		【TG1-2013-0000257】解約理由コードの末尾に"2"を設定する条件変更
*	v5.00.00	2013/10/31  AS)村田		【OM-2013-0003650】請求書発行手数料が割引されない不具合対応
*	v5.00.01	2013/11/13  AS)新居		【OM-2013-0004050】同日[回復〜解約]情報の除外において、割引の考慮
*	v5.00.02	2013/11/14  AS)新居		【OM-2013-0004078】違約金徴収判定変更（基本契約情報設定条件に違約金発生コード追加）
*	v6.00.00	2013/12/11  AS)新居		【OM-2013-0005001】解約〜回復〜�B解約時、回復年月日を�Bに設定する
*	v6.00.01	2013/12/13  AS)新居		【OM-2013-0005052】違約金徴収判定変更（(親サービス契約の課金終了日が、料金計算対象月に対して「前月末日以上」〜「当月末日未満」)
*	v6.00.02	2013/12/25  AS)村田		【OM-2013-0005313】OM-2013-0005001対応コメントアウト
*	v7.00.00	2014/01/30  AS)新居		【OM-2013-0003456】機器提供サービス契約("30")の場合、提供方式契約番号を付与
*	v7.00.01	2014/01/31  FJ)清藤		【OM-2013-0005298】カレント解約に対し過去の回復年月日の設定(OM-2013-0005001対応方法の修正)
*	v7.00.02	2014/02/17  AS)安井		【OM-2014-0000548】違約金発生条件の修正
*	v8.00.00	2014/03/14  AS)安井		【OM-2014-0000270】休止項目の設定方法変更
*	v8.00.01	2014/03/24  FJ)民岡		【OM-2014-0001201】違約金発生条件の修正
*	v8.00.02	2014/06/05  FJ)岡田		【OM-2014-0001963】解約起算日が料金計算対象月の場合の課金終了日設定の修正
*	v10.00.00	2014/08/27  FJ)岡田		【OM-2014-0002395】解約理由が「強制解約」の場合のプラン課金終了年月日判定の修正
*   v11.00.00   2014/11/25  FJ)安井     【OM-2014-0003702】基本契約.サービスコード:電話、機器契約.料金プラン:VDSL買取の場合の提供方式契約番号取得方法を変更
*   v12.00.00   2015/02/12  FJ)安井     【OM-2015-0000061】CP解約情報置き換え条件変更
*   v19.00.00   2015/10/01  FJ)安井     【OM-2015-0001646】カレントの課金終了日以降の課金開始レコードでも回復時の処理を行うよう修正
**********************************************************************/
package eo.business.common;

import java.util.ArrayList;

import eo.business.util.file.JBSbatKKIFM019;
import eo.business.util.table.JBSbatKK_T_SVC_KEI;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.item.JBSbatOutputItem;
import eo.framework.item.JBSbatServiceInterfaceMap;
import eo.framework.util.JBSbatDateUtil;

/**
 * 差分情報抽出結果編集共通部品です。
 * <BR>
 * @author 富士通
 */
public class JKKbatSaiInfChtCommon 
{
	/**
	 * バッチ共通パラメータ
	 */
	private JBSbatCommonItem commonItem = null;

	/**
	 * バッチ運用月月初
	 */
	private String StrSta;

	/**
	 * 抽出契約区分
	 */
	private String chshtKeiDiv;

	/**
	 * 処理月区分
	 */
	private String TrgtMon;

//	/**
//	 * 割引サービス契約内訳_MAX課金終了日
//	 */
//	private String maxUcwkChrgEndYmd;

	/**
	 * 割引サービス契約_課金終了基準日
	 */
	private String wriSvcBaseChrgEndYmd;

	/**
	 * 集約キーリスト(前レコード退避用)
	 */
	private ArrayList<String[]> inSykListBefore;

	/**
	 * 解約キーリスト(前レコード退避用)
	 */
	private ArrayList<String[]> inDslListBefore;

	/**
	 * 集約キーリスト(集約準備)
	 */
	private ArrayList<ArrayList<String[]>> plSykList;

	/**
	 * 解約系年月日リスト(集約準備)
	 */
	private ArrayList<ArrayList<String[]>> plDslList;

	/**
	 * 休止系年月日リスト(集約準備)
	 */
	private ArrayList<ArrayList<String[]>> plPseList;

	/**
	 * 集約キーリスト(編集準備)
	 */
	private ArrayList<ArrayList<String[]>> edSykList;

	/**
	 * 解約系年月日リスト(編集準備)
	 */
	private ArrayList<ArrayList<String[]>> edDslList;

	/**
	 * 休止系年月日リスト(編集準備)
	 */
	private ArrayList<ArrayList<String[]>> edPseList;

	/**
	 * 集約キー・解約系項目マージ結果リスト
	 */
	private ArrayList<ArrayList<String[]>> sykDslMrgList;

	/**
	 * 休止系項目マージ結果リスト(出力準備)
	 */
	private ArrayList<ArrayList<String[]>> mrgRsltList;

	/** 同一サービス情報蓄積フラグ
	 * 
	 */
	boolean smSvPlFlg = false;

	/**
	 * 回復年月日補填フラグ
	 */
	private boolean refKfkYmdFlg;

	/**
	 * 解約回復履歴終了フラグ
	 */
	private boolean dslTrmEndFlg;

	/**
	 * 休止期間履歴終了フラグ
	 */
	private boolean pseTrmEndFlg;

	/**
	 * プラン課金終了日(カレント)
	 */
	private String crntChrgEndYmd;

	// ++++++++++ 性能改善対応 追加開始 ++++++++++
	/**
	 * 料金インターフェイス共通処理部品
	 */
	private JBSbatKKPrcIfCommon prcIfCommon;
	// ++++++++++ 性能改善対応 追加終了 ++++++++++
	
//OM-2014-0003702 ADD STA
	/** 割引における当該契約／料金プランコード */
	static String TARGET_PPLAN = "TARGET_PPLAN";
	
	/** 料金グループ"10(ｅｏ光電話)" */
	private static final String PRC_GRP_CD_10 = "10";
	
	/** 料金プランコード"PC4301(モデム買取)" */
	private static final String PPLAN_CD_PC4301 = "PC4301";
//OM-2014-0003702 ADD STA
	
	/**
	 *コンストラクタ
	 */
	public JKKbatSaiInfChtCommon(JBSbatCommonItem commonItem) throws Exception
	{
		// 共通パラメタ
		this.commonItem = commonItem;
		// ++++++++++ 性能改善対応 削除開始 ++++++++++ //
//		// バッチ運用月月初
//		StrSta = "";
//		// 異動抽出契約区分
//		chshtKeiDiv = "";
//		// 集約キーリスト(集約準備)
//		plSykList = new ArrayList<ArrayList<String[]>>();
//		// 解約系項目リスト(集約準備)
//		plDslList = new ArrayList<ArrayList<String[]>>();
//		// 休止系項目リスト(集約準備)
//		plPseList = new ArrayList<ArrayList<String[]>>();
//		// 集約キーリスト(編集準備)
//		edSykList = new ArrayList<ArrayList<String[]>>();
//		// 解約系項目リスト(編集準備)
//		edDslList = new ArrayList<ArrayList<String[]>>();
//		// 休止系項目リスト(編集準備)
//		edPseList = new ArrayList<ArrayList<String[]>>();
//		// 集約キー・解約系項目マージ結果リスト
//		sykDslMrgList = new ArrayList<ArrayList<String[]>>();
//		// 休止系項目マージ結果リスト(出力準備)
//		mrgRsltList = new ArrayList<ArrayList<String[]>>();
//		// [同一サービス情報蓄積フラグ]
//		smSvPlFlg = false;
//		// 回復年月日補填フラグ
//		refKfkYmdFlg = false;
//		// 解約履歴終了フラグ
//		pseTrmEndFlg = false;
//		// 休止履歴終了フラグ
//		dslTrmEndFlg = false;
		// ++++++++++ 性能改善対応 削除終了 ++++++++++ //
		
		// ++++++++++ 性能改善対応 追加開始 ++++++++++ //
		// 料金インターフェイス共通処理部品
		prcIfCommon = new JBSbatKKPrcIfCommon(commonItem);
		// ++++++++++ 性能改善対応 追加終了 ++++++++++ //
	}
	
	/**	
	 * StrStaを設定します。
	 * @param　String
	 */
	public void setStrSta(String str)
	{
		StrSta = str;
	}

	/**
	 * StrStaを返却します。
	 * @return　String
	 */
	public String getStrSta()
	{
		return StrSta;
	}

	/**	
	 * chshtKeiDivを設定します。
	 * @param　String
	 */
	public void setChshtKeiDiv(String str)
	{
		chshtKeiDiv = str;
	}

	/**
	 * chshtKeiDivを返却します。
	 * @return　String
	 */
	public String getChshtKeiDiv()
	{
		return chshtKeiDiv;
	}

	/**	
	 * wriSvcBaseChrgEndYmdを設定します。
	 * @param　String
	 */
	public void setWriSvcBaseChrgEndYmd(String str)
	{
		wriSvcBaseChrgEndYmd = str;
	}

	/**
	 * wriSvcBaseChrgEndYmdを返却します。
	 * @return　String
	 */
	public String getWriSvcBaseChrgEndYmd()
	{
		return wriSvcBaseChrgEndYmd;
	}

	/**	
	 * TrgtMonを設定します。
	 * @param　String
	 */
	public void setTrgtMon(String str)
	{
		TrgtMon = str;
	}

	/**
	 * TrgtMonを返却します。
	 * @return　String
	 */
	public String getTrgtMon()
	{
		return TrgtMon;
	}

	
	// ++++++++++ 性能改善対応 追加開始 ++++++++++ //
	/**
	 * 各変数の初期化を行います。
	 */
	public void initialize() {
		// バッチ運用月月初
		StrSta = "";
		// 異動抽出契約区分
		chshtKeiDiv = "";
		// 処理月区分
		TrgtMon = "";
		// 集約キーリスト(前レコード退避用)
		inSykListBefore = new ArrayList<String[]>();
		// 解約キーリスト(前レコード退避用)
		inDslListBefore = new ArrayList<String[]>();
		// 集約キーリスト(集約準備)
		plSykList = new ArrayList<ArrayList<String[]>>();
		// 解約系項目リスト(集約準備)
		plDslList = new ArrayList<ArrayList<String[]>>();
		// 休止系項目リスト(集約準備)
		plPseList = new ArrayList<ArrayList<String[]>>();
		// 集約キーリスト(編集準備)
		edSykList = new ArrayList<ArrayList<String[]>>();
		// 解約系項目リスト(編集準備)
		edDslList = new ArrayList<ArrayList<String[]>>();
		// 休止系項目リスト(編集準備)
		edPseList = new ArrayList<ArrayList<String[]>>();
		// 集約キー・解約系項目マージ結果リスト
		sykDslMrgList = new ArrayList<ArrayList<String[]>>();
		// 休止系項目マージ結果リスト(出力準備)
		mrgRsltList = new ArrayList<ArrayList<String[]>>();
		// [同一サービス情報蓄積フラグ]
		smSvPlFlg = false;
		// 回復年月日補填フラグ
		refKfkYmdFlg = false;
		// 解約履歴終了フラグ
		pseTrmEndFlg = false;
		// 休止履歴終了フラグ
		dslTrmEndFlg = false;
		// 割引サービス_課金終了基準日
		wriSvcBaseChrgEndYmd = "";
		// プラン課金終了日(カレント)
		crntChrgEndYmd = "20991231";
	}
	// ++++++++++ 性能改善対応 追加終了 ++++++++++ //
	
	/**
	 * 指定された出力項目名の情報が格納されている配列をリストから取得します。
	 */
	public String[] getKmkStrct(ArrayList<String[]> list, String name)
	{
		String value[] = new String[4];
		
		for(int i=0; i < list.size(); i++)
		{
			if(list.get(i)[1].equals(name))
			{
				int len = list.get(i).length;
				value = new String[len];
				
				for(int j=0; j<len; j++)
				{
					value[j] = list.get(i)[j];
				}
				break;
			}
		}
		for(int i=0; i<value.length; i++)
		{
			if(null == value[i] || 0 == value[i].length())
			{
				value[i] = "";
			}
		}
		return value;
	}

	/**
	 * 指定された出力項目名の情報が格納されている要素をリストから取得します。
	 */
	public Integer getKmkIdx(ArrayList<String[]> list, String name)
	{
		int value = -1;
		
		for(int i=0; i < list.size(); i++)
		{
			if(list.get(i)[1].equals(name))
			{
				value = i;
				break;
			}
		}
		return value;
	}

	/**
	 * 指定された出力項目名の値をリストから取得します。
	 */
	public String getKmkVal(ArrayList<String[]> list, String name)
	{
		String value = "";
		
		for(int i=0; i < list.size(); i++)
		{
			if(list.get(i)[1].equals(name))
			{
				value = list.get(i)[2];
				break;
			}
		}
		if(null == value || 0 == value.length())
		{
			value = "";
		}
		return value;
	}

	/** 終了系年月日の初期設定値 */
	private String DEF_END_YMD = "20991231";

	/** 補填済レコード要素数 */
	private int FIX_REC_IDX_CNT = 5;

	/** レコード区分[回復] */
	private String REC_DIV_KAIFUKU = "0";

	/** レコード区分[解約] */
	private String REC_DIV_KAIYAKU = "1";
	
	//▼▼OM-2014-0002395▼▼
	/** 月初日[01] */
	private String STR_OF_MONTH = "01";
	//▲▲OM-2014-0002395▲▲

	/**
	 * 集約前情報を作成します。
	 * @param inSykList 集約キーリスト
	 * @param inDslList 解約系項目リスト
	 * @param inPseList 休止系項目リスト
	 * @param frstRecFlg 初回レコードフラグ
	 * @param outputBean 出力情報
	 * @throws Exception
	 */
	public void makeSykInf(ArrayList<String[]> inSykList, ArrayList<String[]> inDslList, ArrayList<String[]> inPseList, boolean frstRecFlg) throws Exception
	{
		//【蓄積情報の最新集計キーリスト】
		ArrayList<String[]> tmpSykList = new ArrayList<String[]>();
		//【蓄積情報の最新解約系項目リスト】
		ArrayList<String[]> tmpDslList = new ArrayList<String[]>();
		//【蓄積情報の最新休止系項目リスト】
		ArrayList<String[]> tmpPseList = new ArrayList<String[]>();
		
		// 蓄積情報[プラン課金開始年月日]リストを取得
		String[] tmpPlnChgStYmdStrct = new String[3];
		// 蓄積情報[プラン課金開始年月日]
		String tmpPlnChgStYmd = "";
		// 蓄積情報[解約年月日]
		String tmpDslYmd = "";
		//▼▼▼OM-2014-0000270▼▼▼
		// 月末日取得
		String strEnd = StrSta.substring(0,6) + JBSbatDateUtil.getEndOfMonth(StrSta.substring(0,6));
		//▲▲▲OM-2014-0000270▲▲▲
		
		// 集約キーリスト
		if(0 != plSykList.size())
		{
			// 蓄積情報を補填するため参照とする
			tmpSykList = plSykList.get(plSykList.size()-1);
			
			// 蓄積情報[プラン課金開始年月日]リストを取得
			tmpPlnChgStYmdStrct = getKmkStrct(tmpSykList, JBSbatKKIFM019.PLAN_STAYMD);
			// 蓄積情報[プラン課金開始年月日]を取得
			tmpPlnChgStYmd = getKmkVal(tmpSykList, JBSbatKKIFM019.PLAN_STAYMD);
		}
		// 解約系年月日リスト
		if(0 != plDslList.size())
		{
			// 蓄積情報を補填するため参照とする
			tmpDslList = plDslList.get(plDslList.size()-1);
			
			// 蓄積情報[解約年月日]を取得
			tmpDslYmd = getKmkVal(tmpDslList, JBSbatKKIFM019.SVC_DSL_YMD);
		}
		// 休止系年月日リスト(カレントが中断系の場合はあり得る)
		if(0 != plPseList.size())
		{
			// 蓄積情報を補填するため参照とする
			tmpPseList = plPseList.get(plPseList.size()-1);
		}
		
		// 入力情報[プラン課金開始年月日]リストを取得
		String[] inPlnChgStYmdStrct = getKmkStrct(inSykList, JBSbatKKIFM019.PLAN_STAYMD);
		// 入力情報[プラン課金終了年月日]リストを取得
		String[] inPlnChgEdYmdStrct = getKmkStrct(inSykList, JBSbatKKIFM019.PLAN_ENDYMD);
		// 入力情報[プラン課金開始年月日]を取得
		String inPlnChgStYmd = getKmkVal(inSykList, JBSbatKKIFM019.PLAN_STAYMD);
		// 入力情報[プラン課金終了年月日]を取得
		String inPlnChgEdYmd = getKmkVal(inSykList, JBSbatKKIFM019.PLAN_ENDYMD);
		// 入力情報[容量]を取得
		String inCapa = getKmkVal(inSykList, JBSbatKKIFM019.CAPA);
		// 入力情報[逓増項目区分]を取得
		String inTzKmk = getKmkVal(inSykList, JBSbatKKIFM019.TEIZO_KMK_DIV);
		
		// 入力情報[回復年月日]リストを取得
		String[] inKfkYmdstrct = getKmkStrct(inDslList, JBSbatKKIFM019.KAIHK_YMD);
		// 入力情報[回復年月日]を取得
		String inKfkYmd = getKmkVal(inDslList, JBSbatKKIFM019.KAIHK_YMD);
		// 入力情報[解約年月日]リストを取得
		String[] inDslYmdstrct = getKmkStrct(inDslList, JBSbatKKIFM019.SVC_DSL_YMD);
		// 入力情報[解約年月日]を取得
		String inDslYmd = getKmkVal(inDslList, JBSbatKKIFM019.SVC_DSL_YMD);
		
		// 入力情報[休止開始年月日]を取得
		String inPseStYmd = getKmkVal(inPseList, JBSbatKKIFM019.SVC_PAUSE_YMD);
		// 入力情報[休止料金適用開始年月日]を取得
		String inPsePrYmd = getKmkVal(inPseList, JBSbatKKIFM019.SVC_PAUSE_PRC_TSTAYMD);
		// 入力情報[休止解除年月日]を取得
		String inPseEdYmd = getKmkVal(inPseList, JBSbatKKIFM019.SVC_PAUSE_RLS_YMD);
		// 入力情報[休止中断コード]を取得
		String inPseStpCd = getKmkVal(inPseList, JBSbatKKIFM019.PAUSE_STP_CD);
		
		// 解約履歴オミットフラグ
		boolean dslOmitFlg = false;
		
		// ■集約キーリストの編集■
		
		// ◆[プラン課金開始年月日]編集◆
		// 入力情報[回復年月日]が設定されている、かつ入力情報[解約年月日]が未設定の場合(回復または通常レコード)
		if(!"".equals(inKfkYmd) && "".equals(inDslYmd))
		{
			// [プラン課金開始年月日]補填
			// ※[プラン課金開始年月日]＜[回復年月日]の場合には後続処理にて元に戻す
			String[] strStrct = new String[5];
			strStrct[0] = inPlnChgStYmdStrct[0];
			strStrct[1] = inPlnChgStYmdStrct[1];
			strStrct[2] = inKfkYmdstrct[2];
			strStrct[3] = inPlnChgStYmdStrct[2];
			strStrct[4] = REC_DIV_KAIFUKU;
			
			// 入力情報[回復年月日]にて、入力情報[プラン課金開始年月日]を補填
			if(0 <= getKmkIdx(inSykList, JBSbatKKIFM019.PLAN_STAYMD))
			{
				inSykList.set(getKmkIdx(inSykList, JBSbatKKIFM019.PLAN_STAYMD), strStrct);
			}
		}
		// 入力情報[回復年月日]が未設定、かつ入力情報[解約年月日]が設定されている場合(解約レコード)
		else if(!"".equals(inDslYmd) && "".equals(inKfkYmd))
		{
			// [プラン課金終了年月日]補填
			// ※後続処理にて元に戻す
			String[] strStrct = new String[5];
			strStrct[0] = inPlnChgEdYmdStrct[0];
			strStrct[1] = inPlnChgEdYmdStrct[1];
			strStrct[2] = inDslYmdstrct[2];
			strStrct[3] = inPlnChgEdYmdStrct[2];
			strStrct[4] = REC_DIV_KAIYAKU;
			
			// 入力情報[解約年月日]にて、入力情報[プラン課金終了年月日]を補填
			if(0 <= getKmkIdx(inSykList, JBSbatKKIFM019.PLAN_ENDYMD))
			{
				inSykList.set(getKmkIdx(inSykList, JBSbatKKIFM019.PLAN_ENDYMD), strStrct);
			}
			
			if(inPlnChgStYmd.compareTo(inPlnChgEdYmd) <= 0)
			{
				// 当該解約以前の過去回復の情報は後続レコードにて取得([回復年月日補填フラグ]ON)
				refKfkYmdFlg = true;
			}
			else
			{
				// プラン課金開始、終了が逆転している場合は([回復年月日補填フラグ]OFF)  OM-2013-0003303
				refKfkYmdFlg = false;
			}
		}
		else
		{
			// 処理なし
			// 入力情報[回復年月日]、入力情報[解約年月日]ともに未設定：解約履歴なし
			// 入力情報[回復年月日]、入力情報[解約年月日]ともに設定  ：インスタンス上あり得ない
		}
		
		// ◆蓄積情報反映◆
		// 初回レコード時は無条件に蓄積
		if(frstRecFlg)
		{
			// 入力情報を蓄積情報に退避
			plSykList.add(inSykList);
			
			// カレントが解約レコードの課金終了日(逓増料金項目の遡及解約考慮)
			if(!"".equals(inPlnChgEdYmd))
			{
				crntChrgEndYmd = inPlnChgEdYmd;
			}
		}
		else
		{
//			// 逓増料金項目の場合、カレントの課金終了日より未来の課金開始日の情報は除外(遡及解約時の集計考慮)
//			if("".equals(inTzKmk) || (!"".equals(inTzKmk) && crntChrgEndYmd.compareTo(inPlnChgStYmd) >= 0) )
//			{
			// カレントの課金終了日より未来の課金開始日の情報は除外(遡及解約時の集計考慮)
			if(crntChrgEndYmd.compareTo(inPlnChgStYmd) >= 0)
			{
				// 退避情報と入力情報に差分がある場合
				if(diffList(inSykListBefore, inSykList))
				{
					// 例外蓄積対象外１：[プラン課金終了年月日]が初期値(2099/12/31)のレコード(過去分の通常レコード)
					// 例外蓄積対象：[容量]が設定されている場合(追加容量変更時に年月日は非編集のインスタンス仕様)※ケーブルガイド誌は除外
					if(!DEF_END_YMD.equals(inPlnChgEdYmd)
							|| !"".equals(inCapa) && !JBSbatKKConst.TZKMK_CABLE_GUIDE_MSKM_CNT.equals(inTzKmk))
					{
						// 解約履歴情報制御
						if(!"".equals(getKmkVal(inDslList, JBSbatKKIFM019.SVC_DSL_YMD)) && !"".equals(getKmkVal(inDslListBefore, JBSbatKKIFM019.SVC_DSL_YMD)))
						{
							// 例外蓄積対象外２：解約キーリストについて、前入力情報との差分がないレコード
							// ※強制解約バッチ後の画面からの解約確定投入(eoモバイル(EM)の固有業務)
							if(!diffList(inDslListBefore, inDslList))
							{
								// 解約履歴オミットフラグON
								dslOmitFlg = true;
							}
							else
							{
								// 例外蓄積対象外３：解約キーリストについて、前入力情報との差分が[違約金発生コード]のみのレコード
								// ※解約中の[サービス情報訂正]にて違約金発生コードが編集されたパターン(カレントを適用する)
								if(getKmkVal(inDslList, JBSbatKKIFM019.SVC_DSL_YMD).equals(getKmkVal(inDslListBefore, JBSbatKKIFM019.SVC_DSL_YMD))
										&& !getKmkVal(inDslList, JBSbatKKIFM019.PNLTY_HASSEI_CD).equals(getKmkVal(inDslListBefore, JBSbatKKIFM019.PNLTY_HASSEI_CD)))
								{
									// 解約履歴オミットフラグON
									dslOmitFlg = true;
								}
							}
						}
						
						if(!dslOmitFlg)
						{
							// 例外蓄積対象外４：[プラン課金終了年月日]が割引サービス課金終了基準日と同一のレコードは蓄積対象外(期間型割引の過去分通常レコード)
							if(JBSbatKKConst.CHSHT_KEI_DIV_51.equals(chshtKeiDiv))
							{
								if(!wriSvcBaseChrgEndYmd.equals(inPlnChgEdYmd)
										|| !"".equals(getKmkVal(inDslList, JBSbatKKIFM019.SVC_DSL_YMD)))
								{
									// 入力情報を蓄積情報に退避
									plSykList.add(inSykList);
								}
							}
							else
							{
								// 入力情報を蓄積情報に退避
								plSykList.add(inSykList);
							}
						}
					}
					
					// ◆[プラン課金開始年月日]編集(再)◆
					// [回復年月日補填フラグ]がONの場合(請求契約以外)
					if(refKfkYmdFlg)
					{
						// [プラン課金開始年月日]補填
						// ※[プラン課金開始年月日]＜[回復年月日]の場合には後続処理にて元に戻す
						if( (!"".equals(inKfkYmd) && !"".equals(tmpPlnChgStYmd)))
						{
							String[] strStrct = new String[5];
							strStrct[0] = tmpPlnChgStYmdStrct[0];
							strStrct[1] = tmpPlnChgStYmdStrct[1];
							strStrct[2] = inKfkYmdstrct[2];
							strStrct[3] = inPlnChgStYmdStrct[2]; // 未来課金の場合には後続処理にて元に戻す
							strStrct[4] = REC_DIV_KAIFUKU;
							
							// 入力情報[回復年月日]にて、蓄積情報[プラン課金開始年月日]を補填
							tmpSykList.set(getKmkIdx(tmpSykList, JBSbatKKIFM019.PLAN_STAYMD), strStrct);
							
							// [回復年月日補填フラグ]をOFFに更新
							refKfkYmdFlg = false;
						}
					}
				}
			}
//OM-2015-0001646 ADD STA
			else if(DEF_END_YMD.equals(inPlnChgEdYmd))
			{
				// 退避情報と入力情報に差分がある場合
				if(diffList(inSykListBefore, inSykList))
				{
					// ◆[プラン課金開始年月日]編集(再)◆
					// [回復年月日補填フラグ]がONの場合(請求契約以外)
					if(refKfkYmdFlg)
					{
						// [プラン課金開始年月日]補填
						// ※[プラン課金開始年月日]＜[回復年月日]の場合には後続処理にて元に戻す
						if( (!"".equals(inKfkYmd) && !"".equals(tmpPlnChgStYmd)))
						{
							String[] strStrct = new String[5];
							strStrct[0] = tmpPlnChgStYmdStrct[0];
							strStrct[1] = tmpPlnChgStYmdStrct[1];
							strStrct[2] = inKfkYmdstrct[2];
							strStrct[3] = tmpSykList.get(getKmkIdx(tmpSykList, JBSbatKKIFM019.PLAN_STAYMD))[2]; // 未来課金の場合には後続処理にて元に戻す
							strStrct[4] = REC_DIV_KAIFUKU;
							
							// 入力情報[回復年月日]にて、蓄積情報[プラン課金開始年月日]を補填
							tmpSykList.set(getKmkIdx(tmpSykList, JBSbatKKIFM019.PLAN_STAYMD), strStrct);
							
							// [回復年月日補填フラグ]をOFFに更新
							refKfkYmdFlg = false;
						}
					}
				}
			}
//OM-2015-0001646 ADD END
		}
		// 次レコードとの比較用に入力情報を退避
		inSykListBefore = inSykList;
		
		// ■期間系項目リストの編集■
		
		// ◆蓄積判定◆
		
		// ●解約履歴●
		// 初回レコードは無条件に退避
		if(frstRecFlg)
		{
			// [解約年月日]未設定、[回復年月日]未設定(解約履歴なし)
			if("".equals(inKfkYmd) && "".equals(inDslYmd))
			{
				// [解約履歴終了フラグ]をON
				dslTrmEndFlg = true;
			}
			else
			{
				plDslList.add(inDslList);
				// [同一サービス情報蓄積フラグ]をON
				smSvPlFlg = true;
			}
		}
		else
		{
			// [解約履歴終了フラグ]がONの場合には処理不要
			if(!dslTrmEndFlg)
			{
				// 退避情報と入力情報に差分がある場合
				if(diffList(tmpDslList, inDslList))
				{
					// 退避情報と入力情報について解約年月日が一致する場合は処理対象外(カレント優先)
					// ※解約中の[サービス訂正](違約金発生有無の変更が可能)対応
					if(!tmpDslYmd.equals(inDslYmd))
					{
						// [解約年月日]設定、[回復年月日]未設定(解約レコード)
						if("".equals(inKfkYmd) && !"".equals(inDslYmd))
						{
							// 同一サービスについて既に蓄積済の情報が存在する場合
							if(smSvPlFlg)
							{
								for(int i=0; i<inDslList.size(); i++)
								{
									// [回復年月日]以外の項目を蓄積情報に補填(回復の対になる解約情報を補填)
									if(!JBSbatKKIFM019.KAIHK_YMD.equals(inDslList.get(i)[1]))
									{
										// [解約年月日]、[解約理由コード]、[違約金発生コード]
										tmpDslList.set(getKmkIdx(inDslList, inDslList.get(i)[1]), inDslList.get(getKmkIdx(inDslList, inDslList.get(i)[1])));
									}
								}
							}
							else
							{
								// 入力情報を蓄積
								plDslList.add(inDslList);
								// [同一サービス情報蓄積フラグ]をON
								smSvPlFlg = true;
							}
						}
						// [解約年月日]未設定、[回復年月日]設定(回復または通常レコード)
						else if(!"".equals(inKfkYmd) && "".equals(inDslYmd))
						{
// 過去解約の情報が必要となるケース(強制解約時の違約金は翌月請求(前月分の解約情報が必要))
//							// 月初以前の回復は不要
//							if(Integer.parseInt(inKfkYmd) >= Integer.parseInt(StrSta))
//							{
// ▼▼▼ OM-2013-0005313 ▼▼▼
//							// OM-2013-0005001
//							// 同一サービスについて既に蓄積済の情報が存在する場合
//								if(smSvPlFlg)
//								{
//									// 蓄積情報の回復年月日が未設定（カレントが解約）の場合
//									if("".equals(getKmkVal(tmpDslList, JBSbatKKIFM019.KAIHK_YMD)))
//									{
//										for(int i=0; i<inDslList.size(); i++)
//										{
//											// [回復年月日]を蓄積情報に補填(解約情報に過去の回復日を補填)
//											if(JBSbatKKIFM019.KAIHK_YMD.equals(inDslList.get(i)[1]))
//											{
//												// [回復年月日]
//												tmpDslList.set(getKmkIdx(inDslList, inDslList.get(i)[1]), inDslList.get(getKmkIdx(inDslList, inDslList.get(i)[1])));
//											}
//										}
//									}
//								}
// ▲▲▲ OM-2013-0005313 ▲▲▲
								// 入力情報を蓄積情報へ追加
								plDslList.add(inDslList);
								// [同一サービス情報蓄積フラグ]をON
								smSvPlFlg = true;
//							}
//							else
//							{
//								// [解約履歴終了フラグ]をON
//								dslTrmEndFlg = true;
//							}
						}
						// [解約年月日]未設定、[回復年月日]未設定の場合(解約履歴なし)
						else if("".equals(inKfkYmd) && "".equals(inDslYmd))
						{
							// [解約履歴終了フラグ]をON
							dslTrmEndFlg = true;
						}
						else
						{
							// [解約年月日]設定、[回復年月日]設定(インスタンス仕様として想定外)
						}
					}
				}
			}
		}
		// 次レコードとの比較用に入力情報を退避
		inDslListBefore = inDslList;
		
		// ●休止履歴●
		if(frstRecFlg)
		{
			// [休止開始年月日]未設定、[休止年月日]未設定(休止履歴なし)
			if("".equals(inPseStYmd) && "".equals(inPseEdYmd))
			{
				// [休止履歴終了フラグ]をON
				pseTrmEndFlg = true;
			}
			else
			{
				// 中断の場合には処理不要
				if(!JBSbatKKConst.PAUSE_STP_CD_STP.equals(inPseStpCd))
				{
					plPseList.add(inPseList);
				}
			}
		}
		else
		{
			// [休止履歴終了フラグ]がONの場合、または中断レコードの場合には処理不要
			if(!pseTrmEndFlg && !JBSbatKKConst.PAUSE_STP_CD_STP.equals(inPseStpCd))
			{
				// 退避情報と入力情報に差分がある場合
				if(diffList(tmpPseList, inPseList))
				{
					// [休止料金適用開始年月日]設定、[休止解除年月日]未設定(休止レコード)
					if(!"".equals(inPsePrYmd) && "".equals(inPseEdYmd))
					{
						if(0 == plPseList.size())
						{
							// 蓄積情報へ追加
							plPseList.add(inPseList);
						}
					}
					// [休止料金適用開始年月日]設定、[休止解除年月日]設定(休止解除または通常レコード)
					else if(!"".equals(inPsePrYmd) && !"".equals(inPseEdYmd))
					{
						//▼▼▼OM-2014-0000270▼▼▼
						// 月末以前の休止解除は不要
//						if(Integer.parseInt(inPseEdYmd) >= Integer.parseInt(StrSta))
						if(Integer.parseInt(inPseEdYmd) > Integer.parseInt(strEnd))
						//▲▲▲OM-2014-0000270▲▲▲
						{
							// 蓄積情報へ追加
							plPseList.add(inPseList);
						}
						else
						{
							// [解約履歴終了フラグ]をON
							pseTrmEndFlg = true;
						}
					}
					// [休止開始年月日]未設定、[休止解除年月日]未設定の場合(休止履歴なし)
					else if("".equals(inPseStYmd) && "".equals(inPseEdYmd))
					{
						// [休止履歴終了フラグ]をON
						pseTrmEndFlg = true;
					}
					else
					{
						// [休止料金適用開始年月日]未設定、[休止解除年月日]設定(休止のインスタンス仕様として想定外)
					}
				}
			}
		}
	}

	/**
	 * 情報集約を行い、編集前情報を作成します。
	 * @throws Exception
	 */
	public void makeEditInf()  throws Exception
	{
		// ■集約キーリスト
		
//		// 処理情報の割引サービス単価番号格納用
//		String pWriSvcTanNo = "";
//		// 蓄積情報の割引サービス単価番号格納用
//		String tWriSvcTanNo = "";
		
		// プラン課金開始年月日格納用
		String pChrgStYmd = "";
		// プラン課金終了年月日格納用
		String pChrgEdYmd = "";
		// プラン終了識別コード格納用
		String pEdSbtCd = "";
		// 容量格納用
		String inCapa = "";
		// 逓増項目区分格納用
		String inTzKmk = "";
		// 同日回復〜解約フラグ（容量系逓増料金項目用）格納用
		boolean sameKfkDslFlg = false;
		
		// 抽出契約区分の変わりに割引サービス契約番号格納用
		String inWribSvcKeiNo = "";
		// 処理情報１件格納用
		
		ArrayList<String[]> strctPlList = new ArrayList<String[]>();
		// 蓄積情報１件格納用
		ArrayList<String[]> strctEdList = new ArrayList<String[]>();
		// 蓄積情報作業用
		ArrayList<ArrayList<String[]>> strctWkList = new ArrayList<ArrayList<String[]>>();
		
		// 処理件数カウンタ
		int dataCnt = 0;
		// 年月日初期値データ制御用カウンタ
		int ymdCtrlCnt = 0;
		
		// ●同日[解約〜回復]情報の除外(情報補填含む)
		for(int i=0; i<plSykList.size(); i++)
		{
			// 比較対象となる情報が出揃うまで蓄積
			if(dataCnt == ymdCtrlCnt)
			{
				// 容量系データのうち、課金終了年月日が初期値(20991231)のデータは無条件出力かつ比較対象外
				if(!"".equals(getKmkVal(plSykList.get(i), JBSbatKKIFM019.CAPA))
						&& DEF_END_YMD.equals(getKmkVal(plSykList.get(i), JBSbatKKIFM019.PLAN_ENDYMD)))
				{
					strctWkList.add(plSykList.get(i));
					dataCnt = dataCnt +1;
					ymdCtrlCnt = ymdCtrlCnt +1;
				}
				else
				{
					strctWkList.add(plSykList.get(i));
					dataCnt = dataCnt +1;
					ymdCtrlCnt = 0;
				}
				continue;
			}
			
			// 比較対象データ取得(処理情報)
			strctPlList = plSykList.get(i);
			// 比較対象データ取得(蓄積情報)
			strctEdList = strctWkList.get(dataCnt -ymdCtrlCnt -1);
			
			// 容量系データのうち、課金終了年月日が初期値(20991231)のデータは無条件出力かつ比較対象外
			if(!"".equals(getKmkVal(strctPlList, JBSbatKKIFM019.CAPA))
					&& DEF_END_YMD.equals(getKmkVal(strctPlList, JBSbatKKIFM019.PLAN_ENDYMD)))
			{
				strctWkList.add(strctPlList);
				dataCnt = dataCnt +1;
				ymdCtrlCnt = ymdCtrlCnt +1;
			}
			else
			{
				ymdCtrlCnt = 0;
				
				// 処理情報から、プラン課金終了年月日(解約年月日)を取得
				pChrgEdYmd = getKmkVal(strctPlList, JBSbatKKIFM019.PLAN_ENDYMD);
				// 蓄積情報から、プラン課金開始年月日(回復年月日)を取得
				pChrgStYmd = getKmkVal(strctEdList, JBSbatKKIFM019.PLAN_STAYMD);
				// 処理情報から、プラン終了識別コードを取得
				pEdSbtCd = getKmkVal(strctPlList, JBSbatKKIFM019.PLAN_END_SBT_CD);
				
//				// 蓄積情報のプラン課金開始年月日(回復年月日)と、処理情報のプラン課金終了日(解約年月日)が一致、
//				// かつ処理情報のプラン終了種別コードが未設定の場合(同日解約〜回復)
//				if(!"".equals(pChrgStYmd) && !"".equals(pChrgEdYmd) && pChrgStYmd.equals(pChrgEdYmd) && "".equals(pEdSbtCd))
//				{
				// 蓄積情報のプラン課金開始年月日(回復年月日)と、処理情報のプラン課金終了日(解約年月日)が一致、
				// かつ処理情報のプラン終了種別コードが解約系の場合(同日解約〜回復)
				if(!"".equals(pChrgStYmd) && !"".equals(pChrgEdYmd) && pChrgStYmd.equals(pChrgEdYmd)
						&& (JBSbatKKConst.PLAN_END_SBT_CD_MSDDSL.equals(pEdSbtCd) || JBSbatKKConst.PLAN_END_SBT_CD_KYSDSL.equals(pEdSbtCd) || "".equals(pEdSbtCd)) )
				{
					// 処理情報のプラン課金開始年月日(回復年月日)にて、蓄積情報の同項目を修正(処理情報は出力不要)
					strctEdList.set(getKmkIdx(strctEdList, JBSbatKKIFM019.PLAN_STAYMD), getKmkStrct(strctPlList, JBSbatKKIFM019.PLAN_STAYMD));
				}
				else
				{
					// 処理情報を蓄積情報に追加
					strctWkList.add(strctPlList);
					dataCnt = dataCnt +1;
					ymdCtrlCnt = 0;
				}
			}
		}
		
		// ●同日[回復〜解約]情報の除外
		for(int i=0; i<strctWkList.size(); i++)
		{
			//容量系逓増料金項目について、同日回復〜解約の場合には解約に紐付く回復レコードは出力対象外
			if(sameKfkDslFlg)
			{
				sameKfkDslFlg = false;
				continue;
			}
			strctPlList = strctWkList.get(i);
			
			// 処理情報から、プラン課金終了年月日(解約年月日)を取得
			pChrgEdYmd = getKmkVal(strctPlList, JBSbatKKIFM019.PLAN_ENDYMD);
			// 処理情報から、プラン課金開始年月日(回復年月日)を取得
			pChrgStYmd = getKmkVal(strctPlList, JBSbatKKIFM019.PLAN_STAYMD);
			// 処理情報から、プラン終了識別コードを取得
			pEdSbtCd = getKmkVal(strctPlList, JBSbatKKIFM019.PLAN_END_SBT_CD);
			// 処理情報から、容量を取得
			inCapa = getKmkVal(strctPlList, JBSbatKKIFM019.CAPA);
			// 処理情報から、逓増項目区分を取得
			inTzKmk = getKmkVal(strctPlList, JBSbatKKIFM019.TEIZO_KMK_DIV);
			
			// OM-2031-0004050
			// 処理情報から、抽出契約区分の変わりに割引サービス契約番号を取得
			inWribSvcKeiNo = getKmkVal(strctPlList, JBSbatKKIFM019.WRIB_SVC_KEI_NO);
			inWribSvcKeiNo=(null==inWribSvcKeiNo)?"":inWribSvcKeiNo;
			
			if(FIX_REC_IDX_CNT != getKmkStrct(strctPlList, JBSbatKKIFM019.PLAN_ENDYMD).length 
				&& !"".equals(inWribSvcKeiNo)) 
			{
				//課金終了済みの要素が補填済みでない場合は、そのまま追加
				// 処理情報を蓄積情報に追加
				edSykList.add(strctPlList);
			}
			else
			{
				// 課金開始済みの要素が補填済みの場合
				if(FIX_REC_IDX_CNT == getKmkStrct(strctPlList, JBSbatKKIFM019.PLAN_STAYMD).length)
				{
//					// 処理情報のプラン課金開始年月日(回復年月日)とプラン課金終了日(解約年月日)が一致、
//					// かつプラン終了種別コードが未設定の場合(同日回復〜解約)
//					if(!"".equals(pChrgStYmd) && !"".equals(pChrgEdYmd) && pChrgStYmd.equals(pChrgEdYmd) && "".equals(pEdSbtCd))
//					{
					// 処理情報のプラン課金開始年月日(回復年月日)とプラン課金終了日(解約年月日)が一致、
					// かつプラン終了種別コードが解約系の場合(同日回復〜解約)
					if(!"".equals(pChrgStYmd) && !"".equals(pChrgEdYmd) && pChrgStYmd.equals(pChrgEdYmd)
						&& (JBSbatKKConst.PLAN_END_SBT_CD_MSDDSL.equals(pEdSbtCd) || JBSbatKKConst.PLAN_END_SBT_CD_KYSDSL.equals(pEdSbtCd) || "".equals(pEdSbtCd)) )
					{
						// 出力不要
						// ※容量系逓増料金項目（ガイド誌以外）についてのみ、後続の回復レコードを処理対象外とする必要がある(OM-2013-0003371)
						if(!"".equals(inCapa) && !JBSbatKKConst.TZKMK_CABLE_GUIDE_MSKM_CNT.equals(inTzKmk))
						{
							//同日回復〜解約フラグ（容量系逓増料金項目用）格納用
							sameKfkDslFlg = true;
						}
					}
					else
					{
						// 処理情報を蓄積情報に追加
						edSykList.add(strctPlList);
					}
				}
				else
				{
					// 処理情報を蓄積情報に追加
					edSykList.add(strctPlList);
				}
			}
		}
		
		// ■解約系項目リスト
		// 同日解約回復情報除外
		
		// 処理情報の解約年月日格納用
		String plDslYmd = "";
		// 処理情報の回復年月日格納用
		String plKfkYmd = "";
		// 処理情報の料金プランコード格納用
		String plPplanCd = "";
		// 蓄積情報の解約年月日格納用
		String edDslYmd = "";
		// 蓄積情報の料金プランコード格納用
		String edPplanCd = "";
		
		strctWkList = new ArrayList<ArrayList<String[]>>();
		
		// ●同日[回復〜解約]情報の除外(情報補填含む)
		dataCnt = 0;
		if(0 != plDslList.size())
		{
			strctWkList.add(plDslList.get(0));
			dataCnt = dataCnt +1;
		}
		
		for(int i=1; i<plDslList.size(); i++)
		{
			strctPlList = plDslList.get(i);
			strctEdList = strctWkList.get(dataCnt -1);
			
			plPplanCd = getKmkVal(strctPlList, JBSbatKKIFM019.PPLAN_CD);
			edPplanCd = getKmkVal(strctEdList, JBSbatKKIFM019.PPLAN_CD);
			
			// 料金プランコードが異なる場合には単純蓄積とする
			if(plPplanCd.equals(edPplanCd))
			{
				// 処理情報から、回復年月日を取得
				plKfkYmd = getKmkVal(strctPlList, JBSbatKKIFM019.KAIHK_YMD);
				
				// 蓄積情報から、解約年月日を取得
				edDslYmd = getKmkVal(strctEdList, JBSbatKKIFM019.SVC_DSL_YMD);
				
				// 処理情報の回復年月日と蓄積情報の解約年月日が一致する場合(同日[回復〜解約])
				if(!"".equals(plKfkYmd) && !"".equals(edDslYmd) && plKfkYmd.equals(edDslYmd))
				{
					// 蓄積情報の解約年月日を、処理情報の解約年月日にて更新(処理情報は出力不要)
					strctEdList.set(getKmkIdx(strctEdList, JBSbatKKIFM019.SVC_DSL_YMD), getKmkStrct(strctPlList, JBSbatKKIFM019.SVC_DSL_YMD));
				}
				else
				{
					// 集約前情報を編集前情報に追加
					strctWkList.add(strctPlList);
					dataCnt = dataCnt +1;
				}
			}
			else
			{
				// 集約前情報を編集前情報に追加
				strctWkList.add(strctPlList);
				dataCnt = dataCnt +1;
			}
		}
		
		// ●同日[解約〜回復]情報の除外(情報補填含む)
		for(int i=0; i<strctWkList.size(); i++)
		{
			strctPlList = strctWkList.get(i);
			
			// 処理情報から、解約年月日と回復年月日を取得
			plDslYmd = getKmkVal(strctPlList, JBSbatKKIFM019.SVC_DSL_YMD);
			plKfkYmd = getKmkVal(strctPlList, JBSbatKKIFM019.KAIHK_YMD);
			
			// 解約年月日と回復年月日が一致する場合(同日[解約〜回復])
			if(!"".equals(plDslYmd) && !"".equals(plKfkYmd) && plDslYmd.equals(plKfkYmd))
			{
//				// 蓄積情報から、回復年月日を取得
//				edKfkYmd = getKmkVal(strctEdList, JBSbatKKIFM019.SVC_DSL_YMD);
//				
//				// 蓄積情報の回復年月日と処理情報の解約年月日が不一致の場合
//				// ※�@解約⇒�A同日回復解約⇒�B回復のケース時に�@と�Bを紐付ける処理
//				if(!"".equals(edKfkYmd) && !"".equals(plDslYmd) && !edKfkYmd.equals(plDslYmd))
//				{
//					// 蓄積情報の解約年月日を、処理情報の解約年月日にて更新(処理情報は出力不要)
//					strctEdList.set(getKmkIdx(strctEdList, JBSbatKKIFM019.SVC_DSL_YMD), getKmkStrct(strctPlList, JBSbatKKIFM019.SVC_DSL_YMD));
//				}
			}
			else
			{
				// 処理情報を蓄積情報に追加
				edDslList.add(strctPlList);
			}
		}
		
		// ▼▼▼ OM-2013-0005298 ▼▼▼
		// 蓄積情報に回復履歴があり、かつ１件目の回復年月日が未設定(カレントが解約)の場合
		// (makeSykInf()で連続した解約を集約しているため、回復年月日未設定はカレント解約のみ)
		if(edDslList.size() > 1 && "".equals(getKmkVal(edDslList.get(0), JBSbatKKIFM019.KAIHK_YMD)))
		{
			// 蓄積情報の２件目の回復日にて更新
			edDslList.get(0).set(getKmkIdx(edDslList.get(0), JBSbatKKIFM019.KAIHK_YMD), getKmkStrct(edDslList.get(1), JBSbatKKIFM019.KAIHK_YMD));
		}
		// ▲▲▲ OM-2013-0005298 ▲▲▲
		
		// ■休止系項目リスト
		for(int i=0; i<plPseList.size(); i++)
		{
			// 集約前情報を編集前情報に追加
			edPseList.add(plPseList.get(i));
		}
	}

	/**
	 * 取得対象項目ArrayListに基づき、DBの抽出結果から値を設定します。
	 * @param lastRecFlg 最終レコードフラグ
	 * @param outputBean 出力情報
	 * @throws Exception
	 */
	public void editSaiInf(JBSbatOutputItem outputBean) throws Exception
	{
		// プラン課金開始年月日格納用
		String pChrgStYmd = "";
		// プラン課金終了年月日格納用
		String pChrgEdYmd = "";
		// 解約年月日格納用
		String dslYmd = "";
		// 回復年月日格納用
		String kfkYmd = "";
		// 休止料金適用開始年月日格納用
		String psPrcYmd = "";
		// 休止解除年月日格納用
		String psDslYmd = "";
		
		// 集約キーリストの１履歴分格納用
		ArrayList<String[]> strctEdSykList = new ArrayList<String[]>();
		// 解約系項目リストの１履歴分格納用
		ArrayList<String[]> strctEdDslList = new ArrayList<String[]>();
		// 休止系項目リストの１履歴分格納用
		ArrayList<String[]> strctEdPseList = new ArrayList<String[]>();
		// 集約キー解約系マージ結果リスト１履歴分格納用
		ArrayList<String[]> strctMrgList = new ArrayList<String[]>();
		
		// マージ用作業領域１
		ArrayList<String[]> strctWrkList_1 = new ArrayList<String[]>();
		// マージ用作業領域２
		ArrayList<String[]> strctWrkList_2 = new ArrayList<String[]>();
		
		// 過去回復付与抑止フラグ
		boolean nkfkFlg = false;
		
		//▼▼▼OM-2014-0000270▼▼▼
		// 月末日取得
		String strEnd = StrSta.substring(0,6) + JBSbatDateUtil.getEndOfMonth(StrSta.substring(0,6));
		//▲▲▲OM-2014-0000270▲▲▲
		
		// ■集計キーリストに解約系項目リストをマージ■
		for(int i=0; i<edSykList.size(); i++)
		{
			strctEdSykList = edSykList.get(i);
			
			// 集計キーリストから[プラン課金開始年月日]と[プラン課金終了年月日]を取得
			pChrgStYmd = getKmkVal(strctEdSykList, JBSbatKKIFM019.PLAN_STAYMD);
			pChrgEdYmd = getKmkVal(strctEdSykList, JBSbatKKIFM019.PLAN_ENDYMD);
			
			// プラン課金終了年月日が補填済み(解約レコード)の場合、過去の回復情報付与は不要
			if(FIX_REC_IDX_CNT == getKmkStrct(strctEdSykList, JBSbatKKIFM019.PLAN_ENDYMD).length)
			{
				nkfkFlg = true;
			}
			
			// 合致確認フラグ
			boolean mFlg = false;
			
			for(int j=0; j<edDslList.size(); j++)
			{
				strctEdDslList = edDslList.get(j);
				
				// 解約項目キーリストから[解約年月日]と[回復年月日]を取得
				dslYmd = getKmkVal(strctEdDslList, JBSbatKKIFM019.SVC_DSL_YMD);
				kfkYmd = getKmkVal(strctEdDslList, JBSbatKKIFM019.KAIHK_YMD);
				
				// [プラン課金終了年月日]と[解約年月日]が合致する場合
				if( (!"".equals(pChrgEdYmd) && !"".equals(dslYmd)) && (pChrgEdYmd.equals(dslYmd)) )
				{
					// 集約キーリストと解約項目リストを全件反映
					for(int k = 0; k < strctEdSykList.size(); k++ )
					{
						// 回復・解約レコードはプラン課金開始年月日・終了年月日補填時に退避した補填前の年月日情報の要素が存在
						if(FIX_REC_IDX_CNT != strctEdSykList.get(k).length)
						{
							strctWrkList_1.add(strctEdSykList.get(k));
						}
						// 補填前の値に戻す
						else
						{
							String strct[] = new String[4];
							strct[0] = strctEdSykList.get(k)[0];
							strct[1] = strctEdSykList.get(k)[1];
							
							// 補填後年月日(回復・解約年月日相当)
							int idoDate = Integer.parseInt(strctEdSykList.get(k)[2]);
							// 補填前年月日(プラン課金開始・終了)
							int pcgDate = Integer.parseInt(strctEdSykList.get(k)[3]);
							// レコード区分(0:回復/1:解約)
							String recDiv = strctEdSykList.get(k)[4];
							
							// 回復レコードについては、プラン課金開始日が回復年月日よりも未来の場合のみ補填前の年月日に戻す
							if(REC_DIV_KAIFUKU.equals(recDiv) && pcgDate <= idoDate)
							{
								strct[2] = strctEdSykList.get(k)[2];
							}
							else
							{
								strct[2] = String.valueOf(pcgDate);
							}
							
							strctWrkList_1.add(strct);
						}
					}
					for(int m = 0; m < strctEdDslList.size(); m++ )
					{
						strctWrkList_1.add(strctEdDslList.get(m));
					}
					
					sykDslMrgList.add(strctWrkList_1);
					
					strctWrkList_1 = new ArrayList<String[]>();
					
					mFlg = true;
				}
				
				// [プラン課金開始年月日]と[回復年月日]が合致する場合(回復履歴有の解約レコードの場合処理不要)
				if(!nkfkFlg && (!"".equals(pChrgStYmd) && !"".equals(kfkYmd)) && (pChrgStYmd.equals(kfkYmd)) )
				{
					// 集約キーリスト全件と、解約項目リストから回復年月日のみを反映
					for(int k = 0; k < strctEdSykList.size(); k++ )
					{
						// 回復・解約レコードはプラン課金開始年月日・終了年月日補填時に退避した補填前の年月日情報の要素が存在
						if(FIX_REC_IDX_CNT != strctEdSykList.get(k).length)
						{
							strctWrkList_1.add(strctEdSykList.get(k));
						}
						// 補填前の値に戻す
						else
						{
							String strct[] = new String[3];
							strct[0] = strctEdSykList.get(k)[0];
							strct[1] = strctEdSykList.get(k)[1];
							
							// 補填後年月日(回復・解約年月日相当)
							int idoDate = Integer.parseInt(strctEdSykList.get(k)[2]);
							// 補填前年月日(プラン課金開始・終了)
							int pcgDate = Integer.parseInt(strctEdSykList.get(k)[3]);
							// レコード区分(0:回復/1:解約)
							String recDiv = strctEdSykList.get(k)[4];
							
							// 回復レコードについては、プラン課金開始日が回復年月日よりも未来の場合のみ補填前の年月日に戻す
							if(REC_DIV_KAIFUKU.equals(recDiv) && pcgDate <= idoDate)
							{
								strct[2] = strctEdSykList.get(k)[2];
							}
							else
							{
								strct[2] = String.valueOf(pcgDate);
							}
							
							strctWrkList_1.add(strct);
						}
					}
					
					strctWrkList_1.add(strctEdDslList.get(getKmkIdx(strctEdDslList, JBSbatKKIFM019.KAIHK_YMD)));
					
					// ▼▼▼ OM-2013-0005298 ▼▼▼
					// 課金開始日または課金終了日を補填前の値に補正済みの場合は、集約キー・解約系項目マージ結果リストへ蓄積しない
					if (!mFlg)
					{
						sykDslMrgList.add(strctWrkList_1);
					}
					// ▲▲▲ OM-2013-0005298 ▲▲▲
					strctWrkList_1 = new ArrayList<String[]>();
					
					mFlg = true;
				}
			}
			// 合致しなかった場合には集約キーのみ全件反映
			if(!mFlg)
			{
				for(int k = 0; k < strctEdSykList.size(); k++ )
				{
					// 回復・解約レコードはプラン課金開始年月日・終了年月日補填時に退避した補填前の年月日情報の要素が存在
					if(FIX_REC_IDX_CNT != strctEdSykList.get(k).length)
					{
						strctWrkList_1.add(strctEdSykList.get(k));
					}
					// 補填前の値に戻す
					else
					{
						String strct[] = new String[3];
						strct[0] = strctEdSykList.get(k)[0];
						strct[1] = strctEdSykList.get(k)[1];
						
						// 補填後年月日(回復・解約年月日相当)
						int idoDate = Integer.parseInt(strctEdSykList.get(k)[2]);
						// 補填前年月日(プラン課金開始・終了)
						int pcgDate = Integer.parseInt(strctEdSykList.get(k)[3]);
						// レコード区分(0:回復/1:解約)
						String recDiv = strctEdSykList.get(k)[4];
						
						// 回復レコードについては、プラン課金開始日が回復年月日よりも未来の場合のみ補填前の年月日に戻す
						if(REC_DIV_KAIFUKU.equals(recDiv) && pcgDate <= idoDate)
						{
							strct[2] = strctEdSykList.get(k)[2];
						}
						else
						{
							strct[2] = String.valueOf(pcgDate);
						}
						
						strctWrkList_1.add(strct);
					}
				}
				
				sykDslMrgList.add(strctWrkList_1);
				
				strctWrkList_1 = new ArrayList<String[]>();
			}
			nkfkFlg = false;
		}
		
		// ■休止系年月日をマージ
		for(int i=0; i<sykDslMrgList.size(); i++)
		{
			// 集計キーリストから[プラン課金開始年月日]と[プラン課金終了年月日]を取得
			strctMrgList = sykDslMrgList.get(i);
			pChrgStYmd = getKmkVal(strctMrgList, JBSbatKKIFM019.PLAN_STAYMD);
			pChrgEdYmd = getKmkVal(strctMrgList, JBSbatKKIFM019.PLAN_ENDYMD);
			
			// 合致確認フラグ
			boolean mFlg = false;
			
			for(int j=0; j<edPseList.size(); j++)
			{
				// 休止項目キーリストから[休止料金適用開始年月日]と[休止解除年月日]を取得
				strctEdPseList = edPseList.get(j);
				psPrcYmd = getKmkVal(strctEdPseList, JBSbatKKIFM019.SVC_PAUSE_PRC_TSTAYMD);
				psDslYmd = getKmkVal(strctEdPseList, JBSbatKKIFM019.SVC_PAUSE_RLS_YMD);
				
				// [休止解除年月日]が未設定(カレントが休止中)の場合「2099/12/31」で補填
				if("".equals(psDslYmd))
				{
					psDslYmd = DEF_END_YMD;
				}
				
				//▼▼▼OM-2014-0000270▼▼▼
				// [プラン課金終了年月日]≧[休止料金適用開始年月日]、かつ[プラン課金開始年月日]≦[休止解除年月日]、かつ[月末]≧[休止料金適用開始年月日]、かつ[翌月月初]≦[休止解除年月日]を満たす場合
//				if( ( (!"".equals(pChrgEdYmd) && !"".equals(psPrcYmd)) && (Integer.parseInt(pChrgEdYmd) >= Integer.parseInt(psPrcYmd)) )
//						&& ( (!"".equals(pChrgStYmd) && !"".equals(psDslYmd)) && (Integer.parseInt(pChrgStYmd) <= Integer.parseInt(psDslYmd)) ) )
				if( ( (!"".equals(pChrgEdYmd) && !"".equals(psPrcYmd)) && (Integer.parseInt(pChrgEdYmd) >= Integer.parseInt(psPrcYmd)) )
						&& ( (!"".equals(pChrgStYmd) && !"".equals(psDslYmd)) && (Integer.parseInt(pChrgStYmd) <= Integer.parseInt(psDslYmd)) ) 
						&& ( (!"".equals(strEnd) && !"".equals(psPrcYmd)) && (Integer.parseInt(strEnd) >= Integer.parseInt(psPrcYmd)) )
						&& ( (!"".equals(strEnd) && !"".equals(psDslYmd)) && (Integer.parseInt(strEnd) < Integer.parseInt(psDslYmd)) ) )
				//▲▲▲OM-2014-0000270▲▲▲
				{
					// 集約キーリストと休止項目リストを全件反映
					for(int k = 0; k < strctMrgList.size(); k++ )
					{
						strctWrkList_2.add(strctMrgList.get(k));
					}
					for(int m = 0; m < strctEdPseList.size(); m++ )
					{
						strctWrkList_2.add(strctEdPseList.get(m));
					}
					mrgRsltList.add(strctWrkList_2);
					
					strctWrkList_2 = new ArrayList<String[]>();
					
					mFlg = true;
				}
			}
			// 合致しなかった場合には集約キーのみ全件反映
			if(!mFlg)
			{
				for(int k = 0; k < strctMrgList.size(); k++ )
				{
					strctWrkList_2.add(strctMrgList.get(k));
				}
				mrgRsltList.add(strctWrkList_2);
				
				strctWrkList_2 = new ArrayList<String[]>();
			}
		}
		
		// マージ結果を出力
		setOutMap(outputBean);
	}

	// ++++++++++ 性能改善対応 追加開始 ++++++++++ //
	/**
	 * 料金インタフェース共通部品のクローズを行います。
	 */
	public void close() throws Exception
	{
		prcIfCommon.close();
	}
	// ++++++++++ 性能改善対応 追加終了 ++++++++++ //
	
	/**
	 * 出力情報退避ArrayListの情報を出力情報Mapに展開します。
	 * @param outputBean
	 * @throws Exception
	 */
	private void setOutMap(JBSbatOutputItem outputBean) throws Exception
	{
		// 出力情報格納領域
		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();
		
		// 処理月区分(前月)
		String trgtMonZen = "1";
		
		// マージ結果１件格納領域
		ArrayList<String[]> strctMrgList = new ArrayList<String[]>();
		
		for(int i = 0; i < mrgRsltList.size(); i++)
		{
			// マージ結果から１件取得
			strctMrgList = mrgRsltList.get(i);
			
			// マージ結果全件について処理
			for(int j = 0; j < strctMrgList.size(); j++)
			{
				// 出力情報設定
				outMap.setString(strctMrgList.get(j)[1], strctMrgList.get(j)[2]);
			}
			
			// 抽出契約区分
			outMap.setString(JBSbatKKIFM019.CHSHT_KEI_DIV, chshtKeiDiv);
			
			// 契約数
			outMap.setBigDecimal(JBSbatKKIFM019.KEI_CNT, 1);
			
			// ++++++++++ v5.00.00 追加開始 ++++++++++ //
			// 請求オプション取得
			String chshtSeiOpSvc = outMap.getString(JBSbatKKIFM019.SEIOPSVC_KEI_NO);
			chshtSeiOpSvc=(null==chshtSeiOpSvc)?"":chshtSeiOpSvc;

			if (chshtSeiOpSvc.equals("")) 
			{
			// ++++++++++ v5.00.00追加終了 ++++++++++ //

				// 基本契約情報付与(請求オプションサービス契約、請求契約は設定不要)
				// ※サービス契約については、前月分IFのみ整理番号を最新化する必要あり
				if( (!JBSbatKKConst.CHSHT_KEI_DIV_10.equals(chshtKeiDiv)
						&& !JBSbatKKConst.CHSHT_KEI_DIV_40.equals(chshtKeiDiv)
						&& !JBSbatKKConst.CHSHT_KEI_DIV_90.equals(chshtKeiDiv))
						|| (JBSbatKKConst.CHSHT_KEI_DIV_10.equals(chshtKeiDiv) && trgtMonZen.equals(TrgtMon)) )
				{
					// ++++++++++ 性能改善対応 削除開始 ++++++++++ //
//					// 共通クラスインスタンス生成
//					JBSbatKKPrcIfCommon prcIfCommon = new JBSbatKKPrcIfCommon(commonItem);
					// ++++++++++ 性能改善対応 削除終了 ++++++++++ //
					
					// 適用対象となる基本契約の情報を取得(プラン変更時対応)
					JBSbatCommonDBInterface svcKeiInf = prcIfCommon.getSvcKeiInf(outMap.getString(JBSbatKKIFM019.SVC_KEI_NO));
					
					// 基本契約の契約番号が取得できなかった場合
					if(svcKeiInf == null)
					{
						// 出力領域にnullを設定し返却
						outMap = null;
					}
					else
					{
						// 基本契約(前月分IF)については、整理番号の最新化のみ行う(ADSLコース変更(変更前後共に日割計算))
						if(JBSbatKKConst.CHSHT_KEI_DIV_10.equals(chshtKeiDiv))
						{
							outMap.setString(JBSbatKKIFM019.SEIRI_NO, svcKeiInf.getString(JBSbatKK_T_SVC_KEI.SEIRI_NO)); 		// 整理番号
						}
						else
						{
							outMap.setString(JBSbatKKIFM019.SVC_CD, svcKeiInf.getString(JBSbatKK_T_SVC_KEI.SVC_CD));			// サービスコード
							outMap.setString(JBSbatKKIFM019.PRC_GRP_CD, svcKeiInf.getString(JBSbatKK_T_SVC_KEI.PRC_GRP_CD));	// 料金グループコード
							outMap.setString(JBSbatKKIFM019.PCRS_CD, svcKeiInf.getString(JBSbatKK_T_SVC_KEI.PCRS_CD));			// 料金コースコード
							outMap.setString(JBSbatKKIFM019.SEIRI_NO, svcKeiInf.getString(JBSbatKK_T_SVC_KEI.SEIRI_NO)); 		// 整理番号
						}
						
						//OM-2013-0003456（機器提供サービス契約に提供方式契約番号を付与）
						//抽出契約区分が機器("30")
						if(JBSbatKKConst.CHSHT_KEI_DIV_30.equals(chshtKeiDiv))
						{
//OM-2014-0003702 MOD STA
//							outMap.setString(JBSbatKKIFM019.TK_HOSHIKI_KEI_NO, svcKeiInf.getString(JBSbatKK_T_SVC_KEI.TK_HOSHIKI_KEI_NO)); 		// 提供方式契約番号
							if(svcKeiInf.getString(JBSbatKK_T_SVC_KEI.PRC_GRP_CD) != null 
								&& outMap.getString(JBSbatKKIFM019.PPLAN_CD) != null 
								&& svcKeiInf.getString(JBSbatKK_T_SVC_KEI.PRC_GRP_CD).equals(PRC_GRP_CD_10) 
								&& outMap.getString(JBSbatKKIFM019.PPLAN_CD).equals(PPLAN_CD_PC4301))
							{
								//基本契約の料金グループコード=10(電話)かつ機器提供サービス契約の料金プランコード=PC4301(VDSL買取)の場合、基本契約のカレントレコードから提供方式契約番号を取得
								outMap.setString(JBSbatKKIFM019.TK_HOSHIKI_KEI_NO, prcIfCommon.getTkHoshikiKeiNo(outMap.getString(JBSbatKKIFM019.SVC_KEI_NO))); 		// 提供方式契約番号
							}
							else
							{
								outMap.setString(JBSbatKKIFM019.TK_HOSHIKI_KEI_NO, svcKeiInf.getString(JBSbatKK_T_SVC_KEI.TK_HOSHIKI_KEI_NO)); 		// 提供方式契約番号
							}
//OM-2014-0003702 MOD END
						}
						
						//抽出契約区分が割引("51")
						//かつ、基本契約が解約状態(レコードのサービス解約年月日が設定されている)の場合
						if(JBSbatKKConst.CHSHT_KEI_DIV_51.equals(chshtKeiDiv)){
							
//OM-2014-0003702 MOD STA
//							outMap.setString(JBSbatKKIFM019.TK_HOSHIKI_KEI_NO, svcKeiInf.getString(JBSbatKK_T_SVC_KEI.TK_HOSHIKI_KEI_NO)); 		// 提供方式契約番号
							if(svcKeiInf.getString(JBSbatKK_T_SVC_KEI.PRC_GRP_CD) != null 
								&& outMap.getString(TARGET_PPLAN) != null 
								&& svcKeiInf.getString(JBSbatKK_T_SVC_KEI.PRC_GRP_CD).equals(PRC_GRP_CD_10) 
								&& outMap.getString(TARGET_PPLAN).equals(PPLAN_CD_PC4301))
							{
								//基本契約の料金グループコード=10(電話)かつ機器提供サービス契約の料金プランコード=PC4301(VDSL買取)の場合、基本契約のカレントレコードから提供方式契約番号を取得
								outMap.setString(JBSbatKKIFM019.TK_HOSHIKI_KEI_NO, prcIfCommon.getTkHoshikiKeiNo(outMap.getString(JBSbatKKIFM019.SVC_KEI_NO))); 		// 提供方式契約番号
							}
							else
							{
								outMap.setString(JBSbatKKIFM019.TK_HOSHIKI_KEI_NO, svcKeiInf.getString(JBSbatKK_T_SVC_KEI.TK_HOSHIKI_KEI_NO)); 		// 提供方式契約番号
							}
//OM-2014-0003702 MOD END
							outMap.setString(JBSbatKKIFM019.PPLAN_CD,  svcKeiInf.getString(JBSbatKK_T_SVC_KEI.PPLAN_CD)); 		// 料金プランコード

							//基本契約 サービス解約年月日
							String svcDslYmd=svcKeiInf.getString(JBSbatKK_T_SVC_KEI.SVC_DSL_YMD);
							svcDslYmd=(null==svcDslYmd)?"":svcDslYmd;
							//基本契約 サービス課金終了年月日
							String svcChrgEndymd=svcKeiInf.getString(JBSbatKK_T_SVC_KEI.SVC_CHRG_ENDYMD);
							svcChrgEndymd=(null==svcChrgEndymd)?"":svcChrgEndymd;
							//割引 サービス課金終了年月日
							String wribSvcChrgEndymd=outMap.getString(JBSbatKKIFM019.SVC_CHRG_ENDYMD);
							wribSvcChrgEndymd=(null==wribSvcChrgEndymd)?"":wribSvcChrgEndymd;
							//基本契約 サービス解約理由コード
							String svcSvcDlreCd=svcKeiInf.getString(JBSbatKK_T_SVC_KEI.SVC_DLRE_CD);
							svcSvcDlreCd=(null==svcSvcDlreCd)?"":svcSvcDlreCd;
							//OM-2013-0003689
							//基本契約 違約金発生コード
							String pnltyHasseicd=svcKeiInf.getString(JBSbatKK_T_SVC_KEI.PNLTY_HASSEI_CD);
							pnltyHasseicd=(null==pnltyHasseicd)?"":pnltyHasseicd;
							
							String strEnd = StrSta.substring(0,6) + JBSbatDateUtil.getEndOfMonth(StrSta.substring(0,6));
							
							//OM-2013-0005052
							//OM-2013-0004078
							//基本契約 プラン課金終了年月日
							String PlanChrgEndymd=svcKeiInf.getString(JBSbatKK_T_SVC_KEI.PLAN_CHRG_ENDYMD);
							PlanChrgEndymd=(null==PlanChrgEndymd)?"":PlanChrgEndymd;
							//▼▼OM-2014-0000548▼▼
							//基本契約 プラン課金開始年月日
							String PlanChrgStaymd=svcKeiInf.getString(JBSbatKK_T_SVC_KEI.PLAN_CHRG_STAYMD);
							PlanChrgStaymd=(null==PlanChrgStaymd)?"":PlanChrgStaymd;
							//割引 プラン課金終了年月日
							String wribPlnChrgEndymd=outMap.getString(JBSbatKKIFM019.PLAN_ENDYMD);
							wribPlnChrgEndymd=(null==wribPlnChrgEndymd)?"":wribPlnChrgEndymd;
							//▲▲OM-2014-0000548▲▲
							
							//OM-2013-0005052
							String zngtuYm               = "";		// 前月の年月
							String zngtuMatuYmd          = "";		// 前月末日
							// 処理年月の前月の年月取得
							zngtuYm = JBSbatInterface.adjustMonth(StrSta, -1).substring(0, 6);
							// 処理年月の前月の末日取得（前月の年月＋前月の末日）
							zngtuMatuYmd = zngtuYm.concat(JBSbatInterface.getEndOfMonth(zngtuYm));
							
							//▼▼OM-2014-0002395▼▼
							// 処理年月の前月の初日取得（前月の年月＋01）
							String zngtuShoYmd = zngtuYm.concat(STR_OF_MONTH);
							
							// 基本契約が解約されている、
							// かつ基本契約のサービス解約理由コードが強制解約("02")、かつ基本契約のプラン課金終了年月日が「料金計算対象月の前月初日〜月末−１」の場合
							// または、基本契約のプラン課金終了年月日が「料金計算対象月の前月末〜月末−１」の場合
							//if(!"".equals(svcDslYmd) && svcChrgEndymd.compareTo(strEnd) <= 0){
							//if(!"".equals(svcDslYmd) 
							//		&& PlanChrgEndymd.compareTo(zngtuMatuYmd) >= 0 && PlanChrgEndymd.compareTo(strEnd) < 0){
							if (!"".equals(svcDslYmd) 
									&& ((JBSbatKKConst.SVC_DLRE_CD_KSI.equals(svcSvcDlreCd) && PlanChrgEndymd.compareTo(zngtuShoYmd) >= 0 && PlanChrgEndymd.compareTo(strEnd) < 0)
									|| (PlanChrgEndymd.compareTo(zngtuMatuYmd) >= 0 && PlanChrgEndymd.compareTo(strEnd) < 0)))
							{
							//▲▲OM-2014-0002395▲▲
								//TG1-2013-0000257 設定済みの解約理由コードが適用終了("1000")かつ違約金有の場合のみ設定 AS)新居
								//割引 サービス解約理由コード
								String wribsvcSvcDlreCd=outMap.getString(JBSbatKKIFM019.SVC_DLRE_CD);
								
//OM-2015-0000061 MOD STA
//								//▼▼OM-2014-0000548▼▼
//								//OM-2013-0005052
//								//基本契約の廃止に伴わずに割引サービス契約が解約されている
//								//(基本契約 サービス課金終了年月日と割引 サービス課金終了年月日が等しくない)
//								//if(!svcChrgEndymd.equals(wribSvcChrgEndymd) && (!"".equals(PlanChrgEndymd) && PlanChrgEndymd.compareTo(StrSta) < 0))
//								//{
//									//if(JBSbatKKConst.SVC_DLRE_CPN.equals(wribsvcSvcDlreCd) && JBSbatKKConst.PNLTY_HSS_ARI.equals(pnltyHasseicd))
//									//違約金発生コード有かつ、解約理由コード「1000」または(親契約.プラン課金開始＞親契約.プラン課金終了かつ割引.プラン課金終了年月日が対象月内)
//									if((JBSbatKKConst.SVC_DLRE_CPN.equals(wribsvcSvcDlreCd) 
//										|| (isNullBlunk(wribsvcSvcDlreCd)
//											&& !"".equals(wribPlnChrgEndymd)
//											&& wribPlnChrgEndymd.compareTo(StrSta) >= 0
//											&& wribPlnChrgEndymd.compareTo(strEnd) <= 0
//											&& !"".equals(PlanChrgStaymd)
//											&& !"".equals(PlanChrgEndymd)
//											&& PlanChrgStaymd.compareTo(PlanChrgEndymd) > 0)) 
//										&& JBSbatKKConst.PNLTY_HSS_ARI.equals(pnltyHasseicd))
//								//▲▲OM-2014-0000548▲▲
									// 解約理由コード「1000」または未設定かつ、割引サービス単価番号が違約金対象CPかつ違約金有の場合のみ設定
									if((JBSbatKKConst.SVC_DLRE_CPN.equals(wribsvcSvcDlreCd) || isNullBlunk(wribsvcSvcDlreCd))
										&& prcIfCommon.chkPnltyCpTankaNo(outMap.getString(JBSbatKKIFM019.WRIB_SVC_TANKA_NO), outMap.getString(JBSbatKKIFM019.TK_HOSHIKI_KEI_NO))
										&& JBSbatKKConst.PNLTY_HSS_ARI.equals(pnltyHasseicd))
//OM-2015-0000061 MOD END
									{
										// プラン課金終了年月日←基本契約 プラン課金終了年月日
										//outMap.setString(JBSbatKKIFM019.PLAN_ENDYMD, svcKeiInf.getString(JBSbatKK_T_SVC_KEI.PLAN_CHRG_ENDYMD));
										// サービス解約年月日←基本契約 サービス解約年月日
										//outMap.setString(JBSbatKKIFM019.SVC_DSL_YMD, svcKeiInf.getString(JBSbatKK_T_SVC_KEI.SVC_DSL_YMD));
									//}
									// 割引サービス契約のプラン課金終了年月日を取得
									//String pChrgEdYmd = getKmkVal(strctMrgList, JBSbatKKIFM019.PLAN_ENDYMD);
									//pChrgEdYmd=(null==pChrgEdYmd)?"":pChrgEdYmd;
									
									//かつ、割引のサービス解約理由コードが申出解約("01")または強制解約("02")の場合
									//OM-2013-0003689
									//TG1-2013-0000257 設定済みの解約理由コードが適用終了("1000")かつ違約金有の場合のみ設定 AS)新居
									//if(JBSbatKKConst.SVC_DLRE_CPN.equals(wribsvcSvcDlreCd) && JBSbatKKConst.PNLTY_HSS_ARI.equals(pnltyHasseicd))
									//{
										// 基本契約のサービス解約理由コードが申出解約("01")の場合
										if (JBSbatKKConst.SVC_DLRE_CD_NORMAL.equals(svcSvcDlreCd))
										{
											// プラン課金終了年月日←基本契約 プラン課金終了年月日
											outMap.setString(JBSbatKKIFM019.PLAN_ENDYMD, svcKeiInf.getString(JBSbatKK_T_SVC_KEI.PLAN_CHRG_ENDYMD));
											// サービス解約年月日←基本契約 サービス解約年月日
											outMap.setString(JBSbatKKIFM019.SVC_DSL_YMD, svcKeiInf.getString(JBSbatKK_T_SVC_KEI.SVC_DSL_YMD));
											//▼▼OM-2014-0001201▼▼
											// 割引サービス契約のサービス解約理由コードが適用終了("1000")の場合
											if(JBSbatKKConst.SVC_DLRE_CPN.equals(wribsvcSvcDlreCd))
											{
												// サービス解約理由コードに申出解約(割引適用なし)("0002")を設定。
												outMap.setString(JBSbatKKIFM019.SVC_DLRE_CD, JBSbatKKConst.SVC_DLRE_MOUSIDE_ALONE);
											}
											// 割引サービス契約のサービス解約理由コードが適用終了("1000")以外の場合
											//（親契約.プラン課金開始年月日＞親契約.プラン課金終了年月日
											//  かつ割引サービス契約.プラン課金終了年月日が対象月内の場合）
											else
											{
												// サービス解約理由コードに申出解約(割引適用あり)("01")を設定。
												outMap.setString(JBSbatKKIFM019.SVC_DLRE_CD, JBSbatKKConst.SVC_DLRE_CD_NORMAL);
												// 違約金発生コードを有("1")に設定。
												outMap.setString(JBSbatKKIFM019.PNLTY_HASSEI_CD, JBSbatKKConst.PNLTY_HSS_ARI);
												
												//▼▼OM-2014-0001963▼▼
												// 解約起算日が料金計算対象月初日（基本契約のプラン課金終了年月日が料金計算対象月の前月末）の場合
												if (PlanChrgEndymd.compareTo(zngtuMatuYmd) == 0)
												{
													// プラン課金終了年月日に料金計算対象月初日を設定。
													outMap.setString(JBSbatKKIFM019.PLAN_ENDYMD, StrSta);
												}
												//▲▲OM-2014-0001963▲▲
											}
											//▲▲OM-2014-0001201▲▲
										}
										// 基本契約のサービス解約理由コードが強制解約("02")の場合
										else if(JBSbatKKConst.SVC_DLRE_CD_KSI.equals(svcSvcDlreCd))
										{
											// プラン課金終了年月日←基本契約 プラン課金終了年月日
											outMap.setString(JBSbatKKIFM019.PLAN_ENDYMD, svcKeiInf.getString(JBSbatKK_T_SVC_KEI.PLAN_CHRG_ENDYMD));
											// サービス解約年月日←基本契約 サービス解約年月日
											outMap.setString(JBSbatKKIFM019.SVC_DSL_YMD, svcKeiInf.getString(JBSbatKK_T_SVC_KEI.SVC_DSL_YMD));
											//▼▼OM-2014-0001201▼▼
											// 割引サービス契約のサービス解約理由コードが適用終了("1000")の場合
											if((JBSbatKKConst.SVC_DLRE_CPN.equals(wribsvcSvcDlreCd)))
											{
												// サービス解約理由コードに強制解約(割引適用なし)("0012")を設定。
												outMap.setString(JBSbatKKIFM019.SVC_DLRE_CD, JBSbatKKConst.SVC_DLRE_KSI_ALONE);
											}
											// 割引サービス契約のサービス解約理由コードが適用終了("1000")以外の場合
											//（親契約.プラン課金開始年月日＞親契約.プラン課金終了年月日
											//  かつ割引サービス契約.プラン課金終了年月日が対象月内の場合）
											else
											{
												// サービス解約理由コードに強制解約(割引適用あり)("02")を設定。
												outMap.setString(JBSbatKKIFM019.SVC_DLRE_CD, JBSbatKKConst.SVC_DLRE_CD_KSI);
												// 違約金発生コードを有("1")に設定。
												outMap.setString(JBSbatKKIFM019.PNLTY_HASSEI_CD, JBSbatKKConst.PNLTY_HSS_ARI);
												
												//▼▼OM-2014-0001963▼▼
												// 解約起算日が料金計算対象月初日（基本契約のプラン課金終了年月日が料金計算対象月の前月末）の場合
												if (PlanChrgEndymd.compareTo(zngtuMatuYmd) == 0)
												{
													// プラン課金終了年月日に料金計算対象月初日を設定。
													outMap.setString(JBSbatKKIFM019.PLAN_ENDYMD, StrSta);
												}
												//▲▲OM-2014-0001963▲▲
											}
											//▲▲OM-2014-0001201▲▲
										}
									}
								//}
							}
						}
					}
				
					// ++++++++++ 性能改善対応 削除開始 ++++++++++ //
//					// 共通クラスクローズ
//					prcIfCommon.close();
					// ++++++++++ 性能改善対応 削除終了 ++++++++++ //
				}
			// ++++++++++ v5.00.00 追加開始 ++++++++++ //
			}
			// ++++++++++ v5.00.00追加終了 ++++++++++ //
			
			if (outMap != null)
			{
				outMap.setOutFlg(true);
				
				outputBean.addOutMapList(outMap);
			}
			
			outMap = new JBSbatServiceInterfaceMap();
		}
	}

	/**
	 * 退避情報と入力情報の内容比較を行います。
	 * @param tmpList 退避情報リスト
	 * @param inList 入力情報リスト
	 * @return dfFlg 差分有無フラグ(true:差分有／false:差分無)
	 * @throws Exception
	 */
	private boolean diffList(ArrayList<String[]> tmpList, ArrayList<String[]> inList) throws Exception
	{
		boolean dfFlg = false;
		
		if(0 == tmpList.size())
		{
			dfFlg = true;
		}
		else
		{
			String tmpVal = "";
			String inVal = "";
			
			for(int i=0; i<tmpList.size(); i++)
			{
				tmpVal = tmpList.get(i)[2];
				inVal = inList.get(i)[2];
				
				if( (null != tmpVal && 0 != tmpVal.length()) && (null == inVal || 0 == inVal.length()) )
				{
					dfFlg = true;
				}
				else if( (null == tmpVal || 0 == tmpVal.length()) && (null != inVal && 0 != inVal.length()) )
				{
					dfFlg = true;
				}
				else if( (null != tmpVal && 0 != tmpVal.length()) && (null != inVal && 0 != inVal.length()) && (!tmpVal.equals(inVal)) )
				{
					dfFlg = true;
				}
			}
		}
		
		return dfFlg;
	}

	/**
	 * ArrayListの設定を行います。
	 * @param listA
	 * @param listB
	 */
	private void setArrayList(ArrayList<String[]> listA, ArrayList<String[]> listB)
	{
		for(int i = 0; i < listA.size(); i++ )
		{
			listB.add(listA.get(i));
		}
	}

	/**
	 * null、空文字を判定
	 * @param str
	 * @return true:値なし／false:値あり
	 */
	private boolean isNullBlunk(String str)
	{
		if (str == null || str.equals(""))
		{
			return true;
		}
		return false;
	}
}