/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatACMansTegakPrc
*	ソースファイル名	：JBSbatACMansTegakPrc.java
*	作成者				：富士通　
*	作成日				：2012年01月05日
*＜機能概要＞
*　マンション定額料金計算部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2012/01/05   富士通		新規作成
*	v3.00		2012/07/03   FJ）冨井	【ST2-2012-0001323】サービス休止日判定追加
*	v3.01		2012/08/14   FJ）冨井	【ST2-2012-0001464】処理変更
*	v3.02		2012/09/15   FJ）岡田	【ST2-2012-0001658】請求内訳作成ABEND対応
*	v3.03		2012/09/27   FJ）岡田	【ST2-2012-0001725】整理番号パディング対応
*	v3.03		2012/12/21   FJ）後藤	居住者一括・オーナーのみの場合出力しない
*	v3.04		2013/03/22   FJ）今井	【ANK-1203-00-00】マンションTV親請求対応
*                                       【契約障害対応】マンションオーナー向け利用不可期間減処理の追加対応
*	v5.00		2013/07/09   FJ) 岡田	【TG1-2013-0000662】マスタ参照基準日水平展開対応
*	v5.01		2013/10/02   FJ) 早崎	【OM-2013-0002830】居住者数算出基準を請求先番号単位からサービス番号単位に修正
*	v5.02		2013/10/12   FJ) 早崎	【OM-2013-0003148】全戸一括・居住者一括・ベースの料金コースコードと料金サービスコードを各々オーナーの情報を出力する
*	v6.00		2014/01/06   FJ) 田内	【OM-2013-0005235】マンションID明細作成処理にて、出力元の情報をオーナーから居住者の情報へ変更
*	v8.01		2014/01/10   FJ) 鈴木	【ANK-1794-00-00】L2-MVNO対応（請求書電話番号表示（LC含む））
*	v7.00		2014/02/05   FJ) 垣内	【OM-2014-0000388】マンション定額料金情報のオーナーと異なる料金コース・サービスのレコードが出力されない
*	v7.01		2014/03/20   FJ) 狭間	【OM-2014-0001119】OM-2013-0005235以降の修正を破棄し、出力項目の取得元を修正
*	v8.00		2014/04/14   FJ) 小掠	【OM-2014-0001467】加入契約支払方式コードが全戸一括、ベースのとき、支払契約識別コードが加入者契約支払（電話のみの契約）を入居済にカウントされていたのをカウントしないように変更。
*	v9.00.00	2014/04/25   FJ) 小掠	【ANK-2054-00-00】スマートリンク端末補償対応
**********************************************************************/
package eo.business.service;

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


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.util.file.JBSbatACIFI016;
import eo.business.util.file.JBSbatACIFM053;
import eo.business.util.table.JBSbatAC_M_MANS_TEGAKPRC;
import eo.business.util.table.JBSbatCH_M_PRC_KMK_CS_CHGE;
import eo.common.constant.JACStrConst;
import eo.common.constant.JPCBatchMessageConstant;
import eo.common.util.JPCUtilCommon;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.item.JBSbatServiceInterfaceMap;
import eo.framework.item.JBSbatOutputItem;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.util.JBSbatStringUtil;
import eo.framework.application.JBSbatBusinessException;
import eo.framework.db.JBSbatSQLAccess;

/**
* (クラスの機能概要) <p>
*<BR>
* @author 富士通
*/
public class JBSbatACMansTegakPrc extends JBSbatBusinessService
{
	/**▼▼▼▼▼▼ツールから生成した宣言です 開始▼▼▼▼▼▼*/
	/** テーブル(料金項目抽出変換)*/
	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_AC_M_MANS_TEGAKPRC = "AC_M_MANS_TEGAKPRC";

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

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

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

	/** テーブルアクセスクラス(マンション定額料金)*/
	private JBSbatSQLAccess db_AC_M_MANS_TEGAKPRC = null;
	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/
	
	/** マンション定額料金情報マップ */
	private HashMap<String, ArrayList<JBSbatCommonDBInterface>> mansTeiPrcInfoMap 	= null;
	
	/** 退避．利用料金情報（マンション定額料金情報）リスト */
	private ArrayList<JBSbatServiceInterfaceMap> tmpUsePrcMansInfoList = null;
	
	/** 退避．利用料金情報（オーナー情報）リスト */
	private ArrayList<JBSbatServiceInterfaceMap> tmpUsePrcOwnrInfoList = null;
	
	/** 退避.未入居明細用サービス契約番号 */
	private String minyukyoSvcKeiNo = null;
	
	/** マンション定額料金計算 */
	private String mansTeiPrcCalc = null;
	
	/** 料金項目コード */
	private String tmpPrcKmkCd = null;
	
	/** オーナー用グループコードリスト */
	private ArrayList<String> 	tmpGoupCdList = null;
	
	/**  利用月翌月月初日 */
	private String nextCycTukiSt = null;
	
	/** 退避．KEY（マンションＩＤ） */
	private String tmpKey = null;
	
	/** 退避．居住者数リスト */
	private HashSet<String> tmpResidentCntSet = null;
	
	/** 退避．居住者存在フラグ */
	private boolean tmpResidentFlg = false;
	
	/** マンションID明細料金項目コード変換マップ */
	private HashMap<ArrayList<String>, JBSbatCommonDBInterface> manidCnvMap = null;
	
	/** 整理番号項目長 */
	private int SEIRI_NO_LEN = 14;
	
	/** 退避．群月末日 */
	private String tmpCycEnd = null;
	
	/**
	 * 初期処理
	 * @param JBSbatCommonItem commonItem　バッチ共通パラメータ電文
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	public void initial(JBSbatCommonItem commonItem) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの初期処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した初期化のソースです 開始▼▼▼▼▼▼*/
		// 共通パラメータを設定します
		super.setCommonInfo(commonItem);

		// DBアクセスクラスを生成します
		db_CH_M_PRC_KMK_CS_CHGE = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CH_M_PRC_KMK_CS_CHGE);
		db_AC_M_MANS_TEGAKPRC = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AC_M_MANS_TEGAKPRC);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/
		
		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 + "]");
		
		// 業務パラメータの取得
		// パラメータ取得クラス生成
		JACbatParamUtil paramUtil = new JACbatParamUtil(commonItem);
		
		// 業務パラメータ情報を取得する
		this.mansTeiPrcCalc = paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AC_WKS_MAN_TGPRC);								// マンション定額料金計算
		String[] groupCdCubic = paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AC_OWNR_PRC_GRP_CD).split(JACStrConst.COMMA);	// オーナー用料金グループコード
		this.minyukyoSvcKeiNo = paramUtil.getGyoumuParameter(JACStrConst.WKPAR_AC_MINYUKYO_SVCKEINO);							// 未入居明細用サービス契約番号
		String manidCnvMapWkCd = paramUtil.getGyoumuParameter(JACStrConst.WKPAR_AC_WKS_MANID_CNVMAP);							// マンションID明細料金項目コード変換表
		
		// パラメータ取得クラスクローズ
		paramUtil.close();
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][マンション定額料金計算:" + mansTeiPrcCalc + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][オーナー用料金グループコード:" + groupCdCubic[0] + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][未入居明細用サービス契約番号:" + this.minyukyoSvcKeiNo + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][マンションID明細料金項目コード変換表:" + manidCnvMapWkCd + "]");
		
		// 利用月翌月月初日の取得
		this.getNextCycTukiSt();
		
		// マンションＩＤ中計用の料金項目コードを取得
		this.getPrcKmkCd();
		
		// マンション定額料金情報抽出
		this.getMansTegakprcInfo();
		
		// マンションID明細料金項目コード変換マップを生成する
		manidCnvMap = createManidCnvMap(manidCnvMapWkCd);
		
		// オーナー用料金グループコードの取得
		this.tmpGoupCdList = new ArrayList<String>();
		
		for(String groupCd : groupCdCubic)
		{
			this.tmpGoupCdList.add(groupCd);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][オーナー用料金グループコードリスト:" + this.tmpGoupCdList.toString() + "]");

		// 初期化
		this.tmpUsePrcMansInfoList 	= new ArrayList<JBSbatServiceInterfaceMap>();
		this.tmpUsePrcOwnrInfoList 	= new ArrayList<JBSbatServiceInterfaceMap>();
		this.tmpResidentCntSet		= new HashSet<String>();
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][initial]");
	/**▲▲▲▲▲▲業務サービスの初期処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * マンション定額料金スキーマより、料金項目情報を取得する。
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getMansTegakprcInfo() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getPrcKmkInfo]");
		
		// 退避マップに設定するキー：提供方式契約番号
		String teikyKey 	= null;
		// 検索結果キー
		String searchKey 	= null;
		
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		// システムコード
		paramList.setValue(super.systemCode);
		// 群月末日
		paramList.setValue(this.tmpCycEnd);
		// 群月末日
		paramList.setValue(this.tmpCycEnd);

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getPrcKmkInfo][paramList=" + paramList.getList().toString() + "]");
		// SQL実行
		executeAC_M_MANS_TEGAKPRC_AC_SELECT_003(paramList.getList().toArray());
		// 結果を取得
		JBSbatCommonDBInterface dbMap =  db_AC_M_MANS_TEGAKPRC.selectNext();
		// 取得できた場合
		if(null != dbMap)
		{
			this.mansTeiPrcInfoMap = new HashMap<String, ArrayList<JBSbatCommonDBInterface>>();
			// 退避マップに設定するキー：提供方式契約番号
			teikyKey = dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.TK_HOSHIKI_KEI_NO); 	// 提供方式契約番号
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getPrcKmkInfo]teikyKey:" + teikyKey);
			
			// 退避マップに設定するバリュー：検索結果のリスト
			ArrayList<JBSbatCommonDBInterface> mansTegakPrcList = new ArrayList<JBSbatCommonDBInterface>();
			while(dbMap != null)
			{
				// 検索結果キー作成
				searchKey = dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.TK_HOSHIKI_KEI_NO); 	// 提供方式契約番号
			
				// キーと検索結果の提供方式番号が異なった場合
				if(!teikyKey.equals(searchKey))
				{
					// マンション定額料金情報マップにキーとバリューを設定する
					this.mansTeiPrcInfoMap.put(teikyKey, mansTegakPrcList);
					// キーに新たな値を設定する
					teikyKey = searchKey;
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getPrcKmkInfo]teikyKey:" + teikyKey);
					// バリューをクリアー
					mansTegakPrcList = new ArrayList<JBSbatCommonDBInterface>();
				}
				// 取得結果より定額料金情報マップを作成しリストに格納
				mansTegakPrcList.add(dbMap);
				// 検索結果キークリアー
				searchKey = null;
				dbMap =  db_AC_M_MANS_TEGAKPRC.selectNext();
			}
			// 最後の取得結果を格納
			// マンション定額料金情報マップにキーとバリューを設定する
			this.mansTeiPrcInfoMap.put(teikyKey, mansTegakPrcList);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getPrcKmkInfo]");
	}
	
	/**
	 * 料金項目抽出変換スキーマより、マンションＩＤ中計用の料金項目コードを取得する。
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getPrcKmkCd() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getPrcKmkCd]");
		
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		// システムコード
		paramList.setValue(super.systemCode);
		// 業務機能識別コード
		paramList.setValue(this.mansTeiPrcCalc);
		// 抽出変換コード
		paramList.setValue(JACStrConst.CHSHT_CHG_CD_1);
		// バッチ運用日
		paramList.setValue(super.opeDate);
		// バッチ運用日
		paramList.setValue(super.opeDate);

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

		// SQL実行
		executeCH_M_PRC_KMK_CS_CHGE_AC_SELECT_014(paramList.getList().toArray());
		
		// 結果を取得
		JBSbatCommonDBInterface dbMap =  db_CH_M_PRC_KMK_CS_CHGE.selectNext();
		
		// 取得できた場合
		if(null != dbMap)
		{
			// 料金項目コードを退避領域に格納
			this.tmpPrcKmkCd 	= dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PRC_KMK_CD);
			
			assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getPrcKmkCd][tmpPrcKmkCd=" + this.tmpPrcKmkCd + "]");
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getPrcKmkCd]");
	}
	
	/**
	 * 料金項目抽出変換スキーマを参照し、
	 * マンションID明細料金項目コード変換マップを生成します。
	 * 
	 * @param strWkPar 業務機能識別コード
	 * @return マンションID明細料金項目コード変換マップ
	 * @throws Exception
	 */
	private HashMap<ArrayList<String>, JBSbatCommonDBInterface> createManidCnvMap(String workParam) 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(super.systemCode);			// システムコード
		paramList.setValue(workParam);					// 業務機能識別コード
		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_AC_SELECT_014(paramList.getList().toArray());
		JBSbatCommonDBInterface dbMap =  db_CH_M_PRC_KMK_CS_CHGE.selectNext();
		
		// 取得結果をマップに格納する
		while(null != dbMap)
		{
			// グループ、コース、サービス、料金項目でキーを生成する
			ArrayList<String> mapKey = createMapKey(dbMap);
			// キー単位に抽出結果を格納する
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][createManidCnvMap]mapKey：" + mapKey + " ,OUT_PRC_KMK_CD:" + dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.OUT_PRC_KMK_CD));
			retMap.put(mapKey, dbMap);
			// 次のレコードを読み込む
			dbMap =  db_CH_M_PRC_KMK_CS_CHGE.selectNext();
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][createManidCnvMap]マスタ取得件数：" + retMap.size());
		
		// マップを返却する
		return retMap;
	}
	
	/**
	 * マンション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;
	}
	

	
	/**
	 * 主処理
	 * @param  inMap             入力電文
	 * @param  outputInItem      入力情報
	 * @return JBSbatOutputItem  出力情報
	 * @throws Exception         業務サービス内で発生した例外全般
	 */
	public JBSbatOutputItem execute(JBSbatServiceInterfaceMap inMap, JBSbatOutputItem outputInItem) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの主処理を記述してください。▼▼▼▼▼▼*/
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute]");
		assert 	inMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute][inMap=" + inMap.getMap().toString() + "]") : true;
		
		//1件目のレコードの場合
		if(!outputInItem.isOutMapList())
		{
			// ダミーレコードセット
			outputInItem.addOutMapList(new JBSbatServiceInterfaceMap());
		}
		// キーブレイクチェック処理
		// 退避．KEY ≠ NULL（初回データ） の場合
		if(this.tmpKey != null)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute][退避．KEY ≠ NULL（初回データ） の場合]");
			// 「入力情報 ＝ NULL（最終レコード）」 もしくは
			// 「退避．KEY ≠ 入力．KEY」 の場合
			if(inMap == null || !this.tmpKey.equals(inMap.getString(JBSbatACIFM053.MANSION_ID)))
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute][入力情報 ＝ NULL（最終レコード）　または 退避．KEY ≠ 入力．KEYの場合]");
				// 「オーナー情報取得」を行う。
				this.getOwnrInfo();
				// 「加入契約支払方式別出力判定処理」を行う。
				this.makeKanyuKeiJdgTrn(outputInItem);
				
				// 最終レコードの場合
				if(inMap == null)
				{
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute][最終レコードの場合]");
					return outputInItem;
				}
				// 初期化を行う。
				this.initInfo();
			}
		}
		// データ退避
		{
			// 退避．利用料金情報（マンション定額料金情報）リスト ← 入力情報
			this.tmpUsePrcMansInfoList.add(inMap);
			// 退避．KEY ← 入力．KEY
			this.tmpKey = inMap.getString(JBSbatACIFM053.MANSION_ID);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][execute]");
		return outputInItem;
	/**▲▲▲▲▲▲業務サービスの主処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 業務サービス終了処理
	 * @throws Exception
	 */
	public void terminal() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの終了処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した終了処理のソースです 開始▼▼▼▼▼▼*/
		// DBアクセスクラスをクローズします
		db_CH_M_PRC_KMK_CS_CHGE.close();
		db_AC_M_MANS_TEGAKPRC.close();
		/**▲▲▲▲▲▲ツールから生成した終了処理のソースです 終了▲▲▲▲▲▲*/
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][terminal]");
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][terminal]");

	/**▲▲▲▲▲▲業務サービスの終了処理を記述してください。▲▲▲▲▲▲*/
	}

	/**▼▼▼▼▼▼ツールから生成したメソッドです 開始▼▼▼▼▼▼*/
	/**
	 * SQLKEY(AC_SELECT_014)で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_AC_SELECT_014(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_AC_SELECT_014);
	}

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

		// DBアクセスを実行します
		db_AC_M_MANS_TEGAKPRC.selectBySqlDefine(paramList, AC_M_MANS_TEGAKPRC_AC_SELECT_003);
	}
	/**▲▲▲▲▲▲ツールから生成したメソッドです 終了▲▲▲▲▲▲*/
	
	/**
	 * 利用月翌月月初日の取得をおこないます。
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getNextCycTukiSt() throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getNextCycTukiSt]");
		
		// 料金スケジュール定義アクセス部品初期処理
		JACbatSchdlUtil schdlUtil = new JACbatSchdlUtil(commonItem);
		
		try
		{
			// 請求年月を取得する
			String seikyYm = schdlUtil.getBillDate(super.opeDate, JACStrConst.EVENT_CD_RYOKIN_KEISAN_YMD);
			
			// 請求年月から、終了日取得
			String[] startEndYmd = schdlUtil.getUseStrEnd(seikyYm, JACStrConst.EVENT_CD_USE_STAYMD, JACStrConst.EVENT_CD_USE_ENDYMD);
			
			this.tmpCycEnd = startEndYmd[1];	// 群月末日
			
			// ＋1日して翌月月初日をもとめる
			nextCycTukiSt = JPCUtilCommon.addDay(startEndYmd[1], 1);
		}
		finally
		{
			// 料金スケジュール定義アクセス部品クローズ
			schdlUtil.close();
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "利用月翌月月初日：" + nextCycTukiSt);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getNextCycTukiSt]");
	}
	
	/**
	 * 退避項目の初期化を行う。
	 */
	private void initInfo() 
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][initInfo]");
		// 退避．利用料金情報（マンション定額料金情報）リスト ← クリア
		this.tmpUsePrcMansInfoList.clear();
		// 退避．利用料金情報（オーナー情報）リスト ← クリア
		this.tmpUsePrcOwnrInfoList.clear();
		// 退避．居住者数リスト ← クリア
		this.tmpResidentCntSet.clear();
		// 退避．居住者存在フラグ ← クリア
		this.tmpResidentFlg = false;
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][initInfo]");
	}
	
	/**
	 * 退避．利用料金情報（マンション定額料金情報）リストからオーナー情報取得の取得を行います。
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getOwnrInfo() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getOwnrInfo]");
		
		// オーナー情報判定
		for(JBSbatServiceInterfaceMap inMap : this.tmpUsePrcMansInfoList)
		{
			// 退避．利用料金情報（マンション定額料金情報）リスト[i]．料金グループコード
			String jdgKey = inMap.getString(JBSbatACIFM053.PRC_GRP_CD);
			
			// オーナー用グループコードリスト に存在している場合
			if(tmpGoupCdList.contains(jdgKey))
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getOwnrInfo][追加対象]");	
				// 退避．利用料金情報（オーナー情報）リスト ← 取得情報
				this.tmpUsePrcOwnrInfoList.add(inMap);
			}
			else
			{
				// 退避．居住者存在フラグ ← true
				this.tmpResidentFlg = true;
			}
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getOwnrInfo]");
		return;
	}
	
	/**
	 * マンション定額料金情報マップからマンション定額料金情報抽出（提供方式契約単位）の取得を行います。
	 * @param inMap              利用料金情報（マンション定額料金情報）リスト[i]
	 * @param mansTeiPrcCalcList マンション定額料金情報（提供方式契約単位）リスト（返却用）
	 * @throws Exception         業務サービス内で発生した例外全般
	 */
	private void getMansTegakprcTkInfo(
					JBSbatServiceInterfaceMap inMap,
					ArrayList<JBSbatCommonDBInterface> mansTeiPrcCalcList) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getMansTegakprcTkInfo]");

			mansTeiPrcCalcList.clear();
			// 利用料金情報（マンション定額料金情報）リスト[i]．提供方式契約番号
			String jdgKey = inMap.getString(JBSbatACIFM053.TK_HOSHIKI_KEI_NO);
			
			// 設定済みリストに含まれない
			// かつ マンション定額料金情報マップ ≠ null
			// かつ マンション定額料金情報マップにキーが存在する
			if(this.mansTeiPrcInfoMap != null
					&& this.mansTeiPrcInfoMap.containsKey(jdgKey))
			{
				mansTeiPrcCalcList.addAll(this.mansTeiPrcInfoMap.get(jdgKey));
			}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getMansTegakprcTkInfo]");
		return;
	}
	
	/**
	 * 加入契約支払方式別出力判定処理を行います。
	 * 
	 * @param outputInItem 出力共通電文
	 * @throws Exception 
	 */
	private void makeKanyuKeiJdgTrn(JBSbatOutputItem outputInItem) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeKanyuKeiJdgTrn]");
		
		// 利用料金情報（オーナー情報）マップ
		JBSbatServiceInterfaceMap ownrMap = new JBSbatServiceInterfaceMap();

		// 前回．提供方式契約番号
		String bfTkHoshikiKeiNo = null;
		
		ArrayList<JBSbatCommonDBInterface> mansTeiPrcCalcList = new ArrayList<JBSbatCommonDBInterface>();
		ArrayList<String> pauseJdgInfoList = new ArrayList<String>();
		// オーナー情報判定
		for(int i = 0; i < this.tmpUsePrcMansInfoList.size(); i++)	
		{
			JBSbatServiceInterfaceMap inMap = this.tmpUsePrcMansInfoList.get(i);
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeKanyuKeiJdgTrn][inMap=" + inMap.getMap().toString() + "]");
			
			// オーナー情報の選択処理
			this.getOwnrInfoMap(inMap, ownrMap);
			// 判定条件取得
			String knyuKeiCd 		= inMap.getString(JBSbatACIFM053.KANYU_KEI_PAY_HOSHIKI_CD);
			String prcGrpCd 		= inMap.getString(JBSbatACIFM053.PRC_GRP_CD);
			String tkHoshikiKeiNo 	= inMap.getString(JBSbatACIFM053.TK_HOSHIKI_KEI_NO);
			
			// 前回の提供方式契約番号と違う場合
			if(!tkHoshikiKeiNo.equals(bfTkHoshikiKeiNo))
			{
				// マンション定額料金情報抽出（提供方式契約単位）の取得
				this.getMansTegakprcTkInfo(inMap, mansTeiPrcCalcList);
				// 前回キー ← 入力キー
				bfTkHoshikiKeiNo = tkHoshikiKeiNo;
			}
			
			// 「加入契約支払方式コード ＝ "003"（全戸一括）」 の場合
			if(JACStrConst.KANYU_KEI_PAY_HSHK_CD_IKT.equals(knyuKeiCd))
			{
				// 退避．オーナー用グループコードリストに存在している場合（オーナー契約分のレコード）
				if(this.tmpGoupCdList.contains(prcGrpCd))
				{
					// マンション定額料金情報抽出（提供方式契約単位）の件数分処理する。
					for(JBSbatCommonDBInterface dbMap :mansTeiPrcCalcList)
					{
						// 退避．マンション定額料金情報（提供方式契約単位）リストチェック（オーナー契約支払）
						if(this.isMansTeiPrcCalcInfo(ownrMap, dbMap, JACStrConst.PAY_KEI_SKBT_CD_OWNR))
						{
							// 取得した情報分ファイル出力を行う。
							int cnt = Integer.parseInt(ownrMap.getString(JBSbatACIFM053.TTL_KOSU));
							// 退避．マンション定額料金情報（提供方式契約単位）リスト[i]．料金
							// ÷ 退避．利用料金情報（オーナー情報）マップ．総戸数 （端数切り捨て）
							BigDecimal prc = JACbatRknBusinessUtil.round(JACStrConst.ROUND_DOWN
													, dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC).divide(new BigDecimal(ownrMap.getString(JBSbatACIFM053.TTL_KOSU)), 4, BigDecimal.ROUND_HALF_EVEN)
													, 0);
							for (int j = 0; j < cnt; j++)
							{
								// 利用料金情報（全戸一括_マンションID明細）を作成する。
								this.makeOputInfoIktMansDtl(inMap, ownrMap, dbMap, prc, outputInItem);
							}
							// 利用料金情報（全戸一括_マンションID明細_中計）を作成する。
							this.makeOputInfoIktMansDtlCk(inMap, ownrMap, dbMap, outputInItem);
						}
					}
				}
				// 退避．オーナー用グループコードリストに存在しない場合（居住者契約分のレコード）
				else
				{
					// マンション定額料金情報抽出（提供方式契約単位）の件数分処理する。
					for(JBSbatCommonDBInterface dbMap :mansTeiPrcCalcList)
					{
						
						// 退避．マンション定額料金情報（提供方式契約単位）リストチェック（オーナー契約支払）
						if(this.isMansTeiPrcCalcInfo(ownrMap, dbMap, JACStrConst.PAY_KEI_SKBT_CD_OWNR))
						{
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeKanyuKeiJdgTrn][料金 = " + dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC) + "]");
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeKanyuKeiJdgTrn][戸数 = " + ownrMap.get(JBSbatACIFM053.TTL_KOSU) + "]");
							// 退避．マンション定額料金情報（提供方式契約単位）リスト[i]．料金
							// ÷ 退避．利用料金情報（オーナー情報）マップ．総戸数 （端数切り捨て）
							BigDecimal prc = JACbatRknBusinessUtil.round(JACStrConst.ROUND_DOWN
													, dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC).divide(new BigDecimal(ownrMap.getString(JBSbatACIFM053.TTL_KOSU)), 4, BigDecimal.ROUND_HALF_EVEN)
													, 0);
							// 利用料金情報（全戸一括_部屋番号明細）を作成する。
							this.makeOputInfoIktRmDtl(inMap, ownrMap, dbMap, prc, outputInItem);
							
							// 退避．居住者数リスト ← サービス番号
							this.tmpResidentCntSet.add(inMap.getString(JBSbatACIFM053.SVC_NO));
						}
						
						// 退避．マンション定額料金情報（提供方式契約単位）リストチェック（加入者契約支払）
						if(this.isMansTeiPrcCalcInfo(inMap, dbMap, JACStrConst.PAY_KEI_SKBT_CD_KNYSHA))
						{
							// 利用料金情報（個別(ベース居住者／増速差額)_部屋番号明細）を作成する。
							this.makeOputInfoIktKobetsuRmDtl(inMap, dbMap, outputInItem);
						}
					}
				}
				// 最終レコードの場合
				if(i == this.tmpUsePrcMansInfoList.size() - 1)
				{
					// 退避．利用料金情報（オーナー情報）リスト分
					for(JBSbatServiceInterfaceMap map : this.tmpUsePrcOwnrInfoList)
					{
						// マンション定額料金情報抽出（提供方式契約単位）の取得
						this.getMansTegakprcTkInfo(map, mansTeiPrcCalcList);
						// マンション定額料金情報抽出（提供方式契約単位）の件数分処理する。
						for(JBSbatCommonDBInterface dbTkMap :mansTeiPrcCalcList)
						{
							// 退避．マンション定額料金情報（提供方式契約単位）リストチェック（オーナー契約支払）
							if(this.isMansTeiPrcCalcInfo(map, dbTkMap, JACStrConst.PAY_KEI_SKBT_CD_OWNR))
							{
								// 退避．マンション定額料金情報（提供方式契約単位）リスト[i]．料金
								// ÷ 退避．利用料金情報（オーナー情報）リスト[i]．総戸数 （端数切り捨て）
								BigDecimal prc = JACbatRknBusinessUtil.round(JACStrConst.ROUND_DOWN
										, dbTkMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC).divide(new BigDecimal(map.getString(JBSbatACIFM053.TTL_KOSU)), 4, BigDecimal.ROUND_HALF_EVEN)
										, 0);

								// （退避．利用料金情報（オーナー情報）リスト[i]．総戸数  - 退避．居住者数）分出力
								int cnt = new BigDecimal(map.getString(JBSbatACIFM053.TTL_KOSU)).subtract(new BigDecimal(this.tmpResidentCntSet.size())).intValue();
								
								for(int j = 0; j < cnt; j++)
								{
									// 利用料金情報（全戸一括_部屋番号明細(未入居)）を作成する。
									this.makeOputInfoIktMinyukyo(map, dbTkMap, prc, outputInItem);
								}
							}
						}
					}
				}
			}
			// 「加入契約支払方式コード ＝ "004"（居住者一括）」 の場合
			else if(JACStrConst.KANYU_KEI_PAY_HSHK_CD_JKYO_IKT.equals(knyuKeiCd))
			{
				// 居住者が存在する場合
				if(this.tmpResidentFlg)
				{
					// 退避．オーナー用グループコードリストに存在している場合（オーナー契約分のレコード）
					if(this.tmpGoupCdList.contains(prcGrpCd))
					{
						// マンション定額料金情報抽出（提供方式契約単位）の件数分処理する。
						for(JBSbatCommonDBInterface dbMap :mansTeiPrcCalcList)
						{
							// 退避．マンション定額料金情報（提供方式契約単位）リストチェック（オーナー契約支払）
							if(this.isMansTeiPrcCalcInfo(ownrMap, dbMap, JACStrConst.PAY_KEI_SKBT_CD_OWNR))
							{
								// 退避．利用料金情報（オーナー情報）マップ．総戸数分ファイル出力を行う
								int cnt = Integer.parseInt(ownrMap.getString(JBSbatACIFM053.TTL_KOSU));
								for (int j = 0; j < cnt; j++)
								{
									// 利用料金情報（居住者一括_マンションID明細）を作成する。
									this.makeOputInfoJkyoMansDtl(inMap, ownrMap, dbMap, outputInItem);
								}
								
								// 退避．マンション定額料金情報（提供方式契約単位）リスト[i]．料金
								// × 退避．利用料金情報（オーナー情報）マップ．総戸数
								BigDecimal prc = dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC).multiply(new BigDecimal(ownrMap.getString(JBSbatACIFM053.TTL_KOSU)));

								// 利用料金情報（居住者一括_マンションID明細_中計）を作成する。
								this.makeOputInfoJkyoMansDtlCk(inMap, ownrMap, dbMap, prc, outputInItem);
							}
						}
					}
					
					// 退避．オーナー用グループコードリストに存在しない場合（居住者契約分のレコード）
					else
					{
						// マンション定額料金情報抽出（提供方式契約単位）の件数分処理する。
						for(JBSbatCommonDBInterface dbMap :mansTeiPrcCalcList)
						{
							
							// 退避．マンション定額料金情報（提供方式契約単位）リストチェック（オーナー契約支払）
							if(this.isMansTeiPrcCalcInfo(ownrMap, dbMap, JACStrConst.PAY_KEI_SKBT_CD_OWNR))
							{
								// 利用料金情報（居住者一括_部屋番号明細）を作成する。
								this.makeOputInfoJkyoRmDtl(inMap, ownrMap, dbMap, outputInItem);
							}
							
							// 退避．マンション定額料金情報（提供方式契約単位）リストチェック（加入者契約支払）
							if(this.isMansTeiPrcCalcInfo(inMap, dbMap, JACStrConst.PAY_KEI_SKBT_CD_KNYSHA))
							{
								// 利用料金情報（個別(ベース居住者／増速差額)_部屋番号明細）を作成する。
								this.makeOputInfoIktKobetsuRmDtl(inMap, dbMap, outputInItem);
							}
						}
					}
				}
			}
			// 「加入契約支払方式コード ＝ "001"（ベース）」 の場合
			else if(JACStrConst.KANYU_KEI_PAY_HSHK_CD_BASE.equals(knyuKeiCd))
			{
				// 退避．オーナー用グループコードリストに存在している場合（オーナー契約分のレコード）
				if(this.tmpGoupCdList.contains(prcGrpCd))
				{
					
					// マンション定額料金情報抽出（提供方式契約単位）の件数分処理する。
					for(JBSbatCommonDBInterface dbMap :mansTeiPrcCalcList)
					{
						// 退避．マンション定額料金情報（提供方式契約単位）リストチェック（オーナー契約支払）
						if(this.isMansTeiPrcCalcInfo(ownrMap, dbMap, JACStrConst.PAY_KEI_SKBT_CD_OWNR))
						{
							// 退避．利用料金情報（オーナー情報）マップ．総戸数分ファイル出力を行う
							int cnt = Integer.parseInt(ownrMap.getString(JBSbatACIFM053.TTL_KOSU));
							for (int j = 0; j < cnt; j++)
							{
								// 利用料金情報（ベース_マンションID明細）を作成する。
								this.makeOputInfoBaseMansDtl(inMap, ownrMap, dbMap, outputInItem);
							}
							
							//退避．マンション定額料金情報（提供方式契約単位）リスト[i]．料金
							// × 退避．利用料金情報（オーナー情報）マップ．総戸数
							BigDecimal prc = dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC).multiply(new BigDecimal(ownrMap.getString(JBSbatACIFM053.TTL_KOSU)));
							
							// 利用料金情報（ベース_マンションID明細_中計）を作成する。
							this.makeOputInfoBaseMansDtlCk(inMap, ownrMap, dbMap, prc, outputInItem);
						}
					}
				}
				
				// 退避．オーナー用グループコードリストに存在しない場合（居住者契約分のレコード）
				else
				{
					// マンション定額料金情報抽出（提供方式契約単位）の件数分処理する。
					for(JBSbatCommonDBInterface dbMap :mansTeiPrcCalcList)
					{
						// 退避．マンション定額料金情報（提供方式契約単位）リストチェック（オーナー契約支払）
						if(this.isMansTeiPrcCalcInfo(ownrMap, dbMap, JACStrConst.PAY_KEI_SKBT_CD_OWNR))
						{
							// 利用料金情報（ベース_部屋番号明細）を作成する。
							this.makeOputInfoBaseRmDtl(inMap, ownrMap, dbMap, outputInItem);
							
							// 退避．居住者数リスト ← サービス番号
							this.tmpResidentCntSet.add(inMap.getString(JBSbatACIFM053.SVC_NO));
						}
						
						// 退避．マンション定額料金情報（提供方式契約単位）リストチェック（加入者契約支払）
						if(this.isMansTeiPrcCalcInfo(inMap, dbMap, JACStrConst.PAY_KEI_SKBT_CD_KNYSHA))
						{
							// 利用料金情報（個別(ベース居住者／増速差額)_部屋番号明細）を作成する。
							this.makeOputInfoIktKobetsuRmDtl(inMap, dbMap, outputInItem);
						}
					}
					
				}
				// 最終レコードの場合
				if(i == this.tmpUsePrcMansInfoList.size() - 1)
				{
					// 退避．利用料金情報（オーナー情報）リスト分
					for(JBSbatServiceInterfaceMap map : this.tmpUsePrcOwnrInfoList)
					{
						// マンション定額料金情報抽出（提供方式契約単位）の取得
						this.getMansTegakprcTkInfo(map, mansTeiPrcCalcList);
						// マンション定額料金情報抽出（提供方式契約単位）の件数分処理する。
						for(JBSbatCommonDBInterface dbTkMap :mansTeiPrcCalcList)
						{
							// 退避．マンション定額料金情報（提供方式契約単位）リストチェック（オーナー契約支払）
							if(this.isMansTeiPrcCalcInfo(map, dbTkMap, JACStrConst.PAY_KEI_SKBT_CD_OWNR))
							{
								//  （退避．利用料金情報（オーナー情報）マップ．総戸数 - 退避．居住者数）分のレコードを出力する
								int cnt = new BigDecimal(map.getString(JBSbatACIFM053.TTL_KOSU)).subtract(new BigDecimal(this.tmpResidentCntSet.size())).intValue();
								for (int j = 0; j < cnt; j++)
								{
									// 利用料金情報（ベース_部屋番号明細(未入居)）を作成する。
									this.makeOputInfoBaseMinyukyo(map, inMap, dbTkMap, outputInItem);
								}
							}
						}
					}
				}
			}
			// 「加入契約支払方式コード ＝ "002"（個別）」 の場合
			else if(JACStrConst.KANYU_KEI_PAY_HSHK_CD_KOBETSU.equals(knyuKeiCd))
			{
				// 退避．オーナー用グループコードリストに存在しない場合（居住者契約分のレコード）
				if(!this.tmpGoupCdList.contains(prcGrpCd))
				{
					// マンション定額料金情報抽出（提供方式契約単位）の件数分処理する。
					for(JBSbatCommonDBInterface dbMap :mansTeiPrcCalcList)
					{
						// 退避．マンション定額料金情報（提供方式契約単位）リストチェック（加入者契約支払）
						if(this.isMansTeiPrcCalcInfo(inMap, dbMap, JACStrConst.PAY_KEI_SKBT_CD_KNYSHA))
						{
							this.setPauseJdgInfo(inMap, dbMap, pauseJdgInfoList);
							// 利用料金情報（個別_部屋番号明細）を作成する。
							this.makeOputInfoKobetsuRmDtl(inMap, pauseJdgInfoList, outputInItem);
						}
					}
				}
			}
			// 「加入契約支払方式コード ＝ "005"（特定マンション一括）」 の場合
			else if(JACStrConst.KANYU_KEI_PAY_HSHK_CD_SPE_MANS_IKT.equals(knyuKeiCd))
			{
				// 退避．オーナー用グループコードリストに存在する場合（オーナー分のレコード）
				if(this.tmpGoupCdList.contains(prcGrpCd))
				{
					// マンション定額料金情報抽出（提供方式契約単位）の件数分処理する。
					for(JBSbatCommonDBInterface dbMap :mansTeiPrcCalcList)
					{
						// 退避．マンション定額料金情報（提供方式契約単位）リストチェック（オーナー契約支払）
						if(this.isMansTeiPrcCalcInfo(inMap, dbMap, JACStrConst.PAY_KEI_SKBT_CD_OWNR))
						{
							// 利用料金情報（特定マンション一括_マンションID明細）を作成する。
							this.makeOputInfoSpeMansIkt(inMap, ownrMap, dbMap, outputInItem);
							// 利用料金情報（特定マンション一括_マンションID明細_中計）を作成する。
							this.makeOputInfoSpeMansIktCk(inMap, ownrMap, dbMap, pauseJdgInfoList, outputInItem);
						}
					}
				}
			}
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeKanyuKeiJdgTrn]");
	}
	
	/**
	 * オーナー情報の選択処理をおこないます。
	 * @param  inMap     利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  ownrMap   オーナー情報マップ（返却用）
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	@SuppressWarnings("unchecked")
	private void getOwnrInfoMap(
					JBSbatServiceInterfaceMap inMap,
					JBSbatServiceInterfaceMap ownrMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getOwnrInfoMap]");
		
		// 判定条件取得
		String pcrsCd 		= inMap.getString(JBSbatACIFM053.PCRS_CD);
		String prcSvcCd 	= inMap.getString(JBSbatACIFM053.PRC_SVC_CD);
		String svcSkbtCd 	= inMap.getString(JBSbatACIFM053.SVC_SKBT_CD);
		
		// 【検索条件1】(オーナー負担（支払）の契約と同サービスに居住者が加入している場合)
		for(JBSbatServiceInterfaceMap map : this.tmpUsePrcOwnrInfoList)
		{
			// 判定条件取得
			String jdgPcrsCd = map.getString(JBSbatACIFM053.PCRS_CD);
			String jdgPrcSvcCd = map.getString(JBSbatACIFM053.PRC_SVC_CD);
			// 利用料金情報（オーナー情報）リスト[i]．料金コースコード ＝ 入力．料金コースコード
			// かつ 利用料金情報（オーナー情報）リスト[i]．料金サービスコード ＝ 入力．料金サービスコードの場合
			if(jdgPcrsCd.equals(pcrsCd)
					&& jdgPrcSvcCd.equals(prcSvcCd))
			{
				// オーナー情報設定用 ← 取得した情報
				ownrMap.getMap().putAll(map.getMap());
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getOwnrInfoMap][検索条件1:返却値 = " + ownrMap.getMap().toString() + "]");
				return;
			}
		}
		// 【検索条件2】(オーナー負担（支払）の契約と別サービスに居住者が加入している場合（オプションサービス、機器サービスなどの取得）)
		for(JBSbatServiceInterfaceMap map : this.tmpUsePrcOwnrInfoList)
		{
			// 判定条件取得
			String jdgPrcSvcCd = map.getString(JBSbatACIFM053.PRC_SVC_CD);
			// 利用料金情報（オーナー情報）リスト[i]．料金サービスコード ＝ 入力．料金サービスコードの場合
			if(jdgPrcSvcCd.equals(prcSvcCd))
			{
				// オーナー情報設定用 ← 取得した情報
				ownrMap.getMap().putAll(map.getMap());
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getOwnrInfoMap][検索条件2:返却値 = " + ownrMap.getMap().toString() + "]");
				return;
			}
		}
		// 【検索条件3】(オーナー負担（支払）の契約と別サービスに居住者が加入している場合（回線サービスの取得）)
		for(JBSbatServiceInterfaceMap map : this.tmpUsePrcOwnrInfoList)
		{
			// 判定条件取得
			String jdgSvcSkbtCd = map.getString(JBSbatACIFM053.SVC_SKBT_CD);
			// 利用料金情報（オーナー情報）リスト[i]．料金サービス識別コード      ＝ 退避．利用料金情報（マンション定額料金情報）リスト[i]．料金サービス識別コード
			// かつ 利用料金情報（オーナー情報）リスト[i]．料金サービス識別コード ＝ "1"（基本）
			if(jdgSvcSkbtCd.equals(svcSkbtCd)
					&& JACStrConst.SVC_SKBT_CD_NRML.equals(jdgSvcSkbtCd))
			{
				// オーナー情報設定用 ← 取得した情報
				ownrMap.getMap().putAll(map.getMap());
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getOwnrInfoMap][検索条件3:返却値 = " + ownrMap.getMap().toString() + "]");
				return;
			}
		}
		// オーナー情報クリア
		ownrMap.getMap().clear();
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getOwnrInfoMap][返却値 = " + ownrMap.getMap().toString() + "]");
		return;
	}

	/**
	 * 利用料金情報（全戸一括_マンションID明細）を出力する。
	 * @param  inMap         利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  ownrMap       利用料金情報（オーナー情報）マップ
	 * @param  dbMap         マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  prc           料金
	 * @param  outputInItem  出力共通電文
	 * @throws Exception  業務サービス内で発生した例外全般
	 */
	private void makeOputInfoIktMansDtl(
					JBSbatServiceInterfaceMap inMap,
					JBSbatServiceInterfaceMap ownrMap,
					JBSbatCommonDBInterface  dbMap,
					BigDecimal prc,
					JBSbatOutputItem outputInItem) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOputInfoIktMansDtl] 全戸一括_マンションID明細");

		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatACIFI016.SEIKY_KEI_NO, 		ownrMap.get(JBSbatACIFM053.SEIKY_KEI_NO));						// 請求先番号
		outMap.set(JBSbatACIFI016.SEIKY_YM, 			inMap.get(JBSbatACIFM053.SEIKY_YM));							// 請求年月
		outMap.set(JBSbatACIFI016.SEIRI_NO, 			JBSbatStringUtil.fillHalfSpace((String)inMap.get(JBSbatACIFM053.MANSION_ID),this.SEIRI_NO_LEN,true));		// 整理番号（マンションＩＤを設定）
		outMap.set(JBSbatACIFI016.WRIB_SVC_KEI_NO, 		inMap.get(JBSbatACIFM053.WRIB_SVC_KEI_NO));						// 割引サービス契約番号
		outMap.set(JBSbatACIFI016.WRISVC_TRGT_KEI_NO, 	inMap.get(JBSbatACIFM053.WRISVC_TRGT_KEI_NO));					// 割引サービス対象契約番号
		outMap.set(JBSbatACIFI016.SVC_NO, 				ownrMap.get(JBSbatACIFM053.SVC_NO));							// サービス番号
		outMap.set(JBSbatACIFI016.OP_SVKEI_NO, 			inMap.get(JBSbatACIFM053.OP_SVKEI_NO));							// オプションサービス契約番号
		outMap.set(JBSbatACIFI016.SVC_SKBT_CD, 			inMap.get(JBSbatACIFM053.SVC_SKBT_CD));							// 料金サービス識別コード
		outMap.set(JBSbatACIFI016.PRC_GRP_CD, 			ownrMap.get(JBSbatACIFM053.PRC_GRP_CD));						// 料金グループコード
		outMap.set(JBSbatACIFI016.PCRS_CD, 				ownrMap.get(JBSbatACIFM053.PCRS_CD));							// 料金コースコード
		outMap.set(JBSbatACIFI016.PRC_SVC_CD, 			ownrMap.get(JBSbatACIFM053.PRC_SVC_CD));						// 料金サービスコード
		outMap.set(JBSbatACIFI016.PRC_KMK_CD, 			convPrcKmkCd(outMap, dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_KMK_CD)));// 料金項目コード
		outMap.set(JBSbatACIFI016.COLLECT_PATTERN_CD, 	dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD));	// 徴収パターンコード
		outMap.set(JBSbatACIFI016.PRC, 					prc);															// 料金
		outMap.set(JBSbatACIFI016.USE_STAYMD, 			inMap.get(JBSbatACIFM053.USE_STAYMD));							// 利用開始日
		outMap.set(JBSbatACIFI016.USE_ENDYMD, 			inMap.get(JBSbatACIFM053.USE_ENDYMD));							// 利用終了日
		outMap.set(JBSbatACIFI016.SVC_STAYMD, 			inMap.get(JBSbatACIFM053.SVC_STAYMD));							// サービス開始日
		outMap.set(JBSbatACIFI016.FIRST_CHRG_STAYMD, 	inMap.get(JBSbatACIFM053.FIRST_CHRG_STAYMD));					// 初回課金開始日
		outMap.set(JBSbatACIFI016.SVC_DSL_YMD, 			inMap.get(JBSbatACIFM053.SVC_DSL_YMD));							// サービス解約日
		outMap.set(JBSbatACIFI016.SVC_DLRE, 			inMap.get(JBSbatACIFM053.SVC_DLRE));							// サービス解約理由
		outMap.set(JBSbatACIFI016.SVC_KAIHK_DAY, 		inMap.get(JBSbatACIFM053.SVC_KAIHK_DAY));						// サービス回復日
		outMap.set(JBSbatACIFI016.USE_DAY_CNT, 			inMap.get(JBSbatACIFM053.USE_DAY_CNT));							// 利用日数
		outMap.set(JBSbatACIFI016.USE_FAIL_DAY_CNT, 	ownrMap.get(JBSbatACIFM053.USE_FAIL_DAY_CNT));					// 利用不可日数
		outMap.set(JBSbatACIFI016.AIT_DIV, 				JACStrConst.AITAIKBN_NON);										// 相対区分
		outMap.set(JBSbatACIFI016.SIME_DAY, 			inMap.get(JBSbatACIFM053.SIME_DAY));							// 締め日
		outMap.set(JBSbatACIFI016.USE_APLY_KH_CD, 		dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.USE_FAIL_APLY_WAY_CD));// 利用不可適用可否
		outMap.set(JBSbatACIFI016.MAE_YUSEN_JUN, 		JACStrConst.MAE_YUSEN_JUN_0);									// 前受相殺優先順位
		outMap.set(JBSbatACIFI016.WRIB_YUSEN_JUN, 		JACStrConst.WRIB_YUSEN_JUN_0);									// 割引優先順位
		outMap.set(JBSbatACIFI016.UPPL_JUDGE_YUSEN_JUN, JACStrConst.KARA_MOJI);											// 上限判定優先順位
		outMap.set(JBSbatACIFI016.WRIB_KKSHI_KH, 		JACStrConst.WRIB_KKS_H);										// 割引繰越可否
		outMap.set(JBSbatACIFI016.SVC_DTL_SKBT_NO, 		inMap.get(JBSbatACIFM053.SVC_DTL_SKBT_NO));						// サービス詳細識別番号
		
		outMap.setOutFlg(true);
		
		// 出力共通電文に入出力インターフェースを設定する
		outputInItem.addOutMapList(outMap);
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOputInfoIktMansDtl]");
		return;
	}
	
	/**
	 * 利用料金情報（全戸一括_マンションID明細_中計）を出力する。
	 * @param  inMap        利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  ownrMap      利用料金情報（オーナー情報）マップ
	 * @param  dbMap        マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  outputInItem 出力共通電文
	 * @throws Exception    業務サービス内で発生した例外全般
	 */
	private void makeOputInfoIktMansDtlCk(
					JBSbatServiceInterfaceMap inMap,
					JBSbatServiceInterfaceMap ownrMap,
					JBSbatCommonDBInterface  dbMap,
					JBSbatOutputItem outputInItem) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOputInfoIktMansDtlCk] 全戸一括_マンションID明細_中計");

		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatACIFI016.SEIKY_KEI_NO, 		ownrMap.get(JBSbatACIFM053.SEIKY_KEI_NO));						// 請求先番号
		outMap.set(JBSbatACIFI016.SEIKY_YM, 			inMap.get(JBSbatACIFM053.SEIKY_YM));							// 請求年月
		outMap.set(JBSbatACIFI016.SEIRI_NO, 			JBSbatStringUtil.fillHalfSpace((String)ownrMap.get(JBSbatACIFM053.MANSION_ID),this.SEIRI_NO_LEN,true));		// 整理番号（マンションＩＤを設定）
		outMap.set(JBSbatACIFI016.WRIB_SVC_KEI_NO, 		inMap.get(JBSbatACIFM053.WRIB_SVC_KEI_NO));						// 割引サービス契約番号
		outMap.set(JBSbatACIFI016.WRISVC_TRGT_KEI_NO, 	inMap.get(JBSbatACIFM053.WRISVC_TRGT_KEI_NO));					// 割引サービス対象契約番号
		outMap.set(JBSbatACIFI016.SVC_NO, 				ownrMap.get(JBSbatACIFM053.SVC_NO));							// サービス番号
		outMap.set(JBSbatACIFI016.OP_SVKEI_NO, 			inMap.get(JBSbatACIFM053.OP_SVKEI_NO));							// オプションサービス契約番号
		outMap.set(JBSbatACIFI016.SVC_SKBT_CD, 			inMap.get(JBSbatACIFM053.SVC_SKBT_CD));							// 料金サービス識別コード
		outMap.set(JBSbatACIFI016.PRC_GRP_CD, 			ownrMap.get(JBSbatACIFM053.PRC_GRP_CD));						// 料金グループコード
		outMap.set(JBSbatACIFI016.PCRS_CD, 				ownrMap.get(JBSbatACIFM053.PCRS_CD));							// 料金コースコード
		outMap.set(JBSbatACIFI016.PRC_SVC_CD, 			JACStrConst.PRC_SVC_CD_SP);										// 料金サービスコード
		outMap.set(JBSbatACIFI016.PRC_KMK_CD, 			this.tmpPrcKmkCd);												// 料金項目コード
		outMap.set(JBSbatACIFI016.COLLECT_PATTERN_CD, 	dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD));	// 徴収パターンコード
		outMap.set(JBSbatACIFI016.PRC, 					dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC));				// 料金
		outMap.set(JBSbatACIFI016.USE_STAYMD, 			inMap.get(JBSbatACIFM053.USE_STAYMD));							// 利用開始日
		outMap.set(JBSbatACIFI016.USE_ENDYMD, 			inMap.get(JBSbatACIFM053.USE_ENDYMD));							// 利用終了日
		outMap.set(JBSbatACIFI016.SVC_STAYMD, 			inMap.get(JBSbatACIFM053.SVC_STAYMD));							// サービス開始日
		outMap.set(JBSbatACIFI016.FIRST_CHRG_STAYMD, 	inMap.get(JBSbatACIFM053.FIRST_CHRG_STAYMD));					// 初回課金開始日
		outMap.set(JBSbatACIFI016.SVC_DSL_YMD, 			inMap.get(JBSbatACIFM053.SVC_DSL_YMD));							// サービス解約日
		outMap.set(JBSbatACIFI016.SVC_DLRE, 			inMap.get(JBSbatACIFM053.SVC_DLRE));							// サービス解約理由
		outMap.set(JBSbatACIFI016.SVC_KAIHK_DAY, 		inMap.get(JBSbatACIFM053.SVC_KAIHK_DAY));						// サービス回復日
		outMap.set(JBSbatACIFI016.USE_DAY_CNT, 			inMap.get(JBSbatACIFM053.USE_DAY_CNT));							// 利用日数
		outMap.set(JBSbatACIFI016.USE_FAIL_DAY_CNT, 	inMap.get(JBSbatACIFM053.USE_FAIL_DAY_CNT));					// 利用不可日数
		outMap.set(JBSbatACIFI016.AIT_DIV, 				JACStrConst.AITAIKBN_NON);										// 相対区分
		outMap.set(JBSbatACIFI016.SIME_DAY, 			inMap.get(JBSbatACIFM053.SIME_DAY));							// 締め日
		outMap.set(JBSbatACIFI016.USE_APLY_KH_CD, 		JACStrConst.USE_FAIL_APLY_WAY_CD_NON);							// 利用不可適用可否
		outMap.set(JBSbatACIFI016.MAE_YUSEN_JUN, 		JACStrConst.MAE_YUSEN_JUN_0);									// 前受相殺優先順位
		outMap.set(JBSbatACIFI016.WRIB_YUSEN_JUN, 		JACStrConst.WRIB_YUSEN_JUN_0);									// 割引優先順位
		outMap.set(JBSbatACIFI016.UPPL_JUDGE_YUSEN_JUN, JACStrConst.KARA_MOJI);											// 上限判定優先順位
		outMap.set(JBSbatACIFI016.WRIB_KKSHI_KH, 		JACStrConst.WRIB_KKS_H);										// 割引繰越可否
		outMap.set(JBSbatACIFI016.SVC_DTL_SKBT_NO, 		inMap.get(JBSbatACIFM053.SVC_DTL_SKBT_NO));						// サービス詳細識別番号
		
		outMap.setOutFlg(true);
		
		// 出力共通電文に入出力インターフェースを設定する
		outputInItem.addOutMapList(outMap);
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOputInfoIktMansDtlCk]");
		return;
	}
	
	/**
	 * 利用料金情報（全戸一括_部屋番号明細）を出力する。
	 * @param  inMap        利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  ownrMap      利用料金情報（オーナー情報）マップ
	 * @param  dbMap        マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  prc          料金
	 * @param  outputInItem 出力共通電文
	 * @throws Exception    業務サービス内で発生した例外全般
	 */
	private void makeOputInfoIktRmDtl(
					JBSbatServiceInterfaceMap inMap,
					JBSbatServiceInterfaceMap ownrMap,
					JBSbatCommonDBInterface  dbMap,
					BigDecimal prc,
					JBSbatOutputItem outputInItem) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOputInfoIktRmDtl] 全戸一括_部屋番号明細");

		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatACIFI016.SEIKY_KEI_NO, 		ownrMap.get(JBSbatACIFM053.SEIKY_KEI_NO));						// 請求先番号
		outMap.set(JBSbatACIFI016.SEIKY_YM, 			inMap.get(JBSbatACIFM053.SEIKY_YM));							// 請求年月
		outMap.set(JBSbatACIFI016.SEIRI_NO, 			JBSbatStringUtil.fillHalfSpace((String)inMap.get(JBSbatACIFM053.MANSION_ID),this.SEIRI_NO_LEN,true));		// 整理番号（マンションＩＤを設定）
		outMap.set(JBSbatACIFI016.WRIB_SVC_KEI_NO, 		inMap.get(JBSbatACIFM053.WRIB_SVC_KEI_NO));						// 割引サービス契約番号
		outMap.set(JBSbatACIFI016.WRISVC_TRGT_KEI_NO, 	inMap.get(JBSbatACIFM053.WRISVC_TRGT_KEI_NO));					// 割引サービス対象契約番号
		outMap.set(JBSbatACIFI016.SVC_NO, 				inMap.get(JBSbatACIFM053.SVC_NO));								// サービス番号
		outMap.set(JBSbatACIFI016.OP_SVKEI_NO, 			inMap.get(JBSbatACIFM053.OP_SVKEI_NO));							// オプションサービス契約番号
		outMap.set(JBSbatACIFI016.SVC_SKBT_CD, 			inMap.get(JBSbatACIFM053.SVC_SKBT_CD));							// 料金サービス識別コード
		outMap.set(JBSbatACIFI016.PRC_GRP_CD, 			this.tmpGoupCdList.get(0));										// 料金グループコード
		outMap.set(JBSbatACIFI016.PCRS_CD, 				ownrMap.get(JBSbatACIFM053.PCRS_CD));							// 料金コースコード
		outMap.set(JBSbatACIFI016.PRC_SVC_CD, 			ownrMap.get(JBSbatACIFM053.PRC_SVC_CD));						// 料金サービスコード
		outMap.set(JBSbatACIFI016.PRC_KMK_CD, 			dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_KMK_CD));			// 料金項目コード
		outMap.set(JBSbatACIFI016.COLLECT_PATTERN_CD, 	dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD));	// 徴収パターンコード
		outMap.set(JBSbatACIFI016.PRC, 					prc);															// 料金
		outMap.set(JBSbatACIFI016.USE_STAYMD, 			inMap.get(JBSbatACIFM053.USE_STAYMD));							// 利用開始日
		outMap.set(JBSbatACIFI016.USE_ENDYMD, 			inMap.get(JBSbatACIFM053.USE_ENDYMD));							// 利用終了日
		outMap.set(JBSbatACIFI016.SVC_STAYMD, 			inMap.get(JBSbatACIFM053.SVC_STAYMD));							// サービス開始日
		outMap.set(JBSbatACIFI016.FIRST_CHRG_STAYMD, 	inMap.get(JBSbatACIFM053.FIRST_CHRG_STAYMD));					// 初回課金開始日
		outMap.set(JBSbatACIFI016.SVC_DSL_YMD, 			inMap.get(JBSbatACIFM053.SVC_DSL_YMD));							// サービス解約日
		outMap.set(JBSbatACIFI016.SVC_DLRE, 			inMap.get(JBSbatACIFM053.SVC_DLRE));							// サービス解約理由
		outMap.set(JBSbatACIFI016.SVC_KAIHK_DAY, 		inMap.get(JBSbatACIFM053.SVC_KAIHK_DAY));						// サービス回復日
		outMap.set(JBSbatACIFI016.USE_DAY_CNT, 			inMap.get(JBSbatACIFM053.USE_DAY_CNT));							// 利用日数
		outMap.set(JBSbatACIFI016.USE_FAIL_DAY_CNT, 	ownrMap.get(JBSbatACIFM053.USE_FAIL_DAY_CNT));					// 利用不可日数
		outMap.set(JBSbatACIFI016.AIT_DIV, 				JACStrConst.AITAIKBN_NON);										// 相対区分
		outMap.set(JBSbatACIFI016.SIME_DAY, 			inMap.get(JBSbatACIFM053.SIME_DAY));							// 締め日
		outMap.set(JBSbatACIFI016.USE_APLY_KH_CD, 		dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.USE_FAIL_APLY_WAY_CD));// 利用不可適用可否
		outMap.set(JBSbatACIFI016.MAE_YUSEN_JUN, 		JACStrConst.MAE_YUSEN_JUN_0);									// 前受相殺優先順位
		outMap.set(JBSbatACIFI016.WRIB_YUSEN_JUN, 		JACStrConst.WRIB_YUSEN_JUN_0);									// 割引優先順位
		outMap.set(JBSbatACIFI016.UPPL_JUDGE_YUSEN_JUN, JACStrConst.KARA_MOJI);											// 上限判定優先順位
		outMap.set(JBSbatACIFI016.WRIB_KKSHI_KH, 		JACStrConst.WRIB_KKS_H);										// 割引繰越可否
		outMap.set(JBSbatACIFI016.SVC_DTL_SKBT_NO, 		inMap.get(JBSbatACIFM053.SVC_DTL_SKBT_NO));						// サービス詳細識別番号
		
		outMap.setOutFlg(true);
		
		// 出力共通電文に入出力インターフェースを設定する
		outputInItem.addOutMapList(outMap);
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOputInfoIktRmDtl]");
		return;
	}
	
	/**
	 * 利用料金情報（個別(ベース居住者／増速差額)_部屋番号明細）を出力する。
	 * @param  inMap        利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  dbMap        マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  outputInItem 出力共通電文
	 * @throws Exception    業務サービス内で発生した例外全般
	 */
	private void makeOputInfoIktKobetsuRmDtl(
					JBSbatServiceInterfaceMap inMap,
					JBSbatCommonDBInterface  dbMap,
					JBSbatOutputItem outputInItem) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOputInfoIktKobetsuRmDtl] 個別(ベース居住者／増速差額)_部屋番号明細");

		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatACIFI016.SEIKY_KEI_NO, 		inMap.get(JBSbatACIFM053.SEIKY_KEI_NO));						// 請求先番号
		outMap.set(JBSbatACIFI016.SEIKY_YM, 			inMap.get(JBSbatACIFM053.SEIKY_YM));							// 請求年月
		outMap.set(JBSbatACIFI016.SEIRI_NO, 			inMap.get(JBSbatACIFM053.SEIRI_NO));							// 整理番号
		outMap.set(JBSbatACIFI016.WRIB_SVC_KEI_NO, 		inMap.get(JBSbatACIFM053.WRIB_SVC_KEI_NO));						// 割引サービス契約番号
		outMap.set(JBSbatACIFI016.WRISVC_TRGT_KEI_NO, 	inMap.get(JBSbatACIFM053.WRISVC_TRGT_KEI_NO));					// 割引サービス対象契約番号
		outMap.set(JBSbatACIFI016.SVC_NO, 				inMap.get(JBSbatACIFM053.SVC_NO));								// サービス番号
		outMap.set(JBSbatACIFI016.OP_SVKEI_NO, 			inMap.get(JBSbatACIFM053.OP_SVKEI_NO));							// オプションサービス契約番号
		outMap.set(JBSbatACIFI016.SVC_SKBT_CD, 			inMap.get(JBSbatACIFM053.SVC_SKBT_CD));							// 料金サービス識別コード
		outMap.set(JBSbatACIFI016.PRC_GRP_CD, 			inMap.get(JBSbatACIFM053.PRC_GRP_CD));							// 料金グループコード
		outMap.set(JBSbatACIFI016.PCRS_CD, 				inMap.get(JBSbatACIFM053.PCRS_CD));								// 料金コースコード
		outMap.set(JBSbatACIFI016.PRC_SVC_CD, 			inMap.get(JBSbatACIFM053.PRC_SVC_CD));							// 料金サービスコード
		outMap.set(JBSbatACIFI016.PRC_KMK_CD, 			dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_KMK_CD));			// 料金項目コード
		outMap.set(JBSbatACIFI016.COLLECT_PATTERN_CD, 	dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD));	// 徴収パターンコード
		outMap.set(JBSbatACIFI016.PRC, 					dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC));				// 料金
		outMap.set(JBSbatACIFI016.USE_STAYMD, 			inMap.get(JBSbatACIFM053.USE_STAYMD));							// 利用開始日
		outMap.set(JBSbatACIFI016.USE_ENDYMD, 			inMap.get(JBSbatACIFM053.USE_ENDYMD));							// 利用終了日
		outMap.set(JBSbatACIFI016.SVC_STAYMD, 			inMap.get(JBSbatACIFM053.SVC_STAYMD));							// サービス開始日
		outMap.set(JBSbatACIFI016.FIRST_CHRG_STAYMD, 	inMap.get(JBSbatACIFM053.FIRST_CHRG_STAYMD));					// 初回課金開始日
		outMap.set(JBSbatACIFI016.SVC_DSL_YMD, 			inMap.get(JBSbatACIFM053.SVC_DSL_YMD));							// サービス解約日
		outMap.set(JBSbatACIFI016.SVC_DLRE, 			inMap.get(JBSbatACIFM053.SVC_DLRE));							// サービス解約理由
		outMap.set(JBSbatACIFI016.SVC_KAIHK_DAY, 		inMap.get(JBSbatACIFM053.SVC_KAIHK_DAY));						// サービス回復日
		outMap.set(JBSbatACIFI016.USE_DAY_CNT, 			inMap.get(JBSbatACIFM053.USE_DAY_CNT));							// 利用日数
		outMap.set(JBSbatACIFI016.USE_FAIL_DAY_CNT, 	inMap.get(JBSbatACIFM053.USE_FAIL_DAY_CNT));					// 利用不可日数
		outMap.set(JBSbatACIFI016.AIT_DIV, 				JACStrConst.AITAIKBN_NON);										// 相対区分
		outMap.set(JBSbatACIFI016.SIME_DAY, 			inMap.get(JBSbatACIFM053.SIME_DAY));							// 締め日
		outMap.set(JBSbatACIFI016.USE_APLY_KH_CD, 		dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.USE_FAIL_APLY_WAY_CD));// 利用不可適用可否
		outMap.set(JBSbatACIFI016.MAE_YUSEN_JUN, 		JACStrConst.MAE_YUSEN_JUN_0);									// 前受相殺優先順位
		outMap.set(JBSbatACIFI016.WRIB_YUSEN_JUN, 		JACStrConst.WRIB_YUSEN_JUN_0);									// 割引優先順位
		outMap.set(JBSbatACIFI016.UPPL_JUDGE_YUSEN_JUN, JACStrConst.KARA_MOJI);											// 上限判定優先順位
		outMap.set(JBSbatACIFI016.WRIB_KKSHI_KH, 		JACStrConst.WRIB_KKS_H);										// 割引繰越可否
		outMap.set(JBSbatACIFI016.SVC_DTL_SKBT_NO, 		inMap.get(JBSbatACIFM053.SVC_DTL_SKBT_NO));						// サービス詳細識別番号
		
		outMap.setOutFlg(true);
		
		// 出力共通電文に入出力インターフェースを設定する
		outputInItem.addOutMapList(outMap);
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOputInfoIktKobetsuRmDtl]");
		return;
	}
	
	/**
	 * 利用料金情報（全戸一括_部屋番号明細(未入居)）を出力する。
	 * @param  ownrMap      退避．利用料金情報（オーナー情報）リスト
	 * @param  dbMap        マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  prc          料金
	 * @param  outputInItem 出力共通電文
	 * @throws Exception    業務サービス内で発生した例外全般
	 */
	private void makeOputInfoIktMinyukyo(
					JBSbatServiceInterfaceMap ownrMap,
					JBSbatCommonDBInterface  dbMap,
					BigDecimal prc,
					JBSbatOutputItem outputInItem) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOputInfoIktMinyukyo] 全戸一括_部屋番号明細(未入居)");

		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatACIFI016.SEIKY_KEI_NO, 		ownrMap.get(JBSbatACIFM053.SEIKY_KEI_NO));						// 請求先番号
		outMap.set(JBSbatACIFI016.SEIKY_YM, 			ownrMap.get(JBSbatACIFM053.SEIKY_YM));							// 請求年月
		outMap.set(JBSbatACIFI016.SEIRI_NO, 			JBSbatStringUtil.fillHalfSpace((String)ownrMap.get(JBSbatACIFM053.MANSION_ID),this.SEIRI_NO_LEN,true));		// 整理番号（マンションＩＤを設定）
		outMap.set(JBSbatACIFI016.WRIB_SVC_KEI_NO, 		ownrMap.get(JBSbatACIFM053.WRIB_SVC_KEI_NO));					// 割引サービス契約番号
		outMap.set(JBSbatACIFI016.WRISVC_TRGT_KEI_NO, 	ownrMap.get(JBSbatACIFM053.WRISVC_TRGT_KEI_NO));				// 割引サービス対象契約番号
		outMap.set(JBSbatACIFI016.SVC_NO, 				this.minyukyoSvcKeiNo);											// サービス番号
		outMap.set(JBSbatACIFI016.OP_SVKEI_NO, 			ownrMap.get(JBSbatACIFM053.OP_SVKEI_NO));						// オプションサービス契約番号
		outMap.set(JBSbatACIFI016.SVC_SKBT_CD, 			ownrMap.get(JBSbatACIFM053.SVC_SKBT_CD));						// 料金サービス識別コード
		outMap.set(JBSbatACIFI016.PRC_GRP_CD, 			ownrMap.get(JBSbatACIFM053.PRC_GRP_CD));						// 料金グループコード
		outMap.set(JBSbatACIFI016.PCRS_CD, 				ownrMap.get(JBSbatACIFM053.PCRS_CD));							// 料金コースコード
		outMap.set(JBSbatACIFI016.PRC_SVC_CD, 			ownrMap.get(JBSbatACIFM053.PRC_SVC_CD));						// 料金サービスコード
		outMap.set(JBSbatACIFI016.PRC_KMK_CD, 			dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_KMK_CD));			// 料金項目コード
		outMap.set(JBSbatACIFI016.COLLECT_PATTERN_CD, 	dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD));	// 徴収パターンコード
		outMap.set(JBSbatACIFI016.PRC, 					prc);															// 料金
		outMap.set(JBSbatACIFI016.USE_STAYMD, 			ownrMap.get(JBSbatACIFM053.USE_STAYMD));						// 利用開始日
		outMap.set(JBSbatACIFI016.USE_ENDYMD, 			ownrMap.get(JBSbatACIFM053.USE_ENDYMD));						// 利用終了日
		outMap.set(JBSbatACIFI016.SVC_STAYMD, 			ownrMap.get(JBSbatACIFM053.SVC_STAYMD));						// サービス開始日
		outMap.set(JBSbatACIFI016.FIRST_CHRG_STAYMD, 	ownrMap.get(JBSbatACIFM053.FIRST_CHRG_STAYMD));					// 初回課金開始日
		outMap.set(JBSbatACIFI016.SVC_DSL_YMD, 			ownrMap.get(JBSbatACIFM053.SVC_DSL_YMD));						// サービス解約日
		outMap.set(JBSbatACIFI016.SVC_DLRE, 			ownrMap.get(JBSbatACIFM053.SVC_DLRE));							// サービス解約理由
		outMap.set(JBSbatACIFI016.SVC_KAIHK_DAY, 		ownrMap.get(JBSbatACIFM053.SVC_KAIHK_DAY));						// サービス回復日
		outMap.set(JBSbatACIFI016.USE_DAY_CNT, 			ownrMap.get(JBSbatACIFM053.USE_DAY_CNT));						// 利用日数
		outMap.set(JBSbatACIFI016.USE_FAIL_DAY_CNT, 	ownrMap.get(JBSbatACIFM053.USE_FAIL_DAY_CNT));					// 利用不可日数
		outMap.set(JBSbatACIFI016.AIT_DIV, 				JACStrConst.AITAIKBN_NON);										// 相対区分
		outMap.set(JBSbatACIFI016.SIME_DAY, 			ownrMap.get(JBSbatACIFM053.SIME_DAY));							// 締め日
		outMap.set(JBSbatACIFI016.USE_APLY_KH_CD, 		dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.USE_FAIL_APLY_WAY_CD));// 利用不可適用可否
		outMap.set(JBSbatACIFI016.MAE_YUSEN_JUN, 		JACStrConst.MAE_YUSEN_JUN_0);									// 前受相殺優先順位
		outMap.set(JBSbatACIFI016.WRIB_YUSEN_JUN, 		JACStrConst.WRIB_YUSEN_JUN_0);									// 割引優先順位
		outMap.set(JBSbatACIFI016.UPPL_JUDGE_YUSEN_JUN, JACStrConst.KARA_MOJI);											// 上限判定優先順位
		outMap.set(JBSbatACIFI016.WRIB_KKSHI_KH, 		JACStrConst.WRIB_KKS_H);										// 割引繰越可否
		outMap.set(JBSbatACIFI016.SVC_DTL_SKBT_NO, 		ownrMap.get(JBSbatACIFM053.SVC_DTL_SKBT_NO));						// サービス詳細識別番号
		
		outMap.setOutFlg(true);
		
		// 出力共通電文に入出力インターフェースを設定する
		outputInItem.addOutMapList(outMap);
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOputInfoIktMinyukyo]");
		return;
	}
	
	/**
	 * 利用料金情報（居住者一括_マンションID明細）を出力する。
	 * @param  inMap        利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  ownrMap      利用料金情報（オーナー情報）マップ
	 * @param  dbMap        マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  outputInItem 出力共通電文
	 * @throws Exception    業務サービス内で発生した例外全般
	 */
	private void makeOputInfoJkyoMansDtl(
					JBSbatServiceInterfaceMap inMap,
					JBSbatServiceInterfaceMap ownrMap,
					JBSbatCommonDBInterface dbMap,
					JBSbatOutputItem outputInItem) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOputInfoJkyoMansDtl] 居住者一括_マンションID明細");
		
		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();
		
		outMap.set(JBSbatACIFI016.SEIKY_KEI_NO, 		ownrMap.get(JBSbatACIFM053.SEIKY_KEI_NO));						// 請求先番号
		outMap.set(JBSbatACIFI016.SEIKY_YM, 			inMap.get(JBSbatACIFM053.SEIKY_YM));							// 請求年月
		outMap.set(JBSbatACIFI016.SEIRI_NO, 			JBSbatStringUtil.fillHalfSpace((String)inMap.get(JBSbatACIFM053.MANSION_ID),this.SEIRI_NO_LEN,true));		// 整理番号（マンションID）
		outMap.set(JBSbatACIFI016.WRIB_SVC_KEI_NO, 		inMap.get(JBSbatACIFM053.WRIB_SVC_KEI_NO));						// 割引サービス契約番号
		outMap.set(JBSbatACIFI016.WRISVC_TRGT_KEI_NO, 	inMap.get(JBSbatACIFM053.WRISVC_TRGT_KEI_NO));					// 割引サービス対象契約番号
		outMap.set(JBSbatACIFI016.SVC_NO, 				ownrMap.get(JBSbatACIFM053.SVC_NO));							// サービス番号
		outMap.set(JBSbatACIFI016.OP_SVKEI_NO, 			inMap.get(JBSbatACIFM053.OP_SVKEI_NO));							// オプションサービス契約番号
		outMap.set(JBSbatACIFI016.SVC_SKBT_CD, 			inMap.get(JBSbatACIFM053.SVC_SKBT_CD));							// 料金サービス識別コード
		outMap.set(JBSbatACIFI016.PRC_GRP_CD, 			ownrMap.get(JBSbatACIFM053.PRC_GRP_CD));						// 料金グループコード
		outMap.set(JBSbatACIFI016.PCRS_CD, 				ownrMap.get(JBSbatACIFM053.PCRS_CD));							// 料金コースコード
		outMap.set(JBSbatACIFI016.PRC_SVC_CD, 			ownrMap.get(JBSbatACIFM053.PRC_SVC_CD));						// 料金サービスコード
		outMap.set(JBSbatACIFI016.PRC_KMK_CD, 			convPrcKmkCd(outMap, dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_KMK_CD)));// 料金項目コード
		outMap.set(JBSbatACIFI016.COLLECT_PATTERN_CD, 	dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD));	// 徴収パターンコード
		outMap.set(JBSbatACIFI016.PRC, 					dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC));				// 料金
		outMap.set(JBSbatACIFI016.USE_STAYMD, 			inMap.get(JBSbatACIFM053.USE_STAYMD));							// 利用開始日
		outMap.set(JBSbatACIFI016.USE_ENDYMD, 			inMap.get(JBSbatACIFM053.USE_ENDYMD));							// 利用終了日
		outMap.set(JBSbatACIFI016.SVC_STAYMD, 			inMap.get(JBSbatACIFM053.SVC_STAYMD));							// サービス開始日
		outMap.set(JBSbatACIFI016.FIRST_CHRG_STAYMD, 	inMap.get(JBSbatACIFM053.FIRST_CHRG_STAYMD));					// 初回課金開始日
		outMap.set(JBSbatACIFI016.SVC_DSL_YMD, 			inMap.get(JBSbatACIFM053.SVC_DSL_YMD));							// サービス解約日
		outMap.set(JBSbatACIFI016.SVC_DLRE, 			inMap.get(JBSbatACIFM053.SVC_DLRE));							// サービス解約理由
		outMap.set(JBSbatACIFI016.SVC_KAIHK_DAY, 		inMap.get(JBSbatACIFM053.SVC_KAIHK_DAY));						// サービス回復日
		outMap.set(JBSbatACIFI016.USE_DAY_CNT, 			inMap.get(JBSbatACIFM053.USE_DAY_CNT));							// 利用日数
		outMap.set(JBSbatACIFI016.USE_FAIL_DAY_CNT, 	ownrMap.get(JBSbatACIFM053.USE_FAIL_DAY_CNT));					// 利用不可日数
		outMap.set(JBSbatACIFI016.AIT_DIV, 				JACStrConst.AITAIKBN_NON);										// 相対区分
		outMap.set(JBSbatACIFI016.SIME_DAY, 			inMap.get(JBSbatACIFM053.SIME_DAY));							// 締め日
		outMap.set(JBSbatACIFI016.USE_APLY_KH_CD, 		dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.USE_FAIL_APLY_WAY_CD));// 利用不可適用可否
		outMap.set(JBSbatACIFI016.MAE_YUSEN_JUN, 		JACStrConst.MAE_YUSEN_JUN_0);									// 前受相殺優先順位
		outMap.set(JBSbatACIFI016.WRIB_YUSEN_JUN, 		JACStrConst.WRIB_YUSEN_JUN_0);									// 割引優先順位
		outMap.set(JBSbatACIFI016.UPPL_JUDGE_YUSEN_JUN, JACStrConst.KARA_MOJI);											// 上限判定優先順位
		outMap.set(JBSbatACIFI016.WRIB_KKSHI_KH, 		JACStrConst.WRIB_KKS_H);										// 割引繰越可否
		outMap.set(JBSbatACIFI016.SVC_DTL_SKBT_NO, 		inMap.get(JBSbatACIFM053.SVC_DTL_SKBT_NO));						// サービス詳細識別番号
		
		outMap.setOutFlg(true);
		
		// 出力共通電文に入出力インターフェースを設定する
		outputInItem.addOutMapList(outMap);
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOputInfoJkyoMansDtl]");
		return;
	}
	
	/**
	 * 利用料金情報（居住者一括_マンションID明細_中計）を出力する。
	 * @param  inMap       利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  ownrMap     利用料金情報（オーナー情報）マップ
	 * @param  dbMap       マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  prc         料金
	 * @param outputInItem 出力共通電文
	 * @throws Exception   業務サービス内で発生した例外全般
	 */
	private void makeOputInfoJkyoMansDtlCk(
					JBSbatServiceInterfaceMap inMap,
					JBSbatServiceInterfaceMap ownrMap,
					JBSbatCommonDBInterface  dbMap,
					BigDecimal prc,
					JBSbatOutputItem outputInItem) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOputInfoJkyoMansDtlCk] 居住者一括_マンションID明細_中計");

		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatACIFI016.SEIKY_KEI_NO, 		ownrMap.get(JBSbatACIFM053.SEIKY_KEI_NO));						// 請求先番号
		outMap.set(JBSbatACIFI016.SEIKY_YM, 			inMap.get(JBSbatACIFM053.SEIKY_YM));							// 請求年月
		outMap.set(JBSbatACIFI016.SEIRI_NO, 			JBSbatStringUtil.fillHalfSpace((String)inMap.get(JBSbatACIFM053.MANSION_ID),this.SEIRI_NO_LEN,true));		// 整理番号（マンションID）
		outMap.set(JBSbatACIFI016.WRIB_SVC_KEI_NO, 		inMap.get(JBSbatACIFM053.WRIB_SVC_KEI_NO));						// 割引サービス契約番号
		outMap.set(JBSbatACIFI016.WRISVC_TRGT_KEI_NO, 	inMap.get(JBSbatACIFM053.WRISVC_TRGT_KEI_NO));					// 割引サービス対象契約番号
		outMap.set(JBSbatACIFI016.SVC_NO, 				ownrMap.get(JBSbatACIFM053.SVC_NO));							// サービス番号
		outMap.set(JBSbatACIFI016.OP_SVKEI_NO, 			inMap.get(JBSbatACIFM053.OP_SVKEI_NO));							// オプションサービス契約番号
		outMap.set(JBSbatACIFI016.SVC_SKBT_CD, 			inMap.get(JBSbatACIFM053.SVC_SKBT_CD));							// 料金サービス識別コード
		outMap.set(JBSbatACIFI016.PRC_GRP_CD, 			ownrMap.get(JBSbatACIFM053.PRC_GRP_CD));						// 料金グループコード
		outMap.set(JBSbatACIFI016.PCRS_CD, 				ownrMap.get(JBSbatACIFM053.PCRS_CD));							// 料金コースコード
		outMap.set(JBSbatACIFI016.PRC_SVC_CD, 			JACStrConst.PRC_SVC_CD_SP);										// 料金サービスコード
		outMap.set(JBSbatACIFI016.PRC_KMK_CD, 			this.tmpPrcKmkCd);												// 料金項目コード
		outMap.set(JBSbatACIFI016.COLLECT_PATTERN_CD, 	dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD));	// 徴収パターンコード
		outMap.set(JBSbatACIFI016.PRC, 					prc);															// 料金
		outMap.set(JBSbatACIFI016.USE_STAYMD, 			inMap.get(JBSbatACIFM053.USE_STAYMD));							// 利用開始日
		outMap.set(JBSbatACIFI016.USE_ENDYMD, 			inMap.get(JBSbatACIFM053.USE_ENDYMD));							// 利用終了日
		outMap.set(JBSbatACIFI016.SVC_STAYMD, 			inMap.get(JBSbatACIFM053.SVC_STAYMD));							// サービス開始日
		outMap.set(JBSbatACIFI016.FIRST_CHRG_STAYMD, 	inMap.get(JBSbatACIFM053.FIRST_CHRG_STAYMD));					// 初回課金開始日
		outMap.set(JBSbatACIFI016.SVC_DSL_YMD, 			inMap.get(JBSbatACIFM053.SVC_DSL_YMD));							// サービス解約日
		outMap.set(JBSbatACIFI016.SVC_DLRE, 			inMap.get(JBSbatACIFM053.SVC_DLRE));							// サービス解約理由
		outMap.set(JBSbatACIFI016.SVC_KAIHK_DAY, 		inMap.get(JBSbatACIFM053.SVC_KAIHK_DAY));						// サービス回復日
		outMap.set(JBSbatACIFI016.USE_DAY_CNT, 			inMap.get(JBSbatACIFM053.USE_DAY_CNT));							// 利用日数
		outMap.set(JBSbatACIFI016.USE_FAIL_DAY_CNT, 	inMap.get(JBSbatACIFM053.USE_FAIL_DAY_CNT));					// 利用不可日数
		outMap.set(JBSbatACIFI016.AIT_DIV, 				JACStrConst.AITAIKBN_NON);										// 相対区分
		outMap.set(JBSbatACIFI016.SIME_DAY, 			inMap.get(JBSbatACIFM053.SIME_DAY));							// 締め日
		outMap.set(JBSbatACIFI016.USE_APLY_KH_CD, 		JACStrConst.USE_FAIL_APLY_WAY_CD_NON);							// 利用不可適用可否
		outMap.set(JBSbatACIFI016.MAE_YUSEN_JUN, 		JACStrConst.MAE_YUSEN_JUN_0);									// 前受相殺優先順位
		outMap.set(JBSbatACIFI016.WRIB_YUSEN_JUN, 		JACStrConst.WRIB_YUSEN_JUN_0);									// 割引優先順位
		outMap.set(JBSbatACIFI016.UPPL_JUDGE_YUSEN_JUN, JACStrConst.KARA_MOJI);											// 上限判定優先順位
		outMap.set(JBSbatACIFI016.WRIB_KKSHI_KH, 		JACStrConst.WRIB_KKS_H);										// 割引繰越可否
		outMap.set(JBSbatACIFI016.SVC_DTL_SKBT_NO, 		inMap.get(JBSbatACIFM053.SVC_DTL_SKBT_NO));						// サービス詳細識別番号
		
		outMap.setOutFlg(true);
		
		// 出力共通電文に入出力インターフェースを設定する
		outputInItem.addOutMapList(outMap);
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOputInfoJkyoMansDtlCk]");
		return;
	}
	
	/**
	 * 利用料金情報（居住者一括_部屋番号明細）を出力する。
	 * @param  inMap        利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  ownrMap      利用料金情報（オーナー情報）マップ
	 * @param  dbMap        マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  outputInItem 出力共通電文
	 * @throws Exception    業務サービス内で発生した例外全般
	 */
	private void makeOputInfoJkyoRmDtl(
					JBSbatServiceInterfaceMap inMap,
					JBSbatServiceInterfaceMap ownrMap,
					JBSbatCommonDBInterface  dbMap,
					JBSbatOutputItem outputInItem) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOputInfoJkyoRmDtl] 居住者一括_部屋番号明細");

		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatACIFI016.SEIKY_KEI_NO, 		ownrMap.get(JBSbatACIFM053.SEIKY_KEI_NO));						// 請求先番号
		outMap.set(JBSbatACIFI016.SEIKY_YM, 			inMap.get(JBSbatACIFM053.SEIKY_YM));							// 請求年月
		outMap.set(JBSbatACIFI016.SEIRI_NO, 			JBSbatStringUtil.fillHalfSpace((String)inMap.get(JBSbatACIFM053.MANSION_ID),this.SEIRI_NO_LEN,true));		// 整理番号（マンションID）
		outMap.set(JBSbatACIFI016.WRIB_SVC_KEI_NO, 		inMap.get(JBSbatACIFM053.WRIB_SVC_KEI_NO));						// 割引サービス契約番号
		outMap.set(JBSbatACIFI016.WRISVC_TRGT_KEI_NO, 	inMap.get(JBSbatACIFM053.WRISVC_TRGT_KEI_NO));					// 割引サービス対象契約番号
		outMap.set(JBSbatACIFI016.SVC_NO, 				inMap.get(JBSbatACIFM053.SVC_NO));								// サービス番号
		outMap.set(JBSbatACIFI016.OP_SVKEI_NO, 			inMap.get(JBSbatACIFM053.OP_SVKEI_NO));							// オプションサービス契約番号
		outMap.set(JBSbatACIFI016.SVC_SKBT_CD, 			inMap.get(JBSbatACIFM053.SVC_SKBT_CD));							// 料金サービス識別コード
		outMap.set(JBSbatACIFI016.PRC_GRP_CD, 			this.tmpGoupCdList.get(0));										// 料金グループコード
		outMap.set(JBSbatACIFI016.PCRS_CD, 				ownrMap.get(JBSbatACIFM053.PCRS_CD));								// 料金コースコード
		outMap.set(JBSbatACIFI016.PRC_SVC_CD, 			ownrMap.get(JBSbatACIFM053.PRC_SVC_CD));							// 料金サービスコード
		outMap.set(JBSbatACIFI016.PRC_KMK_CD, 			dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_KMK_CD));			// 料金項目コード
		outMap.set(JBSbatACIFI016.COLLECT_PATTERN_CD, 	dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD));	// 徴収パターンコード
		outMap.set(JBSbatACIFI016.PRC, 					dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC));				// 料金
		outMap.set(JBSbatACIFI016.USE_STAYMD, 			inMap.get(JBSbatACIFM053.USE_STAYMD));							// 利用開始日
		outMap.set(JBSbatACIFI016.USE_ENDYMD, 			inMap.get(JBSbatACIFM053.USE_ENDYMD));							// 利用終了日
		outMap.set(JBSbatACIFI016.SVC_STAYMD, 			inMap.get(JBSbatACIFM053.SVC_STAYMD));							// サービス開始日
		outMap.set(JBSbatACIFI016.FIRST_CHRG_STAYMD, 	inMap.get(JBSbatACIFM053.FIRST_CHRG_STAYMD));					// 初回課金開始日
		outMap.set(JBSbatACIFI016.SVC_DSL_YMD, 			inMap.get(JBSbatACIFM053.SVC_DSL_YMD));							// サービス解約日
		outMap.set(JBSbatACIFI016.SVC_DLRE, 			inMap.get(JBSbatACIFM053.SVC_DLRE));							// サービス解約理由
		outMap.set(JBSbatACIFI016.SVC_KAIHK_DAY, 		inMap.get(JBSbatACIFM053.SVC_KAIHK_DAY));						// サービス回復日
		outMap.set(JBSbatACIFI016.USE_DAY_CNT, 			inMap.get(JBSbatACIFM053.USE_DAY_CNT));							// 利用日数
		outMap.set(JBSbatACIFI016.USE_FAIL_DAY_CNT, 	ownrMap.get(JBSbatACIFM053.USE_FAIL_DAY_CNT));					// 利用不可日数
		outMap.set(JBSbatACIFI016.AIT_DIV, 				JACStrConst.AITAIKBN_NON);										// 相対区分
		outMap.set(JBSbatACIFI016.SIME_DAY, 			inMap.get(JBSbatACIFM053.SIME_DAY));							// 締め日
		outMap.set(JBSbatACIFI016.USE_APLY_KH_CD, 		dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.USE_FAIL_APLY_WAY_CD));// 利用不可適用可否
		outMap.set(JBSbatACIFI016.MAE_YUSEN_JUN, 		JACStrConst.MAE_YUSEN_JUN_0);									// 前受相殺優先順位
		outMap.set(JBSbatACIFI016.WRIB_YUSEN_JUN, 		JACStrConst.WRIB_YUSEN_JUN_0);									// 割引優先順位
		outMap.set(JBSbatACIFI016.UPPL_JUDGE_YUSEN_JUN, JACStrConst.KARA_MOJI);											// 上限判定優先順位
		outMap.set(JBSbatACIFI016.WRIB_KKSHI_KH, 		JACStrConst.WRIB_KKS_H);										// 割引繰越可否
		outMap.set(JBSbatACIFI016.SVC_DTL_SKBT_NO, 		inMap.get(JBSbatACIFM053.SVC_DTL_SKBT_NO));						// サービス詳細識別番号
		
		outMap.setOutFlg(true);
		
		// 出力共通電文に入出力インターフェースを設定する
		outputInItem.addOutMapList(outMap);
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOputInfoJkyoRmDtl]");
		return;
	}
	
	/**
	 * 利用料金情報（ベース_マンションID明細）を出力する。
	 * @param  inMap        利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  ownrMap      利用料金情報（オーナー情報）マップ
	 * @param  dbMap        マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  outputInItem 出力共通電文
	 * @throws Exception  業務サービス内で発生した例外全般
	 */
	private void makeOputInfoBaseMansDtl(
					JBSbatServiceInterfaceMap inMap,
					JBSbatServiceInterfaceMap ownrMap,
					JBSbatCommonDBInterface  dbMap,
					JBSbatOutputItem outputInItem) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOputInfoBaseMansDtl] ベース_マンションID明細");

		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatACIFI016.SEIKY_KEI_NO, 		ownrMap.get(JBSbatACIFM053.SEIKY_KEI_NO));						// 請求先番号
		outMap.set(JBSbatACIFI016.SEIKY_YM, 			inMap.get(JBSbatACIFM053.SEIKY_YM));							// 請求年月
		outMap.set(JBSbatACIFI016.SEIRI_NO, 			JBSbatStringUtil.fillHalfSpace((String)inMap.get(JBSbatACIFM053.MANSION_ID),this.SEIRI_NO_LEN,true));		// 整理番号（マンションID）
		outMap.set(JBSbatACIFI016.WRIB_SVC_KEI_NO, 		inMap.get(JBSbatACIFM053.WRIB_SVC_KEI_NO));						// 割引サービス契約番号
		outMap.set(JBSbatACIFI016.WRISVC_TRGT_KEI_NO, 	inMap.get(JBSbatACIFM053.WRISVC_TRGT_KEI_NO));					// 割引サービス対象契約番号
		outMap.set(JBSbatACIFI016.SVC_NO, 				ownrMap.get(JBSbatACIFM053.SVC_NO));							// サービス番号
		outMap.set(JBSbatACIFI016.OP_SVKEI_NO, 			inMap.get(JBSbatACIFM053.OP_SVKEI_NO));							// オプションサービス契約番号
		outMap.set(JBSbatACIFI016.SVC_SKBT_CD, 			inMap.get(JBSbatACIFM053.SVC_SKBT_CD));							// 料金サービス識別コード
		outMap.set(JBSbatACIFI016.PRC_GRP_CD, 			ownrMap.get(JBSbatACIFM053.PRC_GRP_CD));						// 料金グループコード
		outMap.set(JBSbatACIFI016.PCRS_CD, 				ownrMap.get(JBSbatACIFM053.PCRS_CD));							// 料金コースコード
		outMap.set(JBSbatACIFI016.PRC_SVC_CD, 			ownrMap.get(JBSbatACIFM053.PRC_SVC_CD));						// 料金サービスコード
		outMap.set(JBSbatACIFI016.PRC_KMK_CD, 			convPrcKmkCd(outMap, dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_KMK_CD)));// 料金項目コード
		outMap.set(JBSbatACIFI016.COLLECT_PATTERN_CD, 	dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD));	// 徴収パターンコード
		outMap.set(JBSbatACIFI016.PRC, 					dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC));				// 料金
		outMap.set(JBSbatACIFI016.USE_STAYMD, 			inMap.get(JBSbatACIFM053.USE_STAYMD));							// 利用開始日
		outMap.set(JBSbatACIFI016.USE_ENDYMD, 			inMap.get(JBSbatACIFM053.USE_ENDYMD));							// 利用終了日
		outMap.set(JBSbatACIFI016.SVC_STAYMD, 			inMap.get(JBSbatACIFM053.SVC_STAYMD));							// サービス開始日
		outMap.set(JBSbatACIFI016.FIRST_CHRG_STAYMD, 	inMap.get(JBSbatACIFM053.FIRST_CHRG_STAYMD));					// 初回課金開始日
		outMap.set(JBSbatACIFI016.SVC_DSL_YMD, 			inMap.get(JBSbatACIFM053.SVC_DSL_YMD));							// サービス解約日
		outMap.set(JBSbatACIFI016.SVC_DLRE, 			inMap.get(JBSbatACIFM053.SVC_DLRE));							// サービス解約理由
		outMap.set(JBSbatACIFI016.SVC_KAIHK_DAY, 		inMap.get(JBSbatACIFM053.SVC_KAIHK_DAY));						// サービス回復日
		outMap.set(JBSbatACIFI016.USE_DAY_CNT, 			inMap.get(JBSbatACIFM053.USE_DAY_CNT));							// 利用日数
		outMap.set(JBSbatACIFI016.USE_FAIL_DAY_CNT, 	ownrMap.get(JBSbatACIFM053.USE_FAIL_DAY_CNT));					// 利用不可日数
		outMap.set(JBSbatACIFI016.AIT_DIV, 				JACStrConst.AITAIKBN_NON);										// 相対区分
		outMap.set(JBSbatACIFI016.SIME_DAY, 			inMap.get(JBSbatACIFM053.SIME_DAY));							// 締め日
		outMap.set(JBSbatACIFI016.USE_APLY_KH_CD, 		dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.USE_FAIL_APLY_WAY_CD));// 利用不可適用可否
		outMap.set(JBSbatACIFI016.MAE_YUSEN_JUN, 		JACStrConst.MAE_YUSEN_JUN_0);									// 前受相殺優先順位
		outMap.set(JBSbatACIFI016.WRIB_YUSEN_JUN, 		JACStrConst.WRIB_YUSEN_JUN_0);									// 割引優先順位
		outMap.set(JBSbatACIFI016.UPPL_JUDGE_YUSEN_JUN, JACStrConst.KARA_MOJI);											// 上限判定優先順位
		outMap.set(JBSbatACIFI016.WRIB_KKSHI_KH, 		JACStrConst.WRIB_KKS_H);										// 割引繰越可否
		outMap.set(JBSbatACIFI016.SVC_DTL_SKBT_NO, 		inMap.get(JBSbatACIFM053.SVC_DTL_SKBT_NO));						// サービス詳細識別番号
		
		outMap.setOutFlg(true);
		
		// 出力共通電文に入出力インターフェースを設定する
		outputInItem.addOutMapList(outMap);
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOputInfoBaseMansDtl]");
		return;
	}
	
	/**
	 * 利用料金情報（ベース_マンションID明細_中計）を出力する。
	 * @param  inMap        利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  ownrMap      利用料金情報（オーナー情報）マップ
	 * @param  dbMap        マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  prc          料金
	 * @param  outputInItem 出力共通電文
	 * @throws Exception    業務サービス内で発生した例外全般
	 */
	private void makeOputInfoBaseMansDtlCk(
					JBSbatServiceInterfaceMap inMap,
					JBSbatServiceInterfaceMap ownrMap,
					JBSbatCommonDBInterface  dbMap,
					BigDecimal prc,
					JBSbatOutputItem outputInItem) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOputInfoBaseMansDtlCk] ベース_マンションID明細_中計");

		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatACIFI016.SEIKY_KEI_NO, 		ownrMap.get(JBSbatACIFM053.SEIKY_KEI_NO));						// 請求先番号
		outMap.set(JBSbatACIFI016.SEIKY_YM, 			inMap.get(JBSbatACIFM053.SEIKY_YM));							// 請求年月
		outMap.set(JBSbatACIFI016.SEIRI_NO, 			JBSbatStringUtil.fillHalfSpace((String)inMap.get(JBSbatACIFM053.MANSION_ID),this.SEIRI_NO_LEN,true));		// 整理番号（マンションID）
		outMap.set(JBSbatACIFI016.WRIB_SVC_KEI_NO, 		inMap.get(JBSbatACIFM053.WRIB_SVC_KEI_NO));						// 割引サービス契約番号
		outMap.set(JBSbatACIFI016.WRISVC_TRGT_KEI_NO, 	inMap.get(JBSbatACIFM053.WRISVC_TRGT_KEI_NO));					// 割引サービス対象契約番号
		outMap.set(JBSbatACIFI016.SVC_NO, 				ownrMap.get(JBSbatACIFM053.SVC_NO));							// サービス番号
		outMap.set(JBSbatACIFI016.OP_SVKEI_NO, 			inMap.get(JBSbatACIFM053.OP_SVKEI_NO));							// オプションサービス契約番号
		outMap.set(JBSbatACIFI016.SVC_SKBT_CD, 			inMap.get(JBSbatACIFM053.SVC_SKBT_CD));							// 料金サービス識別コード
		outMap.set(JBSbatACIFI016.PRC_GRP_CD, 			ownrMap.get(JBSbatACIFM053.PRC_GRP_CD));						// 料金グループコード
		outMap.set(JBSbatACIFI016.PCRS_CD, 				ownrMap.get(JBSbatACIFM053.PCRS_CD));							// 料金コースコード
		outMap.set(JBSbatACIFI016.PRC_SVC_CD, 			JACStrConst.PRC_SVC_CD_SP);										// 料金サービスコード
		outMap.set(JBSbatACIFI016.PRC_KMK_CD, 			this.tmpPrcKmkCd);												// 料金項目コード
		outMap.set(JBSbatACIFI016.COLLECT_PATTERN_CD, 	dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD));	// 徴収パターンコード
		outMap.set(JBSbatACIFI016.PRC, 					prc);															// 料金
		outMap.set(JBSbatACIFI016.USE_STAYMD, 			inMap.get(JBSbatACIFM053.USE_STAYMD));							// 利用開始日
		outMap.set(JBSbatACIFI016.USE_ENDYMD, 			inMap.get(JBSbatACIFM053.USE_ENDYMD));							// 利用終了日
		outMap.set(JBSbatACIFI016.SVC_STAYMD, 			inMap.get(JBSbatACIFM053.SVC_STAYMD));							// サービス開始日
		outMap.set(JBSbatACIFI016.FIRST_CHRG_STAYMD, 	inMap.get(JBSbatACIFM053.FIRST_CHRG_STAYMD));					// 初回課金開始日
		outMap.set(JBSbatACIFI016.SVC_DSL_YMD, 			inMap.get(JBSbatACIFM053.SVC_DSL_YMD));							// サービス解約日
		outMap.set(JBSbatACIFI016.SVC_DLRE, 			inMap.get(JBSbatACIFM053.SVC_DLRE));							// サービス解約理由
		outMap.set(JBSbatACIFI016.SVC_KAIHK_DAY, 		inMap.get(JBSbatACIFM053.SVC_KAIHK_DAY));						// サービス回復日
		outMap.set(JBSbatACIFI016.USE_DAY_CNT, 			inMap.get(JBSbatACIFM053.USE_DAY_CNT));							// 利用日数
		outMap.set(JBSbatACIFI016.USE_FAIL_DAY_CNT, 	inMap.get(JBSbatACIFM053.USE_FAIL_DAY_CNT));					// 利用不可日数
		outMap.set(JBSbatACIFI016.AIT_DIV, 				JACStrConst.AITAIKBN_NON);										// 相対区分
		outMap.set(JBSbatACIFI016.SIME_DAY, 			inMap.get(JBSbatACIFM053.SIME_DAY));							// 締め日
		outMap.set(JBSbatACIFI016.USE_APLY_KH_CD, 		JACStrConst.USE_FAIL_APLY_WAY_CD_NON);							// 利用不可適用可否
		outMap.set(JBSbatACIFI016.MAE_YUSEN_JUN, 		JACStrConst.MAE_YUSEN_JUN_0);									// 前受相殺優先順位
		outMap.set(JBSbatACIFI016.WRIB_YUSEN_JUN, 		JACStrConst.WRIB_YUSEN_JUN_0);									// 割引優先順位
		outMap.set(JBSbatACIFI016.UPPL_JUDGE_YUSEN_JUN, JACStrConst.KARA_MOJI);											// 上限判定優先順位
		outMap.set(JBSbatACIFI016.WRIB_KKSHI_KH, 		JACStrConst.WRIB_KKS_H);										// 割引繰越可否
		outMap.set(JBSbatACIFI016.SVC_DTL_SKBT_NO, 		inMap.get(JBSbatACIFM053.SVC_DTL_SKBT_NO));						// サービス詳細識別番号
		
		outMap.setOutFlg(true);
		
		// 出力共通電文に入出力インターフェースを設定する
		outputInItem.addOutMapList(outMap);
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOputInfoBaseMansDtlCk]");
		return;
	}
	
	/**
	 * 利用料金情報（ベース_部屋番号明細）を出力する。
	 * @param  inMap        利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  ownrMap      利用料金情報（オーナー情報）マップ
	 * @param  dbMap        マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  outputInItem 出力共通電文
	 * @throws Exception    業務サービス内で発生した例外全般
	 */
	private void makeOputInfoBaseRmDtl(
					JBSbatServiceInterfaceMap inMap,
					JBSbatServiceInterfaceMap ownrMap,
					JBSbatCommonDBInterface  dbMap,
					JBSbatOutputItem outputInItem) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOputInfoBaseRmDtl] ベース_部屋番号明細");

		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatACIFI016.SEIKY_KEI_NO, 		ownrMap.get(JBSbatACIFM053.SEIKY_KEI_NO));						// 請求先番号
		outMap.set(JBSbatACIFI016.SEIKY_YM, 			inMap.get(JBSbatACIFM053.SEIKY_YM));							// 請求年月
		outMap.set(JBSbatACIFI016.SEIRI_NO, 			JBSbatStringUtil.fillHalfSpace((String)inMap.get(JBSbatACIFM053.MANSION_ID),this.SEIRI_NO_LEN,true));		// 整理番号（マンションID）
		outMap.set(JBSbatACIFI016.WRIB_SVC_KEI_NO, 		inMap.get(JBSbatACIFM053.WRIB_SVC_KEI_NO));						// 割引サービス契約番号
		outMap.set(JBSbatACIFI016.WRISVC_TRGT_KEI_NO, 	inMap.get(JBSbatACIFM053.WRISVC_TRGT_KEI_NO));					// 割引サービス対象契約番号
		outMap.set(JBSbatACIFI016.SVC_NO, 				inMap.get(JBSbatACIFM053.SVC_NO));								// サービス番号
		outMap.set(JBSbatACIFI016.OP_SVKEI_NO, 			inMap.get(JBSbatACIFM053.OP_SVKEI_NO));							// オプションサービス契約番号
		outMap.set(JBSbatACIFI016.SVC_SKBT_CD, 			inMap.get(JBSbatACIFM053.SVC_SKBT_CD));							// 料金サービス識別コード
		outMap.set(JBSbatACIFI016.PRC_GRP_CD, 			this.tmpGoupCdList.get(0));										// 料金グループコード
		outMap.set(JBSbatACIFI016.PCRS_CD, 				ownrMap.get(JBSbatACIFM053.PCRS_CD));							// 料金コースコード
		outMap.set(JBSbatACIFI016.PRC_SVC_CD, 			ownrMap.get(JBSbatACIFM053.PRC_SVC_CD));						// 料金サービスコード
		outMap.set(JBSbatACIFI016.PRC_KMK_CD, 			dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_KMK_CD));			// 料金項目コード
		outMap.set(JBSbatACIFI016.COLLECT_PATTERN_CD, 	dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD));	// 徴収パターンコード
		outMap.set(JBSbatACIFI016.PRC, 					dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC));				// 料金
		outMap.set(JBSbatACIFI016.USE_STAYMD, 			inMap.get(JBSbatACIFM053.USE_STAYMD));							// 利用開始日
		outMap.set(JBSbatACIFI016.USE_ENDYMD, 			inMap.get(JBSbatACIFM053.USE_ENDYMD));							// 利用終了日
		outMap.set(JBSbatACIFI016.SVC_STAYMD, 			inMap.get(JBSbatACIFM053.SVC_STAYMD));							// サービス開始日
		outMap.set(JBSbatACIFI016.FIRST_CHRG_STAYMD, 	inMap.get(JBSbatACIFM053.FIRST_CHRG_STAYMD));					// 初回課金開始日
		outMap.set(JBSbatACIFI016.SVC_DSL_YMD, 			inMap.get(JBSbatACIFM053.SVC_DSL_YMD));							// サービス解約日
		outMap.set(JBSbatACIFI016.SVC_DLRE, 			inMap.get(JBSbatACIFM053.SVC_DLRE));							// サービス解約理由
		outMap.set(JBSbatACIFI016.SVC_KAIHK_DAY, 		inMap.get(JBSbatACIFM053.SVC_KAIHK_DAY));						// サービス回復日
		outMap.set(JBSbatACIFI016.USE_DAY_CNT, 			inMap.get(JBSbatACIFM053.USE_DAY_CNT));							// 利用日数
		outMap.set(JBSbatACIFI016.USE_FAIL_DAY_CNT, 	ownrMap.get(JBSbatACIFM053.USE_FAIL_DAY_CNT));					// 利用不可日数
		outMap.set(JBSbatACIFI016.AIT_DIV, 				JACStrConst.AITAIKBN_NON);										// 相対区分
		outMap.set(JBSbatACIFI016.SIME_DAY, 			inMap.get(JBSbatACIFM053.SIME_DAY));							// 締め日
		outMap.set(JBSbatACIFI016.USE_APLY_KH_CD, 		dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.USE_FAIL_APLY_WAY_CD));// 利用不可適用可否
		outMap.set(JBSbatACIFI016.MAE_YUSEN_JUN, 		JACStrConst.MAE_YUSEN_JUN_0);									// 前受相殺優先順位
		outMap.set(JBSbatACIFI016.WRIB_YUSEN_JUN, 		JACStrConst.WRIB_YUSEN_JUN_0);									// 割引優先順位
		outMap.set(JBSbatACIFI016.UPPL_JUDGE_YUSEN_JUN, JACStrConst.KARA_MOJI);											// 上限判定優先順位
		outMap.set(JBSbatACIFI016.WRIB_KKSHI_KH, 		JACStrConst.WRIB_KKS_H);										// 割引繰越可否
		outMap.set(JBSbatACIFI016.SVC_DTL_SKBT_NO, 		inMap.get(JBSbatACIFM053.SVC_DTL_SKBT_NO));						// サービス詳細識別番号
		
		outMap.setOutFlg(true);
		
		// 出力共通電文に入出力インターフェースを設定する
		outputInItem.addOutMapList(outMap);
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOputInfoBaseRmDtl]");
		return;
	}
	
	/**
	 * 利用料金情報（ベース_部屋番号明細(未入居)）を出力する。
	 * @param  ownrMap      退避．利用料金情報（オーナー情報）リスト
	 * @param  inMap        利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  dbMap        マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  outputInItem 出力共通電文
	 * @throws Exception    業務サービス内で発生した例外全般
	 */
	private void makeOputInfoBaseMinyukyo(
					JBSbatServiceInterfaceMap ownrMap,
					JBSbatServiceInterfaceMap inMap,
					JBSbatCommonDBInterface  dbMap,
					JBSbatOutputItem outputInItem) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOputInfoBaseMinyukyo] ベース_部屋番号明細(未入居)");

		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatACIFI016.SEIKY_KEI_NO, 		ownrMap.get(JBSbatACIFM053.SEIKY_KEI_NO));						// 請求先番号
		outMap.set(JBSbatACIFI016.SEIKY_YM, 			ownrMap.get(JBSbatACIFM053.SEIKY_YM));							// 請求年月
		outMap.set(JBSbatACIFI016.SEIRI_NO, 			JBSbatStringUtil.fillHalfSpace((String)inMap.get(JBSbatACIFM053.MANSION_ID),this.SEIRI_NO_LEN,true));		// 整理番号（マンションID）
		outMap.set(JBSbatACIFI016.WRIB_SVC_KEI_NO, 		ownrMap.get(JBSbatACIFM053.WRIB_SVC_KEI_NO));					// 割引サービス契約番号
		outMap.set(JBSbatACIFI016.WRISVC_TRGT_KEI_NO, 	ownrMap.get(JBSbatACIFM053.WRISVC_TRGT_KEI_NO));				// 割引サービス対象契約番号
		outMap.set(JBSbatACIFI016.SVC_NO, 				this.minyukyoSvcKeiNo);											// サービス番号
		outMap.set(JBSbatACIFI016.OP_SVKEI_NO, 			ownrMap.get(JBSbatACIFM053.OP_SVKEI_NO));						// オプションサービス契約番号
		outMap.set(JBSbatACIFI016.SVC_SKBT_CD, 			ownrMap.get(JBSbatACIFM053.SVC_SKBT_CD));						// 料金サービス識別コード
		outMap.set(JBSbatACIFI016.PRC_GRP_CD, 			ownrMap.get(JBSbatACIFM053.PRC_GRP_CD));						// 料金グループコード
		outMap.set(JBSbatACIFI016.PCRS_CD, 				ownrMap.get(JBSbatACIFM053.PCRS_CD));							// 料金コースコード
		outMap.set(JBSbatACIFI016.PRC_SVC_CD, 			ownrMap.get(JBSbatACIFM053.PRC_SVC_CD));						// 料金サービスコード
		outMap.set(JBSbatACIFI016.PRC_KMK_CD, 			dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_KMK_CD));			// 料金項目コード
		outMap.set(JBSbatACIFI016.COLLECT_PATTERN_CD, 	dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD));	// 徴収パターンコード
		outMap.set(JBSbatACIFI016.PRC, 					dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC));					// 料金
		outMap.set(JBSbatACIFI016.USE_STAYMD, 			ownrMap.get(JBSbatACIFM053.USE_STAYMD));						// 利用開始日
		outMap.set(JBSbatACIFI016.USE_ENDYMD, 			ownrMap.get(JBSbatACIFM053.USE_ENDYMD));						// 利用終了日
		outMap.set(JBSbatACIFI016.SVC_STAYMD, 			ownrMap.get(JBSbatACIFM053.SVC_STAYMD));						// サービス開始日
		outMap.set(JBSbatACIFI016.FIRST_CHRG_STAYMD, 	ownrMap.get(JBSbatACIFM053.FIRST_CHRG_STAYMD));					// 初回課金開始日
		outMap.set(JBSbatACIFI016.SVC_DSL_YMD, 			ownrMap.get(JBSbatACIFM053.SVC_DSL_YMD));						// サービス解約日
		outMap.set(JBSbatACIFI016.SVC_DLRE, 			ownrMap.get(JBSbatACIFM053.SVC_DLRE));							// サービス解約理由
		outMap.set(JBSbatACIFI016.SVC_KAIHK_DAY, 		ownrMap.get(JBSbatACIFM053.SVC_KAIHK_DAY));						// サービス回復日
		outMap.set(JBSbatACIFI016.USE_DAY_CNT, 			ownrMap.get(JBSbatACIFM053.USE_DAY_CNT));						// 利用日数
		outMap.set(JBSbatACIFI016.USE_FAIL_DAY_CNT, 	ownrMap.get(JBSbatACIFM053.USE_FAIL_DAY_CNT));					// 利用不可日数
		outMap.set(JBSbatACIFI016.AIT_DIV, 				JACStrConst.AITAIKBN_NON);										// 相対区分
		outMap.set(JBSbatACIFI016.SIME_DAY, 			ownrMap.get(JBSbatACIFM053.SIME_DAY));							// 締め日
		outMap.set(JBSbatACIFI016.USE_APLY_KH_CD, 		dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.USE_FAIL_APLY_WAY_CD));// 利用不可適用可否
		outMap.set(JBSbatACIFI016.MAE_YUSEN_JUN, 		JACStrConst.MAE_YUSEN_JUN_0);									// 前受相殺優先順位
		outMap.set(JBSbatACIFI016.WRIB_YUSEN_JUN, 		JACStrConst.WRIB_YUSEN_JUN_0);									// 割引優先順位
		outMap.set(JBSbatACIFI016.UPPL_JUDGE_YUSEN_JUN, JACStrConst.KARA_MOJI);											// 上限判定優先順位
		outMap.set(JBSbatACIFI016.WRIB_KKSHI_KH, 		JACStrConst.WRIB_KKS_H);										// 割引繰越可否
		outMap.set(JBSbatACIFI016.SVC_DTL_SKBT_NO, 		ownrMap.get(JBSbatACIFM053.SVC_DTL_SKBT_NO));					// サービス詳細識別番号
		
		outMap.setOutFlg(true);
		
		// 出力共通電文に入出力インターフェースを設定する
		outputInItem.addOutMapList(outMap);
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOputInfoBaseMinyukyo]");
		return;
	}
	
	/**
	 * 利用料金情報（個別_部屋番号明細）を出力する。
	 * @param  inMap            利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  pauseJdgInfoList 休止判定情報リスト[0]：料金項目コード [1]：徴収パターンコード [2]：料金 [3]：利用不可適用可否
	 * @param  outputInItem     出力共通電文
	 * @throws Exception        業務サービス内で発生した例外全般
	 */
	private void makeOputInfoKobetsuRmDtl(JBSbatServiceInterfaceMap inMap
																, ArrayList<String> pauseJdgInfoList, JBSbatOutputItem outputInItem) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOputInfoKobetsuRmDtl] 個別_部屋番号明細");

		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatACIFI016.SEIKY_KEI_NO, 		inMap.get(JBSbatACIFM053.SEIKY_KEI_NO));			// 請求先番号
		outMap.set(JBSbatACIFI016.SEIKY_YM, 			inMap.get(JBSbatACIFM053.SEIKY_YM));				// 請求年月
		outMap.set(JBSbatACIFI016.SEIRI_NO, 			inMap.get(JBSbatACIFM053.SEIRI_NO));				// 整理番号
		outMap.set(JBSbatACIFI016.WRIB_SVC_KEI_NO, 		inMap.get(JBSbatACIFM053.WRIB_SVC_KEI_NO));			// 割引サービス契約番号
		outMap.set(JBSbatACIFI016.WRISVC_TRGT_KEI_NO, 	inMap.get(JBSbatACIFM053.WRISVC_TRGT_KEI_NO));		// 割引サービス対象契約番号
		outMap.set(JBSbatACIFI016.SVC_NO, 				inMap.get(JBSbatACIFM053.SVC_NO));					// サービス番号
		outMap.set(JBSbatACIFI016.OP_SVKEI_NO, 			inMap.get(JBSbatACIFM053.OP_SVKEI_NO));				// オプションサービス契約番号
		outMap.set(JBSbatACIFI016.SVC_SKBT_CD, 			inMap.get(JBSbatACIFM053.SVC_SKBT_CD));				// 料金サービス識別コード
		outMap.set(JBSbatACIFI016.PRC_GRP_CD, 			inMap.get(JBSbatACIFM053.PRC_GRP_CD));				// 料金グループコード
		outMap.set(JBSbatACIFI016.PCRS_CD, 				inMap.get(JBSbatACIFM053.PCRS_CD));					// 料金コースコード
		outMap.set(JBSbatACIFI016.PRC_SVC_CD, 			inMap.get(JBSbatACIFM053.PRC_SVC_CD));				// 料金サービスコード
		outMap.set(JBSbatACIFI016.PRC_KMK_CD, 			pauseJdgInfoList.get(0));							// 料金項目コード
		outMap.set(JBSbatACIFI016.COLLECT_PATTERN_CD, 	pauseJdgInfoList.get(1));							// 徴収パターンコード
		outMap.set(JBSbatACIFI016.PRC, 					new BigDecimal(pauseJdgInfoList.get(2)));			// 料金
		outMap.set(JBSbatACIFI016.USE_STAYMD, 			inMap.get(JBSbatACIFM053.USE_STAYMD));				// 利用開始日
		outMap.set(JBSbatACIFI016.USE_ENDYMD, 			inMap.get(JBSbatACIFM053.USE_ENDYMD));				// 利用終了日
		outMap.set(JBSbatACIFI016.SVC_STAYMD, 			inMap.get(JBSbatACIFM053.SVC_STAYMD));				// サービス開始日
		outMap.set(JBSbatACIFI016.FIRST_CHRG_STAYMD, 	inMap.get(JBSbatACIFM053.FIRST_CHRG_STAYMD));		// 初回課金開始日
		outMap.set(JBSbatACIFI016.SVC_DSL_YMD, 			inMap.get(JBSbatACIFM053.SVC_DSL_YMD));				// サービス解約日
		outMap.set(JBSbatACIFI016.SVC_DLRE, 			inMap.get(JBSbatACIFM053.SVC_DLRE));				// サービス解約理由
		outMap.set(JBSbatACIFI016.SVC_KAIHK_DAY, 		inMap.get(JBSbatACIFM053.SVC_KAIHK_DAY));			// サービス回復日
		outMap.set(JBSbatACIFI016.USE_DAY_CNT, 			inMap.get(JBSbatACIFM053.USE_DAY_CNT));				// 利用日数
		outMap.set(JBSbatACIFI016.USE_FAIL_DAY_CNT, 	inMap.get(JBSbatACIFM053.USE_FAIL_DAY_CNT));		// 利用不可日数
		outMap.set(JBSbatACIFI016.AIT_DIV, 				JACStrConst.AITAIKBN_NON);							// 相対区分
		outMap.set(JBSbatACIFI016.SIME_DAY, 			inMap.get(JBSbatACIFM053.SIME_DAY));				// 締め日
		outMap.set(JBSbatACIFI016.USE_APLY_KH_CD, 		pauseJdgInfoList.get(3));							// 利用不可適用可否
		outMap.set(JBSbatACIFI016.MAE_YUSEN_JUN, 		JACStrConst.MAE_YUSEN_JUN_0);						// 前受相殺優先順位
		outMap.set(JBSbatACIFI016.WRIB_YUSEN_JUN, 		JACStrConst.WRIB_YUSEN_JUN_0);						// 割引優先順位
		outMap.set(JBSbatACIFI016.UPPL_JUDGE_YUSEN_JUN, JACStrConst.KARA_MOJI);								// 上限判定優先順位
		outMap.set(JBSbatACIFI016.WRIB_KKSHI_KH, 		JACStrConst.WRIB_KKS_H);							// 割引繰越可否
		outMap.set(JBSbatACIFI016.SVC_DTL_SKBT_NO, 		inMap.get(JBSbatACIFM053.SVC_DTL_SKBT_NO));		// サービス詳細識別番号
		
		outMap.setOutFlg(true);
		
		// 出力共通電文に入出力インターフェースを設定する
		outputInItem.addOutMapList(outMap);
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOputInfoKobetsuRmDtl]");
		return;
	}

	/**
	 * 利用料金情報（特定マンション一括_マンションID明細）を出力する。
	 * @param  inMap        利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  ownrMap      退避．利用料金情報（オーナー情報）リスト
	 * @param  dbMap        マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  outputInItem 出力共通電文
	 * @throws Exception    業務サービス内で発生した例外全般
	 */
	private void makeOputInfoSpeMansIkt(
					JBSbatServiceInterfaceMap inMap,
					JBSbatServiceInterfaceMap ownrMap,
					JBSbatCommonDBInterface  dbMap,
					JBSbatOutputItem outputInItem) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOputInfoSpeMansIkt] 特定マンション一括_マンションID明細");

		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatACIFI016.SEIKY_KEI_NO, 		ownrMap.get(JBSbatACIFM053.SEIKY_KEI_NO));						// 請求先番号
		outMap.set(JBSbatACIFI016.SEIKY_YM, 			inMap.get(JBSbatACIFM053.SEIKY_YM));							// 請求年月
		outMap.set(JBSbatACIFI016.SEIRI_NO, 			JBSbatStringUtil.fillHalfSpace((String)inMap.get(JBSbatACIFM053.MANSION_ID),this.SEIRI_NO_LEN,true));		// 整理番号（マンションID）
		outMap.set(JBSbatACIFI016.WRIB_SVC_KEI_NO, 		inMap.get(JBSbatACIFM053.WRIB_SVC_KEI_NO));						// 割引サービス契約番号
		outMap.set(JBSbatACIFI016.WRISVC_TRGT_KEI_NO, 	inMap.get(JBSbatACIFM053.WRISVC_TRGT_KEI_NO));					// 割引サービス対象契約番号
		outMap.set(JBSbatACIFI016.SVC_NO, 				ownrMap.get(JBSbatACIFM053.SVC_NO));							// サービス番号
		outMap.set(JBSbatACIFI016.OP_SVKEI_NO, 			inMap.get(JBSbatACIFM053.OP_SVKEI_NO));							// オプションサービス契約番号
		outMap.set(JBSbatACIFI016.SVC_SKBT_CD, 			inMap.get(JBSbatACIFM053.SVC_SKBT_CD));							// 料金サービス識別コード
		outMap.set(JBSbatACIFI016.PRC_GRP_CD, 			ownrMap.get(JBSbatACIFM053.PRC_GRP_CD));						// 料金グループコード
		outMap.set(JBSbatACIFI016.PCRS_CD, 				ownrMap.get(JBSbatACIFM053.PCRS_CD));							// 料金コースコード
		outMap.set(JBSbatACIFI016.PRC_SVC_CD, 			ownrMap.get(JBSbatACIFM053.PRC_SVC_CD));						// 料金サービスコード
		outMap.set(JBSbatACIFI016.PRC_KMK_CD, 			convPrcKmkCd(outMap, dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_KMK_CD)));	// 料金項目コード
		outMap.set(JBSbatACIFI016.COLLECT_PATTERN_CD, 	dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD));	// 徴収パターンコード
		outMap.set(JBSbatACIFI016.PRC, 					dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC));				// 料金
		outMap.set(JBSbatACIFI016.USE_STAYMD, 			inMap.get(JBSbatACIFM053.USE_STAYMD));							// 利用開始日
		outMap.set(JBSbatACIFI016.USE_ENDYMD, 			inMap.get(JBSbatACIFM053.USE_ENDYMD));							// 利用終了日
		outMap.set(JBSbatACIFI016.SVC_STAYMD, 			inMap.get(JBSbatACIFM053.SVC_STAYMD));							// サービス開始日
		outMap.set(JBSbatACIFI016.FIRST_CHRG_STAYMD, 	inMap.get(JBSbatACIFM053.FIRST_CHRG_STAYMD));					// 初回課金開始日
		outMap.set(JBSbatACIFI016.SVC_DSL_YMD, 			inMap.get(JBSbatACIFM053.SVC_DSL_YMD));							// サービス解約日
		outMap.set(JBSbatACIFI016.SVC_DLRE, 			inMap.get(JBSbatACIFM053.SVC_DLRE));							// サービス解約理由
		outMap.set(JBSbatACIFI016.SVC_KAIHK_DAY, 		inMap.get(JBSbatACIFM053.SVC_KAIHK_DAY));						// サービス回復日
		outMap.set(JBSbatACIFI016.USE_DAY_CNT, 			inMap.get(JBSbatACIFM053.USE_DAY_CNT));							// 利用日数
		outMap.set(JBSbatACIFI016.USE_FAIL_DAY_CNT, 	ownrMap.get(JBSbatACIFM053.USE_FAIL_DAY_CNT));					// 利用不可日数
		outMap.set(JBSbatACIFI016.AIT_DIV, 				JACStrConst.AITAIKBN_NON);										// 相対区分
		outMap.set(JBSbatACIFI016.SIME_DAY, 			inMap.get(JBSbatACIFM053.SIME_DAY));							// 締め日
		outMap.set(JBSbatACIFI016.USE_APLY_KH_CD, 		dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.USE_FAIL_APLY_WAY_CD));// 利用不可適用可否
		outMap.set(JBSbatACIFI016.MAE_YUSEN_JUN, 		JACStrConst.MAE_YUSEN_JUN_0);									// 前受相殺優先順位
		outMap.set(JBSbatACIFI016.WRIB_YUSEN_JUN, 		JACStrConst.WRIB_YUSEN_JUN_0);									// 割引優先順位
		outMap.set(JBSbatACIFI016.UPPL_JUDGE_YUSEN_JUN, JACStrConst.KARA_MOJI);											// 上限判定優先順位
		outMap.set(JBSbatACIFI016.WRIB_KKSHI_KH, 		JACStrConst.WRIB_KKS_H);										// 割引繰越可否
		outMap.set(JBSbatACIFI016.SVC_DTL_SKBT_NO, 		inMap.get(JBSbatACIFM053.SVC_DTL_SKBT_NO));						// サービス詳細識別番号
		
		outMap.setOutFlg(true);
		
		// 出力共通電文に入出力インターフェースを設定する
		outputInItem.addOutMapList(outMap);
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOputInfoSpeMansIkt]");
		return;
	}
	
	/**
	 * 利用料金情報（特定マンション一括_マンションID明細_中計）を出力する。
	 * @param  inMap            利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  ownrMap          退避．利用料金情報（オーナー情報）リスト
	 * @param  dbMap            マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  pauseJdgInfoList 休止判定情報リスト[0]：料金項目コード [1]：徴収パターンコード [2]：料金 [3]：利用不可適用可否
	 * @param outputInItem      出力共通電文
	 * @throws Exception        業務サービス内で発生した例外全般
	 */
	private void makeOputInfoSpeMansIktCk(
					JBSbatServiceInterfaceMap inMap,
					JBSbatServiceInterfaceMap ownrMap,
					JBSbatCommonDBInterface  dbMap,
					ArrayList<String> pauseJdgInfoList,
					JBSbatOutputItem outputInItem) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOputInfoSpeMansIktCk] 特定マンション一括_マンションID明細_中計");

		JBSbatServiceInterfaceMap outMap = new JBSbatServiceInterfaceMap();

		outMap.set(JBSbatACIFI016.SEIKY_KEI_NO, 		ownrMap.get(JBSbatACIFM053.SEIKY_KEI_NO));			// 請求先番号
		outMap.set(JBSbatACIFI016.SEIKY_YM, 			inMap.get(JBSbatACIFM053.SEIKY_YM));				// 請求年月
		outMap.set(JBSbatACIFI016.SEIRI_NO, 			JBSbatStringUtil.fillHalfSpace((String)inMap.get(JBSbatACIFM053.MANSION_ID),this.SEIRI_NO_LEN,true));		// 整理番号（マンションID）
		outMap.set(JBSbatACIFI016.WRIB_SVC_KEI_NO, 		inMap.get(JBSbatACIFM053.WRIB_SVC_KEI_NO));			// 割引サービス契約番号
		outMap.set(JBSbatACIFI016.WRISVC_TRGT_KEI_NO, 	inMap.get(JBSbatACIFM053.WRISVC_TRGT_KEI_NO));		// 割引サービス対象契約番号
		outMap.set(JBSbatACIFI016.SVC_NO, 				ownrMap.get(JBSbatACIFM053.SVC_NO));				// サービス番号
		outMap.set(JBSbatACIFI016.OP_SVKEI_NO, 			inMap.get(JBSbatACIFM053.OP_SVKEI_NO));				// オプションサービス契約番号
		outMap.set(JBSbatACIFI016.SVC_SKBT_CD, 			inMap.get(JBSbatACIFM053.SVC_SKBT_CD));				// 料金サービス識別コード
		outMap.set(JBSbatACIFI016.PRC_GRP_CD, 			ownrMap.get(JBSbatACIFM053.PRC_GRP_CD));			// 料金グループコード
		outMap.set(JBSbatACIFI016.PCRS_CD, 				ownrMap.get(JBSbatACIFM053.PCRS_CD));				// 料金コースコード
		outMap.set(JBSbatACIFI016.PRC_SVC_CD, 			JACStrConst.PRC_SVC_CD_SP);							// 料金サービスコード
		outMap.set(JBSbatACIFI016.PRC_KMK_CD, 			this.tmpPrcKmkCd);									// 料金項目コード
		outMap.set(JBSbatACIFI016.COLLECT_PATTERN_CD, 	dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD));	// 徴収パターンコード
		outMap.set(JBSbatACIFI016.PRC, 					dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC));	// 料金
		outMap.set(JBSbatACIFI016.USE_STAYMD, 			inMap.get(JBSbatACIFM053.USE_STAYMD));				// 利用開始日
		outMap.set(JBSbatACIFI016.USE_ENDYMD, 			inMap.get(JBSbatACIFM053.USE_ENDYMD));				// 利用終了日
		outMap.set(JBSbatACIFI016.SVC_STAYMD, 			inMap.get(JBSbatACIFM053.SVC_STAYMD));				// サービス開始日
		outMap.set(JBSbatACIFI016.FIRST_CHRG_STAYMD, 	inMap.get(JBSbatACIFM053.FIRST_CHRG_STAYMD));		// 初回課金開始日
		outMap.set(JBSbatACIFI016.SVC_DSL_YMD, 			inMap.get(JBSbatACIFM053.SVC_DSL_YMD));				// サービス解約日
		outMap.set(JBSbatACIFI016.SVC_DLRE, 			inMap.get(JBSbatACIFM053.SVC_DLRE));				// サービス解約理由
		outMap.set(JBSbatACIFI016.SVC_KAIHK_DAY, 		inMap.get(JBSbatACIFM053.SVC_KAIHK_DAY));			// サービス回復日
		outMap.set(JBSbatACIFI016.USE_DAY_CNT, 			inMap.get(JBSbatACIFM053.USE_DAY_CNT));				// 利用日数
		outMap.set(JBSbatACIFI016.USE_FAIL_DAY_CNT, 	inMap.get(JBSbatACIFM053.USE_FAIL_DAY_CNT));		// 利用不可日数
		outMap.set(JBSbatACIFI016.AIT_DIV, 				JACStrConst.AITAIKBN_NON);							// 相対区分
		outMap.set(JBSbatACIFI016.SIME_DAY, 			inMap.get(JBSbatACIFM053.SIME_DAY));				// 締め日
		outMap.set(JBSbatACIFI016.USE_APLY_KH_CD, 		JACStrConst.USE_FAIL_APLY_WAY_CD_NON);				// 利用不可適用可否
		outMap.set(JBSbatACIFI016.MAE_YUSEN_JUN, 		JACStrConst.MAE_YUSEN_JUN_0);						// 前受相殺優先順位
		outMap.set(JBSbatACIFI016.WRIB_YUSEN_JUN, 		JACStrConst.WRIB_YUSEN_JUN_0);						// 割引優先順位
		outMap.set(JBSbatACIFI016.UPPL_JUDGE_YUSEN_JUN, JACStrConst.KARA_MOJI);								// 上限判定優先順位
		outMap.set(JBSbatACIFI016.WRIB_KKSHI_KH, 		JACStrConst.WRIB_KKS_H);							// 割引繰越可否
		outMap.set(JBSbatACIFI016.SVC_DTL_SKBT_NO, 		inMap.get(JBSbatACIFM053.SVC_DTL_SKBT_NO));			// サービス詳細識別番号
		
		outMap.setOutFlg(true);
		
		// 出力共通電文に入出力インターフェースを設定する
		outputInItem.addOutMapList(outMap);
		
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOputInfoSpeMansIktCk]");
		return;
	}
	
	/**
	 * マンションＩＤ明細料金項目コード変換表より料金項目コードを変換します。
	 * 
	 * @param outMap    出力共通電文<Br>
	 *                   ※変換に必要な以下の値が設定済みであること<Br>
	 *                   「料金グループコード」「料金コースコード」「料金サービスコード」
	 * @param prcKmkCd   マンション定額料金情報（提供方式契約単位）料金項目コード
	 * @return           変換後料金項目コード
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private String convPrcKmkCd(JBSbatServiceInterfaceMap outMap, String prcKmkCd) throws Exception
	{
		// 出力情報と料金項目コードよりマップ検索キーを生成します。
		ArrayList<String> mapKey = createMapKey(outMap, prcKmkCd);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][convPrcKmkCd][mapKey：" + mapKey + "]");
		// マップより変換後の料金項目コードを取得します。
		JBSbatCommonDBInterface dbMap = manidCnvMap.get(mapKey);
		
		if (dbMap != null)
		{
			// 出力料金項目コードを返却する 
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][convPrcKmkCd][出力料金項目コード：" + dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.OUT_PRC_KMK_CD) + "]");
			return dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.OUT_PRC_KMK_CD);
		}
		else
		{
			// 料金項目抽出変換で変換ができなかった場合にはDB未存在エラーとする
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][convPrcKmkCd][DB未存在エラー]");
			String[] msgParam = new String[]
			{ JBSbatCH_M_PRC_KMK_CS_CHGE.TABLE_NAME, mapKey.toString() };
			// マンションＩＤ明細料金項目コード変換表に該当なし
			throw new JBSbatBusinessException(JPCBatchMessageConstant.EACB0240CW, msgParam);
		}
	}
	
	/**
	 * マンションID明細料金項目コード変換マップ検索用のキーを生成します。
	 * @param outMap    出力共通電文<Br>
	 *                   ※変換に必要な以下の値が設定済みであること<Br>
	 *                   「料金グループコード」「料金コースコード」「料金サービスコード」
	 * @param prcKmkCd  マンション定額料金情報（提供方式契約単位）料金項目コード
	 * @return          マップ検索用キーリスト
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private ArrayList<String> createMapKey(JBSbatServiceInterfaceMap outMap, String prcKmkCd) throws Exception
	{
		ArrayList<String> keyList = new ArrayList<String>();
		keyList.add(outMap.getString(JBSbatACIFI016.PRC_GRP_CD));
		keyList.add(outMap.getString(JBSbatACIFI016.PCRS_CD));
		keyList.add(outMap.getString(JBSbatACIFI016.PRC_SVC_CD));
		keyList.add(prcKmkCd);
		return keyList;
	}
	
	/**
	 * 休止判定を行い料金項目情報から対象料金を決定し、必要な情報を取得する。
	 * @param  inMap            利用料金情報（マンション定額料金情報）リスト[i]
	 * @param  dbMap            マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  pauseJdgInfoList 休止判定情報リスト（返却用）[0]：料金項目コード [1]：徴収パターンコード [2]：料金 [3]：利用不可適用可否
	 * @throws Exception        業務サービス内で発生した例外全般
	 */
	private void setPauseJdgInfo(
					JBSbatServiceInterfaceMap inMap,
					JBSbatCommonDBInterface dbMap,
					ArrayList<String> pauseJdgInfoList) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getPauseJdgInfo]");
		pauseJdgInfoList.clear();
		
		// 休止判定
		String svcPauseDay		= inMap.getString(JBSbatACIFM053.SVC_PAUSE_DAY);	// サービス休止日
		String svcPauseRlsDay 	= inMap.getString(JBSbatACIFM053.SVC_PAUSE_RLS_YMD);// サービス休止解除日
		String prc 				= null; 		// 料金
		String prcKmkCd 		= null; 		// 料金項目コード
		String judgePtnCd 		= null; 		// 徴収パターンコード
		String useFailAplyWayCd = null; 		// 利用不可適用可否
		
		// サービス休止日、サービス休止解除日ともに未設定の場合
		if(svcPauseDay.equals(JACStrConst.KARA_MOJI) && svcPauseRlsDay.equals(JACStrConst.KARA_MOJI))
		{
			prc					= dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC).toString();		// 料金
			prcKmkCd 			= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_KMK_CD);				// 料金項目コード
			judgePtnCd 			= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD);		// 徴収パターンコード
			useFailAplyWayCd 	= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.USE_FAIL_APLY_WAY_CD);	// 利用不可適用可否
		}
		// サービス休止日のみ設定されている場合
		else if(!svcPauseDay.equals(JACStrConst.KARA_MOJI) && svcPauseRlsDay.equals(JACStrConst.KARA_MOJI))
		{
			// 課金対象サービス契約情報．サービス休止日 ≧ 初期処理で求めた利用月翌月月初日
			// または　課金対象サービス契約情報．休止料金 ＝ null の場合
			if(svcPauseDay.compareTo(nextCycTukiSt) >= 0
					|| dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PAUSE_PRC) == null)
			{
				prc					= dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC).toString();		// 料金
				prcKmkCd 			= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_KMK_CD);				// 料金項目コード
				judgePtnCd 			= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD);		// 徴収パターンコード
				useFailAplyWayCd 	= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.USE_FAIL_APLY_WAY_CD);	// 利用不可適用可否
			}
			else
			{
				prc 				= dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PAUSE_PRC).toString();		// 休止料金
				prcKmkCd 			= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PAUSE_PRC_KMK_CD);				// 休止料金項目コード
				judgePtnCd 			= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PAUSE_COLLECT_PATTERN_CD);		// 休止徴収パターンコード
				useFailAplyWayCd 	= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PAUSE_USE_FAIL_APLY_WAY_CD);		// 休止利用不可適用可否
			}
		}
		// サービス休止日、サービス休止解除日ともに設定されている場合
		else if(!svcPauseDay.equals(JACStrConst.KARA_MOJI) && !svcPauseRlsDay.equals(JACStrConst.KARA_MOJI))
		{	
			// 課金対象サービス契約情報．サービス休止日 ≧ 初期処理で求めた利用月翌月月初日 の場合
			if(svcPauseDay.compareTo(nextCycTukiSt) >= 0)
			{
				prc					= dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC).toString();		// 料金
				prcKmkCd 			= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_KMK_CD);				// 料金項目コード
				judgePtnCd 			= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD);		// 徴収パターンコード
				useFailAplyWayCd 	= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.USE_FAIL_APLY_WAY_CD);	// 利用不可適用可否
			}
			// サービス休止解除日  ≧  初期処理で求めた利用月翌月月初日の場合
			else if(svcPauseRlsDay.compareTo(nextCycTukiSt) >= 0)
			{
				if(dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PAUSE_PRC) == null)
				{
					prc					= dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC).toString();		// 料金
					prcKmkCd 			= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_KMK_CD);				// 料金項目コード
					judgePtnCd 			= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD);		// 徴収パターンコード
					useFailAplyWayCd 	= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.USE_FAIL_APLY_WAY_CD);	// 利用不可適用可否
				}
				else
				{
					prc 				= dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PAUSE_PRC).toString();		// 休止料金
					prcKmkCd 			= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PAUSE_PRC_KMK_CD);				// 休止料金項目コード
					judgePtnCd 			= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PAUSE_COLLECT_PATTERN_CD);		// 休止徴収パターンコード
					useFailAplyWayCd 	= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PAUSE_USE_FAIL_APLY_WAY_CD);		// 休止利用不可適用可否
				}
			}
			else
			{
				prc					= dbMap.getBigDecimal(JBSbatAC_M_MANS_TEGAKPRC.PRC).toString();		// 料金
				prcKmkCd 			= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_KMK_CD);				// 料金項目コード
				judgePtnCd 			= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.COLLECT_PATTERN_CD);		// 徴収パターンコード
				useFailAplyWayCd 	= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.USE_FAIL_APLY_WAY_CD);	// 利用不可適用可否
			}
		}
		// 休止判定情報リスト（返却用）に取得値を設定
		// 料金項目コード
		// 徴収パターンコード
		// 料金
		// 利用不可適用可否
		pauseJdgInfoList.add(prcKmkCd);
		pauseJdgInfoList.add(judgePtnCd);
		pauseJdgInfoList.add(prc);
		pauseJdgInfoList.add(useFailAplyWayCd);
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getPauseJdgInfo]");
		return;
	}
	
	/**
	 * マンション定額料金情報（提供方式契約単位）にパラメータで渡された支払契約識別コードが存在するかチェックを行います。
	 * @param  inMap        利用料金情報（マンション定額料金情報）リスト[i] または 利用料金情報（オーナー情報）マップ
	 * @param  dbMap        マンション定額料金情報（提供方式契約単位）リスト[i]
	 * @param  payKeiSkbtCd 支払契約識別コード
	 * @return boolean      判定結果（true：あり、false：なし）
	 * @throws Exception    業務サービス内で発生した例外全般
	 */
	private boolean isMansTeiPrcCalcInfo(
						JBSbatServiceInterfaceMap inMap,
						JBSbatCommonDBInterface dbMap,
						String payKeiSkbtCd) throws Exception
	{
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isMansTeiPrcCalcInfo]");
		
		// 判定条件取得
		String manspayKeiSkbtCd = dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PAY_KEI_SKBT_CD);
		String mansPcrsCd 		= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PCRS_CD);
		String mansPrcSvcCd 	= dbMap.getString(JBSbatAC_M_MANS_TEGAKPRC.PRC_SVC_CD);
		
		String pcrsCd 			= inMap.getString(JBSbatACIFM053.PCRS_CD);
		String prcSvcCd 		= inMap.getString(JBSbatACIFM053.PRC_SVC_CD);
		
		if(payKeiSkbtCd.equals(manspayKeiSkbtCd)
				&& mansPcrsCd.equals(pcrsCd)
				&& mansPrcSvcCd.equals(prcSvcCd))
		{
			assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isMansTeiPrcCalcInfo][対象あり]");
			return true;
		}
		assert 	JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isMansTeiPrcCalcInfo][対象なし]");
		return false;
	}
}