/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom						 *
**********************************************************************
*＜プログラム内容＞
*	システム名		：eo顧客基幹システム
*	モジュール名	：JKKKikiIchiranKkKaifukuCC
*	ソースファイル名：JKKKikiIchiranKkKaifukuCC.java
*	作成者			：FAP)古田
*	日付			：2013年12月02日
*＜機能概要＞
*	機器提供サービス契約回復処理の共通コンポーネント
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v7.00.00	2013/12/02	FJ			新規作成
*	v8.00.00	2014/05/26	FJ) 田原	【OM-2014-0001508】
*	v10.00.00	2014/10/28	FJ)徳永		【OM-2014-0003381】障害対応
*	v33.00.00	2017/07/07	FJ)謝		【ANK-2979-00-00】(客B)多機能ルーターキャンセル後の元ルーター回復
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;

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.IRequestParameterReadWrite;
import com.fujitsu.futurity.bp.x21.cc.AbstractCommonComponent;
import com.fujitsu.futurity.bp.x21.cc.exception.SCCallException;
import com.fujitsu.futurity.common.JCMConstants;
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.common.JCMAPLConstMgr;

import eo.ejb.cbs.cbsmsg.EDK0301C040CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0161B004CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0161B004CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0251A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0251A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0251B003CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0251B003CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341C230CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C380CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C390CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C410CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C420CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1081B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1081C011CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1081D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1551D010CBSMsg;


/**
 * 機器提供サービス契約回復呼出処理を行います。<p>
 * <BR>
 * @author 富士通
 */
/**
 * @author 909994
 *
 */
public class JKKKikiIchiranKkKaifukuCC extends AbstractCommonComponent
{
	
	/** 機能コード（チェック＆登録） */
	private static final String FUNC_CODE_1 = "1";
	/** サービス契約一意照会 */
	private static final String TEMPLATE_ID_EKK0081A010 = "EKK0081A010";
	/** 機器提供サービス契約一意照会 */
	private static final String TEMPLATE_ID_EKK0341A010 = "EKK0341A010";
	/** 機器提供サービス契約回復 */
	private static final String TEMPLATE_ID_EKK0341C380 = "EKK0341C380";
	/** サービス提供前機器提供サービス契約回復 */
	private static final String TEMPLATE_ID_EKK0341C390 = "EKK0341C390";
	/** 照査後機器提供サービス契約キャンセル取消 */
	private static final String TEMPLATE_ID_EKK0341C420 = "EKK0341C420";
	/** 照査前機器提供サービス契約キャンセル取消 */
	private static final String TEMPLATE_ID_EKK0341C410 = "EKK0341C410";
	/** 返品機器取消 */
	private static final String TEMPLATE_ID_EDK0301C040 = "EDK0301C040";
	/** 進捗登録 */
	private static final String TEMPLATE_ID_EKK1091D010 = "EKK1091D010";
	/** サービス契約回線内訳一覧照会（現在利用中） */
	private static final String TEMPLATE_ID_EKK0251B003 = "EKK0251B003";
	/** 機器提供サービス契約情報変更 */
	private static final String TEMPLATE_ID_EKK0341C230 = "EKK0341C230";
	// ++++++++++ v10.00.00 追加開始 ++++++++++ //
	/** サービス契約内訳一覧照会 */
	private static final String TEMPLATE_ID_EKK0161B004 = "EKK0161B004";
	/** オーダ発行条件登録 */
	private static final String TEMPLATE_ID_EKK1081D010 = "EKK1081D010";
	/** 同一処理番号採番 */
	private static final String TEMPLATE_ID_EKK1081C011 = "EKK1081C011";
	/** オーダ情報作成ワーク登録 */
	private static final String TEMPLATE_ID_EKK1551D010 = "EKK1551D010";
	/** サービス契約回線内訳一意照会 */
	private static final String TEMPLATE_ID_EKK0251A010 = "EKK0251A010";
	/** オーダ発行条件一覧照会 */
	private static final String TEMPLATE_ID_EKK1081B001 = "EKK1081B001";
	
	// ++++++++++ v10.00.00 追加終了 ++++++++++ //
	
	/** 更新タイムスタンプ格納キー */
	private static final String KK_COM_SVC_UP_DTM = "KK_COM_SVC_UP_DTM";
	/** 進捗情報出力判定情報保持  */
	private static final String KKW03301_PRG_WORK = "KKW03301_PRG_WORK";
	/** 異動登録時の更新タイムスタンプ格納キー */
	private static final String KK_COM_IDO_UP_DTM = "KK_COM_IDO_UP_DTM";
	/** 機器提供サービス契約一意照会（更新後データ） */
	private static final String TEMPLATE_ID_EKK0341A010_AF = "EKK0341A010_AF";
	
	/** 処理対象リスト格納キー */
	private static final String SHORI_LIST_ICHIRAN = "IchiranShoriList";
	/** 更新後リスト（処理対象リスト）格納キー */
	private static final String SHORI_LIST_KIKILIST_AF = "kikiList_af";
	
	/** 進捗ステータス 機器回復完了 */
	private static final String PRG_STAT_3D00 = "3D00";

	/** エラーフラグ（エラー）*/
	private static final String ERR_FLG_ERR = "E";
	/** エラーフラグ（ワーニング）*/
	private static final String ERR_FLG_WARNING = "W";
	
	// ++++++++++ v10.00.00 追加開始 ++++++++++ //
	/** 機能コード（チェックのみ） */
	private static final String FUNC_CODE_2 = "2";
	/** サービス契約内訳ステータス（受付済） */
	private static final String SVC_KEI_UCWK_STAT_UKEZUMI = "010";
	/** サービス契約内訳ステータス（解約） */
	private static final String SVC_KEI_UCWK_STAT_DSL = "910";
	/** サービス契約内訳ステータス（キャンセル） */
	private static final String SVC_KEI_UCWK_STAT_CANCEL = "920";
	
	/** オーダ種別コード (ネット) */
	private static final String ORDER_SBT_CD_1 = "1";
	/** サービスオーダコード（ルーター向け接続情報） */
	private static final String SVC_ORDER_CD_0A = "0A";
	/** 要求種別コード（新規） */
	private static final String YOKYU_SBT_CD_02 = "02";
	/** 要求種別コード（変更） */
	private static final String YOKYU_SBT_CD_04 = "04";
	/** オーダ内容コード（ルーター向け接続情報・変更） */
	private static final String ODR_NAIYO_CD_163 = "163";
	/** オーダ発行条件コード（即時発行） */
	private static final String ODR_HAKKO_JOKEN_CD_01 = "01";
	
	/** 宅内機器種別コード（ルーター） */
	private static final String TAKNKIKI_SBT_CD_F0 = "F0";
	// ++++++++++ v10.00.00 追加終了 ++++++++++ //
// ANK-2979-00-00 ADD START
	/** 回復対象（回復） */
	private static final String KIKI_KAIFUKU_TAISHO_KAIFUKU = "1";
// ANK-2979-00-00 ADD END

	/**
	 * 
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite execKikiIchiranKikiKaifuku(SessionHandle handle, IRequestParameterReadWrite param, 
																	String fixedText) throws Throwable
	{
		String dataMapKey = fixedText;
		
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);

		// エラーフラグ
		ccMsg.put("err_flg", "");
		
		// メッセージ情報
		ArrayList<HashMap<String, Object>> messageInfo = new ArrayList<HashMap<String, Object>>();
		
		// メッセージコードリスト
		ccMsg.put("message_list", messageInfo);
		
		// 一時領域データ
		HashMap<String, Object> temporaryData = new HashMap<String, Object>();
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// サービス契約データが存在しない場合取得します。
		CAANMsg ekk0081a010cbsMsg = (CAANMsg)ccMsg.get("svc_kei_data");
		
		if(ekk0081a010cbsMsg == null)
		{
			// ***** EKK0081A010（サービス契約一意照会）*****
			Object[][] ekk0081a010IN = {
				{EKK0081A010CBSMsg.TEMPLATEID,       TEMPLATE_ID_EKK0081A010},
				{EKK0081A010CBSMsg.FUNC_CODE,        "2"},
				{EKK0081A010CBSMsg.KEY_SVC_KEI_NO,   (String)ccMsg.get("svc_kei_no")},
				{EKK0081A010CBSMsg.KEY_GENE_ADD_DTM, ""},
				{EKK0081A010CBSMsg.KEY_RSV_APLY_YMD, (String)ccMsg.get("unyo_ymd")},
			};
			
			ekk0081a010cbsMsg = callSC(handle, scCall, param, dataMapKey, ekk0081a010IN).getCAANMsgList(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST)[0];
		}
		
		// 検索結果を格納（サービス契約一意照会）
		temporaryData.put(TEMPLATE_ID_EKK0081A010, ekk0081a010cbsMsg);
		
		// 機器提供サービス契約データが存在しない場合取得します。
		CAANMsg ekk0341a010cbsMsg = (CAANMsg)ccMsg.get("kktk_svc_kei_data");
		
		if(ekk0341a010cbsMsg == null)
		{
			ekk0341a010cbsMsg = execEKK0341A010(handle, scCall, param, dataMapKey, temporaryData, (String)ccMsg.get("kktk_svc_kei_no"));
		}
		
		// 検索結果を格納（機器提供サービス契約一意照会）
		temporaryData.put(TEMPLATE_ID_EKK0341A010, ekk0341a010cbsMsg);
		
		// 機器提供サービス契約回復呼び出し
		execKikiKaifuku(handle, scCall, param, dataMapKey, temporaryData);
		
		// 返品機器取消
		String hmpin_kiki_no = getNullToStr((String)ccMsg.get("hmpin_kiki_no"));
		if(!"".equals(hmpin_kiki_no))
		{
			execEDK0301C040(handle, scCall, param, dataMapKey, temporaryData);
		}
		
		// 回復後データ取得
		ekk0341a010cbsMsg = execEKK0341A010(handle, scCall, param, dataMapKey, temporaryData, (String)ccMsg.get("kktk_svc_kei_no"));
		
		// 回復後データを格納
		ccMsg.put("kktk_svc_kei_data_kaihuku", ekk0341a010cbsMsg);
		
		temporaryData.put(TEMPLATE_ID_EKK0341A010_AF, ekk0341a010cbsMsg);
		
		// ワーク領域に処理データを格納
		if(FUNC_CODE_1.equals(ccMsg.get("func_code")))
		{
			setKikiIchiranIkkatsuList(handle, scCall, param, dataMapKey, temporaryData, ekk0341a010cbsMsg);
			
// ANK-2979-00-00 ADD START
			// ルーター回復対象
			String rtrKaifurkuUmu = getNullToStr((String)ccMsg.get("rtr_khk_um"));
			
			// ルーター回復対象が"1"回復の場合、SOD発行処理は行わない
			if (!KIKI_KAIFUKU_TAISHO_KAIFUKU.equals(rtrKaifurkuUmu))
			{
// ANK-2979-00-00 ADD END
			// ++++++++++ v10.00.00 追加開始 ++++++++++ //
			// 機器提供サービス契約番号取得
			String kktkSvcKeiNo = (String)ccMsg.get("kktk_svc_kei_no");
			
			// 回復機器の宅内機器種別コードを取得
			String taknkikiSbtCd = getNullToStr((String)ekk0341a010cbsMsg.getString(EKK0341A010CBSMsg1List.TAKNKIKI_SBT_CD));
			
			// サービス契約番号を取得
			String svcKeiNo = getNullToStr((String)ekk0341a010cbsMsg.getString(EKK0341A010CBSMsg1List.SVC_KEI_NO));
			
			// 宅内機器種別コードがルーター、且つサービス契約番号が設定されている場合
			if(TAKNKIKI_SBT_CD_F0.equals(taknkikiSbtCd) && !"".equals(svcKeiNo))
			{
				// サービス契約内訳取得
				ArrayList<CAANMsg> svcKeiUcwkList = getSvcKeiUcwkData(handle, scCall, param, dataMapKey, svcKeiNo);
				
				// サービス契約内訳取得結果が存在する場合
				if(svcKeiUcwkList != null && svcKeiUcwkList.size() > 0)
				{
					temporaryData.put(TEMPLATE_ID_EKK0161B004, svcKeiUcwkList.get(0));
					
					// 要求種別：「新規」
					// サービスオーダコード：「ルーター向け接続情報」が既に登録されている場合
					if(isOdrHakkoJoken(handle, scCall, param, fixedText, kktkSvcKeiNo, ORDER_SBT_CD_1, YOKYU_SBT_CD_02, SVC_ORDER_CD_0A))
					{
						// 登録処理：オーダ発行条件、オーダ情報作成ワーク
						execSodHakkoCreate(handle, scCall, param, dataMapKey, temporaryData);
					}
				}
			}
			// ++++++++++ v10.00.00 追加終了 ++++++++++ //
// ANK-2979-00-00 ADD START
			}
// ANK-2979-00-00 ADD END
		}
		
		// 進捗登録
		execShinchokuToroku(handle, scCall, param, dataMapKey, temporaryData, PRG_STAT_3D00);
		
		return param;
	}
	
	/**
	 * 回復処理メソッド
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @return boolean
	 * @throws Throwable 
	 * @throws Exception
	 */
	private void execKikiKaifuku(SessionHandle handle, 
									ServiceComponentRequestInvoker scCall, 
									IRequestParameterReadWrite param, 
									String dataMapKey,
									HashMap<String, Object> temporaryData) throws Throwable
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);
		
		// 機器提供サービス契約
		CAANMsg ekk0341a010Msg = (CAANMsg)temporaryData.get(TEMPLATE_ID_EKK0341A010);
		
		// サービス開始年月日
		String svcStrtYmd = getNullToStr(ekk0341a010Msg.getString(EKK0341A010CBSMsg1List.SVC_STA_YMD));
		// 締結日
		String keiTeiketuYmd = getNullToStr(ekk0341a010Msg.getString(EKK0341A010CBSMsg1List.KEI_CNC_YMD));
		// 照査年月日
		String shosaYmd = getNullToStr(ekk0341a010Msg.getString(EKK0341A010CBSMsg1List.SHOSA_YMD));
		
		if(!"".equals(svcStrtYmd))
		{
			// 機器提供サービス契約回復
			execEKK0341C380(handle, scCall, param, dataMapKey, temporaryData);
		}
		else if(!"".equals(keiTeiketuYmd))
		{
			// サービス提供前機器提供サービス契約回復
			execEKK0341C390(handle, scCall, param, dataMapKey, temporaryData);
			if(FUNC_CODE_1.equals((String)ccMsg.get("func_code")))
			{
				// 住所更新
				isKktkSvcKeiJyushoUpdate(handle, scCall, param, dataMapKey, temporaryData);
			}
		}
		else if(!"".equals(shosaYmd))
		{
			// 照査後機器提供サービス契約キャンセル取消
			execEKK0341C420(handle, scCall, param, dataMapKey, temporaryData);
			if(FUNC_CODE_1.equals((String)ccMsg.get("func_code")))
			{
				// 住所更新
				isKktkSvcKeiJyushoUpdate(handle, scCall, param, dataMapKey, temporaryData);
			}
		}
		else
		{
			// 照査前機器提供サービス契約キャンセル取消
			execEKK0341C410(handle, scCall, param, dataMapKey, temporaryData);
			if(FUNC_CODE_1.equals((String)ccMsg.get("func_code")))
			{
				// 住所更新
				isKktkSvcKeiJyushoUpdate(handle, scCall, param, dataMapKey, temporaryData);
			}
		}
	}
	

	/**
	 * メッセージIDを設定します。
	 * @param ccMsg パラメータMap
	 * @param pMessageId メッセージID
	 * @param pReplaceCha 置換文字列
	 * @param pErrItem エラー設定項目
	 * @param pErrFlg エラーフラグ
	 */
	private void setMessageInfo(HashMap<String, Object> ccMsg, String pMessageId, String pReplaceCha, String pErrItem, String pErrFlg)
	{

		// エラーフラグの設定
		// エラーの場合はそのまま設定。　ワーニングの場合はエラーが設定されていない場合、設定
		String errFlg = (String)ccMsg.get("err_flg");

		if("".equals(errFlg) || ERR_FLG_WARNING.equals(errFlg))
		{
			ccMsg.put("err_flg", pErrFlg);
		}

		HashMap<String, Object> messageMap = new HashMap<String, Object>();
		// メッセージIDを設定
		messageMap.put("messageId", pMessageId);
		// 置換文字列
		messageMap.put("replaceCha", pReplaceCha);
		// エラー設定項目
		messageMap.put("errItem", pErrItem);

		ArrayList<HashMap<String, Object>> messageInfo = (ArrayList<HashMap<String, Object>>)ccMsg.get("message_list");
		messageInfo.add(messageMap);

	}
	
	/**
	 * パラメタがNullの場合空白を返却します。
	 * @param str 文字列
	 * @return str
	 */
	private String getNullToStr(String str)
	{
		if (str == null || "".equals(str.trim()))
		{
			return "";
		}
		return str.trim();
	}
	
	/**
	 * SC(サービスインターフェイス）を呼び出す。
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param mappingData
	 * @return CAANMsg
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg callSC(SessionHandle handle, 
							ServiceComponentRequestInvoker scCall, 
							IRequestParameterReadWrite param, 
							String dataMapKey,
							Object[][] mappingData) throws Exception
	{
		HashMap<String, Object> paramMap = editInMsg(param, mappingData);
		
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg msg = templates[0];
		
		// リターンコード取得
		Object return_code = result.get(JCMConstants.RET_CD_INT_KEY);
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		editErrorInfoCom(param, templates, (Integer)return_code, dataMapKey, mappingData);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(return_code.toString()) && 0 == status))
		{
			throw new SCCallException("戻り値不正", return_code.toString(), status);
		}
		return msg;
	}
	
	/**
	 * @param param
	 * @param mappingData
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsg(IRequestParameterReadWrite param,
												Object[][] mappingData) throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

		// 【取得元：電文ヘッダ(ヘッダ)】
		// 電文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));
		
		String svcIf = (String)mappingData[0][1];
		
		CAANMsg template = new CAANMsg(String.format("eo.ejb.cbs.cbsmsg.%sCBSMsg", svcIf));

		// オペレータID
		template.set(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		// 運用日付
		template.set(JCMConstants.OPERATE_DATE_KEY, param.getControlMapData(SCControlMapKeys.OPE_DATE));
		// 運用日時
		template.set(JCMConstants.OPERATE_DATETIME_KEY, param.getControlMapData(SCControlMapKeys.OPE_TIME));
		
		for (int i = 0; i < mappingData.length; i++)
		{
			if ("".equals(mappingData[i][1]))
			{
				template.setNull((String)mappingData[i][0]);
			}
			else
			{
				template.set((String)mappingData[i][0], mappingData[i][1]);
			}
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * 
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @param dataMapKey
	 * @param mappingData
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoCom(IRequestParameterReadWrite param,
														CAANMsg[] templates, 
														int returnCode,
														String dataMapKey,
														Object[][] mappingData) throws RequestParameterException
	{
		// 本来はサービスインターフェイス分の処理が必要
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(JCMConstants.STATUS_INT_KEY);

		if (returnCode != 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<String, String> inMap = null;

		// ユーザデータ情報
		inMap = (HashMap<String, String>)param.getData(dataMapKey);
		
		for (int i = 0; i < mappingData.length; i++)
		{
			if (!template.isNull(mappingData[i][0] + "_err"))
			{
				if (!inMap.containsKey(mappingData[i][0] + "_err"))
				{
					inMap.put(mappingData[i][0] + "_err", template.getString(mappingData[i][0] + "_err"));
				}
			}
		}
		return param;
	}
	
	/**
	 * サービス契約の更新タイムスタンプを取得します。
	 * @param param リクエストパラメータ
	 * @return UpDtm 更新時間
	 * @throws Exception 
	 */
	private String getSvcUpDtm(IRequestParameterReadWrite param) throws Exception
	{
		// 作業領域の取得
		Map<Object, Object> workMap = param.getMappingWorkArea();
		
		return (String)workMap.get(KK_COM_SVC_UP_DTM);

	}
	
	/**
	 * サービス契約の更新タイムスタンプを取得します。
	 * @param param リクエストパラメータ
	 * @param updDtm 更新時間
	 * @throws Exception 
	 */
	private void setSvcUpDtm(IRequestParameterReadWrite param, String updDtm) throws Exception
	{
		// 作業領域の取得
		Map<Object, Object> workMap = param.getMappingWorkArea();
		
		if(updDtm != null && !"".equals(updDtm))
		{
			workMap.put(KK_COM_SVC_UP_DTM, updDtm);
		}
	}
	
	/**
	 * 機器提供サービス契約回復メソッド <br>
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private void execEKK0341C380(SessionHandle handle, 
									ServiceComponentRequestInvoker scCall, 
									IRequestParameterReadWrite param, 
									String dataMapKey,
									HashMap<String, Object> temporaryData) throws Throwable
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);
		
		// サービス契約データを取得
		CAANMsg ekk0081a010cbsMsg = (CAANMsg)temporaryData.get(TEMPLATE_ID_EKK0081A010);

		// ***** EKK0341C380（機器提供サービス契約回復）*****
		Object[][] ekk0341c380IN = { { EKK0341C380CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0341C380 },
										{ EKK0341C380CBSMsg.FUNC_CODE, ccMsg.get("func_code") },
										{ EKK0341C380CBSMsg.KKTK_SVC_KEI_NO, ccMsg.get("kktk_svc_kei_no") },
										{ EKK0341C380CBSMsg.MSKM_DTL_NO, getMskmDtlNo(param, ekk0081a010cbsMsg)},
										{ EKK0341C380CBSMsg.KAIHK_YMD, ccMsg.get("unyo_ymd") },
										{ EKK0341C380CBSMsg.IDO_DIV, ccMsg.get("ido_div") }, 
										{ EKK0341C380CBSMsg.UPD_DTM_BF, getSvcUpDtm(param) },
										/* ++++++++++ v8.00.00 追加開始 ++++++++++ */
										{ EKK0341C380CBSMsg.TAKNKIKI_IDO_CD, "01" },
										/* ++++++++++ v8.00.00 追加終了 ++++++++++ */
									};

		// 更新処理実行
		CAANMsg ekk0341c380Msg_out = callSC(handle, scCall, param, dataMapKey, ekk0341c380IN);

		// 更新タイムスタンプをワーク領域にセットします。
		setSvcUpDtm(param, ekk0341c380Msg_out.getString(EKK0341C380CBSMsg.UPD_DTM));
	}
	
	/**
	 * サービス提供前機器提供サービス契約回復メソッド <br>
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private void execEKK0341C390(SessionHandle handle, 
									ServiceComponentRequestInvoker scCall, 
									IRequestParameterReadWrite param, 
									String dataMapKey,
									HashMap<String, Object> temporaryData) throws Throwable
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);
		
		// サービス契約データを取得
		CAANMsg ekk0081a010cbsMsg = (CAANMsg)temporaryData.get(TEMPLATE_ID_EKK0081A010);

		// ***** EKK0341C390（サービス提供前機器提供サービス契約回復）*****
		Object[][] ekk0341c390IN = { { EKK0341C390CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0341C390 },
										{ EKK0341C390CBSMsg.FUNC_CODE, ccMsg.get("func_code") },
										{ EKK0341C390CBSMsg.KKTK_SVC_KEI_NO, ccMsg.get("kktk_svc_kei_no") },
										{ EKK0341C390CBSMsg.MSKM_DTL_NO, getMskmDtlNo(param, ekk0081a010cbsMsg)},
										{ EKK0341C390CBSMsg.HAISO_KIGEN_YMD, "" },
										{ EKK0341C390CBSMsg.HAISO_ARIV_SHITEI_YMD, "" },
										{ EKK0341C390CBSMsg.KAIHK_YMD, ccMsg.get("unyo_ymd") },
										{ EKK0341C390CBSMsg.IDO_DIV, ccMsg.get("ido_div") }, 
										{ EKK0341C390CBSMsg.UPD_DTM_BF, getSvcUpDtm(param) },
										/* ++++++++++ v8.00.00 追加開始 ++++++++++ */
										{ EKK0341C380CBSMsg.TAKNKIKI_IDO_CD, "01" },
										/* ++++++++++ v8.00.00 追加終了 ++++++++++ */
									};

		// 更新処理実行
		CAANMsg ekk0341c390Msg_out = callSC(handle, scCall, param, dataMapKey, ekk0341c390IN);

		// 更新タイムスタンプをワーク領域にセットします。
		setSvcUpDtm(param, ekk0341c390Msg_out.getString(EKK0341C390CBSMsg.UPD_DTM));
	}
	
	/**
	 * 照査後機器提供サービス契約キャンセル取消メソッド <br>
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private void execEKK0341C420(SessionHandle handle, 
									ServiceComponentRequestInvoker scCall, 
									IRequestParameterReadWrite param, 
									String dataMapKey,
									HashMap<String, Object> temporaryData) throws Throwable
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);
		
		// サービス契約データを取得
		CAANMsg ekk0081a010cbsMsg = (CAANMsg)temporaryData.get(TEMPLATE_ID_EKK0081A010);

		// ***** EKK0341C420（照査後機器提供サービス契約キャンセル取消）*****
		Object[][] ekk0341c420IN = { { EKK0341C420CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0341C420 },
										{ EKK0341C420CBSMsg.FUNC_CODE, ccMsg.get("func_code") },
										{ EKK0341C420CBSMsg.KKTK_SVC_KEI_NO, ccMsg.get("kktk_svc_kei_no") },
										{ EKK0341C420CBSMsg.MSKM_DTL_NO, getMskmDtlNo(param, ekk0081a010cbsMsg)},
										{ EKK0341C420CBSMsg.IDO_DIV, ccMsg.get("ido_div") }, 
										{ EKK0341C420CBSMsg.UPD_DTM_BF, getSvcUpDtm(param) },
										/* ++++++++++ v8.00.00 追加開始 ++++++++++ */
										{ EKK0341C380CBSMsg.TAKNKIKI_IDO_CD, "01" },
										/* ++++++++++ v8.00.00 追加終了 ++++++++++ */
									};

		// 更新処理実行
		CAANMsg ekk0341c420Msg_out = callSC(handle, scCall, param, dataMapKey, ekk0341c420IN);

		// 更新タイムスタンプをワーク領域にセットします。
		setSvcUpDtm(param, ekk0341c420Msg_out.getString(EKK0341C420CBSMsg.UPD_DTM));
	}
	
	/**
	 * 照査前機器提供サービス契約キャンセル取消メソッド <br>
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private void execEKK0341C410(SessionHandle handle, 
									ServiceComponentRequestInvoker scCall, 
									IRequestParameterReadWrite param, 
									String dataMapKey,
									HashMap<String, Object> temporaryData) throws Throwable
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);
		
		// サービス契約データを取得
		CAANMsg ekk0081a010cbsMsg = (CAANMsg)temporaryData.get(TEMPLATE_ID_EKK0081A010);

		// ***** EKK0341C410（照査前機器提供サービス契約キャンセル取消）*****
		Object[][] ekk0341c410IN = { { EKK0341C410CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0341C410 },
										{ EKK0341C410CBSMsg.FUNC_CODE, ccMsg.get("func_code") },
										{ EKK0341C410CBSMsg.KKTK_SVC_KEI_NO, ccMsg.get("kktk_svc_kei_no") },
										{ EKK0341C410CBSMsg.MSKM_DTL_NO, getMskmDtlNo(param, ekk0081a010cbsMsg)},
										{ EKK0341C410CBSMsg.IDO_DIV, ccMsg.get("ido_div") }, 
										{ EKK0341C410CBSMsg.UPD_DTM_BF, getSvcUpDtm(param) },
										/* ++++++++++ v8.00.00 追加開始 ++++++++++ */
										{ EKK0341C380CBSMsg.TAKNKIKI_IDO_CD, "01" },
										/* ++++++++++ v8.00.00 追加終了 ++++++++++ */
									};

		// 更新処理実行
		CAANMsg ekk0341c410Msg_out = callSC(handle, scCall, param, dataMapKey, ekk0341c410IN);

		// 更新タイムスタンプをワーク領域にセットします。
		setSvcUpDtm(param, ekk0341c410Msg_out.getString(EKK0341C410CBSMsg.UPD_DTM));
	}
	
	/**
	 * 機器提供サービス一意照会を行う。
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @param kktkSvcKeiNo
	 * @return
	 * @throws Exception
	 */
	private CAANMsg execEKK0341A010(SessionHandle handle,
										ServiceComponentRequestInvoker scCall,
										IRequestParameterReadWrite param,
										String dataMapKey,
										HashMap<String, Object> temporaryData,
										String kktkSvcKeiNo) throws Exception
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);
		
		// 機器提供サービス契約情報を取得
		// ***** EKK0341A010（機器提供サービス契約一意照会）*****
		Object[][] ekk0341a010IN = {
			{EKK0341A010CBSMsg.TEMPLATEID,       TEMPLATE_ID_EKK0341A010},
			{EKK0341A010CBSMsg.FUNC_CODE,        "2"},
			{EKK0341A010CBSMsg.KEY_KKTK_SVC_KEI_NO,   kktkSvcKeiNo},
			{EKK0341A010CBSMsg.KEY_GENE_ADD_DTM, ""},
			{EKK0341A010CBSMsg.KEY_RSV_APLY_YMD, ccMsg.get("unyo_ymd")},
		};
		
		CAANMsg[] ekk0341a010cbsMsgList = callSC(handle, scCall, param, dataMapKey, ekk0341a010IN).getCAANMsgList(EKK0341A010CBSMsg.EKK0341A010CBSMSG1LIST);
		
		// データが存在しない場合、エラーメッセージを表示します。
		if(ekk0341a010cbsMsgList == null || ekk0341a010cbsMsgList.length == 0)
		{
			// 排他エラーを表示（EKB0320-KW）
			setMessageInfo(ccMsg, "EKB0320-KW", "", "", ERR_FLG_ERR);
			
			return null;
		}
		
		return ekk0341a010cbsMsgList[0];
	}
	
	/**
	 * 返品機器取消実行メソッド
	 * <br>
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private void execEDK0301C040(SessionHandle handle, 
									ServiceComponentRequestInvoker scCall, 
									IRequestParameterReadWrite param, 
									String dataMapKey,
									HashMap<String, Object> temporaryData) throws Throwable
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);
		
		// ***** EDK0301C040（返品機器取消）*****
		Object[][] edk0301c040IN = {
			{EDK0301C040CBSMsg.TEMPLATEID,        TEMPLATE_ID_EDK0301C040},
			{EDK0301C040CBSMsg.FUNC_CODE,         ccMsg.get("func_code")},
			{EDK0301C040CBSMsg.KEY_HMPIN_KIKI_NO, ccMsg.get("hmpin_kiki_no")},
			{EDK0301C040CBSMsg.LAST_UPD_DTM_BF,   ccMsg.get("upd_dtm_hmpin_kiki")}
		};
		callSC(handle, scCall, param, dataMapKey, edk0301c040IN);
	}
	
	/**
	 * 進捗登録SCを呼び出す。
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @param prgStat
	 * @throws Throwable 
	 */
	@SuppressWarnings("unchecked")
	private void execShinchokuToroku(SessionHandle handle, 
									ServiceComponentRequestInvoker scCall, 
									IRequestParameterReadWrite param, 
									String dataMapKey,
									HashMap<String, Object> temporaryData,
									String prgStat) throws Throwable
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);
		
		// 特記事項文字列を取得する
		String prg_tkjk = getPrgTkjk(handle, scCall, param, dataMapKey, temporaryData, prgStat);
		
		// 進捗ステータスに該当する進捗レコードが出力済みか判定する。
		if(!isExecShinchokuToroku(param, prgStat, prg_tkjk))
		{
			return;
		}
		
		// サービス契約データを取得
		CAANMsg ekk0081a010cbsMsg = (CAANMsg)temporaryData.get(TEMPLATE_ID_EKK0081A010);
		
		// 進捗登録SC
		// ***** EKK1091D010（進捗登録）*****
		Object[][] ekk1091d010IN = {
			{EKK1091D010CBSMsg.TEMPLATEID,       TEMPLATE_ID_EKK1091D010},
			{EKK1091D010CBSMsg.FUNC_CODE,        ccMsg.get("func_code")},
			{EKK1091D010CBSMsg.MSKM_DTL_NO,   getMskmDtlNo(param, ekk0081a010cbsMsg)},
			{EKK1091D010CBSMsg.SEIKY_KEI_NO, ""},
			{EKK1091D010CBSMsg.SEIKY_WAY_NO_KOZA, ""},
			{EKK1091D010CBSMsg.SEIKY_WAY_NO_CRECARD, ""},
			{EKK1091D010CBSMsg.SVC_KEI_NO, ccMsg.get("svc_kei_no")},
			{EKK1091D010CBSMsg.SVC_KEI_UCWK_NO, ""},
			{EKK1091D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO, ""},
			{EKK1091D010CBSMsg.KKTK_SVC_KEI_NO, ""},
			{EKK1091D010CBSMsg.OP_SVC_KEI_NO, ""},
			{EKK1091D010CBSMsg.SEIOPSVC_KEI_NO, ""},
			{EKK1091D010CBSMsg.SBOP_SVC_KEI_NO, ""},
			{EKK1091D010CBSMsg.WRIB_SVC_KEI_NO, ""},
			{EKK1091D010CBSMsg.IDO_DIV, ccMsg.get("ido_div")},
			{EKK1091D010CBSMsg.IDO_DTM,  getIdoUpDtm(param)},
			{EKK1091D010CBSMsg.PRG_STAT, prgStat},
			{EKK1091D010CBSMsg.PRG_MEMO, ""},
			{EKK1091D010CBSMsg.PRG_TKJK_1, prg_tkjk},

			{EKK1091D010CBSMsg.PRG_TKJK_2, ""},
		};
		
		// 登録データを格納します。
		ArrayList<HashMap<String, Object>> inList = new ArrayList<HashMap<String, Object>>();
		HashMap<String, Object> inMap = new HashMap<String, Object>();
		
		// 異動理由コード
		inMap.put(EKK1091D010CBSMsg1List.IDO_RSN_CD, getNullToStr((String)ccMsg.get("ido_rsn_cd")));
		// 異動理由メモ
		inMap.put(EKK1091D010CBSMsg1List.IDO_RSN_MEMO, "");
		
		inList.add(inMap);
		
		callSCArray(handle, scCall, param, dataMapKey, ekk1091d010IN, "EKK1091D010CBSMsg1List", inList);
		
		setShinchokuTkjk(param, prgStat, prg_tkjk);

	}
	
	/**
	 * 特記事項取得メソッド
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @param prgStat
	 * @return tkjikou
	 * @throws Throwable 
	 */
	private String getPrgTkjk(SessionHandle handle, 
									ServiceComponentRequestInvoker scCall, 
									IRequestParameterReadWrite param, 
									String dataMapKey,
									HashMap<String, Object> temporaryData,
									String prgStat) throws Throwable
	{
		
		String tkjikou = "";
		
		CAANMsg ekk0341a010cbsMsg = (CAANMsg)temporaryData.get(TEMPLATE_ID_EKK0341A010_AF);
		
		tkjikou = "型番号：" + ekk0341a010cbsMsg.getString(EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD);

		return tkjikou;
	}
	
	/**
	 * 申込明細番号を取得します。
	 * @param param リクエストパラメータ
	 * @param ekk0081a010cbsMsg
	 * @return 申込明細番号
	 * @throws Exception 
	 */
	private String getMskmDtlNo(IRequestParameterReadWrite param, CAANMsg ekk0081a010cbsMsg) throws Exception
	{

		Map<Object, Object> workMap = param.getMappingWorkArea();
		String mskmDtlNo = getNullToStr((String)workMap.get("mskm_dtl_no"));
		
		if("".equals(mskmDtlNo))
		{
			mskmDtlNo = getNullToStr((String)ekk0081a010cbsMsg.getString(EKK0081A010CBSMsg1List.MSKM_DTL_NO));
		}

		return mskmDtlNo;
	}
	
	/**
	 * 進捗出力内容から進捗情報を出力するか判定します。
	 * <br>
	 * @param param
	 * @param dataMapKey
	 * @return true:出力する false:出力しない。
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private boolean isExecShinchokuToroku(IRequestParameterReadWrite param, 
											String prg_stat,
											String prg_tkjk) throws Throwable
	{
		// 作業領域の取得
		Map<Object, Object> workMap = param.getMappingWorkArea();
		
		// ワーク領域より処理一覧を取得
		HashMap<String, Object> prg_work_map = (HashMap<String, Object>)workMap.get(KKW03301_PRG_WORK);
		
		// 未設定の場合、進捗未出力として進捗登録を行う。
		if(prg_work_map == null)
		{
			return true;
		}
		
		// 進捗ステータスの存在チェック
		if(!prg_work_map.containsKey(prg_stat))
		{
			// 該当進捗ステータス未出力として進捗登録を行う。
			return true;
		}
		else
		{
			HashMap<String, Object> prg_stat_map = (HashMap<String, Object>)prg_work_map.get(prg_stat);
			
			if(prg_stat_map.containsKey(prg_tkjk))
			{
				// 進捗ステータス+特記事項が存在するため進捗登録は行わない
				return false;
			}
		}
		
		return true;
	}
	
	/**
	 * 進捗情報をworkMapに保持します。
	 * 
	 * @param param
	 * @param prg_stat
	 * @param prg_tkjk
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private void setShinchokuTkjk(IRequestParameterReadWrite param, 
									String prg_stat,
									String prg_tkjk) throws Throwable
	{
		// 作業領域の取得
		Map<Object, Object> workMap = param.getMappingWorkArea();
		
		// ワーク領域より処理一覧を取得
		HashMap<String, Object> prg_work_map = (HashMap<String, Object>)workMap.get(KKW03301_PRG_WORK);
		
		// 未設定の場合、初期化後再設定
		if(prg_work_map == null)
		{
			prg_work_map = new HashMap<String, Object>();
			workMap.put(KKW03301_PRG_WORK, prg_work_map);
		}
		
		if(prg_work_map.containsKey(prg_stat))
		{
			// key_進捗ステータスが存在する場合、追加する。
			HashMap<String, Object> prg_stat_map = (HashMap<String, Object>)prg_work_map.get(prg_stat);
			
			prg_stat_map.put(prg_tkjk, "");
		}
		else
		{
			// key_進捗ステータスが存在しない場合、新規追加する。
			HashMap<String, Object> prg_stat_map = new HashMap<String, Object>();
			
			prg_stat_map.put(prg_tkjk, "");
			
			prg_work_map.put(prg_stat, prg_stat_map);
			
		}
	}
	
	/**
	 * ワーク領域に保持している異動年月日時分秒を取得します。
	 * 設定値がない場合は共通部品より取得します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @return UpDtm 更新時間
	 * @throws Exception
	 */
	private String getIdoUpDtm(IRequestParameterReadWrite param) throws Exception
	{
		// 作業領域の取得
		Map<Object, Object> workMap = param.getMappingWorkArea();
		
		if("".equals(getNullToStr((String)workMap.get(KK_COM_IDO_UP_DTM))))
		{
			// 未設定時のみworkMapに新規格納
			workMap.put(KK_COM_IDO_UP_DTM, (JPCBPCommon.getSysDateTimeStamp()));
		}
		// workMapから取得
		return (String)workMap.get(KK_COM_IDO_UP_DTM);
	}
	
	/**
	 * SC(サービスインターフェイス）を呼び出す。
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param mappingData
	 * @param inListMsgName
	 * @param inList
	 * @return CAANMsg
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg callSCArray(SessionHandle handle, 
									ServiceComponentRequestInvoker scCall, 
									IRequestParameterReadWrite param, 
									String dataMapKey,
									Object[][] mappingData,
									String inListMsgName, 
									ArrayList<HashMap<String, Object>> inList) throws Exception
	{
		HashMap<String, Object> paramMap = editInArrayMsg(param, mappingData, inListMsgName, inList);
		
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg msg = templates[0];
		
		// リターンコード取得
		Object return_code = result.get(JCMConstants.RET_CD_INT_KEY);
		int status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		editErrorInfoComArray(param, templates, (Integer)return_code, dataMapKey, mappingData, inListMsgName, inList);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(return_code.toString()) && 0 == status))
		{
			// 警告の場合、例外をスローしない
			if(!("0".equals(return_code.toString()) && 4 == status))
			{
				throw new SCCallException("戻り値不正", return_code.toString(), status);
			}
		}
		return msg;
	}
	
	/**
	 * @param param
	 * @param mappingData
	 * @param inListMsgName
	 * @param inList
	 * @return HashMap
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInArrayMsg(IRequestParameterReadWrite param,
													Object[][] mappingData, 
													String inListMsgName, 
													ArrayList<HashMap<String, Object>> inList) throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

		// 【取得元：電文ヘッダ(ヘッダ)】
		// 電文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));
		
		String svcIf = (String)mappingData[0][1];
		
		CAANMsg template = new CAANMsg(String.format("eo.ejb.cbs.cbsmsg.%sCBSMsg", svcIf));


		// オペレータID
		template.set(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		// 運用日付
		template.set(JCMConstants.OPERATE_DATE_KEY, param.getControlMapData(SCControlMapKeys.OPE_DATE));
		// 運用日時
		template.set(JCMConstants.OPERATE_DATETIME_KEY, param.getControlMapData(SCControlMapKeys.OPE_TIME));
		
		for (int i = 0; i < mappingData.length; i++)
		{
			if ("".equals(mappingData[i][1]))
			{
				template.setNull((String)mappingData[i][0]);
			}
			else
			{
				template.set((String)mappingData[i][0], mappingData[i][1]);
			}
		}
		
		CAANMsg[] templateArray = template.getCAANMsgList(inListMsgName);
		
		if (templateArray == null)
		{
			templateArray = new CAANMsg[inList.size()];
		}
		
		for (int i = 0; i < inList.size(); i++)
		{
			HashMap childMap = (HashMap)inList.get(i);
			CAANMsg childTemplate = templateArray[i];
			if (childTemplate == null)
			{
				childTemplate = new CAANMsg(String.format("eo.ejb.cbs.cbsmsg.%sCBSMsg1List", svcIf));
			}
			
			Iterator it = childMap.keySet().iterator();
			while (it.hasNext())
			{
				String key = (String)it.next();
				
				if ("".equals(childMap.get(key)))
				{
					childTemplate.setNull(key);
				}
				else
				{
					childTemplate.set(key, (String)childMap.get(key));
				}
			}

			templateArray[i] = childTemplate;
		}
		
		template.set(inListMsgName, templateArray);
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 * 
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @param dataMapKey
	 * @param mappingData
	 * @param inListMsgName
	 * @param inList
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoComArray(IRequestParameterReadWrite param,
														CAANMsg[] templates, 
														int returnCode,
														String dataMapKey,
														Object[][] mappingData,
														String inListMsgName, 
														ArrayList<HashMap<String, Object>> inList) throws RequestParameterException
	{
		// 本来はサービスインターフェイス分の処理が必要
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(JCMConstants.STATUS_INT_KEY);

		if (returnCode != 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<String, String> inMap = (HashMap<String, String>)param.getData(dataMapKey);
		
		CAANMsg[] templateArray = template.getCAANMsgList(inListMsgName);
		
		for (int i = 0; i < inList.size(); i++)
		{
			HashMap childMap = (HashMap)inList.get(i);
			CAANMsg childTemplate = templateArray[i];
			
			Iterator it = childMap.keySet().iterator();
			while (it.hasNext())
			{
				String key = (String)it.next();
				
				if (!childTemplate.isNull(key + "_err"))
				{
					if (!inMap.containsKey(key + "_err"))
					{
						inMap.put(key + "_err", childTemplate.getString(key + "_err"));
					}
				}
			}
		}
		
		if (!template.isNull(inListMsgName + "_err"))
		{
			if (!inMap.containsKey(inListMsgName + "_err"))
			{
				inMap.put(inListMsgName + "_err", template.getString(inListMsgName + "_err"));
			}
		}

		return param;
	}
	
	/**
	 * 機器提供サービス契約住所更新メソッド
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @param kktkSvcKeiMsg
	 * @return boolean
	 * @throws Throwable 
	 */
	@SuppressWarnings("unchecked")
	private boolean isKktkSvcKeiJyushoUpdate(SessionHandle handle, 
												ServiceComponentRequestInvoker scCall, 
												IRequestParameterReadWrite param,
												String dataMapKey, 
												HashMap<String, Object> temporaryData) throws Throwable
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);
		
		CAANMsg ekk0251b003cbsMsg = execEKK0251B003(handle, scCall, param, dataMapKey);

		String kiki_shs_kbt_shitei_flg = "0";
		if (!isKobetsuJyusho(ccMsg, ekk0251b003cbsMsg))
		{
			kiki_shs_kbt_shitei_flg = "1";
		}
		
		// 機器送付先住所手動入力フラグ
		String kikiShsAdManInputFlg = (String)ccMsg.get("kiki_shs_ad_man_input_flg");
		
		String scrnId = getNullToStr((String)ccMsg.get("check_scrn_id"));
		
//		// 子画面から実行された場合、住所チェックが必要ないため手動入力フラグに1を設定します。
//		if(SCRN_ID_KKW06201.equals(scrnId))
//		{
//			kikiShsAdManInputFlg = "1";
//		}
		
		// 機器送付先住所チェックレベル
		String kikiSohusAdChkLv = "";
		
		// 機器送付先住所チェックレベル
		if("0".equals(kikiShsAdManInputFlg))
		{
			kikiSohusAdChkLv = "1";
		}
		else
		{
			kikiSohusAdChkLv = "0";
		}
		
		// 回復後データ取得（違約金コードなど更新されている可能性があるため）
		CAANMsg kktkSvcKeiMsg = execEKK0341A010(handle, scCall, param, dataMapKey, temporaryData, (String)ccMsg.get("kktk_svc_kei_no"));
		
		
		// ***** EKK0341C230（機器提供サービス契約情報変更）*****
		Object[][] ekk0341c230IN = {
			{EKK0341C230CBSMsg.TEMPLATEID,                 TEMPLATE_ID_EKK0341C230},
			{EKK0341C230CBSMsg.FUNC_CODE,                  ccMsg.get("func_code")},
			{EKK0341C230CBSMsg.KKTK_SVC_KEI_NO,            ccMsg.get("kktk_svc_kei_no")},
			{EKK0341C230CBSMsg.KKTK_SBT_CD,                kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KKTK_SBT_CD)},
			{EKK0341C230CBSMsg.HAMBAI_SBT_CD,              kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.HAMBAI_SBT_CD)},
			{EKK0341C230CBSMsg.TAKNKIKI_MODEL_CD,          kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD)},
			{EKK0341C230CBSMsg.KIKI_SEIZO_NO,              kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_SEIZO_NO)},
			{EKK0341C230CBSMsg.HDD_CAPA_CD,                kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.HDD_CAPA_CD)},
			{EKK0341C230CBSMsg.TSUSHIN_KIKI_SET_CD,        kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.TSUSHIN_KIKI_SET_CD)},
			{EKK0341C230CBSMsg.LINK_STB_FLG,               kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.LINK_STB_FLG)},
			{EKK0341C230CBSMsg.KIKI_HKAT_SHITEI_SOKO_CD,   kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_HKAT_SHITEI_SOKO_CD)},
			{EKK0341C230CBSMsg.KIKI_HKAT_SHITEI_SKDN_CD,   kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_HKAT_SHITEI_SKDN_CD)},
			{EKK0341C230CBSMsg.KIKI_SORYO_UM,              kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_SORYO_UM)},
			{EKK0341C230CBSMsg.KIKI_SOHUS_NM,              ccMsg.get("kiki_sohus_nm")},
			{EKK0341C230CBSMsg.KIKI_SOHUS_KANA,            ccMsg.get("kiki_sohus_kana")},
			{EKK0341C230CBSMsg.KIKI_SOHUS_AD_CD,           ccMsg.get("kiki_sohus_ad_cd")},
			{EKK0341C230CBSMsg.KIKI_SOHUS_PCD,             ccMsg.get("kiki_sohus_pcd")},
			{EKK0341C230CBSMsg.KIKI_SOHUS_STATE_NM,        ccMsg.get("kiki_sohus_state_nm")},
			{EKK0341C230CBSMsg.KIKI_SOHUS_CITY_NM,         ccMsg.get("kiki_sohus_city_nm")},
			{EKK0341C230CBSMsg.KIKI_SOHUS_OAZTSU_NM,       ccMsg.get("kiki_sohus_oaztsu_nm")},
			{EKK0341C230CBSMsg.KIKI_SOHUS_AZCHO_NM,        ccMsg.get("kiki_sohus_azcho_nm")},
			{EKK0341C230CBSMsg.KIKI_SOHUS_BNCHIGO,         ccMsg.get("kiki_sohus_bnchigo")},
			{EKK0341C230CBSMsg.KIKI_SOHUS_ADRTTM,          ccMsg.get("kiki_sohus_adrttm")},
			{EKK0341C230CBSMsg.KIKI_SOHUS_ADRRM,           ccMsg.get("kiki_sohus_adrrm")},
			{EKK0341C230CBSMsg.KIKI_SOHUS_TELNO,           ccMsg.get("kiki_sohus_telno")},
			{EKK0341C230CBSMsg.KIKI_SOHUS_KSH_AD_SAI_FLG,  kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_SOHUS_KSH_AD_SAI_FLG)},
			{EKK0341C230CBSMsg.KIKI_SHS_KBT_SHITEI_FLG,    kiki_shs_kbt_shitei_flg},
			{EKK0341C230CBSMsg.KIKI_STC_SAKI_NM,           kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STC_SAKI_NM)},
			{EKK0341C230CBSMsg.KIKI_STC_SAKI_KANA,         kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STC_SAKI_KANA)},
			{EKK0341C230CBSMsg.KIKI_STC_SAKI_AD_CD,        kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STC_SAKI_AD_CD)},
			{EKK0341C230CBSMsg.KIKI_STC_SAKI_PCD,          kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STC_SAKI_PCD)},
			{EKK0341C230CBSMsg.KIKI_STC_SAKI_STATE_NM,     kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STC_SAKI_STATE_NM)},
			{EKK0341C230CBSMsg.KIKI_STC_SAKI_CITY_NM,      kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STC_SAKI_CITY_NM)},
			{EKK0341C230CBSMsg.KIKI_STC_SAKI_OAZTSU_NM,    kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STC_SAKI_OAZTSU_NM)},
			{EKK0341C230CBSMsg.KIKI_STC_SAKI_AZCHO_NM,     kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STC_SAKI_AZCHO_NM)},
			{EKK0341C230CBSMsg.KIKI_STC_SAKI_BNCHIGO,      kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STC_SAKI_BNCHIGO)},
			{EKK0341C230CBSMsg.KIKI_STC_SAKI_ADRTTM,       kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STC_SAKI_ADRTTM)},
			{EKK0341C230CBSMsg.KIKI_STC_SAKI_ADRRM,        kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STC_SAKI_ADRRM)},
			{EKK0341C230CBSMsg.KIKI_STC_SK_KSH_AD_SAI_FLG, kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STC_SK_KSH_AD_SAI_FLG)},
			{EKK0341C230CBSMsg.KIKI_STC_SK_TELNO,          kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STC_SK_TELNO)},
			{EKK0341C230CBSMsg.KIKI_STS_KKK_SEIRI_CHU_FLG, kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STS_KKK_SEIRI_CHU_FLG)},
			{EKK0341C230CBSMsg.AD_MI_FIX_FLG,              kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.AD_MI_FIX_FLG)},
			{EKK0341C230CBSMsg.HAISO_DIV,                  kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.HAISO_DIV)},
			{EKK0341C230CBSMsg.FTRIAL_KANYU_YMD,           kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.FTRIAL_KANYU_YMD)},
			{EKK0341C230CBSMsg.FTRIAL_PRD_ENDYMD,          kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.FTRIAL_PRD_ENDYMD)},
			{EKK0341C230CBSMsg.HONKANYU_YMD,               kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.HONKANYU_YMD)},
			{EKK0341C230CBSMsg.HONKANYU_IKO_KIGEN_YMD,     kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.HONKANYU_IKO_KIGEN_YMD)},
			{EKK0341C230CBSMsg.HOSHO_CD,                   kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.HOSHO_CD)},
			{EKK0341C230CBSMsg.PNLTY_HASSEI_CD,            kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.PNLTY_HASSEI_CD)},
			{EKK0341C230CBSMsg.IDO_DIV,                    ccMsg.get("ido_div")},
			{EKK0341C230CBSMsg.CAS_CARD_USE_KYODAK_YMD,    kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.CAS_CARD_USE_KYODAK_YMD)},
			{EKK0341C230CBSMsg.KIKI_HUKA_INFO_CD,          kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_HUKA_INFO_CD)},
			{EKK0341C230CBSMsg.HAISO_WAY_CD,               kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.HAISO_WAY_CD)},
			{EKK0341C230CBSMsg.KIKI_ITENS_MV_JSSIS_SKCD,   kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_ITENS_MV_JSSIS_SKCD)},
			{EKK0341C230CBSMsg.HAISO_REQ_SHITEI_YMD,       ccMsg.get("haiso_req_shitei_ymd")},
			{EKK0341C230CBSMsg.UPD_DTM_BF,                 getSvcUpDtm(param)},
			{EKK0341C230CBSMsg.KIKI_SHS_AD_MAN_INPUT_FLG,     kikiShsAdManInputFlg},
			{EKK0341C230CBSMsg.KAISHU_KIKI_UM,         ""},
			{EKK0341C230CBSMsg.SVC_STA_JI_HIS_JOKYO_SKCD,         kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.SVC_STA_JI_HIS_JOKYO_SKCD)},
			{EKK0341C230CBSMsg.KIKI_SOHUS_AD_CHK_LV,     kikiSohusAdChkLv},
			{EKK0341C230CBSMsg.KIKI_STI_JI_KRIPLACE_SKCD,  kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STI_JI_KRIPLACE_SKCD)},
			{EKK0341C230CBSMsg.KIKI_STI_JI_KOCOMP_CD,      kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STI_JI_KOCOMP_CD)},
			{EKK0341C230CBSMsg.KIKI_STI_JI_KOCOMP_SLF_CD,  kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STI_JI_KOCOMP_SLF_CD)},
			{EKK0341C230CBSMsg.KIKI_STI_JI_YTKSKOF_CD,     kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STI_JI_YTKSKOF_CD)},
			{EKK0341C230CBSMsg.KIKI_STI_JI_YTKSKOF_SLF_CD, kktkSvcKeiMsg.getString(EKK0341A010CBSMsg1List.KIKI_STI_JI_YTKSKOF_SLF_CD)},
		};
		CAANMsg ekk0341c230OUT = callSC(handle, scCall, param, dataMapKey, ekk0341c230IN);
		
		// 更新タイムスタンプをワーク領域にセットします。
		setSvcUpDtm(param, ekk0341c230OUT.getString(EKK0341C230CBSMsg.UPD_DTM));

		return true;
	}
	
	/**
	 * サービス契約回線内訳一覧照会（現在利用中）を実行します
	 * <br>
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @return
	 * @throws Throwable
	 */
	private CAANMsg execEKK0251B003(SessionHandle handle,
										ServiceComponentRequestInvoker scCall,
										IRequestParameterReadWrite param,
										String dataMapKey) throws Throwable
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);
		
		// サービス契約回線内訳
		// ***** EKK0251B003（サービス契約回線内訳一覧照会（現在利用中））*****
		Object[][] ekk0251b003IN = { 
				{ EKK0251B003CBSMsg.TEMPLATEID,        TEMPLATE_ID_EKK0251B003 }, 
				{ EKK0251B003CBSMsg.FUNC_CODE,         "1" },
				{ EKK0251B003CBSMsg.KEY_SVC_KEI_NO,    ccMsg.get("svc_kei_no") },
		};
		
		// サービスインターフェースの実行
		CAANMsg ekk0251b003cbsMsg = callSC(handle, scCall, param, dataMapKey, ekk0251b003IN).getCAANMsgList(EKK0251B003CBSMsg.EKK0251B003CBSMSG1LIST)[0];
		
		return ekk0251b003cbsMsg;
	}
	
	/**
	 * 住所情報が変更されているか判定します。
	 * @param ccMsg 画面パラメタ
	 * @param ekk0251b003 検索データ
	 * @return boolean 変更されている場合：false 変更されていない場合：true
	 * @throws Exception
	 */
	private boolean isKobetsuJyusho(HashMap<String, Object> ccMsg, CAANMsg ekk0251b003) throws Exception
	{
		String[][] sofuList = {
				{"kiki_sohus_ad_cd",      EKK0251B003CBSMsg1List.KAISEN_PLACE_AD_CD},
				{"kiki_sohus_pcd",        EKK0251B003CBSMsg1List.KAISEN_PLACE_PCD},
				{"kiki_sohus_state_nm",   EKK0251B003CBSMsg1List.KAISEN_PLACE_STATE_NM},
				{"kiki_sohus_city_nm",    EKK0251B003CBSMsg1List.KAISEN_PLACE_CITY_NM},
				{"kiki_sohus_oaztsu_nm",  EKK0251B003CBSMsg1List.KAISEN_PLACE_OAZTSU_NM},
				{"kiki_sohus_azcho_nm",   EKK0251B003CBSMsg1List.KAISEN_PLACE_AZCHO_NM},
				{"kiki_sohus_bnchigo",    EKK0251B003CBSMsg1List.KAISEN_PLACE_BNCHIGO},
				{"kiki_sohus_adrttm",     EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRTTM},
				{"kiki_sohus_adrrm",      EKK0251B003CBSMsg1List.KAISEN_PLACE_ADRRM},
				{"kiki_sohus_telno",      EKK0251B003CBSMsg1List.KAISEN_PLACE_TELNO},
		};
		
		for(int i = 0; i < sofuList.length; i++)
		{
			if(!getNullToStr((String)ccMsg.get(sofuList[i][0])).equals(getNullToStr(ekk0251b003.getString(sofuList[i][1]))))
			{
				return false;
			}
		}
		return true;
	}
	
	/**
	 * 機器一覧一括処理データ格納メソッド
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @param ekk0341a010cbsMsg
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void setKikiIchiranIkkatsuList(SessionHandle handle, 
											ServiceComponentRequestInvoker scCall, 
											IRequestParameterReadWrite param, 
											String dataMapKey,
											HashMap<String, Object> temporaryData,
											CAANMsg ekk0341a010cbsMsg) throws Exception
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);
		
		String ichiranIndex = getNullToStr((String)ccMsg.get("ichiranIndex"));
		
		if("".equals(ichiranIndex))
		{
			return;
		}
		
		int index = Integer.parseInt(ichiranIndex);
		
		// 作業領域の取得
		Map<Object, Object> workMap = param.getMappingWorkArea();
		
		// ワーク領域より処理一覧を取得
		ArrayList<HashMap<String, Object>> ichiranShoriList = (ArrayList<HashMap<String, Object>>)workMap.get(SHORI_LIST_ICHIRAN);
		
		// 一覧処理マップ(格納するIndexのMapを取り出します。)
		HashMap<String, Object> ichiranShoriMap = ichiranShoriList.get(index);
		
		ArrayList<CAANMsg> shoriListKiki_af = new ArrayList<CAANMsg>();
			
		shoriListKiki_af.add(ekk0341a010cbsMsg);
		
		ichiranShoriMap.put(SHORI_LIST_KIKILIST_AF, shoriListKiki_af);
	}
	// ++++++++++ v10.00.00 追加開始 ++++++++++ //
	/**
	 * サービス契約内訳取得メソッド
	 * <br>
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param svcKeiNo
	 * @return ArrayList<CAANMsg>
	 * @throws Exception
	 */
	private ArrayList<CAANMsg> getSvcKeiUcwkData(SessionHandle handle, 
											ServiceComponentRequestInvoker scCall, 
											IRequestParameterReadWrite param,
											String dataMapKey,
											String svcKeiNo) throws Exception
	{
		ArrayList<CAANMsg> svcKeiUcwkList = new ArrayList<CAANMsg>();
		
		// サービス契約内訳取得
		CAANMsg[] ekk0161b004cbsMsg1list = execEKK0161B004(handle, scCall, param, dataMapKey, svcKeiNo);
		
		// サービス契約内訳取得結果が存在しない場合
		if(ekk0161b004cbsMsg1list == null || ekk0161b004cbsMsg1list.length == 0)
		{
			return svcKeiUcwkList;
		}
		
		String svcKeiUcwkStat = "";

		for (int i = 0; i < ekk0161b004cbsMsg1list.length; i++)
		{
			
			// サービス契約内訳ステータス取得
			svcKeiUcwkStat = getNullToStr(ekk0161b004cbsMsg1list[i].getString(EKK0161B004CBSMsg1List.SVC_KEI_UCWK_STAT));
			
			// 受付済（010）、解約（910）、キャンセル（920）の場合、対象外
			if(SVC_KEI_UCWK_STAT_UKEZUMI.equals(svcKeiUcwkStat) ||
					SVC_KEI_UCWK_STAT_DSL.equals(svcKeiUcwkStat) || SVC_KEI_UCWK_STAT_CANCEL.equals(svcKeiUcwkStat))
			{
				continue;
			}
			
			// リストをクリアし、新しいサービス契約内訳を設定する
			svcKeiUcwkList.clear();
			svcKeiUcwkList.add(ekk0161b004cbsMsg1list[i]);
			
		}
		return svcKeiUcwkList;
	}	
	
	/**
	 * サービス契約内訳一覧照会
	 * <br>
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param svcKeiNo
	 * @return CAANMsg[]
	 * @throws Exception
	 */
	private CAANMsg[] execEKK0161B004(SessionHandle handle, 
										ServiceComponentRequestInvoker scCall, 
										IRequestParameterReadWrite param,
										String dataMapKey,
										String svcKeiNo) throws Exception
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);
		// ***** EKK0161B004（サービス契約内訳一覧照会）******
		Object[][] ekk0161b004IN = {
				{ EKK0161B004CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0161B004 },
				{ EKK0161B004CBSMsg.FUNC_CODE, FUNC_CODE_1 }, // サービス契約内訳一覧照会(変更手続中でない)
				{ EKK0161B004CBSMsg.KEY_SVC_KEI_NO, svcKeiNo },
		};
		
		// 同一場所サービス契約情報照会サービスインターフェイスの実行
		CAANMsg[] ekk0161b004cbsMsg1list = callSC(handle, scCall, param, dataMapKey, ekk0161b004IN).getCAANMsgList(EKK0161B004CBSMsg.EKK0161B004CBSMSG1LIST);
		
		return ekk0161b004cbsMsg1list;
	}
	
	/**
	 * EKK1081D010_オーダ発行条件登録を実行します。
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @param ekk1081d010Map
	 * @return CAANMsg
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg execEKK1081D010(SessionHandle handle, 
									ServiceComponentRequestInvoker scCall, 
									IRequestParameterReadWrite param, 
									String dataMapKey,
									HashMap<String, Object> temporaryData,
									HashMap<String, String> ekk1081d010Map) throws Throwable
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);

		// 同一処理番号採番データ取得
		CAANMsg ekk1081c011Msg = (CAANMsg)temporaryData.get(TEMPLATE_ID_EKK1081C011);
		
		// 機器提供サービス契約（回復後）取得
		CAANMsg ekk0341a010Msg = (CAANMsg)temporaryData.get(TEMPLATE_ID_EKK0341A010_AF);
		
		// サービス契約内訳取得
		CAANMsg ekk0161b004Msg = (CAANMsg)temporaryData.get(TEMPLATE_ID_EKK0161B004);
		
		// ***** EKK1081D010（オーダ情報条件登録）*****
		Object[][] ekk1081d010IN = {
				{EKK1081D010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK1081D010},
				{EKK1081D010CBSMsg.FUNC_CODE, ccMsg.get("func_code")},
				{EKK1081D010CBSMsg.SVC_KEI_NO, ccMsg.get("svc_kei_no")},
				{EKK1081D010CBSMsg.SVC_KEI_UCWK_NO, ekk0161b004Msg.getString(EKK0161B004CBSMsg1List.SVC_KEI_UCWK_NO)},
				{EKK1081D010CBSMsg.KKTK_SVC_KEI_NO, ekk0341a010Msg.getString(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO)},
				{EKK1081D010CBSMsg.OP_SVC_KEI_NO, ""},
				{EKK1081D010CBSMsg.SBOP_SVC_KEI_NO, ""},
				{EKK1081D010CBSMsg.SEIOPSVC_KEI_NO, ""},
				{EKK1081D010CBSMsg.ORDER_SBT_CD, ekk1081d010Map.get(EKK1081D010CBSMsg.ORDER_SBT_CD)},
				{EKK1081D010CBSMsg.SVC_ORDER_CD, ekk1081d010Map.get(EKK1081D010CBSMsg.SVC_ORDER_CD)},
				{EKK1081D010CBSMsg.YOKYU_SBT_CD, ekk1081d010Map.get(EKK1081D010CBSMsg.YOKYU_SBT_CD)},
				{EKK1081D010CBSMsg.ODR_HAKKO_JOKEN_CD, ekk1081d010Map.get(EKK1081D010CBSMsg.ODR_HAKKO_JOKEN_CD)},
				{EKK1081D010CBSMsg.SAME_TRN_NO, ekk1081c011Msg.getString(EKK1081C011CBSMsg.SAME_TRN_NO)},
				{EKK1081D010CBSMsg.TAKNKIKI_MODEL_CD, ekk0341a010Msg.getString(EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD)},
				{EKK1081D010CBSMsg.KIKI_SEIZO_NO, ekk0341a010Msg.getString(EKK0341A010CBSMsg1List.KIKI_SEIZO_NO)},
				{EKK1081D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO, ekk0341a010Msg.getString(EKK0341A010CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO)},
				{EKK1081D010CBSMsg.MLAD, ""},
				{EKK1081D010CBSMsg.SPOT_LOGIN_SYSID, ""},
				{EKK1081D010CBSMsg.SEND_REQ_FIN_DTM, ""}
		};
		// 更新処理の実行
		return callSC(handle, scCall, param, dataMapKey, ekk1081d010IN);
	}
	
	/**
	 * EKK1551D010_オーダ情報作成ワーク登録を実行します。
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @param ekk1551d010Map
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private void execEKK1551D010(SessionHandle handle, 
									ServiceComponentRequestInvoker scCall, 
									IRequestParameterReadWrite param, 
									String dataMapKey,
									HashMap<String, Object> temporaryData,
									HashMap<String, String> ekk1551d010Map) throws Throwable
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);
		
		// オーダ発行条件登録データを取得
		CAANMsg ekk1081d010Msg = (CAANMsg)temporaryData.get(TEMPLATE_ID_EKK1081D010);
		
		// 機器提供サービス契約（回復後）取得
		CAANMsg ekk0341a010Msg = (CAANMsg)temporaryData.get(TEMPLATE_ID_EKK0341A010_AF);
		
		// サービス契約取得
		CAANMsg ekk0081a010Msg = (CAANMsg)temporaryData.get(TEMPLATE_ID_EKK0081A010);
		
		// サービス契約内訳取得
		CAANMsg ekk0161b004Msg = (CAANMsg)temporaryData.get(TEMPLATE_ID_EKK0161B004);
		
		// サービス契約回線内訳番号を取得
		String svcKeiKaiseucwkNo = getNullToStr(ekk0341a010Msg.getString(EKK0341A010CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO));
		String svcKeiKaiseucwkGadtm = "";
		
		// サービス契約回線内訳番号が設定されている場合
		if(!"".equals(svcKeiKaiseucwkNo))
		{
			// サービス契約回線内訳を取得
			CAANMsg ekk0251a010Msg = execEKK0251A010(handle, scCall, param, dataMapKey, svcKeiKaiseucwkNo);
			
			// サービス契約回線内訳.世代登録年月日を取得			
			svcKeiKaiseucwkGadtm = ekk0251a010Msg.getString(EKK0251A010CBSMsg1List.GENE_ADD_DTM);
		}
		
		// ***** EKK1551D010（オーダ情報作成ワーク登録）*****
		Object [][] ekk1551d010IN = {
				{EKK1551D010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK1551D010},
				{EKK1551D010CBSMsg.FUNC_CODE, ccMsg.get("func_code")},
				{EKK1551D010CBSMsg.ODR_HAKKO_JOKEN_NO, ekk1081d010Msg.getString(EKK1081D010CBSMsg.ODR_HAKKO_JOKEN_NO)},
				{EKK1551D010CBSMsg.ODR_NAIYO_CD, ekk1551d010Map.get(EKK1551D010CBSMsg.ODR_NAIYO_CD)},
				{EKK1551D010CBSMsg.SVC_KEI_NO, ekk0081a010Msg.getString(EKK0341A010CBSMsg1List.SVC_KEI_NO)},
				{EKK1551D010CBSMsg.SVKEI_GADTM, ekk0081a010Msg.getString(EKK0081A010CBSMsg1List.GENE_ADD_DTM)},
				{EKK1551D010CBSMsg.SVC_KEI_UCWK_NO, ekk0161b004Msg.getString(EKK0161B004CBSMsg1List.SVC_KEI_UCWK_NO)}, 
				{EKK1551D010CBSMsg.SVKEIUW_GADTM, ekk0161b004Msg.getString(EKK0161B004CBSMsg1List.GENE_ADD_DTM)}, 
				{EKK1551D010CBSMsg.KKTK_SVC_KEI_NO, ekk0341a010Msg.getString(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO)},
				{EKK1551D010CBSMsg.KKTSVKEI_GADTM, ekk0341a010Msg.getString(EKK0341A010CBSMsg1List.GENE_ADD_DTM)},
				{EKK1551D010CBSMsg.OP_SVC_KEI_NO, ""},
				{EKK1551D010CBSMsg.OPSVKEI_GADTM, ""},
				{EKK1551D010CBSMsg.SBOP_SVC_KEI_NO, ""},
				{EKK1551D010CBSMsg.SBOPSVKEI_GADTM, ""},
				{EKK1551D010CBSMsg.SEIOPSVC_KEI_NO, ""},
				{EKK1551D010CBSMsg.SEIOPSVKEI_GADTM, ""},
				{EKK1551D010CBSMsg.HUKA_INF_KEI_NO, ekk0341a010Msg.getString(EKK0341A010CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO)},
				{EKK1551D010CBSMsg.HUKA_INF_KEI_GADTM, svcKeiKaiseucwkGadtm},
				{EKK1551D010CBSMsg.CHBF_SVKEI_GADTM, ""},
				{EKK1551D010CBSMsg.CHBF_SVKEIUW_GADTM, ""},
				{EKK1551D010CBSMsg.CHBF_KKTSVKEI_GADTM, ""},
				{EKK1551D010CBSMsg.CHBF_OPSVKEI_GADTM, ""},
				{EKK1551D010CBSMsg.CHBF_SBOPSVKEI_GADTM, ""},
				{EKK1551D010CBSMsg.CHBF_SEIOPSVKEI_GADTM, ""},
				{EKK1551D010CBSMsg.KKOP_SVC_KEI_NO_1, ""},
				{EKK1551D010CBSMsg.KKOSVKEI_GADTM_1, ""},
				{EKK1551D010CBSMsg.CHBF_KKOSVKEI_GADTM_1, ""},
				{EKK1551D010CBSMsg.KKOP_SVC_KEI_NO_2, ""},
				{EKK1551D010CBSMsg.KKOSVKEI_GADTM_2, ""},
				{EKK1551D010CBSMsg.CHBF_KKOSVKEI_GADTM_2, ""},
		};
		// 更新処理の実行
		callSC(handle, scCall, param, dataMapKey, ekk1551d010IN);
	}
	/**
	 * サービス契約回線内訳一意照会の実行
	 * <br>
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param svc_kei_kaisen_ucwk_no
	 * @return
	 * @throws Throwable
	 */
	private CAANMsg execEKK0251A010(SessionHandle handle,
										ServiceComponentRequestInvoker scCall,
										IRequestParameterReadWrite param,
										String dataMapKey,
										String svc_kei_kaisen_ucwk_no) throws Throwable
	{
		// ***** EKK0251A010（サービス契約回線内訳一意照会）*****
		Object[][] ekk0251a010IN = {
				{ EKK0251A010CBSMsg.TEMPLATEID,                  TEMPLATE_ID_EKK0251A010 }, 
				{ EKK0251A010CBSMsg.FUNC_CODE,                   FUNC_CODE_2 },
				{ EKK0251A010CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO,  svc_kei_kaisen_ucwk_no },
				{ EKK0251A010CBSMsg.KEY_GENE_ADD_DTM,            ""},
		};
		
		// サービスインターフェースの実行
		CAANMsg ekk0251a010cbsMsg = callSC(handle, scCall, param, dataMapKey, ekk0251a010IN).getCAANMsgList(EKK0251A010CBSMsg.EKK0251A010CBSMSG1LIST)[0];
		
		return ekk0251a010cbsMsg;
	}
	
	/**
	 * EKK1081C011_同一処理番号採番を実行します。
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @return CAANMsg
	 * @throws Throwable
	 */
	private CAANMsg execEKK1081C011(SessionHandle handle, 
										ServiceComponentRequestInvoker scCall, 
										IRequestParameterReadWrite param, 
										String dataMapKey,
										HashMap<String, Object> temporaryData) throws Throwable
	{
		
		// ***** EKK1081C011（同一処理番号採番）*****
		// 機能コード"1"固定
		Object[][] ekk1081c011IN = {
				{EKK1081C011CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK1081C011},
				{EKK1081C011CBSMsg.FUNC_CODE, FUNC_CODE_1},
		};
		
		// 実行結果を返す。
		return callSC(handle, scCall, param, dataMapKey, ekk1081c011IN);
	}
	
	
	/**
	 * 登録SOD発行メソッド
	 * <br>
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @throws Throwable 
	 */
	private void execSodHakkoCreate(SessionHandle handle, 
										ServiceComponentRequestInvoker scCall, 
										IRequestParameterReadWrite param, 
										String dataMapKey,
										HashMap<String, Object> temporaryData) throws Throwable
	{
		
		// 同一処理番号採番
		CAANMsg ekk1081c011Msg = execEKK1081C011(handle, scCall, param, dataMapKey, temporaryData);
		temporaryData.put(TEMPLATE_ID_EKK1081C011, ekk1081c011Msg);
		
		// オーダ発行条件登録情報作成
		HashMap<String, String> ekk1081d010Map = new HashMap<String, String>();
		// オーダー種別コード
		ekk1081d010Map.put(EKK1081D010CBSMsg.ORDER_SBT_CD, ORDER_SBT_CD_1);
		// サービスオーダコード
		ekk1081d010Map.put(EKK1081D010CBSMsg.SVC_ORDER_CD, SVC_ORDER_CD_0A);
		// 要求種別コード
		ekk1081d010Map.put(EKK1081D010CBSMsg.YOKYU_SBT_CD, YOKYU_SBT_CD_04);
		// オーダ発行条件コード
		ekk1081d010Map.put(EKK1081D010CBSMsg.ODR_HAKKO_JOKEN_CD, ODR_HAKKO_JOKEN_CD_01);
		
		// オーダ発行条件登録
		CAANMsg ekk1081d010Msg = execEKK1081D010(handle, scCall, param, dataMapKey, temporaryData, ekk1081d010Map);
		temporaryData.put(TEMPLATE_ID_EKK1081D010, ekk1081d010Msg);
		
		// オーダ情報作成ワーク登録情報作成
		HashMap<String, String> ekk1551d010Map = new HashMap<String, String>();
		// オーダ内容コード
		ekk1551d010Map.put(EKK1551D010CBSMsg.ODR_NAIYO_CD, ODR_NAIYO_CD_163);
		
		// オーダ情報作成ワーク登録
		execEKK1551D010(handle, scCall, param, dataMapKey, temporaryData, ekk1551d010Map);
		
	}
	
	/**
	 * オーダ発行条件のオーダの存在チェックを行います。
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param fixedText
	 * @param svcKeiNo
	 * 
	 * @return boolean
	 */
	private boolean isOdrHakkoJoken(SessionHandle handle,
										ServiceComponentRequestInvoker scCall,
										IRequestParameterReadWrite param,
										String fixedText,
										String kktkSvcKeiNo,
										String orderSbtCd,
										String yokyuSbtCd,
										String svcOrderCd) throws Exception{
		
		// 上りマッピング処理
		Object[][] ekk1081b001InMsg = {{EKK1081B001CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK1081B001},
										{EKK1081B001CBSMsg.FUNC_CODE, FUNC_CODE_1},
										{EKK1081B001CBSMsg.KEY_KKTK_SVC_KEI_NO, kktkSvcKeiNo},
										{EKK1081B001CBSMsg.KEY_ORDER_SBT_CD, orderSbtCd},
										{EKK1081B001CBSMsg.KEY_YOKYU_SBT_CD, yokyuSbtCd},
										{EKK1081B001CBSMsg.KEY_SVC_ORDER_CD, svcOrderCd}};
		
		// SC呼出実行
		CAANMsg[] ekk1081b001outMsg = callSC(handle,
											scCall,
											param,
											fixedText,
											ekk1081b001InMsg).getCAANMsgList(EKK1081B001CBSMsg.EKK1081B001CBSMSG1LIST);
		
		// オーダの存在チェック
		if (ekk1081b001outMsg != null && ekk1081b001outMsg.length != 0){
			return true;
		}
		else
		{
			return false;
		}
	}
	// ++++++++++ v10.00.00 追加終了 ++++++++++ //
}