/*********************************************************************
 * All Rights reserved,Copyright (c) K-Opticom, 2011
 **********************************************************************
 *＜プログラム内容＞
 *   システム名      ：eo顧客基幹システム
 *   モジュール名    ：JKKSvcKeiMineoChgCC
 *   ソースファイル名：JKKSvcKeiMineoChgCC.java
 *   作成者          ：富士通
 *   日付            ：2011年08月12日
 *＜機能概要＞
 *   POPPW初期化連携
 *＜修正履歴＞
 *   バージョン  修正日       修正者      修正内容
 *   v1.00.00    2014/01/06   FJ）藤田    新規作成
 *   v8.00.00    2014/02/21   FJ）藤田    【IT2-2014-0000129】対応
 *   v8.01.00    2014/03/11   FJ）阮      【ST-2014-0000080】申込明細ステータスの状態遷移制御対応
 *   v8.02.00    2014/03/19   FJ）藤田    【IT1-2014-0000098】対応
 *   v8.03.00    2014/05/21   FJ）藤田    【ANK-2097-00-00】CC内部例外時に正常終了コードが戻ってしまう
 *   v8.04.00    2014/06/05   FJ）藤田    【OM-2014-0002073】請求オプション一意照会結果の取得でシステムエラー
 *  v11.00.00	 2014/10/11   FJ) 齋藤	  【ANK-2248-00-00】 NHK団体一括対象範囲拡大について
 *  v19.00.00	 2015/10/07   FJ) 金	  【OM-2015-0002492】mineo解約処理で解約日を運用日に変更
 *  v27.00.00	 2016/10/19   FJ) 中山    【OM-2016-0002095】ファミリー会員のmineoキャンセル対応
 *  v40.00.00	 2018/12/27   FJ) 前田    【ANK-3315-00-00】mineoの取扱コード連携機能追加
 **********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.fujitsu.futurity.bp.custom.constant.JKKAddSjishoConst;
import com.fujitsu.futurity.bp.custom.constant.JKKSvcConst;
import com.fujitsu.futurity.bp.custom.mapping.KKSV0037_KKSV0037OP_EKK0071E020BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.KKSV0378_KKSV0378OP_EKK0071B002BSMapper;
import com.fujitsu.futurity.bp.x21.bpm.ServiceComponentRequestInvoker;
import com.fujitsu.futurity.bp.x21.bpm.db.SessionHandle;
import com.fujitsu.futurity.bp.x21.bpm.exception.RequestParameterException;
import com.fujitsu.futurity.bp.x21.bpm.parameter.ErrorLevel;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadWrite;
import com.fujitsu.futurity.bp.x21.bpm.parameter.StatusArea;
import com.fujitsu.futurity.bp.x21.bpm.parameter.StatusInfo;
import com.fujitsu.futurity.bp.x21.cc.AbstractCommonComponent;
import com.fujitsu.futurity.bp.x21.cc.exception.CCException;
import com.fujitsu.futurity.bp.x21.cc.exception.SCCallException;
import com.fujitsu.futurity.bp.x21.values.OUTBREAK_AREA;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.ErrorInfoMapKeys;
import com.fujitsu.futurity.common.x01.sc.SCControlMapKeys;
import com.fujitsu.futurity.mapping.bp.common.TemplateErrorUtil;
import com.fujitsu.futurity.model.base.CAANMsg;
import com.fujitsu.futurity.model.base.jcc.util.JCCDateUtil;
import com.fujitsu.futurity.model.common.JCMAPLConstMgr;
import com.fujitsu.futurity.model.ejb.common.JSYejbLog;

import eo.common.constant.JKKStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.util.JKKStringUtil;
import eo.common.util.JPCDateUtil;
import eo.ejb.cbs.cbsmsg.ECK0011A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0011A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0011D020CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0011D020CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0021A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0021A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0071B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0071B002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0071D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0071E020CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081B024CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B024CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081B526CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B526CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081C160CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081C180CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081C260CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0321B005CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0441A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0441A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0441B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0441B002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0441C210CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0441C230CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2821C010CBSMsg;

/**
 * サービス契約＜ｍｉｎｅｏ＞変更CC
 * <p>
 * <br>
 * サービス契約＜mineo＞の契約状態を変更する。 <br>
 * @author 富士通
 */
@SuppressWarnings("unchecked")
public class JKKSvcKeiMineoChgCC extends AbstractCommonComponent {

	// ANK-3315-00-00 ADD START
	/** リクエスト項目名：取扱コード1-1 */
	private static final String TRAT_CD_1_1 = "trat_cd_1_1";
	/** リクエスト項目名：取扱コード1-2 */
	private static final String TRAT_CD_1_2 = "trat_cd_1_2";
	/** リクエスト項目名：取扱コード2-1 */
	private static final String TRAT_CD_2_1 = "trat_cd_2_1";
	/** リクエスト項目名：取扱コード2-2 */
	private static final String TRAT_CD_2_2 = "trat_cd_2_2";
	/** 取扱コード項目名のリスト */
	private static final String[] TRAT_LIST = {TRAT_CD_1_1, TRAT_CD_1_2, TRAT_CD_2_1, TRAT_CD_2_2};
	/** 表示順_1 */
	private static final String DSP_JUN_1 = "1";
	/** 表示順_2 */
	private static final String DSP_JUN_2 = "2";
	/** 表示順_3 */
	private static final String DSP_JUN_3 = "3";
	/** 表示順_4 */
	private static final String DSP_JUN_4 = "4";
	/** エラー項目接尾辞 */
	private static final String ERRITEM_SUFFIX = "_err";
	/** エラー項目設定値：EA */
	private static final String ERR_EA = "EA";
	/** エラー項目設定値：EB */
	private static final String ERR_EB = "EB";
	/** エラー項目設定値：EC */
	private static final String ERR_EC = "EC";
	/** エラー項目設定値：ED */
	private static final String ERR_ED = "ED";
	/** エラー項目設定値：EE */
	private static final String ERR_EE = "EE";
	/** エラー項目設定値：EF */
	private static final String ERR_EF = "EF";
	/** エラー項目設定値：E1 */
	private static final String ERR_E1 = "E1";
	/** リターンメッセージ取得キー */
	private static final String RETURN_MESSAGE_STRING = "RETURN_MESSAGE_";
	/** リターンメッセージの書式指定文字列 */
	private static final String RETURN_MESSAGE_FORMAT = "%1$04d";
	/** リターンコード：正常  */
	private static final int RETURN_CODE_NORMAL = 0;
	/** チェックエラー時のエラーメッセージ */
	private static final String SC_ERROR_STRING = "サービスコンポーネントエラー";
	// ANK-3315-00-00 ADD END
	
	/** エラーメッセージ */
	public static final String ERR_MSG = "INVALID_RETURN_MESSAGE";
	
	/** ----- 作業用クラスフィールド ----- **/
//	private String oPE_DATE = "";

	/** 照査受付　識別コード、サービスID **/
	private static final String SKBT_CD_KKSV076601SC = "KKSV076601SC";
	private static final String SERVICE_ID_KKSV0766 = "KKSV0766";

	/** キャンセル受付　識別コード、サービスID **/
	private static final String SKBT_CD_KKSV076901SC = "KKSV076901SC";
	private static final String SERVICE_ID_KKSV0769 = "KKSV0769";

	/** 解約受付　識別コード、サービスID **/
	private static final String SKBT_CD_KKSV077001SC = "KKSV077001SC";
	private static final String SERVICE_ID_KKSV0770 = "KKSV0770";
	
	/** 識別コード **/
	private String skbtCd;

	/** サービスID **/
	private String serviceID;

	/** リターンコード **/
	public static final String RETURN_CODE = "return_code";

	/** サービス契約番号 **/
	private static final String SVC_KEI_NO = "svc_kei_no";

	/** お客様ID **/
	private static final String SYSID = "sysid";
	
	private static final String MEMBER_SBT_CD = "member_sbt_cd";

	/** サービス契約照査BPサービスでのお客様会員種別変更CCマップのキー **/
	public static final String CUSTMEMBERSBTCHG = SERVICE_ID_KKSV0766 + "01CC";

	/** サービス契約照査BPサービスでの指示書CCマップのキー **/
	public static final String SJISHO_MAP = SERVICE_ID_KKSV0766 + "02CC";

	/** サービス契約照査BPサービスでの整理番号発番付替CCマップのキー **/
	public static final String SEIRIBANGO_MAP = SERVICE_ID_KKSV0766 + "03CC";
	
	/** 会員種別コード　10：マスター会員（個人） */
	public static final String MBTYPE_CD_MST_KOJIN = "10";

	/** 会員種別コード　20：マスター会員（法人） */
	public static final String MBTYPE_CD_MST_HOJIN = "20";

	/** 会員種別コード　00：非ｅｏ会員 */
	public static final String MBTYPE_CD_NOT_EO = "00";

	/** 会員種別コード　11：ファミリー会員（個人） */
	public static final String MBTYPE_CD_FAMILY_KOJIN = "11";

	/** 会員種別コード　21：ファミリー会員（法人） */
	public static final String MBTYPE_CD_FAMILY_HOJIN = "21";

	/** 会員種別コード　30：オープン会員 */
	public static final String MBTYPE_CD_OPEN = "30";
	
	/** 契約者タイプコード　1：個人 */
	public static final String KSH_TYPE_CO_KOJIN = "1";
	
	/** 契約者タイプコード　2：法人 */
	public static final String KSH_TYPE_CO_HOJIN = "2";
	
	/** 契約者タイプコード　3：保守用 */
	public static final String KSH_TYPE_CO_MNT = "3";
	
	/** 契約者タイプコード　4：自社利用 */
	public static final String KSH_TYPE_CO_JISHA_USE = "4";

	public static final String IDO_RSN_CD_SONOTA = "56";
	
	// ST-2014-0000080 2013/03/10 ADD START
	/** 申込明細ステータス  CD00061　受付済 */
	public static final String MSKM_DTL_STAT_UKETSUKEZUMI = "010";
	// ST-2014-0000080 2013/03/10 ADD END
	
	/** SOAP連携データ格納マップ **/
	private Map<String, Object> soapRenkeiMap;

	/** サービス契約一意照会結果格納マップ **/
	private Map<String, Object> svcKeiMap;

	/** 申込承認登録結果格納マップ **/
	private Map<String, Object> mskmAddMap;
	
	// IT2-2014-0000129 対応 藤田 2014/2/21 DEL START
//	/** エラー情報保存マップ **/
//	private Map<String, Object> errMap;
	// IT2-2014-0000129 対応 藤田 2014/2/21 DEL END
//	private static final String ERR_MAP_KEY_ERR_FLG = "err";
//	private static final String ERR_MAP_KEY_RETURN_CD = "return_cd";
	
//	/** 初期eoId **/
//	private String shk_eoId = null;
	
	/** 運用日付 **/
	private String oPE_DATE;
	
	/** 運用日時 **/
	private String oPE_DATE_TIME;
	
	/** 現在処理中のSYSID **/
	private String currentSysid = null;
	

	/** 入力パラメータ：ＳＹＳＩＤ */
	static final String IN_FUNC_CODE = "func_code";
	
	/** 入力パラメータ：申込書番号 */
	static final String IN_SVC_CL_YMD = "svc_cancel_ymd";
	
	/** 入力パラメータ：申込書明細番号 */
	static final String IN_CL_RSN_CD = "svc_cancel_rsn_cd";
	
	/** 入力パラメータ：サービス終了年月日 */
	static final String IN_SVC_ENDYMD			= "svc_endymd";

	/** 入力パラメータ：サービス課金終了年月日 */
	static final String IN_SVC_CHRG_ENDYMD		= "svc_chrg_endymd";

//	/** 入力パラメータ：サービス解約起算年月日 */
//	static final String IN_SVC_DSL_KISAN_YMD	= "svc_dsl_kisan_ymd";

	/** 入力パラメータ：サービス解約年月日 */
	static final String IN_SVC_DSL_YMD			= "svc_dsl_ymd";

	/** 入力パラメータ：サービス解約理由コード */
	static final String IN_SVC_DLRE_CD			= "svc_dlre_cd";

	/** 入力パラメータ：サービス解約理由メモ */
	static final String IN_SVC_DLRE_MEMO		= "svc_dlre_memo";
	
	// IT2-2014-0000129 対応 藤田 2014/2/21 ADD START
	/** 制御パラメータ：異動区分 */
	static final String IDO_DIV = "ido_div";
	// IT2-2014-0000129 対応 藤田 2014/2/21 ADD END
	
	/** 制御パラメータ：異動日時 */
	static final String IDO_DTM = "ido_dtm";
	
	/** 制御パラメータ：申込番号 */
	static final String MSKM_NO = "mskm_no";
	
	/** 制御パラメータ：申込明細番号 */
	static final String MSKM_DTL_NO = "new_mskm_dtl_no";
	
	/** 制御パラメータ：更新日時（お客様） */
	static final String CK0011_UPD_DTM = "ck0011_upd_dtm";
	
	/** 制御パラメータ：更新日時（申込） */
	static final String KK0011_UPD_DTM = "kk0011_upd_dtm";
	
	/** 入力パラメータ： */
	static final String KK0081_UPD_DTM = "kk0081_upd_dtm";
	
	/** お客様退会ＣＣ連携用マップのキー */
	static final String MAP_KEY_JCKCUSTTAIKAI = "okyakusama_taikai_map";
	
	/**
	 * 作業領域のキー
	 */
	private static final String MAP_KEY_WORK = "work_area";
	
	// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 ADD START
	// 内部で取得するリスト用のマップキー サービス契約番号
	private static final String SVCKEILIST1_SVC_KEI_NO = "svc_kei_no";
	// 内部で取得するリスト用のマップキー サービス契約ステータス
	private static final String SVCKEILIST1_SVC_KEI_STAT = "svc_kei_stat";
	// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 ADD END
	//ANK-2248-00-00 ADD START
	/** 請求オプションサービスコード：請求書発行手数料 */
	private static final String SEIOPSVC_CD_SEIKYSH_HAKKO = "E001";
	//ANK-2248-00-00 ADD END
	
	/**
	 * CAANMsgに必要なデータのマッピング処理を行います。
	 * <br>
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return パラメータマップ
	 * @throws RequestParameterException
	 */
	public HashMap<String, Object> getInvokeCBS(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
			throws RequestParameterException
	{
		//BPチェックは行わない
		
		HashMap<String, Object> paramMap = setSCInputCommonData(param, new HashMap<String, Object>());
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, new CAANMsg[]{});

		return paramMap;
	}


	/**
	 * サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode, String fixedText)
			throws RequestParameterException
	{
		//BPチェックは行わない

		return param;
	}


	/**
	 * SCインプット共通データ設定処理を行います。
	 * <br>
	 * @param param
	 * @param paramMap
	 * @return パラメータマップ
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> setSCInputCommonData(IRequestParameterReadWrite param, HashMap<String, Object> paramMap)
			throws RequestParameterException
	{
		/* SCインプット共通データ */
		// **********************************************
		// 【取得元：電文ヘッダ(ヘッダ)】
		// **********************************************
		// 電文ID
		paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID());
		// ユースケースID
		paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID());
		// オペレーションID
		paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID());
		// サービス呼び出し区分
		paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType());

		// **********************************************
		// 【取得元：ユーザエリア(コントロールマップ)】
		// **********************************************
		// 依頼先ホスト名
		paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTNAME));
		// 依頼元IPアドレス
		paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTIP));
		// 依頼元画面ID
		paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, param.getControlMapData(SCControlMapKeys.REQ_VIEWID));
		// オペレータID
		paramMap.put(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));

		return paramMap;
	}


	/**
	 *　サービス契約＜ｍｉｎｅｏ＞の状態を更新します
	 *
	 * @param handle セッションマネージャなどを持ったハンドル
	 * @param param モデルグループ、コントロールマップを含むパラメータオブジェクト
	 * @param fixedText ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 */
	public IRequestParameterReadWrite changeStatus(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
	 throws Throwable
	{
		//リクエストパラメータの取得
		soapRenkeiMap = analyzeRequestParam(param);
		mskmAddMap = null;

		// IT2-2014-0000129 対応 藤田 2014/2/21 DEL START
//		errMap = new HashMap<String, Object>();
		// IT2-2014-0000129 対応 藤田 2014/2/21 DEL END

		// サービスIDの取得
		serviceID = param.getUsecaseID();

		// 運用日付設定
		String oPE_DATE = JCCBPCommon.getOpeDate(null);
		// 運用日時設定
		String oPE_DATE_TIME = JCCBPCommon.getOpeDateTimeStamp(null);

		this.oPE_DATE = oPE_DATE;
		this.oPE_DATE_TIME = oPE_DATE_TIME;

		// ANK-2097-00-00 CC内部例外時に正常終了コードが戻ってしまう 藤田 2014/05/21 MOD START
		try {
		// ANK-2097-00-00 CC内部例外時に正常終了コードが戻ってしまう 藤田 2014/05/21 MOD END
			// サービスIDによって処理を分岐する。
			if (SERVICE_ID_KKSV0766.equals(serviceID))
			{	// 照査処理
				svcShosa(handle, param);
			} else if (SERVICE_ID_KKSV0769.equals(serviceID))
			{	// キャンセル処理
				svcCancel(handle, param, fixedText);
			} else if (SERVICE_ID_KKSV0770.equals(serviceID))
			{	// 解約処理
				svcKaiyaku(handle, param, fixedText);
			}
		// ANK-2097-00-00 CC内部例外時に正常終了コードが戻ってしまう 藤田 2014/05/21 MOD START
		} catch (Exception e) {
			String returnCode = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
			// 強制的にシステムエラーのコードに置き換え
			if ("0000".equals(returnCode))
			{
				JSYejbLog.printStackTrace(JSYejbLog.ERROR, this.getClass(), e, null, null);
				StatusInfo info = new StatusInfo(ErrorLevel.EL988, OUTBREAK_AREA.CC);
				info.setErrorLogOutput(true);
				param.getStatusArea().add(info);
				param.getStatusArea().setCurrent(info);
				param.setControlMapData(SCControlMapKeys.RETURN_CODE, "9000");
				param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, "システムエラー");
				throw new Exception(serviceID + "実行中に予期せぬエラーが発生しました");
			} else {
				throw e;
			}
		}
		// ANK-2097-00-00 CC内部例外時に正常終了コードが戻ってしまう 藤田 2014/05/21 MOD END
		
		//処理終了
		return param;
	}
	
	
	

	/**
	 * リクエストパラメータの取得
	 * @param param モデルグループ、コントロールマップを含むパラメータオブジェクト
	 * @return リクエストパラメータのHash
	 * @throws RequestParameterException 例外時にスローされます
	 */
	private HashMap<String, Object> analyzeRequestParam(IRequestParameterReadWrite param) 
	throws RequestParameterException
	{
		
		HashMap<String, Object> paramData = null;

		//データの受け取り
		paramData = (HashMap<String, Object>)param.getData(SKBT_CD_KKSV076601SC);
		skbtCd = SKBT_CD_KKSV076601SC;	// 照査
		if (paramData == null) {
			paramData = (HashMap<String, Object>)param.getData(SKBT_CD_KKSV076901SC);
			skbtCd = SKBT_CD_KKSV076901SC;	// キャンセル
			if (paramData == null) {
				paramData = (HashMap<String, Object>)param.getData(SKBT_CD_KKSV077001SC);
				skbtCd = SKBT_CD_KKSV077001SC;	// 解約
			}
		}

		return paramData;
		
	}

	/**
	 * 照査処理
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Throwable 任意の例外
	 */
	private void svcShosa(SessionHandle handle, IRequestParameterReadWrite param)
	 throws Throwable
	{
		// ANK-3315-00-00 ADD START
		//単項目関連チェック
		checkTankoumokukanren(param);
		// ANK-3315-00-00 ADD END
		
		// サービス契約一意照会
		this.svcKeiMap = callEKK0081A010SC(param, handle);

		// ANK-3315-00-00 ADD START
		// 申込明細番号を取得
		String mskmMsNo = (String) svcKeiMap.get(EKK0081A010CBSMsg1List.MSKM_DTL_NO);

		// 申込明細一意照会
		Map<String, Object> mskmDtlMap = callEKK0021A010SC(param, handle, mskmMsNo);

		// 申込番号を取得
		String mskmNo = (String) mskmDtlMap.get(EKK0021A010CBSMsg1List.MSKM_NO);

		// 申込_代理店一覧照会
		ArrayList<HashMap<String, Object>> ekk0071b002Msg1List = callEKK0071B002SC(param, handle, mskmNo);

		// 申込_代理店チェック
		checkMskmAgnt(param, handle, ekk0071b002Msg1List);

		// 申込_代理店削除
		callEKK0071E020SC(param, handle, ekk0071b002Msg1List);

		// 申込_代理店登録
		callEKK0071D010SC(handle, param, mskmDtlMap);
		// ANK-3315-00-00 ADD END

		// サービス契約＜mineo＞照査
		Map<String, Object> shosaRsltMap = callEKK2821C010SC(param, handle);
		
		// sysidを取得
		this.currentSysid = (String) svcKeiMap.get(EKK0081A010CBSMsg1List.SYSID);
		
		// お客様一意照会
		Map<String, Object> custMap = callECK0011A010SC(param, handle, currentSysid);
		
		String svcKeiNo = (String)soapRenkeiMap.get(SVC_KEI_NO);
		
		// IT2-2014-0000129 対応 藤田 2014/2/21 MOD START
		// お客様会員種別を更新する。
		// 対象のお客様ID
		custMap.put(JKKCustMemberSbtChgCC.SYSID, this.currentSysid);
		// サービス契約番号
		// ※内部で呼ばれるお客様回復共通部品にて使用されるサービス契約番号
		custMap.put(JKKCustMemberSbtChgCC.SVC_KEI_NO, svcKeiNo);
		param.setData(CUSTMEMBERSBTCHG, custMap);
		(new JKKCustMemberSbtChgCC()).execute(handle, param, CUSTMEMBERSBTCHG);
//		updCustinfo(param, handle, custMap, svcKeiNo);
		// IT2-2014-0000129 対応 藤田 2014/2/21 MOD END

		Map<String, Object> custMapAfter = callECK0011A010SC(param, handle, currentSysid);

		// IT2-2014-0000129 対応 藤田 2014/2/21 ADD START
		// 申込みの照査を行う
		shosaMskm(param, handle);
		// 指示書用マップ作成
		// 連携データ区分06 請求契約番号(#T)の情報
		JKKBpCommon.putAxMRenkeiDataKbn(
				param, SJISHO_MAP, JKKAddSjishoConst.RENKEI_DATA_KBN_SEIKY_KEI, JKKAddSjishoConst.TRN_KBN_ADD, 
				new String[]{svcKeiNo}, currentSysid);
		JKKAddSjishoCC addSjishoCC = new JKKAddSjishoCC();
		addSjishoCC.addSjisho(handle, param, SJISHO_MAP);
//		// レスポンスデータに載らないよう、不要なマップは削除しておく
//		removeSjishoMap(handle, param);
		// IT2-2014-0000129 対応 藤田 2014/2/21 ADD END
		
		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 MOD START
		String seikyKeiNo = getSeikyKeiNoBySvcKeiNo(handle, param, svcKeiNo);
		// 進捗登録処理
		addPrg(handle, param, seikyKeiNo);
		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 MOD END

		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 ADD START
		String mskmDtlNo = (String)svcKeiMap.get(EKK0081A010CBSMsg1List.MSKM_DTL_NO);
		String idoDiv = (String)svcKeiMap.get(EKK0081A010CBSMsg1List.IDO_DIV);
		shosaForSeikyuOptionService(handle, param, seikyKeiNo, idoDiv);
		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 ADD END
		
		// 整理番号発番付替CCを実行
		//引渡し用マップを編集
		HashMap<String, Object> seiriNoHtbChgCCMap = new HashMap<String, Object>();
		seiriNoHtbChgCCMap.put(SVC_KEI_NO, svcKeiNo);			//サービス契約番号
		seiriNoHtbChgCCMap.put(SYSID,      currentSysid);		//SYSID
		param.setData(SEIRIBANGO_MAP, seiriNoHtbChgCCMap);
		JKKSeiriNoHtbChgCC seiriNoHtbChgCC = new JKKSeiriNoHtbChgCC();
		seiriNoHtbChgCC.seiriNoHtbChg(handle, param, SEIRIBANGO_MAP);
		// IT2-2014-0000129 対応 藤田 2014/2/21 DEL START
//		// 整理番号発番付替CCマップをクリア
//		param.removeData(SEIRIBANGO_MAP);
		// IT2-2014-0000129 対応 藤田 2014/2/21 DEL START
		
		// レスポンス作成処理
		createResponse(param, custMap, custMapAfter);
	}
	
	/**
	 * キャンセル処理
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @throws Throwable 
	 */
	private void svcCancel(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		Map<Object, Object> workAreaMap = param.getMappingWorkArea();
		if (null == workAreaMap)
		{
			workAreaMap = new HashMap<Object, Object>();
			param.setMappingWorkArea(workAreaMap);
		}
		
		Map<String, Object> workMap = (Map<String, Object>) workAreaMap.get(MAP_KEY_WORK);
		if (null == workMap)
		{
			workMap = new HashMap<String, Object>();
			workAreaMap.put(MAP_KEY_WORK, workMap);
		}
		
		//@サービス契約一意照会
//		HashMap<String, Object> kk0081Map = callEKK0081A010(param, handle, fixedText);
		this.svcKeiMap = callEKK0081A010SC(param, handle);
		
		if (null != this.svcKeiMap && this.svcKeiMap.containsKey(EKK0081A010CBSMsg1List.SYSID))
		{
			//ＳＹＳＩＤを格納
			this.currentSysid = (String) this.svcKeiMap.get(EKK0081A010CBSMsg1List.SYSID);
			
			//更新日時（サービス契約）
			workMap.put(KK0081_UPD_DTM, this.svcKeiMap.get(EKK0081A010CBSMsg1List.LAST_UPD_DTM));
		}
		else
		{
			//無いお客様IDを連携された際にEKK0081C160がsvc_kei_no_err=EBを返せるよう更新日時を誤魔化す
			workMap.put(KK0081_UPD_DTM, this.oPE_DATE_TIME);
		}
		
		//異動日時を設定
		workMap.put(IDO_DTM, new String(this.oPE_DATE_TIME));
		
		// IT2-2014-0000129 対応 藤田 2014/2/21 ADD START
		// 異動区分を設定
		workMap.put(IDO_DIV, JKKStrConst.CD00576_CNCL);
		// IT2-2014-0000129 対応 藤田 2014/2/21 ADD END
		
		// お客様一意照会
		Map<String, Object> custMap = callECK0011A010SC(param, handle, this.currentSysid);
		
		//A申込
		callEKK0011D020SC(handle, param, workMap, "00006");		//申込種別 == キャンセル申込
		
		//Bサービス契約キャンセル
		callEKK0081C160SC(handle, param, workMap);
		
		//Cお客様退会
//OM-2016-0002095 MOD START
//		callCusTaikaiCmnKino(handle, param, workMap);
		if (!JKKStrConst.CD00037_UK_ZM.equals(this.svcKeiMap.get(EKK0081A010CBSMsg1List.SVC_KEI_STAT)))
		{
			callCusTaikaiCmnKino(handle, param, workMap);
		}
//OM-2016-0002095 MOD END
//		
//		//D指示書出力
//		addSijisyo4Dsl(handle, param);
		
		//E申込明細照査・後続業務依頼
		callEKK0021C060SC(handle, param, workMap);

		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 MOD START
		String svcKeiNo = (String)soapRenkeiMap.get(SVC_KEI_NO);
		String seikyKeiNo = getSeikyKeiNoBySvcKeiNo(handle, param, svcKeiNo);
		//F進捗
		addPrg(handle, param, seikyKeiNo);
		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 MOD END

		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 ADD START
		// 同一の「請求契約」を指定するインターネットサービス、またはMVNOサービスの「サービス契約」（【解約済】、【キャンセル済】を除く）が存在する場合、何も更新しない
		// 上記以外の場合、配下の請求オプションサービス契約の状態により【キャンセル済】または【解約済】に遷移させる
		List<Map> iservices = getInternetServicesBySeikyuNo(handle, param, seikyKeiNo);
		if (!isExistsEnabledServices(iservices, svcKeiNo))
		{
			String mskmDtlNo = (String)this.svcKeiMap.get("mskm_dtl_no");
			this.cancelOrKaiaykuForSeikyuOptionService(
					 handle, param, seikyKeiNo, mskmDtlNo
					,(String)workMap.get(IDO_DIV)
				);
		}
		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 ADD END
		
		// お客様一意照会
		Map<String, Object> custMapAfter = callECK0011A010SC(param, handle, this.currentSysid);
		
		//Gレスポンス作成処理
		createResponse(param, custMap, custMapAfter);
	}


	/**
	 * 解約処理
	 * @param handle
	 * @param param
	 * @throws Throwable 
	 */
	private void svcKaiyaku(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		Map<Object, Object> workAreaMap = param.getMappingWorkArea();
		if (null == workAreaMap)
		{
			workAreaMap = new HashMap<Object, Object>();
			param.setMappingWorkArea(workAreaMap);
		}
		
		Map<String, Object> workMap = (Map<String, Object>) workAreaMap.get(MAP_KEY_WORK);
		if (null == workMap)
		{
			workMap = new HashMap<String, Object>();
			workAreaMap.put(MAP_KEY_WORK, workMap);
		}
		
		
		//@サービス契約一意照会
//		HashMap<String, Object> kk0081Map = callEKK0081A010(param, handle, fixedText);
		this.svcKeiMap = callEKK0081A010SC(param, handle);
		
		if (null != this.svcKeiMap && this.svcKeiMap.containsKey(EKK0081A010CBSMsg1List.SYSID))
		{
			//ＳＹＳＩＤを格納
			this.currentSysid = (String) this.svcKeiMap.get(EKK0081A010CBSMsg1List.SYSID);
			
			//更新日時（サービス契約）
			workMap.put(KK0081_UPD_DTM, this.svcKeiMap.get(EKK0081A010CBSMsg1List.LAST_UPD_DTM));
		}
		else
		{
			//無いお客様IDを連携された際にEKK0081C180がsvc_kei_no_err=EBを返せるよう更新日時を誤魔化す
			workMap.put(KK0081_UPD_DTM, this.oPE_DATE_TIME);
		}
		
		//異動日時を設定
		workMap.put(IDO_DTM, new String(this.oPE_DATE_TIME));

		// IT2-2014-0000129 対応 藤田 2014/2/21 ADD START
		// 異動区分を設定
		workMap.put(IDO_DIV, JKKStrConst.CD00576_DSL);
		// IT2-2014-0000129 対応 藤田 2014/2/21 ADD END
		
		// お客様一意照会
		Map<String, Object> custMap = callECK0011A010SC(param, handle, this.currentSysid);
		
		//A申込
		callEKK0011D020SC(handle, param, workMap, JKKDslRun.MSKM_SBT_CD_DSL);		//申込種別 == 解約申込
		
		//Bサービス契約解約
		callEKK0081C180SC(handle, param, workMap);
		
//		//解約日が運用日当日の場合
//		if (isTodayDslFix(param))
		{
			//Cサービス契約解約確定
			callEKK0081C260SC(handle, param, workMap);
//			
//			//D指示書出力
//			addSijisyo4Dsl(handle, param);
		}
		
		//Eお客様退会
		callCusTaikaiCmnKino(handle, param, workMap);
		
		//F申込明細照査・後続業務依頼
		callEKK0021C060SC(handle, param, workMap);
		
		//G進捗
		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 MOD START
		String svcKeiNo = (String)soapRenkeiMap.get(SVC_KEI_NO);
		String seikyKeiNo = getSeikyKeiNoBySvcKeiNo(handle, param, svcKeiNo);
		addPrg(handle, param, seikyKeiNo);
////		if (JPCModelConstant.FUNC_CD_1.equals((String)this.soapRenkeiMap.get(IN_FUNC_CODE)))
//		{
//			addPrg(handle, param);
//		}
		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 MOD END

		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 ADD START
		// 同一の「請求契約」を指定するインターネットサービス、またはMVNOサービスの「サービス契約」（【解約済】、【キャンセル済】を除く）が存在する場合、何も更新しない
		// 上記以外の場合、配下の請求オプションサービス契約の状態により【キャンセル済】または【解約済】に遷移させる
		List<Map> iservices = getInternetServicesBySeikyuNo(handle, param, seikyKeiNo);
		if (!isExistsEnabledServices(iservices, svcKeiNo))
		{
			String mskmDtlNo = (String)this.svcKeiMap.get("mskm_dtl_no");
			this.cancelOrKaiaykuForSeikyuOptionService(
					 handle, param, seikyKeiNo, mskmDtlNo
					,(String)workMap.get(IDO_DIV)
				);
		}
		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 ADD END
		
		// お客様一意照会
		Map<String, Object> custMapAfter = callECK0011A010SC(param, handle, this.currentSysid);
		
		//Hレスポンス作成処理
		createResponse(param, custMap, custMapAfter);
	}


	/**
	 * サービス終了日が当日かどうかを判定します
	 * 
	 * @param param 
	 * @return true：運用日当日（解約確定すべし），false：異動予約のケース
	 */
	private boolean isTodayDslFix(IRequestParameterReadWrite param)
	{
		String svcEndYmd = (String) this.soapRenkeiMap.get(IN_SVC_ENDYMD);		//サービス終了日
		boolean ret = (this.oPE_DATE.compareTo(svcEndYmd) == 0);
		return ret;
	}


	/**
	 * 解約／キャンセルの場合の指示書出力を行います
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @throws Throwable 任意の例外
	 */
	private void addSijisyo4Dsl(SessionHandle handle, IRequestParameterReadWrite param) throws Throwable
	{
		/** ＭＩＮＥＯは回線がないので、以下の指示書は不要 **/
		
//		//連携データ区分 07 ：回線契約に紐づく各種サービス契約の情報
//		JKKBpCommon.putAxMRenkeiDataKbn07(
//				param,
//				JKKDslRunConstCC.SJISHO_MAP,
//				JKKAddSjishoConst.TRN_KBN_DEL, 
//				new String[]{(String)this.soapRenkeiMap.get(SVC_KEI_NO)},
//				""
//		);
//		
//		// 連携対象データ区分 02 ：回線契約にかかるサービス契約番号とSYSIDとの紐付け情報
//		JKKBpCommon.putAxMRenkeiDataKbn(
//				param,
//				JKKDslRunConstCC.SJISHO_MAP,
//				JKKAddSjishoConst.RENKEI_DATA_KBN_SYSID,
//				JKKAddSjishoConst.TRN_KBN_UPD,	// 指示書登録CCでは使用していないが設定が必要なため、更新を設定
//				new String[]{(String)this.soapRenkeiMap.get(SVC_KEI_NO)},
//				""								// 連携対象データ区分 02の場合、SYSIDは設定不要のため、空文字を設定
//		);
//		
//		//指示書ＣＣを実行
//		(new JKKAddSjishoCC()).addSjisho(handle, param, SJISHO_MAP);
	}

	// IT2-2014-0000129 対応 藤田 2014/2/21 ADD START
	/**
	 * サービス契約＜Mineo＞の新規申込時に生成された申込明細の照査を行う
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @throws Throwable 任意の例外
	 */
	private void shosaMskm(IRequestParameterReadWrite param, SessionHandle handle)
		throws Throwable
	{
		// 申込一意照会
		JKKSIFEKK0021Mapper mapper = new JKKSIFEKK0021Mapper();
		String mskmDtlNo = (String)svcKeiMap.get(EKK0081A010CBSMsg1List.MSKM_DTL_NO);
		CAANMsg templateEKK0021A010 = mapper.getMappedTemplateEKK0021A010(mskmDtlNo, null);
		// SIF実行
		CAANMsg[] resultEKK0021A010 = callScCmn(param, handle, templateEKK0021A010, mapper);

		// 結果を設定
		Map<String, Object> resultMap = mappingCAANOutMsgOne(EKK0021A010CBSMsg.EKK0021A010CBSMSG1LIST, resultEKK0021A010);
		String updDtm = (String)resultMap.get(EKK0021A010CBSMsg1List.LAST_UPD_DTM);
		
// ST-2014-000080 2014/03/10 ADD START
		// 該当申込の申込明細ステータスを取得
		String mskmDtlStat = (String)resultMap.get(EKK0021A010CBSMsg1List.MSKM_DTL_STAT);
		
		// 申込明細ステータスが受付済の場合のみステータス遷移を実施(既に照査以降の場合はスキップする)
		if (MSKM_DTL_STAT_UKETSUKEZUMI.equals(mskmDtlStat))
		{
// ST-2014-000080 2014/03/10 ADD END
			// 申込明細照査・後続業務依頼
			Map<String, Object> workMap = new HashMap<String, Object>();
			// 申込明細番号
			workMap.put(MSKM_DTL_NO, svcKeiMap.get(EKK0081A010CBSMsg1List.MSKM_DTL_NO));
			// 更新年月日時分秒
			workMap.put(KK0011_UPD_DTM, updDtm);
			// 異動区分 ※受付の状態から引継ぎ
			workMap.put(IDO_DIV, svcKeiMap.get(EKK0081A010CBSMsg1List.IDO_DIV));
			// 申込明細照査・後続業務依頼
			callEKK0021C060SC(handle, param, workMap);
// ST-2014-000080 2014/03/10 ADD START
		}
// ST-2014-000080 2014/03/10 ADD END
	}
	// IT2-2014-0000129 対応 藤田 2014/2/21 ADD END

	// IT2-2014-0000129 対応 藤田 2014/2/21 DEL START
//	/**
//	 * 指示書登録処理
//	 * @param handle セッションハンドル
//	 * @param param リクエストパラメータ
//	 * @throws Throwable 任意の例外
//	 */
//	private void addSjisho(SessionHandle handle, IRequestParameterReadWrite param)
//		throws Throwable
//	{
//		JKKAddSjishoCC addSjishoCC = new JKKAddSjishoCC();
//		addSjishoCC.addSjisho(handle, param, SJISHO_MAP);
//		
//		//指示書マップをクリア
//		param.removeData(SJISHO_MAP);
//		// 下り電文に乗らないよう、
//		// 指示書登録ＣＣ内にて登録される以下のマップをクリア
//		param.removeData(SJISHO_MAP + KKSV0554_KKSV0554OP.KKSV055401SC);	// グループ一覧照会（複合検索）
//		param.removeData(SJISHO_MAP + KKSV0554_KKSV0554OP.KKSV055402SC);	// お客様グループ設定一覧照会（お客様情報取得）
//		param.removeData(SJISHO_MAP + KKSV0554_KKSV0554OP.KKSV055403SC);	// お客様グループ設定一意照会
//		param.removeData(SJISHO_MAP + KKSV0554_KKSV0554OP.KKSV055411SC);	// お客様一意照会
//		
//		// 照査処理
//		if (SERVICE_ID_KKSV0766.equals(serviceID)) {
//			// 指示書登録：連携データ区分01「お客様のグループ情報」
//			param.removeData(SJISHO_MAP + KKSV0554_KKSV0554OP.KKSV055412SC + "01");
//			// 指示書登録：連携データ区分11「お客様の基本情報」
//			param.removeData(SJISHO_MAP + KKSV0554_KKSV0554OP.KKSV055412SC + "02");
//		}
//		
//	}
	// IT2-2014-0000129 対応 藤田 2014/2/21 DEL END
	
	
	/**
	 * 進捗登録
	 * @param handle
	 * @param param
	 * @param seiky_kei_no
	 */
	// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 MOD START
//	private void addPrg(SessionHandle handle, IRequestParameterReadWrite param)
	private void addPrg(SessionHandle handle, IRequestParameterReadWrite param, String seiky_kei_no)
	// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 MOD START
	 throws Throwable
	{
		String svcKeiNo = (String)soapRenkeiMap.get("svc_kei_no");

		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 DEL START
//		// 課金先一覧照会（サービス契約番号）を実行
//		String seiky_kei_no = null;
//		{
//			JKKSIFEKK0321Mapper mapper = new JKKSIFEKK0321Mapper();
//			CAANMsg templateEKK0321B005 = mapper.getMappedTemplateEKK0321B005(svcKeiNo);
////			mapper.editTemplateCommon(param, templateEKK0321B005);
//
//			// SIF実行
//			CAANMsg[] resultMsgsEKK0321B005 = callScCmn(param, handle, templateEKK0321B005, mapper);
//			
//			if (resultMsgsEKK0321B005.length > 0) {
//				List<CAANMsg> data = new ArrayList();
//				for (int i=0; i < resultMsgsEKK0321B005.length; i++) {
//					CAANMsg r = resultMsgsEKK0321B005[i];
//					CAANMsg[] kakinsList = r.getCAANMsgList(EKK0321B005CBSMsg.EKK0321B005CBSMSG1LIST);
//					for (int j=0; j < kakinsList.length; j++) {
//						data.add(kakinsList[j]);
//					}
//				}
//				
//				// 課金先番号 - 降順ソート
//				Collections.sort(data, new Comparator<CAANMsg>()
//						{
//							public int compare(CAANMsg map1, CAANMsg map2)
//							{
//								String key1 = (String)map1.getString("kakins_no");
//								String key2 = (String)map2.getString("kakins_no");
//								return key2.compareTo(key1);
//							}
//						});
//				// 最新の請求契約番号を取得
//				if (data.size() > 0) {
//					seiky_kei_no = data.get(0).getString("seiky_kei_no");
//				}
//			}
//		}
		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 DEL START
		
		String mskm_dtl_no;
		if (mskmAddMap == null) {
			// 照査時の進捗登録処理
			mskm_dtl_no = (String)svcKeiMap.get("mskm_dtl_no");
		} else {
			// キャンセル、解約時の進捗登録処理
			mskm_dtl_no = (String)this.svcKeiMap.get(MSKM_DTL_NO);
		}

		// 進捗登録SIFを実行
		JKKSIFEKK1091Mapper mapper = new JKKSIFEKK1091Mapper();
		String[] idoRsnCdList = {IDO_RSN_CD_SONOTA};
		Map<String,Object> prgAddMap = new HashMap<String,Object>();
		// 申込明細番号
		prgAddMap.put("mskm_dtl_no", mskm_dtl_no);
		// 請求契約番号
		prgAddMap.put("seiky_kei_no", seiky_kei_no);
		// サービス契約番号
		prgAddMap.put("svc_kei_no", svcKeiNo);

		if (SERVICE_ID_KKSV0766.equals(serviceID))	// 照査処理
		{
			// 異動区分
			// IT2-2014-0000129 対応 藤田 2014/2/21 START
//			prgAddMap.put("ido_div", "00001");	// 新規契約
			prgAddMap.put("ido_div", (String)svcKeiMap.get("ido_div"));	// 新規契約
			// IT2-2014-0000129 対応 藤田 2014/2/21 END
			// 進捗ステータス
			prgAddMap.put("prg_stat", "0900");	// 照査ＯＫ
		} else if (SERVICE_ID_KKSV0769.equals(serviceID))	// キャンセル処理
		{	
			// 異動区分
			prgAddMap.put("ido_div", JKKStrConst.CD00576_CNCL);	// キャンセル
			// 進捗ステータス
			prgAddMap.put("prg_stat", "1201");	// キャンセル完了
		} else if (SERVICE_ID_KKSV0770.equals(serviceID))	// 解約処理
		{	
			// 異動区分
			prgAddMap.put("ido_div",JKKStrConst.CD00576_DSL);	// 解約
			// 進捗ステータス
			// IT2-2014-0000129 対応 藤田 2014/2/21 MOD START
//			prgAddMap.put("prg_stat", "0105");	// 解約完了
			prgAddMap.put("prg_stat", "1304");	// 解約完了
			// IT2-2014-0000129 対応 藤田 2014/2/21 MOD END
		}
		
		//異動日時
		prgAddMap.put("ido_dtm", new String(this.oPE_DATE_TIME));
		
		
		CAANMsg templateEKK1091D010 = mapper.getMappedTemplateEKK1091D010(prgAddMap, idoRsnCdList);
//		mapper.editTemplateCommon(param, templateEKK1091D010);

		// SIF実行
		CAANMsg[] resultMsgsEKK1091D010 = callScCmn(param, handle, templateEKK1091D010, mapper);
		
	}
	
	
	/**
	 * お客様退会ＣＣを呼び出します
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param workMap 作業領域
	 * @throws Throwable 任意の例外
	 */
	private void callCusTaikaiCmnKino(SessionHandle handle, IRequestParameterReadWrite param, Map<String, Object> workMap) throws Throwable
	{
		String funcCode = (String) this.soapRenkeiMap.get(IN_FUNC_CODE);
		String sysid    = (String) this.svcKeiMap.get(EKK0081A010CBSMsg1List.SYSID);
		String svcKeiNo = (String) this.soapRenkeiMap.get(SVC_KEI_NO);
		
		// マップ生成
		HashMap<String, Object> taikaiCCMap = new HashMap<String, Object>();

		// マップ編集
		taikaiCCMap.put("sysid", sysid);
		taikaiCCMap.put("svc_kei_no", svcKeiNo);
		taikaiCCMap.put(JCMConstants.FUNC_CODE_KEY, funcCode);
		param.setData(MAP_KEY_JCKCUSTTAIKAI, taikaiCCMap);

		//お客様退会ＣＣ呼出（指示書も内部で出されている）
		JCKCustTaikaiCmnCC executor = new JCKCustTaikaiCmnCC();
		executor.execute(handle, param, MAP_KEY_JCKCUSTTAIKAI);
		
		//下り電文に載らないよう、連携マップを消す
		param.removeData(MAP_KEY_JCKCUSTTAIKAI);
	}

	
	/**
	 * レスポンス作成処理
	 * @param param
	 * @param custMapBefore
	 * @param custMapAfter
	 */
	private void createResponse(
			IRequestParameterReadWrite param,
			Map<String, Object> custMapBefore,
			Map<String, Object> custMapAfter
		)
	 throws Exception
	{
		String returnCode = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (returnCode != null && "0000".equals(returnCode))
		{
			if (custMapBefore == null || custMapAfter == null) {
				throw new Exception("処理が正常終了していません");
			}
			
			// 処理が正常終了した場合
			String memberSbtCd1 = (String)custMapBefore.get(MEMBER_SBT_CD);
			String memberSbtCd2 = (String)custMapAfter.get(MEMBER_SBT_CD);
			
			if (SERVICE_ID_KKSV0766.equals(serviceID))
			{	// 照査処理時
				
				if (MBTYPE_CD_NOT_EO.equals(memberSbtCd1)	// 非ｅｏ会員
				 || MBTYPE_CD_FAMILY_KOJIN.equals(memberSbtCd1)	// ファミリー会員（個人）
				 || MBTYPE_CD_FAMILY_HOJIN.equals(memberSbtCd1)	// ファミリー会員（法人）
				 || MBTYPE_CD_OPEN.equals(memberSbtCd1))	// オープン会員
				{
					// マスター会員に変更・昇格
					if (MBTYPE_CD_MST_KOJIN.equals(memberSbtCd2) || MBTYPE_CD_MST_HOJIN.equals(memberSbtCd2))
					{
						soapRenkeiMap.put("sysid", custMapAfter.get("sysid"));
						soapRenkeiMap.put("eoid", custMapAfter.get("eoid"));
						soapRenkeiMap.put("member_sbt_cd", custMapAfter.get("member_sbt_cd"));
						// IT2-2014-0000129 対応 藤田 2014/2/21 ADD START
						soapRenkeiMap.put("shk_eoid", custMapAfter.get("shk_eoid"));
						soapRenkeiMap.put("shk_eoid_pwd", custMapAfter.get("shk_eoid_pwd"));
						// IT2-2014-0000129 対応 藤田 2014/2/21 ADD END
					}
				}
	
				if (MBTYPE_CD_NOT_EO.equals(memberSbtCd1))	// 非ｅｏ会員
				{
					// マスター会員に変更
					if (MBTYPE_CD_MST_KOJIN.equals(memberSbtCd2) || MBTYPE_CD_MST_HOJIN.equals(memberSbtCd2))
					{
						// IT2-2014-0000129 対応 藤田 2014/2/21 DEL START
//						soapRenkeiMap.put("shk_eoid", custMapAfter.get("shk_eoid"));
//						soapRenkeiMap.put("shk_eoid_pwd", custMapAfter.get("shk_eoid_pwd"));
						// IT2-2014-0000129 対応 藤田 2014/2/21 DEL END
						soapRenkeiMap.put("cust_ntaikai_cd", custMapAfter.get("cust_ntaikai_cd"));
						soapRenkeiMap.put("join_ymd", custMapAfter.get("join_ymd"));
					}
				}
	
			}
			else if (SERVICE_ID_KKSV0769.equals(serviceID) || SERVICE_ID_KKSV0770.equals(serviceID))
			{	// キャンセル処理時 または 解約処理時
				
				String custTaikaiYmd = (String) custMapAfter.get(ECK0011A010CBSMsg1List.CUST_TAIKAI_YMD);	//退会日
				boolean isNotEoMember = (MBTYPE_CD_NOT_EO.equals(memberSbtCd2) || !JKKBpCommon.isNull(custTaikaiYmd));
				
				// マスター会員
				if (MBTYPE_CD_MST_KOJIN.equals(memberSbtCd1) || MBTYPE_CD_MST_HOJIN.equals(memberSbtCd1) ||
					MBTYPE_CD_NOT_EO.equals(memberSbtCd1))			//受付済でキャンセルされた場合を考慮し、非ｅｏ会員も含める
				{
					// 非eo会員へ変更(退会)
					// オープン会員へ変更(降格)
					if (isNotEoMember	// 非ｅｏ会員か退会済
					||	MBTYPE_CD_OPEN.equals(memberSbtCd2))		// オープン会員
					{
						soapRenkeiMap.put("sysid", custMapAfter.get("sysid"));
						soapRenkeiMap.put("eoid", custMapAfter.get("eoid"));
						soapRenkeiMap.put("member_sbt_cd", custMapAfter.get("member_sbt_cd"));
					}
					
					if (isNotEoMember)
					{
						soapRenkeiMap.put("cust_ntaikai_cd", custMapAfter.get("cust_ntaikai_cd"));
						soapRenkeiMap.put("cust_taikai_ymd", custMapAfter.get("cust_taikai_ymd"));
					}
				}
			}
		} else {
			// 処理が正常終了しなかった場合
			if ("1000".equals(returnCode)
			 || "1050".equals(returnCode)
			 || "1100".equals(returnCode)
			 || "1150".equals(returnCode))
			{
//				// 単項目チェックエラー時等のエラーフラグをセット
//				soapRenkeiMap.put("err", (String)errMap.get(ERR_MAP_KEY_ERR_FLG));
//			} else {
//				throw new Exception();
			}
		}
	}

	// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 ADD START
	private String getSeikyKeiNoBySvcKeiNo(
			 SessionHandle handle
			,IRequestParameterReadWrite param
			,String svcKeiNo
		) throws Throwable
	{
		// 課金先一覧照会（サービス契約番号）を実行
		String seiky_kei_no = null;
		{
			JKKSIFEKK0321Mapper mapper = new JKKSIFEKK0321Mapper();
			CAANMsg templateEKK0321B005 = mapper.getMappedTemplateEKK0321B005(svcKeiNo);
//			mapper.editTemplateCommon(param, templateEKK0321B005);

			// SIF実行
			CAANMsg[] resultMsgsEKK0321B005 = callScCmn(param, handle, templateEKK0321B005, mapper);
			
			if (resultMsgsEKK0321B005.length > 0) {
				List<CAANMsg> data = new ArrayList();
				for (int i=0; i < resultMsgsEKK0321B005.length; i++) {
					CAANMsg r = resultMsgsEKK0321B005[i];
					CAANMsg[] kakinsList = r.getCAANMsgList(EKK0321B005CBSMsg.EKK0321B005CBSMSG1LIST);
					for (int j=0; j < kakinsList.length; j++) {
						data.add(kakinsList[j]);
					}
				}
				
				// 課金先番号 - 降順ソート
				Collections.sort(data, new Comparator<CAANMsg>()
						{
							public int compare(CAANMsg map1, CAANMsg map2)
							{
								String key1 = (String)map1.getString("kakins_no");
								String key2 = (String)map2.getString("kakins_no");
								return key2.compareTo(key1);
							}
						});
				// 最新の請求契約番号を取得
				if (data.size() > 0) {
					seiky_kei_no = data.get(0).getString("seiky_kei_no");
				}
			}
		}
		return seiky_kei_no;
	}
	
	/**
	 * 指定された請求契約番号に紐づくサービス契約のリストを取得します
	 * <br>
	 * @param handle
	 * @param param
	 * @param seikyKeiNo
	 * @return
	 * @throws Throwable
	 */
	private List<Map> getInternetServicesBySeikyuNo(
			 SessionHandle handle
			,IRequestParameterReadWrite param
			,String seikyKeiNo
		) throws Throwable
	{
		// 戻り値マップ
		List<Map> rtnList = new ArrayList<Map>();
		CAANMsg[] resultMsgs = null;
		
		// インターネットサービス一覧照会（請求契約番号）実行処理
		JKKSIFEKK0081Mapper mapperEKK0081 = new JKKSIFEKK0081Mapper();
		CAANMsg templateEKK0081B526 = mapperEKK0081.getMappedTemplateEKK0081B526(seikyKeiNo, JPCModelConstant.FUNC_CD_1);
		// SIF実行
		resultMsgs = callScCmn(param, handle, templateEKK0081B526, mapperEKK0081);
		CAANMsg[] msgEKK0081B526List = resultMsgs[0].getCAANMsgList(EKK0081B526CBSMsg.EKK0081B526CBSMSG1LIST);
		
		for(int i = 0; i < msgEKK0081B526List.length; i++)
		{
			CAANMsg msgEKK0081B526 = msgEKK0081B526List[i];

			// インターネットサービス一覧照会（請求契約番号）SIFから値を取得
			String rtnSvcKeiNo = msgEKK0081B526.getString(EKK0081B526CBSMsg1List.SVC_KEI_NO);		// サービス契約番号
			String rtnSvcKeiStat = msgEKK0081B526.getString(EKK0081B526CBSMsg1List.SVC_KEI_STAT);	// サービス契約ステータス

			Map<String, Object> map = new HashMap<String, Object>();
			map.put(SVCKEILIST1_SVC_KEI_NO, rtnSvcKeiNo);
			map.put(SVCKEILIST1_SVC_KEI_STAT, rtnSvcKeiStat);
			rtnList.add(map);
		}
		
		return rtnList;
	}
	
	/**
	 * リストで渡されたサービス契約にキャンセルまたは解約されていない有効なサービス契約がある場合に真を返します<br>
	 * その際、mineoSvcKeiNoに指定されたサービス契約番号はチェック対象から省きます
	 * ※解約・キャンセル処理内にてチェック処理
	 * <br>
	 * @param services
	 * @param statusList
	 * @param mineoSvcKeiNo
	 * @return 有効なサービス契約が含まれていればtrueを、なければfalseを返します
	 */
	private boolean isExistsEnabledServices(
			 List<Map> services
			,String mineoSvcKeiNo
		)
	{
		int aliveOtherNetCnt = 0;
		for (int i=0; i < services.size(); i++)
		{
			Map<String, Object> map = services.get(i);
			String svcKeiNo = (String)map.get(SVCKEILIST1_SVC_KEI_NO);
			String svcKeiStat = (String)map.get(SVCKEILIST1_SVC_KEI_STAT);
			// 自分以外のインターネットサービスで、解約・キャンセル済以外の場合、カウントする
			if(
				(svcKeiNo != null)
				&& !mineoSvcKeiNo.equals(svcKeiNo)
				&& (
						!JKKSvcConst.SVC_KEI_STAT_910.equals(svcKeiStat)
						&& !JKKSvcConst.SVC_KEI_STAT_920.equals(svcKeiStat)
				)
			)
			{
				aliveOtherNetCnt++;
			}
		}
		return aliveOtherNetCnt > 0;
	}

	/**
	 * 請求オプションサービス契約を照査します
	 * <br>
	 * @param handle
	 * @param param
	 * @param seikyKeiNo
	 * @param idoDiv
	 * @throws Throwable
	 */
	private void shosaForSeikyuOptionService(
			 SessionHandle handle
			,IRequestParameterReadWrite param
			,String seikyKeiNo
			,String idoDiv
		) throws Throwable
	{
		CAANMsg[] resultMsgs = null;
		// 請求オプションサービス契約一覧照会実行
		JKKSIFEKK0441Mapper mapperEKK0441 = new JKKSIFEKK0441Mapper();
		CAANMsg templateEKK0441B002 = mapperEKK0441.getMappedTemplateEKK0441B002(
							  seikyKeiNo
							, null
							, null
							, null
							, null
							, JPCModelConstant.FUNC_CD_1
						);
		// SIF実行
		resultMsgs = callScCmn(param, handle, templateEKK0441B002, mapperEKK0441);
		CAANMsg[] msgEKK0441B002List = resultMsgs[0].getCAANMsgList(EKK0441B002CBSMsg.EKK0441B002CBSMSG1LIST);
		
		for(int i = 0; i < msgEKK0441B002List.length; i++)
		{
			CAANMsg msgEKK0441B002 = msgEKK0441B002List[i];

			// 請求オプションサービス契約番号
			String seiopsvcKeiNo = msgEKK0441B002.getString(EKK0441B002CBSMsg1List.SEIOPSVC_KEI_NO);
			// 請求サービス契約ステータスを取得
			String seiopsvcKeiStat = msgEKK0441B002.getString(EKK0441B002CBSMsg1List.SEIOPSVC_KEI_STAT);
			
			// 請求オプションサービス契約一意照会実行
			CAANMsg templateEKK0441A010 = mapperEKK0441.getMappedTemplateEKK0441A010(
								  seiopsvcKeiNo
								, null
								, this.oPE_DATE
								, JPCModelConstant.FUNC_CD_2
							);
			// SIF実行
			resultMsgs = callScCmn(param, handle, templateEKK0441A010, mapperEKK0441);
			CAANMsg[] msgEKK0441A010List = resultMsgs[0].getCAANMsgList(EKK0441A010CBSMsg.EKK0441A010CBSMSG1LIST);
			// OM-2014-0002073 請求オプション一意照会結果の取得でシステムエラー 2014/06/04 藤田 MOD START
			//CAANMsg msgEKK0441A010 = msgEKK0441A010List[i];
			CAANMsg msgEKK0441A010 = msgEKK0441A010List[0];
			// OM-2014-0002073 請求オプション一意照会結果の取得でシステムエラー 2014/06/04 藤田 MOD END
			// 更新年月日時分秒(更新前)
			String updDtmBf = msgEKK0441A010.getString(EKK0441A010CBSMsg1List.LAST_UPD_DTM);
			//ANK-2248-00-00 ADD START
			//請求書発行手数料以外のオプションは無視
			if (!SEIOPSVC_CD_SEIKYSH_HAKKO.equals((String)msgEKK0441A010.getString(EKK0441A010CBSMsg1List.SEIOPSVC_CD)))
			{
				continue;
			}
			//ANK-2248-00-00 ADD END
			// 照査
			if(JKKSvcConst.SVC_KEI_STAT_010.equals(seiopsvcKeiStat)
			)
			{	// 受付済の場合、照査する
				// 照査解約完了コード
				String shosaDslFinCd = (String)soapRenkeiMap.get("shosa_dsl_fin_cd");
				// 請求オプションサービス契約照査
				CAANMsg templateEKK0441C210 = mapperEKK0441.getMappedTemplateEKK0441C030(
							  seiopsvcKeiNo
							, idoDiv
							, shosaDslFinCd
							, updDtmBf
							, JPCModelConstant.FUNC_CD_1
						);
				// SIF実行
				resultMsgs = callScCmn(param, handle, templateEKK0441C210, mapperEKK0441);
				updDtmBf = resultMsgs[0].getString(EKK0441C210CBSMsg.UPD_DTM);
			}
		}
	}
	
	/**
	 * 請求オプションサービス契約をキャンセルまたは解約します
	 * <br>
	 * @param handle
	 * @param param
	 * @param seikyKeiNo
	 * @param mskmDtlNo
	 * @param idoDiv
	 * @throws Throwable
	 */
	private void cancelOrKaiaykuForSeikyuOptionService(
			 SessionHandle handle
			,IRequestParameterReadWrite param
			,String seikyKeiNo
			,String mskmDtlNo
			,String idoDiv
		) throws Throwable
	{
		CAANMsg[] resultMsgs = null;
		// 請求オプションサービス契約一覧照会実行
		JKKSIFEKK0441Mapper mapperEKK0441 = new JKKSIFEKK0441Mapper();
		CAANMsg templateEKK0441B002 = mapperEKK0441.getMappedTemplateEKK0441B002(
							  seikyKeiNo
							, null
							, null
							, null
							, null
							, JPCModelConstant.FUNC_CD_1
						);
		// SIF実行
		resultMsgs = callScCmn(param, handle, templateEKK0441B002, mapperEKK0441);
		CAANMsg[] msgEKK0441B002List = resultMsgs[0].getCAANMsgList(EKK0441B002CBSMsg.EKK0441B002CBSMSG1LIST);
		
		for(int i = 0; i < msgEKK0441B002List.length; i++)
		{
			CAANMsg msgEKK0441B002 = msgEKK0441B002List[i];

			// 請求オプションサービス契約番号
			String seiopsvcKeiNo = msgEKK0441B002.getString(EKK0441B002CBSMsg1List.SEIOPSVC_KEI_NO);
			// 請求サービス契約ステータスを取得
			String seiopsvcKeiStat = msgEKK0441B002.getString(EKK0441B002CBSMsg1List.SEIOPSVC_KEI_STAT);

			// 請求オプションサービス契約一意照会実行
			CAANMsg templateEKK0441A010 = mapperEKK0441.getMappedTemplateEKK0441A010(
								  seiopsvcKeiNo
								, null
								, this.oPE_DATE
								, JPCModelConstant.FUNC_CD_2
							);
			// SIF実行
			resultMsgs = callScCmn(param, handle, templateEKK0441A010, mapperEKK0441);
			CAANMsg[] msgEKK0441A010List = resultMsgs[0].getCAANMsgList(EKK0441A010CBSMsg.EKK0441A010CBSMSG1LIST);
			// OM-2014-0002073 請求オプション一意照会結果の取得でシステムエラー 2014/06/04 藤田 MOD START
//			CAANMsg msgEKK0441A010 = msgEKK0441A010List[i];
			CAANMsg msgEKK0441A010 = msgEKK0441A010List[0];
			// OM-2014-0002073 請求オプション一意照会結果の取得でシステムエラー 2014/06/04 藤田 MOD END
			// 更新年月日時分秒(更新前)
			String updDtmBf = msgEKK0441A010.getString(EKK0441A010CBSMsg1List.LAST_UPD_DTM);
			//ANK-2248-00-00 ADD START
			//請求書発行手数料以外のオプションは無視
			if (!SEIOPSVC_CD_SEIKYSH_HAKKO.equals((String)msgEKK0441A010.getString(EKK0441A010CBSMsg1List.SEIOPSVC_CD)))
			{
				continue;
			}
			//ANK-2248-00-00 ADD END
			// キャンセル or 解約
			if(
					JKKSvcConst.SVC_KEI_STAT_010.equals(seiopsvcKeiStat)
					|| JKKSvcConst.SVC_KEI_STAT_020.equals(seiopsvcKeiStat)
			)
			{	// 受付済 or 照査済の場合は、キャンセル

				String svcCancelRsnCd = (String) this.soapRenkeiMap.get(IN_CL_RSN_CD);
				
				if (JKKStrConst.CD00576_DSL.equals(idoDiv))
				{	// MVNOサービス解約受付連携であるかを判定
					svcCancelRsnCd = "06";		// 06: 解約によるキャンセル
				}
				
				// 請求オプションサービス契約キャンセル
				CAANMsg templateEKK0441C210 = mapperEKK0441.getMappedTemplateEKK0441C210(
							  seiopsvcKeiNo
							, mskmDtlNo
							, svcCancelRsnCd
							, idoDiv
							, updDtmBf
							, JPCModelConstant.FUNC_CD_1
					);
				// SIF実行
				resultMsgs = callScCmn(param, handle, templateEKK0441C210, mapperEKK0441);
			}
			else if(
					JKKSvcConst.SVC_KEI_STAT_030.equals(seiopsvcKeiStat)
					|| JKKSvcConst.SVC_KEI_STAT_100.equals(seiopsvcKeiStat)
					|| JKKSvcConst.SVC_KEI_STAT_210.equals(seiopsvcKeiStat)
					|| JKKSvcConst.SVC_KEI_STAT_220.equals(seiopsvcKeiStat)
			)
			{	// 締結済 or サービス提供中 or 休止・中断中 or 停止中の場合は、解約

				String svcEndymd 	 = (String) this.soapRenkeiMap.get(IN_SVC_ENDYMD);
				String svcChrgEndymd = (String) this.soapRenkeiMap.get(IN_SVC_CHRG_ENDYMD);
				String svcDlreCd     = (String) this.soapRenkeiMap.get(IN_SVC_DLRE_CD);
				String svcDlreMemo   = (String) this.soapRenkeiMap.get(IN_SVC_DLRE_MEMO);
				String svcDslYmd 	 = (String) this.soapRenkeiMap.get(IN_SVC_DSL_YMD);
				String pnltyHasseiCd = "1";		// 違約金の発生いかんは料金側の計算に委ねる

				if (JKKStrConst.CD00576_CNCL.equals(idoDiv))
				{	// MVNOサービスキャンセル受付連携である場合
					svcDlreCd = "01";		// 01: 通常解約
					// サービス終了年月日     ← サービスキャンセル年月日
					svcEndymd = (String) this.soapRenkeiMap.get(IN_SVC_CL_YMD);
					// サービス課金終了年月日 ← サービスキャンセル年月日 -1
					svcChrgEndymd = JPCDateUtil.addDay(svcEndymd, -1);
					// サービス解約年月日     ← サービスキャンセル年月日
					svcDslYmd = (String) this.soapRenkeiMap.get(IN_SVC_CL_YMD);
				}
				
				// 請求オプションサービス契約解約処理
				CAANMsg templateEKK0441C230 = mapperEKK0441.getMappedTemplateEKK0441C230(
							  seiopsvcKeiNo
							, mskmDtlNo
							, this.oPE_DATE
							, svcEndymd
							, svcChrgEndymd
							, svcDslYmd
							, svcDlreCd
							, svcDlreMemo
							, idoDiv
							, updDtmBf
							, pnltyHasseiCd
							, JPCModelConstant.FUNC_CD_1
						);
				// SIF実行
				resultMsgs = callScCmn(param, handle, templateEKK0441C230, mapperEKK0441);
				
				CAANMsg seiopsvcKeiInfo = resultMsgs[0];
				updDtmBf = seiopsvcKeiInfo.getString(EKK0441C230CBSMsg.UPD_DTM);
				String geneAddDtm = seiopsvcKeiInfo.getString(EKK0441C230CBSMsg.GENE_ADD_DTM);

				// 請求オプションサービス契約解約確定処理
				CAANMsg templateEKK0441C240 = mapperEKK0441.getMappedTemplateEKK0441C240(
							  seiopsvcKeiNo
							, geneAddDtm
							, svcEndymd
							, svcChrgEndymd
							, svcDslYmd
							, svcDlreCd
							, svcDlreMemo
							, updDtmBf
							, JPCModelConstant.FUNC_CD_1
						);
				// SIF実行
				resultMsgs = callScCmn(param, handle, templateEKK0441C240, mapperEKK0441);
			}
		}
	}
	// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 ADD END
	
	// IT2-2014-0000129 対応 藤田 2014/2/21 DEL START
//	/**
//	 * お客様管理情報を更新します
//	 * @param param
//	 * @param handle
//	 * @param custMap お客様一意照会結果のマップ
//	 * @param svc_kei_no	サービス契約番号
//	 * @return
//	 * @throws Throwable
//	 */
//	protected String updCustinfo(
//			IRequestParameterReadWrite param,
//			SessionHandle handle,
//			Map<String, Object> custMap,
//			String svc_kei_no)
//	throws Throwable
//	{
//		String memberSbtCd 		= (String) custMap.get(ECK0011A010CBSMsg1List.MEMBER_SBT_CD);
//		String keisyaTypeCd 	= (String) custMap.get(ECK0011A010CBSMsg1List.KEISHA_TYPE_CD);
//		String currentSysid 	= (String) custMap.get(ECK0011A010CBSMsg1List.SYSID);
//		// 変更前会員種別コードを取得(後の処理で、変数に変更後の値が設定される)
//		String regitMemberSbtCd = (String) custMap.get(ECK0011A010CBSMsg1List.MEMBER_SBT_CD);
//		
//		//更新日時
//		String ck0011UpdDtm     = (String) custMap.get(ECK0011A010CBSMsg1List.LAST_UPD_DTM);
//
//		boolean isGroup = false;
//		// *************************************************** //
//		// お客様回復ＣＣ                                      //
//		// *************************************************** //
//		// お客様退会年月日がある場合、お客様回復処理を行い、上位に戻る
//		String cust_taikai_ymd = (String) custMap.get(ECK0011A010CBSMsg1List.CUST_TAIKAI_YMD);
//		if (!JKKBpCommon.isNull(cust_taikai_ymd))
//		{
//			// お客様回復
//			editCustKaihkMap(param, CUSTKAIHK_MAP, svc_kei_no);
//			(new JCKCustKaihkCmnCC()).execute(handle, param, CUSTKAIHK_MAP);
//
//			// お客様回復CCマップをクリア
//			param.removeData(CUSTKAIHK_MAP);
//			
//			return regitMemberSbtCd;
//		}
//
////		// *************************************************** //
////		// 料金グループコード判定                              //
////		// *************************************************** //
////		if (PRC_GRP_CD_TV_KCN.equals(prcGrpCd) || PRC_GRP_CD_TV_SSS.equals(prcGrpCd))
////		{
////			return regitMemberSbtCd;
////		}
//
//		// *************************************************** //
//		// 会員種別判定                                        //
//		// *************************************************** //
//		// 会員種別コードによって処理を分岐
//		if(
//				memberSbtCd.equals(MBTYPE_CD_MST_KOJIN)
//				|| memberSbtCd.equals(MBTYPE_CD_MST_HOJIN)
//		)
//		{
//			// マスター会員の場合は特に何もしない
//			// ※ ケース１：既にマスター会員の場合
//			// ※ ケース２：１SYSID、複数サービス契約の場合で
//			//    １サービス契約目の処理でマスター会員に変更された場合
//			return regitMemberSbtCd;
//		}
//
//		// 会員種別コードがマスター以外の場合
//		// 契約者タイプコードで個人か法人判断する
//		if(keisyaTypeCd.equals(KSH_TYPE_CO_KOJIN))
//		{
//			regitMemberSbtCd = MBTYPE_CD_MST_KOJIN;
//		}
//		else if (
//				keisyaTypeCd.equals(KSH_TYPE_CO_HOJIN)
//				|| keisyaTypeCd.equals(KSH_TYPE_CO_JISHA_USE)
//		)
//		{
//			regitMemberSbtCd = MBTYPE_CD_MST_HOJIN;
//		}
//		else if (keisyaTypeCd.equals(KSH_TYPE_CO_MNT))
//		{
//			// お客様＜個人＞一意照会
//			CAANMsg[] eck0021a010Msgs = callECK0021A010SC(param, handle, currentSysid);
//			CAANMsg[] workECK0021A010 = eck0021a010Msgs[0].getCAANMsgList(ECK0021A010CBSMsg.ECK0021A010CBSMSG1LIST);
//			// お客様＜法人＞一意照会
//			CAANMsg[] eck0031a010Msgs =  callECK0031A010SC(param, handle, currentSysid);
//			CAANMsg[] workECK0031A010 = eck0031a010Msgs[0].getCAANMsgList(ECK0031A010CBSMsg.ECK0031A010CBSMSG1LIST);
//			
//			String keisyaFlg = "0";
//			if(workECK0021A010 != null)
//			{
//				if (workECK0021A010.length > 0) {
//					regitMemberSbtCd = MBTYPE_CD_MST_KOJIN;
//					keisyaFlg = "1";
//				}
//			}
//			
//			if(workECK0031A010 != null)
//			{
//				if (workECK0031A010.length > 0)
//				{
//					regitMemberSbtCd = MBTYPE_CD_MST_HOJIN;
//					keisyaFlg = "1";
//				}
//			}
//			
//			if("0".equals(keisyaFlg))
//			{
//				regitMemberSbtCd = MBTYPE_CD_MST_HOJIN;
//			}
//		}
//
//		// 更新前会員種別コードを保持
//		String memberSbtCdBefore = memberSbtCd;
//		
//		String sysid = currentSysid;
//		
//		// 会員種別変更を実行
//		ArrayList<HashMap> wkMapArray = editMapMemberSbt(param, custMap, regitMemberSbtCd);
//		for (int i=0; i < wkMapArray.size(); i++) {
//			HashMap<String, Object> updCustMap = wkMapArray.get(i);
//			// SIF実行
//			ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
//			Map<?, ?> rslt = scCall.run(updCustMap, handle);
//			// 結果を取得
//			ArrayList<Object> wkErrorList = this.editResultRPECK0011C120(rslt, param);
//			CAANMsg[] eck0011c120Templates = (CAANMsg[])rslt.get(JCMConstants.TEMPLATE_LIST_KEY);
//			CAANMsg eck0011c120Template = eck0011c120Templates[0];
//			if (!eck0011c120Template.isNull(ECK0011C120CBSMsg.SHK_EOID)) 
//			{
////				shk_eoId = eck0011c120Template.getString(ECK0011C120CBSMsg.SHK_EOID);
//				sysid = eck0011c120Template.getString(ECK0011C120CBSMsg.SYSID);
//				currentSysid = sysid;
//				
//			}
//			
//			// 更新日付を書き換え
//			ck0011UpdDtm = eck0011c120Template.getString(ECK0011C120CBSMsg.UPD_DTM);
//		}
//		
//		// ファミリー会員グループ一覧照会（SYSID）を実行
//		{
//			JKKSIFECK0111Mapper mapper = new JKKSIFECK0111Mapper();
//			CAANMsg template = mapper.getMappedTemplateECK0111B002(sysid);
////			mapper.editTemplateCommon(param, template);
//			// SIF実行
//			CAANMsg[] resultMsgs = callScCmn(param, handle, template, mapper);
//			CAANMsg[] eck0111MsgList = resultMsgs[0].getCAANMsgList(ECK0111B002CBSMsg.ECK0111B002CBSMSG1LIST);
//			if (null != eck0111MsgList && eck0111MsgList.length > 0) {
//				isGroup = true;
//			}
//		}
//
//		//グループ登録、お客様グループ設定
//		if(!isGroup ||
//				JCKStrConst.CD00039_FAMILY_HOJIN.equals(memberSbtCdBefore)
//				|| JCKStrConst.CD00039_FAMILY_KOJIN.equals(memberSbtCdBefore)){
//			//グループ登録	
//			{
//				JKKSIFECK0111Mapper mapper = new JKKSIFECK0111Mapper();
//				CAANMsg templateECK0111D010 = mapper.getMappedTemplateECK0111D010(sysid, this.oPE_DATE, null, ck0011UpdDtm);
////				mapper.editTemplateCommon(param, templateECK0111D010);
//
//				// SIF実行
//				callScCmn(param, handle, templateECK0111D010, mapper);
////				editResultRPECK0111D010(param);
//			}
//			
//			// お客様グループ設定
//			//元ファミリー会員の場合、元のお客様グループ設定を無効にする
//			if (JCKStrConst.CD00039_FAMILY_HOJIN.equals(memberSbtCdBefore) || JCKStrConst.CD00039_FAMILY_KOJIN.equals(memberSbtCdBefore))
//			{
//				// お客様グループ設定一覧照会(PMP連携用)を実行
//				JKKSIFECK0121Mapper mapper = new JKKSIFECK0121Mapper();
//				CAANMsg templateECK0121B020 = mapper.getMappedTemplateECK0121B020(sysid);
////				mapper.editTemplateCommon(param, templateECK0111B002);
//				
//				// SIF実行
//				CAANMsg[] resultMsgs = callScCmn(param, handle, templateECK0121B020, mapper);
//				
//				// お客様グループ設定無効を実行
//				if (resultMsgs != null && resultMsgs.length > 0) {
//					CAANMsg[] eck0121MsgList = resultMsgs[0].getCAANMsgList(ECK0121B020CBSMsg.ECK0121B020CBSMSG1LIST);
//					if (null != eck0121MsgList && 0 < eck0121MsgList.length)
//					{
//						String cust_grp_sette_no = eck0121MsgList[0].getString(ECK0121B020CBSMsg1List.CUST_GRP_SETTE_NO);
//						CAANMsg templateECK0121C020 = mapper.getMappedTemplateECK0121C020(cust_grp_sette_no, this.oPE_DATE, ck0011UpdDtm);
//	//					mapper.editTemplateCommon(param, templateECK0121C020);
//	
//						// SIF実行
//						callScCmn(param, handle, templateECK0121C020, mapper);
//					}
//				}
//			}
//		}
//		
//		//連携データ区分01「お客様のグループ情報」
//		JKKBpCommon.putAxMRenkeiDataKbn(
//				param, SJISHO_MAP, JKKAddSjishoConst.RENKEI_DATA_KBN_CUST_GRP, JKKAddSjishoConst.TRN_KBN_ADD, 
//				new String[]{}, currentSysid);
//		//連携データ区分11「お客様の基本情報」
//		JKKBpCommon.putAxMRenkeiDataKbn(
//				param, SJISHO_MAP, JKKAddSjishoConst.RENKEI_DATA_KBN_CUST_INF, JKKAddSjishoConst.TRN_KBN_ADD, 
//				new String[]{svc_kei_no}, currentSysid);
//		
//		// 指示書登録処理
//		addSjisho(handle, param);
//		
//		return regitMemberSbtCd;
//	}
	
//	/**
//	 * お客様回復CC 入力マップ編集
//	 * 
//	 * @param param リクエストパラメータ
//	 * @param mapNm マップID
//	 * @param svc_kei_no サービス契約番号
//	 * @throws RequestParameterException 例外
//	 */
//	protected void editCustKaihkMap(IRequestParameterReadWrite param, String mapNm, String svc_kei_no)
//	throws RequestParameterException
//	{
//		HashMap<String, Object> targetMap = (HashMap<String, Object>)param.getData(mapNm);
//		if (null == targetMap)
//		{
//			targetMap = new HashMap<String, Object>();
//			param.setData(mapNm, targetMap);
//		}
//		
//		//機能コード
//		targetMap.put(JCMConstants.FUNC_CODE_KEY, JPCModelConstant.FUNC_CD_1);
//		
//		//ＳＹＳＩＤ
//		targetMap.put("sysid", currentSysid);
//		
//		//サービス契約番号
//		targetMap.put("svc_kei_no", svc_kei_no);
//	}
	// IT2-2014-0000129 対応 藤田 2014/2/21 DEL END
	
//	/**
//	 * 会員種別変更のマッピング処理です。
//	 * <br>
//	 * @param param モデルグループ、コントロールマップを含むパラメータオブジェクト
//	 * @param userDataIndex param内の業務データのインデックス
//	 * @param custMap 一意照会の結果データ
//	 * @param regitMemberSbtCd param内の業務データのインデックス
//	 * @return 実行結果
//	 * @throws Throwable
//	 */
//	private ArrayList<HashMap> editMapMemberSbt(IRequestParameterReadWrite param,
//			Map<String, Object> custMap, String regitMemberSbtCd)
//	throws Throwable
//	{
//		HashMap<String, Object> rslt = null;
//		
//		ArrayList<HashMap> wkMapArray = null;
//		
//		// お客様一意照会の結果データを取得
//		wkMapArray = new ArrayList();
////		CAANMsg[] wkTenplates = (CAANMsg[])custMap.get(ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST);
////		
////		if(wkTenplates != null)
////		{
////			for (int i = 0; i < wkTenplates.length; i++)
////			{
////				CAANMsg childTemplate = wkTenplates[i];
//				JKKSIFECK0011Mapper mapper = new JKKSIFECK0011Mapper();
//				String sysid = (String)custMap.get(ECK0011A010CBSMsg1List.SYSID);
//				String upd_dtm_bf = (String)custMap.get(ECK0011A010CBSMsg1List.UPD_DTM);
//				CAANMsg templateECK0011C120 = mapper.getMappedTemplateECK0011C120(sysid, upd_dtm_bf, regitMemberSbtCd);
//				mapper.editTemplateCommon(param, templateECK0011C120);
//				
//				rslt = mapper.editInMsgCmn(param);
//				rslt.put(JCMConstants.TEMPLATE_LIST_KEY, new CAANMsg[]{templateECK0011C120});
//				wkMapArray.add(rslt);
////			}
////		}
//		
//		return wkMapArray;
//	}

	// ANK-3315-00-00 ADD START
	/**
	 * 単項目関連チェックを行います。
	 * <br>
	 * @param param リクエストパラメータ
	 * @throws CCException チェックエラーの場合
	 */
	private void checkTankoumokukanren(IRequestParameterReadWrite param)
	throws CCException
	{
		int returnCode = 0;

		String tratCd1 = null;
		String tratCd2 = null;
		String tratCd3 = null;
		String tratCd4 = null;

		if (soapRenkeiMap.containsKey(TRAT_CD_1_1))
		{
			tratCd1 = (String)this.soapRenkeiMap.get(TRAT_CD_1_1);
		}
		if (soapRenkeiMap.containsKey(TRAT_CD_1_2))
		{
			tratCd2 = (String)this.soapRenkeiMap.get(TRAT_CD_1_2);
		}
		if (soapRenkeiMap.containsKey(TRAT_CD_2_1))
		{
			tratCd3 = (String)this.soapRenkeiMap.get(TRAT_CD_2_1);
		}
		if (soapRenkeiMap.containsKey(TRAT_CD_2_2))
		{
			tratCd4 = (String)this.soapRenkeiMap.get(TRAT_CD_2_2);
		}

		// 取扱コード1チェック
		if (tratCd1 != null && "".equals(tratCd1) && !JKKStringUtil.isNullBlank(tratCd2))
		{
			// 単項目関連チェックエラー
			returnCode = JPCModelConstant.ITEM_RELATION_ERR;
			soapRenkeiMap.put(TRAT_CD_1_1 + ERRITEM_SUFFIX, ERR_E1);
		}

		// 取扱コード2チェック
		if (tratCd3 != null && "".equals(tratCd3) && !JKKStringUtil.isNullBlank(tratCd4))
		{
			// 単項目関連チェックエラー
			returnCode = JPCModelConstant.ITEM_RELATION_ERR;
			soapRenkeiMap.put(TRAT_CD_2_1 + ERRITEM_SUFFIX, ERR_E1);
		}

		// チェックエラーの場合
		if (0 < returnCode)
		{
			// エラー情報設定
			String formatStatus = String.format(RETURN_MESSAGE_FORMAT, returnCode);
			String message = JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);

			ArrayList<Object> errList = new ArrayList<Object>();
			HashMap<String, Object> errorMap = new HashMap<String, Object>();
			HashMap<String, String> errorMapChild = new HashMap<String, String>();
			errorMap.put(ErrorInfoMapKeys.RETURN_CODE, RETURN_CODE_NORMAL);
			errorMap.put(ErrorInfoMapKeys.TEMPLATE_ID, "JKKEoelecKeiChgCC");
			errorMap.put(ErrorInfoMapKeys.STATUS, returnCode);
			errorMap.put(ErrorInfoMapKeys.ITEM_CHECK_ERRORS, errorMapChild);
			errList.add(errorMap);
			param.setControlMapData(SCControlMapKeys.ERROR_INFO, errList);

			throw new CCException(SC_ERROR_STRING, new Exception());
		}
	}
	// ANK-3315-00-00 ADD END
	
	/**
	 * サービス契約一意照会SIFを呼び出し
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @param inHash 条件用Hash
	 * @param resultHash 結果のハッシュ
	 * @param index 処理順番
	 * @return サービスインターフェースのリターンコード
	 * @throws Throwable 
	 */
	private HashMap<String, Object> callEKK0081A010SC(
			IRequestParameterReadWrite param,
			SessionHandle handle)
			throws Throwable
	{
		// SIFの実行結果から取得したCAANMsg[]
		CAANMsg[] resultMsgs = null;
		CAANMsg template = null;

		String svcKeiNo = (String)this.soapRenkeiMap.get(SVC_KEI_NO);
		
		//EKK0081A010への呼び出しパラメータ設定
		JKKSIFEKK0081Mapper mapper = new JKKSIFEKK0081Mapper();
		template = mapper.getMappedTemplateEKK0081A010(svcKeiNo, this.oPE_DATE);
//		mapper.editTemplateCommon(param, template);
		
		// SIF実行
		resultMsgs = callScCmn(param, handle, template, mapper);

		// 結果を設定
		HashMap<String, Object> resultHash = mappingCAANOutMsgOne(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST, resultMsgs);

		return resultHash;
	}


//	private HashMap<String, Object> callEKK0081A010(IRequestParameterReadWrite param, SessionHandle handle, String fixedText) throws Throwable
//	{
//		HashMap<?, ?> ioDataMap = (HashMap<?, ?>) param.getData(fixedText);
//		
//		String svcKeiNo = (String)ioDataMap.get(SVC_KEI_NO);
//		
//		//EKK0081A010への呼び出しパラメータ設定
//		JKKSIFEKK0081Mapper mapper = new JKKSIFEKK0081Mapper();
//		CAANMsg template = mapper.getMappedTemplateEKK0081A010(svcKeiNo, this.oPE_DATE);
//		mapper.editTemplateCommon(param, template);
//		
//		// SIF実行
//		CAANMsg[] resultMsgs = callScCmn(param, handle, template);
//
//		// 結果を設定
//		HashMap<String, Object> resultHash = mappingCAANOutMsgOne(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST, resultMsgs);
//
//		return resultHash;
//	}

	// ANK-3315-00-00 ADD START
	/**
	 * 申込明細一意照会を実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param mskmMsNo 申込明細番号
	 * @return 申込明細一意照会明細
	 * @throws Throwable 例外が発生した場合
	 */
	private HashMap<String, Object> callEKK0021A010SC(IRequestParameterReadWrite param, SessionHandle handle, String mskmMsNo)
	throws Throwable
	{
		// SIFの実行結果から取得したCAANMsg[]
		CAANMsg[] resultMsgs = null;
		CAANMsg template = null;

		//EKK0021A010への呼び出しパラメータ設定
		JKKSIFEKK0021Mapper mapper = new JKKSIFEKK0021Mapper();
		template = mapper.getMappedTemplateEKK0021A010(mskmMsNo, null);

		// SIF実行
		resultMsgs = callScCmn(param, handle, template, mapper);

		// 結果を設定
		HashMap<String, Object> resultHash = mappingCAANOutMsgOne(EKK0021A010CBSMsg.EKK0021A010CBSMSG1LIST, resultMsgs);

		return resultHash;
	}

	/**
	 * 申込_代理店一覧照会を実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param mskmNo 申込番号
	 * @return 申込_代理店一覧照会明細
	 * @throws Throwable 例外が発生した場合
	 */
	private ArrayList<HashMap<String, Object>> callEKK0071B002SC(IRequestParameterReadWrite param, SessionHandle handle, String mskmNo)
	throws Throwable
	{

		// SIFの実行結果から取得したCAANMsg[]
		CAANMsg[] resultMsgs = null;
		CAANMsg template = null;

		//EKK0071B002への呼び出しパラメータ設定
		JKKSIFEKK0071Mapper mapper = new JKKSIFEKK0071Mapper();

		// SIF実行
		template = mapper.getMappedTemplateEKK0071B002(mskmNo);
		resultMsgs = callScCmn(param, handle, template, mapper);

		// 結果を設定
		ArrayList<HashMap<String, Object>> resultHash = mappingCAANOutMsg(EKK0071B002CBSMsg.EKK0071B002CBSMSG1LIST, resultMsgs);
		return resultHash;
	}

	/**
	 * 申込_代理店チェックを行います。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param ekk0071b002Msg1List 申込_代理店一覧照会明細
	 * @param ekk0021a010Msg 申込明細一意照会明細(カレント)
	 * @throws CCException チェックエラーの場合
	 */
	private void checkMskmAgnt(IRequestParameterReadWrite param
								, SessionHandle handle
								, ArrayList<HashMap<String, Object>> ekk0071b002Msg1List
								) throws CCException
	{
		String tratCd1 = "";
		String tratCd2 = "";
		String tratCd3 = "";
		String tratCd4 = "";

		for (int i = 0 ; i < ekk0071b002Msg1List.size(); i++)
		{
			HashMap<String, Object> ekk0071b002HashMap = (HashMap<String, Object>)ekk0071b002Msg1List.get(i);
			String dspJun = (String)ekk0071b002HashMap.get(EKK0071B002CBSMsg1List.DSP_JUN);
			
			if (DSP_JUN_1.equals(dspJun))
			{
				tratCd1 = (String)ekk0071b002HashMap.get(EKK0071B002CBSMsg1List.AGNT_CD);
			}
			else if (DSP_JUN_2.equals(dspJun))
			{
				tratCd2 = (String)ekk0071b002HashMap.get(EKK0071B002CBSMsg1List.AGNT_CD);
			}
			else if (DSP_JUN_3.equals(dspJun))
			{
				tratCd3 = (String)ekk0071b002HashMap.get(EKK0071B002CBSMsg1List.AGNT_CD);
			}
			else if (DSP_JUN_4.equals(dspJun))
			{
				tratCd4 = (String)ekk0071b002HashMap.get(EKK0071B002CBSMsg1List.AGNT_CD);
			}
		}

		// 取扱コード存在チェック
		int returnCode = checkAgntX_1Exist(tratCd1, tratCd2, tratCd3, tratCd4);
		// チェックエラーの場合
		errorEdit(param , returnCode);

		// 取扱コード1存在チェック
		returnCode = checkAgnt1Exist(tratCd1, tratCd3);
		// チェックエラーの場合
		errorEdit(param , returnCode);

		// 取扱コード重複チェック
		returnCode = checkAgntDuplicate(tratCd2, tratCd4);
		// チェックエラーの場合
		errorEdit(param , returnCode);
	}

	/**
	 * エラー情報を作成します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param returnCode リターンコード
	 * @throws CCException チェックエラーの場合
	 */
	private void errorEdit(IRequestParameterReadWrite param, int returnCode)
	throws CCException
	{

		if (0 < returnCode)
		{
			// エラー情報設定
			String formatStatus = String.format(RETURN_MESSAGE_FORMAT, returnCode);
			String message = JCMAPLConstMgr.getString(RETURN_MESSAGE_STRING + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);

			ArrayList<Object> errList = new ArrayList<Object>();
			HashMap<String, Object> errorMap = new HashMap<String, Object>();
			HashMap<String, String> errorMapChild = new HashMap<String, String>();
			errorMap.put(ErrorInfoMapKeys.RETURN_CODE, RETURN_CODE_NORMAL);
			errorMap.put(ErrorInfoMapKeys.TEMPLATE_ID, "JKKEoelecKeiChgCC");
			errorMap.put(ErrorInfoMapKeys.STATUS, returnCode);
			errorMap.put(ErrorInfoMapKeys.ITEM_CHECK_ERRORS, errorMapChild);
			errList.add(errorMap);
			param.setControlMapData(SCControlMapKeys.ERROR_INFO, errList);

			throw new CCException(SC_ERROR_STRING, new Exception());
		}
	}

	/**
	 * 取扱コード存在チェックを行います。
	 * <br>
	 * @param tratCd_1_1 取扱コード1-1
	 * @param tratCd_1_2 取扱コード1-2
	 * @param tratCd_2_1 取扱コード2-1
	 * @param tratCd_2_2 取扱コード2-2
	 * @return リターンコード
	 */
	private int checkAgntX_1Exist(String tratCd_1_1
									, String tratCd_1_2
									, String tratCd_2_1
									, String tratCd_2_2)
	{
		int returnCode = 0;

		String updateAgnt1_1 = tratCd_1_1;
		if (soapRenkeiMap.containsKey(TRAT_CD_1_1))
		{
			updateAgnt1_1 = (String)this.soapRenkeiMap.get(TRAT_CD_1_1);
		}

		String updateAgnt1_2 = tratCd_1_2;
		if (soapRenkeiMap.containsKey(TRAT_CD_1_2))
		{
			updateAgnt1_2 = (String)this.soapRenkeiMap.get(TRAT_CD_1_2);
		}

		if (JKKStringUtil.isNullBlank(updateAgnt1_1) && !JKKStringUtil.isNullBlank((updateAgnt1_2)))
		{
			// 関連チェックエラー
			returnCode = JPCModelConstant.RELATION_ERR;
			soapRenkeiMap.put(TRAT_CD_1_1 + ERRITEM_SUFFIX, ERR_ED);
			return returnCode;
		}

		String updateAgnt2_1 = tratCd_2_1;
		if (soapRenkeiMap.containsKey(TRAT_CD_2_1))
		{
			updateAgnt2_1 = (String)this.soapRenkeiMap.get(TRAT_CD_2_1);
		}

		String updateAgnt2_2 = tratCd_2_2;
		if (soapRenkeiMap.containsKey(TRAT_CD_2_2))
		{
			updateAgnt2_2 = (String)this.soapRenkeiMap.get(TRAT_CD_2_2);
		}

		if (JKKStringUtil.isNullBlank(updateAgnt2_1) && !JKKStringUtil.isNullBlank((updateAgnt2_2)))
		{
			// 関連チェックエラー
			returnCode = JPCModelConstant.RELATION_ERR;
			soapRenkeiMap.put(TRAT_CD_2_1 + ERRITEM_SUFFIX, ERR_ED);
			return returnCode;
		}

		return returnCode;
	}

	/**
	 * 取扱コード1存在チェックを行います。
	 * <br>
	 * @param tratCd_1_1 取扱コード1-1
	 * @param tratCd_2_1 取扱コード2-1
	 * @return リターンコード
	 */
	private int checkAgnt1Exist(String tratCd_1_1, String tratCd_2_1)
	{
		int returnCode = 0;

		String updateAgnt1_1 = tratCd_1_1;
		if (soapRenkeiMap.containsKey(TRAT_CD_1_1))
		{
			updateAgnt1_1 = (String)this.soapRenkeiMap.get(TRAT_CD_1_1);
		}

		String updateAgnt2_1 = tratCd_2_1;
		if (soapRenkeiMap.containsKey(TRAT_CD_2_1))
		{
			updateAgnt2_1 = (String)this.soapRenkeiMap.get(TRAT_CD_2_1);
		}

		if (JKKStringUtil.isNullBlank(updateAgnt1_1) && !JKKStringUtil.isNullBlank((updateAgnt2_1)))
		{
			// 関連チェックエラー
			returnCode = JPCModelConstant.RELATION_ERR;
			soapRenkeiMap.put(TRAT_CD_1_1 + ERRITEM_SUFFIX, ERR_EE);
			return returnCode;
		}
		
		return returnCode;
	}

	/**
	 * 取扱コード重複チェックを行います。
	 * <br>
	 * @param tratCd_1_2 取扱コード1-2
	 * @param tratCd_2_2 取扱コード2-2
	 * @return リターンコード
	 */
	private int checkAgntDuplicate(String tratCd_1_2, String tratCd_2_2)
	{
		int returnCode = 0;

		String updateAgnt1_2 = tratCd_1_2;
		if (soapRenkeiMap.containsKey(TRAT_CD_1_2))
		{
			updateAgnt1_2 = (String)this.soapRenkeiMap.get(TRAT_CD_1_2);
		}

		String updateAgnt2_2 = tratCd_2_2;
		if (soapRenkeiMap.containsKey(TRAT_CD_2_2))
		{
			updateAgnt2_2 = (String)this.soapRenkeiMap.get(TRAT_CD_2_2);
		}

		if (!JKKStringUtil.isNullBlank(updateAgnt1_2) && updateAgnt1_2.equals(updateAgnt2_2))
		{
			// 関連チェックエラー
			returnCode = JPCModelConstant.RELATION_ERR;
			this.soapRenkeiMap.put(TRAT_CD_1_2 + ERRITEM_SUFFIX, ERR_EF);
			return returnCode;
		}

		return returnCode;
	}

	/**
	 * 申込_代理店削除を実行します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @param ekk0071b002Msg1List 申込_代理店一覧照会
	 * @throws Throwable 例外が発生した場合
	 */
	private void callEKK0071E020SC(IRequestParameterReadWrite param, SessionHandle handle,
			ArrayList<HashMap<String, Object>> ekk0071b002Msg1List)
	throws Throwable
	{
		for (int i = 0 ; i < ekk0071b002Msg1List.size(); i++)
		{
			HashMap<String, Object> ekk0071b002HashMap = (HashMap<String, Object>)ekk0071b002Msg1List.get(i);
			String dspJun = (String)ekk0071b002HashMap.get(EKK0071B002CBSMsg1List.DSP_JUN);
			
			if (DSP_JUN_1.equals(dspJun) && soapRenkeiMap.containsKey(TRAT_CD_1_1))
			{
				runEKK0071E020SC(handle, param, ekk0071b002HashMap);
			}
			else if (DSP_JUN_2.equals(dspJun) && soapRenkeiMap.containsKey(TRAT_CD_1_2))
			{
				runEKK0071E020SC(handle, param, ekk0071b002HashMap);
			}
			else if (DSP_JUN_3.equals(dspJun) && soapRenkeiMap.containsKey(TRAT_CD_2_1))
			{
				runEKK0071E020SC(handle, param, ekk0071b002HashMap);
			}
			else if (DSP_JUN_4.equals(dspJun) && soapRenkeiMap.containsKey(TRAT_CD_2_2))
			{
				runEKK0071E020SC(handle, param, ekk0071b002HashMap);
			}
		}
	}

	/**
	 * 申込_代理店削除を実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param targetRec 申込_代理店一覧照会
	 * @throws Throwable 例外が発生した場合
	 */
	private void runEKK0071E020SC(SessionHandle handle, IRequestParameterReadWrite param,  HashMap<String, Object> ekk0071b002HashMap) throws Throwable
	{

		// SIFの実行結果から取得したCAANMsg[]
		CAANMsg[] resultMsgs = null;
		CAANMsg template = null;

		//EKK0071E020への呼び出しパラメータ設定
		JKKSIFEKK0071Mapper mapper = new JKKSIFEKK0071Mapper();

		// インプットパラメータの設定
		// 申込番号
		String mskm_no = (String)ekk0071b002HashMap.get(EKK0071B002CBSMsg1List.MSKM_NO);
		// 代理店コード
		String agnt_cd = (String)ekk0071b002HashMap.get(EKK0071B002CBSMsg1List.AGNT_CD);
		// 申込＿代理店番号
		String mskm_agnt_no = "00" + (String)ekk0071b002HashMap.get(EKK0071B002CBSMsg1List.DSP_JUN);
		// 更新年月日時分秒(更新前)
		String upd_dtm = (String)ekk0071b002HashMap.get(EKK0071B002CBSMsg1List.UPD_DTM);

		// SIF実行
		template = mapper.getMappedTemplateEKK0071E020(mskm_no, agnt_cd, mskm_agnt_no, upd_dtm);
		resultMsgs = callScCmn(param, handle, template, mapper);
	}

	/**
	 * 申込_代理店登録を実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param mskmDtlMap 申込明細一意照会明細(カレント)
	 * @throws Throwable 例外が発生した場合
	 */
	private void callEKK0071D010SC(SessionHandle handle, IRequestParameterReadWrite param, Map<String, Object> mskmDtlMap)
	throws Throwable
	{
		for (int i = 0 ; i < TRAT_LIST.length; i++)
		{
			if (soapRenkeiMap.containsKey(TRAT_LIST[i]))
			{
				// 登録します。
				if (!JKKStringUtil.isNullBlank((String)this.soapRenkeiMap.get(TRAT_LIST[i])))
				{
					runEKK0071D010SC(handle, param, (String)mskmDtlMap.get(EKK0021A010CBSMsg1List.MSKM_NO), (String)soapRenkeiMap.get(TRAT_LIST[i]), i + 1);
				}
			}
		}
	}
	
	/**
	 * 申込_代理店登録を実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param mskmNo 申込番号
	 * @param tratCd 代理店コード
	 * @param dspJun 表示順
	 * @throws Throwable 例外が発生した場合
	 */
	private void runEKK0071D010SC(SessionHandle handle, IRequestParameterReadWrite param, String mskmNo, String tratCd, int dspJun)
	throws Throwable
	{
		// SIFの実行結果から取得したCAANMsg[]
		CAANMsg[] resultMsgs = null;
		CAANMsg template = null;

		//EKK0071D010への呼び出しパラメータ設定
		JKKSIFEKK0071Mapper mapper = new JKKSIFEKK0071Mapper();

		// インプットパラメータの設定
		// 申込＿代理店番号
		String mskmAgntNo = "00" + String.valueOf(dspJun);

		// SIF実行
		template = mapper.getMappedTemplateEKK0071D010(mskmNo, tratCd,  String.valueOf(dspJun), mskmAgntNo);
		resultMsgs = callScCmn(param, handle, template, mapper);
	}
	// ANK-3315-00-00 ADD END

	/**
	 * ECK0011A010 お客様一意照会を実行します（カレントを取得）
	 * <br/>
	 * 
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @param sysid sysid
	 * @param resultHash 照会結果
	 * @throws Throwable 任意の例外
	 */
	private Map<String, Object> callECK0011A010SC(
			IRequestParameterReadWrite param,
			SessionHandle handle,
			String sysid
	) throws Throwable
	{
		if (null == sysid || 1 > sysid.length())
		{
			return null;
		}
		
		// SIFの実行結果から取得したCAANMsg[]
		CAANMsg[] resultMsgs = null;
		// テンプレート情報部（入力時の情報）
		CAANMsg template = null;

		// ECK0011A010への呼び出しパラメータ設定
		JKKSIFECK0011Mapper mapper = new JKKSIFECK0011Mapper();
		template = mapper.getMappedTemplateECK0011A010(sysid, this.oPE_DATE);
//		mapper.editTemplateCommon(param, template);

		// SIF実行
		resultMsgs = callScCmn(param, handle, template, mapper);

		// 結果を設定
		HashMap<String, Object> resultHash = mappingCAANOutMsgOne(ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST, resultMsgs);

		// お客様系の採集更新年月日時分秒
//		String custUpdDtm = (String)resultHash.get(ECK0011A010CBSMsg1List.LAST_UPD_DTM);
//		cancelSvcKeiMapper.setCustUpdDtm(custUpdDtm);

		return resultHash;
	}

	/**
	 * サービス契約＜mineo＞照査を実行します
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @return resultHash 実行結果
	 * @throws Throwable
	 */
	private Map<String, Object> callEKK2821C010SC(
			IRequestParameterReadWrite param,
			SessionHandle handle)
	 throws Throwable
	{
		Map<String, Object> resultHash = new HashMap<String, Object>();

		// サービス契約番号
		String svc_kei_no = (String)soapRenkeiMap.get(SVC_KEI_NO);
		// 整理番号
		String seiri_no = null;
		if (svcKeiMap != null) {
			seiri_no = (String)svcKeiMap.get("seiri_no");
		}
		// 異動区分
		// IT2-2014-0000129 対応 藤田 2014/2/21 START
//		String ido_div = JKKStrConst.CD00576_00001;	// 00001：新規受付
		String ido_div = null;
		if (svcKeiMap != null) {
			ido_div = (String)svcKeiMap.get("ido_div");
		} else {
			ido_div = JKKStrConst.CD00576_00001;	// 00001：新規受付
		}
		// IT2-2014-0000129 対応 藤田 2014/2/21 END
		
		// 照査年月日
		String shosa_ymd = (String)soapRenkeiMap.get("shosa_ymd");
		// 照査解約完了コード
		String shosa_dsl_fin_cd = (String)soapRenkeiMap.get("shosa_dsl_fin_cd");
		// 自動照査処理状態コード
		String auto_shosa_tran_stat_cd = "1";	// 処理済
		
		// EKK2821C010への呼び出しパラメータ設定
		JKKSIFEKK2821Mapper mapper = new JKKSIFEKK2821Mapper();
		CAANMsg template = mapper.getMappedTemplateEKK2821C010(
				svc_kei_no, seiri_no, ido_div, shosa_ymd, shosa_dsl_fin_cd, auto_shosa_tran_stat_cd);
//		mapper.editTemplateCommon(param, template);
		
		// SIF実行
		CAANMsg[] resultMsgs = callScCmn(param, handle, template, mapper);

		return resultHash;
	}

	// IT2-2014-0000129 対応 藤田 2014/2/21 DEL START
//	/**
//	 * ECK0021A010 お客様＜個人＞一意照会を実行します（カレントを取得）
//	 * <br>
//	 * @param param リクエストパラメータ
//	 * @param handle セッションハンドル
//	 * @param sysid sysid
//	 * @param resultHash 照会結果
//	 * @throws Throwable 任意の例外
//	 */
//	private CAANMsg[] callECK0021A010SC(
//			IRequestParameterReadWrite param,
//			SessionHandle handle,
//			String sysid
//	) throws Throwable
//	{
//		// SIFの実行結果から取得したCAANMsg[]
//		CAANMsg[] resultMsgs = null;
//		// テンプレート情報部（入力時の情報）
//		CAANMsg template = null;
//
//		// ECK0021A010への呼び出しパラメータ設定
//		template = new CAANMsg(ECK0021A010CBSMsg.class.getName());
//		JKKSIFECK0021Mapper mapper = new JKKSIFECK0021Mapper();
//		template = mapper.getMappedTemplateECK0021A010(sysid);
////		mapper.editTemplateCommon(param, template);
//		
//		// SIF実行
//		resultMsgs = callScCmn(param, handle, template, mapper);
//
//		// 結果を設定
////		HashMap<String, Object> resultHash = mappingCAANOutMsgOne(ECK0021A010CBSMsg.ECK0021A010CBSMSG1LIST, resultMsgs);
//
//		return resultMsgs;
//	}
//
//	/**
//	 * ECK0021A010 お客様＜法人＞一意照会を実行します（カレントを取得）
//	 * <br/>
//	 * 
//	 * @param param リクエストパラメータ
//	 * @param handle セッションハンドル
//	 * @param sysid sysid
//	 * @param resultHash 照会結果
//	 * @throws Throwable 任意の例外
//	 */
//	private CAANMsg[] callECK0031A010SC(
//			IRequestParameterReadWrite param,
//			SessionHandle handle,
//			String sysid
//	) throws Throwable
//	{
//		// SIFの実行結果から取得したCAANMsg[]
//		CAANMsg[] resultMsgs = null;
//		// テンプレート情報部（入力時の情報）
//		CAANMsg template = null;
//
//		// ECK0031A010への呼び出しパラメータ設定
//		JKKSIFECK0031Mapper mapper = new JKKSIFECK0031Mapper();
//		template = mapper.getMappedTemplateECK0031A010(sysid);
////		mapper.editTemplateCommon(param, template);
//		
//		// SIF実行
//		resultMsgs = callScCmn(param, handle, template, mapper);
//
////		// 結果を設定
////		HashMap<String, Object> resultHash = mappingCAANOutMsgOne(ECK0031A010CBSMsg.ECK0031A010CBSMSG1LIST, resultMsgs);
//
//		return resultMsgs;
//	}
	// IT2-2014-0000129 対応 藤田 2014/2/21 DEL END

	/**
	 * EKK0021C060 申込明細照査・後続業務取消S-IFを呼び出します
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param workMap 作業領域
	 * @throws Throwable 任意の例外
	 */
	private void callEKK0021C060SC(SessionHandle handle, IRequestParameterReadWrite param, Map<String, Object> workMap) throws Throwable
	{
		//入力データ
		String mskmDtlNo = (String) workMap.get(MSKM_DTL_NO);
		// IT2-2014-0000129 対応 藤田 2014/2/21 MOD START
//		String idoDiv    = JKKStrConst.CD00576_CNCL;
		String idoDiv    = (String) workMap.get(IDO_DIV);
		// IT2-2014-0000129 対応 藤田 2014/2/21 MOD END
		String updDtmBf  = (String) workMap.get(KK0011_UPD_DTM);
		
		if (!JKKStringUtil.isNullBlank(mskmDtlNo))
		{
			// EKK0081C160呼び出し用マップ設定
			JKKSIFEKK0021Mapper mapper = new JKKSIFEKK0021Mapper();
			CAANMsg template = mapper.getMappedTemplateEKK0021C060(idoDiv, mskmDtlNo, null, updDtmBf);
//			mapper.editTemplateCommon(param, template);
			
			// SIF実行
			CAANMsg[] resultMsgs = callScCmn(param, handle, template, mapper);
			
			//出力結果を取得
			CAANMsg ekk0021c060OutMsg = resultMsgs[0];
		}
	}

	
	/**
	 * EKK0081C160 サービス契約キャンセルS-IFを呼び出します
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param workMap 作業領域
	 * @throws Throwable 任意の例外
	 */
	private void callEKK0081C160SC(SessionHandle handle, IRequestParameterReadWrite param, Map<String, Object> workMap) throws Throwable
	{
		//入力データ
		String funcCode  = (String) this.soapRenkeiMap.get(IN_FUNC_CODE);
		String svcKeiNo  = (String) this.soapRenkeiMap.get(SVC_KEI_NO);
		String mskmDtlNo = (String) workMap.get(MSKM_DTL_NO);
		String svcClYmd  = (String) this.soapRenkeiMap.get(IN_SVC_CL_YMD);
		String dlreCd    = (String) this.soapRenkeiMap.get(IN_CL_RSN_CD);
		String idoDiv    = JKKStrConst.CD00576_CNCL;
		String updDtmBf  = (String) workMap.get(KK0081_UPD_DTM);
		
		// EKK0081C160呼び出し用マップ設定
		JKKSIFEKK0081Mapper mapper = new JKKSIFEKK0081Mapper();
		CAANMsg template = mapper.getMappedTemplateEKK0081C160(funcCode, svcKeiNo, mskmDtlNo, svcClYmd, dlreCd, idoDiv, updDtmBf);
//		mapper.editTemplateCommon(param, template);
		
		// SIF実行
		CAANMsg[] resultMsgs = callScCmn(param, handle, template, mapper);
		
		//出力結果を取得
		CAANMsg ekk0081c160OutMsg = resultMsgs[0];
		
		//更新日時
		String updDtm = ekk0081c160OutMsg.getString(EKK0081C160CBSMsg.UPD_DTM);
		workMap.put(KK0081_UPD_DTM, updDtm);
	}
	
	
	/**
	 * EKK0011D020 申込内容承認登録S-IFを実行します
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText I/Oマップのキー
	 * @param mskmSbtCd 申込種別コード
	 * @throws Throwable 任意の例外
	 */
	private void callEKK0011D020SC(SessionHandle handle, IRequestParameterReadWrite param, Map<String, Object> workMap,
			String mskmSbtCd) throws Throwable
	{
		//入力データ
		String funcCode  = (String) this.soapRenkeiMap.get(IN_FUNC_CODE);
		String sysid        = this.currentSysid;
		String mskmUkDtm    = (String) workMap.get(IDO_DTM);
		
		if (null != sysid && 0 < sysid.length())
		{
			// EKK0011D020への呼び出しパラメータ設定
			JKKSIFEKK0011Mapper mapper = new JKKSIFEKK0011Mapper();
			CAANMsg template = mapper.getMappedTemplateEKK0011D020(param, funcCode, mskmSbtCd, sysid, null, null, mskmUkDtm);
	//		mapper.editTemplateCommon(param, template);
			
			// SIF実行
			CAANMsg[] resultMsgs = callScCmn(param, handle, template, mapper);
			
			//出力結果を取得
			CAANMsg ekk0011d020OutMsg = resultMsgs[0];
			CAANMsg[] kk0021Msg = ekk0011d020OutMsg.getCAANMsgList(EKK0011D020CBSMsg.EKK0011D020CBSMSG1LIST);
			
			//申込番号
			String mskmNo = ekk0011d020OutMsg.getString(EKK0011D020CBSMsg.MSKM_NO);
			workMap.put(MSKM_NO, mskmNo);
			
			//更新日時（申込）
			String kk0011UpdDtm = ekk0011d020OutMsg.getString(EKK0011D020CBSMsg.UPD_DTM);
			workMap.put(KK0011_UPD_DTM, kk0011UpdDtm);
			
			//申込明細番号
			String mskmDtlNo = kk0021Msg[0].getString(EKK0011D020CBSMsg1List.MSKM_DTL_NO);
			workMap.put(MSKM_DTL_NO, mskmDtlNo);
			this.svcKeiMap.put("mskm_dtl_no", mskmDtlNo);
		}
	}
	
	
	/**
	 * EKK0081C180 サービス契約解約S-IFを呼び出します
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param workMap 作業領域
	 * @throws Throwable 任意の例外
	 */
	private void callEKK0081C180SC(
			SessionHandle handle, IRequestParameterReadWrite param, Map<String, Object> workMap) throws Throwable
	{
		//入力データ
		String funcCode  = (String) this.soapRenkeiMap.get(IN_FUNC_CODE);
		String svcKeiNo  = (String) this.soapRenkeiMap.get(SVC_KEI_NO);
		String mskmDtlNo = (String) workMap.get(MSKM_DTL_NO);
		String svcEndYmd = (String) this.soapRenkeiMap.get(IN_SVC_ENDYMD);
		String svcChrgEndYmd = (String) this.soapRenkeiMap.get(IN_SVC_CHRG_ENDYMD);
		String dlreCd    = (String) this.soapRenkeiMap.get(IN_SVC_DLRE_CD);
		String dlreMemo  = (String) this.soapRenkeiMap.get(IN_SVC_DLRE_MEMO);
		String idoDiv    = JKKStrConst.CD00576_DSL;
		String updDtmBf  = (String) workMap.get(KK0081_UPD_DTM);
		String rsvAplyKiboYmd = svcEndYmd;
		// ++++++ v19.00.00【OM-2015-0002492】修正 開始 +++++++++
		//String svcDslYmd = (String) this.soapRenkeiMap.get(IN_SVC_DSL_YMD);		//2014/01/17追加
		String svcDslYmd = this.oPE_DATE;	
		// ++++++ v19.00.00【OM-2015-0002492】修正 終了 +++++++++
		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 ADD START
		// 請求オプション対応と合わせて修正。違約金発生コードは例外のお客様を除いて基本的には"1"を指定するのが正。
		// 実際の違約金発生に関しては料金側の計算に委ねる。
		String pnltyHasseiCd = "1";
		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 ADD END
		
		// EKK0081C180呼び出し用マップ設定
		JKKSIFEKK0081Mapper mapper = new JKKSIFEKK0081Mapper();
		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 MOD START
		CAANMsg template = mapper.getMappedTemplateEKK0081C180(
				  funcCode, svcKeiNo, mskmDtlNo, rsvAplyKiboYmd
				, svcEndYmd, svcChrgEndYmd, dlreCd, dlreMemo
				, pnltyHasseiCd, idoDiv, updDtmBf, svcDslYmd
			);
		// IT1-2014-0000098 請求オプション対応 2014/03/19 藤田 MOD END
//		mapper.editTemplateCommon(param, template);
		
		// SIF実行
		CAANMsg[] resultMsgs = callScCmn(param, handle, template, mapper);
		
		//出力結果を取得
		CAANMsg ekk0081c180OutMsg = resultMsgs[0];
		
		//更新日時
		String updDtm = ekk0081c180OutMsg.getString(EKK0081C180CBSMsg.UPD_DTM);
		workMap.put(KK0081_UPD_DTM, updDtm);
	}


	/**
	 * EKK0081C260 サービス契約解約確定S-IFを呼び出します
	 * 
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param workMap 作業領域
	 * @throws Throwable 任意の例外
	 */
	private void callEKK0081C260SC(
			SessionHandle handle, IRequestParameterReadWrite param, Map<String, Object> workMap) throws Throwable
	{
		//入力データ
		String funcCode  = (String) this.soapRenkeiMap.get(IN_FUNC_CODE);
		String svcKeiNo  = (String) this.soapRenkeiMap.get(SVC_KEI_NO);
		String svcEndYmd = (String) this.soapRenkeiMap.get(IN_SVC_ENDYMD);
		String svcChrgEndYmd = (String) this.soapRenkeiMap.get(IN_SVC_CHRG_ENDYMD);
		String dlreCd    = (String) this.soapRenkeiMap.get(IN_SVC_DLRE_CD);
		String dlreMemo  = (String) this.soapRenkeiMap.get(IN_SVC_DLRE_MEMO);
		String updDtmBf  = (String) workMap.get(KK0081_UPD_DTM);
		// ++++++ v19.00.00【OM-2015-0002492】修正 開始 +++++++++
		//String svcDslYmd = (String) this.soapRenkeiMap.get(IN_SVC_DSL_YMD);		//2014/01/17追加
		String svcDslYmd = this.oPE_DATE;
		// ++++++ v19.00.00【OM-2015-0002492】修正 完了 +++++++++
		
		//解約起算日＝サービス課金終了日＋１
		String dslKisanYmd = JCCDateUtil.addDay(svcChrgEndYmd, 1);
		
//		//当日の場合、確定を行う
//		if (this.oPE_DATE.compareTo(svcEndYmd) == 0)
		{
			// EKK0081C160呼び出し用マップ設定
			JKKSIFEKK0081Mapper mapper = new JKKSIFEKK0081Mapper();
			CAANMsg template = mapper.getMappedTemplateEKK0081C260(funcCode, svcKeiNo, svcEndYmd, svcChrgEndYmd, dslKisanYmd, dlreCd, dlreMemo, updDtmBf, svcDslYmd);
	//		mapper.editTemplateCommon(param, template);
			
			// SIF実行
			CAANMsg[] resultMsgs = callScCmn(param, handle, template, mapper);
			
			//出力結果を取得
			CAANMsg ekk0081c260OutMsg = resultMsgs[0];
			
			//更新日時
			String updDtm = ekk0081c260OutMsg.getString(EKK0081C260CBSMsg.UPD_DTM);
			workMap.put(KK0081_UPD_DTM, updDtm);
		}
	}



	 
	/**
	 * 
	 * @param param
	 * @param handle
	 * @param template
	 * @return
	 * @throws Throwable
	 */
	private CAANMsg[] callScCmn(
			IRequestParameterReadWrite param,
			SessionHandle handle,
			CAANMsg template,
			JKKSIFMapperBase mapper
	) throws Throwable
	{
		HashMap<String, Object> sIFRequest = null;
		CAANMsg[] resultMsgs = null;
		Map<?, ?> sIFResult = null;

		//テンプレート共通情報を設定
		mapper.editTemplateCommon(param, template);
		
		// サービスIF共通の情報を設定
		sIFRequest = mapper.editInMsgCmn(param);

		// リクエスト用クラスの設定
		sIFRequest.put(JCMConstants.TEMPLATE_LIST_KEY, new CAANMsg[]{template});

		// SIFの呼び出し
		sIFResult = (new ServiceComponentRequestInvoker()).run(sIFRequest, handle);

		// 結果の取得
		resultMsgs = (CAANMsg[])sIFResult.get(JCMConstants.TEMPLATE_LIST_KEY);

		// エラー情報のマッピング
		editResultRP(sIFResult, param);

		errChk(sIFResult);

		// リターンコード取得
		int returnCode = (Integer)sIFResult.get(JCMConstants.RET_CD_INT_KEY);
		if (returnCode != 0) {
			throw new Exception();
		}

		return resultMsgs;
	}

	// ANK-3315-00-00 ADD START
	/**
	 * CAANMsg[]の結果をHashとして抽出する（一覧照会用）
	 * @param workMapKey テンプレートリストのマップキー
	 * @param resultMsgs テンプレートリスト
	 * @return サービスＩＦ実行の結果部分(ArrayListのハッシュマップ)
	 */
	private ArrayList<HashMap<String, Object>> mappingCAANOutMsg(String workMapKey,CAANMsg[] resultMsgs)
	{
		ArrayList<HashMap<String, Object>> retHashList = null;
		CAANMsg[] msgs = null;

		// 結果の抽出
		retHashList = new ArrayList<HashMap<String, Object>>();
		msgs = resultMsgs[0].getCAANMsgList(workMapKey);

		if(msgs != null)
		{
			for(int i = 0 ; i < msgs.length ; i++)
			{
				retHashList.add(msgs[i].getMsgData());
			}
		}

		return retHashList;
	}
	// ANK-3315-00-00 ADD END
	
	/**
	 * CAANMsg[]の結果をHashとして抽出する（一意照会用）
	 * @param workMapKey テンプレートリストのマップキー
	 * @param resultMsgs テンプレートリスト
	 * @return EKK0081A010SCの結果部分
	 */
	private HashMap<String, Object> mappingCAANOutMsgOne(String workMapKey,CAANMsg[] resultMsgs)
	{
		HashMap<String, Object> retHash = null;
		CAANMsg msg = null;

		// 結果の抽出
//		msg = resultMsgs[0].getCAANMsgList(workMapKey)[0];
		CAANMsg[] msgs = resultMsgs[0].getCAANMsgList(workMapKey);
		if (null != msgs && 0 < msgs.length)
		{
			msg = msgs[0];
		}

		if(msg != null)
		{
			retHash = msg.getMsgData();
		}

		return retHash;
	}

	/**
	 * <pre>
	 * サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 * 
	 * </pre>
	 * @param msgList CAANMsgクラス
	 * @param param 業務データ取得・書込用I/F
	 * @param fixedText ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2012-08-27 ST1-2012-0000418対応のついで（業務結果とFW処理結果の格納の切り分け）
	 */
	private IRequestParameterReadWrite editResultRP(
			Map<?, ?> msgList,
			IRequestParameterReadWrite param) 
			throws Throwable 
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		// リターンコード取得
		Integer returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);

		// テンプレートID、ステータス取得
		int templateStatus = template.getInt(JCMConstants.STATUS_INT_KEY);
		
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_"
				+ String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			// MVNOの外部ＩＦの使用上、単項目関連チェック(1050)は返さないことになっているため、単項目チェック(1000)エラーとして返す
			if ("1050".equals(formatStatus)) {
				formatStatus = "1000";
				JSYejbLog.println(JSYejbLog.DEBUG,this.getClass(),"MVNO対応：リターンコード置換え(単項目関連チェック：1050 -> 単項目チェック：1000)");
			}
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_"
					+ formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		String tName = template.getString("templateID");		//S-IF名
		
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// ユーザデータ情報にエラー情報をマッピング
		Map<String, Object> contentsMap = template.getMsgData();
		Object[] contents = contentsMap.keySet().toArray();
		for(int i = 0 ; contents != null && i < contents.length ; i++)
		{
			String element = null;
			element = (String)contents[i];
			if (element.indexOf("_err") > 0)
			{
				if (!template.isNull(element))
				{
					//‘key_’を除く
					String e = element.replaceFirst("key_", "");
					if ("EKK2821C010".equals(tName) && e.equals(EKK2821C010CBSMsg.SHOSA_YMD_I_ERR))
					{
						e = EKK2821C010CBSMsg.SHOSA_YMD + "_err";
					}
					if ("EKK0081C160".equals(tName) && e.equals(EKK0081C160CBSMsg.SVC_CANCEL_YMD_I_ERR))
					{
						e = IN_SVC_CL_YMD + "_err";
					}
					if ("EKK0081C260".equals(tName) && e.equals(EKK0081C260CBSMsg.SVC_DSL_YMD_I_ERR))
					{
						e = IN_SVC_DSL_YMD + "_err";
					}
					
					// ANK-3315-00-00 ADD START
					if ("EKK0071D010".equals(tName) && e.equals(EKK0071D010CBSMsg.AGNT_CD_ERR))
					{
						String dspJun = (String)template.getString(EKK0071D010CBSMsg.DSP_JUN);
						String errCd = template.getString(element);
						if (DSP_JUN_1.equals(dspJun))
						{
							e = TRAT_CD_1_1 + ERRITEM_SUFFIX;
						}
						else if (DSP_JUN_2.equals(dspJun))
						{
							e = TRAT_CD_1_2 + ERRITEM_SUFFIX;
						}
						else if (DSP_JUN_3.equals(dspJun))
						{
							e = TRAT_CD_2_1 + ERRITEM_SUFFIX;
						}
						else if (DSP_JUN_4.equals(dspJun))
						{
							e = TRAT_CD_2_2 + ERRITEM_SUFFIX;
						}
						
						// 代理店存在チェック
						if (ERR_EA.equals(errCd))
						{
							// エラーフラグのセット
							soapRenkeiMap.put(e, ERR_EB);
							continue;
						}
						// 代理店有効チェック
						else if (ERR_EB.equals(errCd))
						{
							// エラーフラグのセット
							soapRenkeiMap.put(e, ERR_EC);
							continue;
						}
					}
					// ANK-3315-00-00 ADD END
					// エラーフラグのセット
					soapRenkeiMap.put(e, template.getString(element));
				}
			}
		}

		return param;
	}

	/**
	 * エラーチェック処理です。
	 * <br>
	 * @param msgList サービスインタフェース実行結果
	 * @return void
	 * @throws Exception 
	 * @since 2012-08-27 ST1-2012-0000418対応のついで（業務結果とFW処理結果の格納の切り分け）
	 */
	private void errChk(Map<?, ?> msgList) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		// リターンコード取得
		Integer returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// ステータス取得
		int templateStatus = template.getInt(JCMConstants.STATUS_INT_KEY);
		
		if ((0 != returnCode.intValue()) || (0 != templateStatus))
		{
			String errMsg = ERR_MSG;
			throw new SCCallException(errMsg, String.valueOf(returnCode), templateStatus);
		}
	}

	// IT2-2014-0000129 対応 藤田 2014/2/21 DEL START
//	/**
//	 *<DL>
//	 *<DT>処理概要:指示書登録
//	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
//	 *<DT>入力パラメータ説明:
//	 *<DD>特になし
//	 *<DT>入力パラメータ説明：
//	 *<DD>特になし
//	 *<DT>出力パラメータ説明:
//	 *<DD>特になし
//	 *</DL>
//	 * @param msgList 実行結果マップリスト
//	 * @param param 業務データ取得・書込用I/F
//	 * @return エラー情報
//	 * @throws Exception
//	 * @since 2011.06.07
//	 */
//	public ArrayList<Object> editResultRPECK0011C120(Map<?, ?> msgList, IRequestParameterReadWrite param)
//	throws Exception
//	{
//		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
//		CAANMsg template = templates[0];
//
//		// リターンコード取得
//		Integer returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
//
//		int templateStatus = template.getInt(ECK0011C120CBSMsg.STATUS);
//		if (returnCode.intValue() != 0)
//		{
//			templateStatus = 9000;
//		}
//		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
//		{
//			templateStatus = 0;
//		}
//		
//		int bpStatus = 0;
//		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		if (obj == null)
//		{
//			bpStatus = -1;
//		} 
//		else
//		{
//			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
//		}
//
//		if (templateStatus > bpStatus) 
//		{
//			// BPにサービスコンポーネントのステータスを設定する。
//			String formatStatus = String.format("%1$04d", templateStatus);
//			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
//			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
//			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
//		}
//		
////		HashMap inMap = null;
////		
////		/* ユーザデータ情報 */
////		inMap = (HashMap)param.getData(JKKSvkeiShosaConstCC.TRGT_DATA);
////
////		// SYSIDエラー
////		if (!template.isNull(ECK0011C120CBSMsg.SYSID_ERR))
////		{
////			if (!inMap.containsKey("sysid_err")) 
////			{
////				inMap.put("sysid_err", template.getString(ECK0011C120CBSMsg.SYSID_ERR));
////			}
////		}
////		
////		// 会員種別コードエラー
////		if (!template.isNull(ECK0011C120CBSMsg.MEMBER_SBT_CD_ERR)) 
////		{
////			if (!inMap.containsKey("member_sbt_cd_err")) 
////			{
////				inMap.put("member_sbt_cd_err", template.getString(ECK0011C120CBSMsg.MEMBER_SBT_CD_ERR));
////			}
////		}
////		
////		// 更新年月日時分秒(更新前)エラー
////		if (!template.isNull(ECK0011C120CBSMsg.UPD_DTM_BF_ERR)) 
////		{
////			if (!inMap.containsKey("upd_dtm_bf_err")) 
////			{
////				inMap.put("upd_dtm_bf_err", template.getString(ECK0011C120CBSMsg.UPD_DTM_BF_ERR));
////			}
////		}
//		
//		// コントロールマップに設定
//		ArrayList<Object> errorList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
//		errorList = (errorList == null ? new ArrayList<Object>() : errorList);
//		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errorList));
//		
//		// エラー発生時はExceptionを設定
//		if (errorList != null && !errorList.isEmpty())
//		{
//			throw new SCCallException("", ((Integer)returnCode).toString(), templates[0].getInt(ECK0011C120CBSMsg.STATUS));
//		}
//
//		return errorList;
//	}
	
//	/**
//	 * 	
//	 * @param msgList
//	 * @param param
//	 * @return
//	 * @throws Exception
//	 */
//	public ArrayList<Object> editResultRPECK0111D010(Map<?, ?> msgList, IRequestParameterReadWrite param)
//			throws Exception
//	{
//		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
//		CAANMsg template = templates[0];
////		CAANMsg[] templateArray = null;
//
//		// リターンコード取得
//		Integer returnCode = (Integer)msgList.get(JCMConstants.RET_CD_INT_KEY);
//
//		int templateStatus = template.getInt(ECK0111D010CBSMsg.STATUS);
//		if (returnCode.intValue() != 0)
//		{
//			templateStatus = 9000;
//		}
//		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
//		{
//			templateStatus = 0;
//		}
//
//		int bpStatus = 0;
//		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		if (obj == null)
//		{
//			bpStatus = -1;
//		}
//		else
//		{
//			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
//		}
//
//		if (templateStatus > bpStatus)
//		{
//			// BPにサービスコンポーネントのステータスを設定する。
//			String formatStatus = String.format("%1$04d", templateStatus);
//			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
//			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
//			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
//		}
//
////		HashMap inMap = null;
////		ArrayList inList = null;
////		
////		/* ユーザデータ情報 */
////		inMap = (HashMap)param.getData(JKKSvkeiShosaConstCC.TRGT_DATA);
////
////		// グループ種別コードエラー
////		if (!template.isNull(ECK0111D010CBSMsg.GRP_SBT_CD_ERR))
////		{
////			if (!inMap.containsKey("grp_sbt_cd_err"))
////			{
////				inMap.put("grp_sbt_cd_err", template.getString(ECK0111D010CBSMsg.GRP_SBT_CD_ERR));
////			}
////		}
////		// グループ名エラー
////		if (!template.isNull(ECK0111D010CBSMsg.GRP_NM_ERR))
////		{
////			if (!inMap.containsKey("grp_nm_err"))
////			{
////				inMap.put("grp_nm_err", template.getString(ECK0111D010CBSMsg.GRP_NM_ERR));
////			}
////		}
////		// グループリーダーSYSID
////		if (!template.isNull(ECK0111D010CBSMsg.GRP_LEADER_SYSID_ERR))
////		{
////			if (!inMap.containsKey("grp_leader_sysid_err"))
////			{
////				inMap.put("grp_leader_sysid_err", template.getString(ECK0111D010CBSMsg.GRP_LEADER_SYSID_ERR));
////			}
////		}
////		// グループ適用開始年月日
////		if (!template.isNull(ECK0111D010CBSMsg.GRP_TSTAYMD_ERR))
////		{
////			if (!inMap.containsKey("grp_tstaymd_err"))
////			{
////				inMap.put("grp_tstaymd_err", template.getString(ECK0111D010CBSMsg.GRP_TSTAYMD_ERR));
////			}
////		}
////		// グループ適用終了年月日
////		if (!template.isNull(ECK0111D010CBSMsg.GRP_TENDYMD_ERR))
////		{
////			if (!inMap.containsKey("grp_tendymd_err"))
////			{
////				inMap.put("grp_tendymd_err", template.getString(ECK0111D010CBSMsg.GRP_TENDYMD_ERR));
////			}
////		}
////		
////		inList = (ArrayList)inMap.get("ECK0111D010CBSMsg1List");
////		if (inList == null) {
////			inList = new ArrayList();
////			inMap.put("ECK0111D010CBSMsg1List", inList);
////		}
////
////		templateArray = template.getCAANMsgList(ECK0111D010CBSMsg.ECK0111D010CBSMSG1LIST);
////
////		if (templateArray != null) {
////			for (int i = 0; i < templateArray.length; i++) {
////				if (i >= inList.size()) {
////					inList.add(new HashMap());
////				}
////			
////				HashMap childMap = (HashMap)inList.get(i);
////				CAANMsg childTemplate = templateArray[i];
////
////				// グループ登録マップ.お客様グループ設定明細.SYSID → お客様グループ設定明細.SYSID のエラー情報返却
////				if (!childTemplate.isNull(ECK0111D010CBSMsg1List.SYSID_ERR)) {
////					if (!childMap.containsKey("sysid_err")) {
////						childMap.put("sysid_err", childTemplate.getString(ECK0111D010CBSMsg1List.SYSID_ERR));
////					}
////				}
////				// グループ登録マップ.お客様グループ設定明細.グループ割引適用承認年月日 → お客様グループ設定明細.グループ割引適用承認年月日 のエラー情報返却
////				if (!childTemplate.isNull(ECK0111D010CBSMsg1List.GRP_WRIB_APLY_SHONIN_YMD_ERR)) {
////					if (!childMap.containsKey("grp_wrib_aply_shonin_ymd_err")) {
////						childMap.put("grp_wrib_aply_shonin_ymd_err", childTemplate.getString(ECK0111D010CBSMsg1List.GRP_WRIB_APLY_SHONIN_YMD_ERR));
////					}
////				}
////			}
////		}
////		if (!template.isNull(ECK0111D010CBSMsg.ECK0111D010CBSMSG1LIST_ERR)) {
////			if (!inMap.containsKey("ECK0111D010CBSMsg1List_err")) {
////				inMap.put("ECK0111D010CBSMsg1List_err", template.getString(ECK0111D010CBSMsg.ECK0111D010CBSMSG1LIST_ERR));
////			}
////		}
////		
////		// 更新年月日時分秒（更新前）エラー
////		if (!template.isNull(ECK0111D010CBSMsg.UPD_DTM_BF_ERR))
////		{
////			if (!inMap.containsKey("upd_dtm_bf_err"))
////			{
////				inMap.put("upd_dtm_bf_err", template.getString(ECK0111D010CBSMsg.UPD_DTM_BF_ERR));
////			}
////		}
//
//		// コントロールマップに設定
//		ArrayList<Object> errorList = new ArrayList<Object>();
//		TemplateErrorUtil.getErrorInfo(msgList, errorList);
//
//		return errorList;
//	}
	
//	/**
//	 * 処理結果を示すリターンコードを下りマップにセットします
//	 * 
//	 * @param param リクエストパラメータ一式
//	 * @param statusCode
//	 * @throws Exception
//	 */
//	private void setReturnCode(IRequestParameterReadWrite param, int statusCode) throws Exception
//	{
//		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(skbtCd);
//		dataMap.put(RETURN_CODE, String.valueOf(statusCode));
//	}
	// IT2-2014-0000129 対応 藤田 2014/2/21 DEL END

}
