/*********************************************************************
*	All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名		：eo顧客基幹システム
*	モジュール名	：JKKejbRule0073001
*	ソースファイル名：JKKejbRule0073001.java
*	作成者			：富士通
*	日付			：2011年11月11日
*＜機能概要＞
*	開始日設定(サービス)相関ルール部品
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00.00	2011/11/11	FJ)			新規作成
*   v5.00.00    2013/010/2  FJ）寺園    OM-2013-0002814
*	v5.00.01	2013/10/10	FJ）小島	OM-2013-0003139
*	v5.00.02	2013/10/10	FJ）沖田	OM-2013-0003231
*	v7.00.00	2014/02/28	FJ）小島	OM-2014-0000806
*	v8.00.00	2014/05/02	FJ）小島	OM-2014-0001337
*	v8.00.01	2014/05/02	FJ）小島	OM-2014-0001337
*
**********************************************************************/

package eo.ejb.common.rule;

import java.util.HashMap;

import com.fujitsu.futurity.model.base.CAANException;
import com.fujitsu.futurity.model.base.CAANMsg;
import com.fujitsu.futurity.model.base.CAANRuntimeException;
import com.fujitsu.futurity.model.ejb.common.JSYejbLog;

import eo.ejb.cbm.entity.DK0011ETMsg;
import eo.ejb.cbm.entity.DK0011LE;
import eo.ejb.cbm.entity.DK0021ETMsg;
import eo.ejb.cbm.entity.DK0021LE;
import eo.ejb.cbm.entity.KK0081ETMsg;
import eo.ejb.cbm.entity.KK0251ETMsg;
import eo.ejb.cbm.entity.KK0341ETMsg;
import eo.ejb.cbm.entity.KK0341LE;
import eo.ejb.cbm.entity.KK0621ETMsg;
import eo.ejb.cbm.entity.KK0621LE;
import eo.ejb.cbm.entity.KK1471ETMsg;
import eo.ejb.cbm.entity.KK1471LE;
import eo.ejb.cbm.entity.KU0091ETMsg;
import eo.ejb.cbm.entity.KU0091LE;
import eo.ejb.cbm.entity.SC0021ETMsg;
import eo.ejb.cbm.entity.SC0021LE;
import eo.ejb.cbm.entity.TU0011ETMsg;
import eo.ejb.cbm.entity.TU0011LE;
import eo.ejb.cbm.entity.ZM0291ETMsg;
import eo.ejb.cbm.entity.ZM0291LE;
import eo.ejb.common.JKKModelCommon;
import eo.ejb.common.JKKModelConst;
import eo.ejb.common.db.JKKejbDK0011DBABase;
import eo.ejb.common.db.JKKejbKK0081DBABase;
import eo.ejb.common.db.JKKejbKK0251DBABase;
import eo.ejb.common.db.JKKejbKK0341DBABase;
import eo.ejb.common.db.JKKejbTU0011DBABase;

/**
 * <p>
 * 開始日設定(サービス)相関ルール部品クラスです。
 * </p>
 * @author 富士通
 */
public class JKKejbRule0073001 extends JKKejbRuleBase
{

	/** ルールID */
	private static final String RULE_ID = "RULE0073001";

	/** サービスコード */
	private static final String SVC_CD = "SVC_CD";

	/** 回線提供会社コード */
	private static final String KAISEN_TK_COMP_CD = "KAISEN_TK_COMP_CD";

	/** 料金グループコード */
	private static final String PRC_GRP_CD = "PRC_GRP_CD";

	/** 工事有無 */
	private static final String KOJI_UM = "KOJI_UM";

	/** 機器提供種別コード */
	private static final String KKTK_SBT_CD = "KKTK_SBT_CD";

	/** 番ポ有無 */
	private static final String BMP_UM = "BMP_UM";

	/** 異動区分 */
	private static final String IDO_DIV = "IDO_DIV";

	/** 機器出荷有無 */
	private static final String KKSHKA_UM = "KKSHKA_UM";

	/** 即時/翌月 */
	private static final String SKJ_YKJT = "SKJ_YKJT";
	
	/** 基準日 */
	private static final String STD_DT = "STD_DT";

	/** 基準日からの相対日 */
	private static final String RELATIVE_DATE_COUNT = "RELATIVE_DATE_COUNT";

	/** 実日/営業日 */
	private static final String COUNT_METHOD = "COUNT_METHOD";

	/** 優先基準日 */
	private static final String PRIORITY_STD_DT = "PRIORITY_STD_DT";

	/** 基準日(照査年月日) */
	private static final String STD_DT_SHOSA = "0";

	/** 基準日(工事完了年月日) */
	private static final String STD_DT_KOJI = "1";

	/** 基準日(配送完了年月日) */
	private static final String STD_DT_HAISO = "3";

	/** 基準日(NTT局内工事年月日) */
	private static final String STD_DT_NTT = "4";

	/** 基準日(番ポ工事完了年月日) */
	private static final String STD_DT_BMP = "5";

	/** 基準日(登録年月日) */
	private static final String STD_DT_INS = "6";

	/** 基準日(変更希望日) */
	private static final String STD_DT_UPD = "7";

	/** 基準日(OLT帯域変更日) */
	private static final String STD_DT_OLT = "8";

	/** 基準日(NTT局内工事年月日(連携ファイルコード='CF')) */
	private static final String STD_DT_NTT_CF = "9";

	/** 基準日(機器提供サービス契約サービス開始年月日) */
	private static final String STD_DT_KKTK_STA = "10";

	/** 実日/営業日(実日) */
	private static final String COUNT_METHOD_REALDAY = "0";

	/** 実日/営業日(営業日) */
	private static final String COUNT_METHOD_BUSIDAY = "1";

	/** 優先基準日(サービス開始希望日との大きい方) */
	private static final String PRIORITY_STD_DT_KIBO = "1";

	/** 優先基準日(VLAN-ID取込日との大きい方) */
	private static final String PRIORITY_STD_DT_VLAN = "2";

	/** 優先基準日(運用日) */
	private static final String PRIORITY_STD_DT_OPEDATE = "3";

	/** 優先基準日(サービス開始年月日との大きい方) */
	private static final String PRIORITY_STD_DT_STA_YMD = "4";

	/** 優先基準日(VLAN-ID取込日、サービス開始年月日との大きい方) */
	private static final String PRIORITY_STD_DT_VLAN_STA_YMD = "5";

	/** 回線提供会社コード(K-OPT) */
	private static final String KAISEN_TK_COMP_CD_K_OPT = "01";

	/** 回線提供会社コード(eモバイル) */
	private static final String KAISEN_TK_COMP_CD_E_MOBILE = "04";

	/** 回線提供会社コード(UQ-WiMAX) */
	private static final String KAISEN_TK_COMP_CD_UQ_WIMAX = "05";

	/** 機器提供サービスコード(光電話用VA) */
	private static final String KKTK_SVC_CD_EOH_TEL = "C004";

	/** 機器提供サービスコード(STB) */
	private static final String KKTK_SVC_CD_STB = "C009";

	/** 機器提供サービスコード(eoモバイル機器 e-mobile用) */
	private static final String KKTK_SVC_CD_EOM_E_MOBI = "C016";

	/** 機器提供サービスコード(eoモバイル機器 UQ用) */
	private static final String KKTK_SVC_CD_EOM_UQ = "C017";

	/** 連携ファイルコード_新規契約完了(サービス開通) */
	private static final String RENKEI_FILE_CD_SVC_KAITSU = "F";
	
	/** 連携ファイルコード_契約変更完了 */
	private static final String RENKEI_FILE_CD_KEI_CHG = "CF";

	/** 工事案件種別コード_プラン変更(収容替) */
	private static final String KOJIAK_SBT_CD_PLANHEN_SHUYOGAE = "009";

	/** 営業日フラグ(休日) */
	private static final String BUSIDAY_FLG_HOLIDAY = "0";

	/** 営業日フラグ(営業日) */
	private static final String BUSIDAY_FLG_BUSIDAY = "1";

	/** 無効フラグ 有効 */
	private static final String MKFLG_VALID = "0";
	
	/** 処理対象のCBSMsg */
	private CAANMsg inCBSMsg = null;

	/** サービスコード */
	private String svc_cd = null;

	/** 回線提供会社コード */
	private String kaisen_tk_comp_cd = null;

	/** 料金グループコード */
	private String prc_grp_cd = null;

	/** 工事有無 */
	private String koji_um = null;

	/** 機器提供種別コード */
	private String kktk_sbt_cd = null;

	/** 番ポ有無 */
	private String bmp_um = null;

	/** 異動区分 */
	private String ido_div = null;

	/** 機器出荷有無 */
	private String kkshka_um = null;

	/** 即時／翌月 */
	private String skj_ykjt = null;

	/** サービス契約番号 */
	private String svc_kei_no = null;

	/** サービス契約内訳番号 */
	private String svc_kei_ucwk_no = null;

	/** 申込明細番号 */
	private String mskm_dtl_no = null;

	/** サービス利用開始希望年月日 */
	private String svc_use_sta_kibo_ymd = null;

	/** 予約適用年月日 */
	private String rsv_aply_ymd = null;

	/** 照査年月日 */
	private String shosa_ymd = null;

	/** サービス開始年月日(入力) */
	private String svc_sta_ymd = null;

	
	/**
	 * <p>
	 * JKKejbRule0073001クラスのコンストラクタです。
	 * </p>
	 * @param inMsg 処理対象のCBSMsg
	 */
	public JKKejbRule0073001(CAANMsg inMsg)
	{
		super();
		this.inCBSMsg = inMsg;
	}

	/**
	 * <p>
	 * 処理対象のCBSMsgを取得します。
	 * </p>
	 * @return 処理対象のCBSMsg
	 */
	protected CAANMsg getCBSMsg()
	{
		return this.inCBSMsg;
	}

	/**
	 * <p>
	 * ルールIDを取得します。
	 * </p>
	 * @return ルールID
	 */
	protected String getRuleId()
	{
		return RULE_ID;
	}

	/**
	 * <p>
	 * ルールエンジンを複数条件モードで実行するか設定します。
	 * </p>
	 * @return 複数条件モードで実行する場合はtrue
	 */
	protected boolean isMultiMode()
	{
		return true;
	}

	/**
	 * <p>
	 * サービスコードを取得します。
	 * </p>
	 * @return サービスコード
	 */
	private String getSvc_cd()
	{
		return this.svc_cd;
	}

	/**
	 * <p>
	 * 回線提供会社コードを取得します。
	 * </p>
	 * @return 回線提供会社コード
	 */
	private String getKaisen_tk_comp_cd()
	{
		return this.kaisen_tk_comp_cd;
	}

	/**
	 * <p>
	 * 料金グループコードを取得します。
	 * </p>
	 * @return 料金グループコード
	 */
	private String getPrc_grp_cd()
	{
		return this.prc_grp_cd;
	}

	/**
	 * <p>
	 * 工事有無を取得します。
	 * </p>
	 * @return 工事有無
	 */
	private String getKoji_um()
	{
		return this.koji_um;
	}

	/**
	 * <p>
	 * 機器提供種別コードを取得します。
	 * </p>
	 * @return 機器提供種別コード
	 */
	private String getKktk_sbt_cd()
	{
		return this.kktk_sbt_cd;
	}

	/**
	 * <p>
	 * 番ポ有無を取得します。
	 * </p>
	 * @return 番ポ有無
	 */
	private String getBmp_um()
	{
		return this.bmp_um;
	}

	/**
	 * <p>
	 * 異動区分を取得します。
	 * </p>
	 * @return 異動区分
	 */
	private String getIdo_div()
	{
		return this.ido_div;
	}

	/**
	 * <p>
	 * 機器出荷有無を取得します。
	 * </p>
	 * @return 機器出荷有無
	 */
	private String getKkshka_um()
	{
		return this.kkshka_um;
	}
	
	/**
	 * <p>
	 * 即時／翌月を取得します。
	 * </p>
	 * @return 即時／翌月
	 */
	public String getSkj_ykjt()
	{
		return skj_ykjt;
	}

	/**
	 * <p>
	 * サービス契約番号を取得します。
	 * </p>
	 * @return サービス契約番号
	 */
	private String getSvc_kei_no()
	{
		return this.svc_kei_no;
	}

	/**
	 * <p>
	 * サービス契約内訳番号を取得します。
	 * </p>
	 * @return サービス契約内訳番号
	 */
	private String getSvc_kei_ucwk_no()
	{
		return this.svc_kei_ucwk_no;
	}

	/**
	 * <p>
	 * 申込明細番号を取得します。
	 * </p>
	 * @return 申込明細番号
	 */
	private String getMskm_dtl_no()
	{
		return this.mskm_dtl_no;
	}

	/**
	 * <p>
	 * サービス利用開始希望年月日を取得します。
	 * </p>
	 * @return サービス利用開始希望年月日
	 */
	private String getSvc_use_sta_kibo_ymd()
	{
		return this.svc_use_sta_kibo_ymd;
	}

	/**
	 * <p>
	 * 予約適用年月日を取得します。
	 * </p>
	 * @return 予約適用年月日
	 */
	private String getRsv_aply_ymd()
	{
		return this.rsv_aply_ymd;
	}

	/**
	 * <p>
	 * 照査年月日を取得します。
	 * </p>
	 * @return 照査年月日
	 */
	private String getShosa_ymd()
	{
		return this.shosa_ymd;
	}

	/**
	 * <p>
	 * サービス開始年月日(入力)を取得します。
	 * </p>
	 * @return サービス開始年月日(入力)
	 */
	private String getSvc_sta_ymd()
	{
		return this.svc_sta_ymd;
	}

	/**
	 * <p>
	 * サービスコードを設定します。
	 * </p>
	 * @param p_svc_cd サービスコード
	 */
	public void setSvc_cd(String p_svc_cd)
	{
		this.svc_cd = p_svc_cd;
	}

	/**
	 * <p>
	 * 回線提供会社コードを設定します。
	 * </p>
	 * @param p_kaisen_tk_comp_cd 回線提供会社コード
	 */
	public void setKaisen_tk_comp_cd(String p_kaisen_tk_comp_cd)
	{
		this.kaisen_tk_comp_cd = p_kaisen_tk_comp_cd;
	}

	/**
	 * <p>
	 * 料金グループコードを設定します。
	 * </p>
	 * @param p_prc_grp_cd 料金グループコード
	 */
	public void setPrc_grp_cd(String p_prc_grp_cd)
	{
		this.prc_grp_cd = p_prc_grp_cd;
	}

	/**
	 * <p>
	 * 工事有無を設定します。
	 * </p>
	 * @param p_koji_um 工事有無
	 */
	public void setKoji_um(String p_koji_um)
	{
		this.koji_um = p_koji_um;
	}

	/**
	 * <p>
	 * 機器提供種別コードを設定します。
	 * </p>
	 * @param p_kktk_sbt_cd 機器提供種別コード
	 */
	public void setKktk_sbt_cd(String p_kktk_sbt_cd)
	{
		this.kktk_sbt_cd = p_kktk_sbt_cd;
	}

	/**
	 * <p>
	 * 番ポ有無を設定します。
	 * </p>
	 * @param p_bmp_um 番ポ有無
	 */
	public void setBmp_um(String p_bmp_um)
	{
		this.bmp_um = p_bmp_um;
	}

	/**
	 * <p>
	 * 異動区分を設定します。
	 * </p>
	 * @param p_ido_div 異動区分
	 */
	public void setIdo_div(String p_ido_div)
	{
		this.ido_div = p_ido_div;
	}

	/**
	 * <p>
	 * 機器出荷有無を設定します。
	 * </p>
	 * @param p_kkshka_um 機器出荷有無
	 */
	public void setKkshka_um(String p_kkshka_um)
	{
		this.kkshka_um = p_kkshka_um;
	}

	/**
	 * <p>
	 * 即時／翌月を設定します。
	 * </p>
	 * @param p_skj_ykjt 即時／翌月
	 */	
	public void setSkj_ykjt(String p_skj_ykjt)
	{
		this.skj_ykjt = p_skj_ykjt;
	}

	/**
	 * <p>
	 * サービス契約番号を設定します。
	 * </p>
	 * @param p_svc_kei_no サービス契約番号
	 */
	public void setSvc_kei_no(String p_svc_kei_no)
	{
		this.svc_kei_no = p_svc_kei_no;
	}

	/**
	 * <p>
	 * サービス契約内訳番号を設定します。
	 * </p>
	 * @param p_svc_kei_ucwk_no サービス契約内訳番号
	 */
	public void setSvc_kei_ucwk_no(String p_svc_kei_ucwk_no)
	{
		this.svc_kei_ucwk_no = p_svc_kei_ucwk_no;
	}

	/**
	 * <p>
	 * 申込明細番号を設定します。
	 * </p>
	 * @param p_mskm_dtl_no 申込明細番号
	 */
	public void setMskm_dtl_no(String p_mskm_dtl_no)
	{
		this.mskm_dtl_no = p_mskm_dtl_no;
	}

	/**
	 * <p>
	 * サービス利用開始希望年月日を設定します。
	 * </p>
	 * @param p_svc_use_sta_kibo_ymd サービス利用開始希望年月日
	 */
	public void setSvc_use_sta_kibo_ymd(String p_svc_use_sta_kibo_ymd)
	{
		this.svc_use_sta_kibo_ymd = p_svc_use_sta_kibo_ymd;
	}

	/**
	 * <p>
	 * 予約適用年月日を設定します。
	 * </p>
	 * @param p_rsv_aply_ymd 予約適用年月日
	 */
	public void setRsv_aply_ymd(String p_rsv_aply_ymd)
	{
		this.rsv_aply_ymd = p_rsv_aply_ymd;
	}

	/**
	 * <p>
	 * 照査年月日を設定します。
	 * </p>
	 * @param p_shosa_ymd 照査年月日
	 */
	public void setShosa_ymd(String p_shosa_ymd)
	{
		this.shosa_ymd = p_shosa_ymd;
	}

	/**
	 * <p>
	 * サービス開始年月日(入力)を設定します。
	 * </p>
	 * @param p_svc_sta_ymd サービス開始年月日(入力)
	 */
	public void setSvc_sta_ymd(String p_svc_sta_ymd)
	{
		this.svc_sta_ymd = p_svc_sta_ymd;
	}

	/**
	 * <p>
	 * 開始日設定(サービス)の相関ルールにより開始日を算出する。
	 * </p>
	 * @return 相関ルールの結果により取得した開始年月日
	 */
	public String getStaYmd()
	{
		// ログ出力
		execLogOutput();

		// ルールエンジンで使用する値を設定
		set(SVC_CD, getSvc_cd());
		set(KAISEN_TK_COMP_CD, getKaisen_tk_comp_cd());
		set(PRC_GRP_CD, getPrc_grp_cd());
		set(KOJI_UM, getKoji_um());
		set(KKTK_SBT_CD, getKktk_sbt_cd());
		set(BMP_UM, getBmp_um());
		set(IDO_DIV, getIdo_div());
		set(KKSHKA_UM, getKkshka_um());
		set(SKJ_YKJT, getSkj_ykjt());

		// ルールエンジンの実行
		super.execRuleEngine();

		// 実行結果が存在しない場合、nullを返す。
		if (!hasNext())
		{
			return null;
		}

		// ルールエンジン実行結果を取得
		HashMap<String, Object> retMap = getResultMap();

		// 基準日を取得
		String sStdDate = getStdDate(retMap);

		// 基準日が取得できなかった場合、nullを返す。
		if (null == sStdDate)
		{
			return null;
		}

		// 開始日を取得
		String sStaYmd = getStaYmd(retMap, sStdDate);

		// 開始日が取得できなかった場合、nullを返す。
		if (null == sStaYmd)
		{
			return null;
		}

		// 優先基準日と比較し、確定した開始日を返却する。
		return getConfStaYmd(retMap, sStaYmd);
	}

	/**
	 * <p>
	 * 基準日からの相対日にしたがって開始日を算出する。
	 * １．基準日からの相対日が空白の場合
	 *     相対日を「マンション基準日」として、基準日を開始日とする。
	 * ２．基準日からの相対日が空白以外の場合
	 *     2-1.実日/営業日が"実日"の場合
	 *         基準日に相対日を加算した日付を開始日として返却する。
	 *     2-2.実日/営業日が"営業日"の場合
	 *         基準日に相対日を加算した日付を開始日として返却する。
	 *         (営業日管理で営業日フラグが"休日"と指定されている日付は加算対象外)
	 * </p>
	 * @param retMap 相関ルール実行結果を格納したマップ
	 * @param sStdDate 基準日
	 * @return 基準日からの相対日にしたがって算出した開始日を返却する。
	 */
	private String getStaYmd(HashMap<String, Object> retMap, String sStdDate)
	{
		String sStaYmd = null;

		// 基準日からの相対日
		String sRelDateCnt = (String)retMap.get(RELATIVE_DATE_COUNT);

		// 基準日からの相対日が空白の場合
		if (null == sRelDateCnt || "".equals(sRelDateCnt))
		{
			// 相対日を「マンション基準日」として、基準日を開始日とする。
			sStaYmd = sStdDate;
		}
		// 基準日からの相対日が空白以外の場合
		else
		{
			// 基準日からの相対日を取得
			int iRelDateCnt = Integer.parseInt(sRelDateCnt);

			// 「実日/営業日」が"実日"の場合
			if (COUNT_METHOD_REALDAY.equals(retMap.get(COUNT_METHOD)))
			{
				// 基準日に相対日を加算した日付を開始日に設定
				sStaYmd = JKKModelCommon.addDay(sStdDate, iRelDateCnt);
			}
			// 「実日/営業日」が"営業日"の場合
			else if (COUNT_METHOD_BUSIDAY.equals(retMap.get(COUNT_METHOD)))
			{
				// カウント数保持変数(営業日フラグが休日の場合は加算しない)
				int iAddCnt = 0;

				// 開始日に基準日を設定
				sStaYmd = sStdDate;

				// 相対日分加算するまで繰り返す
				while(iAddCnt < iRelDateCnt)
				{
					// 翌日の日付を算出する。
					sStaYmd = JKKModelCommon.addDay(sStaYmd, 1);

					// 営業日管理レコードを取得
					CAANMsg[] retMsgZM0291 = getConditionZM0291(sStaYmd);

					// レコードが取得できなかった場合、nullを返却する。
					if (0 >= retMsgZM0291.length)
					{
						return null;
					}

					// 営業日フラグが「営業日」の場合
					if (BUSIDAY_FLG_BUSIDAY.equals(retMsgZM0291[0].getString(ZM0291ETMsg.BUSIDAY_FLG)))
					{
						// カウント数を加算する。
						iAddCnt++;
					}
				}
			}
		}

		// 「実日/営業日」が"営業日"の場合
		// (基準日からの相対日が+0で、基準日が休日の場合の対処)
		if (COUNT_METHOD_BUSIDAY.equals(retMap.get(COUNT_METHOD)))
		{
			String sBusidayFlg = BUSIDAY_FLG_HOLIDAY;

			// 営業日フラグが「休日」の間、繰り返し実施
			while(BUSIDAY_FLG_HOLIDAY.equals(sBusidayFlg))
			{
				// 営業日管理レコードを取得
				CAANMsg[] retMsgZM0291 = getConditionZM0291(sStaYmd);
				
				// レコードが取得できなかった場合、nullを返却する。
				if (0 >= retMsgZM0291.length)
				{
					return null;
				}

				// 営業日フラグを取得
				sBusidayFlg = retMsgZM0291[0].getString(ZM0291ETMsg.BUSIDAY_FLG);

				// 営業日フラグが「休日」の場合
				if (BUSIDAY_FLG_HOLIDAY.equals(sBusidayFlg))
				{
					// 翌日の日付を算出する。
					sStaYmd = JKKModelCommon.addDay(sStaYmd, 1);
				}
			}
		}
		
		return sStaYmd;
	}

	/**
	 * <p>
	 * パラメータの対象年月日に紐づく有効な営業日管理の取得結果を返却する。
	 * </p>
	 * @param sTrgtYmd 対象年月日
	 * @return 営業日管理の取得結果を返却する。
	 */
	private CAANMsg[] getConditionZM0291(String sTrgtYmd)
	{
		CAANMsg[] retMsgZM0291 = null;

		try
		{
			// 営業日管理取得条件を設定する。
			CAANMsg inMsgZM0291 = new CAANMsg(ZM0291ETMsg.class.getName());
			inMsgZM0291.set(ZM0291ETMsg.TRGT_YMD, sTrgtYmd);
			inMsgZM0291.set(ZM0291ETMsg.MK_FLG, MKFLG_VALID);

			// 営業日管理を全件検索する。
			retMsgZM0291 = new ZM0291LE().findByCondition(inMsgZM0291);
		}
		catch (CAANException ce)
		{
			throw new CAANRuntimeException(ce);
		}

		return retMsgZM0291;
	}

	/**
	 * <p>
	 * メンバ変数のログ出力を行う。
	 * </p>
	 */
	private void execLogOutput()
	{
		// サービスコード
		JSYejbLog.println(JSYejbLog.DEBUG, getClass(), "JKKejbRule0073001.svc_cd=" + getSvc_cd());

		// 回線提供会社コード
		JSYejbLog.println(JSYejbLog.DEBUG, getClass(), "JKKejbRule0073001.kaisen_tk_comp_cd=" + getKaisen_tk_comp_cd());

		// 料金グループコード
		JSYejbLog.println(JSYejbLog.DEBUG, getClass(), "JKKejbRule0073001.prc_grp_cd=" + getPrc_grp_cd());

		// 工事有無
		JSYejbLog.println(JSYejbLog.DEBUG, getClass(), "JKKejbRule0073001.koji_um=" + getKoji_um());

		// 機器提供種別コード
		JSYejbLog.println(JSYejbLog.DEBUG, getClass(), "JKKejbRule0073001.kktk_sbt_cd=" + getKktk_sbt_cd());

		// 番ポ有無
		JSYejbLog.println(JSYejbLog.DEBUG, getClass(), "JKKejbRule0073001.bmp_um=" + getBmp_um());

		// 異動区分
		JSYejbLog.println(JSYejbLog.DEBUG, getClass(), "JKKejbRule0073001.ido_div=" + getIdo_div());

		// 機器出荷有無
		JSYejbLog.println(JSYejbLog.DEBUG, getClass(), "JKKejbRule0073001.kkshka_um=" + getKkshka_um());

		// サービス契約番号
		JSYejbLog.println(JSYejbLog.DEBUG, getClass(), "JKKejbRule0073001.svc_kei_no=" + getSvc_kei_no());

		// サービス契約内訳番号
		JSYejbLog.println(JSYejbLog.DEBUG, getClass(), "JKKejbRule0073001.svc_kei_ucwk_no=" + getSvc_kei_ucwk_no());

		// 申込明細番号
		JSYejbLog.println(JSYejbLog.DEBUG, getClass(), "JKKejbRule0073001.mskm_dtl_no=" + getMskm_dtl_no());

		// サービス利用開始希望年月日
		JSYejbLog.println(JSYejbLog.DEBUG, getClass(), "JKKejbRule0073001.svc_use_sta_kibo_ymd=" + getSvc_use_sta_kibo_ymd());

		// 予約適用年月日
		JSYejbLog.println(JSYejbLog.DEBUG, getClass(), "JKKejbRule0073001.rsv_aply_ymd=" + getRsv_aply_ymd());

		// 照査年月日
		JSYejbLog.println(JSYejbLog.DEBUG, getClass(), "JKKejbRule0073001.shosa_ymd=" + getShosa_ymd());

		// サービス開始年月日(入力)
		JSYejbLog.println(JSYejbLog.DEBUG, getClass(), "JKKejbRule0073001.svc_sta_ymd=" + getSvc_sta_ymd());
	}

	/**
	 * <p>
	 * 開始日を優先基準日と比較し、決定した開始日を返却する。
	 * １．優先基準日が"サービス開始希望日との大きい方"の場合
	 *     メンバ変数のサービス利用開始希望年月日と比較し、日付が大きいほうを
	 *     開始日として返却する。
	 * ２．優先基準日が"VLAN-ID取込日との大きい方"の場合
	 *     電話用VLANオーダの電話用VLANオーダ結果取込年月日時分秒の年月日と比較し
	 *     日付が大きいほうを開始日として返却する。
	 * </p>
	 * @param retMap 相関ルール実行結果を格納したマップ
	 * @param sStaYmd 開始日
	 * @return 優先基準日と比較し確定した開始日
	 */
	private String getConfStaYmd(HashMap<String, Object> retMap, String sStaYmd)
	{
		// 確定した開始日としてパラメータの開始日を設定しておく
		String sConfStaYmd = sStaYmd;

		// 優先基準日が"サービス開始希望日との大きい方"の場合
		if (PRIORITY_STD_DT_KIBO.equals(retMap.get(PRIORITY_STD_DT)))
		{
			// サービス利用開始希望年月日を取得
			String sSvcUseStaKiboYmd = getSvc_use_sta_kibo_ymd();

			// 開始日よりメンバ変数のサービス利用開始希望年月日のほうが大きい場合
			if (null != sSvcUseStaKiboYmd && 0 > sStaYmd.compareTo(sSvcUseStaKiboYmd))
			{
				// 開始日としてメンバ変数のサービス利用開始希望年月日を設定
				sConfStaYmd = sSvcUseStaKiboYmd;
			}
		}
		// 優先基準日が"VLAN-ID取込日との大きい方"の場合
		else if (PRIORITY_STD_DT_VLAN.equals(retMap.get(PRIORITY_STD_DT)))
		{
			// 電話用VLANオーダ結果取込年月日を取得
			String sTelVlanOdrRsltTrkmYmd = getTelVlanOdrRsltTrkmYmd();
			
			// 開始日より電話用VLANオーダ結果取込年月日時分秒の年月日のほうが大きい場合
			if (sTelVlanOdrRsltTrkmYmd != null && 0 > sStaYmd.compareTo(sTelVlanOdrRsltTrkmYmd))
			{
				// 開始日として電話用VLANオーダ結果取込年月日を設定
				sConfStaYmd = sTelVlanOdrRsltTrkmYmd;
			}
		}
		// 優先基準日が"運用日"の場合
		else if (PRIORITY_STD_DT_OPEDATE.equals(retMap.get(PRIORITY_STD_DT)))
		{
			sConfStaYmd = JKKModelCommon.getOpeDate(getCBSMsg());
		}
		// 優先基準日が"サービス開始年月日との大きい方"の場合
		else if(PRIORITY_STD_DT_STA_YMD.equals(retMap.get(PRIORITY_STD_DT)))
		{
			// サービス開始年月日(入力)を取得
			String svcStaYmd = getSvc_sta_ymd();

			// 開始日よりサービス開始年月日(入力)のほうが大きい場合
			if (null != svcStaYmd && 0 > sStaYmd.compareTo(svcStaYmd))
			{
				// 開始日としてサービス開始年月日(入力)を設定
				sConfStaYmd = svcStaYmd;
			}
		}
		// 優先基準日が"VLAN-ID取込日、サービス開始年月日との大きい方"の場合
		else if (PRIORITY_STD_DT_VLAN_STA_YMD.equals(retMap.get(PRIORITY_STD_DT)))
		{
			// VLAN-ID取込日(電話用VLANオーダ結果取込年月日時分秒の年月日)を取得
			String sTelVlanOdrRsltTrkmYmd = getTelVlanOdrRsltTrkmYmd();
			// サービス開始年月日(入力)を取得
			String svcStaYmd = getSvc_sta_ymd();
			
			// 開始日、サービス開始年月日(入力)よりVLAN-ID取込日のほうが大きい場合
			if (sTelVlanOdrRsltTrkmYmd != null
					&& sTelVlanOdrRsltTrkmYmd.compareTo(sStaYmd) > 0 && sTelVlanOdrRsltTrkmYmd.compareTo(svcStaYmd) > 0)
			{
				// 開始日として電話用VLANオーダ結果取込年月日を設定
				sConfStaYmd = sTelVlanOdrRsltTrkmYmd;
			}
			// 開始日、VLAN-ID取込日よりサービス開始年月日(入力)のほうが大きい場合
			else if (svcStaYmd != null && (sTelVlanOdrRsltTrkmYmd == null 
					|| svcStaYmd.compareTo(sStaYmd) > 0 && svcStaYmd.compareTo(sTelVlanOdrRsltTrkmYmd) > 0))
			{
				// 開始日としてサービス開始年月日(入力)を設定
				sConfStaYmd = svcStaYmd;
			}
		}

		return sConfStaYmd;
	}

	/**
	 * <p>
	 * 基準日とする値を取得する。
	 * </p>
	 * @param retMap 相関ルール実行結果を格納したマップ
	 * @return 相関ルールの実行結果の基準日が「サービス開始日」の場合
	 *          相関ルール実行結果のサービス開始年月日を返す。
	 *          相関ルールの実行結果の基準日が「プラン開始日」の場合
	 *          相関ルール実行結果のプラン開始年月日を返す。
	 */
	private String getStdDate(HashMap<String, Object> retMap)
	{
		String retStdDate = null;
		String sStdDate = (String)retMap.get(STD_DT);

		// 相関ルール実行結果の基準日が「照査年月日」の場合
		if (STD_DT_SHOSA.equals(sStdDate))
		{
			// メンバ変数に設定されている照査年月日を基準日に設定する。
			retStdDate = getShosa_ymd();
		}
		// 相関ルール実行結果の基準日が「工事完了年月日」の場合
		else if (STD_DT_KOJI.equals(sStdDate))
		{
			// サービス契約内訳番号が設定されていない場合
			if (null == getSvc_kei_ucwk_no())
			{
				// 工事完了ワークの工事案件実施年月日を基準日に設定する。
				retStdDate = getKojiAkJssiYmd(0);
			}
			// サービス契約内訳番号が設定されている場合
			else
			{
				// 工事完了ワークの工事案件実施年月日を基準日に設定する。
				retStdDate = getKojiAkJssiYmd(1);
			}
		}
		// 相関ルール実行結果の基準日が「配送完了年月日」の場合
		else if (STD_DT_HAISO.equals(sStdDate))
		{
			// 配送の配送完了年月日を基準日に設定する。
			retStdDate = getHaisoFinYmd();
		}
		// 相関ルール実行結果の基準日が「NTT局内工事年月日」の場合
		else if (STD_DT_NTT.equals(sStdDate))
		{
			// ADSL工事のNTT局内工事年月日を基準日に設定する。
			retStdDate = getNttKyokuNaiKojiYmd(RENKEI_FILE_CD_SVC_KAITSU);
		}
		// 相関ルール実行結果の基準日が「NTT局内工事年月日(連携ファイルコード='CF')」の場合
		else if (STD_DT_NTT_CF.equals(sStdDate))
		{
			// ADSL工事のNTT局内工事年月日を基準日に設定する。
			retStdDate = getNttKyokuNaiKojiYmd(RENKEI_FILE_CD_KEI_CHG);
		}
		// 相関ルール実行結果の基準日が「番ポ工事完了年月日」の場合
		else if (STD_DT_BMP.equals(sStdDate))
		{
			// 番ポ工事の番ポ工事完了年月日を基準日に設定する。
			retStdDate = getBmpKojiFinYmd();
		}
		// 相関ルール実行結果の基準日が「OLT帯域変更日」の場合
		else if (STD_DT_OLT.equals(sStdDate))
		{
			// 工事完了ワークの工事案件実施年月日を基準日に設定する。
			retStdDate = getKojiAkJssiYmd(2);
		}
		// 相関ルール実行結果の基準日が「登録年月日」の場合
		else if (STD_DT_INS.equals(sStdDate))
		{
			// メンバ変数に設定されている予約適用年月日を基準日に設定する。
			retStdDate = getRsv_aply_ymd();
		}
		// 相関ルール実行結果の基準日が「変更希望日」の場合
		else if (STD_DT_UPD.equals(sStdDate))
		{
			// メンバ変数に設定されている予約適用年月日を基準日に設定する。
			retStdDate = getRsv_aply_ymd();
		}
		// 相関ルール実行結果の基準日が「機器提供サービス契約サービス開始年月日」の場合
		else if (STD_DT_KKTK_STA.equals(sStdDate))
		{
			// 個別検索条件マップ
			HashMap<String, String[]> searchJknMap = new HashMap<String, String[]>();
			// 追加検索条件：機器提供サービス契約.機器提供サービスコード = "ＳＴＢ"
			String [] kktkSvcCdList = {KKTK_SVC_CD_STB};
			searchJknMap.put(KK0341ETMsg.KKTK_SVC_CD, kktkSvcCdList);
			
			// サービス契約内訳番号に紐づく「機器提供サービス契約」(ＳＴＢ)を取得する
			JKKejbKK0341DBABase kk0341Dba = new JKKejbKK0341DBABase();
			CAANMsg[] kk0341MsgList = kk0341Dba.getKK0341bySvcKeiUcwk(getSvc_kei_ucwk_no(), searchJknMap, JKKModelCommon.getOpeDate(getCBSMsg()), "1");
			
			// 解約済、キャンセル済を除外する
			kk0341MsgList = kk0341Dba.getKK0341OutDsLCl(kk0341MsgList);
			
			// テレビの「サービス契約内訳」配下のSTBの「機器提供サービス契約」は必ず１件存在する。
			if (kk0341MsgList.length != 1)
			{
				throw new CAANRuntimeException("テレビの「サービス契約内訳」配下のSTBの「機器提供サービス契約」が０件、または複数件存在します。");
			}
			
			// 「機器提供サービス契約」(ＳＴＢ)のサービス開始年月日を基準日に設定する。
			retStdDate = kk0341MsgList[0].getString(KK0341ETMsg.SVC_STA_YMD);
		}

		return retStdDate;
	}

	/**
	 * <p>
	 * パターン別の工事完了ワークを取得し、工事完了ワークの連携年月日、連携通番が
	 * 最大のレコードの工事案件実施年月日を返却する。
	 * @param ptnFlg パターンフラグ
	 *     0：基準日が「工事完了年月日」、メンバ変数にサービス契約内訳番号が設定されていない場合
	 *     1：基準日が「工事完了年月日」、メンバ変数にサービス契約内訳番号が設定されている場合
	 *     2：基準日が「OLT帯域変更日」の場合
	 * @return 工事案件実施年月日
	 */
	private String getKojiAkJssiYmd(int ptnFlg)
	{
		// 工事完了ワークを全件取得する。
		CAANMsg[] retMsgKK1471 = getArrayCAANMsgKK1471(ptnFlg);

		// 工事完了ワークから工事案件実施年月日を取得し、基準日に設定する。
		return getKojiakJssiYmdByKK1471(retMsgKK1471);
	}

	/**
	 * <p>
	 * 回線提供会社の条件別に、配送.配送完了年月日を返却する。
	 * １．回線提供会社が「UQ-WiMAX」の場合：機器提供サービスコードに
	 *    「eoモバイル機器 UQ用」を指定して配送完了年月日を取得する。
	 * ２．回線提供会社が「K-OPT」の場合：機器提供サービスコードに
	 *    「光電話用VA」を指定して配送完了年月日を取得する。
	 * ３．回線提供会社が「eモバイル」の場合：機器提供サービスコードに
	 *    「eoモバイル機器 e-mobile用」を指定して配送完了年月日を取得する。
	 * </p>
	 * @return 配送完了年月日
	 */
	private String getHaisoFinYmd()
	{
		String sHaisoFinYmd = null;

		// 回線提供会社が「UQ-WiMAX」の場合
		if (KAISEN_TK_COMP_CD_UQ_WIMAX.equals(getKaisen_tk_comp_cd()))
		{
			// 機器提供サービスコードに「eoモバイル機器 UQ用」を指定して配送完了年月日取得。
			sHaisoFinYmd = getHaisoFinYmdByKktkSvcCd(KKTK_SVC_CD_EOM_UQ);
		}
		// 回線提供会社が「K-OPT」の場合
		else if (KAISEN_TK_COMP_CD_K_OPT.equals(getKaisen_tk_comp_cd()))
		{
			// 機器提供サービスコードに「多機能ルータ」を指定して配送完了年月日取得。
			sHaisoFinYmd = getHaisoFinYmdByKktkSvcCd(JKKModelConst.KKTK_SVC_CD_TAKINORT);
			
			if (sHaisoFinYmd == null)
			{
				// 機器提供サービスコードに「光電話用VA」を指定して配送完了年月日取得。
				sHaisoFinYmd = getHaisoFinYmdByKktkSvcCd(KKTK_SVC_CD_EOH_TEL);
			}
		}
		// 回線提供会社が「eモバイル」の場合
		else if (KAISEN_TK_COMP_CD_E_MOBILE.equals(getKaisen_tk_comp_cd()))
		{
			// 機器提供サービスコードに「eoモバイル機器 e-mobile用」を指定して配送完了年月日取得。
			sHaisoFinYmd = getHaisoFinYmdByKktkSvcCd(KKTK_SVC_CD_EOM_E_MOBI);
		}

		return sHaisoFinYmd;
	}

	/**
	 * <p>
	 * １．パラメータの機器提供サービスコードに一致する、サービス契約に紐づく機器提供サービス契約の
	 *     カレントレコードを取得する。
	 * ２．取得した機器提供サービス契約のカレントレコードの機器提供サービス契約番号、申込明細番号で
	 *     紐づく配送対象物品を取得する。
	 * ３．取得した配送対象物品の配送番号に紐づく配送の配送完了年月日を返す。
	 * </p>
	 * @param kktkSvcCd 機器提供サービスコード
	 * @return 配送完了年月日
	 */
	private String getHaisoFinYmdByKktkSvcCd(String kktkSvcCd)
	{
		String sHaisoNo = null;

		try
		{
			CAANMsg retMsgKK0341 = null;
			
			if(JKKModelConst.KKTK_SVC_CD_TAKINORT.equals(kktkSvcCd)) {
				// 機器提供サービス契約のカレントレコードを取得する。
				retMsgKK0341 = getCurrentKK0341KaiSenUw(kktkSvcCd);
			} else {
				// 機器提供サービス契約のカレントレコードを取得する。
				retMsgKK0341 = getCurrentKK0341(kktkSvcCd);
			}
			
			// 機器提供サービス契約のカレントレコードが取得できなかった場合、nullを返却する。
			if (null == retMsgKK0341)
			{
				return null;
			}

			// 配送対象物品取得用の検索条件を設定する。
			CAANMsg inMsgDK0021 = new CAANMsg(DK0021ETMsg.class.getName());
			inMsgDK0021.set(DK0021ETMsg.KKTK_SVC_KEI_NO, retMsgKK0341.getString(KK0341ETMsg.KKTK_SVC_KEI_NO));
			inMsgDK0021.set(DK0021ETMsg.KIKI_CHG_NO, retMsgKK0341.getString(KK0341ETMsg.KIKI_CHG_NO));
			inMsgDK0021.set(DK0021ETMsg.MK_FLG, MKFLG_VALID);

			// 設定した検索条件から配送対象物品を全件取得する。
			CAANMsg[] retMsgDK0021 = new DK0021LE().findByCondition(inMsgDK0021);

			// 配送対象物品のレコードが取得できなかった場合、nullを返却する。
			if (0 >= retMsgDK0021.length)
			{
				return null;
			}

			for (int i = 0; i < retMsgDK0021.length; i++)
			{
				// 配送取得用の検索条件を設定する。
				CAANMsg inMsgDK0011 = new CAANMsg(DK0011ETMsg.class.getName());
				inMsgDK0011.set(DK0011ETMsg.HAISO_NO, retMsgDK0021[i].getString(DK0021ETMsg.HAISO_NO));
				inMsgDK0011.set(DK0011ETMsg.MK_FLG, MKFLG_VALID);
	
				// 配送を全件取得する。
				CAANMsg[] retMsgDK0011 = new DK0011LE().findByCondition(inMsgDK0011);
				retMsgDK0011 = new JKKejbDK0011DBABase().getDK0011OutStp(retMsgDK0011);
	
				// 配送のレコードが取得できなかった場合、nullを返却する。
				if (0 >= retMsgDK0011.length)
				{
					continue;
				}
	
				// 配送.配送完了年月日を取得する。
				sHaisoNo = retMsgDK0011[0].getString(DK0011ETMsg.HAISO_FIN_YMD);
				return sHaisoNo;
			}
		}
		catch (CAANException ce)
		{
			throw new CAANRuntimeException(ce);
		}

		return sHaisoNo;
	}

	/**
	 * <p>
	 * パラメータの機器提供サービスコードに一致する、サービス契約に紐づく
	 * 機器提供サービス契約のカレントレコードを取得する。
	 * </p>
	 * @param kktkSvcCd 機器提供サービスコード
	 * @return サービス契約に紐づく機器提供サービス契約(カレントレコード)
	 * @throws CAANException
	 */
	private CAANMsg getCurrentKK0341(String kktkSvcCd) throws CAANException
	{
		// 機器提供サービス契約全件取得用の検索条件を設定する。
		CAANMsg inMsgKK0341 = new CAANMsg(KK0341ETMsg.class.getName());
		inMsgKK0341.set(KK0341ETMsg.SVC_KEI_NO, getSvc_kei_no());
		inMsgKK0341.set(KK0341ETMsg.KKTK_SVC_CD, kktkSvcCd);
		inMsgKK0341.set(KK0341ETMsg.MK_FLG, MKFLG_VALID);

		// 設定した検索条件から機器提供サービス契約を全件取得する。
		CAANMsg[] retMsgKK0341 = new KK0341LE().findByCondition(inMsgKK0341);

		// レコードが取得できなかった場合、nullを返却する。
		if (0 >= retMsgKK0341.length)
		{
			return null;
		}

		// 機器提供サービス契約のカレントレコード取得用メッセージ作成
		CAANMsg inCurMsgKK0341 = new CAANMsg(KK0341ETMsg.class.getName());
		inCurMsgKK0341.set(KK0341ETMsg.KKTK_SVC_KEI_NO, retMsgKK0341[0].getString(KK0341ETMsg.KKTK_SVC_KEI_NO));
		inCurMsgKK0341.set(KK0341ETMsg.RSV_APLY_YMD, JKKModelCommon.getOpeDate(getCBSMsg()));

		// 機器提供サービス契約のカレントレコードを返却する。
		return new JKKejbKK0341DBABase().findByCurrent(inCurMsgKK0341);
	}

	/**
	 * <p>
	 * パターン別の工事完了ワークの取得結果配列を返却する。
	 * </p>
	 * @param ptnFlg パターンフラグ
	 *     0：基準日が「工事完了年月日」、メンバ変数にサービス契約内訳番号が設定されていない場合
	 *     1：基準日が「工事完了年月日」、メンバ変数にサービス契約内訳番号が設定されている場合
	 *     2：基準日が「OLT帯域変更日」の場合
	 * @return 工事完了ワーク取得結果
	 */
	private CAANMsg[] getArrayCAANMsgKK1471(int ptnFlg)
	{
		CAANMsg inMsgKK1471 = null;
		CAANMsg[] retMsgKK1471 = null;

		try
		{
			// 基準日が「工事完了年月日」、メンバ変数にサービス契約内訳番号が設定されていない場合
			// または、基準日が「OLT帯域変更日」の場合
			if (0 == ptnFlg || 2 == ptnFlg)
			{
				inMsgKK1471 = new CAANMsg(KK1471ETMsg.class.getName());
				inMsgKK1471.set(KK1471ETMsg.SVC_KEI_NO, getSvc_kei_no());
				inMsgKK1471.set(KK1471ETMsg.MK_FLG, MKFLG_VALID);

				// 基準日が「OLT帯域変更日」の場合
				if (2 == ptnFlg)
				{
					// 工事案件種別コードに「プラン変更(収容替) 」を指定
					inMsgKK1471.set(KK1471ETMsg.KOJIAK_SBT_CD, KOJIAK_SBT_CD_PLANHEN_SHUYOGAE);
				}

				// 設定した検索条件から工事完了ワークを全件取得する。
				retMsgKK1471 = new KK1471LE().findByCondition(inMsgKK1471);
			}
			// 基準日が「工事完了年月日」、メンバ変数にサービス契約内訳番号が設定されている場合
			else if (1 == ptnFlg)
			{
				// メンバ変数の申込明細番号に紐づく申込明細_工事案件を取得
				CAANMsg[] retMsgKU0091 = getArrayKU0091();

				// 申込明細_工事案件が取得できなかった場合、nullを返却する。
				if (0 >= retMsgKU0091.length)
				{
					return null;
				}

				// 工事完了ワーク取得用の検索条件を設定
				inMsgKK1471 = new CAANMsg(KK1471ETMsg.class.getName());
				inMsgKK1471.set(KK1471ETMsg.KOJIAK_NO, retMsgKU0091[0].getString(KU0091ETMsg.KOJIAK_NO));
				inMsgKK1471.set(KK1471ETMsg.MK_FLG, MKFLG_VALID);

				// 設定した検索条件から工事完了ワークを全件取得する。
				retMsgKK1471 = new KK1471LE().findByCondition(inMsgKK1471);
			}
		}	
		catch (CAANException ce)
		{
			throw new CAANRuntimeException(ce);
		}

		return retMsgKK1471;
	}

	/**
	 * <p>
	 * メンバ変数の申込明細番号に紐づく申込明細_工事案件の全件取得結果を返却する。
	 * </p>
	 * @return 申込明細_工事案件取得結果
	 * @throws CAANException
	 */
	private CAANMsg[] getArrayKU0091() throws CAANException
	{
		// 申込明細_工事案件の検索条件を設定
		CAANMsg inMsgKU0091 = new CAANMsg(KU0091ETMsg.class.getName());
		inMsgKU0091.set(KU0091ETMsg.MSKM_DTL_NO, getMskm_dtl_no());
		inMsgKU0091.set(KU0091ETMsg.MK_FLG, MKFLG_VALID);

		// 設定した検索条件から全件取得した結果を返却する。
		return new KU0091LE().findByCondition(inMsgKU0091);
	}

	/**
	 * <p>
	 * 工事完了ワークの連携年月日、連携通番が最大のレコードの工事案件実施年月日を返却する。
	 * </p>
	 * @param msgKK1471 工事完了ワーク配列
	 * @return 工事案件実施年月日を返却する。
	 */
	private String getKojiakJssiYmdByKK1471(CAANMsg[] msgKK1471)
	{
		// 工事完了ワーク配列が取得できなかった場合、nullを返却する。
		if (null == msgKK1471 || 0 >= msgKK1471.length)
		{
			return null;
		}

		// 連携年月日、連携通番の値保持変数
		String sTmpRnkiYmd = "";
		String sTmpRnkiSeq = "";
		String sRetKojiakJssiYmd = null;

		for (CAANMsg msg : msgKK1471)
		{
			// 取得結果から連携年月日、連携通番、工事案件実施年月日を取得
			String sRnkiYmd = msg.getString(KK1471ETMsg.RNKI_YMD);
			String sRnkiSeq = msg.getString(KK1471ETMsg.RNKI_SEQ);
			String sKojiakJssiYmd = msg.getString(KK1471ETMsg.KOJIAK_JSSI_YMD);

			// 取得した連携年月日が保持していた連携年月日と等しい場合
			if (0 == sRnkiYmd.compareTo(sTmpRnkiYmd))
			{
				// 取得した連携通番が保持していた連携通番より大きい場合
				if (0 < sRnkiSeq.compareTo(sTmpRnkiSeq))
				{
					// 連携通番、工事案件実施年月日を保持する。
					sTmpRnkiSeq = sRnkiSeq;
					sRetKojiakJssiYmd = sKojiakJssiYmd;
				}
			}
			// 取得した連携年月日が保持していた連携年月日より大きい場合
			else if (0 < sRnkiYmd.compareTo(sTmpRnkiYmd))
			{
				// 取得した連携年月日、連携通番、工事案件実施年月日を保持する。
				sTmpRnkiYmd = sRnkiYmd;
				sTmpRnkiSeq = sRnkiSeq;
				sRetKojiakJssiYmd = sKojiakJssiYmd;
			}
		}

		return sRetKojiakJssiYmd;
	}

	/**
	 * <p>
	 * メンバ変数に設定されたサービス契約内訳番号に紐づく番ポ工事の番ポ工事番号を取得し
	 * 番ポ工事番号に紐づく番ポ工事のカレントレコードの番ポ工事完了年月日の値を返却する。
	 * </p>
	 * @return 番ポ工事完了年月日を返却する。
	 */
	private String getBmpKojiFinYmd()
	{
		String sStdDate = null;

		// 番ポ工事の検索条件を設定
		CAANMsg inMsgTU0011 = new CAANMsg(TU0011ETMsg.class.getName());
		inMsgTU0011.set(TU0011ETMsg.SVC_KEI_UCWK_NO, getSvc_kei_ucwk_no());
		inMsgTU0011.set(TU0011ETMsg.MK_FLG, MKFLG_VALID);
		
		try
		{
			// 設定した検索条件から全件取得する。
			CAANMsg[] retMsgTU0011 = new TU0011LE().findByCondition(inMsgTU0011);

			// レコードが取得できなかった場合、nullを返却する。
			if (0 >= retMsgTU0011.length)
			{
				return null;
			}

			// 番ポ工事番号を取得
			String sBmpKojiNo = retMsgTU0011[0].getString(TU0011ETMsg.BMP_KOJI_NO);

			// 取得した番ポ工事番号を取得用パラメータに設定する。
			CAANMsg inCurMsgTU0011 = new CAANMsg(TU0011ETMsg.class.getName());
			inCurMsgTU0011.set(TU0011ETMsg.BMP_KOJI_NO, sBmpKojiNo);

			// 番ポ工事のカレントレコードを取得する。
			CAANMsg retCurMsgTU0011 = new JKKejbTU0011DBABase().findByCurrent(inCurMsgTU0011);

			// カレントレコードから番ポ工事完了年月日を取得する。
			// ※有効なレコードが取得できた時点でカレントは必ず存在するためnullチェック不要
			sStdDate = retCurMsgTU0011.getString(TU0011ETMsg.BMP_KOJI_FIN_YMD);
		}
		catch (CAANException ce)
		{
			throw new CAANRuntimeException(ce);
		}
		
		return sStdDate;
	}

	/**
	 * <p>
	 * メンバ変数に設定されたサービス契約番号、連携ファイルコードが「新規契約完了(サービス開通)」の
	 * 条件に一致するADSL工事のレコードのNTT局内工事年月日の値を返却する。
	 * </p>
	 * @return NTT局内工事年月日を返却する。
	 */
	private String getNttKyokuNaiKojiYmd(String renkeiFileCd)
	{
		String sStdDate = null;

		// ADSL工事の検索条件を設定
		CAANMsg inMsgKK0621 = new CAANMsg(KK0621ETMsg.class.getName());
		inMsgKK0621.set(KK0621ETMsg.SVC_KEI_NO, getSvc_kei_no());
		inMsgKK0621.set(KK0621ETMsg.RENKEI_FILE_CD, renkeiFileCd);
		inMsgKK0621.set(KK0621ETMsg.MK_FLG, MKFLG_VALID);
		
		try
		{
			// ADSL工事の検索実行
			CAANMsg[] retMsgKK0621 = new KK0621LE().findByCondition(inMsgKK0621);

			// レコードが取得できなかった場合、nullを返却する。
			if (0 >= retMsgKK0621.length)
			{
				return null;
			}

			// 取得結果からNTT局内工事年月日を取得する。
			sStdDate = retMsgKK0621[0].getString(KK0621ETMsg.NTT_KYOKU_NAI_KOJI_YMD);
		}
		catch (CAANException ce)
		{
			throw new CAANRuntimeException(ce);
		}

		return sStdDate;
	}

	/**
	 * <p>
	 * メンバ変数に設定されたサービス契約番号に紐づく同一回線のネット用VLANオーダのネット用VLANオーダ結果取込年月日の値を返却する。
	 * </p>
	 * @return 番ポ工事完了年月日を返却する。
	 */
	private String getTelVlanOdrRsltTrkmYmd()
	{
		String sTelVlanOdrRsltTrkmYmd = null;
		
		// 電話用VLANオーダ取得条件を設定する。
		CAANMsg inMsgSC0021 = new CAANMsg(SC0021ETMsg.class.getName());
		inMsgSC0021.set(SC0021ETMsg.SVC_KEI_NO, getSvc_kei_no());
		inMsgSC0021.set(SC0021ETMsg.MK_FLG, MKFLG_VALID);

		try
		{
			// 電話用VLANオーダの全件取得を行う。
			CAANMsg[] retMsgSC0021 = new SC0021LE().findByCondition(inMsgSC0021);

			// 電話用VLANオーダ結果取込年月日時分秒が取得できた場合
			if (!(0 >= retMsgSC0021.length || retMsgSC0021[0].isNull(SC0021ETMsg.TEL_VLAN_ODR_RSLT_TRKM_DTM)))
			{
				// 電話用VLANオーダ結果取込年月日時分秒の年月日を取得
				sTelVlanOdrRsltTrkmYmd = JKKModelCommon.toYmdFromDtm(retMsgSC0021[0].getString(SC0021ETMsg.TEL_VLAN_ODR_RSLT_TRKM_DTM));
				return sTelVlanOdrRsltTrkmYmd;
			}

			// 取得できなかった場合、同一回線に紐付くネット契約のサービス契約番号を取得する。
			// 個別検索条件マップ
			JKKejbKK0081DBABase kk0081dba = new JKKejbKK0081DBABase();
			HashMap<String, String[]> searchJknMap = new HashMap<String, String[]>();
			String[] svcCdLsit = {JKKModelConst.SVC_CD_NET};
			searchJknMap.put(KK0081ETMsg.SVC_CD, svcCdLsit);
			CAANMsg[] KK0081InfoList = kk0081dba.getKK0081bySvcKei(getSvc_kei_no(), searchJknMap, JKKModelCommon.getOpeDate(getCBSMsg()));
			// レコードが取得できなかった場合、nullを返却する。
			if (0 >= KK0081InfoList.length)
			{
				return null;
			}
			
			// ネット用VLANオーダ取得条件を設定する。
			inMsgSC0021 = new CAANMsg(SC0021ETMsg.class.getName());
			inMsgSC0021.set(SC0021ETMsg.SVC_KEI_NO, KK0081InfoList[0].getString(KK0081ETMsg.SVC_KEI_NO));
			inMsgSC0021.set(SC0021ETMsg.MK_FLG, MKFLG_VALID);

			// ネット用VLANオーダの全件取得を行う。
			retMsgSC0021 = new SC0021LE().findByCondition(inMsgSC0021);

			// レコードが取得できなかった場合、またはネット用VLANオーダ結果取込年月日時分秒が未設定の場合、nullを返却する。
			if (0 >= retMsgSC0021.length || retMsgSC0021[0].isNull(SC0021ETMsg.TEL_VLAN_ODR_RSLT_TRKM_DTM))
			{
				return null;
			}

			// ネット用VLANオーダ結果取込年月日時分秒の年月日を取得
			sTelVlanOdrRsltTrkmYmd = JKKModelCommon.toYmdFromDtm(retMsgSC0021[0].getString(SC0021ETMsg.TEL_VLAN_ODR_RSLT_TRKM_DTM));
		}
		catch (CAANException ce)
		{
			throw new CAANRuntimeException(ce);
		}
		
		return sTelVlanOdrRsltTrkmYmd;
	}
	

	/**
	 * <p>
	 * パラメータの機器提供サービスコードに一致する、サービス契約に紐づく
	 * 機器提供サービス契約のカレントレコードを取得する。
	 * </p>
	 * @param kktkSvcCd 機器提供サービスコード
	 * @return サービス契約に紐づく機器提供サービス契約(カレントレコード)
	 * @throws CAANException
	 */
	private CAANMsg getCurrentKK0341KaiSenUw(String kktkSvcCd) throws CAANException
	{
		
		CAANMsg[] kk0251Cur = new JKKejbKK0251DBABase().getKK0251bySvcKei(getSvc_kei_no(), null , JKKModelCommon.getOpeDate(inCBSMsg), "1");

		if(kk0251Cur == null) 
		{
			return null;
		}
		
		String kaisenUwNo = kk0251Cur[0].getString(KK0251ETMsg.SVC_KEI_KAISEN_UCWK_NO);
		
		// 機器提供サービス契約全件取得用の検索条件を設定する。
		CAANMsg inMsgKK0341 = new CAANMsg(KK0341ETMsg.class.getName());
		inMsgKK0341.set(KK0341ETMsg.SVC_KEI_KAISEN_UCWK_NO, kaisenUwNo);
		inMsgKK0341.set(KK0341ETMsg.KKTK_SVC_CD, kktkSvcCd);
		inMsgKK0341.set(KK0341ETMsg.MK_FLG, MKFLG_VALID);

		// 設定した検索条件から機器提供サービス契約を全件取得する。
		CAANMsg[] retMsgKK0341 = new KK0341LE().findByCondition(inMsgKK0341);

		// レコードが取得できなかった場合、nullを返却する。
		if (0 >= retMsgKK0341.length)
		{
			return null;
		}

		// 機器提供サービス契約のカレントレコード取得用メッセージ作成
		CAANMsg inCurMsgKK0341 = new CAANMsg(KK0341ETMsg.class.getName());
		inCurMsgKK0341.set(KK0341ETMsg.KKTK_SVC_KEI_NO, retMsgKK0341[0].getString(KK0341ETMsg.KKTK_SVC_KEI_NO));
		inCurMsgKK0341.set(KK0341ETMsg.RSV_APLY_YMD, JKKModelCommon.getOpeDate(getCBSMsg()));

		// 機器提供サービス契約のカレントレコードを返却する。
		return new JKKejbKK0341DBABase().findByCurrent(inCurMsgKK0341);
	}
}
