/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom						 *
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatACEMUseKoInfTrkm
*	ソースファイル名	：JBSbatACEMUseKoInfTrkm.java
*	作成者				：富士通　
*	作成日				：2011年06月24日
*＜機能概要＞
*　ＥＭ利用呼情報取込部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2011/06/24   富士通		新規作成
*	v3.00		2012/07/30   FJ）冨井	【ST1-2012-0000186】利用バイト数（ゼロパディング）
*	v3.01		2012/08/17   FJ）岡田	【ST1-2012-0000325】サービス契約内訳番号未設定対応
*	v3.02		2012/09/05   FJ）岡田	【ST1-2012-0000397】利用バイト数（ゼロパディング）
*	v4.00		2012/09/22   FJ）冨井	【ANK-0143-00-00】ＥＭ利用呼情報（法人分トレーラ部）ファイル出力判定追加
*	v4.01		2012/12/27   FJ）垣内	【TG1-2012-0000204】料金計算結果リスト「CDR課金なしエラー」の明細不備
*	v4.02		2013/01/17   FJ）高田	【ST4-2013-0000051】DBアクセスの改善・配列更新化
*	v4.03		2013/02/07   FJ) 早崎	【TG1-2013-0000041】モバイル通信明細の通話開始/終了年月日時分秒がアンマッチ
*	v4.04		2013/04/05   FJ) 小柴	【IKK-2013-0000783】文字化け対策のため、エンコード形式の変更
*	v4.05		2013/03/26   FJ) 後藤	【ST4-2013-0000208】性能改善
*	v4.06		2013/05/23   FJ) 早崎	【TG1-2013-0000474】料金計算結果リスト出力後、後続処理を行わない
*	v5.00		2013/07/03   FJ) 前田	【IT1-2013-0001420】ワーニングメッセージを出力
*	v5.01		2013/07/09   FJ) 大戸	【TG1-2013-0000662】マスタ参照基準日対応
*	v8.00		2013/12/17   FJ）柴田	【ANK-1584-00-00】出力ファイルにサービス詳細識別番号を追加。
*	v8.01		2014/01/16   FJ）伊藤	【ANK-1589-00-00】増税対応の為、従量料金マスタの参照方法を変更
*	v8.02		2014/03/19   FJ）北端	【TG1-2014-0000005】従量料金マスタ参照の基準日を変更
*	v10.00		2014/09/24   FJ）沖田	【OM-2014-0003009】通信通話利用開始情報（モバイル）のIF作成条件を修正
*	v10.01		2014/09/29   FJ）鈴木	【OM-2014-0003009】通信通話利用開始情報（モバイル）のIF作成条件を修正
*********************************************************************/
package eo.business.service;

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

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.JCCBatCommon;
import eo.business.common.JCHbatSeikyKaknoBusinessUtil;
import eo.business.util.file.JBSbatACIFM028;
import eo.business.util.file.JBSbatACIFM029;
import eo.business.util.file.JBSbatACIFM216;
import eo.business.util.file.JBSbatKKIFI030;
import eo.business.util.table.JBSbatAC_M_JURYOPRC;
import eo.business.util.table.JBSbatAC_T_EOMOBA_DTL;
import eo.business.util.table.JBSbatCH_M_PRC_KMK_CS_CHGE;
import eo.business.util.table.JBSbatKK_T_KAKINS;
import eo.business.util.table.JBSbatKK_T_SVC_KEI;
import eo.business.util.table.JBSbatKK_T_SVC_KEI_EOMOBA;
import eo.business.util.table.JBSbatZM_M_CD_NM_KANRI;
import eo.business.util.table.JBSbatZM_M_WORK_PARAM_KNRI;
import eo.common.constant.JACStrConst;
import eo.common.constant.JPCBatchMessageConstant;
import eo.common.constant.JZM0171Constant;
import eo.common.util.JPCDateUtil;
import eo.common.util.JPCUtilCommon;
import eo.framework.item.JBSbatCommonItem;
import eo.framework.item.JBSbatServiceInterfaceMap;
import eo.framework.item.JBSbatOutputItem;
import eo.framework.item.JBSbatCommonDBInterface;
import eo.framework.util.JBSbatAplConst;
import eo.framework.util.JBSbatBusinessFileUtil;
import eo.framework.util.JBSbatDateUtil;
import eo.framework.application.JBSbatBusinessException;
import eo.framework.db.JBSbatSQLAccess;
import eo.framework.file.JBSbatDefFileUtil;
import eo.framework.file.JBSbatOutputFileUtil;

/**
* (クラスの機能概要) <p>
*<BR>
* @author 富士通
*/
public class JBSbatACEMUseKoInfTrkm extends JBSbatBusinessService implements JBSbatMatchServiceInterface
{
	/**▼▼▼▼▼▼ツールから生成した宣言です 開始▼▼▼▼▼▼*/
	/** テーブル(業務パラメータ管理)*/
	private static final String D_TBL_NAME_ZM_M_WORK_PARAM_KNRI = "ZM_M_WORK_PARAM_KNRI";

	/** テーブル(従量料金)*/
	private static final String D_TBL_NAME_AC_M_JURYOPRC = "AC_M_JURYOPRC";

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

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

	/** テーブル(ｅｏモバイル明細)*/
	private static final String D_TBL_NAME_AC_T_EOMOBA_DTL = "AC_T_EOMOBA_DTL";

	/** テーブル(サービス契約＜ｅｏモバイル＞)*/
	private static final String D_TBL_NAME_KK_T_SVC_KEI_EOMOBA = "KK_T_SVC_KEI_EOMOBA";

	/** テーブル(コード名称管理)*/
	private static final String D_TBL_NAME_ZM_M_CD_NM_KANRI = "ZM_M_CD_NM_KANRI";

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

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

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

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

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

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

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

	/** テーブルアクセスクラス(業務パラメータ管理)*/
	private JBSbatSQLAccess db_ZM_M_WORK_PARAM_KNRI = null;

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

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

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

	/** テーブルアクセスクラス(ｅｏモバイル明細)*/
	private JBSbatSQLAccess db_AC_T_EOMOBA_DTL = null;
	private JBSbatSQLAccess db_AC_T_EOMOBA_DTL_INI = null;
	private JBSbatSQLAccess db_AC_T_EOMOBA_DTL_UPD = null;

	/** テーブルアクセスクラス(サービス契約＜ｅｏモバイル＞)*/
	private JBSbatSQLAccess db_KK_T_SVC_KEI_EOMOBA = null;

	/** テーブルアクセスクラス(コード名称管理)*/
	private JBSbatSQLAccess db_ZM_M_CD_NM_KANRI = null;

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

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

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

	/** 空文字 */
	private static final String KARA_MOJI = "";

	/** 出力ファイル定義 */
	private static final String PRM_OTD = "OTD";

	/** EM利用呼情報(法人分トレーラ部)格納用リスト */
	private ArrayList<Object> outInfTrailer = null;

	/** 集計対象請求年月 */
	HashMap<String, ArrayList<Object>> outSeikyYm = null;
	
	/** トレーラ部レコードタイプ */
	private String trailerRecType = null;

	/** トレーラ部予備 */
	private String trailerYobi = null;

	/** EM利用呼情報 */
	private String emUseKoInf = null;

	/** バッチ運用年月日 */
	private String opeYmd = null;

	/** サービス請求契約番号エラー */
	private String msgSvcKeiNoErr = null;
	
	/** 退避．料金項目マップ*/
	private HashMap<String, JBSbatCommonDBInterface> prcKmkMap = null;
	
	/** 退避．従量料金情報マップ*/
	private HashMap<String, JBSbatCommonDBInterface> tihJuryoPrcMap = null;
	
	/** 請求収納業務共通クラス */
	private JCHbatSeikyKaknoBusinessUtil seikyKaknoBusinessUtil = null;
	
	/** 固定値：桁数(利用バイト数) */
	private static final int USE_BYTE_CNT_LENGTH = 19;
	
	/** 固定値：桁数(通信開始・終了年月日時分秒) */
	private static final int TSUSHIN_STA_END_DTM_LENGTH = 14;
	
	/** 料金計算結果内容コード */
	private String prcClcRsltCd = JACStrConst.KARA_MOJI;

	/** 料金計算結果内容コード種別名 */
	private String prcRsltNyo = JACStrConst.KARA_MOJI;

	/** コード名称管理情報マップ */
	private HashMap<String, String> cdNmKnriInfMap = null;
	
	/** バッチ運用日をもとに料金スケジュールの利用終了日を基準として取得した請求年月 */
	private String seikyYm = null;
	
	/** 料金計算結果リスト出力フラグ(課金対象従量サービス契約蓄積) */
	private final String PRCCALC_CHRG = "1";
	
	/** 料金計算結果リスト出力フラグ(サービス契約＜ｅｏモバイル＞) */
	private final String PRCCALC_EOMB = "2";

	/** フリー項目 */
	private String[] files = null;

	/** ＥＭ利用呼情報(法人分データ部) */
	private JBSbatBusinessFileUtil hojinDataFileUtil = null;

	/** 再集計対象情報 */
	private JBSbatBusinessFileUtil reShukFileUtil = null;

	/** 料金計算結果リスト情報 */
	private JBSbatBusinessFileUtil prcCalcFileUtil = null;
	
	/** ＥＭ利用呼情報(法人分データ部)件数 */
	private int hojinDataCnt = 0;
	
	/** 連結文字列 */
	private StringBuffer strBuf = new StringBuffer();

	/** エラーカウンタ */
	private int errCnt = 0;
	
	/** 料金スケジュール部品 */
	private JACbatSchdlUtil su = null;

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

		// DBアクセスクラスを生成します
		db_ZM_M_WORK_PARAM_KNRI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_ZM_M_WORK_PARAM_KNRI);
		db_AC_M_JURYOPRC = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AC_M_JURYOPRC);
		db_CH_M_PRC_KMK_CS_CHGE = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CH_M_PRC_KMK_CS_CHGE);
		db_KK_T_SVC_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SVC_KEI);
		db_AC_T_EOMOBA_DTL = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AC_T_EOMOBA_DTL);
		db_AC_T_EOMOBA_DTL_INI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AC_T_EOMOBA_DTL);
		db_AC_T_EOMOBA_DTL_UPD = new JBSbatSQLAccess(commonItem, D_TBL_NAME_AC_T_EOMOBA_DTL);
		db_KK_T_SVC_KEI_EOMOBA = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SVC_KEI_EOMOBA);
		db_ZM_M_CD_NM_KANRI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_ZM_M_CD_NM_KANRI);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][initial]");
		
		// バッチ運用日付を取得
		opeYmd = super.opeDate;
		
		// 料金スケジュール部品を取得
		su = new JACbatSchdlUtil(commonItem);
		
		// 退避．従量料金情報マップを初期化
		tihJuryoPrcMap = new HashMap<String, JBSbatCommonDBInterface>();
		
		// エラーメッセージを取得
		msgSvcKeiNoErr = getWorkParamVal(JACStrConst.WKPARA_AC_MSG_SVCKEINOERR, opeYmd);
		
		JACbatParamUtil paramUtil = new JACbatParamUtil(commonItem);
		
		// ＥＭ利用呼情報を取得
		emUseKoInf = paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AC_WKS_EM_USR_KO_INF);
		this.prcClcRsltCd = paramUtil.getGyoumuParameter(JACStrConst.WKPARA_AC_RSLT_CDR);
		
		paramUtil.close();
		
		// 出力料金項目コード取得用マップ作成
		makePrcKmkMap();
		
		// ファイル名を取得
		String freeItem = commonItem.getFreeItem();
		files = freeItem.split(JACStrConst.FREE_DIV);
		
		// ファイル定義情報(データ部)
		JBSbatOutputFileUtil dataFile = new JBSbatOutputFileUtil(files[1]);
		String dataFileDefName = JBSbatAplConst.getAplConstValue(PRM_OTD) + files[0];
		JBSbatDefFileUtil dataFileDef = new JBSbatDefFileUtil(dataFileDefName, dataFile);
		hojinDataFileUtil = JCCBatCommon.createBusinessFileUtil(files[1], dataFile.getEncode(), JACBatCommon.chgKaigyo(dataFile.getLine()), dataFileDef.getDelimiter());
		
		// 再集計対象情報
		JBSbatOutputFileUtil seikyYmFile = new JBSbatOutputFileUtil(files[5]);
		String seikyYmFileDefName = JBSbatAplConst.getAplConstValue(PRM_OTD) + files[4];
		JBSbatDefFileUtil seikyYmFileDef = new JBSbatDefFileUtil(seikyYmFileDefName, seikyYmFile);
		reShukFileUtil = JCCBatCommon.createBusinessFileUtil(files[5], seikyYmFile.getEncode(), JACBatCommon.chgKaigyo(seikyYmFile.getLine()), seikyYmFileDef.getDelimiter());
		
		// 料金計算結果リスト情報取得
		JBSbatOutputFileUtil errInfoFile = new JBSbatOutputFileUtil(files[7]);
		String errInfoFileDefName = JBSbatAplConst.getAplConstValue(PRM_OTD) + files[6];
		JBSbatDefFileUtil errInfoFileDef = new JBSbatDefFileUtil(errInfoFileDefName, errInfoFile);
		// 料金計算結果リスト情報出力
		prcCalcFileUtil = JCCBatCommon.createBusinessFileUtil(files[7], errInfoFile.getEncode(), JACBatCommon.chgKaigyo(errInfoFile.getLine()), errInfoFileDef.getDelimiter());
		
		// EM利用呼情報(法人分トレーラ部)格納用リストの初期化
		outInfTrailer = new ArrayList<Object>();
		// 集計対象請求年月格納用リストの初期化
		outSeikyYm = new HashMap<String, ArrayList<Object>>();
		
		this.seikyKaknoBusinessUtil = new JCHbatSeikyKaknoBusinessUtil(commonItem);
		
		this.cdNmKnriInfMap = new  HashMap<String, String>();
		
		// コード名称管理検索
		this.getCdNmKnriInf();
		
		// コード種別名検索
		this.prcRsltNyo = this.getRsltNyo(this.prcClcRsltCd);
		
		// イベントコード（利用終了日）に対する請求年月を取得する
		seikyYm = su.getBillDate(super.opeDate, JACStrConst.EVENT_CD_USE_ENDYMD);
		
		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]");
		
		// フラグの設定(各レコード1回ずつ処理するため)
		setMastProcFlg(true);
		setTranProcFlg(true);

		// トレーラ部のレコード存在チェック
		if (tranMap != null)
		{
			// 存在する場合

			// トレーラ部から情報取得
			trailerRecType = tranMap.getString(JBSbatACIFM028.REC_TYPE);
			trailerYobi = tranMap.getString(JBSbatACIFM028.YOBI);
		}
		
		// データ部のレコードが存在しない場合、次のレコード処理へ
		if (mastMap == null)
		{
			return outputInItem;
		}

		// 出力共通電文を生成
		JBSbatOutputItem outputBean = new JBSbatOutputItem();
		// ＥＭ法人契約番号を取得
		String emHojinKshCd = mastMap.getString(JBSbatACIFM216.EM_HOJIN_KEI_NO);
		// 利用バイト数を取得
		BigDecimal useByteCnt = new BigDecimal(mastMap.getString(JBSbatACIFM216.USE_BYTE_CNT));

		// 通信利用日を取得
		String tsushinUseYmd = mastMap.getString(JBSbatACIFM216.TSUSHIN_USE_DAY);

		// 法人判定
		if(!emHojinKshCd.equals(JACStrConst.KARA_MOJI))
		{
			// 法人分の場合
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute] 法人データ（ＥＭ法人契約番号：" + emHojinKshCd + "）");

			// ＥＭ利用呼情報(法人分データ部)の生成
			ArrayList<Object> hjinEMUseKoInfData = new ArrayList<Object>();
			// ＥＭ利用呼情報(法人分データ部)に値を設定
			hjinEMUseKoInfData.add(mastMap.getString(JBSbatACIFM216.REC_TYPE));
			hjinEMUseKoInfData.add(mastMap.getString(JBSbatACIFM216.SIJGSHA_KANRI_CD));
			hjinEMUseKoInfData.add(mastMap.getString(JBSbatACIFM216.MSISDN));
			hjinEMUseKoInfData.add(mastMap.getString(JBSbatACIFM216.EM_KEISHA_CD));
			hjinEMUseKoInfData.add(mastMap.getString(JBSbatACIFM216.TSUSHIN_USE_DAY));
			hjinEMUseKoInfData.add(seikyKaknoBusinessUtil.fillString(JCHbatSeikyKaknoBusinessUtil.FillType.Zero
					, mastMap.getString(JBSbatACIFM216.USE_BYTE_CNT), USE_BYTE_CNT_LENGTH, false));
			hjinEMUseKoInfData.add(mastMap.getString(JBSbatACIFM216.YOBI));
			// ＥＭ利用呼情報(法人分データ部)格納用リストにＥＭ利用呼情報(法人分データ部)を追加
			JCCBatCommon.printBusinessFileUtil(hojinDataFileUtil, hjinEMUseKoInfData);
			
			hojinDataCnt++;
			
			// nullを返却
			return outputInItem;
		}

		// 法人データ判断で法人と判断されなかったデータに対し、以下のデータチェックを行う

		String seikyYm = mastMap.getString(JBSbatACIFM216.SEIKY_YM);
		String inSvcKeiNo = mastMap.getString(JBSbatACIFM216.SVC_KEI_NO);
		String inFirstPctHasseiYmd = mastMap.getString(JBSbatACIFM216.FIRST_PCT_HASSEI_YMD);
		String svcKeiNo = null;
		String sikyKeiNo = null;
		String pcrsCd = null;
		String prcSvcCd = null;
		String outPrcCalcRstFlg = null;
		String svcDslYmd = null;
		
			// レコードの存在チェック
		if (!inSvcKeiNo.equals(JACStrConst.KARA_MOJI))
		{
			// サービス契約番号を取得
			svcKeiNo = inSvcKeiNo;
		}

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute] データチェック サービス契約番号：" + svcKeiNo);
		
		// サービス契約番号存在チェック
		if (svcKeiNo == null || KARA_MOJI.equals(svcKeiNo.trim())) 
		{
			
			String emKshCd = mastMap.getString(JBSbatACIFM216.EM_KEISHA_CD);
			// サービス契約＜ｅｏモバイル＞から情報取得
			JBSbatCommonDBInterface record2 = this.getSvcKeiMobile(emKshCd);

			if(record2 != null)
			{
				// サービス契約番号を取得
				svcKeiNo = record2.getString(JBSbatKK_T_SVC_KEI_EOMOBA.SVC_KEI_NO);
			}

			// サービス契約番号存在チェック
			if (svcKeiNo == null || KARA_MOJI.equals(svcKeiNo.trim())) 
			{
				// エラーデータの生成
				JBSbatServiceInterfaceMap errData = createErrorData(mastMap, msgSvcKeiNoErr);
				// 出力共通電文にエラーデータを設定
				outputBean.addOutMapList_2(errData);
				// 出力共通電文を返却
				return outputBean;
			}
			else
			{
				// 請求契約番号を取得
				sikyKeiNo = record2.getString(JBSbatKK_T_KAKINS.SEIKY_KEI_NO);
				// 料金コースコード
				pcrsCd = record2.getString(JBSbatKK_T_SVC_KEI.PCRS_CD);
				// 料金サービスコード
				prcSvcCd = JACbatRknBusinessUtil.fillHalfSpace(record2.getString(JBSbatKK_T_SVC_KEI.PPLAN_CD), JACStrConst.PRC_SVC_CD_LENGTH, true);
				// 料金計算結果リスト出力内容判定フラグ
				outPrcCalcRstFlg = PRCCALC_EOMB;
			}
		}
		else
		{
			// 請求契約番号を取得
			sikyKeiNo = mastMap.getString(JBSbatACIFM216.SEIKY_KEI_NO);
			// 料金コースコード
			pcrsCd = mastMap.getString(JBSbatACIFM216.PCRS_CD);
			// 料金サービスコード
			prcSvcCd = mastMap.getString(JBSbatACIFM216.PRC_SVC_CD);
			// サービス解約日
			svcDslYmd = mastMap.getString(JBSbatACIFM216.SVC_DSL_YMD);
			// 料金計算結果リスト出力内容判定フラグ
			outPrcCalcRstFlg = PRCCALC_CHRG;
		}

		// 月初日、締め日　←　JACbatSchdlUtil.getUseStrEnd(請求年月, イベントコード("01"（利用開始日））, イベントコード（"02"（利用終了日））)
		String[] tushinSeikyYmd = su.getUseStrEnd(seikyYm, JACStrConst.EVENT_CD_USE_STAYMD, JACStrConst.EVENT_CD_USE_ENDYMD);
		String tushinSeikyEndYmd = tushinSeikyYmd[1];

		// 条件に使用する相対番号を取得
		String aitaiNo = JACStrConst.AITAI_NO_SP;
		// キー作成
		// 料金コースコード　＋　料金サービスコード　＋　1:課税　＋　相対番号　＋　請求年月の月末日
		String key = makeStr(pcrsCd, prcSvcCd, JACStrConst.KAZEI_HIKAZEI_CD_KAZEI, aitaiNo , tushinSeikyEndYmd);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][execute] 従量料金検索キー：" + key);
		
		// MAPキーの存在判定
		if(!tihJuryoPrcMap.containsKey(key))
		{
			// キーが存在しない場合

			// 従量料金の取得
			makeJuryoPrcInfoMap(tushinSeikyEndYmd);
		}
		
		JBSbatCommonDBInterface dbMap = tihJuryoPrcMap.get(key);
		
		if(dbMap == null)
		{
			// レコードが存在しない場合

			// 業務例外
			throw new JBSbatBusinessException(JPCBatchMessageConstant.EACB0440CE, new String[] {JBSbatAC_M_JURYOPRC.TABLE_NAME});
		}
		
		// 料金項目コードを取得・課金単位・単位料金を取得
		String prcKmkCd = dbMap.getString(JBSbatAC_M_JURYOPRC.PRC_KMK_CD);
		// 課金単位を取得
		BigDecimal chrgTani = new BigDecimal(dbMap.getString(JBSbatAC_M_JURYOPRC.CHRG_TANI));
		// 単位料金を取得
		BigDecimal taniPrc = new BigDecimal(dbMap.getString(JBSbatAC_M_JURYOPRC.TANI_PRC));
		// 出力料金項目コードを取得
		String outPrcKmkCd = getOutPrcKmkCd(emUseKoInf, pcrsCd, prcSvcCd, prcKmkCd, seikyYm);
		// 利用パケット数を算出
		BigDecimal usePctCnt = (useByteCnt.divide(chrgTani.multiply(taniPrc), 0, RoundingMode.UP));

		// 料金計算結果リスト出力
		if(outPrcCalcRstFlg.equals(PRCCALC_CHRG))
		{
			// サービス解約日 + ２ヶ月 < 通信利用日
			if(!(svcDslYmd == null || svcDslYmd.equals(JACStrConst.KARA_MOJI)))
			{
				svcDslYmd = JBSbatDateUtil.adjustMonth(svcDslYmd, 2);
				if(svcDslYmd.compareTo(tsushinUseYmd) < 0)
				{
					ArrayList<Object> errInfoData = this.getOutputInf(svcKeiNo, sikyKeiNo, pcrsCd, prcSvcCd, outPrcKmkCd, usePctCnt);
					JCCBatCommon.printBusinessFileUtil(prcCalcFileUtil, errInfoData);
					
					return outputBean;
				}
			}
		}
		else if(outPrcCalcRstFlg.equals(PRCCALC_EOMB))
		{
			
			ArrayList<Object> errInfoData = this.getOutputInf(svcKeiNo, sikyKeiNo, pcrsCd, prcSvcCd, outPrcKmkCd, usePctCnt);
			JCCBatCommon.printBusinessFileUtil(prcCalcFileUtil, errInfoData);
			
			return outputBean;
			
//			// 初回パケット発生年月日・eoモバイル明細再取得
//			inFirstPctHasseiYmd = createFirstChrgInfo(svcKeiNo, opeYmd, tsushinUseYmd);
//			getEmDtl(svcKeiNo, pcrsCd, prcSvcCd, seikyYm, tsushinUseYmd, mastMap);
		}
		
		// 初回課金情報作成判定
		// OM-2014-0003009 MOD START
//		if (inFirstPctHasseiYmd == null || inFirstPctHasseiYmd.compareTo(tsushinUseYmd) <= 0)
		// 2014.09.29 OM-2014-0003009 MOD START
//		if (inFirstPctHasseiYmd == null || inFirstPctHasseiYmd.compareTo(tsushinUseYmd) > 0)
		if (inFirstPctHasseiYmd == null || "".equals(inFirstPctHasseiYmd) || inFirstPctHasseiYmd.compareTo(tsushinUseYmd) > 0)
		// 2014.09.29 OM-2014-0003009 MOD END
		// OM-2014-0003009 MOD END
		{
			// 初回課金情報を作成する場合
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute] 初回課金情報作成対象");
			// 初回課金情報を生成
			JBSbatServiceInterfaceMap firstChrgInfData = createFirstChrgInf(svcKeiNo, tsushinUseYmd);
			// 出力共通電文に初回課金情報を設定
			outputBean.addOutMapList(firstChrgInfData);
		}
		
		// レコードの存在確認
		if (mastMap.getString(JBSbatACIFM216.TSUSHIN_STA_DTM).equals(JACStrConst.KARA_MOJI)) 
		{
			// データが存在しない場合
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute] eoモバイル明細 登録対象");
			// eoモバイル明細の登録処理
			insertEoMobaDtl(mastMap, useByteCnt, usePctCnt, svcKeiNo, null, pcrsCd, outPrcKmkCd, sikyKeiNo, seikyYm, outPrcKmkCd, prcSvcCd);
		}
		else
		{
			// データが存在する場合
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute] eoモバイル明細 更新対象");
			// eoモバイル明細の更新処理
			updateEoMobaDtl(useByteCnt, usePctCnt, mastMap, pcrsCd, prcSvcCd);
		}

		
		// 集計対象請求年月に追加
		// キーを作成（重複除外用）
		String tmpKey = makeStr(seikyYm, 
								sikyKeiNo, 
								svcKeiNo);
		
		// 重複チェック
		if(!this.outSeikyYm.containsKey(tmpKey)){
			ArrayList<Object> seikyYmData = new ArrayList<Object>();
			seikyYmData.add(seikyYm);
			seikyYmData.add(sikyKeiNo);
			seikyYmData.add(svcKeiNo);
			seikyYmData.add(JACStrConst.KARA_MOJI);
			seikyYmData.add(JACStrConst.KARA_MOJI);
			
			this.outSeikyYm.put(tmpKey, seikyYmData);

			JCCBatCommon.printBusinessFileUtil(reShukFileUtil, seikyYmData);
		}
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][execute]");
		
		// 出力共通電文を返却
		return outputBean;

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

	/**
	 * 業務サービス終了処理
	 * @throws Exception
	 */
	public void terminal() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの終了処理を記述してください。▼▼▼▼▼▼*/
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][terminal]");

		// ファイル定義情報(トレーラ部)を取得
		// 出力ファイル名 ≠ ""（空文字）の場合
		if(!JACStrConst.KARA_MOJI.equals(files[2]))
		{
			assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][terminal] [出力ファイル名 ≠ 空文字 の場合]");
			JBSbatOutputFileUtil trailerFile = new JBSbatOutputFileUtil(files[3]);
			String trailerFileDefName = JBSbatAplConst.getAplConstValue(PRM_OTD) + files[2];
			JBSbatDefFileUtil trailerFileDef = new JBSbatDefFileUtil(trailerFileDefName, trailerFile);

			// ファイル出力(トレーラ部)
			ArrayList<ArrayList<Object>> outInfTrailerList = new ArrayList<ArrayList<Object>>();
			outInfTrailer.add(trailerRecType);
			outInfTrailer.add(hojinDataCnt);
			outInfTrailer.add(trailerYobi);
			outInfTrailerList.add(outInfTrailer);
			createFile(files[3], outInfTrailerList, trailerFile.getEncode(), JACBatCommon.chgKaigyo(trailerFile.getLine()), trailerFileDef.getDelimiter());
		}
		
		db_AC_T_EOMOBA_DTL_INI.clearBatch();
		db_AC_T_EOMOBA_DTL_UPD.clearBatch();
		
		/**▼▼▼▼▼▼ツールから生成した終了処理のソースです 開始▼▼▼▼▼▼*/
		// DBアクセスクラスをクローズします
		db_ZM_M_WORK_PARAM_KNRI.close();
		db_AC_M_JURYOPRC.close();
		db_CH_M_PRC_KMK_CS_CHGE.close();
		db_KK_T_SVC_KEI.close();
		db_AC_T_EOMOBA_DTL.close();
		db_AC_T_EOMOBA_DTL_INI.close();
		db_AC_T_EOMOBA_DTL_UPD.close();
		db_KK_T_SVC_KEI_EOMOBA.close();
		db_ZM_M_CD_NM_KANRI.close();
		/**▲▲▲▲▲▲ツールから生成した終了処理のソースです 終了▲▲▲▲▲▲*/
		this.seikyKaknoBusinessUtil.close();
		hojinDataFileUtil.close();
		reShukFileUtil.close();
		prcCalcFileUtil.close();
		su.close();
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][terminal]");
		
		// エラーメッセージを出力
		if (errCnt != 0)
		{
			// 警告終了 「【警告】エラー対象レコード＝（%1%）」
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.EACB0340CW, new String[] { Integer.toString(errCnt) });
		}

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

	/**▼▼▼▼▼▼ツールから生成したメソッドです 開始▼▼▼▼▼▼*/
	
	/**
	 * @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(AC_SELECT_001)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	業務パラメータID
	 *		 	業務パラメータ適用開始年月日
	 *		 	業務パラメータ適用終了年月日
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeZM_M_WORK_PARAM_KNRI_AC_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());

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

	/**
	 * SQLKEY(AC_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 executeAC_M_JURYOPRC_AC_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());

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

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

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

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

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

	/**
	 * SQLKEY(AC_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 executeAC_T_EOMOBA_DTL_AC_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());

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

	/**
	 * SQLKEY(AC_SELECT_001)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数でバイント変数を設定します。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		param:順にバイント変数の値をparam配列に入れます。バイント変数は以下に説明します。
	 *		 	事業者用契約ID
	 *		 	予約適用コード
	 *		 	予約適用コード
	 *		 	予約適用年月日
	 * </pre>
	 * <p>
	 * @param param バイント変数の値配列。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeKK_T_SVC_KEI_EOMOBA_AC_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());

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

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

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

	/**
	 * PK(全項目登録)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数で設定項目マップを作ります。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		setParam:設定したい項目の(項目、値)を(key、value)として、setParamマップに入れます。項目キーは以下に説明します。
	 *		 	サービス契約番号				SVC_KEI_NO
	 *		 	サービス契約内訳番号				SVC_KEI_UCWK_NO
	 *		 	料金コースコード				PCRS_CD
	 *		 	料金サービスコード				PRC_SVC_CD
	 *		 	請求契約番号				SEIKY_KEI_NO
	 *		 	請求年月				SEIKY_YM
	 *		 	事業者用契約ＩＤ				JIGYOSHA_KEI_ID
	 *		 	利用年月				USE_YM
	 *		 	通信開始年月日時分秒				TSUSHIN_STA_DTM
	 *		 	通信終了年月日時分秒				TSUSHIN_END_DTM
	 *		 	利用バイト数				USE_BYTE_CNT
	 *		 	利用パケット数				USE_PCT_CNT
	 *		 	料金項目コード				PRC_KMK_CD
	 *		 	登録年月日時分秒				ADD_DTM
	 *		 	登録オペレータアカウント				ADD_OPEACNT
	 *		 	更新年月日時分秒				UPD_DTM
	 *		 	更新オペレータアカウント				UPD_OPEACNT
	 *		 	削除年月日時分秒				DEL_DTM
	 *		 	削除オペレータアカウント				DEL_OPEACNT
	 *		 	無効フラグ				MK_FLG
	 *		 	登録運用年月日				ADD_UNYO_YMD
	 *		 	登録処理ＩＤ				ADD_TRN_ID
	 *		 	更新運用年月日				UPD_UNYO_YMD
	 *		 	更新処理ＩＤ				UPD_TRN_ID
	 *		 	削除運用年月日				DEL_UNYO_YMD
	 *		 	削除処理ＩＤ				DEL_TRN_ID
	 * </pre>
	 * <p>
	 * @param setParam 設定項目の値。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeAC_T_EOMOBA_DTL_PKINSERT(Object[] setParam) throws Exception
	{
		// 設定値のマップを作成します
		JBSbatCommonDBInterface setMap = new JBSbatCommonDBInterface();
		setMap.setValue("SVC_KEI_NO", setParam[0]);
		setMap.setValue("SVC_KEI_UCWK_NO", setParam[1]);
		setMap.setValue("PCRS_CD", setParam[2]);
		setMap.setValue("PRC_SVC_CD", setParam[3]);
		setMap.setValue("SEIKY_KEI_NO", setParam[4]);
		setMap.setValue("SEIKY_YM", setParam[5]);
		setMap.setValue("JIGYOSHA_KEI_ID", setParam[6]);
		setMap.setValue("USE_YM", setParam[7]);
		setMap.setValue("TSUSHIN_STA_DTM", setParam[8]);
		setMap.setValue("TSUSHIN_END_DTM", setParam[9]);
		setMap.setValue("USE_BYTE_CNT", setParam[10]);
		setMap.setValue("USE_PCT_CNT", setParam[11]);
		setMap.setValue("PRC_KMK_CD", setParam[12]);
		setMap.setValue("ADD_DTM", setParam[13]);
		setMap.setValue("ADD_OPEACNT", setParam[14]);
		setMap.setValue("UPD_DTM", setParam[15]);
		setMap.setValue("UPD_OPEACNT", setParam[16]);
		setMap.setValue("DEL_DTM", setParam[17]);
		setMap.setValue("DEL_OPEACNT", setParam[18]);
		setMap.setValue("MK_FLG", setParam[19]);
		setMap.setValue("ADD_UNYO_YMD", setParam[20]);
		setMap.setValue("ADD_TRN_ID", setParam[21]);
		setMap.setValue("UPD_UNYO_YMD", setParam[22]);
		setMap.setValue("UPD_TRN_ID", setParam[23]);
		setMap.setValue("DEL_UNYO_YMD", setParam[24]);
		setMap.setValue("DEL_TRN_ID", setParam[25]);
	
		// DBアクセスを実行します
		db_AC_T_EOMOBA_DTL_INI.insertByPrimaryKeysBatch(setMap);
	}

	/**
	 * PK(ＰＫ　更新)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数で設定項目マップを作ります。<br>
	 *
	 * 2.引数で条件マップを作ります。<br>
	 *
	 * 3.DBアクセスを実行します。<br>
	 * 
	 * 4.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		setParam:設定したい項目の(項目、値)を(key、value)として、setParamマップに入れます。項目キーは以下に説明します。
	 *		 	利用バイト数				USE_BYTE_CNT
	 *		 	利用パケット数				USE_PCT_CNT
	 *		 	更新年月日時分秒				UPD_DTM
	 *		 	更新オペレータアカウント				UPD_OPEACNT
	 *		 	削除年月日時分秒				DEL_DTM
	 *		 	削除オペレータアカウント				DEL_OPEACNT
	 *		whereParam:PK項目の(項目、値)を(key、value)として,格納された配列です。PK項目は以下に説明します。
	 *		 	SVC_KEI_NO
	 *		 	PCRS_CD
	 *		 	PRC_SVC_CD
	 *		 	SEIKY_YM
	 *		 	TSUSHIN_STA_DTM
	 *		 	TSUSHIN_END_DTM
	 * </pre>
	 * <p>
	 * @param setParam 設定項目の値。
	 * @param whereParam 条件項目の値。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void executeAC_T_EOMOBA_DTL_PKUPDATE(Object[] setParam, Object[] whereParam) throws Exception
	{
		// 設定値のマップを作成します
		JBSbatCommonDBInterface setMap = new JBSbatCommonDBInterface();
		setMap.setValue("USE_BYTE_CNT", setParam[0]);
		setMap.setValue("USE_PCT_CNT", setParam[1]);
		setMap.setValue("UPD_DTM", setParam[2]);
		setMap.setValue("UPD_OPEACNT", setParam[3]);
		setMap.setValue("DEL_DTM", setParam[4]);
		setMap.setValue("DEL_OPEACNT", setParam[5]);
	
		// 条件のマップを作成します
		JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
		whereMap.setValue("SVC_KEI_NO", whereParam[0]);
		whereMap.setValue("PCRS_CD", whereParam[1]);
		whereMap.setValue("PRC_SVC_CD", whereParam[2]);
		whereMap.setValue("SEIKY_YM", whereParam[3]);
		whereMap.setValue("TSUSHIN_STA_DTM", whereParam[4]);
		whereMap.setValue("TSUSHIN_END_DTM", whereParam[5]);

		// DBアクセスを実行します
		db_AC_T_EOMOBA_DTL_UPD.updateByPrimaryKeysBatch(whereMap, setMap, 1);
	}
	/**▲▲▲▲▲▲ツールから生成したメソッドです 終了▲▲▲▲▲▲*/

	/**
	 * 出力料金項目コード取得用マップを作成します。
	 * 
	 */
	private void makePrcKmkMap()throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makePrcKmkMap]");

		// 検索へ渡す引数配列の生成
		Object[] obParam = new Object[] {JACStrConst.SYS_CD_AC, emUseKoInf, JACStrConst.CHSHT_CHG_CD_2, super.opeDate, super.opeDate};
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makePrcKmkMap] CH_M_PRC_KMK_CS_CHGE 検索パラメータ：" + arrayToString(obParam));
		
		// executeCH_M_PRC_KMK_CS_CHGE_AC_SELECT_026の呼び出し
		executeCH_M_PRC_KMK_CS_CHGE_AC_SELECT_026(obParam);

		//レコードの取り出し
		JBSbatCommonDBInterface dbMap = db_CH_M_PRC_KMK_CS_CHGE.selectNext();
		
		if(dbMap == null)
		{
			// システムパラメータ管理テーブルから取得できない場合はエラーとする
			throw new JBSbatBusinessException(JPCBatchMessageConstant.EACB0440CE,
					new String[] { JBSbatCH_M_PRC_KMK_CS_CHGE.TABLE_NAME });
		}
		

		this.prcKmkMap = new HashMap<String, JBSbatCommonDBInterface>();
		while(dbMap != null)
		{
			// キー作成
			// 業務機能識別コード＋料金コースコード＋料金サービスコード＋料金項目コード
			String key = makeStr(dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.WORK_KINO_SKBT_CD), 
					dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PCRS_CD), 
					dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PRC_SVC_CD), 
					dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.PRC_KMK_CD));
			// キー・取得した情報をマップに
			this.prcKmkMap.put(key, dbMap);

			// 次レコード取得
			dbMap = db_CH_M_PRC_KMK_CS_CHGE.selectNext(); 
		}
	}
	
	/**
	 * 従量料金情報検索（従量料金の取得）<br>
	 * 検索結果でマップを作成する。 <br>
	 * @throws Exception
	 */
	private void makeJuryoPrcInfoMap(String tushinSeikyEndYmd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeJuryoPrcInfoMap]");
		
		JBSbatCommonDBInterface paramList = new JBSbatCommonDBInterface();
		
		paramList.setValue(super.systemCode);	// システムコード
		paramList.setValue(tushinSeikyEndYmd);		// 通信利用日基準請求年月末日
		paramList.setValue(tushinSeikyEndYmd);		// 通信利用日基準請求年月末日
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeJuryoPrcInfoMap][paramList=" + paramList.getList().toString() + "]");
		
		// SQL実行
		executeAC_M_JURYOPRC_AC_SELECT_001(paramList.getList().toArray());
		
		// 取得結果取得
		JBSbatCommonDBInterface dbMap = db_AC_M_JURYOPRC.selectNext();
		if(dbMap == null)
		{
			// システムパラメータ管理テーブルから取得できない場合はエラーとする
			throw new JBSbatBusinessException(JPCBatchMessageConstant.EACB0440CE,
					new String[] { JBSbatAC_M_JURYOPRC.TABLE_NAME });
		}
		while(dbMap != null)
		{
			// キー作成
			// 料金コースコード＋料金サービスコード＋課税非課税コード＋相対番号
			String key = makeStr(dbMap.getString(JBSbatAC_M_JURYOPRC.PCRS_CD), 
					dbMap.getString(JBSbatAC_M_JURYOPRC.PRC_SVC_CD), 
					dbMap.getString(JBSbatAC_M_JURYOPRC.KAZEI_HIKAZEI_CD), 
					dbMap.getString(JBSbatAC_M_JURYOPRC.AITAI_NO),
					tushinSeikyEndYmd);
			// キー・取得した情報をマップに
			tihJuryoPrcMap.put(key, dbMap);

			// 次レコード取得
			dbMap = db_AC_M_JURYOPRC.selectNext(); 
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeJuryoPrcInfoMap] 従量料金取得件数：" + tihJuryoPrcMap.size());
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeJuryoPrcInfoMap]");
		return;
	}
	
	/**
	 * 文字を連結します
	 * @param string　文字
	 * @return strBuf　連結した文字列
	 */
	private String makeStr(String ...string)
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][makeStr]");
		
		strBuf.setLength(0);
		for(String str:string){
			strBuf.append(str);
		}
		assert strBuf != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][makeStr][strBuf = " + strBuf.toString() + "]") : true;
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][makeStr]");
		
		return strBuf.toString();
	}
	
	/**
	 * ファイル出力
	 * 
	 * @param file ファイル名
	 * @param arrayList 出力データを格納した配列
	 * @param encode 文字コード
	 * @param line 改行コード
	 * @param div 区切文字
	 * @throws Exception
	 */
	private void createFile(String file, ArrayList<ArrayList<Object>> arrayList, String encode, String line, String div) throws Exception 
	{
		// encodeの形式がSHIFT-JISの場合、MS932に変換
		if (JACStrConst.ENCODE_SJIS.toUpperCase().equals(encode.toUpperCase()))
		{
			encode = JACStrConst.ENCODE_MS932;
		}
		
		// ファイルの生成
		JBSbatBusinessFileUtil fileUtil = JCCBatCommon.createBusinessFileUtil(file, encode, line, div);
		Iterator<ArrayList<Object>> it = arrayList.iterator();
		// データ数分繰り返し
		while(it.hasNext())
		{
			// データを取得
			ArrayList<Object> data = it.next();
			// ファイルに書き込み
			JCCBatCommon.printBusinessFileUtil(fileUtil, data);
		}
		// ファイルを閉じる
		JCCBatCommon.closeBusinessFileUtil(fileUtil);
	}

	/**
	 * 初回課金情報を生成
	 * 
	 * @param svcKeiNo サービス契約番号
	 * @param firstUseYmd 初回利用発生年月日
	 * @return 初回課金情報
	 * @throws Exception 
	 */
	private JBSbatServiceInterfaceMap createFirstChrgInf(String svcKeiNo, String firstUseYmd) throws Exception 
	{
		// 初回課金情報のインスタンスを生成
		JBSbatServiceInterfaceMap dataMap = new JBSbatServiceInterfaceMap();
		// 値を設定
		dataMap.setString(JBSbatKKIFI030.SVC_KEI_NO, svcKeiNo);
		dataMap.setString(JBSbatKKIFI030.FIRST_TUSHIN_HSI_YMD, firstUseYmd);
		dataMap.setOutFlg(true);
		// 初回課金情報を返却
		return dataMap;
	}

	/**
	 * エラーデータを生成
	 * 
	 * @param inMap 入力電文
	 * @param sErr エラー文字列
	 * @return エラーデータ
	 * @throws Exception 
	 */
	private JBSbatServiceInterfaceMap createErrorData(JBSbatServiceInterfaceMap inMap, String sErr) throws Exception 
	{
		// エラーデータのインスタンスを生成
		JBSbatServiceInterfaceMap dataMap = new JBSbatServiceInterfaceMap();
		// 値を設定
		dataMap.setMap(inMap.getMap());
		dataMap.setString(JBSbatACIFM029.ERR_NAIYO, sErr);
		dataMap.setOutFlg(true);
		
		// エラー数をカウントアップ
		errCnt++;
		
		// エラーデータを返却
		return dataMap;
	}

	/**
	 * 料金項目コードより、出力料金項目コードを取得
	 * 
	 * @param koInf ＥＭ利用呼情報
	 * @param pcrsCd 料金コースコード
	 * @param prcSvcCd 料金サービスコード
	 * @param prcKmkCd 料金項目コード
	 * @param sikyYm 請求年月
	 * @return 出力料金項目コード
	 * @throws Exception 例外
	 */
	private String getOutPrcKmkCd(String koInf, String pcrsCd, String prcSvcCd, String prcKmkCd, String sikyYm) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getOutPrcKmkCd]");
		
		// 業務機能識別コード＋料金コースコード＋料金サービスコード＋料金項目コード
		String key = makeStr(koInf + sikyYm.substring(4, 6), pcrsCd, prcSvcCd, prcKmkCd);
		
		JBSbatCommonDBInterface dbMap = prcKmkMap.get(key);
		
		if(dbMap == null)
		{
			// 業務例外
			throw new JBSbatBusinessException(JPCBatchMessageConstant.EACB0440CE, new String[] {JBSbatCH_M_PRC_KMK_CS_CHGE.TABLE_NAME});
		}
		
		String outPrcKmkCd = dbMap.getString(JBSbatCH_M_PRC_KMK_CS_CHGE.OUT_PRC_KMK_CD);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getOutPrcKmkCd][出力料金項目コード：" + outPrcKmkCd + "]");
		// 出力料金項目コードを返却
		return outPrcKmkCd;
	}
	
	/**
	 * 初回課金情報作成判定
	 * 
	 * @param svcKeiNo サービス契約番号
	 * @param batYmd バッチ運用年月日
	 * @param useYmd 通信利用年月日
	 * @return trueなら初回課金情報
	 * @throws Exception
	 */
	private String  createFirstChrgInfo(String svcKeiNo, String batYmd, String useYmd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][createFirstChrgInfo]");
		// executeKK_T_SVC_KEI_AC_SELECT_026の呼び出し
		executeKK_T_SVC_KEI_AC_SELECT_026(new Object[] {svcKeiNo, batYmd});

		//レコードの取り出し
		JBSbatCommonDBInterface record = db_KK_T_SVC_KEI.selectNext();
		String firstPctHasseiYmd = null;
		
		if(record != null)
		{
			firstPctHasseiYmd = record.getString(JBSbatKK_T_SVC_KEI_EOMOBA.FIRST_PCT_HASSEI_YMD);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][createFirstChrgInfo]");
		return firstPctHasseiYmd;
	}
	
	/**
	 * eoモバイル明細登録処理
	 * 
	 * @param inMap ＥＭ利用呼情報(データ部)
	 * @param useByte 利用バイト数
	 * @param usePct 利用パケット数
	 * @param svcKeiNo サービス契約番号
	 * @param svcKeiUwNo サービス契約内訳番号
	 * @param pcrsCd 料金コースコード
	 * @param prcKmkCd 料金項目コード
	 * @param sikyKeiNo 請求契約番号
	 * @param sikyYm 請求年月
	 * @param outPrcKmkCd 出力料金項目コード
	 * @param prcSvcCd 料金サービスコード
	 * @throws Exception
	 */
	private void insertEoMobaDtl(JBSbatServiceInterfaceMap inMap, BigDecimal useByte, BigDecimal usePct, String svcKeiNo, String svcKeiUwNo, 
			String pcrsCd, String prcKmkCd, String sikyKeiNo, String sikyYm, String outPrcKmkCd, String prcSvcCd) throws Exception 
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][insertEoMobaDtl]");
		
		// 設定値を格納する配列を生成
		Object[] setParam = new Object[26];
		// 設定値を設定
		setParam[0] = svcKeiNo;
		setParam[1] = svcKeiUwNo;
		setParam[2] = pcrsCd;
		setParam[3] = prcSvcCd;
		setParam[4] = sikyKeiNo;
		setParam[5] = sikyYm;
		setParam[6] = inMap.getString(JBSbatACIFM216.EM_KEISHA_CD);
		setParam[7] = inMap.getString(JBSbatACIFM216.TSUSHIN_USE_DAY).substring(0, 6);
		setParam[8] = JPCUtilCommon.fillZero((inMap.getString(JBSbatACIFM216.TSUSHIN_USE_DAY)), TSUSHIN_STA_END_DTM_LENGTH, true);
		setParam[9] = JPCUtilCommon.fillZero((inMap.getString(JBSbatACIFM216.TSUSHIN_USE_DAY)), TSUSHIN_STA_END_DTM_LENGTH, true);
		setParam[10] = useByte;
		setParam[11] = usePct;
		setParam[12] = outPrcKmkCd;

		// eoモバイル明細登録処理
		executeAC_T_EOMOBA_DTL_PKINSERT(setParam);
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][insertEoMobaDtl]");
	}
	

	/**
	 * eoモバイル明細更新処理
	 * 
	 * @param useByte 利用バイト数
	 * @param usePct 利用パケット数
	 * @param dbMap 一意照会で検索したeoモバイル明細のＰＫデータ
	 * @throws Exception
	 */
	private void updateEoMobaDtl(BigDecimal useByte, BigDecimal usePct, JBSbatServiceInterfaceMap inMap, String pcrsCd, String prcSvcCd) throws Exception 
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][updateEoMobaDtl]");
		
		// 設定値と条件値を格納する配列を生成
		Object[] setParam = new Object[6];
		Object[] whereParam = new Object[7];
		// 設定値を設定
		setParam[0] = useByte;	// 利用バイト数
		setParam[1] = usePct;	// 利用パケット数
		// 条件値を設定
		whereParam[0] = inMap.getString(JBSbatACIFM216.SVC_KEI_NO);			// 請求契約番号
		whereParam[1] = pcrsCd;												// 料金コースコード
		whereParam[2] = prcSvcCd;											// 料金サービスコード
		whereParam[3] = inMap.getString(JBSbatACIFM216.SEIKY_YM);			// 請求年月
		whereParam[4] = inMap.getString(JBSbatACIFM216.TSUSHIN_STA_DTM);	// 通信開始年月日時分秒
		whereParam[5] = inMap.getString(JBSbatACIFM216.TSUSHIN_END_DTM);	// 通信終了年月日時分秒
		// eoモバイル明細更新処理
		executeAC_T_EOMOBA_DTL_PKUPDATE(setParam, whereParam);
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][updateEoMobaDtl]");
	}

	/**
	 * 業務パラメータ値を取得
	 * 
	 * @param paramId 業務パラメータID
	 * @param batYmd バッチ運用年月日
	 * @return 業務パラメータ
	 * @throws Exception
	 */
	private String getWorkParamVal(String paramId, String batYmd) throws Exception 
	{
		// executeZM_M_WORK_PARAM_KNRI_AC_SELECT_001の呼び出し
		executeZM_M_WORK_PARAM_KNRI_AC_SELECT_001(new Object[] {paramId, batYmd, batYmd});

		// レコードの取り出し
		JBSbatCommonDBInterface record = db_ZM_M_WORK_PARAM_KNRI.selectNext();

		// レコードの存在チェック
		if (record != null)
		{
			// レコードが存在する場合

			// 業務パラメータ値を取得
			return record.getString(JBSbatZM_M_WORK_PARAM_KNRI.WORK_PARAM_SETTE_VALUE);
		}
		else
		{
			// レコードが存在しない場合
			
			// 業務例外
			throw new JBSbatBusinessException(JPCBatchMessageConstant.EACB0440CE, new String[] {JBSbatZM_M_WORK_PARAM_KNRI.TABLE_NAME});
		}
	}
	
	/**
	 * 配列をカンマ区切り文字列に編集します。
	 * 
	 * @param obArray 対象配列
	 * @return カンマ区切り文字列
	 */
	private String arrayToString(Object[] obArray)
	{
		
		StringBuffer bufString = new StringBuffer();
		
		if (obArray == null || obArray.length == 0)
		{
			return bufString.toString();
		}
		
		for(int i = 0; i < obArray.length; i++)
		{
			bufString.append(",");
			bufString.append(obArray[i]);
		}
		bufString.delete(0, 1);
		
		return bufString.toString();
	}

	/**
	 * コード名称管理からコード名称管理情報を取得します。
	 * 
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private void getCdNmKnriInf() throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getCdNmKnriInf]");
		
		JBSbatCommonDBInterface whereParam = new JBSbatCommonDBInterface();
		
		whereParam.setValue(JZM0171Constant.CD01172);			// コード種別
		
		whereParam.setValue(super.opeDate);		// 適用開始年月日
		
		whereParam.setValue(super.opeDate);		// 適用終了年月日
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getCdNmKnriInf][whereParam=" + whereParam.getList().toString() + "]");
		
		// SQL実行
		executeZM_M_CD_NM_KANRI_AC_SELECT_003(whereParam.getList().toArray());
		
		JBSbatCommonDBInterface dbMap = db_ZM_M_CD_NM_KANRI.selectNext();
		
		// 取得できなかった場合
		if(dbMap == null)
		{
			// ログ出力
			super.logPrint.printBusinessErrorLog(JPCBatchMessageConstant.EACB0250CE,
					new String[] {JBSbatZM_M_CD_NM_KANRI.TABLE_NAME, whereParam.getList().toString()});
		}
		// 上記以外の場合
		else
		{
			while(null != dbMap)
			{
				// コード名称管理情報マップに検索結果を設定（キー：コード区分）
				this.cdNmKnriInfMap.put(dbMap.getString(JBSbatZM_M_CD_NM_KANRI.CD_DIV), dbMap.getString(JBSbatZM_M_CD_NM_KANRI.CD_DIV_NM));
				
				dbMap = db_ZM_M_CD_NM_KANRI.selectNext();
			}
		}
		
		assert this.cdNmKnriInfMap != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getCdNmKnriInf][cdNmKnriInfMap=" + this.cdNmKnriInfMap.toString() + "]") : true;
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getCdNmKnriInf]");
		return;
	}

	/**
	 * コード名称管理情報マップから結果内容を取得します。
	 * 
	 * @param clcRsltCd コード区分
	 * @return String 結果内容
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private String getRsltNyo(String clcRsltCd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getRsltNyo]");
		
		String rsltNyo = null;
		
		// コード管理情報マップに値が存在する場合
		if(!this.cdNmKnriInfMap.isEmpty())
		{
			// コード管理情報マップのコード区分が存在する場合
			if(this.cdNmKnriInfMap.containsKey(clcRsltCd))
			{
				// 結果内容取得
				rsltNyo = this.cdNmKnriInfMap.get(clcRsltCd);		
			}
		}
		// 結果内容がnullの場合
		if(rsltNyo == null)
		{
			// ""（空文字）を設定
			rsltNyo = JACStrConst.KARA_MOJI;
		}
		
		
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getRsltNyo][rsltNyo=" + rsltNyo + "]");
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getRsltNyo]");
		
		return rsltNyo;
	}
	
	/**
	 * サービス契約＜ｅｏモバイル＞情報取得を行います。
	 * @param jgMap 
	 * 
	 * @param emKshCd EM契約者コード
	 * @return 
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private JBSbatCommonDBInterface getSvcKeiMobile(String emKshCd) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getFemtoOpInfo]");
		
		// ＤＢアクセス用のパラメータ定義
		JBSbatCommonDBInterface dbList = new JBSbatCommonDBInterface();

		// サービス契約＜ｅｏモバイル＞ ＷＨＥＲＥ条件設定
		dbList.setValue(emKshCd); 								// EM契約者コード
		dbList.setValue(JACStrConst.RSV_APLY_CD_FIX); 			// 予約適用コード
		dbList.setValue(JACStrConst.RSV_APLY_CD_FIX); 			// 予約適用コード
		dbList.setValue(super.opeDate); 						// バッチ運用日
		
		assert dbList != null ? JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][getFemtoOpInfo][dbList=" + dbList.getList().toString() + "]") : true;

		// 事業者間積算料金データ取得
		executeKK_T_SVC_KEI_EOMOBA_AC_SELECT_001(dbList.getList().toArray());

		// レコード読み込み
		JBSbatCommonDBInterface dbMap = db_KK_T_SVC_KEI_EOMOBA.selectNext();

		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getFemtoOpInfo]");
		return dbMap;
	}
	
	/**
	 * サービス契約＜ｅｏモバイル＞情報取得を行います。
	 * @param jgMap 
	 * 
	 * @param emKshCd EM契約者コード
	 * @return 
	 * @throws Exception 業務サービス内で発生した例外全般
	 */
	private void getEmDtl(String svcKeiNo, String pcrsCd, String prcSvcCd, String seikyYm, String tsushinUseYmd, JBSbatServiceInterfaceMap mastMap) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getEmDtl]");
		
		// eoモバイル明細テーブル登録・更新判定処理
		Object[] emParam = new Object[] {svcKeiNo, pcrsCd, prcSvcCd, seikyYm, tsushinUseYmd};
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[L][execute] AC_T_EOMOBA_DTL 検索パラメータ：" + arrayToString(emParam));
		executeAC_T_EOMOBA_DTL_AC_SELECT_006(emParam);

		// レコード読み込み
		JBSbatCommonDBInterface dbMap = db_AC_T_EOMOBA_DTL.selectNext();
		
		if(dbMap != null)
		{
			mastMap.setString(JBSbatACIFM216.TSUSHIN_STA_DTM, JBSbatAC_T_EOMOBA_DTL.TSUSHIN_STA_DTM);
			mastMap.setString(JBSbatACIFM216.TSUSHIN_STA_DTM, JBSbatAC_T_EOMOBA_DTL.TSUSHIN_END_DTM);
		}
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[E][getEmDtl]");
	}

	/**
	 * 出力情報を取得します。
	 * 
	 * @param svcKeiNo サービス契約番号
	 * @param seikyKeiNo 請求契約番号
	 * @param pcrsCd 料金コースコード
	 * @param prcSvcCd 料金サービスコード
	 * @param prcSvcCd 料金項目コード
	 * @param usePctCnt 利用パケット数
	 * @return JBSbatServiceInterfaceMap 出力情報
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private ArrayList<Object> getOutputInf(String svcKeiNo, String seikyKeiNo, String pcrsCd,
			String prcSvcCd, String prcKmkCd, BigDecimal usePctCnt) throws Exception
	{
		assert JACbatDebugLogUtil.printDebugLog(super.logPrint, "[S][getOutputInf]");
		
		ArrayList<Object> errInfoData = new ArrayList<Object>();

		errInfoData.add(this.prcClcRsltCd);								//エラーコード
		errInfoData.add(this.prcRsltNyo);								//エラー内容
		errInfoData.add(JPCUtilCommon.formatDate(super.opeDate));		//処理日
		errInfoData.add(seikyKeiNo);									//請求先番号
		errInfoData.add(JACStrConst.KARA_MOJI);							//請求先カナ名
		errInfoData.add(svcKeiNo);										//サービス契約番号
		errInfoData.add(JACStrConst.KARA_MOJI);							//サービス詳細識別番号
		errInfoData.add(seikyYm);										//請求年月
		errInfoData.add(pcrsCd);										//料金コースコード
		errInfoData.add(prcSvcCd);										//料金サービスコード
		errInfoData.add(prcKmkCd);										//料金項目コード
		errInfoData.add(JACStrConst.KARA_MOJI);							//料金内訳明細
		errInfoData.add(JACStrConst.KARA_MOJI);							//請求金額
		errInfoData.add(usePctCnt.toString());							//通信量
		errInfoData.add(JACStrConst.KARA_MOJI);							//投入区分

		return errInfoData;
	}
}