/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：物流管理システム
*   ソースファイル名：JDKCommon11CC.java
*   作成者          ：富士通
*   日付            ：2011年11月09日
*＜機能概要＞
*   配送完了実績登録CCクラスです。
*＜修正履歴＞
*   バージョン  修正日       修正者      修正内容
*   v1.00.00    2011/11/09   FJ          新規作成
*   v3.00.00    2013/04/17   下原        ANK-0316-00-00、ANK-0342-00-00、ANK-0319-00-00
*   v5.00.00    2013/10/16   山口        OM-2013-0002900
*   v5.00.01    2013/10/17   山口        OM-2013-0003388
*   v16.00.00   2016/02/08   柿坂        OM-2016-0000146
*   v38.00.00   2018/08/06   FJ)謝       【ANK-3274-00-00】【機能改善】工事会社出荷時の機器状態チェック条件の見直し
*   v39.00.00   2018/12/03   FJ)原田     【OM-2018-0001182】 サービスに紐付く機器の世代登録年月日クリア処理追加対応
*   v48.00.00   2019/10/09   FJ)謝       【ANK-3736-00-00】【eo】宅内機器管理機能の適正化に伴うOPMS／MUSe連携データのレイアウト変更
*
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.HashSet;
import java.util.List;
import java.util.Map;

import com.fujitsu.futurity.bp.custom.constant.DKSV0076_DKSV0076OP_DKSV007601CC_EDK0011C080CBSMsg1List;
import com.fujitsu.futurity.bp.custom.constant.DKSV0076_DKSV0076OP_DKSV007602CC;
import com.fujitsu.futurity.bp.custom.constant.DKSV0076_DKSV0076OP_work;
import com.fujitsu.futurity.bp.custom.constant.DKSV0076_DKSV0076OP_work_workList;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0076_DKSV0076OP_EDK0011C080BSMapper;
//import com.fujitsu.futurity.bp.custom.mapping.DKSV0076_DKSV0076OP_EDK0301D010BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0076_DKSV0076OP_EDK0011C100BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0076_DKSV0076OP_EDKA0010008BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0076_DKSV0076OP_EKK0121C041BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0076_DKSV0076OP_EKK0161B004BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0076_DKSV0076OP_EKK0201C051BSMapper;
//import com.fujitsu.futurity.bp.custom.mapping.DKSV0076_DKSV0076OP_EKK0341B503BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0076_DKSV0076OP_EKK0341C040BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0076_DKSV0076OP_EKK0341C060BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0076_DKSV0076OP_EKK1091D010BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0076_DKSV0076OP_EKK1131B001BSMapper;
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 com.fujitsu.futurity.model.ejb.common.JSYejbLog;
import com.fujitsu.futurity.model.ejb.common.StatusCodes;

import eo.common.constant.JDKStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.util.JDKCommonUtil;
import eo.ejb.cbs.cbsmsg.EDK0011C080CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EDK0021B020CBSMsg;
import eo.ejb.cbs.cbsmsg.EDK0021B020CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EDKA0010003CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EDKA0010008CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0121C041CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0161B004CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0201C051CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1131B001CBSMsg;



/**
 * 配送完了実績登録CCクラスです。
 * @author 富士通
 */
public class JDKCommon11CC extends AbstractCommonComponent
{
	/** CC名 */
	private static final String DKSV007601CC = "DKSV007601CC";
	private static final String DKSV007602CC = "DKSV007602CC";
//	private static final String DKSV007604CC = "DKSV007604CC";
	private static final String DKSV007605CC = "DKSV007605CC";
// ANK-3736-00-00 ADD START
	/** テンプレートID(EDK0021B020) 配送対象物品一覧照会（工事案件番号）*/
	private static final String TEMPLATE_ID_EDK0021B020 = "EDK0021B020";
// ANK-3736-00-00 ADD END

	/** 配送完了実績登録マッパー */
	private static final DKSV0076_DKSV0076OP_EDK0011C080BSMapper HAISOFIN_JSSKADD_MAPPER = new DKSV0076_DKSV0076OP_EDK0011C080BSMapper();
	
	
//	/** レンタル */
//	private static final String RENTAL = "02";
//	/** 機種機器変更 */
//	private static final String MODEL_KIKI_CHANGE = "00028";

	/**
	 * 配送完了実績登録処理を行います。
	 * @param handle セッションハンドル
	 * @param param パラメータ
	 * @param fixedText 定型文字
	 * @return パラメータ
	 * @throws Throwable 
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite createHaisoFinJseki(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// 
		Map dksv007601Cc = (Map)param.getData(DKSV007601CC);
// ANK-3274-00-00 ADD START
		// 機能コード
		String dksv007601CcFuncCode = (String) dksv007601Cc.get("func_code");
// ANK-3274-00-00 ADD END
// ANK-3736-00-00 ADD START
		// 登録済トムソンケース番号リスト
		HashSet<String> addZmTcaseNoList = new HashSet<String>();
// ANK-3736-00-00 ADD END
		List<HashMap> haisotbpnList = (ArrayList<HashMap>)dksv007601Cc.get("EDK0011C080CBSMsg1List");
		Map dksv007602Cc = (Map)param.getData(DKSV007602CC);
		List<HashMap> hkatList02 = (ArrayList<HashMap>)dksv007602Cc.get("hkat_list");
//		Map dksv007604Cc = (Map)param.getData(DKSV007604CC);
//		List<HashMap> hkatList04 = (ArrayList<HashMap>)dksv007604Cc.get("hkat_list");
		Map dksv007605Cc = (Map)param.getData(DKSV007605CC);
		List<HashMap> hkatList05 = (ArrayList<HashMap>)dksv007605Cc.get("hkat_list");
		
		Map<String, String> ekk0161b004Map = new HashMap<String, String> ();
		param.setData("DKSV007606CC", ekk0161b004Map);
		List<Map<String, String>> ekk0201c051List = new ArrayList<Map<String, String>> ();
		param.setData("DKSV007607CC", ekk0201c051List);
		List<Map<String, String>> ekk0121c041List = new ArrayList<Map<String, String>> ();
		param.setData("DKSV007608CC", ekk0121c041List);
		
		Map<String, String> ekk1131b001Map = new HashMap<String, String> ();
		param.setData("DKSV007609CC", ekk1131b001Map);
		List<Map<String, String>> ekk1091D0101List = new ArrayList<Map<String, String>> ();
		param.setData("DKSV007610CC", ekk1091D0101List);

		Map work =  (Map)param.getMappingWorkArea().get("work");
		List<Map> worklist = (List<Map>)work.get("workList");
		
		transportUpdDtm(param);
		
		JDKStockMap stocks = new JDKStockMap();
		String warehouse = (String)dksv007601Cc.get("soko_cd");

		JDKStructuredMap<String, String> parentStbProductNos = new JDKStructuredMap<String, String>();
		JDKStructuredMap<String, String> parentStbTypeCds = new JDKStructuredMap<String, String>();
		String lotNo = (String)dksv007601Cc.get("shukka_lot_no");
		
		// 宅内でのチェックを実施する
		DKSV0076_DKSV0076OP_EDKA0010008BSMapper takunaiMapper = new DKSV0076_DKSV0076OP_EDKA0010008BSMapper();
		HashMap takunaiKikiCondition = takunaiMapper.editInMsg(param, haisotbpnList);
		
		// 宅内機器一覧照会(5)処理の処理対象件数の取得
		String tkCnt = (String) takunaiKikiCondition.get("tkCnt");
		
		if(Integer.parseInt(tkCnt) > 0)
		{
			// 対象となるデータが存在した時だけ処理を実施
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "宅内機器一覧照会(5)処理の実行");
			Map takunaiKiki = scCall.run(takunaiKikiCondition, handle);
			takunaiMapper.editResultRP(takunaiKiki, param);
			
			if (JDKBPCommon.hasError(param))
			{
				throw new SCCallException("宅内機器一覧照会(5)処理失敗", "0", 
						Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
			
			JDKBPCommon.throwScExceptionIfHasError("宅内機器一覧照会(5)処理リターンコード不正", param);
		}

		// 配送結合処理を行う
		if (JDKStrConst.UM_FLG_U.equals((String) ((Map) param.getData("DKSV007611CC")).get("haiso_comb_flg")))
		{
			DKSV0076_DKSV0076OP_EDK0011C100BSMapper haisoCombMapper = new DKSV0076_DKSV0076OP_EDK0011C100BSMapper();
			 HashMap<String, Object> haisoCombMap = haisoCombMapper.editInMsg(param);
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "配送結合処理の実行");
			Map haisoCombResult = scCall.run(haisoCombMap, handle);
			haisoCombMapper.editResultRP(haisoCombResult, param);
			if (JDKBPCommon.hasError(param))
			{
				throw new SCCallException("配送完了実績登録処理失敗", "0", 
											Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
		}

		// EDKA0010008用のindex(製番なし機器の対応)
		int index = 0;
		
		for (int i = 0; i < haisotbpnList.size(); i++) {
			Map haisoBpnMap = (Map)haisotbpnList.get(i);
			HashMap dataMap = (HashMap)param.getData("DKSV007601CC");
			Map errorReturnMap = (Map)((List)dataMap.get("EDK0011C080CBSMsg1List")).get(i);
			String shelf = (String)haisoBpnMap.get("shelf_cd");

			// 工事会社経由の場合にトムソンケースに入力なし
			// もしくは工事会社非経由でトムソンケース入力有
			tcaseValidation(haisoBpnMap, errorReturnMap, param);
// ANK-3736-00-00 ADD START
			// 機能コードが"1"(更新モード)の場合
			if (JPCModelConstant.FUNC_CD_1.equals(dksv007601CcFuncCode))
			{
				// 登録済トムソンケース番号リストを取得する(初回のみ取得)
				if (i == 0)
				{
					addZmTcaseNoList = callHaisoTgBpinIcrnKojiakNo(handle, scCall, param, fixedText, haisoBpnMap);
				}
				
				// 工事会社経由の場合
				if (!JDKCommonUtil.isNull(haisoBpnMap.get("koji_comp_cd")))
				{
					// トムソンケース番号は既に登録されている場合はエラー
					if (addZmTcaseNoList.contains((String)haisoBpnMap.get("tcase_no")))
					{
						errorReturnMap.put(EDK0011C080CBSMsg1List.KEY_HAISO_TAIBPIN_NO_ERR, "ET");
						errorReturnMap.put("returnCode", "1100");
						JDKBPCommon.addError(param, EDK0011C080CBSMsg1List.TCASE_NO_ERR, "ET", "EDK0011C080", StatusCodes.RELATION_ERR, 1100);
						throw new SCCallException("入力されたトムソンケース番号は既に登録されている", "0", 
								Integer.parseInt(param.getControlMapData("returnCode").toString()));
					}
				}
			}
// ANK-3736-00-00 ADD END
			
			// 進捗情報異動理由一覧照会サービスインターフェイスの呼び出し
			callShinchokuJohoIdoRiyuItiran(haisoBpnMap, worklist, param, handle);
			// 進捗登録への入力作成
			makeEKK1091D010Input(ekk1091D0101List, haisoBpnMap, (HashMap)param.getData("DKSV007609CC"));
			
			// 進捗登録情報を作り終えたら、異動理由の情報をクリアする(前行の情報を残した場合、次行で取得できなくても前行のデータが残っている為)
			HashMap inMap = (HashMap)param.getData("DKSV007609CC");
			inMap.remove("EKK1131B001CBSMSG1LIST");
			
			// BCASとCCASの上位機種製造番号を決めるために出荷ロット番号とトムソンケース番号を元にSTBの製番を収集する
			if (JDKStrConst.STB.equals(haisotbpnList.get(i).get("taknkiki_sbt_cd").toString()))
			{
				String productNo = haisotbpnList.get(i).get("kiki_seizo_no").toString();
				String typeCd = haisotbpnList.get(i).get("taknkiki_model_cd").toString();
				String tomsonCaseNo = haisotbpnList.get(i).get("tcase_no").toString();

				parentStbProductNos.setValue(productNo, lotNo, tomsonCaseNo);
				parentStbTypeCds.setValue(typeCd, lotNo, tomsonCaseNo);
			}
			
			// 製造番号無は宅内にデータがないので以降のチェックを実施しない
			if (JDKCommonUtil.isNull(haisoBpnMap.get(EDK0011C080CBSMsg1List.KIKI_SEIZO_NO)))
			{
				continue;
			}
			
			// 宅内になければエラー
			 Map takunaiInfo = getTakunaiInfo((String)haisoBpnMap.get(EDK0011C080CBSMsg1List.TAKNKIKI_MODEL_CD), 
												(String)haisoBpnMap.get(EDK0011C080CBSMsg1List.KIKI_SEIZO_NO), dataMap);
			if (takunaiInfo == null
				|| (((List)dataMap.get(EDKA0010008CBSMsg1List.class.getName())).size() == 0)) {
				errorReturnMap.put(EDK0011C080CBSMsg1List.KEY_HAISO_TAIBPIN_NO_ERR, "EF");
				errorReturnMap.put("returnCode", "1100");
				JDKBPCommon.addError(param, EDKA0010008CBSMsg1List.KK_SEIZO_NO, "EF", "EDKA0010008", StatusCodes.RELATION_ERR, 1100);
				throw new SCCallException("宅内に機器情報が存在しない", "0", 
											Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
			
			Map data = (Map)((List)dataMap.get(EDKA0010008CBSMsg1List.class.getName())).get(index);
			
			// 移動元管理場所識別コードが工事会社以外の場合
			if (!JDKStrConst.KANRI_PLACE_SKB_KOJI.equals(haisotbpnList.get(i).get("idomoto_kriplace_skcd")))
			{
				// KOPT所有でない場合はエラー
				if (JDKStrConst.OWNED_BY_OTHER.equals(data.get(EDKA0010008CBSMsg1List.SHOYU_CD)))
				{
					errorReturnMap.put(EDK0011C080CBSMsg1List.KEY_HAISO_TAIBPIN_NO_ERR, "EJ");
					errorReturnMap.put("returnCode", "1100");
					JDKBPCommon.addError(param, EDKA0010008CBSMsg1List.KK_SEIZO_NO, "EJ", "EDKA0010008", StatusCodes.RELATION_ERR, 1100);
					throw new SCCallException("機器がKOPT所有ではない", "0", 
							Integer.parseInt(param.getControlMapData("returnCode").toString()));
				}
				
				// 宅内機器ステータスが破棄であればエラー
				if (JDKStrConst.KAIYAKU.equals(data.get(EDKA0010008CBSMsg1List.TK_STAT)))
				{
					errorReturnMap.put(EDK0011C080CBSMsg1List.KEY_HAISO_TAIBPIN_NO_ERR, "EK");
					errorReturnMap.put("returnCode", "1100");
					JDKBPCommon.addError(param, EDKA0010008CBSMsg1List.KK_SEIZO_NO, "EK", "EDKA0010008", StatusCodes.RELATION_ERR, 1100);
					throw new SCCallException("宅内機器ステータスが破棄である", "0", 
							Integer.parseInt(param.getControlMapData("returnCode").toString()));
				}
				
				// 宅内機器ステータスが設置(使用中)であればエラー
				if (JDKStrConst.SHIYOCHU.equals(data.get(EDKA0010008CBSMsg1List.TK_STAT)))
				{
					errorReturnMap.put(EDK0011C080CBSMsg1List.KEY_HAISO_TAIBPIN_NO_ERR, "EL");
					errorReturnMap.put("returnCode", "1100");
					JDKBPCommon.addError(param, EDKA0010008CBSMsg1List.KK_SEIZO_NO, "EL", "EDKA0010008", StatusCodes.RELATION_ERR, 1100);
					throw new SCCallException("宅内機器ステータスが設置(使用中)である", "0", 
							Integer.parseInt(param.getControlMapData("returnCode").toString()));
				}
				
				
				// 棚移動予約フラグが予約済であればエラー
				if (JDKStrConst.SLF_MV_RSV_FLG_ON.equals(data.get(EDKA0010008CBSMsg1List.SLF_MV_RSV_FLG)))
				{
					errorReturnMap.put(EDK0011C080CBSMsg1List.KEY_HAISO_TAIBPIN_NO_ERR, "EQ");
					errorReturnMap.put("returnCode", "1100");
					JDKBPCommon.addError(param, EDKA0010008CBSMsg1List.KK_SEIZO_NO, "EQ", "EDKA0010008", StatusCodes.RELATION_ERR, 1100);
					throw new SCCallException("棚移動予約フラグが予約済である", "0", 
							Integer.parseInt(param.getControlMapData("returnCode").toString()));
				}
				
				// 出荷元の倉庫・棚に出荷する機器が存在しない場合はエラー
				String shelfCd = haisotbpnList.get(i).get("shelf_cd").toString();
				
				if (!warehouse.equals(data.get(EDKA0010008CBSMsg1List.KNRI_PLC_CD)) || !shelfCd.equals(data.get(EDKA0010008CBSMsg1List.KNRI_PLC_SLF_CD)))
				{
					errorReturnMap.put(EDK0011C080CBSMsg1List.KEY_HAISO_TAIBPIN_NO_ERR, "ER");
					errorReturnMap.put("returnCode", "1100");
					JDKBPCommon.addError(param, EDKA0010008CBSMsg1List.KK_SEIZO_NO, "ER", "EDKA0010008", StatusCodes.RELATION_ERR, 1100);
					throw new SCCallException("出荷元の倉庫・棚に出荷する機器が存在しない", "0", 
							Integer.parseInt(param.getControlMapData("returnCode").toString()));
				}
			}
			
//			// 個別機器出荷の場合、セット品だとエラー
//			if (JDKCommonUtil.isNull(haisoBpnMap.get(EDK0011C080CBSMsg1List.TAKNKIKI_SETHIN_MODEL_CD))
//				&& !JDKCommonUtil.isNull(takunaiInfo.get(EDKA0010008CBSMsg1List.TK_SETHN_NO)))
//			{
//				errorReturnMap.put(EDK0011C080CBSMsg1List.KEY_HAISO_TAIBPIN_NO_ERR, "EM");
//				errorReturnMap.put("returnCode", "1100");
//				JDKBPCommon.addError(param, EDKA0010008CBSMsg1List.KK_SEIZO_NO, "EM", "EDKA0010008", StatusCodes.RELATION_ERR, 1100);
//				throw new SCCallException("個別機器出荷の場合、セット品だとエラー", "0", 
//						Integer.parseInt(param.getControlMapData("returnCode").toString()));
//			}

			// MACアドレス有機器の場合、MACアドレス未設定だとエラー
			String macAddress = haisoBpnMap.containsKey("mac_inf_um") ? haisoBpnMap.get("mac_inf_um").toString() : null;
			if (JDKStrConst.UM_FLG_U.equals(macAddress) && JDKCommonUtil.isNull(data.get(EDKA0010008CBSMsg1List.MAC_AD)))
			{
				errorReturnMap.put(EDK0011C080CBSMsg1List.KEY_HAISO_TAIBPIN_NO_ERR, "EN");
				errorReturnMap.put("returnCode", "1100");
				JDKBPCommon.addError(param, EDKA0010008CBSMsg1List.KK_SEIZO_NO, "EN", "EDKA0010008", StatusCodes.RELATION_ERR, 1100);
				throw new SCCallException("MACアドレス未設定", "0", 
						Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
			
			String idomotoKriplaceSkcd = (String)haisoBpnMap.get(DKSV0076_DKSV0076OP_DKSV007601CC_EDK0011C080CBSMsg1List.IDOMOTO_KRIPLACE_SKCD);
			//移動元管理場所識別コードが2(工事会社)以外の場合のみ、在庫チェックを行う
			if (!JDKStrConst.KANRI_PLACE_SKB_KOJI.equals(idomotoKriplaceSkcd))
			{
				// 在庫のチェック
				String modelNo = (String)data.get(EDKA0010008CBSMsg1List.TK_MDL_CD);
				String [] keies = {warehouse, shelf, modelNo, idomotoKriplaceSkcd};
				
				Integer moves = Integer.parseInt(haisoBpnMap.get("cnt").toString());
				
				if (!stocks.hasKey(keies)) {
					// 宅内機器物流在庫一意照会(EKKA0020005)を実行し、在庫情報を得る
					stocks.setValue(JDKBPCommon.getStockAmount(warehouse, shelf, modelNo, idomotoKriplaceSkcd, handle, param), keies);
				}
				stocks.decrease(moves, keies);
				
				// 在庫不足の場合エラー
				data.put("output_kyoka", stocks.isNegative(keies) ? 0L : 1L);
				if (stocks.isNegative(keies))
				{
					errorReturnMap.put(EDK0011C080CBSMsg1List.KEY_HAISO_TAIBPIN_NO_ERR, "EO");
					errorReturnMap.put("returnCode", "1100");
					JDKBPCommon.addError(param, EDKA0010008CBSMsg1List.KK_SEIZO_NO, "EO", "EDKA0010008", StatusCodes.RELATION_ERR, 1100);
					throw new SCCallException("在庫不足", "0", 
							Integer.parseInt(param.getControlMapData("returnCode").toString()));
				}
			}
// ANK-3274-00-00 ADD START
			// 機能コードが"1"(更新モード)の場合、かつ移動元管理場所識別コードが工事会社の場合
			if (JPCModelConstant.FUNC_CD_1.equals(dksv007601CcFuncCode) && JDKStrConst.KANRI_PLACE_SKB_KOJI.equals(idomotoKriplaceSkcd))
			{
				// 廃棄棚であればエラー
				if (JDKStrConst.HAIKI_TANA.equals(data.get(EDKA0010008CBSMsg1List.KNRI_PLC_SLF_CD)))
				{
					errorReturnMap.put(EDK0011C080CBSMsg1List.KEY_HAISO_TAIBPIN_NO_ERR, "ES");
					errorReturnMap.put("returnCode", "1100");
					JDKBPCommon.addError(param, EDKA0010008CBSMsg1List.KK_SEIZO_NO, "ES", "EDKA0010008", StatusCodes.RELATION_ERR, 1100);
					throw new SCCallException("工事会社からの出荷で、廃棄棚が指定されている", "0", 
							Integer.parseInt(param.getControlMapData("returnCode").toString()));
				}
			}
// ANK-3274-00-00 ADD END
			
			// サービス契約内訳一覧照会サービスインターフェイスの呼び出し
			callKeiyakuUchiwakeItiran(haisoBpnMap, worklist, param, handle);
			
			Map<String, String> kikiKakutei1Map = (Map<String, String>)hkatList02.get(0);
			
			// サービス契約<eoモバイル>情報変更（事業者用契約）への入力作成
			makeEKK0121C041Input(ekk0121c041List, haisoBpnMap, takunaiInfo, kikiKakutei1Map, worklist);
			
			// サービス契約<eoモバイル>情報変更(事業者用契約)実行
			if (ekk0121c041List.size() != 0)
			{
				doEKK0121C041(ekk0121c041List, handle, param);
				// 更新処理を実行後のデータは除去する(必ず処理対象は１件にするため)
				ekk0121c041List.remove(0);
			}
			
			// サービス契約内訳<eoモバイル>情報変更（ＵＱ認証）への入力作成
			makeEKK0201C051Input(ekk0201c051List, haisoBpnMap, takunaiInfo, kikiKakutei1Map, (HashMap)param.getData("DKSV007606CC"));

			// サービス契約内訳＜eoモバイル＞情報変更（ＵＱ認証）実行
			if (ekk0201c051List.size() != 0)
			{
				doEKK0201C051(ekk0201c051List, handle, param);
				// 更新処理を実行後のデータは除去する(必ず処理対象は１件にするため)
				ekk0201c051List.remove(0);
			}
			
			index = index + 1;
		}
		
		// 進捗登録実行
		doEKK1091D0101(ekk1091D0101List, handle, param);

		// 配送完了実績登録処理を行う
		HashMap<String, Object> contractsParamMap = new HashMap<String, Object>();
		Map contractResult = null;
		if (!"2".equals(dksv007601Cc.get("func_code")))
		{
			contractsParamMap = HAISOFIN_JSSKADD_MAPPER.editInMsg(param);
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "配送完了実績登録処理の実行");
			contractResult = scCall.run(contractsParamMap, handle);
			HAISOFIN_JSSKADD_MAPPER.editResultRP(contractResult, param);
			if (JDKBPCommon.hasError(param))
			{
				throw new SCCallException("配送完了実績登録処理失敗", "0", 
											Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
		}
		
		HashMap upDtmMap = new HashMap();
		// 配送対象物品明細の件数分ループ
		for (int i = 0; i < haisotbpnList.size(); i++)
		{
			String svcKeiNo = (String)haisotbpnList.get(i).get("svc_kei_no");
			haisotbpnList.get(i).put("gds_stat_cd", hkatList05.get(i).get("gds_stat_cd"));
			
			//OM-2016-0000146 ADD START
			// 回線に紐付く機器の世代登録年月日時分秒のクリア
			List<Map> workListTmp = (List<Map>)param.getMappingWorkArea().get("workList");
			if ((null != workListTmp) && !workListTmp.isEmpty())
			{
				Map workTmp = workListTmp.get(0);
				if(workTmp.containsKey("gene_add_dtm"))
				{
					workTmp.put("gene_add_dtm",null);
				}
			}
			//OM-2016-0000146 ADD END
// OM-2018-0001182 ADD START
			// サービスに紐付く機器の世代登録年月日時分秒のクリア
			List<Map> workMapTemp = (List<Map>)param.getMappingWorkArea().get(svcKeiNo);
			if ((null != workMapTemp) && !workMapTemp.isEmpty())
			{
				Map workTmp = workMapTemp.get(0);
				if(workTmp.containsKey("gene_add_dtm"))
				{
					workTmp.put("gene_add_dtm",null);
				}
			}
// OM-2018-0001182 ADD END
			// 退避データが存在する場合更新年月日時分秒（更新前）に値を設定
			if (upDtmMap.containsKey(svcKeiNo))
			{
				hkatList02.get(i).put("upd_dtm_bf", (String)upDtmMap.get(svcKeiNo));
			}
			
			String funcCode = (String) hkatList02.get(0).get("func_code");
			
			// 機能コードが２(チェックのみ)の時は、機器提供サービス契約の排他エラーとなる為、機器提供サービス契約締結処理を呼ばない
			// 機能コードが２(チェックのみ)の時は、機器提供サービス契約ステータスでエラーとなる為、機器提供サービス契約宅内機器確定処理を呼ばない
			if (!"2".equals(funcCode))
			{
				// 機器提供サービス契約ステータスが"020"(照査済)の場合
				if (JDKStrConst.SVC_KEI_STAT_SHOSA.equals((String)haisotbpnList.get(i).get("kktk_svc_kei_stat")))
				{
					// 機器提供サービス契約締結処理を行う
					DKSV0076_DKSV0076OP_EKK0341C040BSMapper KKTKYSVCKEI_CONCLUSION_MAPPER = new DKSV0076_DKSV0076OP_EKK0341C040BSMapper();
					KKTKYSVCKEI_CONCLUSION_MAPPER.setParamInMap(hkatList02.get(i));
					contractsParamMap = KKTKYSVCKEI_CONCLUSION_MAPPER.editInMsg(param);
					JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "機器提供サービス契約締結処理の実行");
					contractResult = scCall.run(contractsParamMap, handle);
					KKTKYSVCKEI_CONCLUSION_MAPPER.editResultRP(contractResult, param);
					if (JDKBPCommon.hasError(param))
					{
						throw new SCCallException("機器提供サービス契約締結処理失敗", "0", 
													Integer.parseInt(param.getControlMapData("returnCode").toString()));
					}
				}
				
				// 機器提供サービス契約宅内機器確定処理を行う
				DKSV0076_DKSV0076OP_EKK0341C060BSMapper KKTKYSVCKEI_TKNIKK_DEFINITION_MAPPER = new DKSV0076_DKSV0076OP_EKK0341C060BSMapper();
				KKTKYSVCKEI_TKNIKK_DEFINITION_MAPPER.setParamInMap(hkatList02.get(i));
				contractsParamMap = KKTKYSVCKEI_TKNIKK_DEFINITION_MAPPER.editInMsg(param);
				JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "機器提供サービス契約宅内機器確定処理の実行");
				contractResult = scCall.run(contractsParamMap, handle);
				KKTKYSVCKEI_TKNIKK_DEFINITION_MAPPER.editResultRP(contractResult, param);
				if (JDKBPCommon.hasError(param))
				{
					throw new SCCallException("機器提供サービス契約宅内機器確定処理失敗", "0", 
												Integer.parseInt(param.getControlMapData("returnCode").toString()));
				}
			}

			// 更新年月日時分秒を退避
			HashMap dataMap = (HashMap)param.getData("DKSV007602CC");
			upDtmMap.put(svcKeiNo, dataMap.get("upd_dtm"));
			

//			String kktkSbt = (String)haisotbpnList.get(i).get("kktk_sbt_cd");
//			String addKykIdoKbn = (String)haisotbpnList.get(i).get("add_optnty_kei_ido_div");
//			// 機器提供種別コードが"02"(レンタル)で、かつ登録契機契約異動区分が"00028"(機器機種変更)の場合
//			if ((!JDKCommonUtil.isNull(kktkSbt) && RENTAL.equals(kktkSbt)) && 
//					(!JDKCommonUtil.isNull(addKykIdoKbn) && MODEL_KIKI_CHANGE.equals(addKykIdoKbn)))
//			{
//				// 機種変更旧機器一覧照会を行う
//				DKSV0076_DKSV0076OP_EKK0341B503BSMapper KSYHENKO_OLDKK_SEARCH_MAPPER = new DKSV0076_DKSV0076OP_EKK0341B503BSMapper();
//				KSYHENKO_OLDKK_SEARCH_MAPPER.setParamInMap(hkatList04.get(i));
//				contractsParamMap = KSYHENKO_OLDKK_SEARCH_MAPPER.editInMsg(param);
//				JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "機種変更旧機器一覧照会処理の実行");
//				contractResult = scCall.run(contractsParamMap, handle);
//				KSYHENKO_OLDKK_SEARCH_MAPPER.editResultRP(contractResult, param);
//				if (JDKBPCommon.hasError(param))
//				{
//					throw new SCCallException("機種変更旧機器一覧照会処理失敗", "0", 
//												Integer.parseInt(param.getControlMapData("returnCode").toString()));
//				}
//
//				// 返品機器受付処理を行う
//				// 機種変更旧機器一覧照会で取得した値を設定（※１件しか返却されない）
//				Map itiranMap = (Map)param.getData(DKSV007604CC);
//				List<HashMap> itiranList = (ArrayList<HashMap>)itiranMap.get("EKK0341B503CBSMsg1List");
//				HashMap map = itiranList.get(0);
//				map.put("taknkiki_model_cd", (String)map.get("taknkiki_model_cd"));
//				map.put("kiki_seizo_no", (String)map.get("kiki_seizo_no"));
//				map.put("huzokuhin_model_cd", (String)map.get("huzokuhin_model_cd"));
//				map.put("tk_sbt_cd", (String)map.get("tk_sbt_cd"));
//				map.put("kiki_chg_no", (String)map.get("kiki_chg_no"));
//				hkatList05.get(i).putAll(map);
//
//				DKSV0076_DKSV0076OP_EDK0301D010BSMapper HNPNKK_RECEPT_MAPPER = new DKSV0076_DKSV0076OP_EDK0301D010BSMapper();
//				HNPNKK_RECEPT_MAPPER.setParamInMap(hkatList05.get(i));
//				contractsParamMap = HNPNKK_RECEPT_MAPPER.editInMsg(param);
//				JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "返品機器受付処理の実行");
//				contractResult = scCall.run(contractsParamMap, handle);
//				HNPNKK_RECEPT_MAPPER.editResultRP(contractResult, param);
//				if (JDKBPCommon.hasError(param))
//				{
//					throw new SCCallException("返品機器受付処理失敗", "0", 
//												Integer.parseInt(param.getControlMapData("returnCode").toString()));
//				}
//			}
		}
		
		// EDKA0010008用のindex(製番なし機器の対応)
		index = 0;
		
		List<Map> buppins = new ArrayList<Map>();
		// 機器出荷情報更新を使用し、宅内のデータを更新する
		for (int i = 0; i < haisotbpnList.size(); i++)
		{
			Map buppin = haisotbpnList.get(i);
			
			if (JDKStrConst.KANRI_PLACE_SKB_KOJI.equals(buppin.get("idomoto_kriplace_skcd")) && "".equals(buppin.get("kiki_seizo_no")))
			{
				// 移動元管理場所識別コードが"2"(工事会社)かつ製番なし機器の場合、機器出荷情報更新(EDKA0010003)の処理対象外とする
				continue;
			}
			
			String shelf = (String)buppin.get("shelf_cd");
			
			if (isBCASorCCAS(buppin))
			{
				if (JDKCommonUtil.isNull(hkatList05.get(i).get("koji_comp_cd")))
				{
					// 宅内機器一覧照会(5)で取得した情報を設定する
					HashMap dataMap = (HashMap)param.getData("DKSV007601CC");
					Map data = (Map)((List)dataMap.get(EDKA0010008CBSMsg1List.class.getName())).get(index);
					
					// 上位機器製造番号
					buppin.put("joi_kk_seizo_no", data.get(EDKA0010008CBSMsg1List.JOI_KK_SEIZO_NO));
					// 上位宅内機器型式コード
					buppin.put("joi_tk_mdl_cd", data.get(EDKA0010008CBSMsg1List.JOI_TK_MDL_CD));
				}
				else
				{
					String parentProductNo = parentStbProductNos.getValue(lotNo, buppin.get("tcase_no").toString());
					if (parentProductNo != null) {
						// 上位機器製造番号
						buppin.put("joi_kk_seizo_no", parentProductNo);
					}
					
					String parentTypeCd = parentStbTypeCds.getValue(lotNo, buppin.get("tcase_no").toString());
					if (parentTypeCd != null) {
						// 上位宅内機器型式コード
						buppin.put("joi_tk_mdl_cd", parentTypeCd);
					}
				}
			}

			buppin.put("soko_shka_ymd", JCCBPCommon.getOpeDate(null));

			buppin.put(EDKA0010003CBSMsg1List.SHOYU_CD, "2");
			buppin.put(EDKA0010003CBSMsg1List.SETPLACE_NO, hkatList05.get(i).get("place_no"));
			// 管理場所コード（配送元）
			buppin.put(EDKA0010003CBSMsg1List.KNRI_PLC_CD, warehouse);
			
			buppin.put(EDKA0010003CBSMsg1List.KNRI_PLC_SLF_CD, shelf);
			
			buppin.put(EDKA0010003CBSMsg1List.GDS_STAT_CD, buppin.get("gds_stat_cd"));
			
			if (JDKStrConst.KANRI_PLACE_SKB_KOJI.equals(buppin.get("idomoto_kriplace_skcd")))
			{
				buppin.put(EDKA0010003CBSMsg1List.JZAIKO_NUM, "0");
				buppin.put(EDKA0010003CBSMsg1List.HAISO_UK_JUCHU_NUM, "0");
				buppin.put(EDKA0010003CBSMsg1List.TJITU_HAISO_SHKA_NUM, "0");
			}
			else
			{
				String suryo = buppin.get("cnt").toString();
				buppin.put(EDKA0010003CBSMsg1List.JZAIKO_NUM, "-" + suryo);
				buppin.put(EDKA0010003CBSMsg1List.HAISO_UK_JUCHU_NUM, "-" + suryo);
				buppin.put(EDKA0010003CBSMsg1List.TJITU_HAISO_SHKA_NUM, suryo);
			}
			
			// 配送先工事会社コード
			buppin.put(EDKA0010003CBSMsg1List.HISOS_KOCOMP_CD, hkatList05.get(i).get("koji_comp_cd"));
			
			buppins.add(buppin);
			
			// 製番なし機器ではなかった場合(製番あり機器)、indexをすすめる
			if(!"".equals(buppin.get("kiki_seizo_no")))
			{
				index = index + 1;
			}
		}
		
		// 宅内在庫更新のための連携
		work.put("buppin_list", buppins);
		
		return param;
	}

	
	/**
	 * サービス契約<eoモバイル>情報変更(事業者用契約)情報を作成する
	 * 処理対象は機器種別がH0、J0の場合のみ
	 */
	@SuppressWarnings("unchecked")
	private void makeEKK0121C041Input(List<Map<String, String>> ekk0121c041List, Map haisoBpnMap, Map takunaiInfo, Map<String, String> kikiKakutei1Map, List<Map> worklist)
	{
		if (takunaiInfo == null)
		{
			return;
		}
		String taknkikiSbtCd = (String)haisoBpnMap.get("taknkiki_sbt_cd");
		String jigyohsaKeiId = null;
		
		if ("H0".equals(taknkikiSbtCd))
		{
			jigyohsaKeiId = (String)takunaiInfo.get(EDKA0010008CBSMsg1List.EM_KSH_CD);
		}
		else if("J0".equals(taknkikiSbtCd))
		{
			jigyohsaKeiId = "F" + (String)worklist.get(0).get("jigyoshaCd") + (String)haisoBpnMap.get(DKSV0076_DKSV0076OP_DKSV007601CC_EDK0011C080CBSMsg1List.SVC_KEI_NO);
		}
		else
		{
			return;
		}
		
		JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "サービス契約<eoモバイル>情報変更(事業者用契約)情報の作成(処理対象は機器種別がH0、J0の場合)");
		Map<String, String> arg = new HashMap<String, String>();
		ekk0121c041List.add(arg);
		arg.put(EKK0121C041CBSMsg.SVC_KEI_NO, (String)haisoBpnMap.get(DKSV0076_DKSV0076OP_DKSV007601CC_EDK0011C080CBSMsg1List.SVC_KEI_NO));
		arg.put(EKK0121C041CBSMsg.MSKM_DTL_NO, (String)haisoBpnMap.get(DKSV0076_DKSV0076OP_DKSV007601CC_EDK0011C080CBSMsg1List.MSKM_DTL_NO));
		arg.put(EKK0121C041CBSMsg.IDO_DIV, (String)kikiKakutei1Map.get(DKSV0076_DKSV0076OP_DKSV007602CC.IDO_DIV));
		arg.put(EKK0121C041CBSMsg.JIGYOSHA_KEI_ID, jigyohsaKeiId);
	}
	
	/**
	 * サービス契約内訳<eoモバイル>情報変更(UQ認証)情報を作成する
	 * 処理対象は機器種別がJ0の場合のみ
	 */
	@SuppressWarnings("unchecked")
	private void makeEKK0201C051Input(List<Map<String, String>> ekk0201c051List, Map haisoBpnMap, Map takunaiInfo, Map<String, String> kikiKakutei1Map, HashMap inMap)
	{
		if (takunaiInfo == null)
		{
			return;
		}
		String taknkikiSbtCd = (String)haisoBpnMap.get("taknkiki_sbt_cd");
		if (!("J0".equals(taknkikiSbtCd)))
		{
			return;
		}
		JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "サービス契約内訳<eoモバイル>情報変更(UQ認証)情報の作成(処理対象は機器種別がJ0の場合)");
		Map<String, String> arg = new HashMap<String, String>();
		ekk0201c051List.add(arg);
		
		arg.put(EKK0201C051CBSMsg.SVC_KEI_UCWK_NO, (String)inMap.get("svc_kei_ucwk_no"));
		arg.put(EKK0201C051CBSMsg.MSKM_DTL_NO, (String)haisoBpnMap.get(DKSV0076_DKSV0076OP_DKSV007601CC_EDK0011C080CBSMsg1List.MSKM_DTL_NO));
		arg.put(EKK0201C051CBSMsg.IDO_DIV, (String)kikiKakutei1Map.get(DKSV0076_DKSV0076OP_DKSV007602CC.IDO_DIV));
		arg.put(EKK0201C051CBSMsg.UQ_NINSHO_ID, (String)takunaiInfo.get(EDKA0010008CBSMsg1List.UQ_NINSHO_ID));
		arg.put(EKK0201C051CBSMsg.UQ_NINSHO_ID_PWD, (String)takunaiInfo.get(EDKA0010008CBSMsg1List.UQ_PWD));
		arg.put("svc_kei_no", (String)haisoBpnMap.get(DKSV0076_DKSV0076OP_DKSV007601CC_EDK0011C080CBSMsg1List.SVC_KEI_NO));
	}
	
	/**
	 * 進捗登録情報を作成する
	 */
	@SuppressWarnings("unchecked")
	private void makeEKK1091D010Input(List<Map<String, String>> ekk1091D0101List, Map haisoBpnMap, HashMap inMap)
	{
		JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "進捗登録情報の作成");
		
		ArrayList<Map<String, String>> dataList = new ArrayList<Map<String, String>> ();
		
		dataList = (ArrayList)inMap.get("EKK1131B001CBSMSG1LIST");
		
		Map<String, String> arg = new HashMap<String, String>();
		ekk1091D0101List.add(arg);
		arg.put(EKK1091D010CBSMsg.SVC_KEI_NO, (String)haisoBpnMap.get(DKSV0076_DKSV0076OP_DKSV007601CC_EDK0011C080CBSMsg1List.SVC_KEI_NO));
		arg.put(EKK1091D010CBSMsg.IDO_DIV, (String)haisoBpnMap.get(DKSV0076_DKSV0076OP_DKSV007601CC_EDK0011C080CBSMsg1List.ADD_OPTNTY_KEI_IDO_DIV));
		arg.put(EKK1091D010CBSMsg.IDO_DTM, (String)haisoBpnMap.get(DKSV0076_DKSV0076OP_DKSV007601CC_EDK0011C080CBSMsg1List.ADD_OPTNTY_KEI_IDO_DTM));
		arg.put(EKK1091D010CBSMsg.PRG_STAT, "9301");
		arg.put(EKK1091D010CBSMsg.PRG_TKJK_2, "型番号：" + (String)haisoBpnMap.get(DKSV0076_DKSV0076OP_DKSV007601CC_EDK0011C080CBSMsg1List.TAKNKIKI_MODEL_CD));
		
		if (dataList.size() != 0)
		{
			// 異動理由が取得できていた場合のみ設定する
			arg.put(EKK1091D010CBSMsg1List.IDO_RSN_CD, dataList.get(0).get(EKK1091D010CBSMsg1List.IDO_RSN_CD));
			arg.put(EKK1091D010CBSMsg1List.IDO_RSN_MEMO, dataList.get(0).get(EKK1091D010CBSMsg1List.IDO_RSN_MEMO));
		}
	}
	
	
	/**
	 * 機器がBCASかCCASであるかを判定する
	 */
	@SuppressWarnings("unchecked")
	private boolean isBCASorCCAS(Map buppin) {
		String modelCd = buppin.get("taknkiki_sbt_cd").toString();
		
		return JDKStrConst.BCAS.equals(modelCd)
				|| JDKStrConst.CCAS.equals(modelCd);
	}
	
	
	/**
	 * 宅内情報から指定の機器のデータを取得する
	 */
	@SuppressWarnings("unchecked")
	private Map getTakunaiInfo(String modelCd, String productNo, Map datas) {
		List<Map> infos = (List<Map>)datas.get(EDKA0010008CBSMsg1List.class.getName());
		
		for (Map info : infos) {
			if (modelCd.equals(info.get(EDKA0010008CBSMsg1List.TK_MDL_CD))
					&& productNo.equals(info.get(EDKA0010008CBSMsg1List.KK_SEIZO_NO))) {
				return info;
			}
		}
		return null;
	}


	/**
	 * サービス契約<eoモバイル>情報変更(事業者用契約)を実行する
	 * @throws Throwable 
	 */
	private void doEKK0121C041(List<Map<String, String>> inputDatas, SessionHandle handle, IRequestParameterReadWrite param)
	throws Throwable
	{
		DKSV0076_DKSV0076OP_EKK0121C041BSMapper mapper = new DKSV0076_DKSV0076OP_EKK0121C041BSMapper();
		HashMap<String, Object> inMap = mapper.editInMsg(param);
		JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "サービス契約＜eoモバイル＞情報変更（事業者用契約）処理の実行");
		Map<?, ?> result = new ServiceComponentRequestInvoker().run(inMap, handle);
		mapper.editResultRP(result, param);
		
		if (JDKBPCommon.hasError(param))
		{
			throw new SCCallException("サービス契約＜eoモバイル＞情報変更（事業者用契約）処理失敗", "0", 
					Integer.parseInt(param.getControlMapData("returnCode").toString()));
		}
	}


	/**
	 * サービス契約内訳＜eoモバイル＞情報変更（ＵＱ認証）を実行する
	 * @throws Throwable 
	 */
	private void doEKK0201C051(List<Map<String, String>> inputDatas, SessionHandle handle, IRequestParameterReadWrite param)
	throws Throwable
	{
		DKSV0076_DKSV0076OP_EKK0201C051BSMapper mapper = new DKSV0076_DKSV0076OP_EKK0201C051BSMapper();
		HashMap<String, Object> inMap = mapper.editInMsg(param);
		JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "サービス契約内訳＜eoモバイル＞情報変更（ＵＱ認証）処理の実行");
		Map<?, ?> result = new ServiceComponentRequestInvoker().run(inMap, handle);
		mapper.editResultRP(result, param);
		
		if (JDKBPCommon.hasError(param))
		{
			throw new SCCallException("サービス契約内訳＜eoモバイル＞情報変更（ＵＱ認証）処理失敗", "0", 
				Integer.parseInt(param.getControlMapData("returnCode").toString()));
		}
	}
	
	
	/**
	 * 進捗登録を実行する
	 * @throws Exception 
	 */
	private void doEKK1091D0101(List<Map<String, String>> inputDatas, SessionHandle handle, IRequestParameterReadWrite param)
	throws Exception
	{
		DKSV0076_DKSV0076OP_EKK1091D010BSMapper mapper = new DKSV0076_DKSV0076OP_EKK1091D010BSMapper();
		HashMap<String, Object> inMap = mapper.editInMsg(param);
		JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "進捗登録処理の実行");
		Map<?, ?> result = new ServiceComponentRequestInvoker().run(inMap, handle);
		mapper.editResultRP(result, param);
		
		if (JDKBPCommon.hasError(param))
		{
			throw new SCCallException("進捗登録処理失敗", "0", 
				Integer.parseInt(param.getControlMapData("returnCode").toString()));
		}
	}
	
	@SuppressWarnings("unchecked")
	private void transportUpdDtm(IRequestParameterReadWrite param) throws Exception
	{

		// 作業領域の取得
		Map workMap = (Map)param.getMappingWorkArea();
		if (workMap == null) {
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}

		// 初回の値としてEDK0011B060(DKSV0074)で取得したスキーマ「サービス契約排他制御」の「最終更新年月日時分秒」を設定する
		Map DKSV007602CC = (Map<String, String>) param.getData("DKSV007602CC");
		List<HashMap> hkatList02 = (ArrayList<HashMap>)DKSV007602CC.get("hkat_list");

		// 配送結合対応（回線に紐付いていない機器の場合はサービス契約番号単位で最終更新年月日時分秒を設定）
		if (JDKStrConst.UM_FLG_M.equals((String) ((Map) param.getData("DKSV007611CC")).get("svc_kei_kaisen_ucwk_flg")))
		{
			if (hkatList02 != null && 0 < hkatList02.size())
			{
				for (HashMap map : hkatList02)
				{
					Map work = null;
					List<Map> workList = (List<Map>)workMap.get(map.get("svc_kei_no"));
					if (workList == null)
					{
						work = new HashMap();
						workList = new ArrayList<Map>();
						workList.add(work);
						workMap.put(map.get("svc_kei_no"), workList);
					}
					else if (workList.isEmpty())
					{
						work = new HashMap();
						workList.add(work);
					}
					else
					{
						work = workList.get(0);
					}

					work.put(DKSV0076_DKSV0076OP_work_workList.SVC_KEI_UPD_DTM, map.get("upd_dtm_bf"));
				}
			}
		}
		else
		{
			Map work = null;
			List<Map> workList = (List<Map>)workMap.get(DKSV0076_DKSV0076OP_work.WORKLIST);
			if (workList == null)
			{
				workList = new ArrayList<Map>();
				workMap.put(DKSV0076_DKSV0076OP_work.WORKLIST, workList);
			}
			if (workList.isEmpty())
			{
				work = new HashMap();
				workList.add(work);
			}
			else
			{
				work = workList.get(0);
			}

			Map<String, String> map = (Map<String, String>)hkatList02.get(0);
			work.put(DKSV0076_DKSV0076OP_work_workList.SVC_KEI_UPD_DTM, map.get("upd_dtm_bf"));
		}
	}
	
	
	/**
	 * 
	 * 工事会社経由の場合にトムソンケースに入力なし
	 * もしくは工事会社非経由でトムソンケース入力有
	 * @throws RequestParameterException 
	 * @throws SCCallException 
	 * @throws NumberFormatException 
	 */
	@SuppressWarnings("unchecked")
	private void tcaseValidation(Map haisoBpnMap, Map errorReturnMap, IRequestParameterReadWrite param) throws RequestParameterException, NumberFormatException, SCCallException
	{
		// 工事会社経由の場合にトムソンケースに入力なし
		// もしくは工事会社非経由でトムソンケース入力有
		if (!JDKCommonUtil.isNull(haisoBpnMap.get("koji_comp_cd"))
			&& JDKCommonUtil.isNull(haisoBpnMap.get("tcase_no")))
		{
			errorReturnMap.put(EDK0011C080CBSMsg1List.KEY_HAISO_TAIBPIN_NO_ERR, "E7");
			errorReturnMap.put("returnCode", "1050");
			JDKBPCommon.addError(param, EDK0011C080CBSMsg1List.TCASE_NO_ERR, "E7", "EDK0011C080", StatusCodes.ITEM_RELATION_ERR, 1050);
			throw new SCCallException("配送完了実績登録処理失敗", "0", 
										Integer.parseInt(param.getControlMapData("returnCode").toString()));
		}
		if (JDKCommonUtil.isNull(haisoBpnMap.get("koji_comp_cd"))
			&& !JDKCommonUtil.isNull(haisoBpnMap.get("tcase_no")))
		{
			errorReturnMap.put(EDK0011C080CBSMsg1List.KEY_HAISO_TAIBPIN_NO_ERR, "E8");
			errorReturnMap.put("returnCode", "1050");
			JDKBPCommon.addError(param, EDK0011C080CBSMsg1List.TCASE_NO_ERR, "E8", "EDK0011C080", StatusCodes.ITEM_RELATION_ERR, 1050);
			throw new SCCallException("配送完了実績登録処理失敗", "0", 
										Integer.parseInt(param.getControlMapData("returnCode").toString()));
		}
	}
	
	/**
	 * サービス契約内訳一覧照会を実行する
	 */
	@SuppressWarnings("unchecked")
	private void callKeiyakuUchiwakeItiran(Map haisoBpnMap, List<Map> worklist, IRequestParameterReadWrite param, SessionHandle handle) throws Throwable
	{
		String taknkikiSbtCd = (String)haisoBpnMap.get("taknkiki_sbt_cd");
		if (!("J0".equals(taknkikiSbtCd)))
		{
			return;
		}
		
		DKSV0076_DKSV0076OP_EKK0161B004BSMapper svcKeiUcwkMapper = new DKSV0076_DKSV0076OP_EKK0161B004BSMapper();
		Map<String, String> searchMap = new HashMap<String, String>();
		searchMap.put(EKK0161B004CBSMsg.KEY_SVC_KEI_NO, (String)haisoBpnMap.get(DKSV0076_DKSV0076OP_DKSV007601CC_EDK0011C080CBSMsg1List.SVC_KEI_NO));
		searchMap.put(EKK0161B004CBSMsg.KEY_PCRS_CD, (String)worklist.get(0).get("pcrsCd"));
		searchMap.put(EKK0161B004CBSMsg.KEY_SVC_PRD_FLG, "0");
		HashMap svcKeiUcwkCondition = svcKeiUcwkMapper.editInMsg(param, searchMap);
		JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "サービス契約内訳一覧照会処理の実行");
		Map svcKeiUcwk = new ServiceComponentRequestInvoker().run(svcKeiUcwkCondition, handle);
		svcKeiUcwkMapper.editResultRP(svcKeiUcwk, param);
		if (JDKBPCommon.hasError(param))
		{
			throw new SCCallException("サービス契約内訳一覧照会処理失敗", "0", 
										Integer.parseInt(param.getControlMapData("returnCode").toString()));
		}
	}
	
	/**
	 * 進捗情報異動理由一覧照会サービスインターフェイスの呼び出し
	 */
	@SuppressWarnings("unchecked")
	private void callShinchokuJohoIdoRiyuItiran(Map haisoBpnMap, List<Map> worklist, IRequestParameterReadWrite param, SessionHandle handle) throws Throwable
	{
		DKSV0076_DKSV0076OP_EKK1131B001BSMapper shinchokuMapper = new DKSV0076_DKSV0076OP_EKK1131B001BSMapper();
		Map<String, String> inMap = new HashMap<String, String>();
		inMap.put(EKK1131B001CBSMsg.KEY_SVC_KEI_NO, (String)haisoBpnMap.get(DKSV0076_DKSV0076OP_DKSV007601CC_EDK0011C080CBSMsg1List.SVC_KEI_NO));
		inMap.put(EKK1131B001CBSMsg.KEY_IDO_DIV, (String)haisoBpnMap.get(DKSV0076_DKSV0076OP_DKSV007601CC_EDK0011C080CBSMsg1List.ADD_OPTNTY_KEI_IDO_DIV));
		inMap.put(EKK1131B001CBSMsg.KEY_IDO_DTM, (String)haisoBpnMap.get(DKSV0076_DKSV0076OP_DKSV007601CC_EDK0011C080CBSMsg1List.ADD_OPTNTY_KEI_IDO_DTM));
		HashMap shinchokukCondition = shinchokuMapper.editInMsg(param, inMap);
		JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "進捗情報異動理由一覧照会処理の実行");
		Map shinchokuMap = new ServiceComponentRequestInvoker().run(shinchokukCondition, handle);
		shinchokuMapper.editResultRP(shinchokuMap, param);
		if (JDKBPCommon.hasError(param))
		{
			throw new SCCallException("進捗情報異動理由一覧照会処理失敗", "0", 
										Integer.parseInt(param.getControlMapData("returnCode").toString()));
		}
	}
// ANK-3736-00-00 ADD START
	/**
	 * 配送対象物品一覧照会（工事案件番号）サービスインターフェイスの呼び出し
	 * @param handle セッションハンドル
	 * @param scCall SC呼出
	 * @param param パラメーター
	 * @param dataMapKey データマップキー
	 * @param haisoBpnMap 配送完了実績登録マップ
	 * @return 登録済トムソンケース番号リスト号
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private HashSet<String> callHaisoTgBpinIcrnKojiakNo(SessionHandle handle,
														ServiceComponentRequestInvoker scCall,
														IRequestParameterReadWrite param,
														String dataMapKey,
														Map haisoBpnMap) throws Throwable
	{
		// 登録済トムソンケース番号リスト
		HashSet<String> addZmTcaseNoList = new HashSet<String>();
		
		// 工事案件番号が存在しない場合、実行しない
		if (JDKCommonUtil.isNull(haisoBpnMap.get("anken_no")))
		{
			return addZmTcaseNoList;
		}
		
		// 配送対象物品一覧照会（工事案件番号）サービスI/Fの上りマッピング
		Object[][] edk0021b020In = {
				{EDK0021B020CBSMsg.TEMPLATEID, TEMPLATE_ID_EDK0021B020},
				{EDK0021B020CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1},
				{EDK0021B020CBSMsg.KEY_KOJIAK_NO, (String)haisoBpnMap.get("anken_no")}
		};
		
		// サービスI/F実行
		CAANMsg[] edk0021b020MsgList = callSC(handle, scCall, param, dataMapKey, edk0021b020In).getCAANMsgList(EDK0021B020CBSMsg.EDK0021B020CBSMSG1LIST);
		
		if (edk0021b020MsgList != null && edk0021b020MsgList.length > 0)
		{
			for (CAANMsg edk0021b020Msg : edk0021b020MsgList)
			{
				// トムソンケース番号
				String tcasNo = getNullToStr(edk0021b020Msg.getString(EDK0021B020CBSMsg1List.TCASE_NO));
				
				if (JDKCommonUtil.isNull(tcasNo))
				{
					continue;
				}
				
				if (addZmTcaseNoList.contains(tcasNo))
				{
					continue;
				}
				addZmTcaseNoList.add(tcasNo);
			}
		}
		return addZmTcaseNoList;
	}
	
	/**
	 * SC(サービスインターフェイス）を呼び出す。
	 * @param handle セッションハンドル
	 * @param scCall SC呼び出し部品
	 * @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);
		Integer 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));
		
		CAANMsg template = new CAANMsg(String.format("eo.ejb.cbs.cbsmsg.%sCBSMsg", (String)mappingData[0][1]));
		
		// オペレータ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 CAANMsgクラス
	 * @param returnCode リターンコード
	 * @param dataMapKey パラメータキー
	 * @param mappingData マッピングデータ
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	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, Object> inMap = null;
		
		// ユーザデータ情報
		inMap = (HashMap<String, Object>)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"))
				{
					// ユーザ情報は「key_」がない為、「key_」を削除する。
					if (((String)mappingData[i][0]).startsWith("key_"))
					{
						String key = (String)mappingData[i][0];
						inMap.put(key.substring(4) + "_err", template.getString(mappingData[i][0] + "_err"));
					}
					else
					{
						inMap.put(mappingData[i][0] + "_err", template.getString(mappingData[i][0] + "_err"));
					}
				}
			}
		}
		return param;
	}
	
	/**
	 * パラメタがNullの場合空白を返却します。
	 * @param str 文字列
	 * @return str
	 */
	private String getNullToStr(String str)
	{
		if (str == null || "".equals(str.trim()))
		{
			return "";
		}
		return str;
	}
// ANK-3736-00-00 ADD END
}