/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatCHPrcIktAdj
*	ソースファイル名	：JBSbatCHPrcIktAdj.java
*	作成者				：富士通　
*	作成日				：2011年11月13日
*＜機能概要＞
*　料金一括調整部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者			修正内容
*	v1.00.00	2011/11/13   富士通			新規作成
*	v3.00		2012/08/03   FJ）冨井		【TAI-2012-0000094】税額計算部品修正（DBアクセスクラス見直し対応）
*	v3.01		2012/08/27	 FJ）成田		【TG1-2012-0000139】料金対応記録登録部品クラスの初期化位置を変更
*	v3.02		2012/10/04	 FJ）後藤		【ST2-2012-0001728】エラーチェック修正
*	v3.03		2012/10/24	 FJ）後藤		【ST2-2012-0001873】料金サービスコードチェック修正
*	v4.01		2013/01/28	 FJ）佐藤(智)	【ST4-2012-0000377】請求内訳スキーマの請求年月追加対応
*	v4.02		2013/02/13	 FJ）浜口		【ST3-2013-0000426】請求ステータスチェックの対象を修正（「仮計算中」→「仮計算中」or「仮確定」）
*	v4.03		2013/03/05   FJ) 狭間		【ST4-2013-0000163】水平展開。
*	v4.04		2013/03/23	 FJ) 早崎		【ST3-2013-0000711】入力チェック(E038)条件修正
*	v4.05		2013/03/26	 FJ) 小柴		【内部管理番号-0000613】ファイル出力オブジェクト生成時のエンコード設定ずれ防止対応
*	v4.06		2013/04/05	 FJ) 小柴		【IKK-2013-0000783】文字化け対策のため、エンコード形式の変更
*	v5.00		2013/08/29	 FJ) 垣内		【OM-2013-0001137】料金調整区分設定修正
*	v5.01		2013/09/08	 FJ) 小柴		【OM-2013-0001848】サービス契約番号の存在チェックを、ダミーコードの時は実行しないように修正
*	v5.02		2013/09/09	 FJ) 小柴		【OM-2013-0001848】変更区分のエラーチェック時、マンションレコードかどうかで判定条件を変えるように修正
*	v5.03		2013/09/10	 FJ) 小柴		【OM-2013-0001631】請求内訳が取得できなかった場合の処理を、システムエラーからエラーリストへの出力に修正、部品の修正による引数の追加
*	v5.04		2013/09/11	 FJ) 垣内、小柴	【OM-2013-0001998】サービス契約番号チェック修正（取得SQL修正、入力ファイルのサービス契約番号がnullの場合、スペース埋めに置き換え）
*	v5.05		2013/09/16	 FJ) 垣内		【OM-2013-0002259】整理番号が異なる際の一時金が登録されない
*	v5.06		2013/09/18	 FJ) 伊藤		【OM-2013-0002080】SQL検索条件の「オンライン運用日 <= 督促管理終了年月日」を「オンライン運用日 < 督促管理終了年月日」にする水平展開
*	v5.07		2013/09/24	 FJ) 垣内		【OM-2013-0002534】督促ステータスの値がnullになる対応
*	v5.08		2013/09/25	 FJ) 垣内		【OM-2013-0002555】請求額合計の設定値不正
*	v5.09		2013/10/04	 FJ) 垣内		【OM-2013-0001979】同一処理グループ内の請求契約番号チェック不正修正
*															   SIFチェックエラーをエラーリストに出力するよう修正
*	v5.10		2013/10/05	 FJ) 垣内		【OM-2013-0001979】請求削除後の明細に追加ができるよう修正
*	v5.11		2013/10/15	 FJ) 垣内		【OM-2013-0002698】サービス契約番号チェックの日付誤り対応
*	v5.12		2013/10/21	 FJ) 垣内		【OM-2013-0003344・3285・3460】0円明細表示制御フラグが"0"の場合、0円に更新できない、0円で追加できないよう修正
*	v5.13		2013/10/28	 FJ) 垣内		【OM-2013-0002700】複数のエラーが発生した場合、エラーファイルにエラー内容が出力されるよう修正
*	v5.14		2013/11/07	 FJ) 垣内		【OM-2013-0004143】工事遅延明細が含まれている場合のチェック追加
*	v5.15		2013/11/14	 FJ) 早崎		【OM-2013-0004269】サービス契約番号チェック時条件に予約適用年月日および予約適用コードを追加
*	v6.00		2013/12/05	 FJ) 早崎		【OM-2013-0002699】サービス契約番号が未設定の場合、請求内訳チェック項目からグループコードを外すよう修正
*	v6.01		2013/12/10	 FJ) 早崎		【OM-2013-0003340】マンションIDおよび部屋番号のチェック修正
*	v6.02		2014/01/17	 FJ) 垣内		【OM-2014-0000272】マンションの場合、料金グループコードにオーナー用料金グループコードを設定するよう修正
*	v6.03		2014/01/24	 FJ) 垣内		【OM-2014-0000245】請求契約の抽出条件に予約適用年月日を追加
*	v8.00		2014/01/22	 FJ) 伊藤		【ANK-1794-00-00】請求書電話番号表示対応
*	v9.00.00	2014/05/09   FJ) 狭間		【ANK-2054-00-00】スマートリンク端末補償対応
*	v9.00.01	2014/05/09   FJ) 狭間		【IT1-2014-0000170】機器提供サービス契約番号取得不具合修正
*	v9.00.02	2014/05/27   FJ) 安井		【IT1-2014-0000174】料金項目コードが料金項目リストに存在しない場合のエラーリスト出力処理を削除
*											【IT1-2014-0000175】処理通番が前レコードと同値の場合もエラーリストに出力するよう修正
*	v9.00.03	2014/05/28   FJ) 安井		【IT1-2014-0000164】機器提供サービス契約の予約適用年月日を計九年月月末日で判定するよう変更
*																エラーファイル出力項目(1項目目、2項目目)に「"」を追加
*	v9.00.04	2014/06/24	 FJ) 小掠		【OM-2014-0001815】前受充当金変更可能期間のチェック追加
*	v12.00.00	2015/02/16	 FJ) 川島		【OM-2015-0000053】工事遅延分存在チェック追加
*	v12.01.00	2015/02/27	 FJ) 川島		【OM-2015-0000082】請求オプションチェック追加
*	v16.00.00	2015/06/08	 FJ) 西面		【ANK-2480-00-00】新電力対応
*	v36.00.00	2018/01/22	 FJ) 森			【ANK-3296-00-00】工事費割賦のサービス識別番号のチェック追加
*				2018/01/29									  工事費割賦の埋込み文字の処理追加
*   v44.00.00   2019/06/04   FJ) 大崎       【ANK-3514-00-00】マンションオーナーに対する料金計算日前の料金調整不具合対応（OM-2017-0000033）
*	v45.00.00	2019/09/30	 FJ)吉田		【OM-2019-0000646】請求内訳情報の整理番号表示不備
*	v49.00.00	2020/04/03	 FJ)寺園		【ANK-3826-00-00】譲渡未収分の載せ替え処理の自動化
*	v54.00.00	2021/10/01	 FJ) 山地		【ANK-4068-00-00】IBUKI：020番号の14桁化対応
*   v67.00.00	2023/10/20	 FJ) 田中		【IT2-2023-0000015】調整費対応
*********************************************************************/
package eo.business.service;

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

import eo.business.common.JACBatCommon;
import eo.business.common.JACbatDebugLogUtil;
import eo.business.common.JACbatParamUtil;
import eo.business.common.JACbatRknBusinessUtil;
import eo.business.common.JACbatSchdlUtil;
import eo.business.common.JBSbatBusinessService;
import eo.business.common.JBSbatMatchServiceInterface;
import eo.business.common.JCHbatPrcAdjChgeUtil;
import eo.business.common.JCHbatSeikyKaknoBusinessUtil;
import eo.business.util.file.JBSbatCHIFM110;
import eo.business.util.file.JBSbatCHIFM111;
import eo.business.util.file.JBSbatCHIFM112;
import eo.business.util.file.JBSbatCHIFM118;
import eo.business.util.table.JBSbatAC_M_PRC_SVC_KANRI;
import eo.business.util.table.JBSbatCH_M_PRC_KMK_CS_CHGE;
import eo.business.util.table.JBSbatCH_M_PRC_KMK_OPUT_NM;
import eo.business.util.table.JBSbatCH_M_PRC_SCHDL_TEIGI;
import eo.business.util.table.JBSbatCH_T_SAIKEN;
import eo.business.util.table.JBSbatCH_T_SEIKY;
import eo.business.util.table.JBSbatCH_T_SEIKY_UCWK;
import eo.business.util.table.JBSbatCH_T_TOKUSOKU;
import eo.business.util.table.JBSbatKK_M_PCRS;
import eo.business.util.table.JBSbatKK_M_PPLAN;
import eo.business.util.table.JBSbatKK_T_KAISEN_USE_KEI;
import eo.business.util.table.JBSbatKK_T_OWNR_KEI;
import eo.business.util.table.JBSbatKK_T_SEIKY_KEI;
import eo.business.util.table.JBSbatKK_T_SVC_KEI;
import eo.business.util.table.JBSbatKK_T_SVKEI_KAISEN_UW;
import eo.business.util.table.JBSbatKK_T_KKTK_SVC_KEI;
import eo.common.constant.JACStrConst;
import eo.common.constant.JPCBatchMessageConstant;
import eo.common.util.JPCDateUtil;
import eo.common.util.JPCUtilCommon;
import eo.framework.application.JBSbatBusinessException;
import eo.framework.db.JBSbatSQLAccess;
import eo.framework.file.JBSbatDefFileUtil;
import eo.framework.file.JBSbatOutputFileUtil;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.item.JBSbatOutputItem;
import eo.framework.item.JBSbatServiceInterfaceMap;
import eo.framework.util.JBSbatAplConst;
import eo.framework.util.JBSbatCheckUtil;
import eo.framework.util.JCCBatchEsbInterface;

/**
* (クラスの機能概要) <p>
*<BR>
* @author 富士通
*/
public class JBSbatCHPrcIktAdj extends JBSbatBusinessService implements JBSbatMatchServiceInterface
{
	/**▼▼▼▼▼▼ツールから生成した宣言です 開始▼▼▼▼▼▼*/
	/** テーブル(料金項目抽出変換)*/
	private static final String D_TBL_NAME_CH_M_PRC_KMK_CS_CHGE = "CH_M_PRC_KMK_CS_CHGE";

	/** テーブル(料金コース)*/
	private static final String D_TBL_NAME_KK_M_PCRS = "KK_M_PCRS";

	/** テーブル(料金サービス管理)*/
	private static final String D_TBL_NAME_AC_M_PRC_SVC_KANRI = "AC_M_PRC_SVC_KANRI";

	/** テーブル(料金項目出力名称)*/
	private static final String D_TBL_NAME_CH_M_PRC_KMK_OPUT_NM = "CH_M_PRC_KMK_OPUT_NM";

	/** テーブル(請求契約)*/
	private static final String D_TBL_NAME_KK_T_SEIKY_KEI = "KK_T_SEIKY_KEI";

	/** テーブル(請求)*/
	private static final String D_TBL_NAME_CH_T_SEIKY = "CH_T_SEIKY";

	/** テーブル(サービス契約)*/
	private static final String D_TBL_NAME_KK_T_SVC_KEI = "KK_T_SVC_KEI";

	/** テーブル(請求内訳)*/
	private static final String D_TBL_NAME_CH_T_SEIKY_UCWK = "CH_T_SEIKY_UCWK";

	/** テーブル(料金スケジュール定義)*/
	private static final String D_TBL_NAME_CH_M_PRC_SCHDL_TEIGI = "CH_M_PRC_SCHDL_TEIGI";

	/** テーブル(サービス契約回線内訳)*/
	private static final String D_TBL_NAME_KK_T_SVKEI_KAISEN_UW = "KK_T_SVKEI_KAISEN_UW";

	/** テーブル(機器提供サービス契約)*/
	private static final String D_TBL_NAME_KK_T_KKTK_SVC_KEI = "KK_T_KKTK_SVC_KEI";

// OM-2015-0000082 ADD START
	/** テーブル(料金プラン)*/
	private static final String D_TBL_NAME_KK_M_PPLAN = "KK_M_PPLAN";
// OM-2015-0000082 ADD END

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

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

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

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

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

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

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

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

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

	/** SQL定義キー(AC_SELECT_012)*/
	public static final String CH_M_PRC_SCHDL_TEIGI_AC_SELECT_012 = "AC_SELECT_012";

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

	/** SQL定義キー(CH_SELECT_008)*/
	private static final String KK_T_SVC_KEI_CH_SELECT_008 = "CH_SELECT_008";
	
	/** SQL定義キー(CH_SELECT_012)*/
	private static final String CH_M_PRC_KMK_CS_CHGE_CH_SELECT_012 = "CH_SELECT_012";

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

// OM-2015-0000082 ADD START
	/** SQL定義キー(CH_SELECT_002)*/
	private static final String KK_M_PPLAN_CH_SELECT_002 = "CH_SELECT_002";
// OM-2015-0000082 ADD END

// ANK-3296-00-00 v36.00.00 2018/01/29 Add Start
	/** SQL定義キー(CH_SELECT_006)*/
	private static final String CH_M_PRC_KMK_OPUT_NM_CH_SELECT_006 = "CH_SELECT_006";
// ANK-3296-00-00 v36.00.00 2018/01/29 Add End
	
// IT2-2023-0000015 ADD START
	/** 業務パラメータ（調整費） */
	private static final String WKPRA_CH_ADJ_HI_PRC_KMK = "CH_ADJ_HI_PRC_KMK";
// IT2-2023-0000015 ADD END

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

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

	/** テーブルアクセスクラス(料金サービス管理)*/
	private JBSbatSQLAccess db_AC_M_PRC_SVC_KANRI = null;

	/** テーブルアクセスクラス(料金項目出力名称)*/
	private JBSbatSQLAccess db_CH_M_PRC_KMK_OPUT_NM = null;

	/** テーブルアクセスクラス(請求契約)*/
	private JBSbatSQLAccess db_KK_T_SEIKY_KEI = null;

	/** テーブルアクセスクラス(請求)*/
	private JBSbatSQLAccess db_CH_T_SEIKY = null;

	/** テーブルアクセスクラス(請求)*/
	private JBSbatSQLAccess db_CH_T_SEIKY_2 = null;

	/** テーブルアクセスクラス(サービス契約)*/
	private JBSbatSQLAccess db_KK_T_SVC_KEI = null;

	/** テーブルアクセスクラス(請求内訳)*/
	private JBSbatSQLAccess db_CH_T_SEIKY_UCWK = null;

	/** テーブルアクセスクラス(料金スケジュール定義)*/
	private JBSbatSQLAccess db_CH_M_PRC_SCHDL_TEIGI = null;

	/** テーブルアクセスクラス(サービス契約回線内訳)*/
	private JBSbatSQLAccess db_KK_T_SVKEI_KAISEN_UW = null;

	/** テーブルアクセスクラス(機器提供サービス契約)*/
	private JBSbatSQLAccess db_KK_T_KKTK_SVC_KEI = null;

// OM-2015-0000082 ADD START
	/** テーブルアクセスクラス(料金プラン)*/
	private JBSbatSQLAccess db_KK_M_PPLAN = null;
// OM-2015-0000082 ADD END

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

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

	/** トランファイル処理フラグ*/
	private boolean tranProcFlg;
	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/
	
	/**▼▼▼▼▼▼クラス変数追加 開始▼▼▼▼▼▼*/
	
	/** エラー内容マップ．エラーコードのインデックス */
	private static final int ERR_NAIYO_MAP_ERR_CD = 0;
	
	/** エラー内容マップ．エラー内容のインデックス */
	private static final int ERR_NAIYO_MAP_ERR_NAIYO = 1;
	
	/** フラグ（有効） */
	private static final String FLG_ON = "1";
	
	/** フラグ（無効） */
	private static final String FLG_OFF = "0";
	
	/** マップキー（更新区分） */
	private static final String UPD_DIV = "UPD_DIV";
	
	/** 債権内訳．料金コースコード */
	private static final String SAIKEN_UCWK_PCRS_CD = "SK_PCRS_CD";
	
	/** 債権内訳．料金サービスコード */
	private static final String SAIKEN_UCWK_PRC_SVC_CD = "SK_PRC_SVC_CD";
	
	/** 債権内訳．料金項目コード */
	private static final String SAIKEN_UCWK_PRC_KMK_CD = "SK_PRC_KMK_CD";
	
	/** 更新前請求更新年月日時分秒 */
	private static final String SEIKY_UPD_DTM = "SEIKY_UPD_DTM";
	
	/** 更新前債権更新年月日時分秒 */
	private static final String SAIKEN_UPD_DTM = "SAIKEN_UPD_DTM";
	
	/** 請求金額 */
	private static final String SEIKY_AMNT = "SEIKY_AMNT";

	/** 料金訂正可否 */
	private static final String PRC_TEISE_KH = "PRC_TEISE_KH";

	/** KEY（CSV_ERR） */
	private static final String KEY_CSV_ERR = "CSV_ERR";
	
	/** 処理通番（0001） */
	private static final String TRAN_SEQ_0001 = "0001";
	
	/** 処理通番（0000） */
	private static final String TRAN_SEQ_0000 = "0000";
	
	/** 業務機能識別コード（請求額合計） */
	private String wkparaSikyAmntGk = JACStrConst.KARA_MOJI;
	
	/** 業務機能識別コード（訂正可能料金項目） */
	private String wkparaPrcAdjTrg = JACStrConst.KARA_MOJI;
	
	/** 業務機能識別コード（前受金対象） */
	private String wKinoMaeKinTrg = JACStrConst.KARA_MOJI;

	/** 請求年月 */
	private String tmpSikyYm = JACStrConst.KARA_MOJI;
	
	/** 初回レコードフラグ */
	private String firstRecFlg = FLG_ON;
	
	/** 処理グループ初回フラグ */
	private String tranGrpFstFlg = FLG_ON;
	
	/** 処理グループ番号エラーフラグ */
	private String tranGrpNoErrFrg = FLG_OFF;
	
	/** 業務パラメータ */
	private String tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_0000;
	
	/** 未入居明細用部屋番号（業務パラメータ） */
	private String minyukyoRoomNo = JACStrConst.KARA_MOJI;
	
	/** オーナー用料金グループコード（業務パラメータ） */
	private String ownrPrcGrpCd = JACStrConst.KARA_MOJI;
	
	/** 処理グループ番号 */
	private String tranGroupNo = null;
	
	/** 前回KEY */
	private String tmpPrvKey = null;
	
	/** KEY */
	private String tmpKey = null;
	
	/** 処理通番 */
	private String tranSeq = TRAN_SEQ_0000;
	
	/** 請求契約番号 */
	private String tmpSikyKeiNo = null;
	
	/** 請求番号 */
	private String tmpSikyNo = null;
	
	/** 整理番号 */
	private String tmpSeiriNo = null;
	
	/** 債権番号 */
	private String tmpSaikenNo = JACStrConst.KARA_MOJI;
	
	/** サービス契約番号（ダミー） */
	private String tmpSvcKeiNo = null;
	
	/** 退避．マンションIDマップ */
	private HashMap<String, String> bkMansIdMap = new HashMap<String, String>();
	
	/** エンコード */
	private String encode = JACStrConst.KARA_MOJI;
	
	/** defファイル名（料金調整エラーリスト） */
	private String tmpDefFileNmErr = JACStrConst.KARA_MOJI;
	
	/** 料金コースコードリスト */
	private HashMap<String, JBSbatCommonDBInterface> pcrsCdList = null;
	
	/** 料金サービスコードリスト */
	private ArrayList<String> prcSvcCdList = null;
	
//IT1-2014-0000174 DEL STA 安井
//	/** 料金項目コードリスト */
//	private ArrayList<String> prcKmkCdList = null;
//IT1-2014-0000174 DEL END 安井
	
	/** 料金調整可能料金項目コードリスト */
	private ArrayList<String> prcAdjOkPrcKmkList = null;
	
	/** 前受金料金項目コードリスト */
	private ArrayList<String> prcMaeUkKinPrcKmkList = null;
	
	/** 処理グループ番号リスト */
	private ArrayList<String> tranNoGroupList = null;
	
	/** 請求契約番号リスト */
	private ArrayList<String> sikyKeiNoList = null;
	
	/** 入力データリスト */
	private ArrayList<HashMap<String, String>> inDataList = null;
	
	/** 請求内訳リスト */
	private ArrayList<HashMap<String, String>> sikyUcwkList = null;
	
	/** 調整区分マップ */
	private HashMap<String, String> adjDivMap = null;
	
	/** 料金出力名称データマップ */
	private HashMap<String, HashMap<String, String>> prcOputNmMap = null;
	
	/** エラー内容マップ */
	private HashMap<String, ArrayList<String>> errNaiyoMap = null;
	
	/** 請求収納共通部品アクセスクラス */
	private JCHbatSeikyKaknoBusinessUtil sku = null;
	
	/** サービス関連マップ */
	private HashMap<String, String> svcMap = new HashMap<String, String>();

	/** ユーザー関連マップ */
	private HashMap<String, String> userMap = new HashMap<String, String>();

	/** 処理グループ単位情報保持マップ */
	private HashMap<String, String> shoriGroupMap = new HashMap<String, String>();
	
	/** 未入居明細用サービス契約番号 */
	private String minyukyoSvcKeiNo = null;

	/** 未入居判定フラグ */
	private boolean miNyukyoFlg = false;

	/** イベント年月日（料金計算日）マップ */
	private HashMap<String, String> prcCalcDayMap = new HashMap<String, String>();

	/** イベント年月日（請求処理日）マップ */
	private HashMap<String, String> prcSeikyDayMap = new HashMap<String, String>();
	
	/** ゼロ */
	private final String ZERO = "0";
	
	/** 必須詳細料金項目マップ*/
	private  HashSet<String> reDtPrcMap 	= null;
	
	/** 必須詳細料金項目（重複可）マップ*/
	private  HashSet<String> reDtDplMap 	= null;
	
	/** 必須詳細料金項目（タブレット）マップ*/
	private  HashSet<String> reDtTtPrcMap 	= null;
	
//v16.00.00 2015/06/08 Add Start
	/** 必須詳細料金項目（eo電気）マップ*/
	private  HashSet<String> reDtElectPrcMap 	= null;
//v16.00.00 2015/06/08 Add End
	
// ANK-3296-00-00 v36.00.00 2018/01/22 Add Start
	/** 必須詳細料金項目（工事費割賦）マップ*/
	private  HashSet<String> reDtKjHiKpPrcMap 	= null;
// ANK-3296-00-00 v36.00.00 2018/01/22 Add End
	
	/** 退避．業務機能識別コード（必須詳細料金項目） */
	private String wKinoSkbtReDtPrc = null;
	
	/** 退避．業務機能識別コード（必須詳細料金項目（重複可）） */
	private String wKinoSkbtReDtDpl = null;
	
	/** 退避．業務機能識別コード（必須詳細料金項目（タブレット）） */
	private String wKinoSkbtReDtTtPrc = null;
	
//v16.00.00 2015/06/08 Add Start
	/** 退避．業務機能識別コード（必須詳細料金項目（eo電気必須詳細料金項目）） */
	private String wKinoSkbtReDtElectPrc = null;
//v16.00.00 2015/06/08 Add End
	
// ANK-3296-00-00 v36.00.00 2018/01/22 Add Start
	/** 退避．業務機能識別コード（必須詳細料金項目（工事費割賦））*/
	private  String wKinoSkbtReDtKjHiKpPrc 	= null;
// ANK-3296-00-00 v36.00.00 2018/01/22 Add End
	
	/** 請求内訳番号マップ */
	private HashMap<String, BigDecimal> seikyUcwkNoMap = new HashMap<String, BigDecimal>();
	
//IT1-2014-0000164 ADD STA
	/** 請求年月月末日 */
	private String seikyYmEndDay = null;
//IT1-2014-0000164 ADD END
	
// OM-2015-0000082 ADD START
	/** 請求オプション料金プランマップ */
	private HashMap<String, String> seiopPplanMap = new HashMap<String, String>();
// OM-2015-0000082 ADD END

// IT2-2023-0000015 ADD START
	/** 調整費料金項目コードマップ */
	private HashMap<String, String> adjHiPrcKmkMap = new HashMap<String, String>();
// IT2-2023-0000015 ADD END

	/**▲▲▲▲▲▲クラス変数追加 終了▲▲▲▲▲▲*/
	
	/**
	 * 初期処理
	 * @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_KK_M_PCRS = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_M_PCRS);
		db_AC_M_PRC_SVC_KANRI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AC_M_PRC_SVC_KANRI);
		db_CH_M_PRC_KMK_OPUT_NM = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CH_M_PRC_KMK_OPUT_NM);
		db_KK_T_SEIKY_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SEIKY_KEI);
		db_CH_T_SEIKY = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CH_T_SEIKY);
		db_CH_T_SEIKY_2 = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CH_T_SEIKY);
		db_KK_T_SVC_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SVC_KEI);
		db_CH_T_SEIKY_UCWK = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CH_T_SEIKY_UCWK);
		db_CH_M_PRC_SCHDL_TEIGI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CH_M_PRC_SCHDL_TEIGI);
		db_KK_T_SVKEI_KAISEN_UW = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SVKEI_KAISEN_UW);
		db_KK_T_KKTK_SVC_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_KKTK_SVC_KEI);
				
// OM-2015-0000082 ADD START
		db_KK_M_PPLAN = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_M_PPLAN);
// OM-2015-0000082 ADD END
		
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][initial]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][initial][onlineOpeDate=" + super.onlineOpeDate + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][initial][freeItem=" + super.freeItem + "]");
		
		this.sku = new JCHbatSeikyKaknoBusinessUtil(commonItem);
		
		// 業務パラメータ、システムパラメータ取得
		this.getWorkSysPara();
		
		// 請求年月取得
		this.getSikyYm();
		
		// 料金スケジュール定義アクセス部品
		JACbatSchdlUtil schdlUtil = new JACbatSchdlUtil(commonItem);
		
//IT1-2014-0000164 ADD STA
		// 月末日[1]
		String[] ymd = schdlUtil.getUseStrEnd(this.tmpSikyYm, JACStrConst.EVENT_CD_USE_STAYMD, JACStrConst.EVENT_CD_USE_ENDYMD);
		this.seikyYmEndDay = ymd[1];
//IT1-2014-0000164 ADD END
		
		schdlUtil.close();
		
		// 料金コースコードリスト、料金サービスコードリスト、料金項目コードリスト作成
		this.makePrcCdMap();
		
		// 料金項目出力名称マップ作成
		this.makePrcOputNmMap();
		
		String[] freeItems = super.freeItem.split(JACStrConst.FREE_DIV);
		
		// エンコード取得
		this.encode = freeItems[1];
		
		// defファイル名（料金調整エラーリスト）取得
		this.tmpDefFileNmErr =  freeItems[2];
		
		// 調整マップ作成
		this.makeAdjDivMap();
		
		this.tranNoGroupList		=	new ArrayList<String>();
		this.sikyKeiNoList			=	new ArrayList<String>();
		this.inDataList				=	new ArrayList<HashMap<String, String>>();
		this.sikyUcwkList			=	new ArrayList<HashMap<String, String>>();

		// 料金調整、料金変更共通部品オブジェクト生成し、バッチ→サービス間マッピングで必要な情報を取得
		JCHbatPrcAdjChgeUtil prcAdjChgeUtil = new JCHbatPrcAdjChgeUtil(commonItem);

		// サービス関連情報を取得
		svcMap = prcAdjChgeUtil.getSvcMap(commonItem, JCHbatPrcAdjChgeUtil.SHORI_KBN_ADJ);
		// ユーザー関連情報を取得
		userMap = prcAdjChgeUtil.getUserMap(commonItem, freeItems[0]);

		prcAdjChgeUtil.close();
		
		// 未入居明細用サービス契約コード取得
		JACbatParamUtil paramUtil = new JACbatParamUtil(commonItem);
		this.minyukyoSvcKeiNo = paramUtil.getGyoumuParameter(JACStrConst.WKPAR_AC_MINYUKYO_SVCKEINO);
		paramUtil.close();

		// 料金計算日のイベント年月日をマップに保持
		this.prcCalcDayMap = this.getEventYmd();
		
		// 請求処理日のイベント年月日をマップに保持
		this.prcSeikyDayMap = this.getEventYmdSeiky();
		
		// 必須料金項目マップ初期化
		this.reDtPrcMap = new HashSet<String>();
		
		// 必須料金項目（重複可）マップ初期化
		this.reDtDplMap = new HashSet<String>();
		
		// 必須料金項目（タブレット）マップ初期化
		this.reDtTtPrcMap = new HashSet<String>();
//v16.00.00 2015/06/27 Add Start
		// 必須料金項目（ｅｏ電気）マップ初期化
		this.reDtElectPrcMap = new HashSet<String>();
//v16.00.00 2015/06/28 Add End
		
// ANK-3296-00-00 v36.00.00 2018/01/22 Add Start
		// 必須料金項目（工事費割賦）マップ初期化
		this.reDtKjHiKpPrcMap = new HashSet<String>();
// ANK-3296-00-00 v36.00.00 2018/01/22 Add End
		
// ANK-3296-00-00 v36.00.00 2018/01/22 Mod Start
		// 必須料金項目取得
		//this.getPrcInfo(wKinoSkbtReDtPrc, reDtPrcMap);
		this.getPrcInfo(wKinoSkbtReDtPrc, JACStrConst.SYS_CD_AC, reDtPrcMap);
		
		// 必須料金項目（重複可）取得
		//this.getPrcInfo(wKinoSkbtReDtDpl, reDtDplMap);
		this.getPrcInfo(wKinoSkbtReDtDpl, JACStrConst.SYS_CD_AC, reDtDplMap);
		
		reDtPrcMap.addAll(reDtDplMap);
		
		// 必須料金項目（タブレット）取得
		//this.getPrcInfo(wKinoSkbtReDtTtPrc, reDtTtPrcMap);
		this.getPrcInfo(wKinoSkbtReDtTtPrc, JACStrConst.SYS_CD_AC, reDtTtPrcMap);
		
//v16.00.00 2015/06/08 Add Start
		// 必須料金項目（eo電気）取得
		//this.getPrcInfo(wKinoSkbtReDtElectPrc, reDtElectPrcMap);
		this.getPrcInfo(wKinoSkbtReDtElectPrc, JACStrConst.SYS_CD_AC, reDtElectPrcMap);
//v16.00.00 2015/06/08 Add End
// ANK-3296-00-00 v36.00.00 2018/01/22 Mod End
		
// ANK-3296-00-00 v36.00.00 2018/01/22 Add Start
		// 必須料金項目（工事費割賦）取得
		this.getPrcInfo(wKinoSkbtReDtKjHiKpPrc, JACStrConst.SYS_CD_CH, reDtKjHiKpPrcMap);
// ANK-3296-00-00 v36.00.00 2018/01/22 Add End
		
// OM-2015-0000082 ADD START
		// 請求オプション料金プランマップ設定
		this.setSeiopPplanMap();
// OM-2015-0000082 ADD END
		
		assert this.encode != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][initial][encode=" + this.encode + "]") : true;
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][initial]");
	/**▲▲▲▲▲▲業務サービスの初期処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 主処理
	 * @param mastMap　入力電文
	 * @param tranMap　入力電文
	 * @param outputInItem  入力情報
	 * @return JBSbatOutputItem 出力情報
	 * @throws Exception
	 */
	public JBSbatOutputItem execute(JBSbatServiceInterfaceMap mastMap, JBSbatServiceInterfaceMap tranMap, JBSbatOutputItem outputInItem) throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの主処理を記述してください。▼▼▼▼▼▼*/
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute]");
		assert mastMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute][mastMap=" + mastMap.getMap().toString() + "]") : true;
		assert tranMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute][tranMap=" + tranMap.getMap().toString() + "]") : true;

		// トランファイル処理フラグを設定する。
		this.setTranProcFlg(true);
		// マスタファイル処理フラグを設定する。
		this.setMastProcFlg(true);
		
		// キーブレイク判定を行います。
		this.jdgeKeyBreak(mastMap, outputInItem);
		
		// 退避．業務パラメータ　＝　初期値（CH_PRC_ADJ_MSG_0000）の場合
		if(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_0000.equals(this.tmpWkPara))
		{
			// 入力データチェックを行います。
			this.chkInData(mastMap);
		}
		// 入力データリストへ入力情報、チェック情報を退避
		this.addInDataList(mastMap, tranMap);
		
// ANK-3296-00-00 v36.00.00 2018/01/29 Add Start
		// 必須詳細料金項目（工事費割賦）マップに料金項目コードが存在し、かつ退避．業務パラメータ　＝　初期値（CH_PRC_ADJ_MSG_0000）の場合
		if(this.reDtKjHiKpPrcMap.contains(mastMap.getString(JBSbatCHIFM110.PRC_KMK_CD)) && JACStrConst.WKPRA_CH_PRC_ADJ_MSG_0000.equals(this.tmpWkPara))
		{
			// 入力データリストに情報を追加
			addInDataListKjHiKp(mastMap, tranMap);
		}
// ANK-3296-00-00 v36.00.00 2018/01/29 Add End
		
		// 退避．業務パラメータ　初期値に設定
		this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_0000;
		// 初回レコードフラグ更新
		this.firstRecFlg = FLG_OFF;
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][execute]");
		return outputInItem;
	/**▲▲▲▲▲▲業務サービスの主処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 業務サービス終了処理
	 * @throws Exception
	 */
	public void terminal() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの終了処理を記述してください。▼▼▼▼▼▼*/
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][terminal]");
		
		// 退避．入力データリストにデータが格納されている場合
		if(this.inDataList.size() > 0)
		{
			// 料金調整制御処理を行います。
			this.executeRemainRecord();
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "料金調整制御処理");
		}
		
		/**▼▼▼▼▼▼ツールから生成した終了処理のソースです 開始▼▼▼▼▼▼*/
		// DBアクセスクラスをクローズします
		db_CH_M_PRC_KMK_CS_CHGE.close();
		db_KK_M_PCRS.close();
		db_AC_M_PRC_SVC_KANRI.close();
		db_CH_M_PRC_KMK_OPUT_NM.close();
		db_KK_T_SEIKY_KEI.close();
		db_CH_T_SEIKY.close();
		db_CH_T_SEIKY_2.close();
		db_KK_T_SVC_KEI.close();
		db_CH_T_SEIKY_UCWK.close();
		db_CH_M_PRC_SCHDL_TEIGI.close();
		db_KK_T_SVKEI_KAISEN_UW.close();
		db_KK_T_KKTK_SVC_KEI.close();

// OM-2015-0000082 ADD START
		db_KK_M_PPLAN.close();
// OM-2015-0000082 ADD END
		/**▲▲▲▲▲▲ツールから生成した終了処理のソースです 終了▲▲▲▲▲▲*/
		this.sku.close();
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][terminal]");
	/**▲▲▲▲▲▲業務サービスの終了処理を記述してください。▲▲▲▲▲▲*/
	}

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

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

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

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

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

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

	/**
	 * SQLKEY(CH_SELECT_004)で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_CH_SELECT_004(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_CH_SELECT_004);
	}

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

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

	/**
	 * SQLKEY(AC_SELECT_004)で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_PRC_SVC_KANRI_AC_SELECT_004(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_PRC_SVC_KANRI.selectBySqlDefine(paramList, AC_M_PRC_SVC_KANRI_AC_SELECT_004);
	}

	/**
	 * SQLKEY(CH_SELECT_002)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	料金項目名称種別コード
	 *		 	適用開始年月日
	 *		 	適用終了年月日
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeCH_M_PRC_KMK_OPUT_NM_CH_SELECT_002(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_CH_M_PRC_KMK_OPUT_NM.selectBySqlDefine(paramList, CH_M_PRC_KMK_OPUT_NM_CH_SELECT_002);
	}

// ANK-3296-00-00 v36.00.00 2018/01/29 Add Start
	/**
	 * SQLKEY(CH_SELECT_006)で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_OPUT_NM_CH_SELECT_006(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());
		paramList.setValue(param[5].toString());
		paramList.setValue(param[6].toString());
		paramList.setValue(param[7].toString());
		// DBアクセスを実行します
		db_CH_M_PRC_KMK_OPUT_NM.selectBySqlDefine(paramList, CH_M_PRC_KMK_OPUT_NM_CH_SELECT_006);
		}
// ANK-3296-00-00 v36.00.00 2018/01/29 Add End
	
	/**
	 * SQLKEY(CH_SELECT_004)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	請求契約番号
	 *		 	予約適用年月日
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_T_SEIKY_KEI_CH_SELECT_004(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());
		paramList.setValue(param[1].toString());

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

	/**
	 * SQLKEY(CH_SELECT_024)で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_T_SEIKY_CH_SELECT_024(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_CH_T_SEIKY.selectBySqlDefine(paramList, CH_T_SEIKY_CH_SELECT_024);
	}

	/**
	 * SQLKEY(CH_SELECT_041)で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_T_SEIKY_CH_SELECT_041(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_CH_T_SEIKY_2.selectBySqlDefine(paramList, CH_T_SEIKY_CH_SELECT_041);
	}

	/**
	 * SQLKEY(CH_SELECT_001)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	予約適用年月日
	 *		 	課金先適用年月日
	 *		 	予約適用年月日
	 *		 	請求契約番号
	 *		 	サービス契約番号
	 *		 	料金グループコード
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_T_SVC_KEI_CH_SELECT_001(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());
		paramList.setValue(param[1].toString());
		paramList.setValue(param[2].toString());
		paramList.setValue(param[3].toString());
		paramList.setValue(param[4].toString());
		// OM-2019-0000646 DEL START
//		paramList.setValue(param[5].toString());
		// OM-2019-0000646 DEL END
		// v49.00.00 ADD START
		paramList.setValue(param[5].toString());
		paramList.setValue(param[6].toString());
		paramList.setValue(param[7].toString());
		// v49.00.00 ADD END

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

	/**
	 * SQLKEY(CH_SELECT_010)で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_T_SEIKY_UCWK_CH_SELECT_010(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());
		paramList.setValue(param[5].toString());
		paramList.setValue(param[6].toString());
		paramList.setValue(param[7].toString());
		paramList.setValue(param[8].toString());
		paramList.setValue(param[9].toString());
		paramList.setValue(param[10].toString());
		paramList.setValue(param[11].toString());
		paramList.setValue(param[12].toString());
		paramList.setValue(param[13].toString());
		paramList.setValue(param[14].toString());
		paramList.setValue(param[15].toString());
		paramList.setValue(param[16].toString());
		paramList.setValue(param[17].toString());
		paramList.setValue(param[18].toString());
		paramList.setValue(param[19].toString());

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

	/**
	 * SQLKEY(AC_SELECT_012)で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_SCHDL_TEIGI_AC_SELECT_012(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());

		// DBアクセスを実行します
		db_CH_M_PRC_SCHDL_TEIGI.selectBySqlDefine(paramList, CH_M_PRC_SCHDL_TEIGI_AC_SELECT_012);
	}
	
	/**
	 * SQLKEY(CH_SELECT_001)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	回線内訳使用開始日
	 *		 	回線内訳使用終了日
	 *		 	サービス契約番号
	 *		 	予約適用年月日
	 *		 	マンションID
	 *		 	CATID
	 *		 	マンション営業案件管理番号
	 *		 	PID
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_T_SVKEI_KAISEN_UW_CH_SELECT_001(Object[] param) throws Exception
	{
		// バイント変数のリストを生成します
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		paramList.setValue(param[0].toString());
		paramList.setValue(param[1].toString());
		paramList.setValue(param[2].toString());
		paramList.setValue(param[3].toString());
		paramList.setValue(param[4].toString());
		paramList.setValue(param[5].toString());
		paramList.setValue(param[6].toString());
		paramList.setValue(param[7].toString());

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

	/**
	 * SQLKEY(CH_SELECT_008)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	マンションID
	 *		 	CATID
	 *		 	マンション営業案件管理番号
	 *		 	PID
	 *		 	予約適用年月日
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_T_SVC_KEI_CH_SELECT_008(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_KK_T_SVC_KEI.selectBySqlDefine(paramList, KK_T_SVC_KEI_CH_SELECT_008);
	}
	
	/**
	 * SQLKEY(CH_SELECT_012)で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_CH_SELECT_012(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_CH_SELECT_012);
	}
	
	/**
	 * SQLKEY(CH_SELECT_002)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	サービス契約番号
	 *		 	機器製造番号
	 *			予約適用開始日
	 *		 	サービス契約番号
	 *		 	機器製造番号
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_T_KKTK_SVC_KEI_CH_SELECT_002(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_KK_T_KKTK_SVC_KEI.selectBySqlDefine(paramList, KK_T_KKTK_SVC_KEI_CH_SELECT_002);
	}

	/**▲▲▲▲▲▲ツールから生成したメソッドです 終了▲▲▲▲▲▲*/
	
	/**▼▼▼▼▼▼メソッド追加 開始▼▼▼▼▼▼*/
	
	/**
	 * 業務パラメータ管理及び、システムパラメータ管理から値を取得します。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void getWorkSysPara() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getWorkSysPara]");
		
		JACbatParamUtil paramUtil = new JACbatParamUtil(commonItem);
		
		this.errNaiyoMap = new HashMap<String, ArrayList<String>>();
		
		try
		{
			// 業務機能識別コード（合算請求作成（当月未請求）） 
			wkparaSikyAmntGk = paramUtil.getGyoumuParameter(JACStrConst.WKPRA_CH_WKS_GSN_SKY_TG_MI);
			
			// 業務機能識別コード（料金調整対象）
			wkparaPrcAdjTrg = paramUtil.getGyoumuParameter(JACStrConst.WKPRA_CH_WKS_TEISE_PSB_PRC);
			
			// 業務機能識別コード（前受金充当額（請求先単位））
			this.wKinoMaeKinTrg = paramUtil.getGyoumuParameter(JACStrConst.WKPRA_CH_WKS_MAEUK_JT_SIKY);
			
			// 未入居明細用部屋番号取得（業務パラメータ）
			this.minyukyoRoomNo = paramUtil.getGyoumuParameter(JACStrConst.WKPAR_CH_MINYUKYO_ROOM_NO);

			// オーナー用料金グループコード（業務パラメータ）
			this.ownrPrcGrpCd =  paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AC_OWNR_PRC_GRP_CD);
			
			// 業務機能識別コード（必須詳細料金項目）
			this.wKinoSkbtReDtPrc = paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AC_RE_DT_PRC);
			
			// 業務機能識別コード（必須詳細料金項目（重複可））
			this.wKinoSkbtReDtDpl = paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AC_RE_DT_DPL);

			// 業務機能識別コード（必須詳細料金項目（タブレット））
			this.wKinoSkbtReDtTtPrc = paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AC_RE_DT_TAB_PRC);
			
//v16.00.00 2015/06/08 Add Start
			// 業務機能識別コード（必須詳細料金項目（eo電気））
			this.wKinoSkbtReDtElectPrc = paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AC_RE_DT_ELEC_PRC);
//v16.00.00 2015/06/08 Add End
			
// ANK-3296-00-00 v36.00.00 2018/01/22 Add Start
			// 業務機能識別コード（必須詳細料金項目（工事費割賦））
			this.wKinoSkbtReDtKjHiKpPrc = paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AC_DT_KJ_HI_KAP_PRC);
// ANK-3296-00-00 v36.00.00 2018/01/22 Add End
			
			// エラー内容マップに値を設定（キー：業務パラメータID、値[0]：エラーコード、値[1]：エラー内容）
			
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_H001,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_H001,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E001,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E001,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E002,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E002,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E003,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E003,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E004,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E004,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E005,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E005,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E006,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E006,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E007,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E007,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E008,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E008,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E009,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E009,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E010,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E010,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E011,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E011,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E012,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E012,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E013,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E013,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E014,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E014,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E015,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E015,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E016,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E016,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E017,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E017,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E018,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E018,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E019,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E019,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E020,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E020,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E021,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E021,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E022,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E022,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E023,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E023,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E024,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E024,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_0000,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_0000,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E025,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E025,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E026,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E026,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E027,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E027,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E028,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E028,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E029,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E029,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E030,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E030,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E031,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E031,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E032,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E032,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E033,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E033,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E034,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E034,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E035,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E035,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E036,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E036,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E037,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E037,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E038,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E038,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E039,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E039,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E040,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E040,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E041,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E041,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E042,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E042,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E043,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E043,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E044,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E044,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E045,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E045,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E046,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E046,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E047,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E047,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E048,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E048,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E049,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E049,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E050,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E050,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E051,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E051,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E052,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E052,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E053,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E053,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E054,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E054,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E055,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E055,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E056,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E056,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E057,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E057,		paramUtil));
// OM-2015-0000082 ADD START
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E058,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E058,		paramUtil));
// OM-2015-0000082 ADD END
//v16.00.00 2015/06/08 Add Start
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E059,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E059,		paramUtil));
//v16.00.00 2015/06/08 Add End
// ANK-3296-00-00 v36.00.00 2018/01/22 Add Start
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E060,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E060,		paramUtil));
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E061,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E061,		paramUtil));
// ANK-3296-00-00 v36.00.00 2018/01/22 Add End
// IT2-2023-0000015 ADD START
			this.errNaiyoMap.put(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E062,		this.getErrNaiyoMapValue(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E062,		paramUtil));
			
			// 料金項目コード（調整費）
			this.adjHiPrcKmkMap = paramUtil.getGyoumuParameterMap2(WKPRA_CH_ADJ_HI_PRC_KMK, super.opeDate);
// IT2-2023-0000015 ADD END
			assert this.errNaiyoMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getWorkPara][errNaiyoMap=" + this.errNaiyoMap.toString() + "]") : true;
			
		}
		finally
		{
			paramUtil.close();
		}
		
		// 各種料金項目コード　取得
		
		JBSbatCommonDBInterface prcKmkCsChgeMap = null;
		
		// 料金項目抽出変換スキーマを検索します。
		
		// 業務機能識別コード（料金調整対象）
		prcKmkCsChgeMap = selectPrcKmkCsChge(wkparaPrcAdjTrg);
		
		// 取得結果を料金調整可能料金項目コードリストに設定します。
		this.prcAdjOkPrcKmkList = new ArrayList<String>();
		
//IT1-2014-0000174 DEL STA 安井
//		// 取得結果を料金項目コードリストに設定します。
//		this.prcKmkCdList = new ArrayList<String>();
//IT1-2014-0000174 DEL END 安井
		
		while(null != prcKmkCsChgeMap)
		{
			StringBuffer buf = new StringBuffer();
			
			// 料金項目コード
			String prcKmkCd = prcKmkCsChgeMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PRC_KMK_CD);
			
			// 料金コースコード + 料金サービスコード + 料金項目コード
			buf.append(prcKmkCsChgeMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PCRS_CD));
			buf.append(prcKmkCsChgeMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PRC_SVC_CD));
			buf.append(prcKmkCd);

//IT1-2014-0000174 DEL STA 安井
//			// 料金項目コード
//			this.prcKmkCdList.add(prcKmkCd);
//IT1-2014-0000174 DEL END 安井
			
			// 料金コースコード+料金サービスコード+料金項目コード
			this.prcAdjOkPrcKmkList.add(buf.toString());
			
			prcKmkCsChgeMap = db_CH_M_PRC_KMK_CS_CHGE.selectNext();
		}
		
		//****前受金
		prcKmkCsChgeMap = null;
		
		// 業務機能識別コード（前受金対象）
		prcKmkCsChgeMap = selectPrcKmkCsChge(wKinoMaeKinTrg);
		
		// 取得結果を前受金料金項目コードリストに設定します。
		this.prcMaeUkKinPrcKmkList = new ArrayList<String>();
		
		while(null != prcKmkCsChgeMap)
		{
			StringBuffer buf = new StringBuffer();
			
			// 料金コースコード + 料金サービスコード + 料金項目コード
			buf.append(prcKmkCsChgeMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PCRS_CD));
			buf.append(prcKmkCsChgeMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PRC_SVC_CD));
			buf.append(prcKmkCsChgeMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PRC_KMK_CD));
			
			// 料金コースコード+料金サービスコード+料金項目コード
			this.prcMaeUkKinPrcKmkList.add(buf.toString());
			
			prcKmkCsChgeMap = db_CH_M_PRC_KMK_CS_CHGE.selectNext();
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getWorkSysPara]");
		return;
	}
	
	/**
	 * 料金情報取得を取得します。（必須料金項目取得用）
	 * @param wkKinoSkbt 業務機能識別コード
	 * @param sysCd システムコード
	 * @param targetMap 取得した料金情報を退避させるマップ
	 * @throws Exception
	 */
// ANK-3296-00-00 v36.00.00 2018/01/22 Mod Start
	//private void getPrcInfo(String wkKinoSkbt, HashSet<String> targetMap) throws Exception
	private void getPrcInfo(String wkKinoSkbt, String sysCd, HashSet<String> targetMap) throws Exception
// ANK-3296-00-00 v36.00.00 2018/01/22 Mod End
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getPrcInfoReDtPrc]");

		// ＤＢアクセス用のパラメータ定義
		JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();

		// 対象キーの設定
// ANK-3296-00-00 v36.00.00 2018/01/22 Mod Start
		//dbList.setValue(JACStrConst.SYS_CD_AC); 			// システムコード"AC"
		dbList.setValue(sysCd); 							// システムコード
// ANK-3296-00-00 v36.00.00 2018/01/22 Mod End
		dbList.setValue(wkKinoSkbt); 						// 業務機能識別コード
		dbList.setValue(JACStrConst.CHSHT_CHG_CD_CST); 		// 抽出変換コード（抽出のみ） 
		dbList.setValue(super.opeDate); 					// バッチ運用日
		dbList.setValue(super.opeDate); 					// バッチ運用日
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getPrcInfoReDtPrc]dbList：" + dbList.getList().toString());

		// 料金情報取得
		executeCH_M_PRC_KMK_CS_CHGE_CH_SELECT_012(dbList.getList().toArray());
		
		JBSbatCommonDBInterface dbMap = db_CH_M_PRC_KMK_CS_CHGE.selectNext();
		
		// 取得できた場合
		if(null != dbMap)
		{
			// 取得件数分、処理を継続する
			while(null != dbMap)
			{
				// 値をマップに設定
				targetMap.add(dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PRC_KMK_CD));
				
				dbMap = db_CH_M_PRC_KMK_CS_CHGE.selectNext();
			}
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getPrcInfoReDtPrc]");
	}
	
	/**
	 * エラー内容マップに設定する値を取得します。
	 * 
	 * @param wkparaId 業務パラメータID
	 * @param paramUtil インスタンス変数
	 * @return ArrayList<String> エラー内容マップに設定する値
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private ArrayList<String> getErrNaiyoMapValue(String wkparaId, JACbatParamUtil paramUtil) throws Exception
	{
		ArrayList<String> rtnList = new ArrayList<String>();
		
		// エラーコード
		rtnList.add(wkparaId.substring(wkparaId.length() - 4, wkparaId.length()));
		// エラー内容
		rtnList.add(paramUtil.getGyoumuParameter(wkparaId));
		
		return rtnList;
	}
	
	/**
	 * 料金項目抽出変換スキーマを検索し、結果を返却します。
	 * 
	 * @param gyoumSkbtCd 業務識別コード
	 * @return JBSbatCommonDBInterface 検索結果
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private JBSbatCommonDBInterface selectPrcKmkCsChge(String gyoumSkbtCd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][selectPrcKmkCsChge]");
		
		JBSbatCommonDBInterface whereParam = new JBSbatCommonDBInterface();
		
		// システムコード
		whereParam.setValue(super.systemCode);
		// 業務識別コード
		whereParam.setValue(gyoumSkbtCd);
		// 抽出変換コード
		whereParam.setValue(JACStrConst.CHSHT_CHG_CD_CST);
		// 適用開始年月日
		whereParam.setValue(super.onlineOpeDate);
		// 適用終了年月日
		whereParam.setValue(super.onlineOpeDate);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][selectPrcKmkCsChge][whereParam=" + whereParam.getList().toString() + "]");
		
		// SQL実行
		executeCH_M_PRC_KMK_CS_CHGE_CH_SELECT_004(whereParam.getList().toArray());
		
		// 結果取得
		JBSbatCommonDBInterface prcKmkCsChgeMap = db_CH_M_PRC_KMK_CS_CHGE.selectNext();
		
		// 取得なしの場合
		if(null == prcKmkCsChgeMap)
		{
			// ログ出力（【最重要】ＤＢ未存在エラー）
			String[] msgParam = new String[]
			{ JBSbatCH_M_PRC_KMK_CS_CHGE.TABLE_NAME, whereParam.getList().toString() };
			throw new JBSbatBusinessException(JPCBatchMessageConstant.ECHB0270CH, msgParam);
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][selectPrcKmkCsChge]");
		return prcKmkCsChgeMap;
	}
	
	/**
	 * 機器提供サービス契約スキーマを検索し、結果を返却します。
	 * 
	 * @param svcKeiNo サービス契約番号
	 * @param kikiSeizoNo 機器製造番号
	 * @return String 機器提供サービス契約番号
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private String selectkktkSvcKeiNo(String svcKeiNo, String kikiSeizoNo) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][selectkktkSvcKeiNo]");
		
		JBSbatCommonDBInterface whereParam = new JBSbatCommonDBInterface();
		
		String kktkSvcKeiNo = JACStrConst.KARA_MOJI;
		
		// サービス契約番号
		whereParam.setValue(svcKeiNo);
		// 機器製造番号
		whereParam.setValue(kikiSeizoNo);
		// 予約適用開始日
//IT1-2014-0000164 MOD STA
//		whereParam.setValue(this.onlineOpeDate);
		whereParam.setValue(this.seikyYmEndDay);
//IT1-2014-0000164 MOD END
		// サービス契約番号
		whereParam.setValue(svcKeiNo);
		// 機器製造番号
		whereParam.setValue(kikiSeizoNo);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][selectkktkSvcKeiNo][whereParam=" + whereParam.getList().toString() + "]");
		
		// SQL実行
		executeKK_T_KKTK_SVC_KEI_CH_SELECT_002(whereParam.getList().toArray());
		
		// 結果取得
		JBSbatCommonDBInterface kktkSvcKeiMap = db_KK_T_KKTK_SVC_KEI.selectNext();
		
		// 取得ありの場合
		if(null != kktkSvcKeiMap)
		{
			kktkSvcKeiNo = kktkSvcKeiMap.getString(JBSbatKK_T_KKTK_SVC_KEI.KKTK_SVC_KEI_NO);
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][selectkktkSvcKeiNo]kktkSvcKeiNo=" + kktkSvcKeiNo);
		return kktkSvcKeiNo;
	}
	
	/**
	 * 請求年月を取得します。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void getSikyYm() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSikyYm]");
		
		// 請求年月取得
		this.tmpSikyYm = sku.getSeikyYm(super.onlineOpeDate);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSikyYm][tmpSikyYm=" + this.tmpSikyYm + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getSikyYm]");
		return;
	}
	
	/**
	 * 料金コースコードリスト、料金サービスコードリスト、料金項目コードリストを作成します。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void makePrcCdMap() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makePrcCdMap]");
		
		// 料金コースコードリスト作成
		
		this.pcrsCdList = new HashMap<String, JBSbatCommonDBInterface>();
		
		JBSbatCommonDBInterface whereParam = new JBSbatCommonDBInterface();
		
		// オンライン運用日
		whereParam.setValue(super.onlineOpeDate);
		
		// SQL実行
		executeKK_M_PCRS_CH_SELECT_001(whereParam.getList().toArray());
		
		// 結果取得
		JBSbatCommonDBInterface dbMap = db_KK_M_PCRS.selectNext();
		
		while(null != dbMap)
		{
			// 料金コースコードリストに検索結果を設定
			
			// 料金コースコード
			this.pcrsCdList.put(dbMap.getString(JBSbatKK_M_PCRS.PCRS_CD), dbMap);
			
			dbMap = db_KK_M_PCRS.selectNext();
		}
//		assert this.pcrsCdList != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makePrcCdMap][pcrsCdLIst=" + this.pcrsCdList.toString() + "]") : true;
		
		// 料金サービスコードリスト作成
		
		this.prcSvcCdList = new ArrayList<String>();
		
		whereParam = new JBSbatCommonDBInterface();
		
		whereParam.setValue(JACStrConst.SYS_CD_AC);			// システムコード
		whereParam.setValue(super.onlineOpeDate);			// オンラインバッチ運用日
		whereParam.setValue(super.onlineOpeDate);			// オンラインバッチ運用日
		
		// SQL実行
		executeAC_M_PRC_SVC_KANRI_AC_SELECT_004(whereParam.getList().toArray());
		
		dbMap = db_AC_M_PRC_SVC_KANRI.selectNext();
		
		while(null != dbMap)
		{
			StringBuffer buf = new StringBuffer();
			
			buf.append(dbMap.getString(JBSbatAC_M_PRC_SVC_KANRI.PCRS_CD));			// 料金コースコード
			buf.append(dbMap.getString(JBSbatAC_M_PRC_SVC_KANRI.PRC_SVC_CD));		// 料金サービスコード
			
			// 料金サービスコードリストに検索結果を設定
			this.prcSvcCdList.add(buf.toString());
			
			dbMap = db_AC_M_PRC_SVC_KANRI.selectNext();
		}
		
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makePrcCdMap]");
		return;
	}
	
	/**
	 * 料金出力名称スキーマを検索し、
	 * その結果を退避情報に設定します。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	@SuppressWarnings("unchecked")
	private void makePrcOputNmMap() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makePrcOputNmMap]");
		
		JBSbatCommonDBInterface whereParam = new JBSbatCommonDBInterface();
		
		// 料金項目名称種別コード
		whereParam.setValue(JACStrConst.PRC_KMK_NM_SBT_CD_PRC_KMK);
		// 適用開始年月日
		whereParam.setValue(super.onlineOpeDate);
		// 適用終了年月日
		whereParam.setValue(super.onlineOpeDate);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makePrcOputNmMap][whereParam=" + whereParam.getList().toString() + "]");
		
		// SQL実行
		executeCH_M_PRC_KMK_OPUT_NM_CH_SELECT_002(whereParam.getList().toArray());
		
		// 結果取得
		JBSbatCommonDBInterface dbMap = db_CH_M_PRC_KMK_OPUT_NM.selectNext();
		
		// 取得なしの場合
		if(null == dbMap)
		{
			// ログ出力（【最重要】ＤＢ未存在エラー）
			String[] msgParam = new String[]
			{ JBSbatCH_M_PRC_KMK_OPUT_NM.TABLE_NAME, whereParam.getList().toString() };
			throw new JBSbatBusinessException(JPCBatchMessageConstant.ECHB0270CH, msgParam);
		}
		
		this.prcOputNmMap = new HashMap<String, HashMap<String, String>>();
		
		HashMap<String, String> dateMap = null;
		
		while(null != dbMap)
		{
			// 取得結果をHashMAp<String, String>の形に入れなおします。
			dateMap = (HashMap<String, String>)dbMap.getMap();
			dateMap.put(JBSbatCH_M_PRC_KMK_OPUT_NM.INDENT_CNT, dbMap.getValue(JBSbatCH_M_PRC_KMK_OPUT_NM.INDENT_CNT).toString());
			
			// 料金出力名称データマップに検索結果を設定（キー：料金コースコード＋料金サービスコード＋料金項目コード、値：取得結果）
			this.prcOputNmMap.put(this.makeKey(dbMap.getMap(), false), dateMap);
			
			// 設定情報
			dbMap = new JBSbatCommonDBInterface();
			
			dbMap = db_CH_M_PRC_KMK_OPUT_NM.selectNext();
		}
//		assert this.prcOputNmMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makePrcOputNmMap][prcOputNmMap=" + this.prcOputNmMap.toString() + "]") : true;
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makePrcOputNmMap]");
		return;
	}
	
	/**
	 * 調整区分マップを作成します。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void makeAdjDivMap() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeAdjDivMap]");
		
		// 調整区分マップ作成
		
		this.adjDivMap = new HashMap<String, String>();
		
		// KEY:調整区分"0"（設定なし）, VALUE:""（空文字）
		this.adjDivMap.put(JACStrConst.UPD_DIV_NON,			JACStrConst.KARA_MOJI);
		// KEY:調整区分"1"（追加）, VALUE:"追加"
		this.adjDivMap.put(JACStrConst.UPD_DIV_ADD,			"追加");
		// KEY:調整区分"2"（変更）, VALUE:"変更"
		this.adjDivMap.put(JACStrConst.UPD_DIV_ADJ,			"変更");
		// KEY:調整区分"3"（削除）, VALUE:"削除"
		this.adjDivMap.put(JACStrConst.UPD_DIV_DEL,			"削除");
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeAdjDivMap]");
		return;
	}
	
	/**
	 * キーブレイク判定を行います。
	 * 
	 * @param mastMap 入力電文
	 * @param outputInItem 入力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void jdgeKeyBreak(JBSbatServiceInterfaceMap mastMap, JBSbatOutputItem outputInItem) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][jdgeKeyBreak]");
		assert this.firstRecFlg != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][jdgeKeyBreak][firstRecFlg=" + this.firstRecFlg + "]") : true;
		assert this.tmpKey != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][jdgeKeyBreak][tmpKey=" + this.tmpKey + "]") : true;
		assert this.tmpPrvKey != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][jdgeKeyBreak][tmpPrvKey=" + this.tmpPrvKey + "]") : true;
		assert this.tranGrpFstFlg != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][jdgeKeyBreak][tranGrpFstFlg=" + this.tranGrpFstFlg + "]") : true;
		assert this.tranNoGroupList != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][jdgeKeyBreak][tranNoGroupList=" + this.tranNoGroupList.toString() + "]") : true;
		assert this.sikyKeiNoList != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][jdgeKeyBreak][sikyKeiNoList=" + this.sikyKeiNoList.toString() + "]") : true;
		
		// 入力データチェック（ブレイクキー関連）を行います
		this.chkInDataBreakKey(mastMap);
		
		// 初回レコードフラグ＝"1"の場合
		if(FLG_ON.equals(this.firstRecFlg))
		{
			// 前回キー更新
			this.tmpPrvKey = this.tmpKey;
			// 処理グループ単位マップに入力ファイル情報格納
			this.addInFileShoriGrpMap(mastMap);
			// 処理グループ初回フラグ更新
			this.tranGrpFstFlg = FLG_ON;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][jdgeKeyBreak][tmpPrvKey=" + this.tmpPrvKey + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][jdgeKeyBreak][tranGrpFstFlg=" + this.tranGrpFstFlg + "]");
		}
		// 退避．前回キー≠退避キーの場合
		if(!this.tmpPrvKey.equals(this.tmpKey))
		{
			// キー退避
			this.tmpPrvKey = this.tmpKey;
			
			// 料金調整制御処理実施
			this.prcAdjCtrl(outputInItem);
			
			// 処理グループ初回フラグ更新
			this.tranGrpFstFlg = FLG_ON;
			// 退避．処理通番初期化
			this.tranSeq = TRAN_SEQ_0000;
			// 退避．請求番号クリア
			this.tmpSikyNo = null;
			// 退避．整理番号クリア
			this.tmpSeiriNo = null;
			// サービス契約番号（ダミー）クリア
			this.tmpSvcKeiNo = null;
			// 退避．サービス契約番号（ダミー）クリア
			this.bkMansIdMap = new HashMap<String, String>();
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][jdgeKeyBreak][tmpPrvKey=" + this.tmpPrvKey + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][jdgeKeyBreak][tranSeq=" + this.tranSeq + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][jdgeKeyBreak][tmpPrvKey=" + this.tmpPrvKey + "]");
			
			// 退避．処理グループ番号≠nullの場合
			if(null != this.tranGroupNo)
			{
				// 処理グループ単位マップに入力ファイル情報格納
				this.addInFileShoriGrpMap(mastMap);
				// 退避．処理グループ番号リスト更新
				this.tranNoGroupList.add(this.tranGroupNo);
				// 退避．処理グループ番号クリア
				this.tranGroupNo = null;
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][jdgeKeyBreak][tranNoGroupList=" + this.tranNoGroupList.toString() + "]");
			}
			
			// 退避．請求契約番号≠nullの場合
			if(null != this.tmpSikyKeiNo)
			{
				// 退避．請求契約番号リスト更新
				this.sikyKeiNoList.add(this.tmpSikyKeiNo);
				// 昇順ソート
				Collections.sort(this.sikyKeiNoList);
				// 退避．請求契約番号クリア
				this.tmpSikyKeiNo = null;
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][jdgeKeyBreak][sikyKeiNoList=" + this.sikyKeiNoList.toString() + "]");
			}
			// 退避．業務パラメータ　＝　"CH_PRC_ADJ_MSG_0000"の場合
			if(JACStrConst.WKPRA_CH_PRC_ADJ_MSG_0000.equals(this.tmpWkPara))
			{
				// 退避．処理グループ番号エラーフラグ更新
				this.tranGrpNoErrFrg = FLG_OFF;
			}
			// 上記以外の場合
			else
			{
				// 退避．処理グループ番号エラーフラグ更新
				this.tranGrpNoErrFrg = FLG_ON;
			}
		}
		// 上記以外の場合
		else
		{
			// 退避．処理グループ初回フラグ更新
			this.tranGrpFstFlg = FLG_OFF;
		}
		
		assert this.tranGrpFstFlg != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][jdgeKeyBreak][tranGrpFstFlg=" + this.tranGrpFstFlg + "]") : true;
		assert this.tranGrpNoErrFrg != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][jdgeKeyBreak][tranGrpNoErrFrg=" + this.tranGrpNoErrFrg + "]") : true;
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][jdgeKeyBreak]");
		return;
	}
	
	/**
	 * 入力データチェック（ブレイクキー関連）を行います。
	 * 
	 * @param mastMap 入力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void chkInDataBreakKey(JBSbatServiceInterfaceMap mastMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][chkInDataBreakKey]");
		
		// csv形式チェック
		
		// 入力情報＝nullの場合
		if(mastMap.getMap().size() == 0)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][入力情報＝null]");
			
			// 退避キー更新
			this.tmpKey = KEY_CSV_ERR;
			// 処理グループ番号エラーフラグ更新
			this.tranGrpNoErrFrg = FLG_ON;
			// 業務パラメータ更新
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_H001;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tmpKey=" + this.tmpKey + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tranGrpNoErrFrg=" + this.tranGrpNoErrFrg + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tmpWkPara=" + this.tmpWkPara + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][chkInDataBreakKey]");
			return;
		}
		// キー
		this.tmpKey = mastMap.getString(JBSbatCHIFM110.TRN_GRP_NO);
		
		// 単項目チェック
		
		// 処理グループ番号≠４桁の場合
		if(this.tmpKey.length() != 4)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][処理グループ番号の桁数≠４]");
			
			// 処理グループ番号エラーフラグ更新
			this.tranGrpNoErrFrg = FLG_ON;
			// 業務パラメータ更新
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E001;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tmpKey=" + this.tmpKey + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tranGrpNoErrFrg=" + this.tranGrpNoErrFrg + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tmpWkPara=" + this.tmpWkPara + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][chkInDataBreakKey]");
			return;
		}
		// 処理グループ番号≠半角数字１の場合
		if(!JBSbatCheckUtil.invoke(this.tmpKey, new String[]{"hannkakuesuuji1"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][処理グループ番号≠半角数字１]");
			// 処理グループ番号エラーフラグ更新
			this.tranGrpNoErrFrg = FLG_ON;
			// 業務パラメータ更新
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E001;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tmpKey=" + this.tmpKey + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tranGrpNoErrFrg=" + this.tranGrpNoErrFrg + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tmpWkPara=" + this.tmpWkPara + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][chkInDataBreakKey]");
			return;
		}
		
		// 関連項目チェック
		
		// 処理グループ番号が退避．処理グループ番号リストに存在している場合
		if(!this.tmpKey.equals(this.tmpPrvKey) && this.tranNoGroupList.contains(this.tmpKey))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][処理グループ番号が退避．処理グループ番号リストに存在]");
			// 処理グループ番号エラーフラグ更新
			this.tranGrpNoErrFrg = FLG_ON;
			// 業務パラメータ更新
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E028;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tmpKey=" + this.tmpKey + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tranGrpNoErrFrg=" + this.tranGrpNoErrFrg + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tmpWkPara=" + this.tmpWkPara + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][chkInDataBreakKey]");
			return;
		}
		
		// 退避．処理グループ番号リストに値が存在し、かつ、退避．処理グループ番号リストの値の最大値＞入力．処理グループ番号の場合
		if(this.tranNoGroupList.size() > 0 && this.tmpKey.compareTo(this.tranNoGroupList.get(this.tranNoGroupList.size() - 1)) < 0)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][退避．処理グループ番号リストの値の最大値＞入力．処理グループ番号]");
			// 処理グループ番号エラーフラグ更新
			this.tranGrpNoErrFrg = FLG_ON;
			// 業務パラメータ更新
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E028;
			
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tmpKey=" + this.tmpKey + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tranGrpNoErrFrg=" + this.tranGrpNoErrFrg + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tmpWkPara=" + this.tmpWkPara + "]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][chkInDataBreakKey]");
			return;
		}
		
		// 処理グループ初回レコードフラグ＝"1"の場合
		if(FLG_ON.equals(this.tranGrpFstFlg))
		{
			// 処理グループ番号更新
			this.tranGroupNo = mastMap.getString(JBSbatCHIFM110.TRN_GRP_NO);
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tranGroupNo=" + this.tranGroupNo + "]");
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tmpKey=" + this.tmpKey + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tranGrpNoErrFrg=" + this.tranGrpNoErrFrg + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][chkInDataBreakKey][tmpWkPara=" + this.tmpWkPara + "]");
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][chkInDataBreakKey]");
		return;
	}
	
	/**
	 * 入力データチェックを行います。
	 * 
	 * @param mastMap 入力電文
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void chkInData(JBSbatServiceInterfaceMap mastMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][chkInData]");
		
		// 単項目チェック、関連項目チェックがともに正常の場合
		if(this.isSingleCheckCHIFM110_INF1(mastMap) && this.isKnrnKmkChk(mastMap))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][chkInData]");
			return;
		}
		// 処理グループ番号エラーフラグ更新
		this.tranGrpNoErrFrg = FLG_ON;
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][chkInData]");
		return;
	}
	
	/**
	 *入力情報（料金一括調整指示ファイル）の単項目チェックを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.単項目チェックを行います。<br>
	 * 
	 * 2.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		rsMap:(項目、値)を(key、value)として、データをrsMapに入れます
	 *		itemvalueMap:埋め込み文字の値をitemvalueMapに入れます。キーの値は、以下に説明します。
	 *			 TXT-CHIFM110-INF1.TRN_SEQ			料金一括調整指示ファイル.処理通番
	 *			 TXT-CHIFM110-INF1.TRN_SEQ			料金一括調整指示ファイル.処理通番
	 *			 TXT-CHIFM110-INF1.ADJ_DIV			料金一括調整指示ファイル.調整区分
	 *			 TXT-CHIFM110-INF1.ADJ_DIV			料金一括調整指示ファイル.調整区分
	 *			 TXT-CHIFM110-INF1.SEIKY_YM			料金一括調整指示ファイル.請求年月
	 *			 TXT-CHIFM110-INF1.SEIKY_YM			料金一括調整指示ファイル.請求年月
	 *			 TXT-CHIFM110-INF1.SEIKY_KEI_NO			料金一括調整指示ファイル.請求契約番号
	 *			 TXT-CHIFM110-INF1.SEIKY_KEI_NO			料金一括調整指示ファイル.請求契約番号
	 *			 TXT-CHIFM110-INF1.SVC_KEI_NO			料金一括調整指示ファイル.サービス契約番号
	 *			 TXT-CHIFM110-INF1.SVC_KEI_NO			料金一括調整指示ファイル.サービス契約番号
	 *			 TXT-CHIFM110-INF1.MANS_ID			料金一括調整指示ファイル.マンションID
	 *			 TXT-CHIFM110-INF1.MANS_ID			料金一括調整指示ファイル.マンションID
	 *			 TXT-CHIFM110-INF1.RM_NO			料金一括調整指示ファイル.部屋番号
	 *			 TXT-CHIFM110-INF1.RM_NO			料金一括調整指示ファイル.部屋番号
	 *			 TXT-CHIFM110-INF1.STA_DAY			料金一括調整指示ファイル.開始日
	 *			 TXT-CHIFM110-INF1.STA_DAY			料金一括調整指示ファイル.開始日
	 *			 TXT-CHIFM110-INF1.END_DAY			料金一括調整指示ファイル.終了日
	 *			 TXT-CHIFM110-INF1.END_DAY			料金一括調整指示ファイル.終了日
	 *			 TXT-CHIFM110-INF1.PCRS_CD			料金一括調整指示ファイル.料金コースコード
	 *			 TXT-CHIFM110-INF1.PCRS_CD			料金一括調整指示ファイル.料金コースコード
	 *			 TXT-CHIFM110-INF1.PRC_SVC_CD			料金一括調整指示ファイル.料金サービスコード
	 *			 TXT-CHIFM110-INF1.PRC_SVC_CD			料金一括調整指示ファイル.料金サービスコード
	 *			 TXT-CHIFM110-INF1.PRC_KMK_CD			料金一括調整指示ファイル.料金項目コード
	 *			 TXT-CHIFM110-INF1.PRC_KMK_CD			料金一括調整指示ファイル.料金項目コード
	 *			 TXT-CHIFM110-INF1.ADJ_AF_AMNT			料金一括調整指示ファイル.調整後金額
	 *			 TXT-CHIFM110-INF1.ADJ_AF_AMNT			料金一括調整指示ファイル.調整後金額
	 *			 TXT-CHIFM110-INF1.COMPENSATION_FLG			料金一括調整指示ファイル.補償費扱いフラグ
	 *			 TXT-CHIFM110-INF1.COMPENSATION_FLG			料金一括調整指示ファイル.補償費扱いフラグ
	 *			 TXT-CHIFM110-INF1.COMPENSATION_FLG			料金一括調整指示ファイル.補償費扱いフラグ
	 *			 TXT-CHIFM110-INF1.CUST_TOAK_DSP_FLG			料金一括調整指示ファイル.顧客対応履歴表示フラグ
	 *			 TXT-CHIFM110-INF1.CUST_TOAK_DSP_FLG			料金一括調整指示ファイル.顧客対応履歴表示フラグ
	 *			 TXT-CHIFM110-INF1.CUST_TOAK_DSP_FLG			料金一括調整指示ファイル.顧客対応履歴表示フラグ
	 *			 TXT-CHIFM110-INF1.KIJI			料金一括調整指示ファイル.記事
	 *			 TXT-CHIFM110-INF1.KIJI			料金一括調整指示ファイル.記事
	 *			 TXT-CHIFM110-INF1.KIJI			料金一括調整指示ファイル.記事
	 * </pre>
	 * <p>
	 * @param rsMap 入力データ（TXT又はDB）を格納されたHashMap。
	 * @return  boolean trueである場合、エラーがありません。falseである場合、エラーを発生しました。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private boolean isSingleCheckCHIFM110_INF1(JBSbatServiceInterfaceMap rsMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isSingleCheckCHIFM110_INF1]");
		
		// 単項目チェックを行います
		String strValue = null;

		// 処理通番チェック
		strValue = (String)rsMap.get("TRN_SEQ");
		// 桁数チェック
		// 処理通番の桁数≠4の場合
		if(strValue.length() != 4)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][処理通番の桁数≠4]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E002;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 属性チェック
		// 処理通番の属性≠半角数字１の場合
		if(!JBSbatCheckUtil.invoke(strValue, new String[]{"hannkakusuuji1"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][処理通番の属性≠半角数字１]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E002;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}

		// 調整区分チェック
		strValue = (String)rsMap.get("ADJ_DIV");
		// 桁数チェック
		// 調整区分の桁数≠1の場合
		if(strValue.length() != 1)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][調整区分の桁数≠1]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E003;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 属性チェック
		// 調整区分の属性≠半角英数字１の場合
		if(!JBSbatCheckUtil.invoke(strValue, new String[]{"hannkakuesuuji1"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][調整区分の属性≠半角英数字１]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E003;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}

		// 請求年月チェック
		strValue = (String)rsMap.get("SEIKY_YM");
		// 桁数チェック
		// 請求年月の桁数≠6の場合
		if(strValue.length() != 6)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][請求年月の桁数≠6]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E004;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 属性チェック
		// 請求年月の属性≠年月１の場合
		if(!JBSbatCheckUtil.invoke(strValue, new String[]{"year_month1"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][請求年月の属性≠年月１]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E004;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}

		// 請求契約番号項目チェック
		strValue = (String)rsMap.get("SEIKY_KEI_NO");
		// 桁数チェック
		// 請求契約番号の桁数≠10の場合
		if(strValue.length() != 10)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][請求契約番号の桁数≠10]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E005;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 属性チェック
		// 請求契約番号の属性≠半角英数字１の場合
		if(!JBSbatCheckUtil.invoke(strValue, new String[]{"hannkakuesuuji1"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][請求契約番号の属性≠半角英数字１]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E005;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}

		// サービス契約番号項目チェック
		strValue = (String)rsMap.get("SVC_KEI_NO");
		// 桁数チェック
		// サービス契約番号≠空文字　かつ　サービス契約番号の桁数≠10の場合
		if(!strValue.equals(JACStrConst.KARA_MOJI) && strValue.length() != 10)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][サービス契約番号≠空文字　かつ　サービス契約番号の桁数≠10]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E008;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 属性チェック
		// サービス契約番号≠空文字　かつ　サービス契約番号の属性≠半角英数字１の場合
		if(!strValue.equals(JACStrConst.KARA_MOJI) && !JBSbatCheckUtil.invoke(strValue, new String[]{"hannkakuesuuji1"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][サービス契約番号≠空文字　かつ　サービス契約番号の属性≠半角英数字１]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E008;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}

		// マンションID項目チェック
		strValue = (String)rsMap.get("MANS_ID");
		// 桁数チェック
		// マンションID≠空文字　かつ　マンションIDの桁数≠10の場合
		if(!strValue.equals(JACStrConst.KARA_MOJI) && strValue.length() != 10)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][マンションID≠空文字　かつ　マンションIDの桁数≠10]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E010;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 属性チェック
		// マンションID≠空文字　かつ　マンションIDの属性≠半角英数字１の場合
		if(!strValue.equals(JACStrConst.KARA_MOJI) && !JBSbatCheckUtil.invoke(strValue, new String[]{"hannkakuesuuji1"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][マンションID≠空文字　かつ　マンションIDの属性≠半角英数字１]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E010;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}

		// 部屋番号項目チェック
		strValue = (String)rsMap.get("RM_NO");
		// 桁数チェック
		// 部屋番号≠空文字　かつ　部屋番号の桁数＞5の場合
		if(!strValue.equals(JACStrConst.KARA_MOJI) && strValue.length() > 5)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][部屋番号≠空文字　かつ　部屋番号の桁数＞5]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E012;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 属性チェック
		// 部屋番号≠空文字　かつ　部屋番号の属性≠半角英数字８の場合
		if(!strValue.equals(JACStrConst.KARA_MOJI) && !JBSbatCheckUtil.invoke(strValue, new String[]{"hannkakuesuuji8"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][部屋番号≠空文字　かつ　部屋番号の属性≠半角英数字８]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E012;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}

		// 開始日項目チェック
		strValue = (String)rsMap.get("STA_DAY");
		// 桁数チェック
		// 開始日≠空文字　かつ　開始日の桁数≠8の場合
		if(!strValue.equals(JACStrConst.KARA_MOJI) && strValue.length() != 8)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][開始日≠空文字　かつ　開始日の桁数≠8]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E013;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 属性チェック
		// 開始日≠空文字　かつ　開始日の属性≠年月日１の場合
		if(!strValue.equals(JACStrConst.KARA_MOJI) && !JBSbatCheckUtil.invoke(strValue, new String[]{"year_month_day1"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][開始日≠空文字　かつ　開始日の属性≠年月日１]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E013;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}

		// 終了日項目チェック
		strValue = (String)rsMap.get("END_DAY");
		// 桁数チェック
		// 終了日≠空文字　かつ　終了日の桁数≠8の場合
		if(!strValue.equals(JACStrConst.KARA_MOJI) && strValue.length() != 8)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][終了日≠空文字　かつ　終了日の桁数≠8]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E014;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 属性チェック
		// 終了日≠空文字　かつ　終了日の属性≠年月日１の場合
		if(!strValue.equals(JACStrConst.KARA_MOJI) && !JBSbatCheckUtil.invoke(strValue, new String[]{"year_month_day1"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][終了日≠空文字　かつ　終了日の属性≠年月日１]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E014;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}

		// 料金コースコード項目チェック
		strValue = (String)rsMap.get("PCRS_CD");
		// 桁数チェック
		// 料金コースコードの桁数≠3の場合
		if(strValue.length() != 3)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][料金コースコードの桁数≠3]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E016;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 属性チェック
		// 料金コースコードの属性≠半角英数字３の場合
		if(!JBSbatCheckUtil.invoke(strValue, new String[]{"hannkakuesuuji3"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][料金コースコードの属性≠半角英数字３]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E016;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}

		// 料金サービスコード項目チェック
		strValue = (String)rsMap.get("PRC_SVC_CD");
		// 桁数チェック
		// 料金サービスコードの桁数≠6　かつ　≠12場合
		if(strValue.length() != 6 && strValue.length() != 12)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][料金サービスコードの桁数≠6　かつ　≠12]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E018;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 属性チェック
		// 料金サービスコードの属性≠半角英数字３の場合
		if(!JBSbatCheckUtil.invoke(strValue, new String[]{"hannkakuesuuji3"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][料金サービスコードの属性≠半角英数字３]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E018;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}

		// 料金項目コード項目チェック
		strValue = (String)rsMap.get("PRC_KMK_CD");
		// 桁数チェック
		// 料金項目コードの桁数≠11の場合
		if(strValue.length() != 11)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][料金項目コードの桁数≠11]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E020;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 属性チェック
		// 料金項目コードの属性≠半角英数字１の場合
		if(!JBSbatCheckUtil.invoke(strValue, new String[]{"hannkakuesuuji1"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][料金項目コードの属性≠半角英数字１]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E020;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}

		// 調整後金額項目チェック
		strValue = rsMap.get("ADJ_AF_AMNT").toString();
		// 属性チェック
		// TODO 半角数字１のチェックでは「-（マイナス）」を許容しないため保留
		/*
		// 調整後金額の属性≠半角数字１の場合
		if(!JBSbatCheckUtil.invoke(strValue, new String[]{"hannkakusuuji1"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][調整後金額の属性≠半角数字１]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E022;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		*/
		// 調整後金額≠""（空文字）　かつ　調整後金額の桁数＞11の場合
		if(!JACStrConst.KARA_MOJI.equals(strValue) && strValue.length() > 11)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][調整後金額≠空文字　かつ　調整後金額の桁数＞11]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E022;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		
		// 処理通番
		String inTrnSeq = rsMap.getString(JBSbatCHIFM110.TRN_SEQ);
		
		// 補償費扱いフラグ項目チェック
		strValue = (String)rsMap.get("COMPENSATION_FLG");
		// 処理通番＝"0001"　かつ　補償費扱いフラグの桁数≠1の場合
		if(TRAN_SEQ_0001.equals(inTrnSeq) && strValue.length() != 1)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][処理通番＝0001　かつ　補償費扱いフラグの桁数≠1]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E023;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 処理通番＝"0001"　かつ　補償費扱いフラグの属性≠半角英数字１の場合
		if(TRAN_SEQ_0001.equals(inTrnSeq) && !JBSbatCheckUtil.invoke(strValue, new String[]{"hannkakuesuuji1"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][処理通番＝0001　かつ　補償費扱いフラグの属性≠半角英数字１]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E023;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 処理通番≠"0001"　かつ　補償費扱いフラグ≠""（空文字）の場合
		if(!TRAN_SEQ_0001.equals(inTrnSeq) && !JACStrConst.KARA_MOJI.equals(strValue))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][処理通番≠0001　かつ　補償費扱いフラグ≠（空文字）]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E031;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}

		// 顧客対応履歴表示フラグ項目チェック
		strValue = (String)rsMap.get("CUST_TOAK_DSP_FLG");
		// 処理通番＝"0001"　かつ　 顧客対応履歴表示フラグの桁数≠1の場合
		if(TRAN_SEQ_0001.equals(inTrnSeq) && strValue.length() != 1)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][処理通番＝0001　かつ　 顧客対応履歴表示フラグの桁数≠1]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E024;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 処理通番＝"0001"　かつ　 顧客対応履歴表示フラグの属性≠半角英数字１の場合
		if(TRAN_SEQ_0001.equals(inTrnSeq) && !JBSbatCheckUtil.invoke(strValue, new String[]{"hannkakuesuuji1"}))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][処理通番＝0001　かつ　 顧客対応履歴表示フラグの属性≠半角英数字１]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E024;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 処理通番≠"0001"　かつ　 顧客対応履歴表示フラグ≠""（空文字）の場合
		if(!TRAN_SEQ_0001.equals(inTrnSeq) && !JACStrConst.KARA_MOJI.equals(strValue))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][処理通番≠0001　かつ　 顧客対応履歴表示フラグ≠（空文字）]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E032;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		
		// 記事項目チェック
		strValue = (String)rsMap.get("KIJI");
		// 処理通番＝"0001"　かつ　 記事＝""（空文字）の場合
		if(TRAN_SEQ_0001.equals(inTrnSeq) && JACStrConst.KARA_MOJI.equals(strValue))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][処理通番＝0001　かつ　 記事＝（空文字）の場合]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E025;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 処理通番＝"0001"　かつ　 記事のバイト数≧200の場合
		if(TRAN_SEQ_0001.equals(inTrnSeq) && JACbatRknBusinessUtil.getBytes(strValue, this.encode) > 200)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][処理通番＝0001　かつ　 記事のバイト数＞200]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E026;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		// 処理通番≠"0001"　かつ　 記事≠""（空文字）の場合
		if(!TRAN_SEQ_0001.equals(inTrnSeq) && !JACStrConst.KARA_MOJI.equals(strValue))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSingleCheckCHIFM110_INF1][処理通番≠0001　かつ　 記事≠（空文字）]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E033;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isSingleCheckCHIFM110_INF1]");
			return false;
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isSingleCheckCHIFM110_INF1]");
		return true;
	}
	

	/**
	 * 入力情報の関連項目チェックを行います。
	 * 
	 * @param mastMap 入力情報
	 * @return boolean チェック結果（true：正常、false：異常あり）
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	@SuppressWarnings("unchecked")
	private boolean isKnrnKmkChk(JBSbatServiceInterfaceMap mastMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isKnrnKmkChk]");
		assert this.tranGrpFstFlg != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isKnrnKmkChk][tranGrpFstFlg=" + this.tranGrpFstFlg + "]") : true;
		assert this.tmpSikyKeiNo != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isKnrnKmkChk][tmpSikyKeiNo=" + this.tmpSikyKeiNo + "]") : true;
		assert this.tmpSikyNo != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isKnrnKmkChk][tmpSikyNo=" + this.tmpSikyNo + "]") : true;
		
		// 処理通番
		String inTranSeq = mastMap.getString(JBSbatCHIFM110.TRN_SEQ);
		
		// 処理通番チェック
		
		// 退避．処理グループ初回レコードフラグ＝"1"　かつ　入力．処理通番≠"0001"の場合
		if(FLG_ON.equals(this.tranGrpFstFlg) && !TRAN_SEQ_0001.equals(inTranSeq))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][退避．処理グループ初回レコードフラグ＝1　かつ　入力．処理通番≠0001]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E028;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
			return false;
		}
//IT1-2014-0000175 MOD STA 安井
//		// 退避．処理通番＞入力．処理通番の場合
//		if(this.tranSeq.compareTo(inTranSeq) > 0)
		// 退避．処理通番＞＝入力．処理通番の場合
		if(this.tranSeq.compareTo(inTranSeq) >= 0)
//IT1-2014-0000175 MOD END 安井
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][退避．処理通番＞入力．処理通番]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E028;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
			return false;
		}
		
		// 処理通番退避
		this.tranSeq = inTranSeq;
		
		// 調整区分
		String adjDiv = mastMap.getString(JBSbatCHIFM110.ADJ_DIV);
		
		// 調整区分チェック
		
		// 	調整区分≠"1"（追加）かつ≠"2"（変更）≠"3"（削除）
		if(!JACStrConst.ADJ_DIV_ADD.equals(adjDiv) && !JACStrConst.ADJ_DIV_ADJ.equals(adjDiv) && !JACStrConst.ADJ_DIV_DEL.equals(adjDiv))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][調整区分≠1（追加）かつ≠2（変更）≠3（削除）]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E003;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
			return false;
		}
		
		// 補償費扱いフラグ
		String inCompensationFlg = mastMap.getString(JBSbatCHIFM110.COMPENSATION_FLG);
		
		// 補償費扱いフラグチェック
		
		// 処理通番＝"0001"　かつ　補償費扱いフラグ≠"0"（補償費扱い有り）かつ≠"1"（補償費扱いなし）
		if(TRAN_SEQ_0001.equals(inTranSeq) && !JACStrConst.COMPENSATION_FLG_ARI.equals(inCompensationFlg) && !JACStrConst.COMPENSATION_FLG_NON.equals(inCompensationFlg))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][処理通番＝0001　かつ　補償費扱いフラグ≠0（補償費扱い有り）かつ≠1（補償費扱いなし）]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E023;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
			return false;
		}
		
		// 顧客対応履歴表示フラグ
		String inCustDispFlg = mastMap.getString(JBSbatCHIFM110.CUST_TOAK_DSP_FLG);
		
		// 顧客対応履歴表示フラグチェック
		
		// 処理通番＝"0001"　かつ　顧客対応履歴表示フラグ≠"0"（対応履歴へ表示しない）かつ≠"1"（対応履歴へ表示する）
		if(TRAN_SEQ_0001.equals(inTranSeq) && !JACStrConst.CUST_TOAK_DSP_FLG_DISP_ON.equals(inCustDispFlg) && !JACStrConst.CUST_TOAK_DSP_FLG_DISP_OFF.equals(inCustDispFlg))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][処理通番＝0001　かつ　補償費扱いフラグ≠0（対応履歴へ表示しない）かつ≠1（対応履歴へ表示する）]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E024;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
			return false;
		}
		
		// 記事チェック
		
		// TODO 文字コードチェック用の共通部品が未作成のため保留
		/*
		// 記事
		String inKiji = mastMap.getString(JBSbatCHIFM110.KIJI);
		

		// 共通部品．文字コードチェックで文字コード「MS932(SJIS)」以外の文字が含まれている場合
		if()
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][共通部品．文字コードチェックで文字コード「MS932(SJIS)」以外の文字が含まれている場合]");
			
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E027;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
			return false;
		}
		*/
		
		// 請求年月
		String inSikyYm = mastMap.getString(JBSbatCHIFM110.SEIKY_YM);
		
		// 請求年月チェック
		
		// 入力．請求年月≠退避．請求年月の場合
		if(!inSikyYm.equals(this.tmpSikyYm))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][入力．請求年月≠退避．請求年月]");
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E004;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
			return false;
		}
		
		// 請求契約番号
		String inSikyKeiNo = mastMap.getString(JBSbatCHIFM110.SEIKY_KEI_NO);
		
		// 請求契約番号チェック
		
		// 請求契約番号が請求契約スキーマに未存在の場合
		if(!this.isSikyKeiNo(mastMap))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][請求契約番号が請求契約スキーマに未存在]");
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E006;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
			return false;
		}
		// 退避．前回キー＝キー　または　退避．請求契約番号≠nullの場合
		if(this.tmpPrvKey.equals(this.tmpKey) || null != this.tmpSikyKeiNo)
		{
			// 退避．請求契約番号＝nullの場合
			if(this.tmpSikyKeiNo == null)
			{
				// 退避．請求契約番号更新
				this.tmpSikyKeiNo = inSikyKeiNo;
				
				assert this.tmpSikyKeiNo != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][tmpSikyKeiNo=" + this.tmpSikyKeiNo + "]") : true;
			}
			
			// 退避．請求契約番号≠入力．請求契約番号の場合
			if(!inSikyKeiNo.equals(this.tmpSikyKeiNo))
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][退避．請求契約番号≠入力．請求契約番号]");
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E030;
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
				return false;
			}
			
		}
		
		// 退避．請求契約番号リストに入力．請求契約番号が存在する場合
		if(this.sikyKeiNoList.contains(inSikyKeiNo))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][退避．請求契約番号リストに入力．請求契約番号が存在する]");
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E029;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
			return false;
		}
		
		// 請求契約番号・請求年月チェック
		
		// 請求年月・請求契約番号を基に請求スキーマを検索します。
		this.selectSeiky(mastMap);
		// 結果を取得
		JBSbatCommonDBInterface selectMap = db_CH_T_SEIKY.selectNext();
		
		// 取得できなかった場合
		if(null == selectMap)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][請求契約番号、請求年月で請求スキーマからデータを取得なし]");
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E007;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
			return false;
		}
		// 請求ステータスが"000"（仮計算中）か 請求ステータス"010"（仮確定）でない場合
		else if(!JACStrConst.SEIKY_STAT_KR_CALC.equals(selectMap.getString(JBSbatCH_T_SEIKY.SEIKY_STAT)) &&
					!JACStrConst.SEIKY_STAT_KR_FIX.equals(selectMap.getString(JBSbatCH_T_SEIKY.SEIKY_STAT)))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][請求契約番号、請求年月で請求スキーマから取得したデータ．請求ステータス≠000（仮計算中）かつ≠010（仮確定）]");
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E007;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
			return false;
		}
		// 上記以外の場合
		else
		{
			// 退避．請求番号更新
			this.tmpSikyNo = selectMap.getString(JBSbatCH_T_SEIKY.SEIKY_NO);
			assert this.tmpSikyNo != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][tmpSikyNo=" + this.tmpSikyNo + "]") : true;
		}
		
		// サービス契約番号
		String workSvcKeiNo = mastMap.getString(JBSbatCHIFM110.SVC_KEI_NO);
		// マンションID
		String mansId = mastMap.getString(JBSbatCHIFM110.MANS_ID);
		// 部屋番号
		String rmNo = mastMap.getString(JBSbatCHIFM110.RM_NO).trim();
		// 未入居フラグ初期化
		miNyukyoFlg = false;

		// サービス契約番号≠空、かつマンションID＝空の場合
		if(!JACStrConst.KARA_MOJI.equals(workSvcKeiNo) && JACStrConst.KARA_MOJI.equals(mansId))
		{
			// 部屋番号≠空の場合
			if(!JACStrConst.KARA_MOJI.equals(rmNo) && rmNo != null)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, 
				"[L][isKnrnKmkChk][入力．部屋番号≠マンションＩＤとサービス契約番号で取得したサービス契約回線内訳．部屋番号]");
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E012;
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
				return false;
			}
			
			// 請求契約番号、サービス契約番号がサービス契約スキーマに未存在の場合
			if(!isSvcKei(mastMap))
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][請求契約番号、サービス契約番号がサービス契約スキーマに未存在]");
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E009;
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
				return false;
			}
		}
		// サービス契約番号≠空、かつマンションID≠空
		else if(!JACStrConst.KARA_MOJI.equals(workSvcKeiNo) && !JACStrConst.KARA_MOJI.equals(mansId))
		{
			// 部屋番号＝空の場合
			if(JACStrConst.KARA_MOJI.equals(rmNo) || rmNo == null)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, 
				"[L][isKnrnKmkChk][入力．部屋番号≠マンションＩＤとサービス契約番号で取得したサービス契約回線内訳．部屋番号]");
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E012;
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
				return false;
			}

			// マンションＩＤから部屋番号を取得
			String roomNo = getRoomNo(mastMap);
			tmpSeiriNo = mansId;
			
			// 部屋番号が取得できなかった場合
			if(JACStrConst.KARA_MOJI.equals(roomNo))
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][マンションIDから部屋番号取得不可]");
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E010;
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
				return false;
			}

			// 入力．部屋番号と一致しなかった場合
			if(!roomNo.equals(rmNo))
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, 
						"[L][isKnrnKmkChk][入力．部屋番号≠マンションＩＤとサービス契約番号で取得したサービス契約回線内訳．部屋番号]");
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E012;
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
				return false;
			}
		}
		// マンションID≠空文字
		else if(!JACStrConst.KARA_MOJI.equals(mansId))
		{
			// 部屋番号＝空の場合
			if(JACStrConst.KARA_MOJI.equals(rmNo))
			{
				if(!bkMansIdMap.containsKey(mansId))
				{
					// サービス契約番号（ダミー）を取得
					getSvcKeiNoDummy(mastMap);
					
					// サービス契約番号（ダミー）が取得できなかった場合
					if(JACStrConst.KARA_MOJI.equals(bkMansIdMap.get(mansId)) || bkMansIdMap.get(mansId) == null)
					{
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][マンションオーナーのサービス契約取得不可]");
						this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E010;
						
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
						return false;
					}
				}
				else
				{
					tmpSvcKeiNo = bkMansIdMap.get(mansId);
					tmpSeiriNo = mansId;
				}
			}
			// 部屋番号≠空の場合
			else
			{
				// 未入居の場合
				if(rmNo.equals(this.minyukyoRoomNo))
				{
					// 未入居フラグ ← true
					this.miNyukyoFlg = true;
					
					this.tmpSeiriNo = mansId;
				}
				else
				{
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][マンションID≠空 かつ 部屋番号≠オーナーまたは未入居]");
					this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E012;
					
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
					return false;
				}
			}
		}
		
		// マンションID＝空かつ部屋番号≠空の場合
		else if(JACStrConst.KARA_MOJI.equals(mansId) && !JACStrConst.KARA_MOJI.equals(rmNo))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][マンションID＝空 かつ 部屋番号≠空]");
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E012;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
			return false;
		}

		// 料金コースコード
		String inPcrsCd = mastMap.getString(JBSbatCHIFM110.PCRS_CD);
		
		// 料金コースコード≠ALL空白（3桁）　かつ　料金コースコードが料金コースリストに存在しない場合
		if(!inPcrsCd.equals(JACStrConst.PCRS_CD_SP) && !this.pcrsCdList.containsKey(inPcrsCd))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][料金コースコード≠ALL空白（3桁）　かつ　料金コースコードが料金コースリストに存在しない]");
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E017;
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
			return false;
		}
		
		String inPrcSvcCd = mastMap.getString(JBSbatCHIFM110.PRC_SVC_CD);			// 料金サービスコード
		
		// 料金サービスコード≠ALL空白12桁 かつ 料金コースコード≠ALL空白3桁の場合
		if(!inPrcSvcCd.equals(JACStrConst.PRC_SVC_CD_SP) && !inPcrsCd.equals(JACStrConst.PCRS_CD_SP))
		{
			StringBuffer buf = new StringBuffer();
			
			// 料金コースコード
			buf.append(inPcrsCd);
			// 料金サービスコード
			buf.append(inPrcSvcCd);
			
			// 料金コースコード＋料金サービスコードが退避．料金サービスコードリストに未存在の場合
			if((!this.prcSvcCdList.contains(buf.toString())))
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][料金サービスコード≠ALL空白（12桁）　かつ　料金サービスコードが料金サービスコードリストに存在しない]");
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E019;
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
				return false;
			}
		}
		
		
		// 料金項目コード
		String inPrcKmkCd = mastMap.getString(JBSbatCHIFM110.PRC_KMK_CD);

//IT1-2014-0000174 DEL STA 安井
//		// 料金項目コードが料金項目リストに存在しない場合
//		if(!this.prcKmkCdList.contains(inPrcKmkCd))
//		{
//			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][料金項目コードが料金項目リストに存在しない]");
//			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E021;
//			
//			
//			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
//			return false;
//		}
//IT1-2014-0000174 DEL END 安井
		
		
		StringBuffer buf = new StringBuffer();
		// 料金コースコード
		buf.append(mastMap.getString(JBSbatCHIFM110.PCRS_CD));
		// 料金サービスコード
		buf.append(mastMap.getString(JBSbatCHIFM110.PRC_SVC_CD));
		// 料金項目コード
		buf.append(inPrcKmkCd);

		// 料金コースコード+料金サービスコード+料金項目コードが料金調整可能料金項目コードリストに存在しない場合
		if(!this.prcAdjOkPrcKmkList.contains(buf.toString()))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][料金項目コードが料金調整可能料金項目コードリストに存在しない]");
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E038;
			
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
			return false;
		}
		
		String strValue = mastMap.getString(JBSbatCHIFM110.SVC_DTL_SKBT_NO).trim();
		
		// 必須料金項目に存在する場合
		if (this.reDtPrcMap.contains(inPrcKmkCd))
		{
			// 必須料金項目に存在する
			// かつ、サービス詳細識別番号が入力されている
			if(strValue != null && JACStrConst.KARA_MOJI.equals(strValue) == false)
			{
				if(strValue.length() > 30)
				{
					// サービス詳細識別番号が３０桁を越えている
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][料金項目コードが必須料金項目に存在する　かつ　サービス詳細識別番号が３０桁を超えている]");
					this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E052;
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
					return false;
				}
//ANK-4068-00-00 MOD START
//				if(!JBSbatCheckUtil.invoke(strValue, new String[]{"tel2"}) || strValue.length() != 11)
//				{
//					// サービス詳細識別番号の形式がtel2でない、または１１桁でない
//					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][料金項目コードが必須料金項目に存在する　かつ　サービス詳細識別番号の形式がｔｅｌ２でない、または桁数が１１桁でない]");
//					this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E053;
//					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
//					return false;
//				}
				if(!JBSbatCheckUtil.invoke(strValue, new String[]{"tel1"}) || (strValue.length() != 11 && strValue.length() != 14))
				{
					// サービス詳細識別番号の形式がtel1でない、または「１１桁、１４桁」でない
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][料金項目コードが必須料金項目に存在する　かつ　サービス詳細識別番号の形式がｔｅｌ１でない、または桁数が１１桁・１４桁でない]");
					this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E053;
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
					return false;
				}
				// 形式チェック
				// １１桁の場合
				if(strValue.length() == 11)
				{
					// 以下の条件のいずれかに該当する場合エラー
					// ・2桁目が0
					// ・3桁目が0でない
					if("0".equals(strValue.substring(1, 2)) || !("0".equals(strValue.substring(2, 3))))
					{
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][識別番号に指定された携帯番号・電話番号の形式が誤っています。]");
						this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E053;
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
						return false;
					}
				}
				// １４桁の場合
				else if(strValue.length() == 14)
				{
					// 以下の条件に該当する場合エラー
					// ・「2桁目が2、かつ3桁目が0」でない
					if(!("2".equals(strValue.substring(1, 2)) && "0".equals(strValue.substring(2, 3))))
					{
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][識別番号に指定された携帯番号・電話番号の形式が誤っています。]");
						this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E053;
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
						return false;
					}
				}
//ANK-4068-00-00 MOD END
			}
			else 
			{
				// サービス詳細識別番号が入力されていない
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][料金項目コードが必須料金項目に存在する　かつ　サービス詳細識別番号が入力されていない]");
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E050;
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
				return false;
			}
		}
		
		// タブレット端末系料金の場合
		else if(this.reDtTtPrcMap.contains(inPrcKmkCd))
		{
			
			String svcKeiNo		= mastMap.getString(JBSbatCHIFM110.SVC_KEI_NO);
			String kikiSeizoNo	= mastMap.getString(JBSbatCHIFM110.SVC_DTL_SKBT_NO);
			
			// サービス詳細識別番号のチェック
			if(JACStrConst.KARA_MOJI.equals(kikiSeizoNo))
			{
				// サービス詳細識別番号が未設定の場合
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][料金項目コードがタブレット端末系料金に存在する　かつ　サービス詳細識別番号が未設定]");
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E050;
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
				return false;
			}
			if(kikiSeizoNo.length() > 30)
			{
				// サービス詳細識別番号が３０桁を越えている
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][料金項目コードがタブレット端末系料金に存在する　かつ　サービス詳細識別番号が３０桁を超えている]");
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E052;
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
				return false;
			}
			
			// サービス詳細識別番号（機器製造番号）とサービス契約番号から機器提供サービス契約番号を取得する
			String kktkSvcKeiNo = this.selectkktkSvcKeiNo(svcKeiNo, kikiSeizoNo);
			if(JACStrConst.KARA_MOJI.equals(kktkSvcKeiNo))
			{
				// 機器提供サービス契約番号が取得できなかった場合
				// 機器提供サービス契約番号が取得できない
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][料金項目コードがタブレット端末系料金に存在する　かつ　機器提供サービス契約番号が取得できない]");
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E055;
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
				return false;
			}
			else
			{
				// 機器提供サービス契約番号が取得できた場合
				// サービス詳細識別番号を機器提供サービス契約番号で書き換える
				mastMap.setString(JBSbatCHIFM110.SVC_DTL_SKBT_NO, kktkSvcKeiNo);
			}
		}
//v16.00.00 2015/06/08 Add Start
// ANK-3296-00-00 v36.00.00 2018/01/22 Mod Start
		//else if(this.reDtElectPrcMap.contains(inPrcKmkCd)){
		
		//eo電気必須詳細料金項目マップ、または必須詳細料金項目（工事費割賦）マップに料金項目コードが存在する場合サービス詳細識別番号チェックを行う
		else if(this.reDtElectPrcMap.contains(inPrcKmkCd) || this.reDtKjHiKpPrcMap.contains(inPrcKmkCd)){
// ANK-3296-00-00 v36.00.00 2018/01/22 Mod End
			
			//サービス詳細識別番号を取得する
			String svcDtlSkbtNo = mastMap.getString(JBSbatCHIFM110.SVC_DTL_SKBT_NO);
			
			//サービス詳細識別番号が空白の時
			if(JACStrConst.KARA_MOJI.equals(svcDtlSkbtNo))
			{
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E050;
				return false;
			}
				
// ANK-3296-00-00 v36.00.00 2018/01/22 Mod Start
			//サービス詳細識別番号が22桁以外の場合
			//if(svcDtlSkbtNo.length() != 22 || !JBSbatCheckUtil.invoke(svcDtlSkbtNo, new String[]{"hannkakuesuuji1"})){
				
			//eo電気必須詳細料金項目マップに料金項目コードが存在し、サービス詳細識別番号が22桁以外または半角英数字1以外の場合
			if(this.reDtElectPrcMap.contains(inPrcKmkCd) && (svcDtlSkbtNo.length() != 22 || !JBSbatCheckUtil.invoke(svcDtlSkbtNo, new String[]{"hannkakuesuuji1"}))){
// ANK-3296-00-00 v36.00.00 2018/01/22 Mod End
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E059;
				return false;
			}
// ANK-3296-00-00 v36.00.00 2018/01/22 Add Start
			//必須詳細料金項目（工事費割賦）マップに料金項目コードが存在する場合
			if(this.reDtKjHiKpPrcMap.contains(inPrcKmkCd)) {
				
				// サービス詳細識別番号が1桁以外かつ2桁以外の場合
				if(svcDtlSkbtNo.length() != 1 && svcDtlSkbtNo.length() != 2) {
					this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E060;
					return false;
				}
				// サービス詳細識別番号が半角数字1以外の場合
				else if(!JBSbatCheckUtil.invoke(svcDtlSkbtNo, new String[]{"hannkakusuuji1"})) {
					this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E061;
					return false;
				}
				else
				{
					// 入力情報（マスタ）のサービス詳細識別番号をゼロサプレス
					mastMap.set(JBSbatCHIFM110.SVC_DTL_SKBT_NO, String.valueOf(Integer.parseInt(svcDtlSkbtNo)));
				}
			}
// ANK-3296-00-00 v36.00.00 2018/01/22 Add End
		}
//v16.00.00 2015/06/08 Add End
		
		else
		{
			// 必須料金項目に存在しない　かつ　タブレット端末系料金でない
			// かつ、サービス詳細識別番号が入力されている
			if(strValue != null && JACStrConst.KARA_MOJI.equals(strValue) == false)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][料金項目コードが必須料金項目に存在しない　かつ　サービス詳細識別番号が入力されている]");
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E051;
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
				return false;
			}
		}
		
		// 開始日
		String inStaDay = mastMap.getString(JBSbatCHIFM110.STA_DAY);
		// 終了日
		String inEndDay = mastMap.getString(JBSbatCHIFM110.END_DAY);
		
		// キー（料金コースコード＋料金サービスコード＋料金項目コード）
		String inKey = makeKey(mastMap.getMap(), false);
		
		// キーが退避．料金項目出力名称データマップに未存在の場合
		if(!this.prcOputNmMap.containsKey(inKey))
		{
			// ログメッセージ用マップ
			ArrayList<String> msgparam = new ArrayList<String>();
			
			// 料金コースコード
			msgparam.add(inPcrsCd);
			// 料金サービスコード
			msgparam.add(inPrcSvcCd);
			// 料金項目コード
			msgparam.add(inPrcKmkCd);
			
			// ログ出力（【最重要】ＤＢ未存在エラー）
			String[] msgParam = new String[]
			{ JBSbatCH_M_PRC_KMK_OPUT_NM.TABLE_NAME, msgparam.toString() };
			throw new JBSbatBusinessException(JPCBatchMessageConstant.ECHB0270CH, msgParam);
		}
		
		// 利用期間表示制御フラグ（退避．出力名称マップ）
		String usePrdDspCtrlFlg = (String)this.prcOputNmMap.get(inKey).get(JBSbatCH_M_PRC_KMK_OPUT_NM.USE_PRD_DSP_CTRL_FLG);
		
		// 利用期間表示制御フラグ＝"1"（表示）　かつ　（開始日＝""（空文字）または終了日＝""（空文字））の場合
		if(JACStrConst.USE_PRD_DSP_CTRL_FLG_ON.equals(usePrdDspCtrlFlg) && (JACStrConst.KARA_MOJI.equals(inStaDay) || JACStrConst.KARA_MOJI.equals(inEndDay)))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][設定対象料金に対し、開始日、終了日が設定されていない。]");
			this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E015;
			
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
			return false;
		}
		
//		// 利用期間設定判別フラグ更新
//		this.tmpUsePrdStHmbtFlg = usePrdDspCtrlFlg;
		
		//前受金充当金変更可能期間チェック
        // 調整区分チェックで="1"（追加）または="2"（変更）または="3"（削除）のみ対象に絞りこまれている
		buf = new StringBuffer();
		// 料金コースコード
		buf.append(mastMap.getString(JBSbatCHIFM110.PCRS_CD));
		// 料金サービスコード
		buf.append(mastMap.getString(JBSbatCHIFM110.PRC_SVC_CD));
		// 料金項目コード
		buf.append(inPrcKmkCd);
		
		//料金項目コードが前受金の場合、前受金変更可能期間のチェック
		if(this.prcMaeUkKinPrcKmkList.contains(buf.toString()))
		{
			// 請求年月から料金計算日を取得
			String prcCalDay = this.prcCalcDayMap.get(mastMap.getString(JBSbatCHIFM110.SEIKY_YM));
			
			// 請求年月から請求処理日を取得
			String prcSeikyDay = this.prcSeikyDayMap.get(mastMap.getString(JBSbatCHIFM110.SEIKY_YM));
			
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][onlineOpeDate:"+ super.onlineOpeDate +"]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][料金計算日:"+ prcCalDay +"]");
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][請求処理日:"+ prcSeikyDay +"]");
			
			if(prcCalDay.compareTo(super.onlineOpeDate) >= 0)
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][前受金変更不可期間(>=料金計算日)]");
				
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E056;

				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
				return false;
			}
			
			if(prcSeikyDay.compareTo(super.onlineOpeDate) < 0 )
			{
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKnrnKmkChk][前受金変更不可期間(<請求処理日)]");
				
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E056;
				
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
				return false;
			}
		}
		
// OM-2015-0000082 ADD START
		// 請求オプションチェック
		
		// 調整区分が追加または変更
		if(JACStrConst.ADJ_DIV_ADD.equals(adjDiv) || JACStrConst.ADJ_DIV_ADJ.equals(adjDiv))
		{
			// サービス契約番号が設定されており、料金サービスコードが請求オプション料金プランマップに存在する場合、
			if(!JACStrConst.KARA_MOJI.equals(workSvcKeiNo) && this.seiopPplanMap.containsKey(inPrcSvcCd.trim()))
			{
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E058;
				return false;
			}
// IT2-2023-0000015 ADD START
			// サービス契約番号が設定されており、料金項目コードが調整費の場合
			if(!JACStrConst.KARA_MOJI.equals(workSvcKeiNo) && adjHiPrcKmkMap.containsValue(inPrcKmkCd)) 
			{
				this.tmpWkPara = JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E062;
				return false;
			}
// IT2-2023-0000015 ADD END
		}
// OM-2015-0000082 ADD END
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKnrnKmkChk]");
		
		return true;
	}
	
	/**
	 * 請求契約スキーマを入力情報の請求契約番号で検索し、取得の有無のチェックを行います。
	 * 
	 * @param mastMap 入力情報
	 * @return boolean 判定結果（true：あり、false：なし）
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private boolean isSikyKeiNo(JBSbatServiceInterfaceMap mastMap) throws Exception
	{
		
		JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
		
		// 請求年月から料金計算日を取得
		String prcCalDay = this.prcCalcDayMap.get(mastMap.getString(JBSbatCHIFM110.SEIKY_YM));
		
		// 請求契約番号
		whereMap.setValue(mastMap.getString(JBSbatCHIFM110.SEIKY_KEI_NO));
		// 予約適用年月日
		whereMap.setValue(prcCalDay);
		
		// SQL実行
		executeKK_T_SEIKY_KEI_CH_SELECT_004(whereMap.getList().toArray());
		
		// 結果を取得
		JBSbatCommonDBInterface dbMap = db_KK_T_SEIKY_KEI.selectNext();
		
		// 取得なしの場合
		if(dbMap == null)
		{
			return false;
		}
		
		return true;
	}
	
	/**
	 * 請求スキーマを検索します。
	 * 
	 * @param mastMap 入力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void selectSeiky(JBSbatServiceInterfaceMap mastMap) throws Exception
	{
		JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
		
		// 請求契約番号
		whereMap.setValue(mastMap.getString(JBSbatCHIFM110.SEIKY_KEI_NO));
		// 請求年月
		whereMap.setValue(mastMap.getString(JBSbatCHIFM110.SEIKY_YM));
		// 請求種別コード
		whereMap.setValue(JACStrConst.SIKYSHBTS_TEIGK_SEIKY);
		
		// SQL実行
		executeCH_T_SEIKY_CH_SELECT_024(whereMap.getList().toArray());
		
		return;
	}
	
	/**
	 * サービス契約スキーマを入力情報の請求契約番号、サービス契約番号で検索し、取得の有無のチェックを行います。
	 * 
	 * @param mastMap 入力情報
	 * @return boolean 判定結果（true：あり、false：なし）
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private boolean isSvcKei(JBSbatServiceInterfaceMap mastMap) throws Exception
	{
		JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
		
		// 請求年月から料金計算日を取得
		String prcCalDay = this.prcCalcDayMap.get(mastMap.getString(JBSbatCHIFM110.SEIKY_YM));

		// v49.00.00 ADD START
		// 請求契約番号
		whereMap.setValue(mastMap.getString(JBSbatCHIFM112.SEIKY_KEI_NO));
		// 請求年月
		whereMap.setValue(mastMap.getString(JBSbatCHIFM112.SEIKY_YM));
		// サービス契約番号
		whereMap.setValue(mastMap.getString(JBSbatCHIFM112.SVC_KEI_NO));
		// v49.00.00 ADD END
		// 予約適用年月日
		whereMap.setValue(prcCalDay);
		// OM-2019-0000646 DEL START
//		// 課金先適用年月日
//		whereMap.setValue(prcCalDay);
		// OM-2019-0000646 DEL END
		// 予約適用年月日
		whereMap.setValue(prcCalDay);
		// 請求契約番号
		whereMap.setValue(mastMap.getString(JBSbatCHIFM110.SEIKY_KEI_NO));
		// サービス契約番号
		whereMap.setValue(mastMap.getString(JBSbatCHIFM110.SVC_KEI_NO));
		// 料金グループコード
		whereMap.setValue(this.ownrPrcGrpCd);

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isSvcKei][whereMap=" + whereMap.getList().toString() + "]");
		
		// SQL実行
		executeKK_T_SVC_KEI_CH_SELECT_001(whereMap.getList().toArray());
		
		// 結果を取得
		JBSbatCommonDBInterface dbMap = db_KK_T_SVC_KEI.selectNext();
		
		// 取得なしの場合
		if(dbMap == null)
		{
			return false;
		}
		else
		{
			this.tmpSeiriNo = dbMap.getString(JBSbatKK_T_SVC_KEI.SEIRI_NO);
		}
		
		return true;
	}
	
	/**
	 * 入力情報及びチェック結果を退避．入力情報リストに設定します。
	 * 
	 * @param mastMap 入力情報（マスタ）
	 * @param tranMap 入力情報（トラン）
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	@SuppressWarnings("unchecked")
	private void addInDataList(JBSbatServiceInterfaceMap mastMap, JBSbatServiceInterfaceMap tranMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][addInDataList]");
		
		HashMap<String, String> setMap = new HashMap<String, String>();
		
		setMap.putAll(mastMap.getMap());
		
		// 未入居の場合
		if(this.miNyukyoFlg)
		{
			// サービス契約番号に未入居明細用サービス契約番号を設定する
			setMap.put(JBSbatCHIFM110.SVC_KEI_NO,		this.minyukyoSvcKeiNo);
		}

		// 整理番号
		String seiriNo = JACStrConst.SEIRI_NO_SP;
		if(!(mastMap.getString(JBSbatCHIFM110.SVC_KEI_NO) == null || mastMap.getString(JBSbatCHIFM110.SVC_KEI_NO).equals(JACStrConst.KARA_MOJI)))
		{
			seiriNo = this.tmpSeiriNo;
		}
		else if(!JACStrConst.KARA_MOJI.equals(this.tmpSvcKeiNo) && this.tmpSvcKeiNo != null)
		{
			seiriNo = this.tmpSeiriNo;
		}
		else if(this.miNyukyoFlg)
		{
			seiriNo = this.tmpSeiriNo;
		}
		
		// 料金グループコード
		String prcGrpCd = JACStrConst.PRC_GRP_CD_SP;
		
		// マンションIDが入力されていたら、オーナーの料金グループコードを設定する
		if(mastMap.getString(JBSbatCHIFM110.MANS_ID) != null && !JACStrConst.KARA_MOJI.equals(mastMap.getString(JBSbatCHIFM110.MANS_ID)))
		{
			prcGrpCd = this.ownrPrcGrpCd;
		}
		else if(this.pcrsCdList.containsKey(mastMap.get(JBSbatCHIFM110.PCRS_CD)))
		{
			// 料金コースコードリストより料金グループコードを取得
			// 該当する料金コースがない場合は、ALLスペース
			JBSbatCommonDBInterface pcrsCdMap = this.pcrsCdList.get(mastMap.get(JBSbatCHIFM110.PCRS_CD));
			prcGrpCd = pcrsCdMap.getString(JBSbatCH_T_SEIKY_UCWK.PRC_GRP_CD);
		}
		
		// エラーコード
		setMap.put(JBSbatCHIFM111.IKT_ADD_ERR_CD,		this.errNaiyoMap.get(this.tmpWkPara).get(ERR_NAIYO_MAP_ERR_CD));
		// エラー内容
		setMap.put(JBSbatCHIFM111.ERR_NYO,				this.errNaiyoMap.get(this.tmpWkPara).get(ERR_NAIYO_MAP_ERR_NAIYO));
//		// 請求番号
//		setMap.put(JBSbatCH_T_SEIKY.SEIKY_NO,			this.tmpSikyNo);
		// 整理番号
		setMap.put(JBSbatCH_T_SEIKY_UCWK.SEIRI_NO,		seiriNo);
		// 料金グループコード
		setMap.put(JBSbatCH_T_SEIKY_UCWK.PRC_GRP_CD,	prcGrpCd);
		// 一括登録ファイル
		setMap.put(JBSbatCHIFM118.IKT_ADD_FILE,			tranMap.getString(JBSbatCHIFM118.IKT_ADD_FILE));
//		// 利用期間設定判別フラグ
//		setMap.put(USE_PRD_HNBT_FLG,					this.tmpUsePrdStHmbtFlg);
		
// ANK-3296-00-00 v36.00.00 2018/01/29 Add Start
		
		// 料金項目コード
		String inPrcKmkCd = setMap.get(JBSbatCHIFM110.PRC_KMK_CD);
		
		// 必須詳細料金項目（工事費割賦）マップに料金項目コードが存在する場合
		if(this.reDtKjHiKpPrcMap.contains(inPrcKmkCd))
		{
			// setMapのサービス詳細識別番号を更新
			setMap.put(JBSbatCHIFM110.SVC_DTL_SKBT_NO, JACStrConst.KARA_MOJI);
		}
// ANK-3296-00-00 v36.00.00 2018/01/29 Add End
		
		// サービス契約番号（ダミー）
		if(!JACStrConst.KARA_MOJI.equals(this.tmpSvcKeiNo) && this.tmpSvcKeiNo != null)
		{
			setMap.put(JBSbatCH_T_SEIKY_UCWK.SVC_KEI_NO,	this.tmpSvcKeiNo);
			this.tmpSvcKeiNo = JACStrConst.KARA_MOJI;
		}
		
		assert setMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][addInDataList][setMap=" + setMap + "]") : true;
		
		this.inDataList.add(setMap);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][addInDataList]");
		return;
	}
	
// ANK-3296-00-00 v36.00.00 2018/01/29 Add Start
	/**
	 * 追加情報リストを退避．入力情報リストに設定します。
	 * 
	 * @param mastMap 入力情報（マスタ）
	 * @param tranMap 入力情報（トラン）
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	@SuppressWarnings("unchecked")
	private void addInDataListKjHiKp(JBSbatServiceInterfaceMap mastMap, JBSbatServiceInterfaceMap tranMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][addInDataListKjHiKp]");
		
		// 追加情報リスト
		HashMap<String, String> setMap = new HashMap<String, String>();
		
		setMap.putAll(mastMap.getMap());
		
		// 未入居の場合
		if(this.miNyukyoFlg)
		{
			// サービス契約番号に未入居明細用サービス契約番号を設定する
			setMap.put(JBSbatCHIFM110.SVC_KEI_NO,		this.minyukyoSvcKeiNo);
		}

		// 整理番号
		String seiriNo = JACStrConst.SEIRI_NO_SP;
		if(!(mastMap.getString(JBSbatCHIFM110.SVC_KEI_NO) == null || mastMap.getString(JBSbatCHIFM110.SVC_KEI_NO).equals(JACStrConst.KARA_MOJI)))
		{
			seiriNo = this.tmpSeiriNo;
		}
		else if(!JACStrConst.KARA_MOJI.equals(this.tmpSvcKeiNo) && this.tmpSvcKeiNo != null)
		{
			seiriNo = this.tmpSeiriNo;
		}
		else if(this.miNyukyoFlg)
		{
			seiriNo = this.tmpSeiriNo;
		}
		
		// 料金グループコード
		String prcGrpCd = JACStrConst.PRC_GRP_CD_SP;
		
		// マンションIDが入力されていたら、オーナーの料金グループコードを設定する
		if(mastMap.getString(JBSbatCHIFM110.MANS_ID) != null && !JACStrConst.KARA_MOJI.equals(mastMap.getString(JBSbatCHIFM110.MANS_ID)))
		{
			prcGrpCd = this.ownrPrcGrpCd;
		}
		else if(this.pcrsCdList.containsKey(mastMap.get(JBSbatCHIFM110.PCRS_CD)))
		{
			// 料金コースコードリストより料金グループコードを取得
			// 該当する料金コースがない場合は、ALLスペース
			JBSbatCommonDBInterface pcrsCdMap = this.pcrsCdList.get(mastMap.get(JBSbatCHIFM110.PCRS_CD));
			prcGrpCd = pcrsCdMap.getString(JBSbatCH_T_SEIKY_UCWK.PRC_GRP_CD);
		}
		
		// エラーコード
		setMap.put(JBSbatCHIFM111.IKT_ADD_ERR_CD,		this.errNaiyoMap.get(this.tmpWkPara).get(ERR_NAIYO_MAP_ERR_CD));
		// エラー内容
		setMap.put(JBSbatCHIFM111.ERR_NYO,				this.errNaiyoMap.get(this.tmpWkPara).get(ERR_NAIYO_MAP_ERR_NAIYO));
		// 整理番号
		setMap.put(JBSbatCH_T_SEIKY_UCWK.SEIRI_NO,		seiriNo);
		// 料金グループコード
		setMap.put(JBSbatCH_T_SEIKY_UCWK.PRC_GRP_CD,	prcGrpCd);
		// 一括登録ファイル
		setMap.put(JBSbatCHIFM118.IKT_ADD_FILE,			tranMap.getString(JBSbatCHIFM118.IKT_ADD_FILE));
		
		// setMapのサービス詳細識別番号を更新
		setMap.put(JBSbatCHIFM110.SVC_DTL_SKBT_NO, JACStrConst.KARA_MOJI);
		
		// サービス契約番号（ダミー）
		if(!JACStrConst.KARA_MOJI.equals(this.tmpSvcKeiNo) && this.tmpSvcKeiNo != null)
		{
			setMap.put(JBSbatCH_T_SEIKY_UCWK.SVC_KEI_NO,	this.tmpSvcKeiNo);
			this.tmpSvcKeiNo = JACStrConst.KARA_MOJI;
		}
		
		// 追加情報リストを更新
		updateSetMap(mastMap, setMap, prcGrpCd);
		
		assert setMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][addInDataListKjHiKp][setMap=" + setMap + "]") : true;
		
		this.inDataList.add(setMap);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][addInDataListKjHiKp]");
		
		return;
	}
	
	/**
	 * 追加情報リストを更新します。
	 * 
	 * @param mastMap 入力情報（マスタ）
	 * @param setMap 追加情報リスト
	 * @param prcGrpCd 料金グループコード
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void updateSetMap(JBSbatServiceInterfaceMap mastMap, HashMap<String, String> setMap, String prcGrpCd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][updateSetMap]");
		
		JBSbatCommonDBInterface param = new JBSbatCommonDBInterface();
		
		// 料金項目名称種別コード
		param.setValue(JACStrConst.PRC_KMK_NM_SBT_CD_PRC_KMK);
		// 料金グループコード
		param.setValue(prcGrpCd);
		// 料金コースコード
		param.setValue(mastMap.getString(JBSbatCHIFM110.PCRS_CD));
		// 料金サービスコード
		param.setValue(mastMap.getString(JBSbatCHIFM110.PRC_SVC_CD));
		// 料金項目コード
		param.setValue(mastMap.getString(JBSbatCHIFM110.PRC_KMK_CD));
		// オンライン運用日
		param.setValue(super.onlineOpeDate);
		// オンライン運用日
		param.setValue(super.onlineOpeDate);
		// オンライン運用日
		param.setValue(super.onlineOpeDate);
		
		// SQL実行
		executeCH_M_PRC_KMK_OPUT_NM_CH_SELECT_006(param.getList().toArray());
		
		// 結果を取得
		JBSbatCommonDBInterface dbMap = db_CH_M_PRC_KMK_OPUT_NM.selectNext();
		
		// 取得なしの場合
		if(null == dbMap)
		{
			// ログ出力
			String[] msgParam = new String[]
			{
					JBSbatCH_M_PRC_KMK_OPUT_NM.TABLE_NAME, param.getList().toString()
			};
			// 業務エラーとして処理
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.ECHB0240CW, msgParam);
		}
		// 正常終了した場合
		else
		{
			while(null != dbMap)
			{
				
				setMap.put(JBSbatCHIFM110.ADJ_AF_AMNT, mastMap.getString(JBSbatCHIFM110.SVC_DTL_SKBT_NO));				// 調整後料金更新
				setMap.put(JBSbatCH_T_SEIKY_UCWK.PRC_GRP_CD, dbMap.getString(JBSbatCH_M_PRC_KMK_OPUT_NM.UMKM_PRC_GRP_CD));	// 料金グループコード更新
				setMap.put(JBSbatCHIFM110.PCRS_CD, dbMap.getString(JBSbatCH_M_PRC_KMK_OPUT_NM.UMKM_PCRS_CD));				// 料金コースコード更新
				setMap.put(JBSbatCHIFM110.PRC_SVC_CD, dbMap.getString(JBSbatCH_M_PRC_KMK_OPUT_NM.UMKM_PRC_SVC_CD));			// 料金サービスコード更新
				setMap.put(JBSbatCHIFM110.PRC_KMK_CD, dbMap.getString(JBSbatCH_M_PRC_KMK_OPUT_NM.UMKM_PRC_KMK_CD));			// 料金項目コード更新
				
				dbMap = db_CH_M_PRC_KMK_OPUT_NM.selectNext();
			}
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][updateSetMap]");
		
		return;
	}
// ANK-3296-00-00 v36.00.00 2018/01/29 Add End
	
	
	
	/**
	 * 料金調整制御処理を行います。
	 * 
	 * @param outputInItem 入力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void prcAdjCtrl(JBSbatOutputItem outputInItem) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][prcReAdjCtrl]");
		
		// 退避．処理グループ番号エラーフラグ＝"0"の場合
		if(FLG_OFF.equals(this.tranGrpNoErrFrg))
		{
			// 料金再調整チェック制御を行います。
			this.chkPrcReAdjCtrl();
		}
		
		// 退避．処理グループ番号エラーフラグ＝"0"の場合
		if(FLG_OFF.equals(this.tranGrpNoErrFrg))
		{
			// 各種スキーマ更新・料金調整リストの出力を行います。
			this.updTable();
			
//			// コミットを行います。
//			super.commit();
		}
		// 退避．処理グループ番号エラーフラグ＝"1"の場合
		if(FLG_ON.equals(this.tranGrpNoErrFrg))
		{
			// エラーファイル出力情報を作成します。
			this.makeOutputFile(outputInItem);
		}
		
		// 退避情報をクリアします。
		this.inDataList.clear();
		this.sikyUcwkList.clear();
		this.seikyUcwkNoMap.clear();
		this.tmpSaikenNo = null;
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][prcReAdjCtrl]");
		return;
	}
	
	/**
	 * 料金再調整チェック制御を行います。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void chkPrcReAdjCtrl() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][chkPrcReAdjCtrl]");
		
		// 請求内訳取得
		this.selectSikyUcwk();
		
		// 退避．処理グループ番号エラーフラグ＝"0"の場合
		if(FLG_OFF.equals(this.tranGrpNoErrFrg))
		{
			// 料金調整チェックを行います。
			this.isPrcAdj();
		}

		// 退避．処理グループ番号エラーフラグ＝"0"の場合
		if(FLG_OFF.equals(this.tranGrpNoErrFrg))
		{
			// 工事遅延チェックを行います。
			this.isKojiDly();
		}

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][chkPrcReAdjCtrl]");
		return;
	}
	
	/**
	 * 請求内訳スキーマを検索します。
	 * 
	 * @return JBSbatCommonDBInterface 検索結果
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void selectSikyUcwk() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][selectSikyUcwk]");
		
		JBSbatCommonDBInterface whereParam = new JBSbatCommonDBInterface();
		
		// システムコード
		whereParam.setValue(super.systemCode);
		// 業務機能識別コード（請求額合計）
		whereParam.setValue(wkparaSikyAmntGk);
		// 抽出変換コード
		whereParam.setValue(JACStrConst.CHSHT_CHG_CD_CST);
		// オンライン運用日
		whereParam.setValue(super.onlineOpeDate);
		// システムコード
		whereParam.setValue(super.systemCode);
		// 業務機能識別コード（訂正可能料金項目）
		whereParam.setValue(wkparaPrcAdjTrg);
		// 抽出変換コード
		whereParam.setValue(JACStrConst.CHSHT_CHG_CD_CST);
		// オンライン運用日
		whereParam.setValue(super.onlineOpeDate);
		// 請求種別コード
		whereParam.setValue(JACStrConst.SIKYSHBTS_TEIGK_SEIKY);
		// システムコード
		whereParam.setValue(super.systemCode);
		// 業務機能識別コード（料金項目表示用）
		whereParam.setValue(JACStrConst.WORK_KINO_SKBT_ADJ_U_DSP);
		// 抽出変換コード
		whereParam.setValue(JACStrConst.CHSHT_CHG_CD_CST);
		// オンライン運用日
		whereParam.setValue(super.onlineOpeDate);
		// 料金項目名称種別コード
		whereParam.setValue(JACStrConst.PRC_KMK_NM_SBT_CD_PRC_NM);
		// オンライン運用日
		whereParam.setValue(super.onlineOpeDate);
		// オンライン運用日
		whereParam.setValue(super.onlineOpeDate);
		// オンライン運用日
		whereParam.setValue(super.onlineOpeDate);
		// オンライン運用日
		whereParam.setValue(super.onlineOpeDate);
		// 請求契約番号
		whereParam.setValue(this.shoriGroupMap.get(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_KEI_NO));
		// 請求年月
		whereParam.setValue(this.shoriGroupMap.get(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_YM));
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][selectSikyUcwk][whereParam=" + whereParam.getList().toString() + "]");
		
		// SQL実行
		executeCH_T_SEIKY_UCWK_CH_SELECT_010(whereParam.getList().toArray());
		
		// 結果取得
		JBSbatCommonDBInterface getParam = db_CH_T_SEIKY_UCWK.selectNext();
		
		// 処理グループ単位情報保持マップに格納済か判断するフラグ
		boolean flg = false;

		// 取得結果なしの場合
		if(null == getParam)
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][selectSikyUcwk][請求内訳スキーマにデータ未存在]");

			this.selectSeikyNo();
			
			JBSbatCommonDBInterface selectMap = db_CH_T_SEIKY_2.selectNext();

			// 取得できなかった場合
			if(null == selectMap)
			{
				// 入力リスト分、エラーリスト内容更新
				for(int i = 0; i < inDataList.size(); i++)
				{
					updInDataListErr(i, JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E042);
				}
			}
			else
			{
				// 処理グループ単位情報保持マップに格納
				this.addShoriGrpMap(selectMap);
			}
		}
		while(null != getParam)
		{
			String n0yenDtlDspCtrlFlg = getParam.getString(JBSbatCH_M_PRC_KMK_OPUT_NM.N_0_YEN_DTL_DSP_CTRL_FLG);
			String amnt = getParam.getString(JBSbatCH_T_SEIKY_UCWK.AMNT);
			
			if(!flg)
			{
				// 処理グループ単位情報保持マップに格納
				this.addShoriGrpMap(getParam);
				
				// フラグを格納済にする
				flg = true;
			}
			
			// ０円明細表示制御フラグが"0" かつ 金額が0円の場合は請求内訳リストに入れない
			if(!(JACStrConst.N_0_YEN_DTL_DSP_CTRL_FLG_HIDSP.equals(n0yenDtlDspCtrlFlg) && ZERO.equals(amnt)))
			{
				// 取得した情報を請求内訳リストに格納
				this.addSeikyUcwkList(getParam);
			}
			getParam = db_CH_T_SEIKY_UCWK.selectNext();
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][selectSikyUcwk][tmpSaikenNo" + this.tmpSaikenNo + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][selectSikyUcwk]");
		return;
	}
	
	/**
	 * 請求内訳リストに入力ファイルの値を格納します。
	 * 
	 * @param dbMap 債権内訳取得情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void addInFileShoriGrpMap(JBSbatServiceInterfaceMap mastMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][addInFileShoriGrpMap]");
		
		// 取得情報を設定
		
		// 請求契約番号
		this.shoriGroupMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_KEI_NO,			mastMap.getString(JBSbatCHIFM110.SEIKY_KEI_NO));
		// 請求年月
		this.shoriGroupMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_YM,				mastMap.getString(JBSbatCHIFM110.SEIKY_YM));
		// 料金対応記録種別詳細コード
		this.shoriGroupMap.put(JCHbatPrcAdjChgeUtil.PRC_TAIO_KIROK_SBT_DTL_CD,		JACStrConst.TKRK_SBTD_SEIKY_AMNT_CHG);
		// 補償費扱いフラグ
		this.shoriGroupMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_COMPENSATION_UM_FLG,	mastMap.getString(JBSbatCHIFM110.COMPENSATION_FLG));
		// 対応履歴連動対象フラグ
		this.shoriGroupMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_TAIORRKI_RENDO_TG_FLG,	mastMap.getString(JBSbatCHIFM110.CUST_TOAK_DSP_FLG));
		// 記事
		this.shoriGroupMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_KIJI,					mastMap.getString(JBSbatCHIFM110.KIJI));
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][addInFileShoriGrpMap][setMap=" + this.shoriGroupMap.toString() + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][addInFileShoriGrpMap]");
		return;
	}
	
	/**
	 * 請求内訳リストに値を格納します。
	 * 
	 * @param dbMap 債権内訳取得情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void addShoriGrpMap(JBSbatCommonDBInterface dbMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][addShoriGrpMap]");
		
		// 取得情報を設定
		
		// 請求番号
		this.shoriGroupMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_NO,				dbMap.getString(JBSbatCH_T_SEIKY.SEIKY_NO));
		// 請求ステータス
		this.shoriGroupMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_STAT,				dbMap.getString(JBSbatCH_T_SEIKY.SEIKY_STAT));
		// 請求種別コード
		this.shoriGroupMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_SBT_CD,			dbMap.getString(JBSbatCH_T_SEIKY.SEIKY_SBT_CD));
		// 更新前請求更新年月日時分秒
		this.shoriGroupMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_UPD_DTM_AF,		dbMap.getString(SEIKY_UPD_DTM));
		// 債権番号
		this.shoriGroupMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SAIKEN_NO,				dbMap.getString(JBSbatCH_T_SAIKEN.SAIKEN_NO));
		// 更新前債権更新年月日時分秒
		this.shoriGroupMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SAIKEN_UPD_DTM_AF,		dbMap.getString(SAIKEN_UPD_DTM));
		// 督促ステータス
		String tokusokuSt = dbMap.getString(JBSbatCH_T_TOKUSOKU.TOKUSOKU_STAT);
		if(tokusokuSt == null)
		{
			tokusokuSt = JACStrConst.KARA_MOJI;
		}
		this.shoriGroupMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_TOKUSOKU_STAT,			tokusokuSt);
		// 請求先名（カナ） 
		this.shoriGroupMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SHS_KANA,				dbMap.getString(JBSbatKK_T_SEIKY_KEI.SHS_KANA));
		// 請求金額 
		String seikyAmnt = dbMap.getString(SEIKY_AMNT);
		if(seikyAmnt == null)
		{
			seikyAmnt = "0";
		}
		this.shoriGroupMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_AMNT,				seikyAmnt);

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][addShoriGrpMap][setMap=" + this.shoriGroupMap.toString() + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][addShoriGrpMap]");
		return;
	}
	
	/**
	 * 請求内訳リストに値を格納します。
	 * 
	 * @param dbMap 債権内訳取得情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void addSeikyUcwkList(JBSbatCommonDBInterface dbMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][addSeikyUcwkList]");
		
		HashMap<String, String> setMap = new HashMap<String, String>();
		
		// 取得情報を設定
		
		// 料金訂正可否が訂正可能の場合のみ、調整区分を設定する
		String ajstDiv = JACStrConst.KARA_MOJI;
		if(dbMap.getString(PRC_TEISE_KH).equals(JACStrConst.PRC_TEISEI_KH_PSB))
		{
			ajstDiv = JACStrConst.PRC_ADJ_DIV_NO_CHG;
		}
		
		// サービス詳細識別番号がNULLの場合、空文字に変換する。
		String svcDtlSkbtNo = dbMap.getString(JBSbatCH_T_SEIKY_UCWK.SVC_DTL_SKBT_NO);
		if(svcDtlSkbtNo == null)
		{
			svcDtlSkbtNo = JACStrConst.KARA_MOJI;
		}

		// 請求契約番号
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_KEI_NO,			dbMap.getString(JBSbatCH_T_SEIKY_UCWK.SEIKY_KEI_NO));
		// 請求年月
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_YM,				dbMap.getString(JBSbatCH_T_SEIKY_UCWK.SEIKY_YM));
		// 請求番号
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_NO,				dbMap.getString(JBSbatCH_T_SEIKY.SEIKY_NO));
		// 請求ステータス
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_STAT,				dbMap.getString(JBSbatCH_T_SEIKY.SEIKY_STAT));
		// 請求種別コード
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_SBT_CD,			dbMap.getString(JBSbatCH_T_SEIKY.SEIKY_SBT_CD));
		// 更新前請求更新年月日時分秒
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_UPD_DTM_AF,		dbMap.getString(SEIKY_UPD_DTM));
		// 整理番号
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIRI_NO,				dbMap.getString(JBSbatCH_T_SEIKY_UCWK.SEIRI_NO));
		// サービス契約番号
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SVC_KEI_NO,				dbMap.getString(JBSbatCH_T_SEIKY_UCWK.SVC_KEI_NO));
		// 料金グループコード
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_GRP_CD,				dbMap.getString(JBSbatCH_T_SEIKY_UCWK.PRC_GRP_CD));
		// 料金コースコード
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_PCRS_CD,				dbMap.getString(JBSbatCH_T_SEIKY_UCWK.PCRS_CD));
		// 料金サービスコード
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_SVC_CD,				dbMap.getString(JBSbatCH_T_SEIKY_UCWK.PRC_SVC_CD));
		// 料金項目コード
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_KMK_CD,				dbMap.getString(JBSbatCH_T_SEIKY_UCWK.PRC_KMK_CD));
		// 合算請求年月
		setMap.put(JBSbatCH_T_SEIKY_UCWK.GSAN_SEIKY_YM,					dbMap.getString(JBSbatCH_T_SEIKY_UCWK.GSAN_SEIKY_YM));
		// 利用開始年月日
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_USE_STAYMD,				dbMap.getString(JBSbatCH_T_SEIKY_UCWK.USE_STAYMD));
		// 利用終了年月日
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_USE_ENDYMD,				dbMap.getString(JBSbatCH_T_SEIKY_UCWK.USE_ENDYMD));
		// 変更前利用開始年月日
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_USE_STAYMD_BF,			dbMap.getString(JBSbatCH_T_SEIKY_UCWK.USE_STAYMD));
		// 変更前利用終了年月日
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_USE_ENDYMD_BF,			dbMap.getString(JBSbatCH_T_SEIKY_UCWK.USE_ENDYMD));
		// 金額
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_AMNT,				dbMap.getString(JBSbatCH_T_SEIKY_UCWK.AMNT));
		// マンションID
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_MANSION_ID,				dbMap.getString(JBSbatKK_T_KAISEN_USE_KEI.MANSION_ID));
		// ＣＡＴ−ＩＤ
		setMap.put(JBSbatKK_T_KAISEN_USE_KEI.CATID,						dbMap.getString(JBSbatKK_T_KAISEN_USE_KEI.CATID));
		// マンション営業案件管理番号
		setMap.put(JBSbatKK_T_KAISEN_USE_KEI.MSBSN_ANKEN_KNRI_NO,		dbMap.getString(JBSbatKK_T_KAISEN_USE_KEI.MSBSN_ANKEN_KNRI_NO));
		// Ｐ−ＩＤ
		setMap.put(JBSbatKK_T_OWNR_KEI.PID,								dbMap.getString(JBSbatKK_T_OWNR_KEI.PID));
		// 回線場所住所補記＿部屋番号
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_KAISEN_PLACE_ADRRM,		dbMap.getString(JBSbatKK_T_SVKEI_KAISEN_UW.SKS_YO_KISN_PLACE_AD_RM_NO));
		// 債権番号
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SAIKEN_NO,				dbMap.getString(JBSbatCH_T_SAIKEN.SAIKEN_NO));
		// 更新前債権更新年月日時分秒
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SAIKEN_UPD_DTM_AF,		dbMap.getString(SAIKEN_UPD_DTM));
		// 変更前金額
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_AJST_BF_AMNT,			dbMap.getString(JBSbatCH_T_SEIKY_UCWK.AMNT));
		// 変更後金額
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_AJST_AF_AMNT,			dbMap.getString(JBSbatCH_T_SEIKY_UCWK.AMNT));
		// 表示順
		setMap.put(JBSbatCH_M_PRC_KMK_OPUT_NM.DSP_JUN,					dbMap.getString(JBSbatCH_M_PRC_KMK_OPUT_NM.DSP_JUN));
		// 利用期間表示制御フラグ
		setMap.put(JBSbatCH_M_PRC_KMK_OPUT_NM.USE_PRD_DSP_CTRL_FLG,		dbMap.getString(JBSbatCH_M_PRC_KMK_OPUT_NM.USE_PRD_DSP_CTRL_FLG));
		// 金額表示カラム数
		setMap.put(JBSbatCH_M_PRC_KMK_OPUT_NM.AMNT_DSP_COLUM_CNT,		dbMap.getString(JBSbatCH_M_PRC_KMK_OPUT_NM.AMNT_DSP_COLUM_CNT));
		// ０円明細表示制御フラグ
		setMap.put(JBSbatCH_M_PRC_KMK_OPUT_NM.N_0_YEN_DTL_DSP_CTRL_FLG,	dbMap.getString(JBSbatCH_M_PRC_KMK_OPUT_NM.N_0_YEN_DTL_DSP_CTRL_FLG));
		// 督促ステータス
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_TOKUSOKU_STAT,			dbMap.getString(JBSbatCH_T_TOKUSOKU.TOKUSOKU_STAT));
		// 請求先名（カナ） 
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SHS_KANA,				dbMap.getString(JBSbatKK_T_SEIKY_KEI.SHS_KANA));
		// 料金訂正可否
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_TEISE_KH,			dbMap.getString(PRC_TEISE_KH));
		// 更新区分
		setMap.put(UPD_DIV,												JACStrConst.UPD_DIV_NON);
		// 料金調整区分
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_AJST_DIV,				ajstDiv);
		// サービス詳細識別番号
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SVC_DTL_SKBT_NO,		svcDtlSkbtNo);
		// 請求内訳番号
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_UCWK_NO,			dbMap.getString(JBSbatCH_T_SEIKY_UCWK.SEIKY_UCWK_NO));
		
		// サービス詳細識別番号区分
		String svcDtlSkbtNoKbn = JACStrConst.KARA_MOJI;
		// タブレット端末系料金の場合
		if(this.reDtTtPrcMap.contains(dbMap.getString(JBSbatCH_T_SEIKY_UCWK.PRC_KMK_CD)))
		{
			// サービス詳細識別番号区分に"1"：タブレットを設定
			svcDtlSkbtNoKbn = JCHbatPrcAdjChgeUtil.SVC_DTL_SKBT_NO_NBN_TBT;
		}
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SVC_DTL_SKBT_NO_KBN,	svcDtlSkbtNoKbn);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][addSeikyUcwkList][setMap=" + setMap.toString() + "]");
		
		this.sikyUcwkList.add(setMap);
		
		// 料金項目コードが必須詳細料金項目．料金項目コード（重複可）に含まれる場合
		if(reDtDplMap.contains(dbMap.getString(JBSbatCH_T_SEIKY_UCWK.PRC_KMK_CD)))
		{
			// 請求内訳番号を取得
			BigDecimal seikyUcwkNo = new BigDecimal(dbMap.getString(JBSbatCH_T_SEIKY_UCWK.SEIKY_UCWK_NO));
			
			// 識別子＋サービス詳細識別番号単位で請求内訳番号を格納する
			StringBuffer buf = new StringBuffer();
			
			buf.append(dbMap.getString(JBSbatCH_T_SEIKY_UCWK.SEIRI_NO))
			   .append(dbMap.getString(JBSbatCH_T_SEIKY_UCWK.SVC_KEI_NO))
			   .append(dbMap.getString(JBSbatCH_T_SEIKY_UCWK.PRC_GRP_CD))
			   .append(dbMap.getString(JBSbatCH_T_SEIKY_UCWK.PCRS_CD))
			   .append(dbMap.getString(JBSbatCH_T_SEIKY_UCWK.PRC_SVC_CD))
			   .append(dbMap.getString(JBSbatCH_T_SEIKY_UCWK.PRC_KMK_CD))
			   .append(dbMap.getString(JBSbatCH_T_SEIKY_UCWK.SVC_DTL_SKBT_NO));
			
			String key = buf.toString();
			
			// 請求内訳番号マップに既に含まれる場合
			if(seikyUcwkNoMap.containsKey(key))
			{
				// 退避している番号と比較し、大きければ更新
				BigDecimal thSeikyUcwkNo = seikyUcwkNoMap.get(key);
				if(seikyUcwkNo.compareTo(thSeikyUcwkNo) > 0)
				{
					seikyUcwkNoMap.put(key, seikyUcwkNo);
				}
			}
			else
			{
				// 請求内訳番号で追加
				seikyUcwkNoMap.put(key, seikyUcwkNo);
			}
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][addSeikyUcwkList]");
		return;
	}
	
	/**
	 * 料金調整を行い、その処理結果を返却します。
	 * 
	 * @param inDataIndex 退避．入力データリストの対象マップのインデックス
	 * @return boolean 処理結果（true:正常終了、false:エラーデータあり）
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private boolean isPrcAdj() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isPrcAdj]");
		
		// 入力データリスト数ループ
		for(int inNum = 0; inNum < this.inDataList.size(); inNum++)
		{
			// 退避．入力データリスト->調整区分
			String inDataAdjDiv = this.inDataList.get(inNum).get(JBSbatCHIFM110.ADJ_DIV);
			// 退避．入力データリスト->金額
			String inDataAdjAfAmnt = this.inDataList.get(inNum).get(JBSbatCHIFM110.ADJ_AF_AMNT);
			
			// 存在チェックフラグ（true:存在しない場合、false:存在する場合）
			boolean flg = true;
			
			for(int suNum = 0; suNum < this.sikyUcwkList.size(); suNum++)
			{
				// チェック対象判定フラグ
				boolean chkFlg = true;

				// サービス契約番号を取得しnull、または空の場合ALLスペースに置き換える
				String workSvcKeiNo = this.inDataList.get(inNum).get(JBSbatCHIFM110.SVC_KEI_NO);
				if (workSvcKeiNo == null || JACStrConst.KARA_MOJI.equals(workSvcKeiNo))
				{
					workSvcKeiNo = JACStrConst.SVC_KEI_NO_SP;
				}
				
				// 取得したサービス契約番号がnullまたは空の場合
				if(JACStrConst.SVC_KEI_NO_SP.equals(workSvcKeiNo))
				{
					// 退避．入力データリスト->サービス契約番号		＝	退避．請求内訳リスト->サービス契約番号		かつ
					// （退避．入力データリスト->マンションID		≠	null・空文字								または
					// 退避．入力データリスト->料金コースコード		＝	退避．請求内訳リスト->料金コースコード）	かつ
					// 退避．入力データリスト->料金サービスコード	＝	退避．請求内訳リスト->料金サービスコード	かつ
					// 退避．入力データリスト->料金項目コード		＝	退避．請求内訳リスト->料金項目コード		かつ
					// 退避．入力データリスト->サービス詳細識別番号	＝	退避．請求内訳リスト->サービス詳細識別番号	の場合
					if(workSvcKeiNo.equals(this.sikyUcwkList.get(suNum).get(JCHbatPrcAdjChgeUtil.MAP_KEY_SVC_KEI_NO))
						&& (
								(this.inDataList.get(inNum).get(JBSbatCHIFM110.MANS_ID) != null && !JACStrConst.KARA_MOJI.equals(this.inDataList.get(inNum).get(JBSbatCHIFM110.MANS_ID)))
								|| this.inDataList.get(inNum).get(JBSbatCH_T_SEIKY_UCWK.PCRS_CD).equals(this.sikyUcwkList.get(suNum).get(JCHbatPrcAdjChgeUtil.MAP_KEY_PCRS_CD))
							)
						&& this.inDataList.get(inNum).get(JBSbatCHIFM110.PRC_SVC_CD).equals(this.sikyUcwkList.get(suNum).get(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_SVC_CD))
						&& this.inDataList.get(inNum).get(JBSbatCHIFM110.PRC_KMK_CD).equals(this.sikyUcwkList.get(suNum).get(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_KMK_CD))
						&& this.inDataList.get(inNum).get(JBSbatCHIFM110.SVC_DTL_SKBT_NO).equals(this.sikyUcwkList.get(suNum).get(JCHbatPrcAdjChgeUtil.MAP_KEY_SVC_DTL_SKBT_NO)))
					{
						// 存在チェックフラグ←false
						flg = false;
						
						// チェック対象判定フラグ←false
						chkFlg = false;
					}
				}
				else
				{
					// 退避．入力データリスト->サービス契約番号		＝	退避．請求内訳リスト->サービス契約番号		かつ
					// （退避．入力データリスト->マンションID		≠	null・空文字								または
					// 　退避．入力データリスト->料金グループコード	＝	退避．請求内訳リスト->料金グループコード）	かつ
					// 退避．入力データリスト->料金コースコード		＝	退避．請求内訳リスト->料金コースコード		かつ
					// 退避．入力データリスト->料金サービスコード	＝	退避．請求内訳リスト->料金サービスコード	かつ
					// 退避．入力データリスト->料金項目コード		＝	退避．請求内訳リスト->料金項目コード		かつ
					// 退避．入力データリスト->サービス詳細識別番号	＝	退避．請求内訳リスト->サービス詳細識別番号	の場合
					if(workSvcKeiNo.equals(this.sikyUcwkList.get(suNum).get(JCHbatPrcAdjChgeUtil.MAP_KEY_SVC_KEI_NO))
									&& (
													(this.inDataList.get(inNum).get(JBSbatCHIFM110.MANS_ID) != null && !JACStrConst.KARA_MOJI.equals(this.inDataList.get(inNum).get(JBSbatCHIFM110.MANS_ID)))
													|| this.inDataList.get(inNum).get(JBSbatCH_T_SEIKY_UCWK.PRC_GRP_CD).equals(this.sikyUcwkList.get(suNum).get(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_GRP_CD))
									)
									&& this.inDataList.get(inNum).get(JBSbatCHIFM110.PCRS_CD).equals(this.sikyUcwkList.get(suNum).get(JCHbatPrcAdjChgeUtil.MAP_KEY_PCRS_CD))
									&& this.inDataList.get(inNum).get(JBSbatCHIFM110.PRC_SVC_CD).equals(this.sikyUcwkList.get(suNum).get(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_SVC_CD))
									&& this.inDataList.get(inNum).get(JBSbatCHIFM110.PRC_KMK_CD).equals(this.sikyUcwkList.get(suNum).get(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_KMK_CD))
									&& this.inDataList.get(inNum).get(JBSbatCHIFM110.SVC_DTL_SKBT_NO).equals(this.sikyUcwkList.get(suNum).get(JCHbatPrcAdjChgeUtil.MAP_KEY_SVC_DTL_SKBT_NO)))
					{
//v44.00.00 ANK-3514-00-00 MOD START
						// 存在チェックフラグ←false
//						flg = false;
//v44.00.00 ANK-3514-00-00 MOD END
						
						// チェック対象判定フラグ←false
						chkFlg = false;
					}
				}
				
				// チェック対象レコードの場合
				if (!chkFlg)
				{
//					// 退避．請求内訳リスト->更新区分≠"0"（対応なし）の場合
//					if(!JACStrConst.UPD_DIV_NON.equals(this.sikyUcwkList.get(k).get(UPD_DIV)))
//					{
//						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][k=" + String.valueOf(k) + "]");
//						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][this.sikyUcwkList.get(k)=" + this.sikyUcwkList.get(k).toString() + "]");
//						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][入力データが請求内訳リストにデータが存在し、請求内訳リスト．更新区分≠0（何もしない）]");
//						
//						// 退避．入力データリストをエラーとして処理します。
//						updInDataListErr(inDataIndex, JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E040);
//						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isPrcAdj]");
//						return false;
//						
//					}
					
					// 入力データリスト．料金項目コードが必須詳細料金項目．料金項目コード（重複可）に含まれる場合
					if(reDtDplMap.contains(this.inDataList.get(inNum).get(JBSbatCHIFM110.PRC_KMK_CD)))
					{
						// 退避．入力データリスト->変更区分＝"2"（変更）または退避．入力データリスト->調整区分＝"3"（削除）の場合
						if(JACStrConst.UPD_DIV_ADJ.equals(inDataAdjDiv) || JACStrConst.UPD_DIV_DEL.equals(inDataAdjDiv))
						{
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][inNum=" + String.valueOf(inNum) + "]");
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][this.sikyUcwkList.get(suNum)=" + this.sikyUcwkList.get(suNum).toString() + "]");
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][入力データリスト．料金項目コード＝必須詳細料金項目．料金項目コード（重複可）]");
							
							// 退避．入力データリストをエラーとして処理します。
							updInDataListErr(inNum, JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E054);
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isPrcAdj]");
							break;
						}
						
						flg = true;
					}
					// 入力データリスト．料金項目コードが必須詳細料金項目．料金項目コード（重複可）に含まれない場合
					else
					{
						// 退避．入力データリスト->更新区分＝"1"（追加）の場合
						if(JACStrConst.UPD_DIV_ADD.equals(inDataAdjDiv))
						{
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][suNum=" + String.valueOf(suNum) + "]");
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][this.sikyUcwkList.get(suNum)=" + this.sikyUcwkList.get(suNum).toString() + "]");
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][入力データが請求内訳リストにデータが存在し、入力データリスト．調整区分＝1（追加）]");
							
							// 退避．入力データリストをエラーとして処理します。
							updInDataListErr(inNum, JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E041);
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isPrcAdj]");
							break;
						}

						// 退避．入力データリスト->変更区分＝"2"（変更）かつ退避．入力データリスト->０円明細表示制御フラグ＝"0"（非表示）
						// かつ入力データリスト．金額＝０の場合
						if(JACStrConst.UPD_DIV_ADJ.equals(inDataAdjDiv)
								&& JACStrConst.N_0_YEN_DTL_DSP_CTRL_FLG_HIDSP.equals(this.sikyUcwkList.get(suNum).get(JBSbatCH_M_PRC_KMK_OPUT_NM.N_0_YEN_DTL_DSP_CTRL_FLG))
								&& ZERO.equals(inDataAdjAfAmnt))
						{
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][inNum=" + String.valueOf(inNum) + "]");
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][this.sikyUcwkList.get(suNum)=" + this.sikyUcwkList.get(suNum).toString() + "]");
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][０円明細表示制御フラグ＝0（非表示）かつ入力データリスト．金額＝０]");
							
							// 退避．入力データリストをエラーとして処理します。
							updInDataListErr(inNum, JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E048);
							assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isPrcAdj]");
							break;
						}
						
//v44.00.00 ANK-3514-00-00 MOD START
						// 請求内訳リストを入力データで更新
//						this.sikyUcwkListUpd(inNum, suNum);
						// 退避．入力データリスト->料金グループコード＝オーナー用料金グループコードかつ
						// 退避．入力データリスト->サービス契約番号＝未入居明細用サービス契約番号の場合
						if(ownrPrcGrpCd.equals(this.inDataList.get(inNum).get(JBSbatCH_T_SEIKY_UCWK.PRC_GRP_CD)) && minyukyoSvcKeiNo.equals(this.inDataList.get(inNum).get(JBSbatCHIFM110.SVC_KEI_NO)))
						{
							String inMansionID = this.inDataList.get(inNum).get(JBSbatCHIFM110.MANS_ID);
							String dbMansionID = this.sikyUcwkList.get(suNum).get(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIRI_NO);
							// 退避．入力データリスト->マンションＩＤ、退避．請求内訳リスト->整理番号がＮＵＬＬ以外　かつ
							// 退避．入力データリスト->マンションＩＤ ＝ trim(退避．請求内訳リスト->整理番号)　の場合
							if((!JACBatCommon.isNull(inMansionID) && !JACBatCommon.isNull(dbMansionID)) && inMansionID.equals(dbMansionID.trim()))
							{
								// 請求内訳リストを入力データで更新
								this.sikyUcwkListUpd(inNum, suNum);
								// 存在チェックフラグ←false
								flg = false;
							}
						}
						else
						{
							// 請求内訳リストを入力データで更新
							this.sikyUcwkListUpd(inNum, suNum);
							// 存在チェックフラグ←false
							flg = false;
						}
//v44.00.00 ANK-3514-00-00 MOD END
					}
				}
			}
			// 該当レコード未存在の場合
			if(flg)
			{
				// 退避．入力データリスト->調整区分＝"2"（変更）
				if(JACStrConst.UPD_DIV_ADJ.equals(inDataAdjDiv))
				{
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][入力データが請求内訳リストにデータが存在せず、入力データリスト．調整区分＝2（変更）]");
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][inNum=" + String.valueOf(inNum) + "]");
					
					// 退避．入力データリストをエラーとして処理します。
					updInDataListErr(inNum, JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E034);
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isPrcAdj]");
					continue;
				}
				
				// 退避．入力データリスト->調整区分＝"3"（削除）
				if(JACStrConst.UPD_DIV_DEL.equals(inDataAdjDiv))
				{
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][入力データが請求内訳リストにデータが存在せず、入力データリスト．調整区分＝3（削除）]");
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][inNum=" + String.valueOf(inNum) + "]");
					
					// 退避．入力データリストをエラーとして処理します。
					updInDataListErr(inNum, JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E034);
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isPrcAdj]");
					continue;
				}


				// 入力データリスト．金額＝０の場合
				if(ZERO.equals(inDataAdjAfAmnt))
				{
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][入力データリスト．金額＝０]");
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isPrcAdj][inNum=" + String.valueOf(inNum) + "]");
					
					// 退避．入力データリストをエラーとして処理します。
					updInDataListErr(inNum, JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E047);
					assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isPrcAdj]");
					continue;
				}

				// 料金変更リストに入力データを追加
				this.addPrcChgListAdd(inNum);
			}
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isPrcAdj]");
		return true;
	}
	
	/**
	 * 請求内訳リストの値を更新します。
	 * 
	 * @param dbMap 債権内訳取得情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void sikyUcwkListUpd(int inNum, int suNum) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][sikyUcwkListUpd]");
		
		// 取得情報を設定
		
//		// 請求契約番号
//		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_KEI_NO,			this.sikyUcwkList.get(suNum).get(JBSbatCH_T_SEIKY_UCWK.SEIKY_KEI_NO));
//		// 請求年月
//		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_YM,				this.sikyUcwkList.get(suNum).get(JBSbatCH_T_SEIKY_UCWK.SEIKY_YM));
//		// 請求番号
//		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_NO,				this.sikyUcwkList.get(suNum).get(JBSbatCH_T_SEIKY.SEIKY_NO));
//		// 請求ステータス
//		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_STAT,			this.sikyUcwkList.get(suNum).get(JBSbatCH_T_SEIKY.SEIKY_STAT));
//		// 債権番号
//		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_SAIKEN_NO,			this.sikyUcwkList.get(suNum).get(JBSbatCH_T_SAIKEN.SAIKEN_NO));
//		// 更新前請求更新年月日時分秒
//		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_UPD_DTM_AF,		this.sikyUcwkList.get(suNum).get(SEIKY_UPD_DTM));
//		// 更新前債権更新年月日時分秒
//		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_SAIKEN_UPD_DTM_AF,	this.sikyUcwkList.get(suNum).get(SAIKEN_UPD_DTM));
//		// 整理番号
//		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIRI_NO,				this.inDataList.get(inNum).get(JBSbatCH_T_SEIKY_UCWK.SEIRI_NO));
		// サービス契約番号
		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_SVC_KEI_NO,			this.inDataList.get(inNum).get(JBSbatCHIFM110.SVC_KEI_NO));
		// 利用開始年月日
		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_USE_STAYMD,			this.inDataList.get(inNum).get(JBSbatCHIFM110.STA_DAY));
		// 利用終了年月日
		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_USE_ENDYMD,			this.inDataList.get(inNum).get(JBSbatCHIFM110.END_DAY));
//		// 料金グループコード
//		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_GRP_CD,			this.inDataList.get(inNum).get(JBSbatCH_T_SEIKY_UCWK.PRC_GRP_CD));
		// 料金コースコード
		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_PCRS_CD,				this.inDataList.get(inNum).get(JBSbatCHIFM110.PCRS_CD));
		// 料金サービスコード
		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_SVC_CD,			this.inDataList.get(inNum).get(JBSbatCHIFM110.PRC_SVC_CD));
		// 料金項目コード
		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_KMK_CD,			this.inDataList.get(inNum).get(JBSbatCHIFM110.PRC_KMK_CD));
//		// 金額
//		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_AMNT,			this.sikyUcwkList.get(suNum).get(JBSbatCH_T_SEIKY_UCWK.AMNT));
		// マンションID
		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_MANSION_ID,			this.sikyUcwkList.get(suNum).get(JBSbatCHIFM110.MANS_ID));
		// 請求書用回線場所住所部屋番号
		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_KAISEN_PLACE_ADRRM,	this.sikyUcwkList.get(suNum).get(JBSbatCHIFM110.RM_NO));
//		// 変更前金額
//		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_AJST_BF_AMNT,			this.sikyUcwkList.get(suNum).get(JBSbatCH_T_SEIKY_UCWK.AMNT));
		// 変更後金額
		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_AJST_AF_AMNT,			this.inDataList.get(inNum).get(JBSbatCHIFM110.ADJ_AF_AMNT));
		// 料金調整区分
		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_AJST_DIV,				JPCUtilCommon.fillZero(this.inDataList.get(inNum).get(JBSbatCHIFM110.ADJ_DIV), 2, false));
		// サービス詳細識別番号
		this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_SVC_DTL_SKBT_NO,		this.inDataList.get(inNum).get(JBSbatCHIFM110.SVC_DTL_SKBT_NO));
		// 更新区分
		this.sikyUcwkList.get(suNum).put(UPD_DIV,											this.inDataList.get(inNum).get(JBSbatCHIFM110.ADJ_DIV));
		// サービス詳細識別番号区分
		// タブレット端末系料金の場合
		if(this.reDtTtPrcMap.contains(this.inDataList.get(inNum).get(JBSbatCHIFM110.PRC_KMK_CD)))
		{
			// サービス詳細識別番号区分に"1"：タブレットを設定
			this.sikyUcwkList.get(suNum).put(JCHbatPrcAdjChgeUtil.MAP_KEY_SVC_DTL_SKBT_NO_KBN,	JCHbatPrcAdjChgeUtil.SVC_DTL_SKBT_NO_NBN_TBT);
		}
		

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][sikyUcwkListUpd]");
		return;
	}
	
	/**
	 * 請求内訳リストに追加します。
	 * 
	 * @param dbMap 債権内訳取得情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void addPrcChgListAdd(int inNum) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][addPrcChgListAdd]");
		
		HashMap<String, String> setMap = new HashMap<String, String>();
		
		String seikyUcwkNo = "1";
		
		// 料金項目コードが必須詳細料金項目．料金項目コード（重複可）に含まれる場合
		if(reDtDplMap.contains(this.inDataList.get(inNum).get(JBSbatCHIFM110.PRC_KMK_CD)))
		{
			// 識別子＋サービス詳細識別番号単位で請求内訳番号を格納する
			StringBuffer buf = new StringBuffer();
			
			buf.append(this.inDataList.get(inNum).get(JBSbatCH_T_SEIKY_UCWK.SEIRI_NO))
			   .append(this.inDataList.get(inNum).get(JBSbatCHIFM110.SVC_KEI_NO))
			   .append(this.inDataList.get(inNum).get(JBSbatCH_T_SEIKY_UCWK.PRC_GRP_CD))
			   .append(this.inDataList.get(inNum).get(JBSbatCHIFM110.PCRS_CD))
			   .append(this.inDataList.get(inNum).get(JBSbatCHIFM110.PRC_SVC_CD))
			   .append(this.inDataList.get(inNum).get(JBSbatCHIFM110.PRC_KMK_CD))
			   .append(this.inDataList.get(inNum).get(JBSbatCHIFM110.SVC_DTL_SKBT_NO));
			
			String key = buf.toString();
			
			if(seikyUcwkNoMap.containsKey(key))
			{
				BigDecimal newSeikyUcwkNo = seikyUcwkNoMap.get(key).add(BigDecimal.ONE);
				
				seikyUcwkNoMap.put(key, newSeikyUcwkNo);
				
				seikyUcwkNo = newSeikyUcwkNo.toString();
			}
		}
		
		// 取得情報を設定
		
//		// 請求契約番号
//		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_KEI_NO,			this.inDataList.get(inNum).get(JBSbatCHIFM110.SEIKY_KEI_NO));
//		// 請求年月
//		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_YM,				this.inDataList.get(inNum).get(JBSbatCHIFM110.SEIKY_YM));
//		// 請求番号
//		setMap.put(JBSbatCH_T_SEIKY.SEIKY_NO,							this.sikyUcwkList.get(suNum).get(JBSbatCH_T_SEIKY.SEIKY_NO));
//		// 請求ステータス
//		setMap.put(JBSbatCH_T_SEIKY.SEIKY_STAT,							this.sikyUcwkList.get(suNum).get(JBSbatCH_T_SEIKY.SEIKY_STAT));
//		// 債権番号
//		setMap.put(JBSbatCH_T_SAIKEN.SAIKEN_NO,							this.sikyUcwkList.get(suNum).get(JBSbatCH_T_SAIKEN.SAIKEN_NO));
//		// 更新前請求更新年月日時分秒
//		setMap.put(SEIKY_UPD_DTM,										this.sikyUcwkList.get(suNum).get(SEIKY_UPD_DTM));
//		// 更新前債権更新年月日時分秒
//		setMap.put(SAIKEN_UPD_DTM,										this.sikyUcwkList.get(suNum).get(SAIKEN_UPD_DTM));
		// 整理番号
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIRI_NO,				this.inDataList.get(inNum).get(JBSbatCH_T_SEIKY_UCWK.SEIRI_NO));
		// サービス契約番号
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SVC_KEI_NO,				this.inDataList.get(inNum).get(JBSbatCHIFM110.SVC_KEI_NO));
		// 利用開始年月日
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_USE_STAYMD,				this.inDataList.get(inNum).get(JBSbatCHIFM110.STA_DAY));
		// 利用終了年月日
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_USE_ENDYMD,				this.inDataList.get(inNum).get(JBSbatCHIFM110.END_DAY));
		// 料金グループコード
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_GRP_CD,				this.inDataList.get(inNum).get(JBSbatCH_T_SEIKY_UCWK.PRC_GRP_CD));
		// 料金コースコード
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_PCRS_CD,				this.inDataList.get(inNum).get(JBSbatCHIFM110.PCRS_CD));
		// 料金サービスコード
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_SVC_CD,				this.inDataList.get(inNum).get(JBSbatCHIFM110.PRC_SVC_CD));
		// 料金項目コード
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_KMK_CD,				this.inDataList.get(inNum).get(JBSbatCHIFM110.PRC_KMK_CD));
		// 金額
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_AMNT,				this.inDataList.get(inNum).get(JBSbatCHIFM110.ADJ_AF_AMNT));
		// マンションID
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_MANSION_ID,				this.inDataList.get(inNum).get(JBSbatCHIFM110.MANS_ID));
		// 回線場所住所補記＿部屋番号
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_KAISEN_PLACE_ADRRM,		this.inDataList.get(inNum).get(JBSbatCHIFM110.RM_NO));
//		// 変更前金額
//		setMap.put(CHG_BF_AMNT,											"0");
		// 変更後金額
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_AJST_AF_AMNT,			this.inDataList.get(inNum).get(JBSbatCHIFM110.ADJ_AF_AMNT));
		// 料金調整区分
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_AJST_DIV,				JPCUtilCommon.fillZero(this.inDataList.get(inNum).get(JBSbatCHIFM110.ADJ_DIV), 2, false));
		// 調整フラグ
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_AJST_FLG,				"0");
		// 更新区分
		setMap.put(UPD_DIV,												this.inDataList.get(inNum).get(JBSbatCHIFM110.ADJ_DIV));
		// サービス詳細識別番号
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SVC_DTL_SKBT_NO,		this.inDataList.get(inNum).get(JBSbatCHIFM110.SVC_DTL_SKBT_NO));
		// 請求内訳番号
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_UCWK_NO,			seikyUcwkNo);
		// サービス詳細識別番号区分
		String svcDtlSkbtNoKbn = JACStrConst.KARA_MOJI;
		// タブレット端末系料金の場合
		if(this.reDtTtPrcMap.contains(this.inDataList.get(inNum).get(JBSbatCHIFM110.PRC_KMK_CD)))
		{
			// サービス詳細識別番号区分に"1"：タブレットを設定
			svcDtlSkbtNoKbn = JCHbatPrcAdjChgeUtil.SVC_DTL_SKBT_NO_NBN_TBT;
		}
		setMap.put(JCHbatPrcAdjChgeUtil.MAP_KEY_SVC_DTL_SKBT_NO_KBN,	svcDtlSkbtNoKbn);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][addPrcChgListAdd][setMap=" + setMap.toString() + "]");
		
		this.sikyUcwkList.add(setMap);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][addPrcChgListAdd]");
		return;
	}
	
	/**
	 * 請求内訳の工事遅延チェックを行います。 <br>
	 * 
	 * @param bean サービスフォームBean
	 * @return 判定結果
	 * @throws Exception 
	 */
	private boolean isKojiDly() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][isKojiDly]");

		boolean existKojiDly = false;   // 工事遅延明細存在フラグ
		boolean existAddChg = false;    // 追加・変更明細存在フラグ
		int teiseiCount =  0 ;
		int delCount =  0 ;
		String seikyYm = null;

		for (int idx = 0; idx < sikyUcwkList.size(); idx++)
		{
			HashMap<String, String> sikyUcwkMap = sikyUcwkList.get(idx);
			String prcTeiseiKh = sikyUcwkMap.get(JCHbatPrcAdjChgeUtil.MAP_KEY_PRC_TEISE_KH);
			String divAdjPrc = sikyUcwkMap.get(JCHbatPrcAdjChgeUtil.MAP_KEY_AJST_DIV);

			if (JACStrConst.PRC_TEISEI_KH_PSB.equals(prcTeiseiKh))
			{
				// 訂正可能明細数
				teiseiCount ++ ;
				
				if (JACStrConst.PRC_ADJ_DIV_DEL.equals(divAdjPrc))
				{
					// 削除明細数
					delCount ++ ;
				}

				seikyYm = sikyUcwkMap.get(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_YM);
				String gsanSeikyYm = sikyUcwkMap.get(JBSbatCH_T_SEIKY_UCWK.GSAN_SEIKY_YM);
				if (!JACStrConst.KARA_MOJI.equals(gsanSeikyYm) && !seikyYm.equals(gsanSeikyYm))
				{
					// 工事遅延明細在り
					existKojiDly = true;

					if (!JACStrConst.PRC_ADJ_DIV_DEL.equals(divAdjPrc))
					{
						// 工事遅延明細が削除でなければエラーとして処理
						for(int inNum = 0; inNum < inDataList.size(); inNum++)
						{
							updInDataListErr(inNum, JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E049);
						}
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKojiDly][this.sikyUcwkList.get(idx)=" + this.sikyUcwkList.get(idx).toString() + "]");
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKojiDly][工事遅延明細が削除でない]");
						assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKojiDly]");
						return false;
					}
				}
				else
				{
					if (JACStrConst.PRC_ADJ_DIV_ADD.equals(divAdjPrc) || JACStrConst.PRC_ADJ_DIV_DEL.equals(divAdjPrc))
					{
						// 工事遅延明細以外に追加/削除された明細が存在する
						existAddChg = true;
					}
					else
					{
						// 金額が変更されたか判定
						String amntBf =sikyUcwkMap.get(JCHbatPrcAdjChgeUtil.MAP_KEY_AJST_BF_AMNT);
						String amntAf = sikyUcwkMap.get(JCHbatPrcAdjChgeUtil.MAP_KEY_AJST_AF_AMNT);
						if (!JACStrConst.KARA_MOJI.equals(amntBf) && !JACStrConst.KARA_MOJI.equals(amntAf) && !amntBf.equals(amntAf))
						{
							// 工事遅延明細以外に変更された明細が存在する
							existAddChg = true;
						}
						// 利用開始日 利用終了日が変更されたか判定
						String usePrdDspCtrlFlg = sikyUcwkMap.get(JBSbatCH_M_PRC_KMK_OPUT_NM.USE_PRD_DSP_CTRL_FLG);
						if (usePrdDspCtrlFlg.equals(JACStrConst.USE_PRD_DSP_CTRL_FLG_ON))
						{
							String useStaYmd = sikyUcwkMap.get(JCHbatPrcAdjChgeUtil.MAP_KEY_USE_STAYMD);
							String useStaYmdBf = sikyUcwkMap.get(JCHbatPrcAdjChgeUtil.MAP_KEY_USE_STAYMD_BF);
							String useEndYmd = sikyUcwkMap.get(JCHbatPrcAdjChgeUtil.MAP_KEY_USE_ENDYMD);
							String useEndYmdBf = sikyUcwkMap.get(JCHbatPrcAdjChgeUtil.MAP_KEY_USE_ENDYMD_BF);

							if (!useStaYmd.equals(useStaYmdBf) || !useEndYmd.equals(useEndYmdBf))
							{
								// 工事遅延明細以外に変更された明細が存在する
								existAddChg = true;
							}
						}
					}
				}
			}
		}

		if(existKojiDly && existAddChg)
		{
			// 工事遅延明細が存在する場合
			if (teiseiCount != delCount)
			{
				// 請求取消でなく、工事遅延明細以外の追加・変更・削除明細が存在すればエラー
				for(int inNum = 0; inNum < inDataList.size(); inNum++)
				{
					updInDataListErr(inNum, JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E049);
				}
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][isKojiDly][請求取消でなく、工事遅延明細以外の追加・変更・削除明細が存在する]");
				assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKojiDly]");
				return false;
			}
		}
		
		// 工事遅延分が存在し、請求年月が取得できた場合
		if(existKojiDly && null != seikyYm)
		{
			// 請求年月から料金計算日を取得
			String prcCalDay = this.prcCalcDayMap.get(seikyYm);
			// 料金計算日翌日を求める
			String prcCalNextDay = JPCDateUtil.addDay(prcCalDay, 1);
			
			// 請求年月から請求処理日を取得
			String prcSeikyDay = this.prcSeikyDayMap.get(seikyYm);
			
			// オンライン運用日 < 料金計算日翌日 or 請求処理日 < オンライン運用日の場合、エラー
			if(this.onlineOpeDate.compareTo(prcCalNextDay) < 0 || this.onlineOpeDate.compareTo(prcSeikyDay) > 0)
			{
				for(int inNum = 0; inNum < inDataList.size(); inNum++)
				{
					updInDataListErr(inNum, JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E057);
				}
				
				return false;
			}
		}

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][isKojiDly]");
		return true;
	}

	/**
	 * 各種スキーマを更新します。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void updTable() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][updTable]");
		
		// 検索結果格納用マップを生成。
		HashMap<Object, Object> outputMap = new HashMap<Object, Object>();

		// 料金変更登録サービス呼び出し
		outputMap = this.execService(this.sikyUcwkList);
		
		// リターンコードを取得します。
		String rtnCd = JCCBatchEsbInterface.getReturnCode(outputMap); 
		
		// リターンコード≠"0000"（正常）の場合
		if(!JCCBatchEsbInterface.RETURN_CODE_SUCCESS.equals(rtnCd))
		{
			if(JCCBatchEsbInterface.RETURN_CODE_SINGLEDATA_ERR.equals(rtnCd))
			{
				// 単項目チェックエラー
				for(int i = 0; i < inDataList.size(); i++)
				{
					updInDataListErr(i, JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E043);
				}
			}
			else if(JCCBatchEsbInterface.RETURN_CODE_ITEM_RELATION_ERR.equals(rtnCd))
			{
				// 単関連チェックエラー
				for(int i = 0; i < inDataList.size(); i++)
				{
					updInDataListErr(i, JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E044);
				}
			}
			else if(JCCBatchEsbInterface.RETURN_CODE_RELATION_ERR.equals(rtnCd))
			{
				// 関連チェックエラー
				for(int i = 0; i < inDataList.size(); i++)
				{
					updInDataListErr(i, JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E045);
				}
			}
			else
			{
				// その他チェックエラー
				for(int i = 0; i < inDataList.size(); i++)
				{
					updInDataListErr(i, JACStrConst.WKPRA_CH_PRC_ADJ_MSG_E046);
				}
			}
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][updTable][outputMap=" + outputMap.toString() + "]");
		}
		
		// 退避．入力データリストの最初のレコードを用いて料金対応記録登録を行います。
//		this.prcTaiokrkAdd(this.inDataList.get(0));
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][updTable]");
		return;
	}

	/**
	 * 入力情報をもとに、部屋番号を取得し、その結果を返却します。
	 *
	 * @param mastMap 入力情報
	 * @return String 部屋番号
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private String getRoomNo(JBSbatServiceInterfaceMap mastMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getRoomNo]");
		// 部屋番号
		String rtnRoomNo = JACStrConst.KARA_MOJI;
		
		JBSbatCommonDBInterface whereParam = new JBSbatCommonDBInterface();
		
		// 回線内訳使用開始日
		whereParam.setValue(this.prcCalcDayMap.get(mastMap.getString(JBSbatCHIFM110.SEIKY_YM)));
		// 回線内訳使用終了日
		whereParam.setValue(this.prcCalcDayMap.get(mastMap.getString(JBSbatCHIFM110.SEIKY_YM)));
		// サービス契約番号
		whereParam.setValue(mastMap.getString(JBSbatCHIFM110.SVC_KEI_NO));
		// 予約適用年月日
		whereParam.setValue(this.prcCalcDayMap.get(mastMap.getString(JBSbatCHIFM110.SEIKY_YM)));
		// マンションＩＤ
		whereParam.setValue(mastMap.getString(JBSbatCHIFM110.MANS_ID));
		// ＣＡＴＩＤ
		whereParam.setValue(mastMap.getString(JBSbatCHIFM110.MANS_ID));
		// マンション営業案件管理番号
		whereParam.setValue(mastMap.getString(JBSbatCHIFM110.MANS_ID));
		// ＰＩＤ
		whereParam.setValue(mastMap.getString(JBSbatCHIFM110.MANS_ID));
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getRoomNo][whereParam=" + whereParam.getList().toArray() + "]");
		
		// SQL実行
		executeKK_T_SVKEI_KAISEN_UW_CH_SELECT_001(whereParam.getList().toArray());
		
		// 実行結果　取得
		JBSbatCommonDBInterface dbMap = db_KK_T_SVKEI_KAISEN_UW.selectNext();
		
		// 取得結果有の場合
		if(null != dbMap)
		{
			String strRmNo = dbMap.getString(JBSbatKK_T_SVKEI_KAISEN_UW.SKS_YO_KISN_PLACE_AD_RM_NO);
			if(strRmNo != null && !JACStrConst.KARA_MOJI.equals(strRmNo))
			{
				rtnRoomNo = dbMap.getString(JBSbatKK_T_SVKEI_KAISEN_UW.SKS_YO_KISN_PLACE_AD_RM_NO).trim();
			}
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getRoomNo][roomNo=" + rtnRoomNo + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getRoomNo]");
		return rtnRoomNo;
		
	}
	
	/**
	 * 入力情報をもとに、サービス契約番号（ダミー）を取得し、その結果を返却します。
	 * 
	 * @param mastMap 入力情報
	 * @return String サービス契約番号（ダミー）
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getSvcKeiNoDummy(JBSbatServiceInterfaceMap mastMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getSvcKeiNoDummy]");
		// サービス契約番号（ダミー）
		String rtnSvcKeiNoDmy = JACStrConst.KARA_MOJI;
		
		JBSbatCommonDBInterface whereParam = new JBSbatCommonDBInterface();
		
		// マンションＩＤ
		whereParam.setValue(mastMap.getString(JBSbatCHIFM110.MANS_ID));
		// ＣＡＴＩＤ
		whereParam.setValue(mastMap.getString(JBSbatCHIFM110.MANS_ID));
		// マンション営業案件管理番号
		whereParam.setValue(mastMap.getString(JBSbatCHIFM110.MANS_ID));
		// ＰＩＤ
		whereParam.setValue(mastMap.getString(JBSbatCHIFM110.MANS_ID));
		// 予約適用年月日
		whereParam.setValue(this.prcCalcDayMap.get(mastMap.getString(JBSbatCHIFM110.SEIKY_YM)));
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSvcKeiNoDummy][whereParam=" + whereParam.getList().toArray() + "]");
		
		// SQL実行
		executeKK_T_SVC_KEI_CH_SELECT_008(whereParam.getList().toArray());
		
		// 実行結果　取得
		JBSbatCommonDBInterface dbMap = db_KK_T_SVC_KEI.selectNext();
		
		// 取得結果有の場合
		if(null != dbMap)
		{
			tmpSvcKeiNo = dbMap.getString(JBSbatKK_T_SVC_KEI.SVC_KEI_NO);
			tmpSeiriNo = mastMap.getString(JBSbatCHIFM110.MANS_ID);
			bkMansIdMap.put(mastMap.getString(JBSbatCHIFM110.MANS_ID), dbMap.getString(JBSbatKK_T_SVC_KEI.SVC_KEI_NO));
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getSvcKeiNoDummy][svcKeiNoDmy=" + rtnSvcKeiNoDmy + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getSvcKeiNoDummy]");
		return;
		
	}
	
//	/**
//	 * XXX 巻にて実装
//	 * 請求内訳情報をもとに、部屋番号を取得し、その結果を返却します。
//	 * 
//	 * @param svcKeiNo サービス契約番号
//	 * @return String 部屋番号
//	 * @throws Exception 業務サービス内で発生した例外全般
//	 */
//	private String getRoomNo(String svcKeiNo) throws Exception
//	{
//		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getRoomNo]");
//		// 部屋番号
//		String roomNo = this.tmpRoomNo;
//		
//		JBSbatCommonDBInterface whereParam = new JBSbatCommonDBInterface();
//		
//		// サービス契約番号
//		whereParam.setValue(svcKeiNo);
//		// 回線内訳使用開始日
//		whereParam.setValue(super.onlineOpeDate);
//		// 回線内訳使用終了日
//		whereParam.setValue(super.onlineOpeDate);
//		
//		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getRoomNo][whereParam=" + whereParam.getList().toArray() + "]");
//		
//		// SQL実行
//		executeKK_T_SVKEI_KAISEN_UW_CH_SELECT_001(whereParam.getList().toArray());
//		
//		// 実行結果　取得
//		JBSbatCommonDBInterface dbMap = db_KK_T_SVKEI_KAISEN_UW.selectNext();
//		
//		// 取得結果有の場合
//		if(null != dbMap)
//		{
//			roomNo = roomNo.concat(dbMap.getString(JBSbatKK_T_SVKEI_KAISEN_UW.KAISEN_PLACE_ADRRM));
//		}
//		// 取得結果なしの場合
//		else
//		{
//			// エラーログ出力
//			String[] msgParam = new String[]{ JBSbatKK_T_SVKEI_KAISEN_UW.TABLE_NAME, whereParam.getList().toString() };
//			
//			commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECHB0240CW, msgParam);
//		}
//		
//		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getRoomNo][roomNo=" + roomNo + "]");
//		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getRoomNo]");
//		return roomNo;
//		
//	}
	
//	/**
//	 * 請求内訳情報をもとに、お客様名を取得し、その結果を返却します。
//	 * 
//	 * @param svcKeiNo
//	 * @return String お客様名
//	 * @throws Exception 業務サービス内で発生した例外全般
//	 */
//	private String getCustNm(String svcKeiNo) throws Exception
//	{
//		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getCustNm]");
//		// お客様名
//		String custNm = JACStrConst.KARA_MOJI;
//		
//		JBSbatCommonDBInterface whereParam = new JBSbatCommonDBInterface();
//		
//		// サービス契約．サービス契約番号
//		whereParam.setValue(svcKeiNo);
//		// サービス契約．サービス契約番号
//		whereParam.setValue(svcKeiNo);
//		// サービス契約．予約適用年月日
//		whereParam.setValue(super.onlineOpeDate);
//		// お客様．予約適用年月日
//		whereParam.setValue(super.onlineOpeDate);
//		
//		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getCustNm][whereParam=" + whereParam.getList().toArray() + "]");
//		
//		// SQL実行
//		executeCK_T_CUST_CH_SELECT_001(whereParam.getList().toArray());
//		
//		// 実行結果　取得
//		JBSbatCommonDBInterface dbMap = db_CK_T_CUST.selectNext();
//		
//		// 取得結果有の場合
//		if(null != dbMap)
//		{
//			custNm = dbMap.getString(JBSbatCK_T_CUST.CUST_NM);
//		}
//		// 取得結果なしの場合
//		else
//		{
//			// エラーログ出力
//			String[] msgParam = new String[]{ JBSbatCK_T_CUST.TABLE_NAME, whereParam.getList().toString() };
//			
//			commonItem.getLogPrint().printBusinessErrorLog(JPCBatchMessageConstant.ECHB0240CW, msgParam);
//		}
//		
//		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getCustNm][custNm=" + custNm + "]");
//		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getCustNm]");
//		return custNm;
//	}
	
//	// XXX 巻にて実装
//	/**
//	 * 出力情報に明細部のデータ及び、項番を追加します。
//	 * 
//	 * @param sikyUcwkInfo 請求内訳情報
//	 * @param prcKmkoptNmInf 料金項目出力名称情報
//	 * @param outputInfo 出力情報
//	 * @param roomNo 部屋番号
//	 * @param custNm お客様名
//	 * @param no 項番
//	 * @throws Exception 業務サービス内で発生した例外全般
//	 */	
//	private void setDtlInfo(HashMap<String, String> sikyUcwkInf, HashMap<String, Object> prcKmkoptNmInf, ArrayList<String> outputInfo, String roomNo, String custNm, int no) throws Exception
	
	/**
	 * 料金一括調整エラーファイル出力処理を行います。
	 * 
	 * @param outputInItem 入力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void makeOutputFile(JBSbatOutputItem outputInItem) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeOutputFile]");
		
		for(int i = 0; i < this.inDataList.size(); i++)
		{
			JBSbatServiceInterfaceMap outBean = new JBSbatServiceInterfaceMap();
			
//IT1-2014-0000164 MOD STA
//			// エラーコード
//			outBean.set(JBSbatCHIFM111.IKT_ADD_ERR_CD,  this.inDataList.get(i).get(JBSbatCHIFM111.IKT_ADD_ERR_CD));
//			// エラー内容
//			outBean.set(JBSbatCHIFM111.ERR_NYO,  this.inDataList.get(i).get(JBSbatCHIFM111.ERR_NYO));
			// エラーコード
			outBean.set(JBSbatCHIFM111.IKT_ADD_ERR_CD,  "\"" + this.inDataList.get(i).get(JBSbatCHIFM111.IKT_ADD_ERR_CD) + "\"");
			// エラー内容
			outBean.set(JBSbatCHIFM111.ERR_NYO,  "\"" + this.inDataList.get(i).get(JBSbatCHIFM111.ERR_NYO) + "\"");
//IT1-2014-0000164 MOD END
			// 料金一括調整指示ファイル
			outBean.set(JBSbatCHIFM111.PRC_IKT_ADJ_SJI_FILE, this.inDataList.get(i).get(JBSbatCHIFM118.IKT_ADD_FILE));
			
			outBean.setOutFlg(true);
			
			// 出力情報を格納
			outputInItem.addOutMapList(outBean);
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeOutputFile]");
		return;
	}
	
	/**
	 * 終了処理にて、退避．入力データリスト内の情報で料金調整制御処理を行い、ファイル出力がある場合ファイルを出力します。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void executeRemainRecord() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][executeOutputRecord]");
		
		// ファイル出力部品を取得
		JBSbatOutputFileUtil fileUtil = super.commonItem.getOutPutFile();
		// 設定されているエンコード形式を退避
		String enc = fileUtil.getEncode();
		
		// 出力定義ファイル名を取得する。
		String outFileDefName = JBSbatAplConst.getAplConstValue("OTD") + this.tmpDefFileNmErr;
		
		// 出力定義ファイルオブジェクトを生成する
		JBSbatDefFileUtil outFileDef = new JBSbatDefFileUtil(outFileDefName, fileUtil);
		// 退避したエンコード形式を戻す（出力定義ファイルオブジェクト生成時に上書きが発生しているため）
		fileUtil.setEncode(enc);
		
		// リスト内の情報をすべて出力
		JBSbatOutputItem outputInItem = new JBSbatOutputItem();
		
		// 退避．入力データリストにデータが存在している場合
		if(this.inDataList.size() > 0)
		{
			// 料金調整制御処理を実行します。
			this.prcAdjCtrl(outputInItem);
		}
		int listSize = outputInItem.getOutMapList().size();
		
		for (int i = 0; i < listSize; i++)
		{
			fileUtil.print((JBSbatServiceInterfaceMap)outputInItem.getOutMapList().get(i), outFileDef);
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][executeOutputRecord]");
	}
	
	
	/**
	 * 引数で渡された退避．入力データリストのインデックスと業務機能識別コードを基に対象レコードをエラーとして処理します。
	 * 
	 * @param index 退避．入力データリストの対象インデックス
	 * @param wkpara 業務識別コード
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void updInDataListErr(int index, String wkpara) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][updInDataListErr]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][updInDataListErr][index=" + String.valueOf(index) + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][updInDataListErr][inDataList.get(index)=" + this.inDataList.get(index).toString() + "]");
		
		// 退避．処理グループ番号エラーフラグ更新
		this.tranGrpNoErrFrg = FLG_ON;
		
		// 退避．入力データリスト->エラーコード
		this.inDataList.get(index).put(JBSbatCHIFM111.IKT_ADD_ERR_CD,	this.errNaiyoMap.get(wkpara).get(ERR_NAIYO_MAP_ERR_CD));
		// 退避．入力データリスト->エラー内容
		this.inDataList.get(index).put(JBSbatCHIFM111.ERR_NYO,			this.errNaiyoMap.get(wkpara).get(ERR_NAIYO_MAP_ERR_NAIYO));
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][updInDataListErr][inDataList.get(index)=" + this.inDataList.get(index).toString() + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][updInDataListErr]");
		return;
	}
	
	/**
	 * 引数で渡されたマップの料金コースコード、料金サービスコード、料金項目コードを結合し、返却します。
	 * 
	 * @param trgMap 対象マップ
	 * @param trgFlg 対象マップのキー制御フラグ（true:債権内訳の各項目、false:それ以外）
	 * @return String 結合文字
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private String makeKey(HashMap<String, String> trgMap, boolean trgFlg) throws Exception
	{
		StringBuffer buf = new StringBuffer();
		// 債権内訳の場合
		if(trgFlg)
		{
			// 債権内訳．料金コースコード
			buf.append(trgMap.get(SAIKEN_UCWK_PCRS_CD));
			// 債権内訳．料金サービスコード
			buf.append(trgMap.get(SAIKEN_UCWK_PRC_SVC_CD));
			// 債権内訳．料金項目コード
			buf.append(trgMap.get(SAIKEN_UCWK_PRC_KMK_CD));
		}
		// 上記以外の場合
		else
		{
			// 料金コースコード
			buf.append(trgMap.get(JBSbatCHIFM110.PCRS_CD));
			// 料金サービスコード
			buf.append(trgMap.get(JBSbatCHIFM110.PRC_SVC_CD));
			// 料金項目コード
			buf.append(trgMap.get(JBSbatCHIFM110.PRC_KMK_CD));
		}
		return buf.toString();
	}

	/**
	 * 料金調整登録サービス呼び出し<br>
	 * @param paramList inputリスト
	 * @throws Exception
	 */
	private HashMap<Object, Object> execService(List<HashMap<String, String>> paramList) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execService]");

		// ユースケースIDを格納するMAP
		HashMap<String, String> paramMap = new HashMap<String, String>();

		// ユースケースIDを設定
		paramMap.put(JCCBatchEsbInterface.TELEGRAM_INFO_USECASE_ID, JCHbatPrcAdjChgeUtil.USECASE_ID_ADJ);

		// サービスに渡す業務データを格納するMAP
		HashMap<String, HashMap<String, Object>> inputMap = new HashMap<String, HashMap<String, Object>>();

		// 料金調整、料金変更共通部品オブジェクト生成
		JCHbatPrcAdjChgeUtil prcAdjChgeUtil = new JCHbatPrcAdjChgeUtil(commonItem);

		// 入力ファイル→料金調整登録SCマッピング
		prcAdjChgeUtil.mapping2JKanryoSC1(inputMap, paramList, svcMap, shoriGroupMap, JCHbatPrcAdjChgeUtil.SHORI_KBN_ADJ);

		// 入力ファイル→電子ファイル管理登録SCマッピング
		prcAdjChgeUtil.mapping2KanryoSC2(inputMap, paramList, svcMap, shoriGroupMap);

		// 入力ファイル→料金調整変更リスト作成CCマッピング
		prcAdjChgeUtil.mapping2JCHPrcChoseiHenkoCreateCC(inputMap, paramList, userMap, shoriGroupMap);

		// 入力ファイル→対応記録登録料金用CCマッピング
		prcAdjChgeUtil.mapping2JACTaioKirokAddCC(inputMap, paramList, svcMap, userMap, shoriGroupMap);

		// 入力ファイル→対応記録ホットボイス登録CCマッピング
		prcAdjChgeUtil.mapping2JCRAddHotVoicCC(inputMap);

		// 入力ファイル→料金調整登録SCマッピング
		prcAdjChgeUtil.mapping2JCHPrcTaioKirokAddCC(inputMap, paramList, svcMap, userMap, shoriGroupMap);

		// サービスの処理結果が格納されるMAP
		HashMap<Object, Object> outputMap = new HashMap<Object, Object>();

		// サービス呼び出し
		JCCBatchEsbInterface.invokeService(super.commonItem, paramMap, inputMap, outputMap);

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][execService]");

		return outputMap;
	}

	/**
	 * 請求番号・債権番号を取得します。
	 * 
	 * @param mastMap 入力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void selectSeikyNo() throws Exception
	{
		JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
		
		// 請求契約番号
		whereMap.setValue(this.shoriGroupMap.get(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_KEI_NO));
		// 請求年月
		whereMap.setValue(this.shoriGroupMap.get(JCHbatPrcAdjChgeUtil.MAP_KEY_SEIKY_YM));
		// 請求種別コード
		whereMap.setValue(JACStrConst.SIKYSHBTS_TEIGK_SEIKY);
		
		// SQL実行
		executeCH_T_SEIKY_CH_SELECT_041(whereMap.getList().toArray());
		
		return;
	}

	/**
	 * 料金計算日のイベント年月日を取得します。
	 * 
	 * @param mastMap 入力情報
	 * @return 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private HashMap<String, String> getEventYmd() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getEventYmd]");

		JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
		HashMap<String, String> rtnMap = new HashMap<String, String>(); 
		
		// イベントコード
		whereMap.setValue(JACStrConst.EVENT_CD_PRC_CALC_DAY);
		
		// SQL実行
		executeCH_M_PRC_SCHDL_TEIGI_AC_SELECT_012(whereMap.getList().toArray());
		
		// 結果取得
		JBSbatCommonDBInterface dbMap = db_CH_M_PRC_SCHDL_TEIGI.selectNext();

		// 取得結果なしの場合
		if(null == dbMap)
		{
			// 異常終了
			String[] msgParam = new String[]{JBSbatCH_M_PRC_SCHDL_TEIGI.TABLE_NAME, whereMap.getList().toString()};
			throw new JBSbatBusinessException(JPCBatchMessageConstant.ECHB0270CH, msgParam);
		}
		
		while(dbMap != null)
		{
			String seikyYm = dbMap.getString(JBSbatCH_M_PRC_SCHDL_TEIGI.SEIKY_YM);
			String eventYmd = dbMap.getString(JBSbatCH_M_PRC_SCHDL_TEIGI.EVENT_YMD);
			
			// 請求年月をキーにイベント年月日をもつ
			rtnMap.put(seikyYm, eventYmd);
			dbMap = db_CH_M_PRC_SCHDL_TEIGI.selectNext();
		}

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getEventYmd]");
		return rtnMap;
	}
	
	/**
	 * 請求処理日のイベント年月日を取得します。
	 * 
	 * @param mastMap 入力情報
	 * @return 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private HashMap<String, String> getEventYmdSeiky() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getEventYmd]");

		JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
		HashMap<String, String> rtnMap = new HashMap<String, String>(); 
		
		// イベントコード
		whereMap.setValue(JACStrConst.EVENT_CD_SIKY_TRN_DAY);
		
		// SQL実行
		executeCH_M_PRC_SCHDL_TEIGI_AC_SELECT_012(whereMap.getList().toArray());
		
		// 結果取得
		JBSbatCommonDBInterface dbMap = db_CH_M_PRC_SCHDL_TEIGI.selectNext();

		// 取得結果なしの場合
		if(null == dbMap)
		{
			// 異常終了
			String[] msgParam = new String[]{JBSbatCH_M_PRC_SCHDL_TEIGI.TABLE_NAME, whereMap.getList().toString()};
			throw new JBSbatBusinessException(JPCBatchMessageConstant.ECHB0270CH, msgParam);
		}
		
		while(dbMap != null)
		{
			String seikyYm = dbMap.getString(JBSbatCH_M_PRC_SCHDL_TEIGI.SEIKY_YM);
			String eventYmd = dbMap.getString(JBSbatCH_M_PRC_SCHDL_TEIGI.EVENT_YMD);
			
			// 請求年月をキーにイベント年月日をもつ
			rtnMap.put(seikyYm, eventYmd);
			dbMap = db_CH_M_PRC_SCHDL_TEIGI.selectNext();
		}

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getEventYmd]");
		return rtnMap;
	}
	
// OM-2015-0000082 ADD START
	/**
	 * 請求オプション料金プランマップ設定
	 * @throws Exception 
	 */
	private void setSeiopPplanMap() throws Exception
	{
		// ＤＢアクセス用のパラメータ定義
		JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();
		
		// 対象キーの設定
		dbList.setValue(super.onlineOpeDate);	// 料金コース適用開始年月日
		dbList.setValue(super.onlineOpeDate);	// 料金コース適用終了年月日
		dbList.setValue(super.onlineOpeDate);	// 請求オプションサービス適用開始年月日
		dbList.setValue(super.onlineOpeDate);	// 請求オプションサービス適用終了年月日
		dbList.setValue(super.onlineOpeDate);	// 予約適用年月日
		dbList.setValue(super.onlineOpeDate);	// 料金プラン適用開始年月日
		dbList.setValue(super.onlineOpeDate);	// 料金プラン適用終了年月日
		
		// 請求オプション料金プラン取得
		executeKK_M_PPLAN_CH_SELECT_002(dbList.getList().toArray());
		
		JBSbatCommonDBInterface dbMap = null;
		
		while(null != (dbMap = db_KK_M_PPLAN.selectNext()))
		{
			this.seiopPplanMap.put(dbMap.getString(JBSbatKK_M_PPLAN.PPLAN_CD), dbMap.getString(JBSbatKK_M_PPLAN.PPLAN_CD));
		}
	}
	
	/**
	 * SQLKEY(CH_SELECT_002)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	料金コース適用開始年月日
	 *		 	料金コース適用終了年月日
	 *		 	請求オプションサービス適用開始年月日
	 *		 	請求オプションサービス適用終了年月日
	 *		 	予約適用年月日
	 *		 	料金プラン適用開始年月日
	 *		 	料金プラン適用終了年月日
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_M_PPLAN_CH_SELECT_002(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());
		paramList.setValue(param[5].toString());
		paramList.setValue(param[6].toString());

		// DBアクセスを実行します
		db_KK_M_PPLAN.selectBySqlDefine(paramList, KK_M_PPLAN_CH_SELECT_002);
	}
// OM-2015-0000082 ADD END
}