/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JBSbatCHIktNyukinAdd
*	ソースファイル名	：JBSbatCHIktNyukinAdd.java
*	作成者				：富士通　
*	作成日				：2023年10月11日
*＜機能概要＞
*　一括入金登録部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v68.00.00	2023/11/01  FJ)謝		【ANK-4475-00-00】インボイス対応 STEP2
*********************************************************************/
package eo.business.service;

import java.io.File;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;

import eo.business.common.JACBatCommon;
import eo.business.common.JACbatParamUtil;
import eo.business.common.JACbatRknBusinessUtil;
import eo.business.common.JBSbatBusinessService;
import eo.business.common.JCCBatCommon;
import eo.business.common.JCCbatShoriIraiUtil;
import eo.business.common.JCHBatNameStkuUtil;
import eo.business.common.JCHbatTaiorrkDataAdd;
import eo.business.util.file.JBSbatCHIFM432;
import eo.business.util.file.JBSbatCHIFM433;
import eo.business.util.table.JBSbatCC_T_DLYD_TRN_REQ;
import eo.business.util.table.JBSbatCH_M_TKSKST_CHG_JKN;
import eo.business.util.table.JBSbatCH_T_KNK;
import eo.business.util.table.JBSbatCH_T_SAIKEN;
import eo.business.util.table.JBSbatCH_T_SEIKY_SKN_KNRN;
import eo.business.util.table.JBSbatCH_T_TOKUSOKU;
import eo.common.constant.JACStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.constant.JZM0171Constant;
import eo.framework.db.JBSbatSQLAccess;
import eo.framework.file.JBSbatDefFileUtil;
import eo.framework.file.JBSbatInputFileUtil;
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.JBSbatBusinessFileUtil;
import eo.framework.util.JBSbatCheckUtil;
import eo.framework.util.JBSbatDateUtil;
import eo.framework.util.JCCBatchEsbInterface;

/**
* (クラスの機能概要) <p>
*<BR>
* @author 富士通
*/
public class JBSbatCHIktNyukinAdd extends JBSbatBusinessService
{
	/**▼▼▼▼▼▼ツールから生成した宣言です 開始▼▼▼▼▼▼*/
	/** テーブル(ディレイド処理依頼)*/
	private static final String D_TBL_NAME_CC_T_DLYD_TRN_REQ = "CC_T_DLYD_TRN_REQ";

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

	/** テーブル(債権)*/
	private static final String D_TBL_NAME_CH_T_SAIKEN = "CH_T_SAIKEN";

	/** テーブル(金庫)*/
	private static final String D_TBL_NAME_CH_T_KNK = "CH_T_KNK";

	/** テーブル(督促)*/
	private static final String D_TBL_NAME_CH_T_TOKUSOKU = "CH_T_TOKUSOKU";

	/** テーブル(ダウンロードファイル管理)*/
	private static final String D_TBL_NAME_ZM_T_DL_FILE_KANRI = "ZM_T_DL_FILE_KANRI";

	/** テーブル(督促ステータス変更条件)*/
	private static final String D_TBL_NAME_CH_M_TKSKST_CHG_JKN = "CH_M_TKSKST_CHG_JKN";

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

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

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

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

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

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

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

	/** テーブルアクセスクラス(ディレイド処理依頼)*/
	private JBSbatSQLAccess db_CC_T_DLYD_TRN_REQ = null;

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

	/** テーブルアクセスクラス(債権)*/
	private JBSbatSQLAccess db_CH_T_SAIKEN = null;

	/** テーブルアクセスクラス(金庫)*/
	private JBSbatSQLAccess db_CH_T_KNK = null;

	/** テーブルアクセスクラス(督促)*/
	private JBSbatSQLAccess db_CH_T_TOKUSOKU = null;

	/** テーブルアクセスクラス(ダウンロードファイル管理)*/
	private JBSbatSQLAccess db_ZM_T_DL_FILE_KANRI = null;

	/** テーブルアクセスクラス(督促ステータス変更条件)*/
	private JBSbatSQLAccess db_CH_M_TKSKST_CHG_JKN = null;
	/**▲▲▲▲▲▲ツールから生成した宣言です 終了▲▲▲▲▲▲*/
	/** ファイルコード */
	private static final String FILE_CD = "0000";
	/** 処理管理番号 一括入金登録 */
	private static final String TRN_KANRI_NO_IKT_NYUKIN_ADD = "000000000266";
	/** コード種別コード（一括入金登録エラーコード） */
	private static final String CD_SBT_CD_ADD_ERR_CD  = "CD01817";
	/** 一括入金登録エラーコード 0000 */
	private static final String ERR_CD_0000 = "0000";
	/** 一括入金登録エラーコード H001 */
	private static final String ERR_CD_H001 = "H001";
	/** 一括入金登録エラーコード E001 */
	private static final String ERR_CD_E001 = "E001";
	/** 一括入金登録エラーコード E002 */
	private static final String ERR_CD_E002 = "E002";
	/** 一括入金登録エラーコード E003 */
	private static final String ERR_CD_E003 = "E003";
	/** 一括入金登録エラーコード E004 */
	private static final String ERR_CD_E004 = "E004";
	/** 一括入金登録エラーコード E005 */
	private static final String ERR_CD_E005 = "E005";
	/** 一括入金登録エラーコード E006 */
	private static final String ERR_CD_E006 = "E006";
	/** 一括入金登録エラーコード E007 */
	private static final String ERR_CD_E007 = "E007";
	/** 一括入金登録エラーコード E008 */
	private static final String ERR_CD_E008 = "E008";
	/** 一括入金登録エラーコード E009 */
	private static final String ERR_CD_E009 = "E009";
	/** 一括入金登録エラーコード E010 */
	private static final String ERR_CD_E010 = "E010";
	/** 一括入金登録エラーコード E011 */
	private static final String ERR_CD_E011 = "E011";
	/** 一括入金登録エラーコード E100 */
	private static final String ERR_CD_E100 = "E100";
	/** 一括入金登録エラーコード E101 */
	private static final String ERR_CD_E101 = "E101";
	/** 一括入金登録エラーコード E102 */
	private static final String ERR_CD_E102 = "E102";
	/** 一括入金登録エラーコード E200 */
	private static final String ERR_CD_E200 = "E200";
	/** 一括入金登録エラーコード E201 */
	private static final String ERR_CD_E201 = "E201";
	/** 一括入金登録エラーコード E900 */
	private static final String ERR_CD_E900 = "E900";
	/** 一括入金登録エラーコード W001 */
	private static final String ERR_CD_W001 = "W001";
	/** 一括入金登録エラーコード W002 */
	private static final String ERR_CD_W002 = "W002";
	
	/** ユーザー関連情報 ユーザーID */
	private static final String USER_INF_USER_ID = "USER_ID";
	/** ユーザー関連情報 ユーザー名 */
	private static final String USER_INF_USER_NM = "USER_NM";
	/** ユーザー関連情報 業務個別設定組織コード */
	private static final String USER_INF_WKKBT_ORG_CD = "WKKBT_ORG_CD";
	/** ユーザー関連情報 業務個別設定組織名 */
	private static final String USER_INF_WKKBT_ORG_NM = "WKKBT_ORG_NM";
	
	/** 入金登録関連情報 請求契約番号 */
	private static final String NKIN_INF_SEIKY_KEI_NO = "SEIKY_KEI_NO";
	/** 入金登録関連情報 督促ステータス */
	private static final String NKIN_INF_TOKUSOKU_STAT = "TOKUSOKU_STAT";
	/** 入金登録関連情報 対応履歴連動対象フラグ */
	private static final String NKIN_INF_TAIORRKI_RENDO_TG_FLG = "TAIORRKI_RENDO_TG_FLG";
	/** 入金登録関連情報 記事 */
	private static final String NKIN_INF_KIJI = "KIJI";
	/** 入金登録関連情報 請求契約マップ */
	private static final String NKIN_INF_SEIKY_KEI_MAP = "SEIKY_KEI_MAP";
	/** 入金登録関連情報 債権リスト */
	private static final String NKIN_INF_SAIKEN_LIST = "SAIKEN_LIST";
	/** 入金登録関連情報 充当リスト */
	private static final String NKIN_INF_JUTO_LIST = "JUTO_LIST";
	/** 入金登録関連情報 預り金リスト */
	private static final String NKIN_INF_AZUKIN_LIST = "AZUKIN_LIST";
	/** 入金登録関連情報 預り金残高 */
	private static final String NKIN_INF_AZUKIN_AMNT = "AZUKIN_AMNT";
	/** 入金登録関連情報 未納額合計 全て */
	private static final String NKIN_INF_MINOU_AMNT_SUM_ALL = "MINOU_AMNT_SUM_ALL";
	/** 入金登録関連情報 未納額合計 対象 */
	private static final String NKIN_INF_MINOU_AMNT_SUM_TRGT = "MINOU_AMNT_SUM_TRGT";
	
	/** ユーザー関連情報格納マップ */
	private HashMap<String, String> userMap  = null;
	/** 一括入金登録エラーコード格納マップ */
	private HashMap<String, String> iktNyukinAddErrCdMap  = null;
	/** 督促ステータス格納マップ */
	private HashMap<String, String> tokusokuStatMap  = null;
	/** 対応履歴連動対象フラグ格納マップ */
	private HashMap<String, String> taiorrkiRendoTgFlgMap  = null;
	/** 業務機能識別コード：料金項目コード（未収金額） */
	private String wksMisyuKingaku  = JACStrConst.KARA_MOJI;
	/** エンコード */
	private String encode = JACStrConst.KARA_MOJI;
	
	/** 請求契約番号リスト（重複チェック用） */
	private HashSet<String> seikyKeiNoZumiList = null;
	/** 請求年月リスト（重複チェック用） */
	private HashSet<String> seikyYmZumiList = null;
	
	/** 一括入金登録処理結果ファイルのファイルオブジェクト */
	private JBSbatBusinessFileUtil chlst10502Obj = null;
	/** 一括入金登録処理結果ファイルのレコード件数 */
	private int chlst10502Cnt = 0;
	
	/** 退避.サービス契約ステータス */
	private String svcKeiStat = null;

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

		// DBアクセスクラスを生成します
		db_CC_T_DLYD_TRN_REQ = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CC_T_DLYD_TRN_REQ);
		db_KK_T_SEIKY_KEI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_KK_T_SEIKY_KEI);
		db_CH_T_SAIKEN = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CH_T_SAIKEN);
		db_CH_T_KNK = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CH_T_KNK);
		db_CH_T_TOKUSOKU = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CH_T_TOKUSOKU);
		db_ZM_T_DL_FILE_KANRI = new JBSbatSQLAccess(commonItem, D_TBL_NAME_ZM_T_DL_FILE_KANRI);
		db_CH_M_TKSKST_CHG_JKN = new JBSbatSQLAccess(commonItem, D_TBL_NAME_CH_M_TKSKST_CHG_JKN);
		/**▲▲▲▲▲▲ツールから生成した初期化のソースです 終了▲▲▲▲▲▲*/
		
		// 初期化
		iktNyukinAddErrCdMap  = new HashMap<String, String>();
		tokusokuStatMap  = new HashMap<String, String>();
		taiorrkiRendoTgFlgMap  = new HashMap<String, String>();
		
		// コード名称管理から該当の名称マップを作成する
		JCHBatNameStkuUtil nameStkuUtil = new JCHBatNameStkuUtil();
		
		// 一括入金登録エラーコード
		iktNyukinAddErrCdMap = nameStkuUtil.getCdNmMap(commonItem, CD_SBT_CD_ADD_ERR_CD);
		// 督促ステータス
		tokusokuStatMap = nameStkuUtil.getCdNmMap(commonItem, JZM0171Constant.CD00184);
		// 対応履歴連動対象フラグ
		taiorrkiRendoTgFlgMap = nameStkuUtil.getCdNmMap(commonItem, JZM0171Constant.CD00984);
		
		// 業務パラメータ管理から対象データを取得する
		JACbatParamUtil paramUtil = new JACbatParamUtil(commonItem);
		
		// 業務機能識別コード：料金項目コード（未収金額）
		wksMisyuKingaku = paramUtil.getGyoumuParameter(JACStrConst.WKPARA_CH_WKS_MISYU_KINGAKU);
		paramUtil.close();
		
	/**▲▲▲▲▲▲業務サービスの初期処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 主処理
	 * @return JBSbatOutputItem　出力情報
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public JBSbatOutputItem execute() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの主処理を記述してください。▼▼▼▼▼▼*/
		
		// ディレイド処理依頼情報を取得する
		List<HashMap<String, Object>> shoriIraiList = JCCbatShoriIraiUtil.getShoriIraiInfo(commonItem, this.jobid);
		if (shoriIraiList == null)
		{
			// 対象データが存在しないため処理終了
			return null;
		}
		
		// フリー項目を取得する
		String[] freeItems = freeItem.split(JACStrConst.FREE_DIV);
		
		// エンコード取得
		encode = freeItems[1];
		
		for (HashMap<String, Object> shoriIrai : shoriIraiList)
		{
			// チェックエラー存在フラグ false:エラーなし、true:エラーあり
			boolean checkErr = false;
			
			// 初回処理フラグ true:初回、false:初回以外
			boolean firstTranFlg = true;
			
			// 入力ファイルの定義取得
			String chlst10501DefFileName = JBSbatAplConst.getAplConstValue("IND") + "CHIFM432.def";
			
			// ディレイド処理依頼番号
			String shoriIraiNo = (String)shoriIrai.get(JBSbatCC_T_DLYD_TRN_REQ.DLYD_TRN_REQ_NO);
			
			// 入力電子ファイル管理番号
			String fileKanriNo = (String)shoriIrai.get(JBSbatCC_T_DLYD_TRN_REQ.INPUT_EFILE_KANRI_NO);
			
			// 電子ファイル管理より一括入金登録指示ファイルの復元
			String chlst10501Path = JCCBatCommon.searchDenshiFile(commonItem, fileKanriNo);
			JBSbatInputFileUtil chlst10501Util = new JBSbatInputFileUtil(chlst10501Path);
			JBSbatDefFileUtil chlst10501Def = new JBSbatDefFileUtil(chlst10501DefFileName, chlst10501Util);
			
			// Readerオブジェクトを生成する
			chlst10501Util.createReader();
			
			// 一括入金登録処理結果ファイルのファイル名を編集
			String sysDateTimeStamp = JCCBatCommon.getSysDateTimeStamp();
			String chlst10502Name =  "CHIFM433001_" + sysDateTimeStamp + ".csv";
			
			// 一括入金登録処理結果ファイルのファイルパス
			String chlst10502FullPath = freeItems[0] + chlst10502Name;
			
			// 一括入金登録処理結果ファイルのファイルオブジェクト
			chlst10502Obj = JCCBatCommon.createBusinessFileUtil(
					chlst10502FullPath, JACStrConst.ENCODE_SJIS, JACStrConst.LINE_SEPARATOR, JACStrConst.COMMA);
			
			// 一括入金登録処理結果ファイルのファイル
			chlst10502Cnt = 0;
			
			// 請求契約番号リスト
			seikyKeiNoZumiList = new HashSet<String>();
			
			// ユーザー関連情報
			userMap = new HashMap<String, String>();
			
			// ディレイド処理依頼のＰＫ検索を行う
			JBSbatCommonDBInterface dlydTrnReqMap = executeCC_T_DLYD_TRN_REQ_PKSELECT(new Object[]{shoriIraiNo});
			
			if (dlydTrnReqMap != null)
			{
				// ユーザーID
				String userId = dlydTrnReqMap.getString(JBSbatCC_T_DLYD_TRN_REQ.ADD_OPEACNT);
				userMap.put(USER_INF_USER_ID, userId);
				
				// 対応記録関連データ登録部品
				JCHbatTaiorrkDataAdd taiorrkDataAdd = new JCHbatTaiorrkDataAdd(commonItem, userId);
				
				// ユーザー名
				userMap.put(USER_INF_USER_NM, taiorrkDataAdd.getUserNm());
				// 業務個別設定組織コード
				userMap.put(USER_INF_WKKBT_ORG_CD, taiorrkDataAdd.getWkkbtOrgCd());
				// 業務個別設定組織名
				userMap.put(USER_INF_WKKBT_ORG_NM, taiorrkDataAdd.getWkkbtOrgNm());
			}
			
			// 請求年月リスト（重複チェック用）
			seikyYmZumiList = new HashSet<String>();
			// 出力用データリスト
			ArrayList<HashMap<String, String>> outFileDateList = new ArrayList<HashMap<String,String>>();
			// 入金登録用データマップ
			HashMap<String, Object> nyukinAddDataMap  = new HashMap<String, Object>();
			// 先頭レコードを判別するフラグ true:先頭レコード、false:先頭レコード以外
			boolean firstReccrdFlg = true;
			// 請求契約単位エラーフラグ false:エラーなし、true:エラーあり
			boolean seikyTaniErrFlg = false;
			// 請求契約番号（ブレイクキー）
			String seikyKeiNoBrkKey = JACStrConst.KARA_MOJI;
			// 退避．サービス契約ステータスを初期化する
			this.svcKeiStat = JACStrConst.KARA_MOJI;
			
			while (chlst10501Util.ready()) 
			{
				// ファイルから１レコード取得
				String chlst10501Line = chlst10501Util.readLine();
				
				// １レコードの情報をマップに格納
				JBSbatServiceInterfaceMap recordMap = chlst10501Def.lineToObject(chlst10501Line, chlst10501Util, 0);
				
				// 請求契約番号
				String seikyKeiNo = getNullToStr(recordMap.getString(JBSbatCHIFM432.SEIKY_KEI_NO));
				
				// 初回処理の場合
				if (firstTranFlg)
				{
					seikyKeiNoBrkKey = seikyKeiNo;
					firstTranFlg = false;
				}
				else
				{
					// 入力ファイルの請求契約番号が前回処理の請求契約番号と異なる場合
					if (!seikyKeiNo.equals(seikyKeiNoBrkKey))
					{
						// 入金登録処理を行う
						if (!executeNyukinAdd(seikyTaniErrFlg, seikyKeiNoBrkKey, outFileDateList, nyukinAddDataMap))
						{
							checkErr = true;
						}
						
						// 初期化　※請求契約単位
						// 請求年月リスト（重複チェック用）
						seikyYmZumiList = new HashSet<String>();
						// 出力用データリスト
						outFileDateList = new ArrayList<HashMap<String,String>>();
						// 入金登録用データマップ
						nyukinAddDataMap  = new HashMap<String, Object>();
						// 先頭レコードを判別するフラグ
						firstReccrdFlg = true;
						// 請求契約単位エラーフラグ
						seikyTaniErrFlg = false;
						// 請求契約番号（ブレイクキー）
						seikyKeiNoBrkKey = seikyKeiNo;
						// 退避．サービス契約ステータスを初期化する
						this.svcKeiStat = JACStrConst.KARA_MOJI;
					}
				}
				
				// 登録チェック処理
				HashMap<String, String> resultMap = checkMain(recordMap, nyukinAddDataMap, firstReccrdFlg);
				
				// チェックエラーの場合
				if (!JACBatCommon.isNull(resultMap.get(JBSbatCHIFM433.ERR_CD)))
				{
					HashMap<String, String> dataMap = recordMap.getMap();
					dataMap.put(JBSbatCHIFM433.ERR_CD, resultMap.get(JBSbatCHIFM433.ERR_CD));
					dataMap.put(JBSbatCHIFM433.NYUKIN_ADD_AMNT, JACStrConst.KARA_MOJI);
					outFileDateList.add(dataMap);
					seikyTaniErrFlg = true;
				}
				else
				{
					HashMap<String, String> dataMap = recordMap.getMap();
					dataMap.put(JBSbatCHIFM433.ERR_CD, JACStrConst.KARA_MOJI);
					dataMap.put(JBSbatCHIFM433.NYUKIN_ADD_AMNT, resultMap.get(JBSbatCHIFM433.NYUKIN_ADD_AMNT));
					outFileDateList.add(dataMap);
				}
				
				firstReccrdFlg = false;
			}
			
			// 最終回処理
			if (!firstTranFlg)
			{
				// 入金登録処理を行う
				if (!executeNyukinAdd(seikyTaniErrFlg, seikyKeiNoBrkKey, outFileDateList, nyukinAddDataMap))
				{
					checkErr = true;
				}
			}
			
			// 出力ファイルをクローズする
			JCCBatCommon.closeBusinessFileUtil(chlst10502Obj);
			
			if (checkErr)
			{
				// チェックエラーありのため、ディレイド処理依頼結果コードを"業務エラー"で更新
				JCCbatShoriIraiUtil.updateShoriIraiResult(commonItem, shoriIraiNo, JACStrConst.DLYD_TRN_RSLT_CD_WORK_ERR, null);
			}
			else
			{
				// チェックエラーなしのため、ディレイド処理依頼結果コードを"完了"で更新
				
				JCCbatShoriIraiUtil.updateShoriIraiResult(commonItem, shoriIraiNo, JACStrConst.DLYD_TRN_RSLT_CD_FIN, null);
			}
			
			// 電子ファイル管理登録処理
			JBSbatCommonItem arg0 = commonItem;								// 業務共通電文
			String arg1 = FILE_CD;											// ファイルコード
			String arg2 = chlst10502FullPath;								// ファイルパス
			String arg3 = JBSbatDateUtil.adjustMonth(super.opeDate, 1);		// ファイル削除年月日（運用日付 + 1ヶ月）
			String[] rc = JCCBatCommon.createDenshiFile(arg0, arg1, arg2, arg3);
			
			// ログ出力
			super.logPrint.printDebugLog("電子ファイル管理番号(" + rc[0] + ")、世代登録年月日時分秒(" + rc[1] + ")");
			
			// 電話ファイル管理に登録する日本語のファイル名
			String chlst10502NhngName = "一括入金登録処理結果ファイル_" + sysDateTimeStamp + ".csv";
			
			// ダウンロードファイル管理登録処理
			String[] dlFileKanriParam = new String[5];
			dlFileKanriParam[0] = TRN_KANRI_NO_IKT_NYUKIN_ADD;				// 処理管理番号
			dlFileKanriParam[1] = chlst10502NhngName;						// ファイル名
			dlFileKanriParam[2] = String.valueOf(chlst10502Cnt);			// データ件数
			dlFileKanriParam[3] = rc[0];									// 電子ファイル管理番号
			dlFileKanriParam[4] = rc[1];									// 世代登録年月日時分秒
			executeZM_T_DL_FILE_KANRI_CH_INSERT_001(dlFileKanriParam);
			
			// 一時ファイルを削除する
			File chlst10502 = new File(chlst10502FullPath);
			if (chlst10502.exists())
			{
				chlst10502.delete();
			}
		}
		
		return null;
	/**▲▲▲▲▲▲業務サービスの主処理を記述してください。▲▲▲▲▲▲*/
	}

	/**
	 * 業務サービス終了処理
	 * @throws Exception
	 */
	public void terminal() throws Exception
	{
	/**▼▼▼▼▼▼業務サービスの終了処理を記述してください。▼▼▼▼▼▼*/
		/**▼▼▼▼▼▼ツールから生成した終了処理のソースです 開始▼▼▼▼▼▼*/
		// DBアクセスクラスをクローズします
		db_CC_T_DLYD_TRN_REQ.close();
		db_KK_T_SEIKY_KEI.close();
		db_CH_T_SAIKEN.close();
		db_CH_T_KNK.close();
		db_CH_T_TOKUSOKU.close();
		db_ZM_T_DL_FILE_KANRI.close();
		db_CH_M_TKSKST_CHG_JKN.close();
		/**▲▲▲▲▲▲ツールから生成した終了処理のソースです 終了▲▲▲▲▲▲*/
	/**▲▲▲▲▲▲業務サービスの終了処理を記述してください。▲▲▲▲▲▲*/
	}

	/**▼▼▼▼▼▼ツールから生成したメソッドです 開始▼▼▼▼▼▼*/
	/**
	 * PK(ＰＫ　検索)でDBアクセスを行います。<br>
	 * <p>
	 * <b>処理フロー</b><br>
	 * <pre>
	 * 1.引数で条件マップを作ります。<br>
	 *
	 * 2.DBアクセスを実行します。<br>
	 * 
	 * 3.メソッドの呼び出し方です。<br>
	 *		引数:
	 *		whereParam:PK項目の(項目、値)を(key、value)として,格納された配列です。PK項目は以下に説明します。
	 *		 	DLYD_TRN_REQ_NO
	 * </pre>
	 * <p>
	 * @param whereParam 条件項目の値。
	 * @return JBSbatCommonDBInterface 検索の結果。
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private JBSbatCommonDBInterface executeCC_T_DLYD_TRN_REQ_PKSELECT(Object[] whereParam) throws Exception
	{
		// 条件のマップを作成します
		JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
		whereMap.setValue("DLYD_TRN_REQ_NO", whereParam[0]);

		// DBアクセスを実行します
		return db_CC_T_DLYD_TRN_REQ.selectByPrimaryKeys(whereMap);
	}

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

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

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

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

	/**
	 * SQLKEY(CH_SELECT_044)で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_SAIKEN_CH_SELECT_044(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_CH_T_SAIKEN.selectBySqlDefine(paramList, CH_T_SAIKEN_CH_SELECT_044);
	}

	/**
	 * SQLKEY(CH_SELECT_011)で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_TOKUSOKU_CH_SELECT_011(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_TOKUSOKU.selectBySqlDefine(paramList, CH_T_TOKUSOKU_CH_SELECT_011);
	}

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

		// DBアクセスを実行します
		db_ZM_T_DL_FILE_KANRI.executeBySqlDefine(paramList, ZM_T_DL_FILE_KANRI_CH_INSERT_001);
	}

	/**
	 * 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 executeCH_M_TKSKST_CHG_JKN_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());

		// DBアクセスを実行します
		db_CH_M_TKSKST_CHG_JKN.selectBySqlDefine(paramList, CH_M_TKSKST_CHG_JKN_CH_SELECT_001);
	}
	/**▲▲▲▲▲▲ツールから生成したメソッドです 終了▲▲▲▲▲▲*/
	
	/**
	 * 登録チェックを行います。
	 * <br>
	 * @param recordMap 入金登録指示ファイルの１レコードの情報
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param firstReccrdFlg 請求契約単位で先頭レコードを判別するフラグ
	 * @return 入金登録チェック結果
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, String> checkMain(JBSbatServiceInterfaceMap recordMap, HashMap<String, Object> nyukinAddDataMap, boolean firstReccrdFlg)throws Exception
	{
		HashMap<String, String> resultMap = new HashMap<String, String>();
		resultMap.put(JBSbatCHIFM433.ERR_CD, JACStrConst.KARA_MOJI);
		resultMap.put(JBSbatCHIFM433.NYUKIN_ADD_AMNT, JACStrConst.KARA_MOJI);
		
		// ■■■ファイルチェック
		// フォーマットチェック
		if (recordMap.isInputErrorFlg())
		{
			// １レコードの項目数が異なる
			resultMap.put(JBSbatCHIFM433.ERR_CD, ERR_CD_H001);
			return resultMap;
		}
		
		// 必須・属性・桁数チェック・重複チェック
		String result = singleCheck(recordMap.getMap(), firstReccrdFlg);
		
		if (!JACBatCommon.isNull(result))
		{
			resultMap.put(JBSbatCHIFM433.ERR_CD, result);
			return resultMap;
		}
		
		// 請求契約番号
		String seikyKeiNo = recordMap.getString(JBSbatCHIFM432.SEIKY_KEI_NO);
		// 請求年月
		String seikyYm = recordMap.getString(JBSbatCHIFM432.SEIKY_YM);
		
		// 先頭レコードの場合
		if (firstReccrdFlg)
		{
			// 請求契約番号
			nyukinAddDataMap.put(NKIN_INF_SEIKY_KEI_NO, recordMap.getString(JBSbatCHIFM432.SEIKY_KEI_NO));
			// 督促ステータス
			nyukinAddDataMap.put(NKIN_INF_TOKUSOKU_STAT, recordMap.getString(JBSbatCHIFM432.TOKUSOKU_STAT));
			// 対応履歴連動対象フラグ
			nyukinAddDataMap.put(NKIN_INF_TAIORRKI_RENDO_TG_FLG, recordMap.getString(JBSbatCHIFM432.TAIORRKI_RENDO_TG_FLG));
			// 記事
			nyukinAddDataMap.put(NKIN_INF_KIJI, recordMap.getString(JBSbatCHIFM432.KIJI));
			
			// 請求契約マップ
			executeKK_T_SEIKY_KEI_CH_SELECT_004(new String[]{seikyKeiNo, super.opeDate});
			JBSbatCommonDBInterface seikyKeiInfo = db_KK_T_SEIKY_KEI.selectNext();
			nyukinAddDataMap.put(NKIN_INF_SEIKY_KEI_MAP, seikyKeiInfo);
			
			// 未納額合計
			BigDecimal minouAmntSum = BigDecimal.ZERO;
			
			// 債権リスト
			ArrayList<JBSbatCommonDBInterface> saikenList = new ArrayList<JBSbatCommonDBInterface>();
			executeCH_T_SAIKEN_CH_SELECT_044(new String[]{wksMisyuKingaku, super.opeDate, seikyKeiNo, seikyKeiNo});
			JBSbatCommonDBInterface saikenInfo = db_CH_T_SAIKEN.selectNext();
			while (saikenInfo != null)
			{
				minouAmntSum = minouAmntSum.add(new BigDecimal(getNullToZero(saikenInfo.getString("MINOU_AMNT"))));
				saikenList.add(saikenInfo);
				saikenInfo = db_CH_T_SAIKEN.selectNext();
			}
			nyukinAddDataMap.put(NKIN_INF_MINOU_AMNT_SUM_ALL, minouAmntSum.toString());
			nyukinAddDataMap.put(NKIN_INF_SAIKEN_LIST, saikenList);
		}
		
		// ■■■請求契約番号存在チェック
		JBSbatCommonDBInterface seikyKeiChk = (JBSbatCommonDBInterface)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_MAP);
		if (seikyKeiChk == null)
		{
			resultMap.put(JBSbatCHIFM433.ERR_CD, ERR_CD_E100);
			return resultMap;
		}
		
		// ■■■債権年月存在チェック
		executeCH_T_SAIKEN_CH_SELECT_045(new String[]{seikyKeiNo, seikyYm});
		JBSbatCommonDBInterface saikenChk = db_CH_T_SAIKEN.selectNext();
		if (saikenChk == null)
		{
			resultMap.put(JBSbatCHIFM433.ERR_CD, ERR_CD_E101);
			return resultMap;
		}
		
		ArrayList<JBSbatCommonDBInterface> saikenListAll = (ArrayList<JBSbatCommonDBInterface>)nyukinAddDataMap.get(NKIN_INF_SAIKEN_LIST);
		ArrayList<JBSbatCommonDBInterface> seikyYmJutoList = new ArrayList<JBSbatCommonDBInterface>();
		// 請求年月の未納額合計
		BigDecimal seikyYmMinouAmntSum = BigDecimal.ZERO;
		if (saikenListAll != null)
		{
			for (JBSbatCommonDBInterface saikenMap : saikenListAll)
			{
				BigDecimal minouAmnt = new BigDecimal(getNullToZero(saikenMap.getString("MINOU_AMNT")));
				
				// 未納額が０円以外、かつ、
				// 債権ステータスが"020"(請求確定)、かつ、
				// 請求種別コードが"0"(定例請求)、かつ、
				// 債権年月が入力ファイルの請求年月と一致する
				if (minouAmnt.compareTo(BigDecimal.ZERO) != 0
						&& JACStrConst.SAIKEN_STAT_FIX_SEIKY.equals(saikenMap.getString(JBSbatCH_T_SAIKEN.SAIKEN_STAT))
						&& JACStrConst.SIKYSHBTS_TEIGK_SEIKY.equals(saikenMap.getString(JBSbatCH_T_SAIKEN.SEIKY_SBT_CD))
						&& seikyYm.equals(saikenMap.getString(JBSbatCH_T_SAIKEN.SAIKEN_YM)))
				{
					seikyYmMinouAmntSum = seikyYmMinouAmntSum.add(minouAmnt);
					seikyYmJutoList.add(saikenMap);
				}
			}
		}
		
		// ■■■債権ステータスチェック
		if (seikyYmJutoList.size() == 0)
		{
			resultMap.put(JBSbatCHIFM433.ERR_CD, ERR_CD_E102);
			return resultMap;
		}
		
		// 充当リスト
		ArrayList<JBSbatCommonDBInterface> jutoList = (ArrayList<JBSbatCommonDBInterface>)nyukinAddDataMap.get(NKIN_INF_JUTO_LIST);
		if (jutoList == null)
		{
			jutoList = new ArrayList<JBSbatCommonDBInterface>();
		}
		
		jutoList.addAll(seikyYmJutoList);
		nyukinAddDataMap.put(NKIN_INF_JUTO_LIST, jutoList);
		
		// 未納額合計 対象
		BigDecimal minouAmntSumTrgt = new BigDecimal(getNullToZero((String)nyukinAddDataMap.get(NKIN_INF_MINOU_AMNT_SUM_TRGT)));
		nyukinAddDataMap.put(NKIN_INF_MINOU_AMNT_SUM_TRGT, minouAmntSumTrgt.add(seikyYmMinouAmntSum).toString());
		
		// チェックOK
		resultMap.put(JBSbatCHIFM433.NYUKIN_ADD_AMNT, seikyYmMinouAmntSum.toString());
		return resultMap;
	}
	
	/**
	 * 入力情報（一括入金登録指示ファイル）の単項目チェックを行います。
	 * <br>
	 * @param rsMap 入力データ（TXT又はDB）を格納されたHashMap。
	 * @param firstReccrdFlg 請求契約単位で先頭レコードを判別するフラグ
	 * @return エラー内容に該当する入金登録エラーコード。エラーなしの場合には空文字を返却。
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private String singleCheck(HashMap rsMap, boolean firstReccrdFlg) throws Exception
	{
		// 単項目チェックを行います
		String strValue = null;
		
		// ■■■請求契約番号項目チェック
		strValue = (String)rsMap.get(JBSbatCHIFM432.SEIKY_KEI_NO);
		
		// 必須チェック
		if(JACBatCommon.isNull(strValue))
		{
			return ERR_CD_E001;
		}
		// 桁数チェック
		if(!JBSbatCheckUtil.invoke(strValue, new String[]{"ketasuu1","10"}))
		{
			return ERR_CD_E001;
		}
		// 属性チェック
		if(!JBSbatCheckUtil.invoke(strValue, new String[]{"hannkakuesuuji1"}))
		{
			return ERR_CD_E001;
		}
		// 重複チェック
		if(seikyKeiNoZumiList.contains(strValue))
		{
			return ERR_CD_E009;
		}
		
		// ■■■請求年月項目チェック
		strValue = (String)rsMap.get(JBSbatCHIFM432.SEIKY_YM);
		
		// 必須チェック
		if(JACBatCommon.isNull(strValue))
		{
			return ERR_CD_E002;
		}
		// 桁数チェック
		if(!JBSbatCheckUtil.invoke(strValue, new String[]{"ketasuu1","6"}))
		{
			return ERR_CD_E002;
		}
		// 属性チェック
		if(!JBSbatCheckUtil.invoke(strValue, new String[]{"year_month1"}))
		{
			return ERR_CD_E002;
		}
		// 重複チェック
		if(seikyYmZumiList.contains(strValue))
		{
			return ERR_CD_E010;
		}
		else
		{
			seikyYmZumiList.add(strValue);
		}
		
		// 請求契約単位で先頭レコードの場合
		if (firstReccrdFlg)
		{
			// ■■■督促ステータス項目チェック
			strValue = (String)rsMap.get(JBSbatCHIFM432.TOKUSOKU_STAT);
			
			// 必須チェック
			if(JACBatCommon.isNull(strValue))
			{
				return ERR_CD_E003;
			}
			// 属性チェック
			if(!tokusokuStatMap.containsKey(strValue))
			{
				return ERR_CD_E003;
			}
			// 督促ステータスが「貸倒登録済」の場合、エラー
			if (JACStrConst.TOKUSOKU_STAT_KASHID_ZUMI.equals(strValue))
			{
				return ERR_CD_E011;
			}
			
			// ■■■対応履歴連動対象フラグ項目チェック
			strValue = (String)rsMap.get(JBSbatCHIFM432.TAIORRKI_RENDO_TG_FLG);
			
			// 必須チェック
			if(JACBatCommon.isNull(strValue))
			{
				return ERR_CD_E004;
			}
			// 属性チェック
			if(!taiorrkiRendoTgFlgMap.containsKey(strValue))
			{
				return ERR_CD_E004;
			}
			
			// ■■■記事項目チェック
			strValue = (String)rsMap.get(JBSbatCHIFM432.KIJI);
			
			// 必須チェック
			if(JACBatCommon.isNull(strValue))
			{
				return ERR_CD_E005;
			}
			// バイト数チェック
			if(JACbatRknBusinessUtil.getBytes(strValue, encode) > 200)
			{
				return ERR_CD_E005;
			}
		}
		// 請求契約単位で2件目以降の場合
		else
		{
			// ■■■督促ステータス項目チェック
			strValue = (String)rsMap.get(JBSbatCHIFM432.TOKUSOKU_STAT);
			
			// 設定された場合、エラー
			if(!JACBatCommon.isNull(strValue))
			{
				return ERR_CD_E006;
			}
			
			// ■■■対応履歴連動対象フラグ項目チェック
			strValue = (String)rsMap.get(JBSbatCHIFM432.TAIORRKI_RENDO_TG_FLG);
			
			// 設定された場合、エラー
			if(!JACBatCommon.isNull(strValue))
			{
				return ERR_CD_E007;
			}
			
			// ■■■記事項目チェック
			strValue = (String)rsMap.get(JBSbatCHIFM432.KIJI);
			
			// 設定された場合、エラー
			if(!JACBatCommon.isNull(strValue))
			{
				return ERR_CD_E008;
			}
		}
		
		return JACStrConst.KARA_MOJI;
	}
	
	/**
	 * 入金登録処理を行います。
	 * <br>
	 * @param seikyTaniErrFlg 請求契約単位エラーフラグ
	 * @param seikyKeiNoBrkKey 請求契約番号（ブレイクキー）
	 * @param outFileDateList 出力用データリスト
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @return 正常の場合はtrue、異常の場合はfalse
	 * @throws Exception 
	 */
	private boolean executeNyukinAdd(boolean seikyTaniErrFlg,
										String seikyKeiNoBrkKey,
										ArrayList<HashMap<String, String>> outFileDateList,
										HashMap<String, Object> nyukinAddDataMap)throws Exception
	{
		// 入金登録完了フラグ
		boolean nyukinAddZmFlg = false;
		
		// ■■■請求契約単位チェック
		// チェックエラーありの場合
		if (seikyTaniErrFlg)
		{
			// 結果ファイル作成
			createChlst10502(outFileDateList, ERR_CD_E200, JACStrConst.KARA_MOJI, nyukinAddZmFlg);
		}
		// チェックエラーなしの場合
		else
		{
			// 預り金リスト
			ArrayList<JBSbatCommonDBInterface> azukinList = new ArrayList<JBSbatCommonDBInterface>();
			
			// 預り金残高
			BigDecimal azukinAmnt = BigDecimal.ZERO;
			
			// 預り金残高を取得する
			executeCH_T_KNK_CH_SELECT_012(new String[]{seikyKeiNoBrkKey, JACStrConst.PRC_KMK_CD_AZUKIN});
			JBSbatCommonDBInterface knkInfo = db_CH_T_KNK.selectNext();
			while (knkInfo != null)
			{
				azukinAmnt = azukinAmnt.add(new BigDecimal(getNullToZero(knkInfo.getString(JBSbatCH_T_KNK.KNK_AMNT))));
				azukinList.add(knkInfo);
				knkInfo = db_CH_T_KNK.selectNext();
			}
			nyukinAddDataMap.put(NKIN_INF_AZUKIN_AMNT, azukinAmnt.toString());
			nyukinAddDataMap.put(NKIN_INF_AZUKIN_LIST, azukinList);
			
			// 未納額合計 対象
			BigDecimal minouAmntSumTrgt = new BigDecimal(getNullToZero((String)nyukinAddDataMap.get(NKIN_INF_MINOU_AMNT_SUM_TRGT)));
			
			// 未納額合計が預り金残高を超えた場合
			if (minouAmntSumTrgt.compareTo(azukinAmnt) > 0)
			{
				// 結果ファイル作成
				createChlst10502(outFileDateList, ERR_CD_E201, JACStrConst.KARA_MOJI, nyukinAddZmFlg);
			}
			else
			{
				// 入金登録サービス情報
				HashMap<String, Object> outputMap = null;
				
				// 入金登録のためサービスを呼び出す
				try
				{
					outputMap = invokeService(nyukinAddDataMap);
				}
				catch (Throwable e)
				{
					// 何もしない
				}
				
				// リターンコード 
				String returnCode = JCCBatchEsbInterface.getReturnCode(outputMap);
				
				// 異常の場合
				if(!JCCBatchEsbInterface.RETURN_CODE_SUCCESS.equals(returnCode))
				{
					createChlst10502(outFileDateList, ERR_CD_E900, JACStrConst.KARA_MOJI, nyukinAddZmFlg);
				}
				// 正常の場合
				else
				{
					nyukinAddZmFlg = true;
					
					// 督促情報更新
					String tokusokuErrCd = updateTokusoku(seikyKeiNoBrkKey, nyukinAddDataMap);
					
					// 異常終了の場合
					if (!JACBatCommon.isNull(tokusokuErrCd))
					{
						// 結果ファイル作成
						createChlst10502(outFileDateList, tokusokuErrCd, azukinAmnt.subtract(minouAmntSumTrgt).toString(), nyukinAddZmFlg);
					}
					// 正常終了の場合
					else
					{
						// 結果ファイル作成
						createChlst10502(outFileDateList, ERR_CD_0000, azukinAmnt.subtract(minouAmntSumTrgt).toString(), nyukinAddZmFlg);
					}
					
				}
			}
		}
		
		// 請求契約番号リストに処理済の請求契約番号を追加する
		if (!JACBatCommon.isNull(seikyKeiNoBrkKey) && !seikyKeiNoZumiList.contains(seikyKeiNoBrkKey))
		{
			seikyKeiNoZumiList.add(seikyKeiNoBrkKey);
		}
		
		return nyukinAddZmFlg;
	}
	
	/**
	 * サービス呼出処理
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @return サービスの処理結果
	 * @throws Exception
	 */
	private HashMap<String, Object> invokeService(HashMap<String, Object> nyukinAddDataMap) throws Exception
	{
		// サービス呼び出し時の引数を生成
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		paramMap.put(JCCBatchEsbInterface.TELEGRAM_INFO_USECASE_ID, "CHSV0010");
		paramMap.put(JCCBatchEsbInterface.TELEGRAM_INFO_OPERATION_ID, "CHSV0010OP");
		
		// サービスに渡す業務データを格納するMAP
		HashMap<String, Object> inDataMap = new HashMap<String, Object>();
		
		setCHSV001001CC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		setPRCSCHDLTEIGI(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_2);
		setSEIKYUCWKSAIKEN(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		setUPDATESEIKYUCWK(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		setTOKUSOKUUNIQUE(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_2);
		setTOKUSOKUSTATUS(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		setTOKUSOKUSAIKENKANREN(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		setUPDATETOKUSOKU(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		setHURYOCUSTDELCC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		setINSERTTOKUSOKUIDO(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		setJKKUSESTPRLSRUNCC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		setRUNCCFLG(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		setTAIOKIROKADDCC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		setADDHOTVOICCC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		setPRCTAIOKIROKADDCC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		setJKKUSESTPKAIJOADDSHIJISHOCC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		
		// サービスの処理結果が格納されるMAP
		HashMap<String, Object> outputMap = new HashMap<String, Object>();
		
		// サービス呼び出し
		JCCBatchEsbInterface.invokeService(super.commonItem, paramMap, inDataMap, outputMap);
		
		return outputMap;
	}
	
	/**
	 * 上りマッピングをする
	 * 
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private HashMap setCHSV001001CC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code) throws Exception
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);
		
		// "90"(金庫充当) → 入金登録債権充当マップ.入金経路コード
		parentMap.put("nyukin_route_cd", JACStrConst.NYKNKEIRCD_JUTO);

		// "90"(預り金充当) → 入金登録債権充当マップ.収納機関コード
		parentMap.put("shunokikan_cd", JACStrConst.SHNKKNCD_AZU_JUTO_PRC);

		// 運用日付 → 入金登録債権充当マップ.外部組織収納年月日
		parentMap.put("shuno_ymd", super.opeDate);

		// 運用日付 → 入金登録債権充当マップ.領収年月日
		parentMap.put("receipt_ymd", super.opeDate);

		// 入金額 → 入金登録債権充当マップ.入金額
		parentMap.put("nyukin_amnt", (String)nyukinAddDataMap.get(NKIN_INF_MINOU_AMNT_SUM_TRGT));

		// 請求契約番号 → 入金登録債権充当マップ.請求契約番号
		parentMap.put("seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));

		// 預り金 → 入金登録債権充当マップ.預り金
		parentMap.put("azukin", (String)nyukinAddDataMap.get(NKIN_INF_AZUKIN_AMNT));
		
		// 未収金額合計 → 入金登録債権充当マップ.未収金額合計
		parentMap.put("mishugokei", (String)nyukinAddDataMap.get(NKIN_INF_MINOU_AMNT_SUM_ALL));
		
		ArrayList list = new ArrayList();
		ArrayList allList = new ArrayList();
		
		// 充当リスト
		ArrayList<JBSbatCommonDBInterface> jutoList = (ArrayList<JBSbatCommonDBInterface>)nyukinAddDataMap.get(NKIN_INF_JUTO_LIST);
		
		if (jutoList != null)
		{
			for (JBSbatCommonDBInterface jutoMap : jutoList)
			{
				HashMap childMap = new HashMap();
				
				// 未納債権一覧情報.債権番号 → 入金登録債権充当マップ.債権充当明細リスト.債権番号
				childMap.put("saiken_no", jutoMap.getString(JBSbatCH_T_SAIKEN.SAIKEN_NO));

				// 未納債権一覧情報.更新年月日時分秒 → 入金登録債権充当マップ.債権充当明細リスト.更新前債権更新年月日時分秒
				childMap.put("saiken_upd_dtm_af", jutoMap.getString(JBSbatCH_T_SAIKEN.UPD_DTM));

				// 未納債権一覧情報.未納額 → 入金登録債権充当マップ.債権充当明細リスト.充当額
				childMap.put("juto_amnt", jutoMap.getString("MINOU_AMNT"));

				// 未納債権一覧情報.未納額 → 入金登録債権充当マップ.債権充当明細リスト.充当額＿行合計
				childMap.put("juto_line_amnt", jutoMap.getString("MINOU_AMNT"));

				// 未納債権一覧情報.未納額 → 入金登録債権充当マップ.債権充当明細リスト.未収額
				childMap.put("misyu_amnt", jutoMap.getString("MINOU_AMNT"));

				// 未納債権一覧情報.預り金 → 入金登録債権充当マップ.債権充当明細リスト.預り金
				childMap.put("azukin", (String)nyukinAddDataMap.get(NKIN_INF_AZUKIN_AMNT));

				// 未納債権一覧情報.債権ステータスコード → 入金登録債権充当マップ.債権充当明細リスト.債権ステータスコード
				childMap.put("saiken_stat_cd", jutoMap.getString(JBSbatCH_T_SAIKEN.SAIKEN_STAT));

				// 未納債権一覧情報.未納額合計 → 入金登録債権充当マップ.債権充当明細リスト.充当額合計
				childMap.put("juto_amnt_sum", (String)nyukinAddDataMap.get(NKIN_INF_MINOU_AMNT_SUM_TRGT));

				// 未納債権一覧情報.入金額 → 入金登録債権充当マップ.債権充当明細リスト.入金額
				childMap.put("nyukin_amnt", (String)nyukinAddDataMap.get(NKIN_INF_MINOU_AMNT_SUM_TRGT));

				// 未納債権一覧情報.支払方法コード → 入金登録債権充当マップ.債権充当明細リスト.支払方法コード
				childMap.put("seiky_way_cd", jutoMap.getString(JBSbatCH_T_SAIKEN.SEIKY_WAY_CD));

				// 未納債権一覧情報.債権年月 → 入金登録債権充当マップ.債権充当明細リスト.請求年月
				childMap.put("seiky_ym", jutoMap.getString(JBSbatCH_T_SAIKEN.SAIKEN_YM));

				// 未納債権一覧情報.請求番号 → 入金登録債権充当マップ.債権充当明細リスト.請求番号
				childMap.put("seiky_no", jutoMap.getString(JBSbatCH_T_SEIKY_SKN_KNRN.SEIKY_NO));
				
				list.add(childMap);
			}
		}
		
		// 債権リスト
		ArrayList<JBSbatCommonDBInterface> saikenListAll = (ArrayList<JBSbatCommonDBInterface>)nyukinAddDataMap.get(NKIN_INF_SAIKEN_LIST);
		
		if (saikenListAll != null)
		{
			for (JBSbatCommonDBInterface saikenMap : saikenListAll)
			{
				HashMap allChildMap = new HashMap();
				
				// 未納債権一覧情報.債権番号 → 入金登録債権充当マップ.債権充当明細リスト.債権番号
				allChildMap.put("saiken_no", saikenMap.getString(JBSbatCH_T_SAIKEN.SAIKEN_NO));

				// 未納債権一覧情報.未納額 → 入金登録債権充当マップ.債権充当明細リスト.未収額
				allChildMap.put("misyu_amnt", saikenMap.getString("MINOU_AMNT"));
				
				allList.add(allChildMap);
			}
		}
		
		parentMap.put("saiken_juto_list", list);
		parentMap.put("saiken_all_list", allList);
		
		list = new ArrayList();
		
		// 預り金リスト
		ArrayList<JBSbatCommonDBInterface> azukinList = (ArrayList<JBSbatCommonDBInterface>)nyukinAddDataMap.get(NKIN_INF_AZUKIN_LIST);
		
		if (azukinList != null)
		{
			for (JBSbatCommonDBInterface azukinMap : azukinList)
			{
				HashMap childMap = new HashMap();
				
				// 預り金明細情報.金庫番号 → 入金登録債権充当マップ.預り金明細リスト.金庫番号
				childMap.put("knk_no", azukinMap.getString(JBSbatCH_T_KNK.KNK_NO));

				// 預り金明細情報.精算方法コード → 入金登録債権充当マップ.預り金明細リスト.精算方法コード
				childMap.put("ssn_way_cd", azukinMap.getString(JBSbatCH_T_KNK.SSN_WAY_CD));

				// 預り金明細情報.金庫金額 → 入金登録債権充当マップ.預り金明細リスト.金庫金額
				childMap.put("knk_amnt", azukinMap.getString(JBSbatCH_T_KNK.KNK_AMNT));

				// 預り金明細情報.入金番号 → 入金登録債権充当マップ.預り金明細リスト.入金番号
				childMap.put("nyukin_no", azukinMap.getString(JBSbatCH_T_KNK.NYUKIN_NO));

				// 預り金明細情報.金庫更新年月日時分秒 → 入金登録債権充当マップ.預り金明細リスト.金庫更新年月日時分秒
				childMap.put("knk_upd_dtm", azukinMap.getString(JBSbatCH_T_KNK.UPD_DTM));
				
				list.add(childMap);
			}
		}

		parentMap.put("azukin_list", list);

		outputMap.put("CHSV001001CC", parentMap);

		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setPRCSCHDLTEIGI(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		// 部品呼び出し → 料金スケジュール定義一意照会マップ.ＫＥＹ＿運用日
		parentMap.put("key_unyo_day", super.opeDate);

		outputMap.put("PRCSCHDLTEIGI", parentMap);

		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setSEIKYUCWKSAIKEN(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		// 請求契約番号 → 請求内訳債権番号一覧照会マップ１.ＫＥＹ＿請求契約番号
		parentMap.put("key_seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));

		outputMap.put("MAP_SEIKY_UCWK", parentMap);

		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setUPDATESEIKYUCWK(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		// 入金フラグ
		parentMap.put("nyukin_flg", JACStrConst.AMNT_HANNEI_CD_GNSN);

		outputMap.put("UPDSEIKYUW", parentMap);
		outputMap.put("ADDSEIKYUW", parentMap);
		outputMap.put("DELSEIKYUW", parentMap);

		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setTOKUSOKUUNIQUE(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		// 請求契約番号 → 督促一意照会マップ.ＫＥＹ＿請求契約番号
		parentMap.put("key_seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));

		// 部品呼び出し → 督促一意照会マップ.ＫＥＹ＿督促管理年月日
		parentMap.put("key_tokusoku_kanri_ymd", super.opeDate);

		outputMap.put("TOKUSOKUUNIQUE", parentMap);

		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setTOKUSOKUSTATUS(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		outputMap.put("TOKUSOKUSTATUS", parentMap);

		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setTOKUSOKUSAIKENKANREN(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		outputMap.put("TOKUSOKUSAIKENKANREN", parentMap);

		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setUPDATETOKUSOKU(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		// 部品呼び出し → 督促異動イベントコード（入金登録画面）
		parentMap.put("tokusoku_ido_evnt_cd", JACStrConst.TKSKIDO_EVCD_NYKIN_ADD_DISP);

		outputMap.put("UPDATETOKUSOKU", parentMap);

		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setHURYOCUSTDELCC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		// 請求契約番号 → 不良顧客削除マップ.請求契約番号
		parentMap.put("key_seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));

		// 料金対応記録追加モード"1"(請求先単位)
		parentMap.put("prc_taio_kirok_add_mode", "1");

		// 料金対応記録種別コード
		parentMap.put("prc_taio_kirok_sbt_cd", JACStrConst.TKRK_SBT_NYUKIN_ADD);

		outputMap.put("HURYOCUSTDELCC", parentMap);

		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setINSERTTOKUSOKUIDO(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		// 部品呼び出し → 督促異動イベントコード（入金登録画面）
		parentMap.put("tokusoku_ido_event_cd", JACStrConst.TKSKIDO_EVCD_NYKIN_ADD_DISP);

		outputMap.put("INSERTTOKUSOKUIDO", parentMap);

		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setRUNCCFLG(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		outputMap.put("RUNCCFLG", parentMap);

		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setJKKUSESTPRLSRUNCC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		// 請求契約番号 → 利用停止解除対象抽出マップ.抽出対象請求契約番号
		parentMap.put("chsht_trgt_seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));

		outputMap.put("JKKUSESTPRLSRUNCC", parentMap);

		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setTAIOKIROKADDCC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		String wkkbtOrgCd = userMap.get(USER_INF_WKKBT_ORG_CD);
		String wkkbtOrgNm = userMap.get(USER_INF_WKKBT_ORG_NM);
		String userId = userMap.get(USER_INF_USER_ID);
		String userNm = userMap.get(USER_INF_USER_NM);
		String dtm = JCCBatCommon.getSysDateTime();

		ArrayList<HashMap<String, Object>> taioKirokAddList = new ArrayList<HashMap<String, Object>>();

		HashMap<String, Object> childMap = new HashMap<String, Object>();

		// 入金登録["112"固定] → 対応記録登録マップ.応対区分カテゴリーリスト.料金対応記録種別コード
		childMap.put("prc_taio_kirok_sbt_cd", JACStrConst.TKRK_SBT_NYUKIN_ADD);

		// 手動入金(一括)["1304"固定] → 対応記録登録マップ.応対区分カテゴリーリスト.料金対応記録種別詳細コード
		childMap.put("prc_taio_kirok_dtl_bunrui_cd", JACStrConst.TKRK_SBTD_IKT_MANUAL_NYUKIN);

		// "一括入金登録" → 対応記録登録マップ.対応記録登録リスト.タイトル
		childMap.put("title", JACStrConst.TKRK_TITLE_IKT_NYUKIN_ADD);

		// 記事 → 対応記録登録マップ.対応記録登録リスト.問合せ内容
		childMap.put("toiawase_naiyo", (String)nyukinAddDataMap.get(NKIN_INF_KIJI));

		// 業務個別設定組織コード → 対応記録登録マップ.対応記録登録リスト.業務個別設定組織コード
		childMap.put("wkkbt_org_cd", wkkbtOrgCd);

		// 業務個別設定組織名 → 対応記録登録マップ.対応記録登録リスト.業務個別設定組織名
		childMap.put("wkkbt_org_nm", wkkbtOrgNm);

		// ユーザーＩＤ → 対応記録登録マップ.対応記録登録リスト.ユーザーＩＤ
		childMap.put("user_id", userId);

		// ユーザー名 → 対応記録登録マップ.対応記録登録リスト.ユーザー名
		childMap.put("user_nm", userNm);

		// 年月日時分秒 → 対応記録登録マップ.対応記録登録リスト.年月日時分秒
		childMap.put("dtm", dtm);

		// 応対区分カテゴリーリストの作成
		ArrayList<HashMap<String, Object>> rspCtgrList = new ArrayList<HashMap<String, Object>>();
		HashMap<String, Object> ctgrMap = new HashMap<String, Object>();

		// 入金登録["112"固定] → 対応記録登録マップ.応対区分カテゴリーリスト.料金対応記録種別コード
		ctgrMap.put("prc_taio_kirok_sbt_cd", JACStrConst.TKRK_SBT_NYUKIN_ADD);

		// 手動入金["1304"固定] → 対応記録登録マップ.応対区分カテゴリーリスト.料金対応記録種別詳細コード
		ctgrMap.put("prc_taio_kirok_dtl_bunrui_cd", JACStrConst.TKRK_SBTD_IKT_MANUAL_NYUKIN);

		// taio_kirok_add_listにrsp_ctgr_listを追加
		rspCtgrList.add(ctgrMap);
		childMap.put("rsp_ctgr_list", rspCtgrList);

		taioKirokAddList.add(childMap);

		parentMap.put("taio_kirok_add_list", taioKirokAddList);

		parentMap.put("seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));

		outputMap.put(JACStrConst.TAIOKIROKADDCC_MAP_ID, parentMap);

		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param bean　[0]：請求書再発行
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setADDHOTVOICCC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		// 応対区分カテゴリーリストの作成
		ArrayList<HashMap<String, Object>> rspCtgrList = new ArrayList<HashMap<String, Object>>();
		HashMap<String, Object> ctgrMap = new HashMap<String, Object>();
		rspCtgrList.add(ctgrMap);

		parentMap.put("RSP_CTGR_List", rspCtgrList);
		outputMap.put("ADDHOTVOICCC", parentMap);

		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * 
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private HashMap setPRCTAIOKIROKADDCC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code) throws Exception
	{
		String userId = userMap.get(USER_INF_USER_ID);
		HashMap<String, Object> parentMap = new HashMap<String, Object>();
		List<HashMap<String, Object>> list = new ArrayList();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		HashMap childMap = new HashMap();

		// ユーザＩＤ → 料金対応記録登録マップ.料金対応記録明細リスト.料金対応ユーザＩＤ
		childMap.put("prc_taio_user_id", userId);

		// 請求契約番号 → 料金対応記録登録マップ.料金対応記録明細リスト.請求契約番号
		childMap.put("seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));

		// 料金対応記録種別コード(入金登録) → 料金対応記録登録マップ.料金対応記録明細リスト.料金対応記録種別コード
		childMap.put("prc_taio_kirok_sbt_cd", JACStrConst.TKRK_SBT_NYUKIN_ADD);

		// 料金対応記録種別詳細コード(手動入金(一括)) → 料金対応記録登録マップ.料金対応記録明細リスト.料金対応記録種別詳細コード
		childMap.put("prc_taio_kirok_sbt_dtl_cd", JACStrConst.TKRK_SBTD_IKT_MANUAL_NYUKIN);

		// 記事 → 料金対応記録登録マップ.料金対応記録明細リスト.記事
		childMap.put("kiji", (String)nyukinAddDataMap.get(NKIN_INF_KIJI));

		// "一括入金登録" → 対応記録登録マップ.対応記録登録リスト.タイトル
		childMap.put("title", JACStrConst.TKRK_TITLE_IKT_NYUKIN_ADD);

		// 未収金額合計（変更前） → 料金対応記録登録マップ.料金対応記録明細リスト.変更前金額
		childMap.put("chg_bf_amnt", (String)nyukinAddDataMap.get(NKIN_INF_MINOU_AMNT_SUM_ALL));

		// 未収金額合計から充当額を引いて未収金額合計（変更後）を算出する
		BigDecimal mishuGokei = new BigDecimal(getNullToZero((String)nyukinAddDataMap.get(NKIN_INF_MINOU_AMNT_SUM_ALL)));
		BigDecimal jutoSum = new BigDecimal(getNullToZero((String)nyukinAddDataMap.get(NKIN_INF_MINOU_AMNT_SUM_TRGT)));
		BigDecimal mishuGokeiAf = mishuGokei.subtract(jutoSum);

		// 未収金額合計（変更後） → 料金対応記録登録マップ.料金対応記録明細リスト.変更後金額
		childMap.put("chg_af_amnt", String.valueOf(mishuGokeiAf));

		// 記録対象年月
		String kirokTgYm = JACStrConst.KARA_MOJI;
		
		// 充当リスト
		ArrayList<JBSbatCommonDBInterface> jutoList = (ArrayList<JBSbatCommonDBInterface>)nyukinAddDataMap.get(NKIN_INF_JUTO_LIST);
		
		if (jutoList != null)
		{
			for (JBSbatCommonDBInterface jutoMap : jutoList)
			{
				// 請求年月
				String seikyYm = getNullToStr(jutoMap.getString(JBSbatCH_T_SAIKEN.SAIKEN_YM));
				
				// 最新の請求年月を取得する
				if (JACBatCommon.isNull(kirokTgYm) || kirokTgYm.compareTo(seikyYm) < 0)
				{
					kirokTgYm = seikyYm;
				}
			}
		}
		
		// 未納債権一覧情報.請求年月 → 料金対応記録登録マップ.料金対応記録明細リスト.記録対象年月
		childMap.put("kirok_tg_ym", kirokTgYm);

		// 対応履歴表示 → 料金対応記録登録マップ.料金対応記録明細リスト.対応履歴連動対象フラグ
		childMap.put("taiorrki_rendo_tg_flg", (String)nyukinAddDataMap.get(NKIN_INF_TAIORRKI_RENDO_TG_FLG));

		list.add(childMap);

		parentMap.put("prc_taio_kirok_list", list);

		outputMap.put(JACStrConst.PRCTAIOKIROKADDCC_MAP_ID, parentMap);

		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param bean　[0]：入金登録　[1]：共有フォームBean
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setJKKUSESTPKAIJOADDSHIJISHOCC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);
		// 利用停止後指示書登録CC内で呼ばれるmapper部品内ではこちらを使用しているので設定する。
		parentMap.put("func_cd", func_code);

		// 請求契約番号 → 利用停止解除後指示書登録マップ.請求契約番号
		parentMap.put("seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));

		outputMap.put("JKKUSESTPKAIJOADDSHIJISHOCC", parentMap);
						
		return outputMap;
	}
	
	/**
	 * 一括入金登録処理結果ファイル作成処理
	 * @param outFileDateList 出力用データリスト
	 * @param errCd エラーコード
	 * @param azukinAmnt 預り金残高
	 * @param nyukinAddZmFlg 入金登録完了フラグ
	 * @throws Exception
	 */
	private void createChlst10502(ArrayList<HashMap<String, String>> outFileDateList, String errCd, String azukinAmnt, boolean nyukinAddZmFlg) throws Exception
	{
		for (HashMap<String, String> dateMap : outFileDateList)
		{
			ArrayList<String> dataInfo = new ArrayList<String>();
			
			// エラーコード
			String errCdRow = dateMap.get(JBSbatCHIFM433.ERR_CD);
			if (JACBatCommon.isNull(errCdRow))
			{
				errCdRow = errCd;
			}
			
			// エラー内容
			String errNaiyoRow = JACStrConst.KARA_MOJI;
			if (!JACBatCommon.isNull(errCdRow))
			{
				errNaiyoRow = iktNyukinAddErrCdMap.get(errCdRow);
			}
			
			// エラーコード
			dataInfo.add(getNullToStr(errCdRow));
			// エラー内容
			dataInfo.add(getNullToStr(errNaiyoRow));
			// 請求契約番号
			dataInfo.add(getNullToStr(dateMap.get(JBSbatCHIFM432.SEIKY_KEI_NO)));
			// 請求年月
			dataInfo.add(getNullToStr(dateMap.get(JBSbatCHIFM432.SEIKY_YM)));
			// 督促ステータス
			dataInfo.add(getNullToStr(dateMap.get(JBSbatCHIFM432.TOKUSOKU_STAT)));
			// 対応履歴連動対象フラグ
			dataInfo.add(getNullToStr(dateMap.get(JBSbatCHIFM432.TAIORRKI_RENDO_TG_FLG)));
			// 記事
			dataInfo.add(getNullToStr(dateMap.get(JBSbatCHIFM432.KIJI)));
			
			// 正常の場合
			if (nyukinAddZmFlg)
			{
				// 入金登録金額
				dataInfo.add(getNullToStr(dateMap.get(JBSbatCHIFM433.NYUKIN_ADD_AMNT)));
				// 預り金残高
				dataInfo.add(getNullToStr(azukinAmnt));
			}
			else
			{
				// 入金登録金額
				dataInfo.add(JACStrConst.KARA_MOJI);
				// 預り金残高
				dataInfo.add(JACStrConst.KARA_MOJI);
			}
			
			JCCBatCommon.printDoubleQuoteBusinessFileUtil(chlst10502Obj, dataInfo);
			
			// 出力件数カウントアップ
			chlst10502Cnt++;
		}
	}
	
	/**
	 * 督促更新を行います。
	 * <br>
	 * @param seikyKeiNo 請求契約番号
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @return エラー内容に該当する入金登録エラーコード。エラーなしの場合には空文字を返却。
	 * @throws Exception 
	 */
	private String updateTokusoku(String seikyKeiNo, HashMap<String, Object> nyukinAddDataMap)throws Exception
	{
		// 変更前督促ステータス 初期値：督促なし
		String tokusokuStatBf = JACStrConst.TOKUSOKU_STAT_NASHI;
		
		// 変更前督促情報を取得する
		executeCH_T_TOKUSOKU_CH_SELECT_011(new String[]{seikyKeiNo, super.opeDate, super.opeDate});
		JBSbatCommonDBInterface tokusokuInfoMap = db_CH_T_TOKUSOKU.selectNext();
		
		// 督促情報が存在する場合
		if (tokusokuInfoMap != null)
		{
			tokusokuStatBf = getNullToStr(tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.TOKUSOKU_STAT));
		}
		
		// 変更前督促ステータスが「督促なし」の場合、正常終了
		if (JACStrConst.TOKUSOKU_STAT_NASHI.equals(tokusokuStatBf))
		{
			return JACStrConst.KARA_MOJI;
		}
		
		// 変更後督促ステータス
		String tokusokuStatAf = getNullToStr((String)nyukinAddDataMap.get(NKIN_INF_TOKUSOKU_STAT));
		
		// 変更前督促ステータスが変更後督促ステータスと一致する場合、正常終了
		if (tokusokuStatBf.equals(tokusokuStatAf))
		{
			return JACStrConst.KARA_MOJI;
		}
		
		// 変更前督促ステータスが「貸倒登録済」の場合、異常終了
		if (JACStrConst.TOKUSOKU_STAT_KASHID_ZUMI.equals(tokusokuStatBf))
		{
			return ERR_CD_W001;
		}
		
		// 督促ステータス変更条件取得
		JBSbatCommonDBInterface tkskstChgJknMap = getTokusokuStatChgKhInfo(tokusokuStatBf, tokusokuStatAf);
		
		// 督促ステータスが変更不可の組み合わせの場合、異常終了
		if (tkskstChgJknMap == null)
		{
			return ERR_CD_W001;
		}
		
		// 対象請求契約番号のサービス契約ステータスを取得する
		executeGetSvcKeiStat(seikyKeiNo);
		
		
		// 督促状況更新サービス情報
		HashMap<String, Object> outputMap = null;
		
		// 督促状況更新のためサービスを呼び出す
		try
		{
			outputMap = executeUpdTokusokuStat(nyukinAddDataMap, tokusokuInfoMap, tkskstChgJknMap);
		}
		catch (Throwable e)
		{
			// 何もしない
		}
		
		// リターンコード 
		String returnCode = JCCBatchEsbInterface.getReturnCode(outputMap);
		
		// 異常の場合
		if(!JCCBatchEsbInterface.RETURN_CODE_SUCCESS.equals(returnCode))
		{
			return ERR_CD_W002;
		}
		
		return JACStrConst.KARA_MOJI;
	}
	
	/**
	 * 督促ステータス変更条件スキーマの検索を行います。
	 * @param tokusokuStatBf 変更前督促ステータス
	 * @param tokusokuStatAf 変更後督促ステータス
	 * @return JBSbatCommonDBInterface 取得結果
	 * @throws Exception 業務サービス内で発生した例外全般。
	 */
	private JBSbatCommonDBInterface getTokusokuStatChgKhInfo(String tokusokuStatBf, String tokusokuStatAf) throws Exception
	{
		JBSbatCommonDBInterface whereMap = new JBSbatCommonDBInterface();
		// 変更前督促ステータス
		whereMap.setValue(tokusokuStatBf);
		// 変更後督促ステータス
		whereMap.setValue(tokusokuStatAf);
		// 変更可否（可）
		whereMap.setValue(JACStrConst.CHG_KH_PSB);
		// 督促ステータス変更条件適用開始年月日
		whereMap.setValue(super.opeDate);
		// 督促ステータス変更条件適用終了年月日
		whereMap.setValue(super.opeDate);
		// 予約適用年月日
		whereMap.setValue(super.opeDate);
		
		// SQL実行
		executeCH_M_TKSKST_CHG_JKN_CH_SELECT_001(whereMap.getList().toArray());
		
		// 結果を取得
		JBSbatCommonDBInterface dbMap = db_CH_M_TKSKST_CHG_JKN.selectNext();
		
		return dbMap;
	}
	
	/**
	 * 現在処理中の請求契約番号をキーとして、サービスを使用してサービス契約ステータスを取得します。
	 * @param seikyKeiNo 請求契約番号
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void executeGetSvcKeiStat(String seikyKeiNo) throws Exception
	{
		try
		{
			// サービス呼び出し時の引数を生成
			HashMap<String, Object> paramMap = new HashMap<String, Object>();
			paramMap.put(JCCBatchEsbInterface.TELEGRAM_INFO_USECASE_ID, "CHSV0076");
			paramMap.put(JCCBatchEsbInterface.TELEGRAM_INFO_OPERATION_ID, "CHSV0076OP");
			
			// サービスに渡す業務データを格納するMAP
			HashMap<String, HashMap<String, Object>> inputMap = new HashMap<String, HashMap<String, Object>>();
			HashMap<String, Object> dataMap = new HashMap<String, Object>();
			
			// 請求契約番号
			dataMap.put("key_seiky_kei_no", seikyKeiNo);
			// 機能コード
			dataMap.put("func_code", JPCModelConstant.FUNC_CD_1);
			// 設定したマップをSCのタイトルをキーとして設定する
			inputMap.put("CHSV007601SC" , dataMap);
			
			// サービスの処理結果が格納されるMAP
			HashMap<Object, Object> outputMap = new HashMap<Object, Object>();
			
			// サービス呼び出し
			JCCBatchEsbInterface.invokeService(super.commonItem, paramMap, inputMap, outputMap);
			
			// サービスの処理結果が格納されたoutputMapからリターンコードを取得する。
			String returnCode = JCCBatchEsbInterface.getReturnCode(outputMap);
			
			if(!JCCBatchEsbInterface.RETURN_CODE_SUCCESS.equals(returnCode))
			{
				return;
			}
			
			// 戻り値からサービス契約ステータスを取り出して変数に保持
			HashMap<String, Object> returnMap = (HashMap<String, Object>)outputMap.get("CHSV007601SC");
			if (returnMap != null)
			{
				ArrayList retList = (ArrayList)returnMap.get("EKK0081B514CBSMsg1List");
				
				// サービスからの戻り値リストが空でない場合、1件目を取得する
				if (retList != null && retList.size() > 0)
				{
					HashMap<String, Object> returnMap2 = (HashMap<String, Object>)retList.get(0);
					
					// サービス契約ステータスの値を取得する
					this.svcKeiStat = getNullToStr((String)returnMap2.get("svc_kei_stat"));
				}
			}
		}
		catch (Throwable e)
		{
			// 何もしない
		}
		
		return;
	}
	
	/**
	 * 現在処理中の請求契約番号レコードが、利用停止処理対象であるかを判定します。
	 * @param tkskstChgJknMap 督促ステータス更新判定マップ
	 * @return 利用停止対象の場合true
	 * @throws Exception
	 */
	private boolean isUseStop(JBSbatCommonDBInterface tkskstChgJknMap) throws Exception
	{
		// 督促ステータス更新判定マップより、利用停止フラグを取得
		String flg = tkskstChgJknMap.getString(JBSbatCH_M_TKSKST_CHG_JKN.USE_STP_TG_FLG);
		
		// 利用停止フラグ＝１、かつサービス契約ステータスが「サービス提供中」「休止・中断中」の場合対象とする
		if (JACStrConst.USE_STP_TG_RLS_FLG_ON.equals(flg)
				&& (JACStrConst.SVC_KEI_STAT_SVCTK.equals(this.svcKeiStat)
						|| JACStrConst.SVC_KEI_STAT_KYUSHI.equals(this.svcKeiStat)))
		{
			return true;
		}
		
		return false;
	}
	
	/**
	 * 現在処理中の請求契約番号レコードが、利用停止解除処理対象であるかを判定します。
	 * @param tkskstChgJknMap 督促ステータス更新判定マップ
	 * @return 利用停止解除対象の場合true
	 * @throws Exception
	 */
	private boolean isUseStopRls(JBSbatCommonDBInterface tkskstChgJknMap) throws Exception
	{
		// 督促ステータス更新判定マップより、利用停止解除フラグを取得
		String flg = tkskstChgJknMap.getString(JBSbatCH_M_TKSKST_CHG_JKN.USE_STP_RLS_TG_FLG);
		
		// 利用停止解除フラグ＝１、かつサービス契約ステータスが「サービス提供中」「休止・中断中」「停止中」の場合対象とする
		if (JACStrConst.USE_STP_TG_RLS_FLG_ON.equals(flg)
				&& (JACStrConst.SVC_KEI_STAT_SVCTK.equals(this.svcKeiStat)
						|| JACStrConst.SVC_KEI_STAT_KYUSHI.equals(this.svcKeiStat)
						|| JACStrConst.SVC_KEI_STAT_STP.equals(this.svcKeiStat)))
		{
			return true;
		}
		
		return false;
	}
	
	/**
	 * 現在処理中の請求契約番号レコードが、強制解約処理対象であるかを判定します。
	 * @param tkskstChgJknMap 督促ステータス更新判定マップ
	 * @return 強制解約対象の場合true
	 * @throws Exception
	 */
	private boolean isKsiDsl(JBSbatCommonDBInterface tkskstChgJknMap) throws Exception
	{
		// 督促ステータス更新判定マップより、強制解約フラグを取得
		String flg = tkskstChgJknMap.getString(JBSbatCH_M_TKSKST_CHG_JKN.KSI_DSL_TG_FLG);
		
		// 強制解約フラグ＝１、かつサービス契約ステータスが「締結済」「サービス提供中」「休止・中断中」「停止中」の場合対象とする
		if (JACStrConst.USE_STP_TG_RLS_FLG_ON.equals(flg)
				&& (JACStrConst.SVC_KEI_STAT_TIKT.equals(this.svcKeiStat)
						|| JACStrConst.SVC_KEI_STAT_SVCTK.equals(this.svcKeiStat)
						|| JACStrConst.SVC_KEI_STAT_KYUSHI.equals(this.svcKeiStat)
						|| JACStrConst.SVC_KEI_STAT_STP.equals(this.svcKeiStat)))
		{
			return true;
		}
		
		return false;
	}
	
	/**
	 * 督促状況更新サービス呼出処理
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param tokusokuInfoMap 督促情報マップ
	 * @param tkskstChgJknMap 督促ステータス変更条件マップ
	 * @return サービスの処理結果
	 * @throws Exception
	 */
	private HashMap<String, Object> executeUpdTokusokuStat(HashMap<String, Object> nyukinAddDataMap, JBSbatCommonDBInterface tokusokuInfoMap, JBSbatCommonDBInterface tkskstChgJknMap) throws Exception
	{
		// サービス呼び出し時の引数を生成
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		paramMap.put(JCCBatchEsbInterface.TELEGRAM_INFO_USECASE_ID, "CHSV0046");
		paramMap.put(JCCBatchEsbInterface.TELEGRAM_INFO_OPERATION_ID, "CHSV0046OP");
		
		// サービスに渡す業務データを格納するMAP
		HashMap<String, Object> inDataMap = new HashMap<String, Object>();
		
		// 督促変更
		setCHSV0046CHSV004601SC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1, tokusokuInfoMap, tkskstChgJknMap);
		// 督促異動登録
		setCHSV0046CHSV004602SC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1, tokusokuInfoMap);
		// 実行部品判定用フラグ設定
		setCHSV0046RUNCCFLG(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1, tkskstChgJknMap);
		// 利用停止実行部品CC（照会部呼出し）
		setCHSV0046JKKUSESTPRUNCC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		// 利用停止解除実行部品CC（照会部呼出し）
		setCHSV0046JKKUSESTPRLSRUNCC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		// 強制解約実行部品CC（照会部呼出し）
		setCHSV0046JKKKYOSEIDSLRUNCC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		// 請求抑止振分CC
		setCHSV0046SEIKYYOKSIHRIWAKECC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		// 対応記録登録CC
		setCHSV0046TAIOKIROKADDCC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		// ホットボイスCC
		setCHSV0046ADDHOTVOICCC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		// 督促状況更新マッピングCC（料金対応記録登録CC）
		setCHSV0046PRCTAIOKIROKTMP(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1, tokusokuInfoMap, tkskstChgJknMap);
		// 利用停止後指示書登録CC
		setCHSV0046JKKUSESTPKAIJOADDSHIJISHOCC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		// 利用停止後指示書登録CC
		setCHSV0046JKKUSESTPADDSHIJISHOCC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		// 料金指示書登録CC
		setCHSV0046JCHPRCSHIJISHOCC(nyukinAddDataMap, inDataMap, JPCModelConstant.FUNC_CD_1);
		
		// サービスの処理結果が格納されるMAP
		HashMap<String, Object> outputMap = new HashMap<String, Object>();
		
		// サービス呼び出し
		JCCBatchEsbInterface.invokeService(super.commonItem, paramMap, inDataMap, outputMap);
		
		return outputMap;
	}
	
	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 * @param tokusokuInfoMap 督促情報マップ
	 * @param tkskstChgJknMap 督促ステータス変更条件マップ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private HashMap setCHSV0046CHSV004601SC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code, JBSbatCommonDBInterface tokusokuInfoMap, JBSbatCommonDBInterface tkskstChgJknMap) throws Exception
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		// 督促番号 → 督促変更マップ.督促番号
		parentMap.put("tokusoku_no", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.TOKUSOKU_NO));
		// 変更督促ステータスコード → 督促変更マップ.督促ステータス
		parentMap.put("tokusoku_stat", (String)nyukinAddDataMap.get(NKIN_INF_TOKUSOKU_STAT));
		// 督促金額 → 督促変更マップ.更新前督促金額
		parentMap.put("tokusoku_amnt_bf", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.TOKUSOKU_AMNT));
		// 督促金額 → 督促変更マップ.異動金額
		parentMap.put("ido_amnt", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.TOKUSOKU_AMNT));
		// 支払約束受付年月日 → 督促変更マップ.支払約束受付年月日
		parentMap.put("pay_yakusoku_uk_ymd", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.PAY_YAKUSOKU_UK_YMD));
		// 支払約束日 → 督促変更マップ.支払約束年月日
		parentMap.put("pay_yakusoku_ymd", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.PAY_YAKUSOKU_YMD));
		// 支払約束日 → 督促変更マップ.変更支払約束年月日
		parentMap.put("pay_yakusoku_ymd_af", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.PAY_YAKUSOKU_YMD));
		// 支払約束履行判定日 → 督促変更マップ.支払約束履行判定年月日
		parentMap.put("pay_yakusoku_riko_ymd", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.PAY_YAKUSOKU_RIKO_JDG_YMD));
		// 支払約束履行判定日 → 督促変更マップ.変更支払約束履行判定年月日
		parentMap.put("pay_yakusoku_riko_ymd_af", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.PAY_YAKUSOKU_RIKO_JDG_YMD));
		// イベントコード"20"（督促ステータス変更有） → 督促変更マップ.督促異動イベントコード
		parentMap.put("tokusoku_ido_evnt_cd", JACStrConst.TKSKIDO_EVCD_TKSK_DISP_ARI);
		// 運用日付 → 督促変更マップ．督促異動年月日
		parentMap.put("tokusoku_ido_ymd", super.opeDate);
		// 更新年月日時分秒 → 督促変更マップ.更新前督促更新年月日時分秒
		parentMap.put("tokusoku_upd_dtm_af", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.UPD_DTM));
		// 督促終了年月日 → 督促変更マップ.督促管理終了年月日
		parentMap.put("tokusoku_endymd", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.TOKUSOKU_ENDYMD));
		
		// 利用停止解除フラグが1の場合、オンライン運用日に更新
		if (isUseStopRls(tkskstChgJknMap))
		{
			// 利用停止解除依頼年月日
			parentMap.put("use_stp_rls_ymd", super.opeDate);
		}
		// フラグが0の場合は現在の値のまま変更しない
		else
		{
			// 利用停止解除依頼年月日
			parentMap.put("use_stp_rls_ymd", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.USE_STP_RLS_REQ_YMD));
		}
		
		// 利用停止フラグが1の場合、オンライン運用日に更新
		if (isUseStop(tkskstChgJknMap))
		{
			// 利用停止依頼年月日
			parentMap.put("use_stp_ymd", super.opeDate);
		}
		// フラグが0の場合は現在の値のまま変更しない
		else
		{
			// 利用停止依頼年月日
			parentMap.put("use_stp_ymd", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.USE_STP_REQ_YMD));
		}
		
		// 強制解約フラグが1の場合、オンライン運用日に更新
		if (isKsiDsl(tkskstChgJknMap))
		{
			// 強制解約依頼年月日
			parentMap.put("kyosei_dsl_ymd", super.opeDate);
		}
		// フラグが0の場合は現在の値のまま変更しない
		else
		{
			// 強制解約依頼年月日
			parentMap.put("kyosei_dsl_ymd", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.KYOSEI_DSL_REQ_YMD));
		}
		
		// 債権回収委託会社委託処理年月日 → 督促変更マップ.債権回収委託会社委託処理年月日
		parentMap.put("sknksitkcm_itaku_tran_ymd", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.SKNKSITKCM_ITAKU_TRAN_YMD));
		
		// 空文字 → 督促変更マップ.貸倒処理年月日
		parentMap.put("kashid_tran_ymd", JACStrConst.KARA_MOJI);
		
		outputMap.put("CHSV004601SC", parentMap);
		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 * @param tokusokuInfoMap 督促情報マップ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private HashMap setCHSV0046CHSV004602SC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code, JBSbatCommonDBInterface tokusokuInfoMap) throws Exception
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);
		
		// 督促番号 
		parentMap.put("tokusoku_no", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.TOKUSOKU_NO));
		
		// 督促イベントコード
		parentMap.put("tokusoku_ido_event_cd", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.TOKUSOKU_IDO_EVENT_CD));
		
		// 督促ステータス
		parentMap.put("tokusoku_stat", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.TOKUSOKU_STAT));
		
		// 督促金額
		parentMap.put("tokusoku_amnt", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.TOKUSOKU_AMNT));
		
		// 督促異動年月日
		parentMap.put("tokusoku_ido_ymd", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.TOKUSOKU_IDO_YMD));
		
		// 支払約束受付年月日
		parentMap.put("pay_yakusoku_uk_ymd", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.PAY_YAKUSOKU_UK_YMD));
		
		// 支払約束年月日 
		parentMap.put("pay_yakusoku_ymd", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.PAY_YAKUSOKU_YMD));
		
		// 変更支払約束年月日 
		parentMap.put("pay_yakusoku_ymd_af", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.PAY_YAKUSOKU_YMD));
		
		// 支払約束履行判定年月日
		parentMap.put("pay_yakusoku_riko_ymd", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.PAY_YAKUSOKU_RIKO_JDG_YMD));
		
		// 変更支払約束履行判定年月日
		parentMap.put("pay_yakusoku_riko_ymd_af", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.PAY_YAKUSOKU_RIKO_JDG_YMD));

		outputMap.put("CHSV004602SC", parentMap);
		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 * @param tkskstChgJknMap 督促ステータス変更条件マップ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private HashMap setCHSV0046RUNCCFLG(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code, JBSbatCommonDBInterface tkskstChgJknMap) throws Exception
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);
		
		// 選択利用停止対象フラグ
		// 利用停止対象の場合、DBのフラグをそのまま渡す
		if (isUseStop(tkskstChgJknMap))
		{
			parentMap.put("use_stp_tg_flg", tkskstChgJknMap.getString(JBSbatCH_M_TKSKST_CHG_JKN.USE_STP_TG_FLG));
		}
		// 対象外の場合、フラグを固定0で渡す
		else
		{
			parentMap.put("use_stp_tg_flg", JACStrConst.USE_STP_TG_FLG_OFF);
		}
		
		// 選択利用停止解除対象フラグ
		// 利用停止対象外の場合、DBのフラグをそのまま渡す
		if (isUseStopRls(tkskstChgJknMap))
		{
			parentMap.put("use_stp_rls_tg_flg", tkskstChgJknMap.getString(JBSbatCH_M_TKSKST_CHG_JKN.USE_STP_RLS_TG_FLG));
		}
		// 対象外の場合、フラグを固定0で渡す
		else
		{
			parentMap.put("use_stp_rls_tg_flg", JACStrConst.USE_STP_TG_RLS_FLG_OFF);
		}
		
		// 選択強制解約対象フラグ
		// 強制解約対象の場合、DBのフラグをそのまま渡す
		if (isKsiDsl(tkskstChgJknMap))
		{
			parentMap.put("ksi_dsl_tg_flg", tkskstChgJknMap.getString(JBSbatCH_M_TKSKST_CHG_JKN.KSI_DSL_TG_FLG));
		}
		// 対象外の場合、フラグを固定0で渡す
		else
		{
			parentMap.put("ksi_dsl_tg_flg", JACStrConst.KSI_DSL_TG_FLG_OFF);
		}
		
		outputMap.put("RUNCCFLG", parentMap);
		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setCHSV0046JKKUSESTPRUNCC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);
		
		// 請求契約番号 → 利用停止対象抽出マップ.抽出対象請求契約番号
		parentMap.put("chsht_trgt_seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));
		
		outputMap.put("JKKUSESTPRUNCC", parentMap);
		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setCHSV0046JKKUSESTPRLSRUNCC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);
		
		// 請求契約番号 → 利用停止解除対象抽出マップ.抽出対象請求契約番号
		parentMap.put("chsht_trgt_seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));

		outputMap.put("JKKUSESTPRLSRUNCC", parentMap);
		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setCHSV0046JKKKYOSEIDSLRUNCC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);
		
		// 請求契約番号 → 強制解約対象抽出マップ.抽出対象請求契約番号
		parentMap.put("chsht_trgt_seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));

		outputMap.put("KKSV017201CC", parentMap);
		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setCHSV0046SEIKYYOKSIHRIWAKECC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);
		
		// 請求抑止振分マップ
		ArrayList dataList = new ArrayList();
		HashMap<String, Object> wkDataMap = new HashMap<String, Object>();
		
		// 請求契約番号
		wkDataMap.put("seiky_kei_no", JACStrConst.KARA_MOJI);
		
		// 請求抑止コード
		wkDataMap.put("seiky_yoksi_cd", JACStrConst.KARA_MOJI);
		
		// 請求抑止フラグ
		wkDataMap.put("seiky_yoksi_flg", JACStrConst.KARA_MOJI);
		
		// 変更前抑止フラグ
		wkDataMap.put("henko_mae_yoksi_flg", JACStrConst.KARA_MOJI);
		
		// 抑止情報有無
		wkDataMap.put("yoksi_info_um", JACStrConst.KARA_MOJI);
		
		// 更新年月日時分秒（更新前）
		wkDataMap.put("upd_dtm_bf", JACStrConst.KARA_MOJI);
		
		dataList.add(wkDataMap);
		
		parentMap.put("seikyYoksiHriwakeList", dataList);
		
		outputMap.put("SEIKYYOKSIHRIWAKECC", parentMap);
		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setCHSV0046TAIOKIROKADDCC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();
		
		// 共通情報のマッピング
		parentMap.put("func_code", func_code);
		
		String wkkbtOrgCd = userMap.get(USER_INF_WKKBT_ORG_CD);
		String wkkbtOrgNm = userMap.get(USER_INF_WKKBT_ORG_NM);
		String userId = userMap.get(USER_INF_USER_ID);
		String userNm = userMap.get(USER_INF_USER_NM);
		String dtm = JCCBatCommon.getSysDateTime();
		
		ArrayList<String> prcTaioKirokSbtCdList = new ArrayList<String>();
		HashMap<String, Object> runMap = (HashMap<String, Object>)outputMap.get("RUNCCFLG");
		// 利用停止対象フラグ
		String useStpTgFlg = (String)runMap.get("use_stp_tg_flg");
		// 利用停止解除対象フラグ
		String useStpRlsTgFlg = (String)runMap.get("use_stp_rls_tg_flg");
		// 強制解約対象フラグ
		String ksiDslTgFlg = (String)runMap.get("ksi_dsl_tg_flg");
		
		// 料金対応記録種別詳細コード（督促ステータス変更）
		prcTaioKirokSbtCdList.add(JACStrConst.TKRK_SBTD_TOKUSOKU_ST_CHG);
		
		// ◇督促副次判定（利用停止、利用停止解除、強制解約）結果に応じた料金対応記録種別詳細コードを設定
		if(JACStrConst.USE_STP_TG_FLG_ON.equals(useStpTgFlg))
		{
			// 料金対応記録種別詳細コード（：利用停止実施）
			prcTaioKirokSbtCdList.add(JACStrConst.TKRK_SBTD_USE_STP_JSSI);
		}
		if(JACStrConst.USE_STP_TG_RLS_FLG_ON.equals(useStpRlsTgFlg))
		{
			// 料金対応記録種別詳細コード（：利用停止解除実施）
			prcTaioKirokSbtCdList.add(JACStrConst.TKRK_SBTD_USE_STP_CL);
		}
		if(JACStrConst.KSI_DSL_TG_FLG_ON.equals(ksiDslTgFlg))
		{
			// 料金対応記録種別詳細コード（：強制解約実施）
			prcTaioKirokSbtCdList.add(JACStrConst.TKRK_SBTD_KYOSEI_DSL_JSSI);
		}
		
		ArrayList<HashMap<String, Object>> taioKirokAddList = new ArrayList<HashMap<String, Object>>();

		for (int i = 0; i < prcTaioKirokSbtCdList.size(); i++)
		{
			HashMap<String, Object> childMap = new HashMap<String, Object>();

			if (prcTaioKirokSbtCdList.size() >0)
			{
				// 督促状況更新["107"固定] → 対応記録登録マップ.対応記録登録リスト.料金対応記録種別コード
				childMap.put("prc_taio_kirok_sbt_cd", JACStrConst.TKRK_SBT_TOKUSOKU_STAT_UPD);
				// 料金対応記録種別詳細コード → 対応記録登録マップ.対応記録登録リスト.料金対応記録種別詳細コード
				childMap.put("prc_taio_kirok_dtl_bunrui_cd", prcTaioKirokSbtCdList.get(0));
			}

			// "督促状況更新" → 対応記録登録マップ.対応記録登録リスト.タイトル
			childMap.put("title", JACStrConst.SCREEN_NAME_CHW01302);

			// 記事 → 対応記録登録マップ.対応記録登録リスト.問合せ内容
			childMap.put("toiawase_naiyo", (String)nyukinAddDataMap.get(NKIN_INF_KIJI));

			// 業務個別設定組織コード → 対応記録登録マップ.対応記録登録リスト.業務個別設定組織コード
			childMap.put("wkkbt_org_cd", wkkbtOrgCd);

			// 業務個別設定組織名 → 対応記録登録マップ.対応記録登録リスト.業務個別設定組織名
			childMap.put("wkkbt_org_nm", wkkbtOrgNm);

			// ユーザーＩＤ → 対応記録登録マップ.対応記録登録リスト.ユーザーＩＤ
			childMap.put("user_id", userId);

			// ユーザー名 → 対応記録登録マップ.対応記録登録リスト.ユーザー名
			childMap.put("user_nm", userNm);

			// 年月日時分秒 → 対応記録登録マップ.対応記録登録リスト.年月日時分秒
			childMap.put("dtm", dtm);

			// 応対区分カテゴリーリストの作成
			ArrayList<HashMap<String, Object>> rspCtgrList = new ArrayList<HashMap<String, Object>>();
			HashMap<String, Object> ctgrMap = new HashMap<String, Object>();

			// 料金対応記録種別コード(督促状況更新) → 対応記録登録マップ.料金対応記録種別コード
			ctgrMap.put("prc_taio_kirok_sbt_cd", JACStrConst.TKRK_SBT_TOKUSOKU_STAT_UPD);

			// 料金対応記録種別詳細コード → 対応記録登録マップ.料金対応記録種別詳細コード
			ctgrMap.put("prc_taio_kirok_dtl_bunrui_cd", prcTaioKirokSbtCdList.get(i));

			// 督促ステータスが変更されている場合
			if(JACStrConst.TKRK_SBTD_TOKUSOKU_ST_CHG.equals(prcTaioKirokSbtCdList.get(i)))
			{
				// 督促ステータス
				ctgrMap.put("tkskst", (String)nyukinAddDataMap.get(NKIN_INF_TOKUSOKU_STAT));
			}
			else
			{
				// 督促ステータス
				ctgrMap.put("tkskst", JACStrConst.KARA_MOJI);
			}
			
			// taio_kirok_add_listにrsp_ctgr_listを追加
			rspCtgrList.add(ctgrMap);
			childMap.put("rsp_ctgr_list", rspCtgrList);

			taioKirokAddList.add(childMap);
		}

		parentMap.put("taio_kirok_add_list", taioKirokAddList);

		parentMap.put("seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));

		outputMap.put(JACStrConst.TAIOKIROKADDCC_MAP_ID, parentMap);
		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setCHSV0046ADDHOTVOICCC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		// 応対区分カテゴリーリストの作成
		ArrayList<HashMap<String, Object>> rspCtgrList = new ArrayList<HashMap<String, Object>>();
		HashMap<String, Object> ctgrMap = new HashMap<String, Object>();
		rspCtgrList.add(ctgrMap);

		parentMap.put("RSP_CTGR_List", rspCtgrList);
		outputMap.put("ADDHOTVOICCC", parentMap);
		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 * @param tokusokuInfoMap 督促情報マップ
	 * @param tkskstChgJknMap 督促ステータス変更条件マップ
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private HashMap setCHSV0046PRCTAIOKIROKTMP(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code, JBSbatCommonDBInterface tokusokuInfoMap, JBSbatCommonDBInterface tkskstChgJknMap) throws Exception
	{
		String userId = userMap.get(USER_INF_USER_ID);

		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);
		
		// 請求契約番号
		parentMap.put("seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));
		
		// 督促番号
		parentMap.put("tokusoku_no", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.TOKUSOKU_NO));
		
		// 変更前督促ステータス
		parentMap.put("tokusoku_stat_bf", tkskstChgJknMap.getString(JBSbatCH_M_TKSKST_CHG_JKN.CHBF_TKSKST));
		
		// 変更後督促ステータス
		parentMap.put("tokusoku_stat_af", tkskstChgJknMap.getString(JBSbatCH_M_TKSKST_CHG_JKN.CHAF_TKSKST));
		
		// 支払約束日
		parentMap.put("pay_yakusoku_ymd", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.PAY_YAKUSOKU_YMD));
		
		// 変更支払約束日
		parentMap.put("pay_yakusoku_ymd_af", tokusokuInfoMap.getString(JBSbatCH_T_TOKUSOKU.PAY_YAKUSOKU_YMD));
		
		// 利用停止対象フラグ
		// 利用停止対象の場合、DBのフラグをそのまま渡す
		if (isUseStop(tkskstChgJknMap))
		{
			parentMap.put("use_stp_tg_flg", tkskstChgJknMap.getString(JBSbatCH_M_TKSKST_CHG_JKN.USE_STP_TG_FLG));
		}
		// 対象外の場合、フラグを固定0で渡す
		else
		{
			parentMap.put("use_stp_tg_flg", JACStrConst.USE_STP_TG_FLG_OFF);
		}
		
		// 利用停止解除対象フラグ
		// 利用停止対象外の場合、DBのフラグをそのまま渡す
		if (isUseStopRls(tkskstChgJknMap))
		{
			parentMap.put("use_stp_rls_tg_flg", tkskstChgJknMap.getString(JBSbatCH_M_TKSKST_CHG_JKN.USE_STP_RLS_TG_FLG));
		}
		// 対象外の場合、フラグを固定0で渡す
		else
		{
			parentMap.put("use_stp_rls_tg_flg", JACStrConst.USE_STP_TG_RLS_FLG_OFF);
		}
		
		// 強制解約対象フラグ
		// 強制解約対象の場合、DBのフラグをそのまま渡す
		if (isKsiDsl(tkskstChgJknMap))
		{
			parentMap.put("ksi_dsl_tg_flg", tkskstChgJknMap.getString(JBSbatCH_M_TKSKST_CHG_JKN.KSI_DSL_TG_FLG));
		}
		// 対象外の場合、フラグを固定0で渡す
		else
		{
			parentMap.put("ksi_dsl_tg_flg", JACStrConst.KSI_DSL_TG_FLG_OFF);
		}
		
		// タイトル
		parentMap.put("title", JACStrConst.SCREEN_NAME_CHW01302);
		
		// 記事
		parentMap.put("kiji", (String)nyukinAddDataMap.get(NKIN_INF_KIJI));
		
		// 対応履歴連動対象フラグ
		parentMap.put("taiorrki_rendo_tg_flg", (String)nyukinAddDataMap.get(NKIN_INF_TAIORRKI_RENDO_TG_FLG));

		// 料金対応ユーザID 
		parentMap.put("prc_taio_user_id", userId);
		
		outputMap.put("PRCTAIOKIROKTMP", parentMap);
		return outputMap;
	}

	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setCHSV0046JKKUSESTPKAIJOADDSHIJISHOCC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);
		// 利用停止後指示書登録CC内で呼ばれるmapper部品内ではこちらを使用しているので設定する。
		parentMap.put("func_cd", func_code);

		// 請求契約番号 → 利用停止解除後指示書登録マップ.請求契約番号
		parentMap.put("seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));

		outputMap.put("JKKUSESTPKAIJOADDSHIJISHOCC", parentMap);
		return outputMap;
	}
	
	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 */
	@SuppressWarnings("unchecked")
	private HashMap setCHSV0046JKKUSESTPADDSHIJISHOCC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);
		// 利用停止後指示書登録CC内で呼ばれるmapper部品内ではこちらを使用しているので設定する。
		parentMap.put("func_cd", func_code);

		// 請求契約番号 → 利用停止後指示書登録マップ.請求契約番号
		parentMap.put("seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));

		outputMap.put("JKKUSESTPADDSHIJISHOCC", parentMap);
		return outputMap;
	}
	
	/**
	 * 上りマッピングをする
	 * @param nyukinAddDataMap 入金登録用データマップ
	 * @param outputMap
	 * @param func_code　機能コード
	 * @param flg　督促登録フラグ
	 */
	@SuppressWarnings("unchecked")
	private HashMap setCHSV0046JCHPRCSHIJISHOCC(HashMap<String, Object> nyukinAddDataMap, HashMap outputMap, String func_code)
	{
		HashMap<String, Object> parentMap = new HashMap<String, Object>();

		// 共通情報のマッピング
		parentMap.put("func_code", func_code);

		// 請求契約番号 → 料金指示書登録マップ.請求契約番号
		parentMap.put("seiky_kei_no", (String)nyukinAddDataMap.get(NKIN_INF_SEIKY_KEI_NO));
		// 変更督促ステータスコード → 料金指示書登録マップ.督促ステータス
		parentMap.put("tokusoku_stat", (String)nyukinAddDataMap.get(NKIN_INF_TOKUSOKU_STAT));
		
		HashMap<String, Object> runMap = (HashMap<String, Object>)outputMap.get("RUNCCFLG");
		// 実行判定用のフラグを設定
		parentMap.put("use_stp_tg_flg", (String)runMap.get("use_stp_tg_flg"));
		parentMap.put("use_stp_rls_tg_flg", (String)runMap.get("use_stp_rls_tg_flg"));
		parentMap.put("ksi_dsl_tg_flg", (String)runMap.get("ksi_dsl_tg_flg"));
		
		outputMap.put("JCHPRCSHIJISHOCC", parentMap);
		return outputMap;
	}

	/**
	 * パラメタがNullの場合空白を返却します。
	 * @param str 文字列
	 * @return str
	 */
	private String getNullToStr(String str)
	{
		if (JACBatCommon.isNull(str))
		{
			return JACStrConst.KARA_MOJI;
		}
		
		return str;
	}
	
	/**
	 * パラメタがNullの場合ゼロを返却します。
	 * @param str 文字列
	 * @return str
	 */
	private String getNullToZero(String str)
	{
		if (JACBatCommon.isNull(str))
		{
			return "0";
		}
		
		return str;
	}
}