/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatAKSoteiMansPrc
*	ソースファイル名	：JBSbatAKSoteiMansPrc.java
*	作成者				：富士通　
*	作成日				：2012年07月20日
*＜機能概要＞
*　想定金額算出（マンション定額）部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v3.00.00	2012/07/20   FJ）冨井	新規作成
*	v4.00.00	2013/03/26   FJ) 小柴	【内部管理番号-0000613】ファイル出力オブジェクト生成時のエンコード設定ずれ防止対応
*	v4.00.01	2013/04/05   FJ) 小柴	【IKK-2013-0000783】文字化け対策のため、エンコード形式の変更
*	v4.00.02	2013/05/02   FJ) 高橋	料金検証障害対応【No29】マンション定額（個別）の基本料金（休止）が不一致対応
*	v4.00.03	2013/05/15   FJ) 高橋	料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応
*	v4.01.00	2013/07/09   FJ) 黒木	【LT-2013-0000358】料金検証障害対応
*	v4.02.00	2013/07/23   FJ) 黒木	【ANK-1464-00-00】料金検証不具合対応
*	v4.03.00	2013/07/29   FJ) 黒木	【ANK-1464-00-00】料金検証不具合対応
*	v12.00.00	2014/09/24   FJ) 前田	【ANK-2249-00-00】マンション日割り対応
*	v15.00.00	2015/08/20   FJ) 高橋	【ANK-2163-00-00】【ＮＯ．１５５７】課金終了日以降にも利用不可期間減額を適用
*********************************************************************/
package eo.business.service;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;

import eo.business.common.JACbatDebugLogUtil;
import eo.business.common.JACbatParamUtil;
import eo.business.common.JACbatRknBusinessUtil;
import eo.business.common.JACbatSchdlUtil;
import eo.business.common.JBSbatBusinessService;
import eo.business.common.JBSbatMatchServiceInterface;
import eo.business.common.JCHbatSeikyKaknoBusinessUtil;
import eo.business.common.JCHbatSeikyKaknoBusinessUtil.FillType;
import eo.business.util.file.JBSbatAKIFM003;
import eo.business.util.file.JBSbatAKIFM004;
import eo.business.util.table.JBSbatAK_M_SOTEI_PRC;
import eo.business.util.table.JBSbatCH_M_PRC_KMK_CS_CHGE;
import eo.business.util.table.JBSbatKK_T_TK_HOSHIKI_KEI;
import eo.common.constant.JACStrConst;
import eo.common.constant.JPCBatchMessageConstant;
import eo.framework.db.JBSbatSQLAccess;
import eo.framework.file.JBSbatDefFileUtil;
import eo.framework.file.JBSbatOutputFileUtil;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.item.JBSbatOutputItem;
import eo.framework.item.JBSbatServiceInterfaceMap;
import eo.framework.util.JBSbatAplConst;
import eo.framework.util.JBSbatDateUtil;

/**
* (クラスの機能概要) <p>
*<BR>
* @author 富士通
*/
public class JBSbatAKSoteiMansPrc extends JBSbatBusinessService implements JBSbatMatchServiceInterface
{
	/**▼▼▼▼▼▼ツールから生成した宣言です 開始▼▼▼▼▼▼*/
	/** テーブル(想定料金)*/
	private static final String D_TBL_NAME_AK_M_SOTEI_PRC = "AK_M_SOTEI_PRC";

	/** テーブル(料金項目抽出変換)*/
	private static final String D_TBL_NAME_CH_M_PRC_KMK_CS_CHGE = "CH_M_PRC_KMK_CS_CHGE";

	/** テーブル(提供方式契約)*/
	private static final String D_TBL_NAME_KK_T_TK_HOSHIKI_KEI = "KK_T_TK_HOSHIKI_KEI";

	/** SQL定義キー(AK_SELECT_002)*/
	private static final String AK_M_SOTEI_PRC_AK_SELECT_002 = "AK_SELECT_002";

	/** SQL定義キー(AK_SELECT_001)*/
	private static final String CH_M_PRC_KMK_CS_CHGE_AK_SELECT_001 = "AK_SELECT_001";

	/** SQL定義キー(AK_SELECT_002)*/
	private static final String KK_T_TK_HOSHIKI_KEI_AK_SELECT_002 = "AK_SELECT_002";

	/** テーブルアクセスクラス(想定料金)*/
	private JBSbatSQLAccess db_AK_M_SOTEI_PRC = null;

	/** テーブルアクセスクラス(料金項目抽出変換)*/
	private JBSbatSQLAccess db_CH_M_PRC_KMK_CS_CHGE = null;

	/** テーブルアクセスクラス(提供方式契約)*/
	private JBSbatSQLAccess db_KK_T_TK_HOSHIKI_KEI = null;

	/** キーマッチ処理フラグ*/
	private boolean matchProcFlg;

	/** マスタファイル処理フラグ*/
	private boolean mastProcFlg;

	/** トランファイル処理フラグ*/
	private boolean tranProcFlg;
	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/

	/** 退避．想定料金マップ */
	private HashMap<String, ArrayList<JBSbatCommonDBInterface>> tmpSoteiPrcMap = null;
	
	/** 退避．利用不可期間減額用存在チェックレベルコード */
	private String tmpRfkgySzchkLvCd = null;
	
	/** 退避．利用不可期間減額用金額チェックレベルコード */
	private String tmpRfkgyAmchkLvCd = null;
	
	/** 退避．未入居明細用サービス契約番号 */
	private String tmpMiNyukyoSvcKeiNo = null;
	
	/** ワーク入力Ｍ有無フラグ（有り：true、なし：false） */
	private boolean wkInputMastUmFlg = false;
	
	/** ワーク入力Ｍレコード */
	private JBSbatServiceInterfaceMap wkInputMastRecode = null;
	
	/** ワーク．Ｔ提供方式契約番号 */
	private String wkTTkHoshikiKeiNo = JACStrConst.KARA_MOJI;
	
	/** ワークマスタ．想定料金 */
	private BigDecimal wkMastSoteiAmnt = BigDecimal.ZERO;
	
	/** ワーク．想定金額 */
	private BigDecimal tmpWkSoteiAmnt = BigDecimal.ZERO;
	
	// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 MOD START
	// UI者の意図と既存処理が大幅に違うため、暫定対応
	/** ワーク．想定料金 */
	private BigDecimal tmpWkSoteiPrc = BigDecimal.ZERO;
	// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 MOD END
	
	/** ワーク．総戸数 */
	private BigDecimal wkTtlKoSu = BigDecimal.ZERO;
	
	/** ワーク．居住者数 */
	private BigDecimal wkKyojuSyaSu = BigDecimal.ZERO;
	
	/** ワーク未入居レコード */
	private JBSbatServiceInterfaceMap wkMiNyuKyoRecode = null;
	
	/** ワーク未入居フラグ （true：有り、false：なし）*/
	private boolean wkMiNyuKyoFlg = false;
	
	/** 月中利用不可日数 */
	private BigDecimal wkUseFailDayCnt = new BigDecimal(0);
	
	// 2015/08/20 ANK-2163-00-00 ADD START
	/** 月中利用不可日数（日割なし） */
	private BigDecimal wkUseFailDayCntHiwariNon = new BigDecimal(0);
	// 2015/08/20 ANK-2163-00-00 ADD END
	
	/** 退避．オーナー用料金グループコード配列 */
	private ArrayList<String> tmpGoupCdList = null;
	
	/** ワーク．トラン請求契約番号 */
	private String wkTranSeikyKeiNo = JACStrConst.KARA_MOJI;
	
	/** 退避．業務機能識別コード（マンション定額料金計算） */
	private String tmpWorkKinoSkbtCd = null;
	
	/** 退避．マンションID明細料金項目コード変換表 */
	private String  tmpManidCnvMapWkCd = null;
	
	/** 退避．料金項目コード（マンション定額料金計算） */
	private String tmpPrcKmkCd = null;
	
	/** マンションID明細料金項目コード変換マップ */
	private HashMap<ArrayList<String>, JBSbatCommonDBInterface> manidCnvMap = null;
	
	/** 退避．請求年月 */
	private String tmpSeikyYm = null;
	
	/** 退避．月初日 */
	private String tmpMonStaDay = null;
	
	/** 退避．月末日 */
	private String tmpMonEndDay = null;
	
	/** 退避．料金計算日 */
	private String tmpEventYmd = null;
	
	/** 退避．請求年月の暦日数 */
	private BigDecimal tmpCalDay = BigDecimal.ZERO;
	
	/** ワーク．利用不可適用方法コード */
	private String tmpUseFailAplyWayCd = JACStrConst.KARA_MOJI;
	
	/** 固定値：日付差分フラグ（両日付を差に含める） */
	private static final String DIFF_NAI_FLG 		= "1";
	
	/** 固定値：-1 */
	private static final BigDecimal MINUS_ONE = new BigDecimal("-1");

	/** 固定値：入力Ｍファイル名 */
	private static final String MST_FILE_NM = "請求パターン付加検証対象契約情報（オーナーダミー）";

	/** 固定値：入力Ｔファイル名 */
	private static final String TRN_FILE_NM = "請求パターン内訳情報（マンション定額）";

	/** 請求収納業務共通クラス */
	private JCHbatSeikyKaknoBusinessUtil seikyUtil = null;

	/** マンションＩＤ項目長 */
	private static final int MANSION_ID_LENGTH = 14;
	
	/**
	 * 初期処理
	 * @param JBSbatCommonItem commonItem　バッチ共通パラメータ電文
	 * @throws Exception
	 */
	public void initial(JBSbatCommonItem commonItem) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの初期処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した初期化のソースです 開始▼▼▼▼▼▼*/
		// 共通パラメータを設定します
		super.setCommonInfo(commonItem);

		// DBアクセスクラスを生成します
		db_AK_M_SOTEI_PRC = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AK_M_SOTEI_PRC);
		db_CH_M_PRC_KMK_CS_CHGE = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CH_M_PRC_KMK_CS_CHGE);
		db_KK_T_TK_HOSHIKI_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_TK_HOSHIKI_KEI);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][initial]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][opeDate=" + super.opeDate + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][freeItem=" + super.freeItem + "]");
		
		// 想定料金マップ作成
		this.makeSoteiPrcMap();
		
		// 業務パラメータを取得する。
		this.getWorkPara();
		
		// マンションＩＤ中計用の料金項目コードを取得
		this.getPrcKmkCd();
		
		// マンションID明細料金項目コード変換マップ生成
		this.createManidCnvMap();
		
		// スケジュール取得
		this.getSchdlInfo();

		seikyUtil = new JCHbatSeikyKaknoBusinessUtil(commonItem); 
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][initial]");
		
	/**▲▲▲▲▲▲業務サービスの初期処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 主処理
	 * @param mastMap　入力電文
	 * @param tranMap　入力電文
	 * @param outputInItem  入力情報
	 * @return JBSbatOutputItem 出力情報
	 * @throws Exception
	 */
	public JBSbatOutputItem execute(JBSbatServiceInterfaceMap mastMap, JBSbatServiceInterfaceMap tranMap, JBSbatOutputItem outputInItem) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの主処理を記述してください。▼▼▼▼▼▼*/
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute]");
		assert mastMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute][mastMap=" + mastMap.getMap().toString() + "]") : true;
		assert tranMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute][tranMap=" + tranMap.getMap().toString() + "]") : true;
		
		// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 ADD START
		// 不要な前回取得項目を初期化
		this.wkMastSoteiAmnt = BigDecimal.ZERO;
		this.tmpWkSoteiAmnt = BigDecimal.ZERO;
		this.tmpWkSoteiPrc = BigDecimal.ZERO;		
		// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 ADD END
		
		// 入力Ｍのみ存在する
		if(mastMap != null && tranMap == null)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute][入力Ｍのみ存在する]");
			
			// マスタフラグ　←　true（入力Ｍ読み込み）
			this.setMastProcFlg(true);
		}
		// 入力Ｔのみ存在する
		else if(null == mastMap && null != tranMap)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute][入力Ｔのみ存在する]");
			
			// 1. 「(3) オーナ契約クリア」を行う
			this.wkOwnerKeiClear();
			
			// 2. 「(2) 請求パターン内訳情報（マンション明細）作成」を行う。
			this.makeSeikyPtaUcwkInfo(mastMap, tranMap, outputInItem);
			
			// 4. トランフラグ　←　true（入力Ｔ読み込み）
			this.setTranProcFlg(true);
		}
		else 
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute][入力Ｍ、入力Ｔともに存在する][入力Ｍ＝入力Ｔ]");
			
			// マッチングキー取得
			
			// マスタキー
			String mastKey	= this.makeHanneiSkWkKey(mastMap);
			// トランキー
			String trnKey	= this.makeHanneiSkWkKey(tranMap);
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute][入力Ｍ．マッチングキー=" + mastKey + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute][入力Ｔ．マッチングキー=" + trnKey + "]");
			
			// マッチング処理
			// 入力Ｍ＝入力Ｔ（マッチ）
			if (mastKey.equals(trnKey))
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute][入力Ｍ、入力Ｔともに存在する][入力Ｍ＝入力Ｔ（マッチ）]");
				
				// 1. 「(2) オーナー契約退避」を行う。
				this.wkOwnerKei(mastMap);
				
				// 2. 「(4) 請求パターン内訳情報（マンション明細）作成」を行う。
				this.makeSeikyPtaUcwkInfo(mastMap, tranMap, outputInItem);
				
				// 3. トランフラグ　←　true（トラン読み込み）
				this.setTranProcFlg(true);
			}
			// 入力Ｍ＜入力Ｔ
			else if (mastKey.compareTo(trnKey) < 0)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute][入力Ｍ、入力Ｔともに存在する][入力Ｍ＜入力Ｔ]");
				
				// マスタフラグ　←　true（入力Ｍ読み込み）
				this.setMastProcFlg(true);
			}
			// 入力Ｍ＞入力Ｔ
			else
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute][入力Ｍ、入力Ｔともに存在する][入力Ｍ＞入力Ｔ]");
				
				// 1. 「(3) オーナ契約クリア」を行う
				this.wkOwnerKeiClear();
				
				// 2. 「(4) 請求パターン内訳情報（マンション明細）作成」を行う。
				this.makeSeikyPtaUcwkInfo(mastMap, tranMap, outputInItem);
				
				// 4. トランフラグ　←　true（入力Ｔ読み込み）
				this.setTranProcFlg(true);
			}
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute][マスタフラグ:" + this.mastProcFlg + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute][トランフラグ:" + this.tranProcFlg + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][execute]");
		return outputInItem;
	/**▲▲▲▲▲▲業務サービスの主処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 業務サービス終了処理
	 * @throws Exception
	 */
	public void terminal() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの終了処理を記述してください。▼▼▼▼▼▼*/
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][terminal]");
		
		JBSbatOutputFileUtil fileUtil = super.commonItem.getOutPutFile();
		// 設定されているエンコード形式を退避
		String enc = fileUtil.getEncode();
		// encodeの形式がSHIFT-JISの場合、MS932に変換
		if (JACStrConst.ENCODE_SJIS.toUpperCase().equals(enc.toUpperCase()))
		{
			enc = JACStrConst.ENCODE_MS932;
		}
		
		// 出力定義ファイル名を取得します。
		String outFileDefName = JBSbatAplConst.getAplConstValue("OTD") + super.freeItem;
		
		// 出力定義ファイルオブジェクトを生成します。
		JBSbatDefFileUtil outFileDef = new JBSbatDefFileUtil(outFileDefName, fileUtil);
		// 退避したエンコード形式を戻す（出力定義ファイルオブジェクト生成時に上書きが発生しているため）
		fileUtil.setEncode(enc);
		
		// 出力情報生成
		JBSbatOutputItem outputInItem = new JBSbatOutputItem();
		
		// 未入居明細の出力が必要な場合、未入居明細用の想定金額を算出し未入居明細を出力する。
		//（　ワーク．未入居出力フラグ　＝　"有り"　かつ　ワーク未入居．請求契約番号　≠　空文字　）の場合
		if(this.wkMiNyuKyoFlg && !JACStrConst.KARA_MOJI.equals(this.wkMiNyuKyoRecode.getString(JBSbatAKIFM004.SEIKY_KEI_NO).trim()))
		{
			// （ア）（　ワーク未入居．加入契約支払方式コード　＝　"003"（全戸一括）　 ）　の場合
			if(JACStrConst.KANYU_KEI_PAY_HSHK_CD_IKT.equals(this.wkMiNyuKyoRecode.getString(JBSbatAKIFM004.KANYU_KEI_PAY_HOSHIKI_CD)))
			{
				// ワーク未入居．想定金額　　←　ワークマスタ．想定料金　÷　ワーク．総戸数　×　（ワーク．総戸数　−　ワーク．居住者数）
				// （端数切り捨て、ワーク．総戸数＝０の場合は計算せずにワーク未入居．想定金額←ゼロを設定）
				if(this.wkTtlKoSu.compareTo(new BigDecimal(0)) == 0)
				{
					this.wkMiNyuKyoRecode.set(JBSbatAKIFM004.SOTEI_AMNT, "0");
				}
				else
				{
					// ワークマスタ．想定料金の算出を行う。
					// 想定金額算出（マンション定額）呼び出し
					this.wkMastSoteiAmnt(this.wkMiNyuKyoRecode);
					this.wkMastSoteiAmnt = this.tmpWkSoteiAmnt;
					
					// ワーク．総戸数　−　ワーク．居住者数の算出
					BigDecimal minyukyosu = this.wkTtlKoSu.subtract(this.wkKyojuSyaSu);
					BigDecimal reslt = this.wkMastSoteiAmnt.divide(this.wkTtlKoSu, 5, BigDecimal.ROUND_HALF_EVEN).multiply(minyukyosu);
					reslt = JACbatRknBusinessUtil.round(JACStrConst.ROUND_DOWN, reslt, 2);
					
					this.wkMiNyuKyoRecode.set(JBSbatAKIFM004.SOTEI_AMNT, reslt);
				}
			}
			// （イ）（　ワーク未入居．加入契約支払方式コード　＝　"001"（ベース）　　 ）　の場合
			else if(JACStrConst.KANYU_KEI_PAY_HSHK_CD_BASE.equals(this.wkMiNyuKyoRecode.getString(JBSbatAKIFM004.KANYU_KEI_PAY_HOSHIKI_CD)))
			{
				// ワークマスタ．想定料金の算出を行う。
				// 想定金額算出（マンション定額）呼び出し
				this.wkMastSoteiAmnt(this.wkMiNyuKyoRecode);
				this.wkMastSoteiAmnt = this.tmpWkSoteiAmnt;
				
				// ワーク未入居．想定金額　　←　ワークマスタ．想定料金　×　（ワーク．総戸数　−　ワーク．居住者数）
				// ワーク．総戸数　−　ワーク．居住者数の算出
				BigDecimal minyukyosu = this.wkTtlKoSu.subtract(this.wkKyojuSyaSu);
				BigDecimal reslt = this.wkMastSoteiAmnt.multiply(minyukyosu);
				reslt = JACbatRknBusinessUtil.round(JACStrConst.ROUND_DOWN, reslt, 2);
				
				this.wkMiNyuKyoRecode.set(JBSbatAKIFM004.SOTEI_AMNT, reslt);
			}
			
			// （ウ）未入居明細出力
			// 下記(5) 明細レコード編集・出力　を行う。『未入居明細』
			this.makeOutputInfo(wkMiNyuKyoRecode, outputInItem, this.wkMiNyuKyoRecode.getString(JBSbatAKIFM004.UW_PRC_KMK_CD));
			
			// （エ）ワーク．未入居出力フラグクリア
			this.wkMiNyuKyoFlg = false;
		}
		
		int listSize = outputInItem.getOutMapList().size();
		
		for (int i = 0; i < listSize; i++)
		{
			// ファイルを出力します
			fileUtil.print((JBSbatServiceInterfaceMap)outputInItem.getOutMapList().get(i), outFileDef);
		}
		/**▼▼▼▼▼▼ツールから生成した終了処理のソースです 開始▼▼▼▼▼▼*/
		// DBアクセスクラスをクローズします
		db_AK_M_SOTEI_PRC.close();
		db_CH_M_PRC_KMK_CS_CHGE.close();
		db_KK_T_TK_HOSHIKI_KEI.close();
		/**▲▲▲▲▲▲ツールから生成した終了処理のソースです 終了▲▲▲▲▲▲*/
		seikyUtil.close();
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][terminal]");
	/**▲▲▲▲▲▲業務サービスの終了処理を記述してください。▲▲▲▲▲▲*/
	}

	/**▼▼▼▼▼▼ツールから生成したメソッドです 開始▼▼▼▼▼▼*/
	/**
	 * @return mastProcFlg を戻します。
	 */
	public boolean isMastProcFlg()
	{
		return mastProcFlg;
	}

	/**
	 * @return matchProcFlg を戻します。
	 */
	public boolean isMatchProcFlg()
	{
		return matchProcFlg;
	}

	/**
	 * @return tranProcFlg を戻します。
	 */
	public boolean isTranProcFlg()
	{
		return tranProcFlg;
	}

	/**
	 * @param mast_ProcFlg 設定する mastProcFlg。
	 */
	public void setMastProcFlg(boolean mast_ProcFlg)
	{
		this.mastProcFlg = mast_ProcFlg;
	}

	/**
	 * @param match_ProcFlg 設定する matchProcFlg。
	 */
	public void setMatchProcFlg(boolean match_ProcFlg)
	{
		this.matchProcFlg = match_ProcFlg;
	}

	/**
	 * @param tran_ProcFlg 設定する tranProcFlg。
	 */
	public void setTranProcFlg(boolean tran_ProcFlg)
	{
		this.tranProcFlg = tran_ProcFlg;
	}

	/**
	 * SQLKEY(AK_SELECT_002)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	想定料金適用開始年月日
	 *		 	想定料金適用終了年月日
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeAK_M_SOTEI_PRC_AK_SELECT_002(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());
		paramList.setValue(param[1].toString());

		// DBアクセスを実行します
		db_AK_M_SOTEI_PRC.selectBySqlDefine(paramList, AK_M_SOTEI_PRC_AK_SELECT_002);
	}

	/**
	 * SQLKEY(AK_SELECT_001)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	システムコード
	 *		 	業務機能識別コード
	 *		 	抽出変換コード
	 *		 	料金項目抽出変換適用開始年月日
	 *		 	料金項目抽出変換適用終了年月日
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeCH_M_PRC_KMK_CS_CHGE_AK_SELECT_001(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());
		paramList.setValue(param[1].toString());
		paramList.setValue(param[2].toString());
		paramList.setValue(param[3].toString());
		paramList.setValue(param[4].toString());

		// DBアクセスを実行します
		db_CH_M_PRC_KMK_CS_CHGE.selectBySqlDefine(paramList, CH_M_PRC_KMK_CS_CHGE_AK_SELECT_001);
	}

	/**
	 * SQLKEY(AK_SELECT_002)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	提供方式契約番号
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_T_TK_HOSHIKI_KEI_AK_SELECT_002(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());

		// DBアクセスを実行します
		db_KK_T_TK_HOSHIKI_KEI.selectBySqlDefine(paramList, KK_T_TK_HOSHIKI_KEI_AK_SELECT_002);
	}
	/**▲▲▲▲▲▲ツールから生成したメソッドです 終了▲▲▲▲▲▲*/
	
	/**▼▼▼▼▼▼メソッド追加 開始▼▼▼▼▼▼*/
	
	/**
	 * 引数で渡されたマップをもとに、
	 * 反映先ワークキーを作成し、その結果を返却します。
	 * 
	 * @param trgMap 対象情報
	 * @return String 反映先ワークキー
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private String makeHanneiSkWkKey(JBSbatServiceInterfaceMap trgMap) throws Exception
	{
		StringBuffer buf = new StringBuffer();
		
		// 提供方式契約番号
		buf.append(trgMap.getString(JBSbatAKIFM003.TK_HOSHIKI_KEI_NO));
		
		return buf.toString();
	}
	
	/**
	 * オーナ契約の退避する。
	 * 
	 * @param mastMap 入力Ｍ
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void wkOwnerKei(JBSbatServiceInterfaceMap mastMap) throws Exception
	{
		// ワーク入力Ｍ有無フラグ　←　true（有り）
		this.wkInputMastUmFlg = true;
		
		// 入力Ｍレコードを退避
		this.wkInputMastRecode = new JBSbatServiceInterfaceMap();
		this.wkInputMastRecode.getMap().putAll(mastMap.getMap());
	}
	
	/**
	 * オーナ契約のクリアを行う。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void wkOwnerKeiClear() throws Exception
	{
		// ワーク入力Ｍ有無フラグ　←　false（なし）
		this.wkInputMastUmFlg = false;
		
		// 入力Ｍレコードのクリア
		this.wkInputMastRecode = new JBSbatServiceInterfaceMap();
		this.wkInputMastRecode.setString(JBSbatAKIFM004.SEIKY_KEI_NO, JACStrConst.SEIKY_KEI_NO_SP);
		this.wkInputMastRecode.setString(JBSbatAKIFM004.SVC_KEI_NO, JACStrConst.SVC_KEI_NO_SP);
		this.wkInputMastRecode.setString(JBSbatAKIFM004.PRC_GRP_CD, JACStrConst.PRC_GRP_CD_SP);
		this.wkInputMastRecode.setString(JBSbatAKIFM004.PCRS_CD, JACStrConst.PCRS_CD_SP);
		this.wkInputMastRecode.setString(JBSbatAKIFM004.PRC_SVC_CD, JACStrConst.PRC_SVC_CD_SP);
	}
	
	/**
	 * 請求パターン内訳情報（マンション明細）作成をおこないます。
	 * @param mastMap　入力電文
	 * @param tranMap　入力電文
	 * @param outputInItem  出力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void makeSeikyPtaUcwkInfo(JBSbatServiceInterfaceMap mastMap, JBSbatServiceInterfaceMap tranMap, JBSbatOutputItem outputInItem) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeSeikyPtaUcwkInfo]");
		
		// (a) トランの提供方式契約番号ブレイク
		//     （　ワーク．Ｔ提供方式契約番号　≠　入力Ｔ．提供方式契約番号　）の場合
		if(!this.wkTTkHoshikiKeiNo.equals(tranMap.getString(JBSbatAKIFM004.TK_HOSHIKI_KEI_NO)))
		{
			
			// 未入居明細の出力が必要な場合、未入居明細用の想定金額を算出し未入居明細を出力する。
			//    （　ワーク．未入居出力フラグ　　＝　"有り"　）の場合
			if(this.wkMiNyuKyoFlg)
			{
				// （ア）（　ワーク未入居．加入契約支払方式コード　＝　"003"（全戸一括）　 ）　の場合
				if(JACStrConst.KANYU_KEI_PAY_HSHK_CD_IKT.equals(this.wkMiNyuKyoRecode.getString(JBSbatAKIFM004.KANYU_KEI_PAY_HOSHIKI_CD)))
				{
					// ワーク未入居．想定金額　　←　ワークマスタ．想定料金　÷　ワーク．総戸数　×　（ワーク．総戸数　−　ワーク．居住者数）
					// （端数切り捨て、ワーク．総戸数＝０の場合は計算せずにワーク未入居．想定金額←ゼロを設定）
					if(this.wkTtlKoSu.compareTo(new BigDecimal(0)) == 0)
					{
						this.wkMiNyuKyoRecode.set(JBSbatAKIFM004.SOTEI_AMNT, "0");
					}
					else
					{
						// ワークマスタ．想定料金の算出を行う。
						// 想定金額算出（マンション定額）呼び出し
						this.wkMastSoteiAmnt(this.wkMiNyuKyoRecode);
						this.wkMastSoteiAmnt = this.tmpWkSoteiAmnt;
						
						// ワーク．総戸数　−　ワーク．居住者数の算出
						BigDecimal minyukyosu = this.wkTtlKoSu.subtract(this.wkKyojuSyaSu);
						BigDecimal reslt = this.wkMastSoteiAmnt.divide(this.wkTtlKoSu, 5, BigDecimal.ROUND_HALF_EVEN).multiply(minyukyosu);
						reslt = JACbatRknBusinessUtil.round(JACStrConst.ROUND_DOWN, reslt, 2);
						
						this.wkMiNyuKyoRecode.set(JBSbatAKIFM004.SOTEI_AMNT, reslt);
					}
				}
				// （イ）（　ワーク未入居．加入契約支払方式コード　＝　"001"（ベース）　　 ）　の場合
				else if(JACStrConst.KANYU_KEI_PAY_HSHK_CD_BASE.equals(this.wkMiNyuKyoRecode.getString(JBSbatAKIFM004.KANYU_KEI_PAY_HOSHIKI_CD)))
				{
					// ワークマスタ．想定料金の算出を行う。
					// 想定金額算出（マンション定額）呼び出し
					this.wkMastSoteiAmnt(this.wkMiNyuKyoRecode);
					this.wkMastSoteiAmnt = this.tmpWkSoteiAmnt;
					
					// ワーク未入居．想定金額　　←　ワークマスタ．想定料金　×　（ワーク．総戸数　−　ワーク．居住者数）
					// ワーク．総戸数　−　ワーク．居住者数の算出
					BigDecimal minyukyosu = this.wkTtlKoSu.subtract(this.wkKyojuSyaSu);
					BigDecimal reslt = this.wkMastSoteiAmnt.multiply(minyukyosu);
					reslt = JACbatRknBusinessUtil.round(JACStrConst.ROUND_DOWN, reslt, 2);
					
					this.wkMiNyuKyoRecode.set(JBSbatAKIFM004.SOTEI_AMNT, reslt);
				}
				
				// （ウ）未入居明細出力
				// ワーク未入居．請求契約番号　≠　空の場合のみ
				// 下記(5) 明細レコード編集・出力　を行う。『未入居明細』
				if(!JACStrConst.KARA_MOJI.equals(this.wkMiNyuKyoRecode.getString(JBSbatAKIFM004.SEIKY_KEI_NO).trim()))
				{
					this.makeOutputInfo(wkMiNyuKyoRecode, outputInItem, this.wkMiNyuKyoRecode.getString(JBSbatAKIFM004.UW_PRC_KMK_CD));
				}
				
				// （エ）ワーク．未入居出力フラグクリア
				this.wkMiNyuKyoFlg = false;
			}
			
			// 総戸数取得
			this.getTtlKosu(tranMap);
			
			// 居住者数をクリア
			this.wkKyojuSyaSu = BigDecimal.ZERO;
			
			// 入力Ｔ．提供方式契約番号を退避する。
			this.wkTTkHoshikiKeiNo = tranMap.getString(JBSbatAKIFM004.TK_HOSHIKI_KEI_NO);
			
			// ワーク．請求契約番号をクリアする。
			this.wkTranSeikyKeiNo = JACStrConst.KARA_MOJI;
		}
		// (b) トランの請求契約番号ブレイク時
		//     （　ワーク．Ｔ請求契約番号　≠　入力Ｔ．請求契約番号　）　の場合
		if(!this.wkTranSeikyKeiNo.equals(tranMap.getString(JBSbatAKIFM004.SEIKY_KEI_NO)))
		{
			// トランが子契約の場合、ワーク．居住者数をカウントする。
			// ANK-2249-00-00 MOD START
			// （ 入力Ｔ．料金グループコードが、初期処理(5) で設定したオーナー用料金グループコード配列に存在しない ）
			// かつ サービス開始月でない（プラン開始年月日＜請求年月の月初日）の場合
			// if(!this.tmpGoupCdList.contains(tranMap.getString(JBSbatAKIFM004.PRC_GRP_CD)))
			if(!this.tmpGoupCdList.contains(tranMap.getString(JBSbatAKIFM004.PRC_GRP_CD))
							&& this.tmpMonStaDay.compareTo(tranMap.getString(JBSbatAKIFM004.PLAN_STAYMD)) > 0)
			// ANK-2249-00-00 MOD END
			{
				this.wkKyojuSyaSu = this.wkKyojuSyaSu.add(BigDecimal.ONE);
			}
			
			//入力Ｔ．請求契約番号を退避する。
			this.wkTranSeikyKeiNo = tranMap.getString(JBSbatAKIFM004.SEIKY_KEI_NO);
		}
		
		// (c) 入力Ｔレコードを退避する。
		JBSbatServiceInterfaceMap wkRecodeMap		 = new JBSbatServiceInterfaceMap();		// ワーク退避レコード
		JBSbatServiceInterfaceMap wkUseFailRecodeMap = new JBSbatServiceInterfaceMap();		// ワーク退避（利用不可）レコード
		{
			// ワーク退避レコード ← 入力Ｔレコード
			wkRecodeMap.getMap().putAll(tranMap.getMap());
		}
		
		// (d) 【マンション親契約】ワーク退避．料金グループコードが、初期処理(5) で設定したオーナー用料金グループコード配列に存在する場合
		// 判定条件取得
		String prcGrpCd 			= wkRecodeMap.getString(JBSbatAKIFM004.PRC_GRP_CD);					// 料金グループコード
		String kanyuKeiPayHoshikiCd = wkRecodeMap.getString(JBSbatAKIFM004.KANYU_KEI_PAY_HOSHIKI_CD);	// 加入契約支払方式コード
		// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 MOD START
		// 月中利用不可日数の変数が未使用＆統一されていない形であったので、グローバル変数側に修正
		//BigDecimal useFailDayCnt 	= wkRecodeMap.getBigDecimal(JBSbatAKIFM004.USE_FAIL_DAY_CNT);		// 月中利用不可日数
		this.wkUseFailDayCnt		= wkRecodeMap.getBigDecimal(JBSbatAKIFM004.USE_FAIL_DAY_CNT);		// 月中利用不可日数
		// 2015/08/20 ANK-2163-00-00 ADD START
		this.wkUseFailDayCntHiwariNon	= wkRecodeMap.getBigDecimal(JBSbatAKIFM004.USE_FAIL_DAY_CNT_HIWARI_NON);	// 月中利用不可日数（日割なし）
		String planChrgEndYmd = wkRecodeMap.getString(JBSbatAKIFM004.PLAN_CHRG_ENDYMD);								// プラン課金終了年月日
		// 2015/08/20 ANK-2163-00-00 ADD END
		
		//assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeSeikyPtaUcwkInfo][月中利用不可日数:" + useFailDayCnt + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeSeikyPtaUcwkInfo][月中利用不可日数:" + this.wkUseFailDayCnt + "]");
		// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 MOD END
		// 2015/08/20 ANK-2163-00-00 ADD START
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeSeikyPtaUcwkInfo][月中利用不可日数（日割なし）:" + this.wkUseFailDayCntHiwariNon + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeSeikyPtaUcwkInfo][プラン課金終了年月日:" + planChrgEndYmd + "]");
		// 2015/08/20 ANK-2163-00-00 ADD END
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeSeikyPtaUcwkInfo][加入契約支払方式コード:" + kanyuKeiPayHoshikiCd + "]");
		
		if(this.tmpGoupCdList.contains(prcGrpCd))
		{
			// 下記(5) 明細レコード編集・出力　を行う。『親契約の明細』
			String mansionId = seikyUtil.fillString(FillType.HalfSpace, wkRecodeMap.getString(JBSbatAKIFM004.MANSION_ID), MANSION_ID_LENGTH, true);
			wkRecodeMap.set(JBSbatAKIFM004.SEIRI_NO, mansionId);
			
			this.makeOutPutDtlInfo(wkRecodeMap, outputInItem);
			
			// 未入居レコード退避
			this.wkMiNyuKyo(wkRecodeMap);
			
			// 2015/08/20 ANK-2163-00-00 MOD START
			//   （　ワーク．利用不可適用方法コード ＝ "1"（利用不可期間減額明細作成）または
			//                                         "2"（利用期間が全日利用不可時徴収なし）　）　の場合
			//if(this.wkUseFailDayCnt.compareTo(BigDecimal.ZERO) > 0
			//		&& (JACStrConst.USE_FAIL_APLY_WAY_CD_DTL.equals(this.tmpUseFailAplyWayCd)
			//				|| JACStrConst.USE_FAIL_APLY_WAY_CD_ALL.equals(this.tmpUseFailAplyWayCd)))
			//{
			//	// ワーク退避（利用不可）レコード ← ワーク退避レコード
			//	wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
			//	// 明細（利用不可）レコード編集・出力 を行う。『親契約の明細（利用不可）』
			//	this.makeOutPutDtlUseFailInfo(wkUseFailRecodeMap, outputInItem);
			//}
			if(JACStrConst.USE_FAIL_APLY_WAY_CD_DTL.equals(this.tmpUseFailAplyWayCd)
							|| JACStrConst.USE_FAIL_APLY_WAY_CD_ALL.equals(this.tmpUseFailAplyWayCd))
			{
				//（　ワーク退避．月中利用不可日数（日割なし） ＞ ゼロ　）　且つ
				// 請求年月　＝　プラン課金終了年月（ワーク退避．プラン課金終了年月日の上６桁）
				if(this.wkUseFailDayCntHiwariNon.compareTo(BigDecimal.ZERO) > 0 && tmpSeikyYm.equals(planChrgEndYmd.substring(0, 6)) )
				{
					// ワーク退避（利用不可）レコード ← ワーク退避レコード
					wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
					// 明細（利用不可・日割なし）レコード編集・出力 を行う。『親契約の明細（利用不可）』
					this.makeOutPutDtlUseFailHiwariNonInfo(wkUseFailRecodeMap, outputInItem);
				}
				//（　ワーク退避．月中利用不可日数 ＞ ゼロ　）
				else if(this.wkUseFailDayCnt.compareTo(BigDecimal.ZERO) > 0)
				{
					// ワーク退避（利用不可）レコード ← ワーク退避レコード
					wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
					// 明細（利用不可）レコード編集・出力 を行う。『親契約の明細（利用不可）』
					this.makeOutPutDtlUseFailInfo(wkUseFailRecodeMap, outputInItem);
				}
			}
			// 2015/08/20 ANK-2163-00-00 MOD END
			
			// 下記(7)　中計集計用レコード編集・出力を行う。『中計集計用』
			this.makeOutPutCbriInfo(wkRecodeMap, outputInItem);
			
			// 2015/08/20 ANK-2163-00-00 DEL START
			//// （　ワーク退避．月中利用不可日数　＞　ゼロ　）　且つ
			////    （　ワーク．利用不可適用方法コード　＝　"1"（利用付加期間減額明細作成）　または
			////                                             "2"（利用期間が全日利用不可時徴収なし）　）　の場合
			//if(this.wkUseFailDayCnt.compareTo(new BigDecimal(0)) > 0
			//		&& (this.tmpUseFailAplyWayCd.equals(JACStrConst.USE_FAIL_APLY_WAY_CD_DTL)
			//				|| this.tmpUseFailAplyWayCd.equals(JACStrConst.USE_FAIL_APLY_WAY_CD_ALL)))
			//{
			//	// ワーク退避（利用不可）レコード ← ワーク退避レコード
			//	wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
			//	
			//	// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 DEL START
			//	// 下記(8)中計集計用（利用不可）レコード編集・出力を行う。『中計集計用（利用不可）』
			//	//this.makeOutPutCbriUseFailInfo(wkUseFailRecodeMap, outputInItem);
			//	// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 DEL END
			//}
			// 2015/08/20 ANK-2163-00-00 DEL END
			
			// ワーク退避．加入契約支払方式コード ≠ "003"（全戸一括）の場合
			if(!JACStrConst.KANYU_KEI_PAY_HSHK_CD_IKT.equals(kanyuKeiPayHoshikiCd))
			{
				// エラーログ出力
				super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.EAKB0250CW, new String[]{tranMap.getMap().toString()});
			}
		}
		// (e) 【マンション子契約】上記(c) 以外（ワーク退避．料金グループコードが、初期処理(5) で設定したオーナー用料金グループコード配列に存在しない場合）
		else
		{
			// 　ワーク退避．加入契約支払方式コード ＝ "001"（ベース）または"004"（住居者一括） の場合
			if(JACStrConst.KANYU_KEI_PAY_HSHK_CD_BASE.equals(kanyuKeiPayHoshikiCd)
					|| JACStrConst.KANYU_KEI_PAY_HSHK_CD_JKYO_IKT.equals(kanyuKeiPayHoshikiCd))
			{
				if(JACStrConst.KANYU_KEI_PAY_HSHK_CD_BASE.equals(kanyuKeiPayHoshikiCd) 
						|| (JACStrConst.KANYU_KEI_PAY_HSHK_CD_JKYO_IKT.equals(kanyuKeiPayHoshikiCd) && !wkRecodeMap.get(JBSbatAKIFM004.UW_PRC_SVC_CD).equals(wkInputMastRecode.get(JBSbatAKIFM004.PRC_SVC_CD))))
				{
					// （ア）明細レコード編集・出力を行う。『子契約の明細』
					this.makeOutPutDtlInfo(wkRecodeMap, outputInItem);
					
					// 2015/08/20 ANK-2163-00-00 MOD START
					// （イ）（ ワーク退避．月中利用不可日数 ＞ ゼロ ）
					//       かつ（ ワーク．利用不可適用方法コード ＝ "1"（利用不可期間減額明細作成）
					//       または "2"（利用期間が全日利用不可時徴収なし） ）の場合
					//if(this.wkUseFailDayCnt.compareTo(BigDecimal.ZERO) > 0
					//		&& (JACStrConst.USE_FAIL_APLY_WAY_CD_DTL.equals(this.tmpUseFailAplyWayCd)
					//				|| JACStrConst.USE_FAIL_APLY_WAY_CD_ALL.equals(this.tmpUseFailAplyWayCd)))
					//{
					//	// ワーク退避（利用不可）レコード ← ワーク退避レコード
					//	wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
					//	// 明細（利用不可）レコード編集・出力 を行う。『子契約の明細（利用不可）』
					//	this.makeOutPutDtlUseFailInfo(wkUseFailRecodeMap, outputInItem);
					//}
					// （イ）（ ワーク．利用不可適用方法コード ＝ "1"（利用不可期間減額明細作成）
					//       または "2"（利用期間が全日利用不可時徴収なし） ）の場合
					if(JACStrConst.USE_FAIL_APLY_WAY_CD_DTL.equals(this.tmpUseFailAplyWayCd)
									|| JACStrConst.USE_FAIL_APLY_WAY_CD_ALL.equals(this.tmpUseFailAplyWayCd))
					{
						//（　ワーク退避．月中利用不可日数（日割なし） ＞ ゼロ　）　且つ
						// 請求年月　＝　プラン課金終了年月（ワーク退避．プラン課金終了年月日の上６桁）
						if(this.wkUseFailDayCntHiwariNon.compareTo(BigDecimal.ZERO) > 0 && tmpSeikyYm.equals(planChrgEndYmd.substring(0, 6)) )
						{
							// ワーク退避（利用不可）レコード ← ワーク退避レコード
							wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
							// 明細（利用不可）レコード編集・出力 を行う。『子契約の明細（利用不可）』
							this.makeOutPutDtlUseFailHiwariNonInfo(wkUseFailRecodeMap, outputInItem);
						}
						//（　ワーク退避．月中利用不可日数 ＞ ゼロ　）
						else if(this.wkUseFailDayCnt.compareTo(BigDecimal.ZERO) > 0)
						{
							// ワーク退避（利用不可）レコード ← ワーク退避レコード
							wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
							// 明細（利用不可）レコード編集・出力 を行う。『子契約の明細（利用不可）』
							this.makeOutPutDtlUseFailInfo(wkUseFailRecodeMap, outputInItem);
						}
					}
					// 2015/08/20 ANK-2163-00-00 MOD END
				}

				// （ウ）下記(5)明細レコード編集・出力を行う。『親契約の部屋毎明細』
				// ANK-2249-00-00 ADD START
				wkRecodeMap.getMap().putAll(tranMap.getMap());
				// ANK-2249-00-00 ADD END
				wkRecodeMap.set(JBSbatAKIFM004.SEIKY_KEI_NO,		wkInputMastRecode.getString(JBSbatAKIFM004.SEIKY_KEI_NO));
				String mansionId = seikyUtil.fillString(FillType.HalfSpace, wkRecodeMap.getString(JBSbatAKIFM004.MANSION_ID), MANSION_ID_LENGTH, true);
				wkRecodeMap.set(JBSbatAKIFM004.SEIRI_NO,			mansionId);
				wkRecodeMap.set(JBSbatAKIFM004.PRC_GRP_CD,			wkInputMastRecode.getString(JBSbatAKIFM004.PRC_GRP_CD));
				wkRecodeMap.set(JBSbatAKIFM004.PAY_KEI_SKBT_CD,		JACStrConst.PAY_KEI_SKBT_CD_OWNR);
				// ANK-2249-00-00 ADD START
				wkRecodeMap.set(JBSbatAKIFM004.PCRS_CD,				wkInputMastRecode.getString(JBSbatAKIFM004.PCRS_CD));
				wkRecodeMap.set(JBSbatAKIFM004.UW_PRC_SVC_CD,		wkInputMastRecode.getString(JBSbatAKIFM004.PRC_SVC_CD));
				
				if(!JACStrConst.KARA_MOJI.equals(wkRecodeMap.getString(JBSbatAKIFM004.SEIKY_KEI_NO).trim())
								&& this.tmpMonStaDay.compareTo(wkRecodeMap.getString(JBSbatAKIFM004.PLAN_STAYMD)) > 0
								&& this.tmpMonEndDay.compareTo(this.wkInputMastRecode.getString(JBSbatAKIFM004.PLAN_CHRG_STAYMD)) >= 0
								&& this.tmpMonStaDay.compareTo(this.wkInputMastRecode.getString(JBSbatAKIFM004.PLAN_CHRG_ENDYMD)) <= 0)
				{
					// // ワーク退避．請求契約番号　≠　空文字の場合のみ
					// if(!JACStrConst.KARA_MOJI.equals(wkRecodeMap.getString(JBSbatAKIFM004.SEIKY_KEI_NO).trim()))
					// {
						this.makeOutPutDtlInfo(wkRecodeMap, outputInItem);
					// }

					// （エ）入力Ｔレコード（子契約のレコード）を元に、ワーク退避レコードに親契約のレコードを設定する。
					{
						// ワーク退避レコード ← 入力Ｔレコード
						// ワーク退避．請求契約番号        ← ワーク．入力Ｍ請求契約番号
						// ワーク退避．サービス契約番号    ← ワーク．入力Ｍサービス契約番号
						// ワーク退避．料金グループコード  ← ワーク．入力Ｍ料金グループコード
						// ワーク退避．料金コースコード    ← ワーク．入力Ｍ料金コースコード
						// ワーク退避．料金サービスコード  ← ワーク．入力Ｍ料金サービスコード
						// ワーク退避．整理番号            ← ワーク退避．マンションＩＤ
						// ワーク退避．支払契約識別コード  ← "1"（オーナー契約支払）
						// wkRecodeMap.getMap().putAll(tranMap.getMap());
						// wkRecodeMap.set(JBSbatAKIFM004.SEIKY_KEI_NO,		wkInputMastRecode.getString(JBSbatAKIFM004.SEIKY_KEI_NO));
						wkRecodeMap.set(JBSbatAKIFM004.SVC_KEI_NO,			wkInputMastRecode.getString(JBSbatAKIFM004.SVC_KEI_NO));
						// wkRecodeMap.set(JBSbatAKIFM004.PRC_GRP_CD,			wkInputMastRecode.getString(JBSbatAKIFM004.PRC_GRP_CD));
						// wkRecodeMap.set(JBSbatAKIFM004.PCRS_CD,				wkInputMastRecode.getString(JBSbatAKIFM004.PCRS_CD));
						// wkRecodeMap.set(JBSbatAKIFM004.UW_PRC_SVC_CD,		wkInputMastRecode.getString(JBSbatAKIFM004.PRC_SVC_CD));
						// String mansionIdTmp = seikyUtil.fillString(FillType.HalfSpace, wkRecodeMap.getString(JBSbatAKIFM004.MANSION_ID), MANSION_ID_LENGTH, true);
						// wkRecodeMap.set(JBSbatAKIFM004.SEIRI_NO,			mansionIdTmp);
						// wkRecodeMap.set(JBSbatAKIFM004.PAY_KEI_SKBT_CD,		JACStrConst.PAY_KEI_SKBT_CD_OWNR);
					}

					// （オ）明細レコード編集・出力　を行う。『親契約の明細』
					// ワーク退避．請求契約番号　≠　空文字の場合のみ
					// if(!JACStrConst.KARA_MOJI.equals(wkRecodeMap.getString(JBSbatAKIFM004.SEIKY_KEI_NO).trim()))
					// {
						this.makeOutPutDtlInfo(wkRecodeMap, outputInItem);
					// }

					// （カ）（　ワーク退避．加入契約支払方式コード　＝　"001"（ベース）　）　の場合のみ、未入居明細用にレコード退避する。
					if(JACStrConst.KANYU_KEI_PAY_HSHK_CD_BASE.equals(wkRecodeMap.getString(JBSbatAKIFM004.KANYU_KEI_PAY_HOSHIKI_CD)))
					{
						// ワーク未入居レコード　　　　　 ←　ワーク退避レコード
						// ワーク未入居.サービス契約番号　←　未入居明細用サービス契約番号
						// ワークマスタ．想定料金　　　　 ←　ワーク．想定料金
						// ワーク．未入居出力フラグ　　　 ←　true（有り）
						this.wkMiNyuKyo(wkRecodeMap);
					}

					// （キ）中計集計用レコード編集・出力　を行う。『中計集計用』
					// ワーク退避．請求契約番号　≠　空文字の場合のみ
					// if(!JACStrConst.KARA_MOJI.equals(wkRecodeMap.getString(JBSbatAKIFM004.SEIKY_KEI_NO).trim()))
					// {
						this.makeOutPutCbriInfo(wkRecodeMap, outputInItem);
					// }

					// 2015/08/20 ANK-2163-00-00 MOD START
					// （ク）（ワーク退避．月中利用不可日数 ＞ ゼロ）
					//        かつ（ワーク．利用不可適用方法コード ＝ "1"（利用不可期間減額明細作成）
					//        または"2"（利用期間が全日利用不可時徴収なし） ）の場合
					//if(this.wkUseFailDayCnt.compareTo(BigDecimal.ZERO) > 0
					//				&& (JACStrConst.USE_FAIL_APLY_WAY_CD_DTL.equals(this.tmpUseFailAplyWayCd)
					//								|| JACStrConst.USE_FAIL_APLY_WAY_CD_ALL.equals(this.tmpUseFailAplyWayCd)))
					//{
					//	// ワーク退避（利用不可）レコード　←　ワーク退避レコード
					//	wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
					//	// 明細（利用不可）レコード編集・出力 を行う。『親契約の明細（利用不可）』
					//	// ワーク退避．請求契約番号　≠　空文字の場合のみ
					//	// if(!JACStrConst.KARA_MOJI.equals(wkRecodeMap.getString(JBSbatAKIFM004.SEIKY_KEI_NO).trim()))
					//	// {
					//		this.makeOutPutDtlUseFailInfo(wkUseFailRecodeMap, outputInItem);
					//	// }
					//}
					// （ク） （ワーク．利用不可適用方法コード ＝ "1"（利用不可期間減額明細作成）
					//        または"2"（利用期間が全日利用不可時徴収なし） ）の場合
					if(JACStrConst.USE_FAIL_APLY_WAY_CD_DTL.equals(this.tmpUseFailAplyWayCd)
							|| JACStrConst.USE_FAIL_APLY_WAY_CD_ALL.equals(this.tmpUseFailAplyWayCd))
					{
						//（　ワーク退避．月中利用不可日数（日割なし） ＞ ゼロ　）　且つ
						// 請求年月　＝　プラン課金終了年月（ワーク退避．プラン課金終了年月日の上６桁）
						if(this.wkUseFailDayCntHiwariNon.compareTo(BigDecimal.ZERO) > 0 && tmpSeikyYm.equals(planChrgEndYmd.substring(0, 6)) )
						{
							// ワーク退避（利用不可）レコード　←　ワーク退避レコード
							wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
							// 明細（利用不可）レコード編集・出力 を行う。『親契約の明細（利用不可）』
							this.makeOutPutDtlUseFailHiwariNonInfo(wkUseFailRecodeMap, outputInItem);
						}
						//（　ワーク退避．月中利用不可日数 ＞ ゼロ　）
						else if(this.wkUseFailDayCnt.compareTo(BigDecimal.ZERO) > 0)
						{
							// ワーク退避（利用不可）レコード　←　ワーク退避レコード
							wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
							// 明細（利用不可）レコード編集・出力 を行う。『親契約の明細（利用不可）』
							// ワーク退避．請求契約番号　≠　空文字の場合のみ
							// if(!JACStrConst.KARA_MOJI.equals(wkRecodeMap.getString(JBSbatAKIFM004.SEIKY_KEI_NO).trim()))
							// {
								this.makeOutPutDtlUseFailInfo(wkUseFailRecodeMap, outputInItem);
							// }
						}
					}
					// 2015/08/20 ANK-2163-00-00 MOD END
				}
				// ANK-2249-00-00 ADD END
			}
			// 　ワーク退避．加入契約支払方式コード ＝ "003"（全戸一括） の場合
			else if(JACStrConst.KANYU_KEI_PAY_HSHK_CD_IKT.equals(kanyuKeiPayHoshikiCd))
			{
				if(!wkRecodeMap.get(JBSbatAKIFM004.UW_PRC_SVC_CD).equals(wkInputMastRecode.get(JBSbatAKIFM004.PRC_SVC_CD)))
				{
					// （ア）明細レコード編集・出力を行う。『子契約の明細』
					this.makeOutPutDtlInfo(wkRecodeMap, outputInItem);

					// 2015/08/20 ANK-2163-00-00 MOD START
					// （イ）（ ワーク退避．月中利用不可日数 ＞ ゼロ ）
					//       かつ（ ワーク．利用不可適用方法コード ＝ "1"（利用不可期間減額明細作成）
					//       または "2"（利用期間が全日利用不可時徴収なし） ）の場合
					//if(this.wkUseFailDayCnt.compareTo(BigDecimal.ZERO) > 0
					//		&& (JACStrConst.USE_FAIL_APLY_WAY_CD_DTL.equals(this.tmpUseFailAplyWayCd)
					//				|| JACStrConst.USE_FAIL_APLY_WAY_CD_ALL.equals(this.tmpUseFailAplyWayCd)))
					//{
					//	// ワーク退避（利用不可）レコード ← ワーク退避レコード
					//	wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
					//	// 明細（利用不可）レコード編集・出力 を行う。『子契約の明細（利用不可）』
					//	this.makeOutPutDtlUseFailInfo(wkUseFailRecodeMap, outputInItem);
					//}
					// （イ）（ ワーク．利用不可適用方法コード ＝ "1"（利用不可期間減額明細作成）
					//       または "2"（利用期間が全日利用不可時徴収なし） ）の場合
					if(JACStrConst.USE_FAIL_APLY_WAY_CD_DTL.equals(this.tmpUseFailAplyWayCd)
									|| JACStrConst.USE_FAIL_APLY_WAY_CD_ALL.equals(this.tmpUseFailAplyWayCd))
					{
						//（　ワーク退避．月中利用不可日数（日割なし） ＞ ゼロ　）　且つ
						// 請求年月　＝　プラン課金終了年月（ワーク退避．プラン課金終了年月日の上６桁）
						if(this.wkUseFailDayCntHiwariNon.compareTo(BigDecimal.ZERO) > 0 && tmpSeikyYm.equals(planChrgEndYmd.substring(0, 6)) )
						{
							// ワーク退避（利用不可）レコード ← ワーク退避レコード
							wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
							// 明細（利用不可）レコード編集・出力 を行う。『子契約の明細（利用不可）』
							this.makeOutPutDtlUseFailHiwariNonInfo(wkUseFailRecodeMap, outputInItem);
						}
						//（　ワーク退避．月中利用不可日数 ＞ ゼロ　）
						else if(this.wkUseFailDayCnt.compareTo(BigDecimal.ZERO) > 0)
						{
							// ワーク退避（利用不可）レコード ← ワーク退避レコード
							wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
							// 明細（利用不可）レコード編集・出力 を行う。『子契約の明細（利用不可）』
							this.makeOutPutDtlUseFailInfo(wkUseFailRecodeMap, outputInItem);
						}
					}
					// 2015/08/20 ANK-2163-00-00 MOD END
				}

				// （ウ）下記(5)明細レコード編集・出力を行う。『親契約の部屋毎明細』
				wkRecodeMap.set(JBSbatAKIFM004.SEIKY_KEI_NO,		wkInputMastRecode.getString(JBSbatAKIFM004.SEIKY_KEI_NO));
				String mansionId = seikyUtil.fillString(FillType.HalfSpace, wkRecodeMap.getString(JBSbatAKIFM004.MANSION_ID), MANSION_ID_LENGTH, true);
				wkRecodeMap.set(JBSbatAKIFM004.SEIRI_NO,			mansionId);
				wkRecodeMap.set(JBSbatAKIFM004.PRC_GRP_CD,			wkInputMastRecode.getString(JBSbatAKIFM004.PRC_GRP_CD));
				// ANK-2249-00-00 MOD START
				wkRecodeMap.set(JBSbatAKIFM004.PCRS_CD, wkInputMastRecode.getString(JBSbatAKIFM004.PCRS_CD));
				wkRecodeMap.set(JBSbatAKIFM004.UW_PRC_SVC_CD, wkInputMastRecode.getString(JBSbatAKIFM004.PRC_SVC_CD));
				
				// ワーク退避．請求契約番号　≠　空文字の場合のみ
				// if(!JACStrConst.KARA_MOJI.equals(wkRecodeMap.getString(JBSbatAKIFM004.SEIKY_KEI_NO).trim()))
				if(!JACStrConst.KARA_MOJI.equals(wkRecodeMap.getString(JBSbatAKIFM004.SEIKY_KEI_NO).trim())
								&& this.tmpMonStaDay.compareTo(wkRecodeMap.getString(JBSbatAKIFM004.PLAN_STAYMD)) > 0
								&& this.tmpMonEndDay.compareTo(this.wkInputMastRecode.getString(JBSbatAKIFM004.PLAN_CHRG_STAYMD)) >= 0
								&& this.tmpMonStaDay.compareTo(this.wkInputMastRecode.getString(JBSbatAKIFM004.PLAN_CHRG_ENDYMD)) <= 0)
				// ANK-2249-00-00 MOD END
				{
					this.makeOutPutDtlInfo(wkRecodeMap, outputInItem);
				}
			}
			// 　上記、以外（"002"（個別））の場合
			else
			{
				// （ア）明細レコード編集・出力　を行う。『子契約の明細』
				this.makeOutPutDtlInfo(wkRecodeMap, outputInItem);
				// 2015/08/20 ANK-2163-00-00 MOD START
				// （イ）（ワーク退避．月中利用不可日数 ＞ ゼロ）
				//        かつ （ワーク．利用不可適用方法コード＝"1"（利用不可期間減額明細作成） 
				//        または "2"（利用期間が全日利用不可時徴収なし）） の場合
				// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 DEL START
				//useFailDayCnt = wkRecodeMap.getBigDecimal(JBSbatAKIFM004.USE_FAIL_DAY_CNT);			// 月中利用不可日数
				// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 DEL END
				
				// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 MOD START
				//if(useFailDayCnt.compareTo(BigDecimal.ZERO) > 0
				//if(this.wkUseFailDayCnt.compareTo(BigDecimal.ZERO) > 0
				// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 MOD END
				//		&& (JACStrConst.USE_FAIL_APLY_WAY_CD_DTL.equals(this.tmpUseFailAplyWayCd)
				//				|| JACStrConst.USE_FAIL_APLY_WAY_CD_ALL.equals(this.tmpUseFailAplyWayCd)))
				//{
					// ワーク退避（利用不可）レコード ← ワーク退避レコード
				//	wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
					// 明細（利用不可）レコード編集・出力 を行う。『子契約の明細（利用不可）』
				//	this.makeOutPutDtlUseFailInfo(wkUseFailRecodeMap, outputInItem);
				//}
				// （イ） （ワーク．利用不可適用方法コード＝"1"（利用不可期間減額明細作成） 
				//        または "2"（利用期間が全日利用不可時徴収なし）） の場合
				if(JACStrConst.USE_FAIL_APLY_WAY_CD_DTL.equals(this.tmpUseFailAplyWayCd)
								|| JACStrConst.USE_FAIL_APLY_WAY_CD_ALL.equals(this.tmpUseFailAplyWayCd))
				{
					//（　ワーク退避．月中利用不可日数（日割なし） ＞ ゼロ　）　且つ
					// 請求年月　＝　プラン課金終了年月（ワーク退避．プラン課金終了年月日の上６桁）
					if(this.wkUseFailDayCntHiwariNon.compareTo(BigDecimal.ZERO) > 0 && tmpSeikyYm.equals(planChrgEndYmd.substring(0, 6)) )
					{
						// ワーク退避（利用不可）レコード ← ワーク退避レコード
						wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
						// 明細（利用不可）レコード編集・出力 を行う。『子契約の明細（利用不可）』
						this.makeOutPutDtlUseFailHiwariNonInfo(wkUseFailRecodeMap, outputInItem);
					}
					//（　ワーク退避．月中利用不可日数 ＞ ゼロ　）
					else if(this.wkUseFailDayCnt.compareTo(BigDecimal.ZERO) > 0)
					{
						// ワーク退避（利用不可）レコード ← ワーク退避レコード
						wkUseFailRecodeMap.getMap().putAll(wkRecodeMap.getMap());
						// 明細（利用不可）レコード編集・出力 を行う。『子契約の明細（利用不可）』
						this.makeOutPutDtlUseFailInfo(wkUseFailRecodeMap, outputInItem);
					}
				}
				// 2015/08/20 ANK-2163-00-00 MOD END
				// （ウ）（ワーク退避．加入契約支払方式コード ≠ （"002"（個別）））の場合
				if(!JACStrConst.KANYU_KEI_PAY_HSHK_CD_KOBETSU.equals(kanyuKeiPayHoshikiCd))
				{
					// エラーログ出力
					super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.EAKB0250CW, new String[]{tranMap.getMap().toString()});
				}
			}
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeSeikyPtaUcwkInfo]");
		return;
	}
	
	/**
	 * 未入居明細用に退避する
	 * 
	 * @param trgMap ターゲットマップ
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void wkMiNyuKyo(JBSbatServiceInterfaceMap trgMap) throws Exception
	{
		// ワーク未入居レコード　←　ワーク退避レコード
		this.wkMiNyuKyoRecode = new JBSbatServiceInterfaceMap();
		this.wkMiNyuKyoRecode.getMap().putAll(trgMap.getMap());
		
		// ワーク未入居用サービス契約番号　←　退避．未入居用サービス契約番号
		this.wkMiNyuKyoRecode.set(JBSbatAKIFM004.SVC_KEI_NO, this.tmpMiNyukyoSvcKeiNo);
		
		// ワークマスタ．想定料金
		this.wkMastSoteiAmnt = this.tmpWkSoteiAmnt;
		
		// ワーク未入居フラグ　←　true（有り）
		this.wkMiNyuKyoFlg = true;
		
	}
	
	/**
	 * 提供方式契約、回線使用契約、回線使用契約物件数を検索し
	 * 総戸数を取得する。
	 * 
	 * @param tranMap 入力Ｔ
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getTtlKosu(JBSbatServiceInterfaceMap tranMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getTtlKosu]");

		// (3)　総戸数取得
		// (a)　提供方式契約、回線使用契約、回線使用契約物件数を検索する。
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
	
		// ワーク契約キー（提供方式契約番号）
		paramList.setValue(tranMap.getString(JBSbatAKIFM004.TK_HOSHIKI_KEI_NO));

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSoKosu][param = " + paramList.getList().toString() + "]");

		// SQL実行
		executeKK_T_TK_HOSHIKI_KEI_AK_SELECT_002(paramList.getList().toArray());
		JBSbatCommonDBInterface dbMap = db_KK_T_TK_HOSHIKI_KEI.selectNext();
		
		if(dbMap != null)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getPrcKmkCd][dbMap=" + dbMap.getMap().toString() + "]");
			this.wkTtlKoSu = new BigDecimal(dbMap.getString(JBSbatKK_T_TK_HOSHIKI_KEI.TTL_KOSU));
		}
		else
		{
			this.wkTtlKoSu = BigDecimal.ZERO;
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getTtlKosu][総戸数 = " + this.wkTtlKoSu + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getTtlKosu]");
		return;
	}
	
	/**
	 * 未入居レコード出力前に想定料金の算出を行う。
	 * 作成した明細レコードを請求パターン内訳情報（マンション明細）に出力する。
	 * @param trgMap　ワーク未入居レコード
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void wkMastSoteiAmnt(JBSbatServiceInterfaceMap trgMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][wkMastSoteiAmnt]");
		
		// KEY：料金コースコード ＋ ワーク退避．内訳料金サービスコード ＋ 
		//      ワーク退避．内訳料金項目コード ＋ ワーク退避．加入契約支払方式コード ＋ ワーク退避．支払契約識別コード
		String serchKey = makeStr(trgMap.getString(JBSbatAKIFM004.PCRS_CD), 
									trgMap.getString(JBSbatAKIFM004.UW_PRC_SVC_CD), 
									trgMap.getString(JBSbatAKIFM004.UW_PRC_KMK_CD), 
									trgMap.getString(JBSbatAKIFM004.KANYU_KEI_PAY_HOSHIKI_CD), 
									trgMap.getString(JBSbatAKIFM004.PAY_KEI_SKBT_CD));
		
		this.tmpWkSoteiAmnt 		= BigDecimal.ZERO;
		
		if(this.tmpSoteiPrcMap.containsKey(serchKey))
		{
			ArrayList<JBSbatCommonDBInterface> dbList = this.tmpSoteiPrcMap.get(serchKey);
			
			// 判定条件取得
			BigDecimal hanteiDankaiKmkValue = trgMap.getBigDecimal(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE);	// ワーク退避．判定用段階決定元項目値
			for(int i = 0; i <  dbList.size(); i++)
			{
				JBSbatCommonDBInterface dbMap = dbList.get(i);
				// 配列情報[]．下限値 ≦ ワーク退避．判定用段階決定元項目値 
				// かつ 配列情報[]．上限値 ＞ ワーク退避．判定用段階決定元項目値
				// 判定条件取得
				BigDecimal lowlValue = dbMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.LOWL_VALUE);		// 配列情報[]．下限値
				BigDecimal upplValue = dbMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.UPPL_VALUE);		// 配列情報[]．上限値
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlInfo][判定用段階決定元項目値:" + hanteiDankaiKmkValue + "]");
				if(lowlValue.compareTo(hanteiDankaiKmkValue) <= 0
						&& upplValue.compareTo(hanteiDankaiKmkValue) > 0)
				{
					// 2013/05/02 料金検証障害対応【No29】マンション定額（個別）の基本料金（休止）が不一致対応 ADD START
					this.tmpWkSoteiAmnt = dbMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC);	// 想定料金
					// 2013/05/02 料金検証障害対応【No29】マンション定額（個別）の基本料金（休止）が不一致対応 ADD END
					// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 MOD START
					this.tmpWkSoteiPrc = dbMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC);	// 想定料金
					// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 MOD END
					// 想定金額算出
					this.setSoteiAmntSnst(trgMap, dbMap);
				}
			}
		}
	}
	
	/**
	 * 想定料金マスタを検索して、
	 * 料金コースコード・料金サービスコード・料金項目コード・支払契約識別コード・下限値・上限値毎に想定料金ＭＡＰを作成する。
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void makeSoteiPrcMap() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeSoteiPrcMap]");

		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
	
		// 想定料金適用開始年月日
		paramList.setValue(super.opeDate);
		// 想定料金適用終了年月日
		paramList.setValue(super.opeDate);

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeSoteiPrcMap][paramList=" + paramList.getList().toString() + "]");

		// SQL実行
		executeAK_M_SOTEI_PRC_AK_SELECT_002(paramList.getList().toArray());
		JBSbatCommonDBInterface dbMap = db_AK_M_SOTEI_PRC.selectNext();
		
		this.tmpSoteiPrcMap = new HashMap<String, ArrayList<JBSbatCommonDBInterface>>();
		ArrayList<JBSbatCommonDBInterface> dbList = new ArrayList<JBSbatCommonDBInterface>();
		
		// 取得出来た場合
		if(dbMap != null)
		{
			// KEY：料金コースコード＋料金サービスコード＋料金項目コード＋ 加入契約支払方式コード＋支払契約識別コード
			String tihKey = makeStr(dbMap.getString(JBSbatAK_M_SOTEI_PRC.PCRS_CD), 
									dbMap.getString(JBSbatAK_M_SOTEI_PRC.PRC_SVC_CD), 
									dbMap.getString(JBSbatAK_M_SOTEI_PRC.PRC_KMK_CD), 
									dbMap.getString(JBSbatAK_M_SOTEI_PRC.KANYU_KEI_PAY_HOSHIKI_CD), 
									dbMap.getString(JBSbatAK_M_SOTEI_PRC.PAY_KEI_SKBT_CD));

			// 取得件数分処理を繰り返す
			while(dbMap != null)
			{
				String key = makeStr(dbMap.getString(JBSbatAK_M_SOTEI_PRC.PCRS_CD), 
									dbMap.getString(JBSbatAK_M_SOTEI_PRC.PRC_SVC_CD), 
									dbMap.getString(JBSbatAK_M_SOTEI_PRC.PRC_KMK_CD),
									dbMap.getString(JBSbatAK_M_SOTEI_PRC.KANYU_KEI_PAY_HOSHIKI_CD), 
									dbMap.getString(JBSbatAK_M_SOTEI_PRC.PAY_KEI_SKBT_CD));
				// キーが同じ場合、リストに追加
				if(key.equals(tihKey))
				{
					dbList.add(dbMap);	// リストに追加
				}
				else
				{
					this.tmpSoteiPrcMap.put(tihKey, dbList);			// HashMapへ設定
					tihKey = key;										// 退避キーの置き換え
					dbList = new ArrayList<JBSbatCommonDBInterface>();	// 初期化
					dbList.add(dbMap);
				}
				// 次レコード取得
				dbMap = db_AK_M_SOTEI_PRC.selectNext(); 
			}
			this.tmpSoteiPrcMap.put(tihKey, dbList);	// HashMapへ設定
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeSoteiPrcMap]");
		return;
	}
	
	/**
	 * 料金スケジュール定義アクセス部品を使用してスケジュール情報を取得する。
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getSchdlInfo() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSchdlInfo]");
		
		JACbatSchdlUtil schdlUtil = new JACbatSchdlUtil(commonItem);
		try
		{
			// 請求年月
			this.tmpSeikyYm 		= schdlUtil.getBillDate(super.opeDate, JACStrConst.EVENT_CD_PRC_CALC_DAY);
			// 月初日[0] 月末日[1]
			String[] ymd 		= schdlUtil.getUseStrEnd(this.tmpSeikyYm, JACStrConst.EVENT_CD_USE_STAYMD, JACStrConst.EVENT_CD_USE_ENDYMD);
			this.tmpMonStaDay 	= ymd[0];
			this.tmpMonEndDay 	= ymd[1];
			// 料金計算日
			this.tmpEventYmd 	= schdlUtil.getUseStrEnd(this.tmpSeikyYm, JACStrConst.EVENT_CD_USE_STAYMD, JACStrConst.EVENT_CD_PRC_CALC_DAY)[1];
			// 請求年月の暦日数
			this.tmpCalDay 		= new BigDecimal(JBSbatDateUtil.dayDiff(this.tmpMonEndDay, this.tmpMonStaDay, DIFF_NAI_FLG));
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][請求年月=" + this.tmpSeikyYm + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][月初日=" + this.tmpMonStaDay + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][月末日=" + this.tmpMonEndDay + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][料金計算日=" + this.tmpEventYmd + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSchdlInfo][請求年月の暦日数=" + this.tmpCalDay + "]");
		}
		finally
		{
			schdlUtil.close();
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getSchdlInfo]");
		return;
	}
	
	/**
	 * 業務パラメータ管理から値を取得します。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void getWorkPara() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getWorkPara]");
		
		// 業務パラメータ取得
		JACbatParamUtil paramUtil = new JACbatParamUtil(commonItem);
		try
		{
			// 利用不可期間減額用存在チェックレベルコード
			this.tmpRfkgySzchkLvCd 	= paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AK_RFKGY_SZCHK_LV_CD);
			// 利用不可期間減額用金額チェックレベルコード
			this.tmpRfkgyAmchkLvCd 	= paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AK_RFKGY_AMCHK_LV_CD);
			
			// オーナー用グループコード取得
			String[] groupCdCubic = paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AC_OWNR_PRC_GRP_CD).split(JACStrConst.SEMI_COLON);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][groupCdCubic:" + groupCdCubic[0] + "]");
			
			this.tmpGoupCdList = new ArrayList<String>();
			
			for(String groupCd : groupCdCubic)
			{
				this.tmpGoupCdList.add(groupCd);
			}
			// 業務機能識別コード_料金項目コード（マンション定額料金計算）
			this.tmpWorkKinoSkbtCd = paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AC_WKS_MAN_TGPRC);
			
			// 未入居明細用サービス契約番号
			this.tmpMiNyukyoSvcKeiNo = paramUtil.getGyoumuParameter(JACStrConst.WKPAR_AC_MINYUKYO_SVCKEINO);
			
			// マンションID明細料金項目コード変換表
			this.tmpManidCnvMapWkCd = paramUtil.getGyoumuParameter(JACStrConst.WKPAR_AC_WKS_MANID_CNVMAP);
		}
		finally
		{
			paramUtil.close();
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getWorkPara][利用不可期間減額用存在チェックレベルコード = " + this.tmpRfkgySzchkLvCd  + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getWorkPara][利用不可期間減額用金額チェックレベルコード = " + this.tmpRfkgyAmchkLvCd + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getWorkPara][オーナー用グループコード = " + this.tmpGoupCdList.toString() + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getWorkPara][料金項目コード（マンション定額料金計算） = " + this.tmpWorkKinoSkbtCd + "]");
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getWorkPara]");
		return;
	}
	
	/**
	 *  マンションＩＤ中計用の料金項目コードを取得する。
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getPrcKmkCd() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getPrcKmkCd]");

		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
	
		// システムコード
		paramList.setValue(JACStrConst.SYS_CD_AC);
		// 業務機能識別コード
		paramList.setValue(this.tmpWorkKinoSkbtCd);
		// 抽出変換コード
		paramList.setValue(JACStrConst.CHSHT_CHG_CD_CST);
		// 料金項目抽出変換適用開始年月日
		paramList.setValue(super.opeDate);
		// 料金項目抽出変換適用終了年月日
		paramList.setValue(super.opeDate);

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getPrcKmkCd][param = " + paramList.getList().toString() + "]");

		// SQL実行
		executeCH_M_PRC_KMK_CS_CHGE_AK_SELECT_001(paramList.getList().toArray());
		JBSbatCommonDBInterface dbMap = db_CH_M_PRC_KMK_CS_CHGE.selectNext();
		
		if(dbMap != null)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getPrcKmkCd][dbMap=" + dbMap.getMap().toString() + "]");
			this.tmpPrcKmkCd = dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PRC_KMK_CD);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getPrcKmkCd]");
		return;
	}
	
	/**
	 * ワーク退避．サービス休止課金開始年月日、サービス休止解除年月日、休止中断コードを元に休止判定を行う。
	 * （ワーク．想定料金、ワーク．利用不可適用方法コード、ワーク退避．内訳料金項目コードの設定を行う。)
	 * @param wkRecodeMap　ワーク退避レコード
	 * @param dbMap  想定料金マップ.配列情報[]
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void setPauseJdg(JBSbatServiceInterfaceMap wkRecodeMap, JBSbatCommonDBInterface dbMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isPauseJdg]");
		
		// （ア）（ ワーク退避．サービス休止課金開始年月日 ＝ （空） または ＝ 空白 ） の場合
		// 判定条件取得
		String svcPauseChrgStaYmd 	= wkRecodeMap.getString(JBSbatAKIFM004.SVC_PAUSE_CHRG_STA_YMD);		// サービス休止課金開始年月日
		String svcPauseRlsYmd 		= wkRecodeMap.getString(JBSbatAKIFM004.SVC_PAUSE_RLS_YMD);			// サービス休止解除年月日
		String pauseStpCd 			= wkRecodeMap.getString(JBSbatAKIFM004.PAUSE_STP_CD);				// 休止中断コード
		BigDecimal soteiPausePrc 	= dbMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PAUSE_PRC);		// 想定休止料金
			
		if(JACStrConst.KARA_MOJI.equals(svcPauseChrgStaYmd.trim()))
		{
			// ワーク．想定料金               ← 配列情報[]．想定料金
			// ワーク．利用不可適用方法コード ← 配列情報[]．利用不可適用方法コード
			this.tmpWkSoteiAmnt 		= dbMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC);
			this.tmpUseFailAplyWayCd 	= dbMap.getString(JBSbatAK_M_SOTEI_PRC.USE_FAIL_APLY_WAY_CD);
		}
		
		// （イ）（ワーク退避．サービス休止課金開始年月日≠（空）かつ≠空白）
		// かつ（ワーク退避．サービス休止解除年月日＝（空）または＝空白）の場合
		else if(JACStrConst.KARA_MOJI.equals(svcPauseRlsYmd.trim()))
		{
			// （?）（ワーク退避．サービス休止課金開始年月日 ≦ ワーク．月末日 ）
			//        かつ（ワーク退避．休止中断コード＝"00"（休止中(SOD未発行)）
			//        または ワーク退避．休止中断コード＝"01"（休止中(SOD発行済)））
			//        かつ（配列情報[]．想定休止料金≠（空） ）の場合
			if(svcPauseChrgStaYmd.compareTo(this.tmpMonEndDay) <= 0
					&& (JACStrConst.PAUSE_STP_CD_PAUSE_SOD_MI.equals(pauseStpCd)
						|| JACStrConst.PAUSE_STP_CD_PAUSE_SOD_ZUMI.equals(pauseStpCd))
					&& soteiPausePrc != null)
			{
				// ワーク．想定料金               ← 配列情報[]．想定休止料金
				// ワーク．利用不可適用方法コード ← 配列情報[]．休止利用不可適用方法コード
				// ワーク退避．内訳料金項目コード ← 配列情報[]．想定休止料金項目コード
				this.tmpWkSoteiAmnt 		= soteiPausePrc;
				this.tmpUseFailAplyWayCd 	= dbMap.getString(JBSbatAK_M_SOTEI_PRC.PAUSE_USE_FAIL_APLY_WAY_CD);
				wkRecodeMap.set(JBSbatAKIFM004.UW_PRC_KMK_CD, dbMap.getString(JBSbatAK_M_SOTEI_PRC.SOTEI_PAUSE_PRC_KMK_CD));
			}
			//（?）上記（?）以外の場合
			else
			{
				// ワーク．想定料金               ← 配列情報[]．想定料金
				// ワーク．利用不可適用方法コード ← 配列情報[]．利用不可適用方法コード
				this.tmpWkSoteiAmnt 		= dbMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC);
				this.tmpUseFailAplyWayCd 	= dbMap.getString(JBSbatAK_M_SOTEI_PRC.USE_FAIL_APLY_WAY_CD);
			}
		}
		// （ウ）（ワーク退避．サービス休止課金開始年月日 ≠ （空）かつ≠空白）
		//       かつ（ワーク退避．サービス休止解除年月日 ≠ （空）かつ≠空白）の場合
		else
		{
			
			//（?）（ワーク退避．サービス休止課金開始年月日 ≦ ワーク．月末日
			//       かつ ワーク退避．サービス休止解除年月日 ＞ ワーク．月末日）
			//       かつ （ワーク退避．休止中断コード＝"00"（休止中(SOD未発行)） 
			//       または ワーク退避．休止中断コード＝"01"（休止中(SOD発行済)））
			//       かつ（配列情報[]．想定休止料金≠（空））の場合
			if((svcPauseChrgStaYmd.compareTo(this.tmpMonEndDay) <= 0
						&& svcPauseRlsYmd.compareTo(this.tmpMonEndDay) > 0)
					&& (JACStrConst.PAUSE_STP_CD_PAUSE_SOD_MI.equals(pauseStpCd)
							|| JACStrConst.PAUSE_STP_CD_PAUSE_SOD_ZUMI.equals(pauseStpCd))
					&& soteiPausePrc != null)
			{
				// ワーク．想定料金               ← 配列情報[]．想定休止料金
				// ワーク．利用不可適用方法コード ← 配列情報[]．休止利用不可適用方法コード
				// ワーク退避．内訳料金項目コード ← 配列情報[]．想定休止料金項目コード
				this.tmpWkSoteiAmnt 		= soteiPausePrc;
				this.tmpUseFailAplyWayCd 	= dbMap.getString(JBSbatAK_M_SOTEI_PRC.PAUSE_USE_FAIL_APLY_WAY_CD);
				wkRecodeMap.set(JBSbatAKIFM004.UW_PRC_KMK_CD, dbMap.getString(JBSbatAK_M_SOTEI_PRC.SOTEI_PAUSE_PRC_KMK_CD));
			}
			// （?）上記（?）以外の場合
			else
			{
				// ワーク．想定料金               ← 配列情報[]．想定料金
				// ワーク．利用不可適用方法コード ← 配列情報[]．利用不可適用方法コード
				this.tmpWkSoteiAmnt 		= dbMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC);
				this.tmpUseFailAplyWayCd 	= dbMap.getString(JBSbatAK_M_SOTEI_PRC.USE_FAIL_APLY_WAY_CD);
			}
		}
		// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 MOD START
		// 既存障害の暫定対応
		this.tmpWkSoteiPrc = this.tmpWkSoteiAmnt;	// ワーク．想定料金に取得した値を設定
		// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 MOD END
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPauseJdg][ワーク．利用不可適用方法コード:" + this.tmpUseFailAplyWayCd + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isPauseJdg]");

		return;
	}
	
	/**
	 * 配列情報[]．日割要否、丸め方法コードの設定に従い、ワーク．想定金額を算出する。
	 * @param wkRecodeMap　ワーク退避レコード
	 * @param dbMap  想定料金マップ.配列情報[]
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void setSoteiAmntSnst(JBSbatServiceInterfaceMap wkRecodeMap, JBSbatCommonDBInterface dbMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isPauseJdg]");
		
		// （ア）配列情報[]．日割要否 ＝ "1"（日割なし） の場合
		// 判定条件取得
		String hiwariYh = dbMap.getString(JBSbatAK_M_SOTEI_PRC.HIWARI_YH);		// 日割要否
		// 2013/05/02 料金検証障害対応【No29】マンション定額（個別）の基本料金（休止）が不一致対応 DEL START
		//this.tmpWkSoteiAmnt = dbMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.SOTEI_PRC);	// 想定料金
		// 2013/05/02 料金検証障害対応【No29】マンション定額（個別）の基本料金（休止）が不一致対応 DEL END
		if(JACStrConst.HIWARI_YH_NON.equals(hiwariYh))
		{
			// ワーク．想定金額　←　ワーク．想定料金（そのまま）
		}
		// （イ）上記（ア）以外（"2"（日割あり）） の場合
		else if(JACStrConst.HIWARI_YH_ARI.equals(hiwariYh))
		{
			BigDecimal useDayCnt = wkRecodeMap.getBigDecimal(JBSbatAKIFM004.USE_DAY_CNT);		// 月中利用日数
			// ワーク．想定金額 ← ワーク．想定料金 × ワーク退避．月中利用日数 ÷ ワーク．暦日数
			this.tmpWkSoteiAmnt = this.tmpWkSoteiAmnt.multiply(useDayCnt).divide(this.tmpCalDay, 5, BigDecimal.ROUND_HALF_EVEN);

		}
		// （ウ）端数処理
		{
			String roundWayCd = dbMap.getString(JBSbatAK_M_SOTEI_PRC.ROUND_WAY_CD);
			// （?）配列情報[]．丸め方法コード ＝ "1"（四捨五入） の場合
			// （?）配列情報[]．丸め方法コード ＝ "2"（切上げ）   の場合
			// （?）配列情報[]．丸め方法コード ＝ "3"（切捨て）   の場合
			// （?）上記（?）〜（?）以外（"0"（丸めなし））     の場合
			// 小数点第三位で四捨五入を行う。
			this.tmpWkSoteiAmnt = JACbatRknBusinessUtil.round(roundWayCd, this.tmpWkSoteiAmnt, 2);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isPauseJdg]");
		return;
	}

	/**
	 * ワーク退避レコードを対象に、想定金額を算出・編集した明細レコードを作成する。
	 * 作成した明細レコードを請求パターン内訳情報（マンション明細）に出力する。
	 * @param wkRecodeMap　ワーク退避レコード
	 * @param outputInItem  出力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void makeOutPutDtlInfo(JBSbatServiceInterfaceMap wkRecodeMap, JBSbatOutputItem outputInItem) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOutPutDtlInfo]");
		
		// (a) 想定金額算出（マンション定額）
		// 想定料金マスタ検索
		// KEY：料金コースコード ＋ ワーク退避．内訳料金サービスコード ＋ 
		//      ワーク退避．内訳料金項目コード＋ ワーク退避．加入契約支払方式コード ＋ ワーク退避．支払契約識別コード
		String serchKey = makeStr(wkRecodeMap.getString(JBSbatAKIFM004.PCRS_CD), 
									wkRecodeMap.getString(JBSbatAKIFM004.UW_PRC_SVC_CD), 
									wkRecodeMap.getString(JBSbatAKIFM004.UW_PRC_KMK_CD), 
									wkRecodeMap.getString(JBSbatAKIFM004.KANYU_KEI_PAY_HOSHIKI_CD), 
									wkRecodeMap.getString(JBSbatAKIFM004.PAY_KEI_SKBT_CD));
		
		this.tmpWkSoteiAmnt 		= BigDecimal.ZERO;
		this.tmpUseFailAplyWayCd 	= JACStrConst.KARA_MOJI; 
		
		if(this.tmpSoteiPrcMap.containsKey(serchKey))
		{
			ArrayList<JBSbatCommonDBInterface> dbList = this.tmpSoteiPrcMap.get(serchKey);
			// 判定条件取得
			BigDecimal hanteiDankaiKmkValue = wkRecodeMap.getBigDecimal(JBSbatAKIFM004.HANTEI_DANKAI_KMK_VALUE);	// ワーク退避．判定用段階決定元項目値
			for(int i = 0; i <  dbList.size(); i++)
			{
				JBSbatCommonDBInterface dbMap = dbList.get(i);
				// 配列情報[]．下限値 ≦ ワーク退避．判定用段階決定元項目値 
				// かつ 配列情報[]．上限値 ＞ ワーク退避．判定用段階決定元項目値
				// 判定条件取得
				BigDecimal lowlValue = dbMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.LOWL_VALUE);		// 配列情報[]．下限値
				BigDecimal upplValue = dbMap.getBigDecimal(JBSbatAK_M_SOTEI_PRC.UPPL_VALUE);		// 配列情報[]．上限値
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlInfo][判定用段階決定元項目値:" + hanteiDankaiKmkValue + "]");
				if(lowlValue.compareTo(hanteiDankaiKmkValue) <= 0
						&& upplValue.compareTo(hanteiDankaiKmkValue) > 0)
				{
					// 休止判定
					this.setPauseJdg(wkRecodeMap, dbMap);
					// 想定金額算出
					this.setSoteiAmntSnst(wkRecodeMap, dbMap);
				}
			}
		}
		
		// マンションＩＤ明細料金項目コード変換
		String svcKeiNoMst 	= this.wkInputMastRecode.getString(JBSbatAKIFM004.SVC_KEI_NO);;		// ワーク入力Ｍ．サービス契約番号
		String svcKeiNo 	= wkRecodeMap.getString(JBSbatAKIFM004.SVC_KEI_NO);					// サービス契約番号
		String uwPrcSvcCd 	= wkRecodeMap.getString(JBSbatAKIFM004.UW_PRC_SVC_CD);				// 内訳料金サービスコード
		String uwPrcKmkCd 	= wkRecodeMap.getString(JBSbatAKIFM004.UW_PRC_KMK_CD);				// 内訳料金項目コード
		// サービス契約番号　＝　ワーク入力Ｍ．サービス契約番号
		// かつ　内訳料金サービスコード　≠　空白　　の場合
		if(svcKeiNo.equals(svcKeiNoMst) && !JACStrConst.PRC_SVC_CD_SP.equals(uwPrcSvcCd))
		{
			// 出力情報と料金項目コードよりマップ検索キーを生成します。
			ArrayList<String> mapKey = createMapKey(wkRecodeMap);
			// マップより変換後の料金項目コードを取得します。
			JBSbatCommonDBInterface dbMap = manidCnvMap.get(mapKey);
			if (dbMap != null)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlInfo][マンションID明細料金項目コード変換マップに存在したため、置換]");
				// 出力料金項目コードを返却する
				uwPrcKmkCd =  dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.OUT_PRC_KMK_CD);
			}
		}

		// 請求パターン内訳情報（マンション明細）編集・出力
		{
			// ワーク退避．想定金額　←　ワーク．想定金額
			wkRecodeMap.set(JBSbatAKIFM004.SOTEI_AMNT, this.tmpWkSoteiAmnt);
			this.makeOutputInfo(wkRecodeMap, outputInItem, uwPrcKmkCd);
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOutPutDtlInfo]");
		
		return;
	}
	
	/**
	 * マンションID明細料金項目コード変換マップ検索用のキーを生成します。
	 * @param wkRecodeMap 料金項目抽出変換出力結果
	 * @return マップ検索用キーリスト
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private ArrayList<String> createMapKey(JBSbatServiceInterfaceMap wkRecodeMap) throws Exception
	{
		ArrayList<String> keyList = new ArrayList<String>();
		keyList.add(wkRecodeMap.getString(JBSbatAKIFM004.PRC_GRP_CD));			// 料金グループコード
		keyList.add(wkRecodeMap.getString(JBSbatAKIFM004.PCRS_CD));				// 料金コースコード
		keyList.add(wkRecodeMap.getString(JBSbatAKIFM004.UW_PRC_SVC_CD));		// 内訳料金サービスコード
		keyList.add(wkRecodeMap.getString(JBSbatAKIFM004.UW_PRC_KMK_CD));		// 内訳料金項目コード
		return keyList;
	}
	
	/**
	 * マンションID明細料金項目コード変換マップ検索用のキーを生成します。
	 * @param dbMap 料金項目抽出変換出力結果
	 * @return マップ検索用キーリスト
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private ArrayList<String> createMapKey(JBSbatCommonDBInterface dbMap) throws Exception
	{
		ArrayList<String> keyList = new ArrayList<String>();
		keyList.add(dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PRC_GRP_CD));	// 料金グループコード
		keyList.add(dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PCRS_CD));		// 料金コースコード
		keyList.add(dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PRC_SVC_CD));	// 料金サービスコード
		keyList.add(dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PRC_KMK_CD));	// 料金項目コード
		return keyList;
	}
	
	/**
	 * ワーク退避（利用不可）レコードを対象に、利用不可期間減額の想定金額を算出・編集した明細レコードを作成する。
	 * 作成した明細レコードを請求パターン内訳情報（マンション明細）に出力する。想定金額の算出には、(3) にて設定したワーク．想定料金を使用する。
	 * @param wkUseFailRecodeMap　ワーク退避（利用不可）レコード
	 * @param outputInItem  出力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void makeOutPutDtlUseFailInfo(JBSbatServiceInterfaceMap wkUseFailRecodeMap, JBSbatOutputItem outputInItem) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOutPutDtlUseFailInfo]");
		
		// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 ADD START
		// ワーク．想定金額
		BigDecimal wkSoteiAmt = BigDecimal.ZERO;
		// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 ADD END
		
		// (a) 利用不可期間減額の算出
		{
			BigDecimal useFailDayCnt = wkUseFailRecodeMap.getBigDecimal(JBSbatAKIFM004.USE_FAIL_DAY_CNT);	// ワーク退避（利用不可）．月中利用不可日数
			// ワーク．想定金額 ← ワーク．想定料金 × ワーク退避（利用不可）．月中利用不可日数 ÷ ワーク．暦日数 × -1（端数は小数点第三位で切下げる）
			// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 MOD START
			//this.tmpWkSoteiAmnt = this.tmpWkSoteiAmnt.multiply(useFailDayCnt).divide(this.tmpCalDay, 5, BigDecimal.ROUND_HALF_EVEN);
			//this.tmpWkSoteiAmnt = JACbatRknBusinessUtil.round(JACStrConst.ROUND_UP, this.tmpWkSoteiAmnt, 2).multiply(MINUS_ONE);
			wkSoteiAmt = this.tmpWkSoteiPrc.multiply(useFailDayCnt).divide(this.tmpCalDay, 5, BigDecimal.ROUND_HALF_EVEN);
			wkSoteiAmt = JACbatRknBusinessUtil.round(JACStrConst.ROUND_UP, wkSoteiAmt, 2).multiply(MINUS_ONE);
			// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 MOD END
		}
		// (b) 請求パターン内訳情報（マンション明細）編集・出力（利用不可期間減額）
		{
			// ワーク退避（利用不可）．想定金額                 ← ワーク．想定金額
			// ワーク退避（利用不可）．内訳料金項目コード       ← ワーク退避（利用不可）．内訳料金項目コードの下3桁目を"7"（利用不可期間減額）に置換したコード
			// ワーク退避（利用不可）．存在チェックレベルコード ← ワーク．利用不可期間減額用存在チェックレベルコード（初期処理(5) にて取得済み）
			// ワーク退避（利用不可）．金額チェックレベルコード ← ワーク．利用不可期間減額用金額チェックレベルコード（初期処理(5) にて取得済み）
			String uwPrcKmkCd = wkUseFailRecodeMap.getString(JBSbatAKIFM004.UW_PRC_KMK_CD);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][ワーク退避（利用不可）．内訳料金項目コード置換前=" + uwPrcKmkCd + "]");
			uwPrcKmkCd = makeStr(uwPrcKmkCd.substring(0, uwPrcKmkCd.length() - 3), JACStrConst.PRC_KMK_CD_RFKGY, uwPrcKmkCd.substring(uwPrcKmkCd.length() - 2));
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailInfo][ワーク退避（利用不可）．内訳料金項目コード置換後=" + uwPrcKmkCd + "]");
			
			// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 MOD START
			//wkUseFailRecodeMap.set(JBSbatAKIFM004.SOTEI_AMNT,		this.tmpWkSoteiAmnt);
			wkUseFailRecodeMap.set(JBSbatAKIFM004.SOTEI_AMNT,		wkSoteiAmt);
			// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 MOD END
			wkUseFailRecodeMap.set(JBSbatAKIFM004.SONZAI_CHK_LV_CD,	this.tmpRfkgySzchkLvCd);
			wkUseFailRecodeMap.set(JBSbatAKIFM004.AMNT_CHK_LV_CD,	this.tmpRfkgyAmchkLvCd);
			
			// 請求パターン内訳情報（マンション明細）編集・出力（利用不可期間減額）
			this.makeOutputInfo(wkUseFailRecodeMap, outputInItem, uwPrcKmkCd);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOutPutDtlUseFailInfo]");

		return;
	}
	
	// 2015/08/20 ANK-2163-00-00 ADD START
	/**
	 * ワーク退避（利用不可）レコードを対象に、利用不可期間減額の想定金額を算出・編集した明細レコードを作成する。
	 * 作成した明細レコードを請求パターン内訳情報（マンション明細）に出力する。想定金額の算出には、(5) にて設定したワーク．想定料金を使用する。
	 * @param wkUseFailRecodeMap　ワーク退避（利用不可）レコード
	 * @param outputInItem  出力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void makeOutPutDtlUseFailHiwariNonInfo(JBSbatServiceInterfaceMap wkUseFailRecodeMap, JBSbatOutputItem outputInItem) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOutPutDtlUseFailHiwariNonInfo]");
		
		// ワーク．想定金額
		BigDecimal wkSoteiAmt = BigDecimal.ZERO;
		
		// (a) 利用不可期間減額（日割なし）の算出
		{
			BigDecimal useFailDayCntHN = wkUseFailRecodeMap.getBigDecimal(JBSbatAKIFM004.USE_FAIL_DAY_CNT_HIWARI_NON);	// ワーク退避（利用不可）．月中利用不可日数（日割なし）
			// ワーク．想定金額 ← ワーク．想定料金 × ワーク退避（利用不可）．月中利用不可日数（日割なし） ÷ ワーク．暦日数 × -1（端数は小数点第三位で切上げる）
			wkSoteiAmt = this.tmpWkSoteiPrc.multiply(useFailDayCntHN).divide(this.tmpCalDay, 5, BigDecimal.ROUND_HALF_EVEN);
			wkSoteiAmt = JACbatRknBusinessUtil.round(JACStrConst.ROUND_UP, wkSoteiAmt, 2).multiply(MINUS_ONE);
		}
		// (b) 請求パターン内訳情報（マンション明細）編集・出力（利用不可期間減額）
		{
			// ワーク退避（利用不可）．想定金額                 ← ワーク．想定金額
			// ワーク退避（利用不可）．内訳料金項目コード       ← ワーク退避（利用不可）．内訳料金項目コードの下3桁目を"7"（利用不可期間減額）に置換したコード
			// ワーク退避（利用不可）．存在チェックレベルコード ← ワーク．利用不可期間減額用存在チェックレベルコード（初期処理(5) にて取得済み）
			// ワーク退避（利用不可）．金額チェックレベルコード ← ワーク．利用不可期間減額用金額チェックレベルコード（初期処理(5) にて取得済み）
			String uwPrcKmkCd = wkUseFailRecodeMap.getString(JBSbatAKIFM004.UW_PRC_KMK_CD);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailHiwariNonInfo][ワーク退避（利用不可）．内訳料金項目コード置換前=" + uwPrcKmkCd + "]");
			uwPrcKmkCd = makeStr(uwPrcKmkCd.substring(0, uwPrcKmkCd.length() - 3), JACStrConst.PRC_KMK_CD_RFKGY, uwPrcKmkCd.substring(uwPrcKmkCd.length() - 2));
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeOutPutDtlUseFailHiwariNonInfo][ワーク退避（利用不可）．内訳料金項目コード置換後=" + uwPrcKmkCd + "]");
			
			wkUseFailRecodeMap.set(JBSbatAKIFM004.SOTEI_AMNT,		wkSoteiAmt);
			wkUseFailRecodeMap.set(JBSbatAKIFM004.SONZAI_CHK_LV_CD,	this.tmpRfkgySzchkLvCd);
			wkUseFailRecodeMap.set(JBSbatAKIFM004.AMNT_CHK_LV_CD,	this.tmpRfkgyAmchkLvCd);
			
			// 請求パターン内訳情報（マンション明細）編集・出力（利用不可期間減額）
			this.makeOutputInfo(wkUseFailRecodeMap, outputInItem, uwPrcKmkCd);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOutPutDtlUseFailHiwariNonInfo]");

		return;
	}
	// 2015/08/20 ANK-2163-00-00 ADD END
	
	/**
	 * ワーク退避レコードの以下の項目を編集して中計集計用レコードとする。中計集計用レコードを請求パターン内訳情報（中計集計用）に編集し出力する。
	 * @param wkRecodeMap　ワーク退避レコード
	 * @param outputInItem  出力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void makeOutPutCbriInfo(JBSbatServiceInterfaceMap wkRecodeMap, JBSbatOutputItem outputInItem) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOutPutCbriInfo]");
		// (a) 請求パターン内訳情報（中計集計用）編集・出力
		{
			// ワーク退避．内訳料金サービスコード 
			// ワーク退避．内訳料金項目コード ← ワーク．料金項目コード（初期処理(6) にて取得済みのマンションＩＤ中計用の料金項目コード）
			// 出力レコード ← ワーク退避レコード
			wkRecodeMap.set(JBSbatAKIFM004.UW_PRC_SVC_CD, JACStrConst.PRC_SVC_CD_SP);
			wkRecodeMap.set(JBSbatAKIFM004.UW_PRC_KMK_CD, this.tmpPrcKmkCd);
			// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 ADD START
			// 想定金額の小数点第一位で切捨てを行う。
			this.tmpWkSoteiAmnt = JACbatRknBusinessUtil.round(JACStrConst.ROUND_DOWN, this.tmpWkSoteiAmnt, 0);
			wkRecodeMap.set(JBSbatAKIFM004.SOTEI_AMNT , this.tmpWkSoteiAmnt);
			// 2013/05/15 料金検証障害対応【No42】中間集計用利用不可レコードの非出力化・端数なし化対応 ADD END
			this.makeOutputShukInfo(wkRecodeMap, outputInItem);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOutPutCbriInfo]");
		return;
	}
	
	/**
	 * ワーク退避（利用不可）レコードの以下の項目を編集して中計集計用（利用不可）レコードとする。
	 * @param wkUseFailRecodeMap　ワーク退避（利用不可）レコード
	 * @param outputInItem  出力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void makeOutPutCbriUseFailInfo(JBSbatServiceInterfaceMap wkUseFailRecodeMap, JBSbatOutputItem outputInItem) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOutPutCbriUseFailInfo]");
		// (a) 請求パターン内訳情報（中計集計用）編集・出力
		{
			// ワーク退避．内訳料金サービスコード 
			// ワーク退避（利用不可）．内訳料金項目コード ← ワーク．料金項目コード（初期処理(6) にて取得済みのマンションＩＤ中計用の料金項目コード）の
			// 下3桁目を"7"に置換したコード
			//出力レコード ← ワーク退避レコード
			wkUseFailRecodeMap.set(JBSbatAKIFM004.UW_PRC_SVC_CD, JACStrConst.PRC_SVC_CD_SP);
			String uwPrcKmkCd = makeStr(this.tmpPrcKmkCd.substring(0, this.tmpPrcKmkCd.length() - 3), 
										JACStrConst.PRC_KMK_CD_RFKGY, 
										this.tmpPrcKmkCd.substring(this.tmpPrcKmkCd.length() - 2));

			wkUseFailRecodeMap.set(JBSbatAKIFM004.UW_PRC_KMK_CD, uwPrcKmkCd);
			this.makeOutputShukInfo(wkUseFailRecodeMap, outputInItem);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOutPutCbriUseFailInfo]");
		return;
	}
	
	/**
	 * 請求パターン内訳情報出力します。
	 * @param wkMap ワーク退避レコード
	 * @param outputInItem  出力情報
	 * @param uwPrcKmkCd 内訳料金項目コード
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void makeOutputInfo(JBSbatServiceInterfaceMap wkMap, JBSbatOutputItem outputInItem, String uwPrcKmkCd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOutputInfo]");
		
		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();
		// 入力電文コピー
		outMap.getMap().putAll(wkMap.getMap());
		outMap.setString(JBSbatAKIFM004.UW_PRC_KMK_CD, uwPrcKmkCd);
		// 出力フラグ設定
		outMap.setOutFlg(true);
		
		outputInItem.addOutMapList(outMap);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOutputInfo]");

		return;
	}
	
	/**
	 * 請求パターン内訳情報出力します。
	 * @param wkMap ワーク退避レコード
	 * @param outputInItem  出力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void makeOutputShukInfo(JBSbatServiceInterfaceMap wkMap, JBSbatOutputItem outputInItem) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOutputShukInfo]");
		
		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();
		// 入力電文コピー
		outMap.getMap().putAll(wkMap.getMap());
		// 出力フラグ設定
		outMap.setOutFlg(true);
		
		outputInItem.addOutMapList_2(outMap);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOutputShukInfo]");

		return;
	}
	
	/**
	 * 料金項目抽出変換スキーマを参照し、
	 * マンションID明細料金項目コード変換マップを生成します。
	 * 
	 * @throws Exception
	 */
	private void createManidCnvMap() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][createManidCnvMap]");
		
		// 結果返却用マップ
		HashMap<ArrayList<String>, JBSbatCommonDBInterface> retMap = new HashMap<ArrayList<String>, JBSbatCommonDBInterface>();
		
		// 料金項目抽出変換マスタ検索用のキーパラメータを生成する
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(JACStrConst.SYS_CD_AC);			// システムコード
		paramList.setValue(this.tmpManidCnvMapWkCd);					// 業務機能識別コード
		paramList.setValue(JACStrConst.CHSHT_CHG_CD_2);	// 抽出変換コード
		paramList.setValue(super.opeDate);				// バッチ運用日
		paramList.setValue(super.opeDate);				// バッチ運用日
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][createManidCnvMap][paramList=" + paramList.getList().toString() + "]");

		// SQL実行
		executeCH_M_PRC_KMK_CS_CHGE_AK_SELECT_001(paramList.getList().toArray());
		JBSbatCommonDBInterface dbMap =  db_CH_M_PRC_KMK_CS_CHGE.selectNext();
		
		this.manidCnvMap = new HashMap<ArrayList<String>, JBSbatCommonDBInterface>();
		
		// 取得結果をマップに格納する
		while(null != dbMap)
		{
			// グループ、コース、サービス、料金項目でキーを生成する
			ArrayList<String> mapKey = createMapKey(dbMap);
			// キー単位に抽出結果を格納する
			this.manidCnvMap.put(mapKey, dbMap);
			// 次のレコードを読み込む
			dbMap =  db_CH_M_PRC_KMK_CS_CHGE.selectNext();
		}
		assert this.manidCnvMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][createManidCnvMap]マスタ取得件数：" + this.manidCnvMap.size()) : true;
		
		// マップを返却する
		return ;
	}
	
	/**
	 * 文字を連結します
	 * @param  string 文字
	 * @return strBuf 連結した文字列
	 */
	private String makeStr(String ...string)
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeStr]");
		
		StringBuffer strBuf = new StringBuffer();
		for(String str:string)
		{
			if(str == null)
			{
				strBuf.append(JACStrConst.KARA_MOJI);
			}
			else
			{
				strBuf.append(str);
			}
		}
		
		assert strBuf != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][strBuf][strBuf = " + strBuf.toString() + "]") : true;
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeStr]");
		
		return strBuf.toString();
	}
	
	/**▲▲▲▲▲▲メソッド追加 終了▲▲▲▲▲▲*/
	

	

}