/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：物流管理システム
*   ソースファイル名：JDKCommon08CC.java
*   作成者          ：富士通
*   日付            ：2011年07月20日
*＜機能概要＞
*   返品機器承認CCクラスです。
*＜修正履歴＞
*   バージョン  修正日       修正者      修正内容
*   v1.00.00    2011/07/20   FJ          新規作成
*   v5.00.00    2013/10/29   FJ          取消処理修正(OM-2013-0003584)
*   v7.00.00	2014/02/24   FJ          EKK0341A010の使用をやめ、EKK0341B514で取消データも参照するように変更(OM-2014-0000707)
*   v8.00.00    2014/05/16   FJ          IT2-2014-00000201対応
*   v10.00.00	2014/08/06   FJ          ANK-2141-00-00（STB交換方法の変更）
*  	v10.00.01	2014/08/22   FJ)横田     IT1-2014-0000292（STB交換方法の変更）
*  	v10.00.02	2014/09/04   FJ)横田     IT2-2014-0000300（STB交換方法の変更） 
*   v10.00.03	2014/09/26   FJ)山下     ANK-2119-00-00（返品SODのリアル化対応）
*   v10.00.04	2014/10/20   FJ)山下     IT1-2014-0000341（返品SODのリアル化対応）
*   v10.00.05	2014/10/23   FJ)山下     IT1-2014-0000341（返品SODのリアル化対応）
*   v10.00.06	2014/10/27   FJ)山下     IT1-2014-0000348（返品SODのリアル化対応）
*   v10.00.07	2014/11/12   FJ)山下     IT1-2014-0000368（返品SODのリアル化対応）
*   v10.00.08	2014/11/16   FJ)山下     IT1-2014-0000369（返品SODのリアル化対応）
*   v11.00.00	2014/12/11   FJ)山下     OM-2014-0003844（機器製造番号対応）
*   v13.00.00	2015/03/10   FJ)舩橋     ANK-2406-00-00（返品承認一覧画面）
*   v13.00.01	2015/04/03   FJ)窪田     OM-2015-0000671対応
*   v23.00.00	2016/02/08   FJ)黒田    【OM-2016-0000175】機器提供サービス契約の最新のオーダ設定の抽出条件に機器製造番号を追加
*   v33.00.00	2017/08/28   FJ)周藤    【ANK-3080-00-00】返品承認時の自動アンリンク処理追加
*   v33.00.01	2017/08/28   FJ)周藤     IT1-2017-0000118 返品承認時の自動アンリンク処理追加対応
*   v33.00.02	2017/09/30   FJ)阪口     OM-2017-0001015 返品承認画面の不備対応
*   v33.00.03	2017/10/18   FJ)川島     ST-2017-0000015 対応
*   v33.00.04	2017/11/17   FJ)川島     OM-2017-0001015 返品承認画面の不備対応
*   v34.00.00	2018/01/19   FJ)黒田(耕) OM-2018-0000010 返品機器アンリンクの不備対応
*   v50.00.00	2020/06/18   FJ)吉田     OM-2020-0000461 番号追加でレンタルVA⇒多機能へ交換となった場合、VA提供中でも返品承認できてしまう
*   v50.00.01	2020/08/21   FJ)謝       【ANK-3892-00-00】締結済状態での返品承認可能対応
*   v61.00.00	2023/02/28   GDC）v.auditor  【ANK-4315-00-00】【eo定期】 eoホームゲートウェイ導入対応_Step2
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

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

import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EDK0301A010BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EDK0301A010_01BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EDK0301B090BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EDK0301C030BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EDK0301C070BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EDK0301D010BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EDK0301E010BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EDKA0010005BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EDKA0010008BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EKK0081A010BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EKK0081B034BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EKK0161B004BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EKK0341A010_02BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EKK0341B001BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EKK0341B034BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EKK0341B514BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EKK1081C011BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EKK1081D010BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EKK1551D010BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EKK2811B010BSMapper;
import com.fujitsu.futurity.bp.custom.mapping.DKSV0081_DKSV0081OP_EZM0411A010BSMapper;
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.IRequestParameterReadOnly;
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.CCException;
import com.fujitsu.futurity.bp.x21.cc.exception.SCCallException;
import com.fujitsu.futurity.bp.x21.sc.exception.SCException;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.ErrorInfoMapKeys;
import com.fujitsu.futurity.common.x01.sc.SCControlMapKeys;
import com.fujitsu.futurity.mapping.bp.common.TemplateErrorUtil;
import com.fujitsu.futurity.model.base.CAANMsg;
import com.fujitsu.futurity.model.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.JKKStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.constant.JWCStrConst;
import eo.ejb.cbs.cbsmsg.EDKA0010005CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081B034CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B034CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0161B004CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0161B004CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341B034CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341B034CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1081C011CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1081D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1551D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2811B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EWCA0010002CBSMsg;
import eo.ejb.cbs.cbsmsg.EWCA0010002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0411A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0411A010CBSMsg1List;

//ANK-2141-00-00 ADD STRAT
import eo.ejb.cbs.cbsmsg.EDK0111B026CBSMsg;
import eo.ejb.cbs.cbsmsg.EWCA0010001CBSMsg;
import eo.ejb.cbs.cbsmsg.EWCA0010002CBSMsg;
import eo.ejb.cbs.cbsmsg.EWCA0010002CBSMsg1List;
//ANK-2141-00-00 ADD END

import eo.ejb.cbs.cbsmsg.EWC0151B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EWC0151B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EWC0101B010CBSMsg;
import eo.ejb.cbs.cbsmsg.EWC0101B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EWC0011D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EWC0011C010CBSMsg;
import eo.ejb.cbs.cbsmsg.EWC0011C020CBSMsg;
import eo.ejb.cbs.cbsmsg.EWCA0010001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EWCA0010003CBSMsg;
/**
 * 返品機器承認CCクラスです。
 * @author 富士通
 */
public class JDKCommon08CC extends AbstractCommonComponent
{
	/** CC名 */
	private static final String DKSV008101CC = "DKSV008101CC";

	/** 返品受け入れ情報取得マッパー */
	private static final DKSV0081_DKSV0081OP_EDK0301B090BSMapper EDK0301B090BSMapper = new DKSV0081_DKSV0081OP_EDK0301B090BSMapper();
	/** 返品一意照会情報取得マッパー */
	private static final DKSV0081_DKSV0081OP_EDK0301A010BSMapper EDK0301A010BSMapper = new DKSV0081_DKSV0081OP_EDK0301A010BSMapper();
	/** 返品機器削除マッパー */
	private static final DKSV0081_DKSV0081OP_EDK0301E010BSMapper EDK0301E010BSMapper = new DKSV0081_DKSV0081OP_EDK0301E010BSMapper();
	/** 承認処理マッパー */
	private static final DKSV0081_DKSV0081OP_EDK0301C030BSMapper EDK0301C030BSMapper = new DKSV0081_DKSV0081OP_EDK0301C030BSMapper();
	/** 未受入承認処理マッパー */
	private static final DKSV0081_DKSV0081OP_EDK0301C070BSMapper EDK0301C070BSMapper = new DKSV0081_DKSV0081OP_EDK0301C070BSMapper();
	/** 宅内在庫照会マッパー */
	private static final DKSV0081_DKSV0081OP_EDKA0010008BSMapper EDKA0010008BSMapper = new DKSV0081_DKSV0081OP_EDKA0010008BSMapper();
	/** 宅内在庫更新マッパー */
	private static final DKSV0081_DKSV0081OP_EDKA0010005BSMapper EDKA0010005BSMapper = new DKSV0081_DKSV0081OP_EDKA0010005BSMapper();
	/** 契約情報取得マッパー */
	private static final DKSV0081_DKSV0081OP_EKK0341B514BSMapper EKK0341B514BSMapper = new DKSV0081_DKSV0081OP_EKK0341B514BSMapper();
	/** 返品一意照会情報取得マッパー(取消時受付済元ネタ取得用) */
	private static final DKSV0081_DKSV0081OP_EDK0301A010_01BSMapper EDK0301A010_01BSMapper = new DKSV0081_DKSV0081OP_EDK0301A010_01BSMapper();
	/** 返品機器受付マッパー */
	private static final DKSV0081_DKSV0081OP_EDK0301D010BSMapper EDK0301D010BSMapper = new DKSV0081_DKSV0081OP_EDK0301D010BSMapper();
	
	// ANK-2119-00-00 ADD START
	/** 宅内機器型式一意照会マッパー */
	private static final DKSV0081_DKSV0081OP_EZM0411A010BSMapper EZM0411A010BSMapper = new DKSV0081_DKSV0081OP_EZM0411A010BSMapper();
	/** サービス契約一意照会マッパー */
	private static final DKSV0081_DKSV0081OP_EKK0081A010BSMapper EKK0081A010BSMapper = new DKSV0081_DKSV0081OP_EKK0081A010BSMapper();
	// IT1-2014-0000341 MOD START
	/** 機器提供サービス契約サービス契約番号一覧照会マッパー */
	private static final DKSV0081_DKSV0081OP_EKK0081B034BSMapper EKK0081B034BSMapper = new DKSV0081_DKSV0081OP_EKK0081B034BSMapper();
	//** 回線利用中サービス契約一覧照会マッパー */
	//private static final DKSV0081_DKSV0081OP_EKK0081B007BSMapper EKK0081B007BSMapper = new DKSV0081_DKSV0081OP_EKK0081B007BSMapper();
	// サービス契約内訳一覧照会マッパー */
	// IT1-2014-0000368 MOD START
	//private static final DKSV0081_DKSV0081OP_EKK0161B004BSMapper EKK0161B004BSMapper = new DKSV0081_DKSV0081OP_EKK0161B004BSMapper();
	private static final DKSV0081_DKSV0081OP_EKK0161B004BSMapper EKK0161B004BSMapper = new DKSV0081_DKSV0081OP_EKK0161B004BSMapper();
	// IT1-2014-0000368 MOD END
	// サービス契約回線内訳一覧照会マッパー */
	//private static final DKSV0081_DKSV0081OP_EKK0251B001BSMapper EKK0251B001BSMapper = new DKSV0081_DKSV0081OP_EKK0251B001BSMapper();
	// IT1-2014-0000341 MOD END
	/** 機器提供サービス契約一意照会マッパー */
	private static final DKSV0081_DKSV0081OP_EKK0341A010_02BSMapper EKK0341A010_02BSMapper = new DKSV0081_DKSV0081OP_EKK0341A010_02BSMapper();
	/** 機器オプションサービス契約一覧照会マッパー */
	private static final DKSV0081_DKSV0081OP_EKK2811B010BSMapper EKK2811B010BSMapper = new DKSV0081_DKSV0081OP_EKK2811B010BSMapper();
	/** 機器提供サービス契約一覧照会（返品SOD発行）マッパー */
	private static final DKSV0081_DKSV0081OP_EKK0341B034BSMapper EKK0341B034BSMapper = new DKSV0081_DKSV0081OP_EKK0341B034BSMapper();
	/** 同一処理番号採番マッパー */
	private static final DKSV0081_DKSV0081OP_EKK1081C011BSMapper EKK1081C011BSMapper = new DKSV0081_DKSV0081OP_EKK1081C011BSMapper();
	/** オーダ発行条件登録マッパー */
	private static final DKSV0081_DKSV0081OP_EKK1081D010BSMapper EKK1081D010BSMapper = new DKSV0081_DKSV0081OP_EKK1081D010BSMapper();
	/** オーダ情報作成ワーク登録マッパー */
	private static final DKSV0081_DKSV0081OP_EKK1551D010BSMapper EKK1551D010BSMapper = new DKSV0081_DKSV0081OP_EKK1551D010BSMapper();
	// IT1-2014-0000368 ADD START
	/** 機器提供サービス契約一覧照会（機器製造番号）マッパー */
	private static final DKSV0081_DKSV0081OP_EKK0341B001BSMapper EKK0341B001BSMapper = new DKSV0081_DKSV0081OP_EKK0341B001BSMapper();
	// IT1-2014-0000368 ADD END
	/** SOD作業領域名 */
	private static final String SOD_WORKAREA_KEY = "SODWORK";
	// ANK-2119-00-00 ADD END
	
	/**
	 * 返品区分
	 */
	private static final Set<String> HMPIN_KBN = new HashSet<String>();
	static {
		// OM-2015-0000671 ADD START
		HMPIN_KBN.add("");
		// OM-2015-0000671 ADD END
		HMPIN_KBN.add("1");
		HMPIN_KBN.add("2");
	}
	
	/** レンタル */
	private static final String RENTAL = "02";
	//ANK-2141-00-00 ADD STRAT
	/** 本運用 */
	private static final String HONUNYO = "012";
	/** リンク中 */
	private static final String RINKCHU = "012";
	//ANK-2141-00-00 ADD END
	private static final IRequestParameterReadOnly IRequestParameterReadOnly = null;
	
//ANK-2406-00-00 ADD START
	/** 処理区分：確認 */
	private static final String FUNC_CODE_2 = "2";

	/** 予約適用コード：取消し */
	private static final String TORIKESHI = "3";
//ANK-2406-00-00 ADD END

	/**
	 * 返品承認データ一覧取得処理を行います。
	 * @param handle セッションハンドル
	 * @param param パラメータ
	 * @param fixedText 定型文字
	 * @return パラメータ
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite approve(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		HashMap<String, Object> ukeireParamMap = new HashMap<String, Object>();
		Map contractData = (Map)param.getData(DKSV008101CC);
		
		List<Map> approveDatas = (List<Map>)contractData.get("key_hmpin_kiki_list");
		// 更新ステータス
		String updateStat = (String) approveDatas.get(0).get("key_hmpin_kiki_stat");
		
//ANK-2406-00-00 ADD START
		// 処理区分
		String funcCode = (String) contractData.get("func_code");
//ANK-2406-00-00 ADD END

		// 取消処理用のwork
		HashMap<String, Object> cancelWorkMap = new HashMap<String, Object>();
		ArrayList workList = new ArrayList();
		cancelWorkMap.put("workList", workList);
		param.setData("workMap", cancelWorkMap);

		// サービス契約番号が入力されているデータは対応する受付済みデータを取得する
		ukeireParamMap = EDK0301B090BSMapper.editInMsg(param);
		if (hasArgument(ukeireParamMap)) {
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "返品未受入機器一覧照会処理の実行");
			Map ukeireResult = scCall.run(ukeireParamMap, handle);

			EDK0301B090BSMapper.editResultRP(ukeireResult, param);

//ANK-2406-00-00 MOD START
//			if (contractData.containsKey("kktk_svc_kiy_no_err_list"))
			if (JDKStrConst.HMPIN_KIKI_STAT_TORIKESHI.equals(updateStat) && contractData.containsKey("kktk_svc_kiy_no_err_list"))
//ANK-2406-00-00 MOD END
			{
				JDKBPCommon.addError(param, "key_hmpin_kiki_no_err", "EB", "EDK0301C030", StatusCodes.RELATION_ERR, 0);
				throw new SCCallException("承認処理失敗", "0", StatusCodes.RELATION_ERR);
			}

			if (JDKBPCommon.hasError(param))
			{
				throw new SCCallException("返品承認処理失敗", "0", 
											Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
		}

		// 契約ステータスによる入力チェック
		Map<String, String> svcNoAndTkCds = kikiTeikyoCds(param);
		List<Map<String, Object>> errors = new ArrayList<Map<String, Object>>();

//ANK-2406-00-00 ADD START
		List<Map<String, Object>> errors2 = new ArrayList<Map<String, Object>>();
		List<Map<String, Object>> errors3 = new ArrayList<Map<String, Object>>();
// ANK-3080-00-00 DEL START
//		 List<Map<String, Object>> errors4 = new ArrayList<Map<String, Object>>();
// ANK-3080-00-00 DEL END
		List<Map<String, Object>> errors5 = new ArrayList<Map<String, Object>>();
//ANK-2406-00-00 ADD END
// ANK-3080-00-00 ADD START
		List<Map<String, Object>> errors6 = new ArrayList<Map<String, Object>>();
		List<Map<String, Object>> errors7 = new ArrayList<Map<String, Object>>();
		
		// アンリンク処理済データ
		HashSet<String> checkMap = new HashSet<String>();
		// アンリンク用パラメータマップ
		HashMap<String, Object> tmpParamMap = new HashMap<String, Object>();
		List<HashMap<String, Object>> unlinkMap = new ArrayList<HashMap<String, Object>>();
// ANK-3080-00-00 ADD END

		for (Map data : approveDatas)
		{
			// 承認の場合は返品区分のチェックを行う
			if (JDKStrConst.HMPIN_KIKI_STAT_SHONIN.equals(updateStat))
			{
				// 代替機または故障品の場合、エラーメッセージを出力する
				if(JDKStrConst.SUBSTITUTE.equals(data.get("key_hmpin_kbn")) || JDKStrConst.BROKEN.equals(data.get("key_hmpin_kbn")))
				{
//ANK-2406-00-00 DEL START
//					JDKBPCommon.addError(param, "key_hmpin_kiki_no_err", "ED", "EDK0301C030", StatusCodes.RELATION_ERR, 0);
//ANK-2406-00-00 DEL END
	
					Map<String, Object> svcKiyNo = new HashMap<String, Object>();
					svcKiyNo.put("kktk_svc_kiy_no_hmpin_kbn", data.get("key_kktk_svc_kei_no"));
					svcKiyNo.put("svc_kiy_no_hmpin_kbn", data.get("svc_kei_no"));
					errors.add(svcKiyNo);

//ANK-2406-00-00 ADD START
					Map<String, Object> svcKiyNo3 = new HashMap<String, Object>();
					svcKiyNo3.put("key_hmpin_kiki_no", data.get("key_hmpin_kiki_no"));
					errors3.add(svcKiyNo3);
//ANK-2406-00-00 ADD END

					continue;
				}
			}
			//OM-2015-0000671 ADD START
			if (data.get("key_kktk_svc_kei_no").equals("")) {
				continue;
			}
			//OM-2015-0000671 ADD END

			HashMap<String, Object> contractsParamMap = new HashMap<String, Object>();
			contractsParamMap = EKK0341B514BSMapper.editInMsg(param, data);
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "機器提供サービス契約一覧照会（機器変更番号指定）処理の実行");
			Map contractResult = scCall.run(contractsParamMap, handle);
			EKK0341B514BSMapper.editResultRP(contractResult, param);
			if (JDKBPCommon.hasError(param))
			{
				throw new SCCallException("機器提供サービス契約一覧照会（機器変更番号指定）処理失敗", "0", 
											Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}

			List<Map> dataList = (ArrayList<Map>)contractData.get("EKK0341B514CBSMsg1List");
//IT2-2014-0000300 ADD START
			if ( dataList != null && dataList.size() > 0 )
			{
//IT2-2014-0000300 ADD END
//IT1-2014-0000292 ADD START
				if(JDKStrConst.STB.equals(dataList.get(0).get("taknkiki_sbt_cd"))
				   || JDKStrConst.CCAS.equals(dataList.get(0).get("taknkiki_sbt_cd")))
				{
// OM-2018-0000010 DEL START
//					HashMap<String, Object> paramMap = new HashMap<String, Object>();
// OM-2018-0000010 DEL END

// ANK-3080-00-00 ADD START
// OM-2018-0000010 MOD START
//					if(!funcCode.equals(FUNC_CODE_2))
					// 返品承認の時のみ実行する
					if(JDKStrConst.HMPIN_KIKI_STAT_SHONIN.equals(updateStat) && !funcCode.equals(FUNC_CODE_2))
// OM-2018-0000010 MOD END
					{
						// アンリンク処理
						tmpParamMap = unlink(param,(String)data.get("key_tk_mdl_cd"), 
								(String)data.get("key_kk_seizo_no"), (String)contractData.get("svc_kei_no"), 
								checkMap,scCall,handle, (String)data.get("key_hmpin_kiki_no"));
						
						// エラー登録
						if(tmpParamMap.get("key_unlink_unyo_hmpin_kiki_no") != null
								&& !"".equals(tmpParamMap.get("key_unlink_unyo_hmpin_kiki_no")))
						{
							Map<String, Object> svcKiyNo6 = new HashMap<String, Object>();
							svcKiyNo6.put("key_unlink_unyo_hmpin_kiki_no", tmpParamMap.get("key_unlink_unyo_hmpin_kiki_no"));
							errors.add(svcKiyNo6);
							errors6.add(svcKiyNo6);
						}
						if(tmpParamMap.get("key_unlink_link_hmpin_kiki_no") != null
								&& !"".equals(tmpParamMap.get("key_unlink_link_hmpin_kiki_no")))
						{
							Map<String, Object> svcKiyNo7 = new HashMap<String, Object>();
							svcKiyNo7.put("key_unlink_link_hmpin_kiki_no", tmpParamMap.get("key_unlink_link_hmpin_kiki_no"));
							errors.add(svcKiyNo7);
							errors7.add(svcKiyNo7);
						}
						// エラーフラグ、ＳＴＢ連携不要フラグがない場合、ＳＴＢ連携用にパラメータをリストに保持
//IT1-2017-0000118 MOD START
//						if(tmpParamMap.size() > 0)
						if(tmpParamMap.size() > 0
								&& !tmpParamMap.containsKey("key_unlink_unyo_hmpin_kiki_no") 
								&& !tmpParamMap.containsKey("key_unlink_link_hmpin_kiki_no") 
								&& !tmpParamMap.containsKey("key_not_unlink_flg"))
//IT1-2017-0000118 MOD END
						{
							unlinkMap.add(tmpParamMap);
						}
					}
// ANK-3080-00-00 ADD END

// OM-2018-0000010 DEL START
//					paramMap = editInMsg(param,(String)data.get("key_tk_mdl_cd"),(String)data.get("key_kk_seizo_no"));
//		
//					// SC呼出実行
//					// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
//					JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "宅内機器一意照会(2)処理の実行");
//					Map<?, ?> result = scCall.run(paramMap, handle);
//		
//					CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
//					CAANMsg msg = templates[0];
//		
//					// 検索リストを取得する
//					CAANMsg[] serchList = msg.getCAANMsgList(EWCA0010002CBSMsg.EWCA0010002CBSMSG1LIST);
//					if ( serchList != null && serchList.length > 0 )
//					{
//						String stbCd = serchList[0].getString(EWCA0010002CBSMsg1List.STB_STAT_CD);
//						String ccStat = serchList[0].getString(EWCA0010002CBSMsg1List.CCAS_CARD_STAT_CD);
//						
//						if (HONUNYO.equals(stbCd)||RINKCHU.equals(ccStat))
//						{
////ANK-2406-00-00 MOD START
////							JDKBPCommon.addError(param, "key_hmpin_kiki_no_err", "EC", "EDK0301C030", StatusCodes.RELATION_ERR, 0);
//
//							if (JDKStrConst.HMPIN_KIKI_STAT_TORIKESHI.equals(updateStat)) {
//								JDKBPCommon.addError(param, "key_hmpin_kiki_no_err", "EC", "EDK0301C030", StatusCodes.RELATION_ERR, 0);
//							}
////ANK-2406-00-00 MOD END
//
//							Map<String, Object> svcKiyNo = new HashMap<String, Object>();
//							svcKiyNo.put("kktk_svc_kiy_no_rink", data.get("key_kktk_svc_kei_no"));
//							svcKiyNo.put("svc_kiy_no_rink", data.get("svc_kei_no"));
//							errors.add(svcKiyNo);
//
//// ANK-3080-00-00 DEL START
////ANK-2406-00-00 ADD START
////							 Map<String, Object> svcKiyNo4 = new HashMap<String, Object>();
////							 svcKiyNo4.put("key_hmpin_kiki_no", data.get("key_hmpin_kiki_no"));
////							 errors4.add(svcKiyNo4);
////ANK-2406-00-00 ADD END
//// ANK-3080-00-00 DEL END
//
//						}
//					}
// OM-2018-0000010 DEL END
				}
//IT1-2014-0000292 ADD END
//IT2-2014-0000300 ADD START
			}
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "機器提供サービス契約ステータス：" + dataList.get(0).get("kktk_svc_kei_stat"));
//IT2-2014-0000300 ADD END
			if (dataList == null || dataList.size() == 0)
			{
//ANK-2406-00-00 MOD START
//				JDKBPCommon.addError(param, "key_hmpin_kiki_no_err", "EE", "EDK0301C030", StatusCodes.RELATION_ERR, 0);

				if (JDKStrConst.HMPIN_KIKI_STAT_TORIKESHI.equals(updateStat)) {
					JDKBPCommon.addError(param, "key_hmpin_kiki_no_err", "EE", "EDK0301C030", StatusCodes.RELATION_ERR, 0);
				}
//ANK-2406-00-00 MOD END

				Map<String, Object> svcKiyNo = new HashMap<String, Object>();
				svcKiyNo.put("kktk_svc_kiy_no_nodata", data.get("key_kktk_svc_kei_no"));
				svcKiyNo.put("svc_kiy_no_nodata", data.get("svc_kei_no"));
				errors.add(svcKiyNo);

//ANK-2406-00-00 ADD START
				Map<String, Object> svcKiyNo5 = new HashMap<String, Object>();
				svcKiyNo5.put("key_hmpin_kiki_no", data.get("key_hmpin_kiki_no"));
				errors5.add(svcKiyNo5);
//ANK-2406-00-00 ADD END

				continue;
			}
// ANK-3892-00-00 MOD START
//			// サービス契約ステータスがサービス提供中で、自分より大きい機器変更番号がある場合
//			else if(JDKStrConst.SVC_KEI_STAT_SVTEIKYO.equals(dataList.get(0).get("kktk_svc_kei_stat"))
			// サービス契約ステータスがサービス提供中、締結済で、自分より大きい機器変更番号がある場合
			else if((JDKStrConst.SVC_KEI_STAT_SVTEIKYO.equals(dataList.get(0).get("kktk_svc_kei_stat"))
					|| JDKStrConst.SVC_KEI_STAT_TEIKETSU.equals(dataList.get(0).get("kktk_svc_kei_stat")))
// ANK-3892-00-00 MOD END
					&& !dataList.get(0).get("gene_add_dtm").equals(""))
			{
				continue;
			}

//ANK-2406-00-00 MOD START
//			// サービス契約ステータスが契約変更中、解約済、キャンセル済の場合
//			else if(JDKStrConst.SVC_KEI_STAT_HENKOU.equals(dataList.get(0).get("kktk_svc_kei_stat"))
//					|| JDKStrConst.SVC_KEI_STAT_KAIYAKU.equals(dataList.get(0).get("kktk_svc_kei_stat"))
//					|| JDKStrConst.SVC_KEI_STAT_CANCEL.equals(dataList.get(0).get("kktk_svc_kei_stat")))
//			{
//				continue;
//			}
			// サービス契約ステータスが解約済、キャンセル済の場合
			else if(JDKStrConst.SVC_KEI_STAT_KAIYAKU.equals(dataList.get(0).get("kktk_svc_kei_stat"))
					|| JDKStrConst.SVC_KEI_STAT_CANCEL.equals(dataList.get(0).get("kktk_svc_kei_stat")))
			{
				continue;
			}
			// サービス契約ステータスが契約変更中、予約適用コードが取消しの場合
			else if(JDKStrConst.SVC_KEI_STAT_HENKOU.equals(dataList.get(0).get("kktk_svc_kei_stat"))
					&& TORIKESHI.equals(dataList.get(0).get("rsv_aply_cd")))
			{
				continue;
			}

			// サービス契約ステータスが照査済み、契約変更中、休止・中断中、停止中
			else if(JDKStrConst.SVC_KEI_STAT_SHOSA.equals(dataList.get(0).get("kktk_svc_kei_stat"))
// ANK-3892-00-00 DEL START
//					|| JDKStrConst.SVC_KEI_STAT_TEIKETSU.equals(dataList.get(0).get("kktk_svc_kei_stat"))
// ANK-3892-00-00 DEL END
					|| JDKStrConst.SVC_KEI_STAT_HENKOU.equals(dataList.get(0).get("kktk_svc_kei_stat"))
					|| JDKStrConst.SVC_KEI_STAT_KYUSHI.equals(dataList.get(0).get("kktk_svc_kei_stat"))
					|| JDKStrConst.SVC_KEI_STAT_TEISHI.equals(dataList.get(0).get("kktk_svc_kei_stat")))
			{
				// カレントデータでない場合
				if (!dataList.get(0).get("gene_add_dtm").equals(data.get("key_kktk_svc_gene_add_dtm"))) {
					continue;
				}
			
			}
//ANK-2406-00-00 MOD END
		
			String teikyoCd = svcNoAndTkCds.get(data.get("key_kktk_svc_kei_no"));
			if (RENTAL.equals(teikyoCd))
			{
//ANK-2406-00-00 MOD START
//				JDKBPCommon.addError(param, "key_hmpin_kiki_no_err", "EC", "EDK0301C030", StatusCodes.RELATION_ERR, 0);

				if (JDKStrConst.HMPIN_KIKI_STAT_TORIKESHI.equals(updateStat)) {
					JDKBPCommon.addError(param, "key_hmpin_kiki_no_err", "EC", "EDK0301C030", StatusCodes.RELATION_ERR, 0);
				}
//ANK-2406-00-00 MOD END

				Map<String, Object> svcKiyNo = new HashMap<String, Object>();
				svcKiyNo.put("kktk_svc_kiy_no", data.get("key_kktk_svc_kei_no"));
				svcKiyNo.put("svc_kiy_no", data.get("svc_kei_no"));
				errors.add(svcKiyNo);

//ANK-2406-00-00 ADD START
				Map<String, Object> svcKiyNo2 = new HashMap<String, Object>();
				svcKiyNo2.put("kktk_svc_kei_stat", dataList.get(0).get("kktk_svc_kei_stat"));
				svcKiyNo2.put("key_hmpin_kiki_no", data.get("key_hmpin_kiki_no"));
				errors2.add(svcKiyNo2);
//ANK-2406-00-00 ADD END

//IT1-2014-0000292 DEL START
//				continue;
//IT1-2014-0000292 DEL END
		    }	
//IT1-2014-0000292 DEL START
//			//ANK-2141-00-00 ADD START
//			HashMap<String, Object> paramMap = new HashMap<String, Object>();
//
//			paramMap = editInMsg(param,(String)data.get("key_tk_mdl_cd"),(String)data.get("key_kk_seizo_no"));
//
//			// SC呼出実行
//			// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
//			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "宅内機器一意照会(2)処理の実行");
//			Map<?, ?> result = scCall.run(paramMap, handle);
//
//			CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
//			CAANMsg msg = templates[0];
//
//			// 検索リストを取得する
//			CAANMsg[] serchList = msg.getCAANMsgList(EWCA0010002CBSMsg.EWCA0010002CBSMSG1LIST);
//			if ( serchList != null && serchList.length > 0 )
//			{
//				String stbCd = serchList[0].getString(EWCA0010002CBSMsg1List.STB_STAT_CD);
//				String ccStat = serchList[0].getString(EWCA0010002CBSMsg1List.CCAS_CARD_STAT_CD);
//				
//				if (HONUNYO.equals(stbCd)||RINKCHU.equals(ccStat))
//				{
//					JDKBPCommon.addError(param, "key_hmpin_kiki_no_err", "EC", "EDK0301C030", StatusCodes.RELATION_ERR, 0);
//
//					Map<String, Object> svcKiyNo = new HashMap<String, Object>();
//					svcKiyNo.put("kktk_svc_kiy_no_rink", data.get("key_kktk_svc_kei_no"));
//					svcKiyNo.put("svc_kiy_no_rink", data.get("svc_kei_no"));
//					errors.add(svcKiyNo);
//				}
//
//			}
//			//ANK-2141-00-00 ADD END
//IT1-2014-0000292 DEL END
		}
		if (!errors.isEmpty())
		{
			contractData.put("kktk_svc_kiy_no_err_list", errors);

//ANK-2406-00-00 ADD START
			contractData.put("kktk_svc_kiy_stat_err_list", errors2);
			contractData.put("kktk_svc_kiy_hen_err_list", errors3);
// ANK-3080-00-00 DEL START
//			 contractData.put("kktk_svc_kiy_rink_err_list", errors4);
// ANK-3080-00-00 DEL END
			contractData.put("kktk_svc_kiy_son_err_list", errors5);
//ANK-2406-00-00 ADD END

//ANK-2406-00-00 MOD START
//			throw new SCCallException("返品承認処理失敗", "0", StatusCodes.RELATION_ERR);
			// 取消の場合は処理終了
			if (JDKStrConst.HMPIN_KIKI_STAT_TORIKESHI.equals(updateStat))
			{
				throw new SCCallException("返品承認処理失敗", "0", StatusCodes.RELATION_ERR);
			}
//ANK-2406-00-00 MOD END
// ANK-3080-00-00 ADD START
			// アンリンクの場合は処理終了
			if (errors6.size() > 0)
			{
				setExceptionErr(param, contractData, "EZM0411A010", "kktk_svc_kiy_unlink_unyo_err_list");
				contractData.put("err_cd", "1");
				contractData.put("kktk_svc_kiy_unlink_unyo_err_list", errors6);
				// 例外をスロー
				throw new SCCallException("返品承認処理失敗", "0", StatusCodes.RELATION_ERR);
			}
			if (errors7.size() > 0 )
			{
				setExceptionErr(param, contractData, "EZM0411A010", "kktk_svc_kiy_unlink_link_err_list");
				contractData.put("err_cd", "2");
				contractData.put("kktk_svc_kiy_unlink_link_err_list", errors7);
				// 例外をスロー
				throw new SCCallException("返品承認処理失敗", "0", StatusCodes.RELATION_ERR);
			}
		}
// ANK-3080-00-00 ADD END

		// サービス契約番号が入力されているデータが返品バッチで処理されたときの倉入れ情報を取得する
		HashMap hmpinParamMap = EDK0301A010BSMapper.editInMsg(param);
		if (hasArgument(hmpinParamMap))
		{
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "返品機器一意照会処理の実行");
			Map hempinResult = scCall.run(hmpinParamMap, handle);
			EDK0301A010BSMapper.editResultRP(hempinResult, param);
			if (JDKBPCommon.hasError(param))
			{
				contractData.put("kktk_svc_kiy_no_err_list", errors);
				throw new SCCallException("返品承認処理失敗", "0", 
										Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
		}

		// サービス契約番号が入力されているデータの返品機器データを承認する
		// データの振り分けはマッパー内部で実施する
		HashMap miukeireHmpinParamMap = EDK0301C070BSMapper.editInMsg(param);
		if (hasArgument(miukeireHmpinParamMap))
		{
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "返品機器未受入承認処理の実行");
			Map miukeireHempinResult = scCall.run(miukeireHmpinParamMap, handle);
			EDK0301C070BSMapper.editResultRP(miukeireHempinResult, param);
			if (JDKBPCommon.hasError(param))
			{
				contractData.put("kktk_svc_kiy_no_err_list", errors);
				throw new SCCallException("返品承認処理失敗", "0", 
											Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
		}

		// サービス契約番号が入力されている返品機器データのうち、倉入れ情報を削除する
		HashMap kuraireDeleteInput = EDK0301E010BSMapper.editInMsg(param);
		if (hasArgument(kuraireDeleteInput))
		{
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "返品機器削除処理の実行");
			Map kuraireDeleteResult = scCall.run(kuraireDeleteInput, handle);
			EDK0301E010BSMapper.editResultRP(kuraireDeleteResult, param);
			if (JDKBPCommon.hasError(param))
			{
				contractData.put("kktk_svc_kiy_no_err_list", errors);
				throw new SCCallException("返品承認処理失敗", "0", 
											Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
		}

		// サービス契約番号が入力されていない返品機器データを承認する
		// データの振り分けはマッパー内部で実施する
		HashMap<String, Object> approveParamMap = EDK0301C030BSMapper.editInMsg(param);
		if (hasArgument(approveParamMap))
		{
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "返品機器承認処理の実行");
			Map approveResult = scCall.run(approveParamMap, handle);
			param = EDK0301C030BSMapper.editResultRP(approveResult, param);
			if (JDKBPCommon.hasError(param))
			{
				contractData.put("kktk_svc_kiy_no_err_list", errors);
				throw new SCCallException("返品承認処理失敗", "0", 
											Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
		}
// OM-2018-0000010 DEL START
//// ST-2017-0000015 ADD START
//		// ＳＴＢ情報更新
//		updateSTB(param, unlinkMap, scCall, handle);
//// ST-2017-0000015 ADD END
// OM-2018-0000010 DEL END
		
		// 承認の場合は宅内更新を実施する
		if (JDKStrConst.HMPIN_KIKI_STAT_SHONIN.equals(updateStat))
		{
// OM-2018-0000010 ADD START
			// ＳＴＢ情報更新
			updateSTB(param, unlinkMap, scCall, handle);
// OM-2018-0000010 ADD END
			// 宅内機器一覧照会(5)（製造番号ありのデータのみ）
			HashMap<String, Object> takunaiKikiMap = new HashMap<String, Object>();
			takunaiKikiMap = EDKA0010008BSMapper.editInMsg(param);
			// 宅内機器一覧照会(5)処理の処理対象件数が1件以上の場合
			if (0 < Integer.parseInt((String) takunaiKikiMap.get("tkCnt"))) {
				JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "宅内機器一覧照会(5)処理の実行");
				Map takunaiResult = scCall.run(takunaiKikiMap, handle);
				param = EDKA0010008BSMapper.editResultRP(takunaiResult, param);
				if (JDKBPCommon.hasError(param))
				{
					throw new SCCallException("返品承認処理失敗", "0", 
												Integer.parseInt(param.getControlMapData("returnCode").toString()));
				}
				
				JDKBPCommon.throwScExceptionIfHasError("返品承認処理リターンコード不正", param);
				
				// 問い合わせした件数
				String tkRequestCnt = (String) takunaiKikiMap.get("tkCnt");
				
				// 問い合わせ結果件数
				Map dataMap = (Map)param.getData("DKSV008101CC");
				String tkResultCnt = (String) dataMap.get("resultCnt");
				
				// 問い合わせした結果と件数が異なる場合
				if(Integer.parseInt(tkRequestCnt) != Integer.parseInt(tkResultCnt))
				{
					// 「宅内機器に該当の製造番号が存在しません。」のメッセージを設定
					JDKBPCommon.addError(param, 
							"kiki_seizo_no_err", 
							"EA", "EDKA0010008", 1100, 0);
					throw new SCCallException("宅内機器一覧照会(5)処理（データ存在チェックエラー）", "0", StatusCodes.RELATION_ERR);
				}
			}
			
			// 宅内機器返品情報更新
			HashMap<String, Object> stockMap = new HashMap<String, Object>();
			stockMap = EDKA0010005BSMapper.editInMsg(param);

			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "宅内機器返品情報更新処理の実行");
			Map takunaiResult = scCall.run(stockMap, handle);
			param = EDKA0010005BSMapper.editResultRP(takunaiResult, param);
			if (JDKBPCommon.hasError(param))
			{
				throw new SCCallException("返品承認処理失敗", "0", 
											Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
			
			// ANK-2119-00-00 ADD START
			// 返品SOD発行処理
			this.addHmpinSodHakko(approveDatas, handle, param, scCall);
			// ANK-2119-00-00 ADD END
			
			JDKBPCommon.throwScExceptionIfHasError("返品承認処理リターンコード不正", param);
		}
		
		// 返品の受付済のデータを作る（取消処理かつ倉入済レコードの提供種別が買取品以外の場合）
		if (JDKStrConst.HMPIN_KIKI_STAT_TORIKESHI.equals(updateStat))
		{
			cancelWorkMap = (HashMap)param.getData("workMap");
			List<Map> cancelWorkList = (List<Map>)cancelWorkMap.get("workList");
			for (Map data : cancelWorkList)
			{
				JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "返品機器番号1:" + data.get("key_hmpin_kiki_no").toString());
				// 返品機器スキーマの一意照会を呼んで必要な情報を取得する
				HashMap<String, Object> hmpinReMap = new HashMap<String, Object>();
				hmpinReMap = EDK0301A010_01BSMapper.editInMsg(param, data.get("key_hmpin_kiki_no").toString());
				JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "返品一意照会情報取得(取消時受付済元ネタ取得用)処理の実行");
				Map hmpinReResult = scCall.run(hmpinReMap, handle);
				EDK0301A010_01BSMapper.editResultRP(hmpinReResult, param);
				if (JDKBPCommon.hasError(param))
				{
					throw new SCCallException("返品一意照会情報取得(取消時受付済元ネタ取得用)失敗", "0", 
												Integer.parseInt(param.getControlMapData("returnCode").toString()));
				}
				
				// 返品機器の受付登録のサービスIFを呼ぶ
				// ※機能コードが１で来た時だけ実行する(関連チェックでエラーとなる為)
				if ("1".equals(contractData.get("func_code")))
				{
					JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "EDK0301D010BSMapper開始");
					HashMap hmpinInsMap = EDK0301D010BSMapper.editInMsg(param);
					JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "返品機器受付処理の実行");
					Map hmpinInsResult = scCall.run(hmpinInsMap, handle);
					EDK0301D010BSMapper.editResultRP(hmpinInsResult, param);
					if (JDKBPCommon.hasError(param))
					{
						throw new SCCallException("返品機器受付処理失敗", "0", 
													Integer.parseInt(param.getControlMapData("returnCode").toString()));
					}
				}
			}
		}
// ST-2017-0000015 DEL START
//// ANK-3080-00-00 ADD START
//		// ＳＴＢ情報更新
//		updateSTB(param, unlinkMap, scCall, handle);
////ANK-3080-00-00 ADD END
// ST-2017-0000015 DEL END
		return param;
	}

	/**
	 * 機器提供コード一覧を取得する
	 * ただし取得されるのは入力チェック対象のみ
	 * @param param パラメータ
	 * @return コード一覧
	 * @throws RequestParameterException 例外発生時
	 */
	@SuppressWarnings("unchecked")
	private Map<String, String> kikiTeikyoCds(IRequestParameterReadWrite param) throws RequestParameterException  
	{
		Map<String, String> map = new HashMap<String, String>();

		HashMap inMap = (HashMap)param.getData(DKSV008101CC);

		List<Map> list = (List)inMap.get("key_hmpin_kiki_list");

		for (Map data : list)
		{
			if ("".equals(data.get("key_kktk_svc_kei_no"))) 
			{
				continue;
			}

			if ("".equals(data.get("tk_sbt_cd")))
			{
				continue;
			}
			// ここでチェック対象のキャンセル品、レンタル品以外を読み飛ばしておく
			if (!HMPIN_KBN.contains(data.get("key_hmpin_kbn")))
			{
				continue;
			}

			map.put((String)data.get("key_kktk_svc_kei_no"), (String)data.get("tk_sbt_cd"));
		}

		return map;
	}

	@SuppressWarnings("unchecked")
	private boolean hasArgument(Map map) throws RequestParameterException
	{

		if (!map.containsKey(JCMConstants.TEMPLATE_LIST_KEY))
		{
			return false;
		}

		if (!(map.get(JCMConstants.TEMPLATE_LIST_KEY) instanceof CAANMsg[]))
		{
			return false;
		}

		return ((CAANMsg[])map.get(JCMConstants.TEMPLATE_LIST_KEY)).length != 0;
	}

	//ANK-2141-00-00 ADD START
	/**
	 * 宅内機器一意照会(2)処理を行う
	 * @param param
	 * @param csvData
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public HashMap<String, Object> editInMsg(IRequestParameterReadWrite param,String key_tk_mdl_cd,String key_kk_seizo_no)throws RequestParameterException 
	{

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

		/* SCインプット共通データ */
		// **********************************************
		// 【取得元：電文ヘッダ(ヘッダ)】
		// **********************************************
		// 電文ID
		paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID());
		// ユースケースID
		paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID());
		// オペレーションID
		paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID());
		// サービス呼び出し区分
		paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType());

		// **********************************************
		// 【取得元：ユーザエリア(コントロールマップ)】
		// **********************************************
		// 依頼先ホスト名
		paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTNAME));
		// 依頼元IPアドレス
		paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTIP));
		// 依頼元画面ID
		paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, param.getControlMapData(SCControlMapKeys.REQ_VIEWID));
		// オペレータID
		paramMap.put(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));

		CAANMsg template = new CAANMsg(EWCA0010002CBSMsg.class.getName());

		HashMap inMap = null;

		// テンプレートID
		template.set(EWCA0010002CBSMsg.TEMPLATEID, "EWCA0010002");


		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);

		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);

		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		

		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(DKSV008101CC);
		
		if(inMap != null)
		{
			// 機能コード（デフォルト：１）
			template.set(EWCA0010002CBSMsg.FUNC_CODE, "1");
		}
		
		if (key_tk_mdl_cd == null || "".equals(key_tk_mdl_cd)) 
		{
			template.setNull(EWCA0010002CBSMsg.KEY_TK_MDL_CD);
		} 
		else 
		{
			template.set(EWCA0010002CBSMsg.KEY_TK_MDL_CD, key_tk_mdl_cd);
		}
		
		if (key_kk_seizo_no == null || "".equals(key_kk_seizo_no)) 
		{
			template.setNull(EWCA0010002CBSMsg.KEY_KK_SEIZO_NO);
		} 
		else 
		{
			template.set(EWCA0010002CBSMsg.KEY_KK_SEIZO_NO, key_kk_seizo_no);
		}


		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	//ANK-2141-00-00 ADD END
	
	// ANK-2119-00-00 ADD START
	/**
	 * 返品SOD発行処理
	 * @param approveDatas
	 * @param handle
	 * @param param
	 * @param scCall
	 * @throws Throwable 
	 */
	@SuppressWarnings("unchecked")
	private void addHmpinSodHakko(List<Map> approveDatas, SessionHandle handle, IRequestParameterReadWrite param, ServiceComponentRequestInvoker scCall) throws Exception
	{
		// 作業領域を取得
		Map workMap = (Map)param.getMappingWorkArea();
		if (workMap == null) {
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// SOD作業領域が無い場合
		if (!workMap.containsKey(SOD_WORKAREA_KEY))
		{
			// 作業領域にSOD作業領域を設定
			Map sodWorkMap = new HashMap();
			workMap.put(SOD_WORKAREA_KEY, sodWorkMap);
		}
		
		// SOD作業領域を取得
		Map sodWorkMap = this.getSodWorkMap(param);

//ANK-2406-00-00 ADD START
		/* ユーザデータ情報 */
		HashMap inMap = (HashMap)param.getData(DKSV008101CC);
//ANK-2406-00-00 ADD END
		
		// 画面で選択された機器の数だけ繰り返す
		Iterator<Map> ite = approveDatas.iterator();
		while (ite.hasNext())
		{
			
			// 機器情報を取得
			Map map = ite.next();

//ANK-2406-00-00 ADD START
			if (checkErrList(inMap, "kktk_svc_kiy_stat_err_list", map)) {
				continue;
			}
	
			if (checkErrList(inMap, "kktk_svc_kiy_hen_err_list", map)) {
				continue;
			}
	
// ANK-3080-00-00 DEL START
//			if (checkErrList(inMap, "kktk_svc_kiy_rink_err_list", map)) {
//				continue;
//			}
// ANK-3080-00-00 DEL START
	
			if (checkErrList(inMap, "kktk_svc_kiy_son_err_list", map)) {
				continue;
			}
//ANK-2406-00-00 ADD END
			
			// IT1-2014-0000368 ADD START
			// 機器提供サービス契約一覧照会(機器製造番号)
			HashMap ekk0341B001InMap = new HashMap();
			
			// SOD作業領域に、画面で選択された機器の機器製造番号を設定
			String kikiSeizoNo = null;
			if (map.containsKey("key_kk_seizo_no"))
			{
				kikiSeizoNo = (String) map.get("key_kk_seizo_no");
			}
			
			// OM-2014-0003844 ADD START
			// 機器製造番号が取得できない場合
			if (null == kikiSeizoNo || 0 == kikiSeizoNo.length())
			{
				// 返品SOD発行処理は行わず、次の機器へ処理を移行する。
				continue;
			}
			// OM-2014-0003844 ADD END
			
			ekk0341B001InMap.put(EKK0341B001CBSMsg.KEY_KIKI_SEIZO_NO, kikiSeizoNo);
			sodWorkMap.put(DKSV0081_DKSV0081OP_EKK0341B001BSMapper.TEMPLATEID, ekk0341B001InMap);
			
			HashMap ekk0341B001ParamMap = EKK0341B001BSMapper.editInMsg(param);
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "機器提供サービス契約一覧照会(機器製造番号)処理の実行");
			Map ekk0341B001ResultMap = scCall.run(ekk0341B001ParamMap, handle);
			param = EKK0341B001BSMapper.editResultRP(ekk0341B001ResultMap, param);
			if (JDKBPCommon.hasError(param))
			{
				throw new SCCallException("機器提供サービス契約一覧照会(機器製造番号)失敗", "0", 
						Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
			
			// 機器提供サービス契約一覧照会(機器製造番号)下り
			HashMap ekk0341B001OutMap = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK0341B001BSMapper.TEMPLATEID);
			// 明細取得
			List ekk0341B001CbsMsg1List = (List) ekk0341B001OutMap.get(EKK0341B001CBSMsg.EKK0341B001CBSMSG1LIST);
			
			// 画面で選択された機器の機器提供サービス契約番号
			String keyKktkSvcKeiNo = (String) map.get("key_kktk_svc_kei_no");
			// OM-2015-0000671 ADD START
			// 機器提供サービス契約番号が取得できない場合
			if (null == keyKktkSvcKeiNo || 0 == keyKktkSvcKeiNo.length())
			{
				// 返品SOD発行処理は行わず、次の機器へ処理を移行する。
				continue;
			}
			// OM-2015-0000671 ADD END
			// 世代年月日時分秒
			String geneAddDtm = null;
			
			Iterator ekk0341B001Ite = ekk0341B001CbsMsg1List.iterator();
			while (ekk0341B001Ite.hasNext())
			{
				HashMap ekk0341B001CbsMsgSub = (HashMap) ekk0341B001Ite.next();
				
				String subKey = (String) ekk0341B001CbsMsgSub.get(EKK0341B001CBSMsg1List.KKTK_SVC_KEI_NO);
				
				// 機器提供サービス契約番号が一致した場合
				if (keyKktkSvcKeiNo.equals(subKey))
				{
					// 世代年月日時分秒を取得
					geneAddDtm = (String) ekk0341B001CbsMsgSub.get(EKK0341B001CBSMsg1List.GENE_ADD_DTM);
					break;
				}
			}
			// IT1-2014-0000368 ADD END
			
			// 機器提供サービス契約一意照会
			HashMap ekk0341A010_02InMap = new HashMap();
			ekk0341A010_02InMap.put(EKK0341A010CBSMsg.KEY_KKTK_SVC_KEI_NO, (String) map.get("key_kktk_svc_kei_no"));
			// IT1-2014-0000368 ADD START
			ekk0341A010_02InMap.put(EKK0341A010CBSMsg.KEY_GENE_ADD_DTM, geneAddDtm);
			// IT1-2014-0000368 ADD END
			
			sodWorkMap.put(DKSV0081_DKSV0081OP_EKK0341A010_02BSMapper.TEMPLATEID, ekk0341A010_02InMap);
			
			HashMap ekk0341A010_02ParamMap = EKK0341A010_02BSMapper.editInMsg(param);
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "機器提供サービス契約一意照会処理の実行");
			Map ekk0341A010_02ResultMap = scCall.run(ekk0341A010_02ParamMap, handle);
			param = EKK0341A010_02BSMapper.editResultRP(ekk0341A010_02ResultMap, param);
			if (JDKBPCommon.hasError(param))
			{
				throw new SCCallException("機器提供サービス契約一意照会失敗", "0", 
						Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
			
			// 機器提供サービス契約一意照会下り
			HashMap ekk0341A010_02OutMap = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK0341A010_02BSMapper.TEMPLATEID);
			// 明細取得
			List ekk0341A010CbsMsg1List = (List) ekk0341A010_02OutMap.get(EKK0341A010CBSMsg.EKK0341A010CBSMSG1LIST);
			
			// 機器提供サービス契約一意照会でレコードが取得できなかった場合
			if (ekk0341A010CbsMsg1List.size() == 0)
			{
				// 返品SOD発行処理は行わない。
				continue;
			}
			
			// カレント取得
			Map tmpKK0341A001Map = (HashMap) ekk0341A010CbsMsg1List.get(0);
			
			// IT1-2014-0000348 ADD START
			String tkMdlCd = null;
			if (map.containsKey("key_tk_mdl_cd"))
			{
				tkMdlCd = (String) map.get("key_tk_mdl_cd");
			}
			// IT1-2014-0000348 ADD END
			
			// 宅内機器型式一意照会 上り
			HashMap ezm0411A010InMap = new HashMap();
			// SOD作業領域に、選択された機器の宅内機器型式コードを設定
			// IT1-2014-0000348 MOD START
			//ezm0411A010InMap.put(EZM0411A010CBSMsg.KEY_TAKNKIKI_MODEL_CD, (String) tmpKK0341A001Map.get(EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD));
			ezm0411A010InMap.put(EZM0411A010CBSMsg.KEY_TAKNKIKI_MODEL_CD, tkMdlCd);
			// IT1-2014-0000348 MOD END
			
			sodWorkMap.put(DKSV0081_DKSV0081OP_EZM0411A010BSMapper.TEMPLATEID, ezm0411A010InMap);
			
			// 宅内機器型式一意照会
			HashMap<String, Object> ezm0411A010ParamMap = EZM0411A010BSMapper.editInMsg(param);
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "宅内機器型式一意照会処理の実行");
			Map ezm0411A010ResultMap = scCall.run(ezm0411A010ParamMap, handle);
			param = EZM0411A010BSMapper.editResultRP(ezm0411A010ResultMap, param);
			if (JDKBPCommon.hasError(param))
			{
				throw new SCCallException("宅内機器型式一意照会処理失敗", "0", 
						Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
			
			// 宅内機器型式一意照会 下り
			HashMap ezm0411A010OutMap = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EZM0411A010BSMapper.TEMPLATEID);
			// 明細取得
			ArrayList ezm0411A010CbsMsg1List = (ArrayList) ezm0411A010OutMap.get(EZM0411A010CBSMsg.EZM0411A010CBSMSG1LIST);
			
			// 宅内機器型式一意照会でレコードが取得できなかった場合
			if (ezm0411A010CbsMsg1List.size() == 0)
			{
				// 返品SOD発行処理は行わない。
				continue;
			}
			
			HashMap ezm0411A010CbsMsg = (HashMap) ezm0411A010CbsMsg1List.get(0);
			
			// 宅内機器種別コードを取得
			String tkniKikiSbtCd = (String) ezm0411A010CbsMsg.get(EZM0411A010CBSMsg1List.TAKNKIKI_SBT_CD);
			
			// 宅内機器種別コードが、返品SOD発行対象でない場合
			if (!this.checkTkniKikiSbtCd(tkniKikiSbtCd))
			{
				// 返品SOD発行処理は行わない。
				continue;
			}
			
			// 機器提供サービス契約一覧（返品SOD発行）上り
			HashMap ekk0341B034InMap = new HashMap();
			
			// SOD作業領域に、画面で選択された機器の機器提供サービス契約番号を設定
			ekk0341B034InMap.put(EKK0341B034CBSMsg.KEY_KKTK_SVC_KEI_NO, (String) map.get("key_kktk_svc_kei_no"));
// OM-2016-0000175 ADD START
			// SOD作業領域に、画面で選択された機器の機器製造番号を設定
			ekk0341B034InMap.put(EKK0341B034CBSMsg.KEY_KK_SEIZO_NO, (String) map.get("key_kk_seizo_no"));
// OM-2016-0000175 ADD END
			sodWorkMap.put(DKSV0081_DKSV0081OP_EKK0341B034BSMapper.TEMPLATEID, ekk0341B034InMap);
			
			// 機器提供サービス契約一覧照会（返品SOD発行）
			HashMap ekk0341B034ParamMap = EKK0341B034BSMapper.editInMsg(param);
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "機器提供サービス契約一覧照会（返品SOD発行）処理の実行");
			Map ekk0341B034ResultMap = scCall.run(ekk0341B034ParamMap, handle);
			param = EKK0341B034BSMapper.editResultRP(ekk0341B034ResultMap, param);
			if (JDKBPCommon.hasError(param))
			{
				throw new SCCallException("機器提供サービス契約一覧照会（返品SOD発行）失敗", "0", 
						Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
			
			// 機器提供サービス契約一覧（返品SOD発行）下り
			HashMap ekk0341B034OutMap = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK0341B034BSMapper.TEMPLATEID);
			// 明細取得
			List kk0341B034CbsMsg1List = (List) ekk0341B034OutMap.get(EKK0341B034CBSMsg.EKK0341B034CBSMSG1LIST);
			
			// 機器提供サービス契約一覧照会（返品SOD発行）でレコードが取得できなかった場合
			if (kk0341B034CbsMsg1List.size() == 0)
			{
				// 返品SOD発行処理は行わない。
				continue;
			}
			
			// 返品SOD発行対象フラグ
			boolean isSod = false;
			
			// 機器提供サービス契約一覧照会（返品SOD発行）で取得した分だけ繰り返す
			Iterator kk0341B034Ite = kk0341B034CbsMsg1List.iterator();
			while (kk0341B034Ite.hasNext())
			{
				Map kk0341B034Map = (Map) kk0341B034Ite.next();
				String kktkSvcKeiNo = (String) kk0341B034Map.get(EKK0341B034CBSMsg1List.KKTK_SVC_KEI_NO);
				String kikiChgNo = (String) kk0341B034Map.get(EKK0341B034CBSMsg1List.KIKI_CHG_NO);
				
				// 以下の何れかに該当すれば、返品SOD発行処理対象とする。
				// 機器変更番号が変更されている（機器の交換が行われ、返品承認が行われている）
				if (tmpKK0341A001Map.get(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO).equals(kktkSvcKeiNo) &&
						!tmpKK0341A001Map.get(EKK0341A010CBSMsg1List.KIKI_CHG_NO).equals(kikiChgNo))
				{
					isSod = true;
					break;
				}
				
				// 機器提供サービス契約が解約されている（機器が解約され、返品承認が行われている）
				else if (tmpKK0341A001Map.get(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO).equals(kktkSvcKeiNo) &&
						tmpKK0341A001Map.get(EKK0341A010CBSMsg1List.KIKI_CHG_NO).equals(kikiChgNo) &&
						(tmpKK0341A001Map.get(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_STAT).equals("910") || tmpKK0341A001Map.get(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_STAT).equals("920")))
				{
					isSod = true;
					break;
				}
				
				// OM-2020-0000461 ADD START
				else if (JDKStrConst.MODEL_CHANGE.equals((String) map.get("key_hmpin_kbn")))
				{
					isSod = true;
					break;
				}
				// OM-2020-0000461 ADD END
			}
			
			// 返品SOD発行対象の場合
			if (isSod)
			{
				// IT1-2014-0000341 MOD START
				// サービス契約番号
				String svcKeiNo = null;
				
				// ANK-4315-00-00 MOD START
				// 多機能ルータもしくはＨＧＷの場合、機器提供サービス契約のサービス契約回線内訳番号からサービス契約を取得する。
				//if ("R0".equals(tkniKikiSbtCd))
				if ("R0".equals(tkniKikiSbtCd) || "S0".equals(tkniKikiSbtCd))
				// ANK-4315-00-00 MOD END
				{
					// IT1-2014-0000341 DEL START
					// EKK0081B007_回線利用中サービス契約一覧照会
					//HashMap ekk0081B007InMap = new HashMap();
					//ekk0081B007InMap.put(EKK0081B007CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO, tmpKK0341A001Map.get(EKK0341A010CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO));
					//
					//sodWorkMap.put(DKSV0081_DKSV0081OP_EKK0081B007BSMapper.TEMPLATE_ID, ekk0081B007InMap);
					//
					//HashMap<String, Object> ekk0081B007ParamMap = EKK0081B007BSMapper.editInMsg(param);
					//JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "回線利用中サービス契約一覧照会処理の実行");
					//Map ekk0081B007ResultMap = scCall.run(ekk0081B007ParamMap, handle);
					//param = EKK0081B007BSMapper.editResultRP(ekk0081B007ResultMap, param);
					//if (JDKBPCommon.hasError(param))
					//{
					//	throw new SCCallException("回線利用中サービス契約一覧照会処理失敗", "0", 
					//			Integer.parseInt(param.getControlMapData("returnCode").toString()));
					//}
					//
					// 回線利用中サービス契約一覧照会下り
					//HashMap ekk0081B007OutMap = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK0081B007BSMapper.TEMPLATE_ID);
					// 明細取得
					//ArrayList ekk0081B007CbsMsg1List = (ArrayList) ekk0081B007OutMap.get(EKK0081B007CBSMsg.EKK0081B007CBSMSG1LIST);
					//
					// 回線利用中サービス契約一覧照会でレコードが取得できなかった場合
					//if (ekk0081B007CbsMsg1List.size() == 0)
					//{
					//	// 返品SOD発行処理は行わない。
					//	continue;
					//}
					//
					//HashMap ekk0081B007CbsMsg = (HashMap) ekk0081B007CbsMsg1List.get(0);
					//
					//svcKeiNo = (String) ekk0081B007CbsMsg.get(EKK0081B007CBSMsg1List.SVC_KEI_NO);
					// IT1-2014-0000341 DEL END
					
					// IT1-2014-0000341 ADD START
					// EKK0081B034_機器提供サービス契約サービス契約番号一覧照会
					HashMap ekk0081B034InMap = new HashMap();
					ekk0081B034InMap.put(EKK0081B034CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO, tmpKK0341A001Map.get(EKK0341A010CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO));
					
					sodWorkMap.put(DKSV0081_DKSV0081OP_EKK0081B034BSMapper.TEMPLATE_ID, ekk0081B034InMap);
					
					HashMap<String, Object> ekk0081B034ParamMap = EKK0081B034BSMapper.editInMsg(param);
					JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "機器提供サービス契約サービス契約番号一覧照会処理の実行");
					Map ekk0081B034ResultMap = scCall.run(ekk0081B034ParamMap, handle);
					param = EKK0081B034BSMapper.editResultRP(ekk0081B034ResultMap, param);
					if (JDKBPCommon.hasError(param))
					{
						throw new SCCallException("機器提供サービス契約サービス契約番号一覧照会処理失敗", "0", 
								Integer.parseInt(param.getControlMapData("returnCode").toString()));
					}
					
					// 機器提供サービス契約サービス契約番号一覧照会下り
					HashMap ekk0081B034OutMap = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK0081B034BSMapper.TEMPLATE_ID);
					// 明細取得
					ArrayList ekk0081B034CbsMsg1List = (ArrayList) ekk0081B034OutMap.get(EKK0081B034CBSMsg.EKK0081B034CBSMSG1LIST);
					
					// 機器提供サービス契約サービス契約番号一覧照会でレコードが取得できなかった場合
					if (ekk0081B034CbsMsg1List.size() == 0)
					{
						// 返品SOD発行処理は行わない。
						continue;
					}
					
					HashMap ekk0081B034CbsMsg = null;
					Iterator<HashMap> cbsMsgListIte = ekk0081B034CbsMsg1List.iterator();
					while (cbsMsgListIte.hasNext())
					{
						
						HashMap cbsMsg = cbsMsgListIte.next();
						
						// ネット優先
						if (JKKStrConst.CD00130_01.equals(cbsMsg.get(EKK0081B034CBSMsg1List.SVC_CD)))
						{
							ekk0081B034CbsMsg = cbsMsg;
							break;
						}
						
						if (null == ekk0081B034CbsMsg || JKKStrConst.CD00130_02.equals(cbsMsg.get(EKK0081B034CBSMsg1List.SVC_CD)))
						{
							ekk0081B034CbsMsg = cbsMsg;
						}
					}
					
					svcKeiNo = (String) ekk0081B034CbsMsg.get(EKK0081B034CBSMsg1List.SVC_KEI_NO);
					// IT1-2014-0000341 ADD END
				}
				// 多機能ルータ以外の場合、機器提供サービス契約のサービス契約番号を取得する。
				else
				{
					svcKeiNo = (String)tmpKK0341A001Map.get(EKK0341A010CBSMsg1List.SVC_KEI_NO);
				}
				
				HashMap ekk0081A010InMap = new HashMap();
				ekk0081A010InMap.put(EKK0081A010CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);
				// IT1-2014-0000341 MOD END
				
				sodWorkMap.put(DKSV0081_DKSV0081OP_EKK0081A010BSMapper.TEMPLATE_ID, ekk0081A010InMap);
				
				// サービス契約一意照会
				HashMap<String, Object> ekk0081A010ParamMap = EKK0081A010BSMapper.editInMsg(param);
				JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "サービス契約一意照会処理の実行");
				Map ekk0081A010ResultMap = scCall.run(ekk0081A010ParamMap, handle);
				param = EKK0081A010BSMapper.editResultRP(ekk0081A010ResultMap, param);
				if (JDKBPCommon.hasError(param))
				{
					throw new SCCallException("サービス契約一意照会処理失敗", "0", 
							Integer.parseInt(param.getControlMapData("returnCode").toString()));
				}
				
				// サービス契約一意照会 下り
				HashMap ekk0081A010OutMap = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK0081A010BSMapper.TEMPLATE_ID);
				// 明細取得
				ArrayList ekk0081A010CbsMsg1List = (ArrayList) ekk0081A010OutMap.get(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);
				
				// サービス契約一意照会でレコードが取得できなかった場合
				if (ekk0081A010CbsMsg1List.size() == 0)
				{
					// 返品SOD発行処理は行わない。
					continue;
				}
				
				// IT1-2014-0000341 DEL START
				// サービス契約内訳一覧照会
				//HashMap ekk0161B004InMap = new HashMap();
				//
				// SOD作業領域に、画面で選択された機器のサービス契約番号を設定
				//ekk0161B004InMap.put(EKK0161B004CBSMsg.KEY_SVC_KEI_NO, (String) tmpKK0341A001Map.get(EKK0341A010CBSMsg1List.SVC_KEI_NO));
				//sodWorkMap.put(DKSV0081_DKSV0081OP_EKK0161B004BSMapper.TEMPLATEID, ekk0161B004InMap);
				//
				// サービス契約内訳一覧照会
				//HashMap ekk0161B004ParamMap = EKK0161B004BSMapper.editInMsg(param);
				//JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "サービス契約内訳一覧照会処理の実行");
				//Map ekk0161B004ResultMap = scCall.run(ekk0161B004ParamMap, handle);
				//param = EKK0161B004BSMapper.editResultRP(ekk0161B004ResultMap, param);
				//if (JDKBPCommon.hasError(param))
				//{
				//	throw new SCCallException("サービス契約内訳一覧照会失敗", "0", 
				//			Integer.parseInt(param.getControlMapData("returnCode").toString()));
				//}
				// IT1-2014-0000341 DEL END
				
				// 同一処理番号を取得
				HashMap ekk1081C011InMap = new HashMap();
				
				sodWorkMap.put(DKSV0081_DKSV0081OP_EKK1081C011BSMapper.TEMPLATEID, ekk1081C011InMap);
				
				HashMap ekk1081C011ParamMap = EKK1081C011BSMapper.editInMsg(param);
				JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "同一処理番号取得処理の実行");
				Map ekk1081C011ResultMap = scCall.run(ekk1081C011ParamMap, handle);
				param = EKK1081C011BSMapper.editResultRP(ekk1081C011ResultMap, param);
				if (JDKBPCommon.hasError(param))
				{
					throw new SCCallException("同一処理番号取得処理失敗", "0", 
							Integer.parseInt(param.getControlMapData("returnCode").toString()));
				}
				
				String sameTrnNo =  (String) ((HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK1081C011BSMapper.TEMPLATEID)).get(EKK1081C011CBSMsg.SAME_TRN_NO);
				
				// 返品ＳＯＤ対象抽出の宅内機器種別コードが "50"（光電話ＶＡ）の場合
				if ("50".equals(tkniKikiSbtCd))
				{
					// オーダ発行条件に対してＶＡ解約の情報を登録する
					// IT1-2014-0000348 MOD START
					// this.insertOdrHakkoJoken(tmpKK0341A001Map, "2", "20", "03", sameTrnNo, handle, param, scCall);
					this.insertOdrHakkoJoken(map, tmpKK0341A001Map, "2", "20", "03", sameTrnNo, handle, param, scCall);
					// IT1-2014-0000348 MOD END
					// オーダ情報作成ワークに対してＶＡ解約の情報を登録する
					this.insertOdrInfSksiWk("215", handle, param, scCall);
					// オーダ発行条件に対してＶＡ消去の情報を登録する
					// IT1-2014-0000348 MOD START
					// this.insertOdrHakkoJoken(tmpKK0341A001Map, "2", "20", "08", sameTrnNo, handle, param, scCall);
					this.insertOdrHakkoJoken(map, tmpKK0341A001Map, "2", "20", "08", sameTrnNo, handle, param, scCall);
					// IT1-2014-0000348 MOD END
					// オーダ情報作成ワークに対してＶＡ消去の情報を登録する
					this.insertOdrInfSksiWk("216", handle, param, scCall);
				}
				// 返品ＳＯＤ対象抽出の宅内機器種別コードが "F0"（ＢＢＲ）の場合
				else if ("F0".equals(tkniKikiSbtCd))
				{
					// オーダ発行条件に対してルータ解約の情報を登録する
					// IT1-2014-0000348 MOD START
					// this.insertOdrHakkoJoken(tmpKK0341A001Map, "1", "0A", "03", sameTrnNo, handle, param, scCall);
					this.insertOdrHakkoJoken(map, tmpKK0341A001Map, "1", "0A", "03", sameTrnNo, handle, param, scCall);
					// IT1-2014-0000348 MOD END
					// オーダ情報作成ワークに対してルータ解約の情報を登録する
					this.insertOdrInfSksiWk("149", handle, param, scCall);
					// オーダ発行条件に対してルータ消去の情報を登録する
					// IT1-2014-0000348 MOD START
					// this.insertOdrHakkoJoken(tmpKK0341A001Map, "1", "0A", "08", sameTrnNo, handle, param, scCall);
					this.insertOdrHakkoJoken(map, tmpKK0341A001Map, "1", "0A", "08", sameTrnNo, handle, param, scCall);
					// IT1-2014-0000348 MOD END
					// オーダ情報作成ワークに対してルータ消去の情報を登録する
					this.insertOdrInfSksiWk("150", handle, param, scCall);
				}
				// 返品ＳＯＤ対象抽出の宅内機器種別コードが "J0"（ＵＱ）の場合
				else if ("J0".equals(tkniKikiSbtCd))
				{
					// IT1-2014-0000368 ADD START
					// サービス契約内訳一覧照会
					HashMap ekk0161B004InMap = new HashMap();
					
					// SOD作業領域に、画面で選択された機器のサービス契約番号を設定
					ekk0161B004InMap.put(EKK0161B004CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);
					sodWorkMap.put(DKSV0081_DKSV0081OP_EKK0161B004BSMapper.TEMPLATEID, ekk0161B004InMap);
					//
					// サービス契約内訳一覧照会
					HashMap ekk0161B004ParamMap = EKK0161B004BSMapper.editInMsg(param);
					JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "サービス契約内訳一覧照会処理の実行");
					Map ekk0161B004ResultMap = scCall.run(ekk0161B004ParamMap, handle);
					param = EKK0161B004BSMapper.editResultRP(ekk0161B004ResultMap, param);
					if (JDKBPCommon.hasError(param))
					{
						throw new SCCallException("サービス契約内訳一覧照会失敗", "0", 
								Integer.parseInt(param.getControlMapData("returnCode").toString()));
					}
					// IT1-2014-0000368 ADD END
					
					// オーダ発行条件に対してUQ解約の情報を登録する
					// IT1-2014-0000348 MOD START
					// this.insertOdrHakkoJoken(tmpKK0341A001Map, "3", "02", "03", sameTrnNo, handle, param, scCall);
					this.insertOdrHakkoJoken(map, tmpKK0341A001Map, "3", "02", "03", sameTrnNo, handle, param, scCall);
					// IT1-2014-0000348 MOD END
					// オーダ情報作成ワークに対してUQ解約の情報を登録する
					this.insertOdrInfSksiWk("309", handle, param, scCall);
				}
				// ANK-4315-00-00 MOD START
				//else if (JKKStrConst.TAKNKIKI_SBT_CD_TAKINORT.equals(tkniKikiSbtCd))
				// 返品ＳＯＤ対象抽出の宅内機器種別コードが "R0"(多機能ルータ)、もしくは"S0"(ＨＧＷ)の場合
				else if (JKKStrConst.TAKNKIKI_SBT_CD_TAKINORT.equals(tkniKikiSbtCd) || JKKStrConst.TAKNKIKI_SBT_CD_HGW.equals(tkniKikiSbtCd))
				// ANK-4315-00-00 MOD END
				{
					// IT1-2014-0000368 ADD START
					// サービス契約内訳一覧照会
					HashMap ekk0161B004InMap = new HashMap();
					
					// SOD作業領域に、画面で選択された機器のサービス契約番号を設定
					ekk0161B004InMap.put(EKK0161B004CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);
					sodWorkMap.put(DKSV0081_DKSV0081OP_EKK0161B004BSMapper.TEMPLATEID, ekk0161B004InMap);
					//
					// サービス契約内訳一覧照会
					HashMap ekk0161B004ParamMap = EKK0161B004BSMapper.editInMsg(param);
					JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "サービス契約内訳一覧照会処理の実行");
					Map ekk0161B004ResultMap = scCall.run(ekk0161B004ParamMap, handle);
					param = EKK0161B004BSMapper.editResultRP(ekk0161B004ResultMap, param);
					if (JDKBPCommon.hasError(param))
					{
						throw new SCCallException("サービス契約内訳一覧照会失敗", "0", 
								Integer.parseInt(param.getControlMapData("returnCode").toString()));
					}
					// IT1-2014-0000368 ADD END
					
					// IT1-2014-0000341 DEL START
					// サービス契約回線内訳一覧照会
					//HashMap ekk0251B001InMap = new HashMap();
					//
					// SOD作業領域に、画面で選択された機器のサービス契約番号を設定
					//ekk0251B001InMap.put(EKK0251B001CBSMsg.KEY_SVC_KEI_NO, (String) tmpKK0341A001Map.get(EKK0341A010CBSMsg1List.SVC_KEI_NO));
					//sodWorkMap.put(DKSV0081_DKSV0081OP_EKK0251B001BSMapper.TEMPLATEID, ekk0251B001InMap);
					//
					// サービス契約内訳一覧照会
					//HashMap ekk0251B001ParamMap = EKK0251B001BSMapper.editInMsg(param);
					//JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "サービス契約回線内訳一覧照会処理の実行");
					//Map ekk0251B001ResultMap = scCall.run(ekk0251B001ParamMap, handle);
					//param = EKK0251B001BSMapper.editResultRP(ekk0251B001ResultMap, param);
					//if (JDKBPCommon.hasError(param))
					//{
					//	throw new SCCallException("サービス契約回線内訳一覧照会失敗", "0", 
					//			Integer.parseInt(param.getControlMapData("returnCode").toString()));
					//}
					// IT1-2014-0000341 DEL END
					
					// 機器オプションサービス契約一覧照会
					HashMap ekk2811B010InMap = new HashMap();
					
					// SOD作業領域に、画面で選択された機器の機器提供サービス契約番号を設定
					ekk2811B010InMap.put(EKK2811B010CBSMsg.KEY_KKTK_SVC_KEI_NO, (String) tmpKK0341A001Map.get(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO));
					sodWorkMap.put(DKSV0081_DKSV0081OP_EKK2811B010BSMapper.TEMPLATEID, ekk2811B010InMap);
					
					HashMap ekk2811B010ParamMap = EKK2811B010BSMapper.editInMsg(param);
					JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "機器オプションサービス契約一覧照会処理の実行");
					Map ekk2811B010ResultMap = scCall.run(ekk2811B010ParamMap, handle);
					param = EKK2811B010BSMapper.editResultRP(ekk2811B010ResultMap, param);
					if (JDKBPCommon.hasError(param))
					{
						throw new SCCallException("機器オプションサービス契約一覧照会失敗", "0", 
								Integer.parseInt(param.getControlMapData("returnCode").toString()));
					}
					
					// オーダ発行条件に対して多機能ルータ解約の情報を登録する
					// IT1-2014-0000348 MOD START
					// this.insertOdrHakkoJoken(tmpKK0341A001Map, "2", "26", "03", sameTrnNo, handle, param, scCall);
					this.insertOdrHakkoJoken(map, tmpKK0341A001Map, "2", "26", "03", sameTrnNo, handle, param, scCall);
					// IT1-2014-0000348 MOD END
					// オーダ情報作成ワークに対して多機能ルータ解約の情報を登録する
					this.insertOdrInfSksiWk("423", handle, param, scCall);
					// オーダ発行条件に対して多機能ルータ消去の情報を登録する
					// IT1-2014-0000348 MOD START
					// this.insertOdrHakkoJoken(tmpKK0341A001Map, "2", "26", "08", sameTrnNo, handle, param, scCall);
					this.insertOdrHakkoJoken(map, tmpKK0341A001Map, "2", "26", "08", sameTrnNo, handle, param, scCall);
					// IT1-2014-0000348 MOD END
					// オーダ情報作成ワークに対して多機能ルータ消去の情報を登録する
					this.insertOdrInfSksiWk("424", handle, param, scCall);
				}
			}
			
			// 機器毎の処理終了時にSOD作業領域を削除
			sodWorkMap.clear();
		}
		
		workMap.remove(sodWorkMap);
	}

// ANK-3080-00-00 ADD START
	/**
	 * アンリンク処理を行う
	 * @param param
	 * @param key_tk_mdl_cd
	 * @param key_kk_seizo_no
	 * @param checkMap
	 * @param scCall
	 * @param handle
	 * @param keyHmpinKikiNo
	 * @throws Exception 
	 */
	@SuppressWarnings({ "unchecked" })
	public HashMap<String, Object> unlink(IRequestParameterReadWrite param,String keyTkMdlCd, String keyKkSeizoNo, String keySvcKeiNo, 
			HashSet<String> checkMap, ServiceComponentRequestInvoker scCall, SessionHandle handle, String keyHmpinKikiNo)throws Exception 
	{
		
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		HashMap<String, Object> tmpParamMap = new HashMap<String, Object>();
		// アンリンク判定処理
		if(checkMap != null && checkMap.size() > 0)
		{
			if(checkMap.contains(keyTkMdlCd+keyKkSeizoNo)){
				return tmpParamMap;
			}
		}
		
		// ハッシュマップにパラメータを保持
		// 宅内機器形式コード
		tmpParamMap.put("taknkiki_mdl_cd", keyTkMdlCd);
		// 機器製造番号
		tmpParamMap.put("kiki_seizo_no", keyKkSeizoNo);
		// サービス契約番号
		tmpParamMap.put("svc_kei_no", keySvcKeiNo);
		// 運用日付
		tmpParamMap.put("operate_date_key", param.getControlMapData(SCControlMapKeys.OPE_DATE));
		// 運用日時
		tmpParamMap.put("operate_datetime_key", param.getControlMapData(SCControlMapKeys.OPE_TIME));
		// オペレータID
		tmpParamMap.put("operator_id", param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		
		/* SCインプット共通データ */
		// **********************************************
		// 【取得元：電文ヘッダ(ヘッダ)】
		// **********************************************
		// 電文ID
		paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID());
		// ユースケースID
		paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID());
		// オペレーションID
		paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID());
		// サービス呼び出し区分
		paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType());
		
		// **********************************************
		// 【取得元：ユーザエリア(コントロールマップ)】
		// **********************************************
		// 依頼先ホスト名
		paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTNAME));
		// 依頼元IPアドレス
		paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTIP));
		// 依頼元画面ID
		paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, param.getControlMapData(SCControlMapKeys.REQ_VIEWID));
		// オペレータID
		paramMap.put(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		
		HashMap inMap = null;
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData(DKSV008101CC);
		
		// (a-2)返品機器リストの宅内機器型式コードを元に、宅内機器型式情報を取得する。
		// 宅内機器型式一意照会パラメータセット
		editTkniKikiMsg(paramMap, inMap, tmpParamMap);
		
		// SC呼出実行
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "宅内機器型式一意照会処理の実行(アンリンク)");
		Map<?, ?> result = scCall.run(paramMap, handle);
		editResultRrr(result, param);
		if (JDKBPCommon.hasError(param))
		{
			throw new SCCallException("宅内機器型式一意照会失敗", "0", 
					Integer.parseInt(param.getControlMapData("returnCode").toString()));
		}
		
		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg msg = templates[0];
		
		// 検索リストを取得する
		CAANMsg[] serchList = msg.getCAANMsgList(EZM0411A010CBSMsg.EZM0411A010CBSMSG1LIST);
		if ( serchList != null && serchList.length > 0 )
		{
			// 宅内機器種別コード
			tmpParamMap.put("taknkiki_sbt_cd", serchList[0].getString(EZM0411A010CBSMsg1List.TAKNKIKI_SBT_CD));
			
			// (a-3) 宅内機器管理システムより、STBステータスコードとC-CASステータスコードの情報を取得する。
			// 宅内機器一覧照会(3)パラメータセット
			editTkniKiki3Msg(paramMap, inMap, tmpParamMap);
			
			// SC呼出実行
			// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "宅内機器一覧照会(3)処理の実行");
			result = scCall.run(paramMap, handle);
			editResultRrr(result, param);
			if (JDKBPCommon.hasError(param))
			{
				throw new SCCallException("宅内機器一覧照会(3)失敗", "0", 
						Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
			
			templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
			msg = templates[0];
			
			// 検索リストを取得する
			serchList = msg.getCAANMsgList(EWCA0010001CBSMsg.EWCA0010001CBSMSG1LIST);
			if ( serchList != null && serchList.length > 0 )
			{
				// 宅内機器一覧照会(3)取得リスト
				tmpParamMap.put("EWCA0010001CBSMSG1LIST", serchList[0]);
				
				msg = serchList[0];
				String stb_stat_cd = msg.getString(EWCA0010001CBSMsg1List.STB_STAT_CD);
				String ccas_card_stat_cd = msg.getString(EWCA0010001CBSMsg1List.CCAS_CARD_STAT_CD);
				
				// アンリンク処理済判定用キーの設定(STBとC-CAS)
				checkMap.add(msg.getString(EWCA0010001CBSMsg1List.STB_TK_MDL_CD)
						+ msg.getString(EWCA0010001CBSMsg1List.STB_KK_SEIZO_NO));
				checkMap.add(msg.getString(EWCA0010001CBSMsg1List.CCAS_TK_MDL_CD)
						+ msg.getString(EWCA0010001CBSMsg1List.CCAS_KK_SEIZO_NO));
				
				// ・STBステータスがアンリンク不可（"011"(仮登録)、"012"(本運用)以外）、かつ、
				//   C-CASのステータスがアンリンク可能（"012"(リンク中)）の場合エラー
				if(!(JWCStrConst.CD_DIV_WATCH_KIKI_KANRI_STAT_KARITO.equals(stb_stat_cd) ||
						JWCStrConst.CD_DIV_WATCH_KIKI_KANRI_STAT_HONUNYO.equals(stb_stat_cd))&&
						JWCStrConst.CD_DIV_CCAS_CARD_KANRI_STAT_LINKCHU.equals(ccas_card_stat_cd)){
					tmpParamMap.put("key_unlink_unyo_hmpin_kiki_no", keyHmpinKikiNo);
					return tmpParamMap;
				}
				
				// ・STBステータスがアンリンク可能（"011"(仮登録)、"012"(本運用)）、かつ、
				//   C-CASのステータスがアンリンク不可（"012"(リンク中)以外）の場合エラー
				if((JWCStrConst.CD_DIV_WATCH_KIKI_KANRI_STAT_KARITO.equals(stb_stat_cd) ||
						JWCStrConst.CD_DIV_WATCH_KIKI_KANRI_STAT_HONUNYO.equals(stb_stat_cd))&&
						!JWCStrConst.CD_DIV_CCAS_CARD_KANRI_STAT_LINKCHU.equals(ccas_card_stat_cd)){
					tmpParamMap.put("key_unlink_link_hmpin_kiki_no", keyHmpinKikiNo);
					return tmpParamMap;
				}
				
				// アンリンク可能なステータスの場合、以下を実行
				if((JWCStrConst.CD_DIV_WATCH_KIKI_KANRI_STAT_KARITO.equals(stb_stat_cd) ||
						JWCStrConst.CD_DIV_WATCH_KIKI_KANRI_STAT_HONUNYO.equals(stb_stat_cd))&&
						JWCStrConst.CD_DIV_CCAS_CARD_KANRI_STAT_LINKCHU.equals(ccas_card_stat_cd))
				{
					// (a-4) 局一覧照会サービスインターフェイスを呼出し、局情報を取得する。
					// 局一覧照会パラメータセット
					CAANMsg template = new CAANMsg(EWC0151B010CBSMsg.class.getName());
					
					// テンプレートID
					template.set(EWC0151B010CBSMsg.TEMPLATEID, "EWC0151B010");
					
					if(inMap != null)
					{
						// 機能コード（デフォルト：１）
						template.set(EWC0151B010CBSMsg.FUNC_CODE, "1");
						// 運用日付
						template.set(EWC0151B010CBSMsg.OPERATEDATE,tmpParamMap.get("operate_date_key"));
						// 運用日時
						template.set(EWC0151B010CBSMsg.OPERATEDATETIME,tmpParamMap.get("operate_datetime_key"));
						// オペレータID
						template.set(EWC0151B010CBSMsg.OPERATORID,tmpParamMap.get("operator_id"));
					}
					
					templates = new CAANMsg[1];
					templates[0] = template;
					paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
					
					// SC呼出実行
					// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
					JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "局一覧照会処理の実行");
					result = scCall.run(paramMap, handle);
					editResultRrr(result, param);
					if (JDKBPCommon.hasError(param))
					{
						throw new SCCallException("局一覧照会処理失敗", "0", 
								Integer.parseInt(param.getControlMapData("returnCode").toString()));
					}
					
					templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
					msg = templates[0];
					
					// 検索リストを取得する
					serchList = msg.getCAANMsgList(EWC0151B010CBSMsg.EWC0151B010CBSMSG1LIST);
					if ( serchList != null && serchList.length > 0 )
					{
						// 局コード
						tmpParamMap.put("kyoku_cd", serchList[0].getString(EWC0151B010CBSMsg1List.KYOKU_CD));
						
						// (a-5) 制御エリア一意照会サービスインターフェイスを呼出し、制御エリア情報を取得する。
						// 制御エリア一覧照会パラメータセット
						template = new CAANMsg(EWC0101B010CBSMsg.class.getName());
						
						// テンプレートID
						template.set(EWC0101B010CBSMsg.TEMPLATEID, "EWC0101B010");
						
						if(inMap != null)
						{
							// 機能コード（デフォルト：１）
							template.set(EWC0101B010CBSMsg.FUNC_CODE, "1");
							// 局コード
							template.set(EWC0101B010CBSMsg.KEY_KYOKU_CD, tmpParamMap.get("kyoku_cd"));
							// 運用日付
							template.set(EWC0101B010CBSMsg.OPERATEDATE,tmpParamMap.get("operate_date_key"));
							// 運用日時
							template.set(EWC0101B010CBSMsg.OPERATEDATETIME,tmpParamMap.get("operate_datetime_key"));
							// オペレータID
							template.set(EWC0101B010CBSMsg.OPERATORID,tmpParamMap.get("operator_id"));
						}
						
						templates = new CAANMsg[1];
						templates[0] = template;
						paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
						
						// SC呼出実行
						// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
						JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "制御エリア一覧照会処理の実行");
						result = scCall.run(paramMap, handle);
						editResultRrr(result, param);
						if (JDKBPCommon.hasError(param))
						{
							throw new SCCallException("制御エリア一覧照会失敗", "0", 
									Integer.parseInt(param.getControlMapData("returnCode").toString()));
						}
						
						templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
						msg = templates[0];
						
						// 検索リストを取得する
						serchList = msg.getCAANMsgList(EWC0101B010CBSMsg.EWC0101B010CBSMSG1LIST);
						if ( serchList != null && serchList.length > 0 )
						{
							// 制御エリアコード
							tmpParamMap.put("ctrl_area_cd", serchList[0].getString(EWC0101B010CBSMsg1List.CTRL_AREA_CD));
							
							// (a-6) 視聴制御オーダ受付サービスインターフェイスを呼出し、視聴制御オーダテーブルにデータ登録する。
							// 視聴制御オーダ受付パラメータセット
							editOrderUktkMsg(paramMap, inMap, tmpParamMap);
							
							// SC呼出実行
							// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
							JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "視聴制御オーダ受付処理の実行");
							result = scCall.run(paramMap, handle);
							editResultRrr(result, param);
							if (JDKBPCommon.hasError(param))
							{
								throw new SCCallException("視聴制御オーダ受付失敗", "0", 
										Integer.parseInt(param.getControlMapData("returnCode").toString()));
							}
							
							// 登録結果を取得する
							editResultUktk(result, tmpParamMap);
							
							templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
							msg = templates[0];
							
							// (a-7) 視聴制御オーダ送信サービスインターフェイスを呼出し、視聴制御パッケージへコマンド発行を行う。
							// 視聴制御オーダ送信パラメータセット
							editOrderSendMsg(paramMap, inMap, tmpParamMap);
							
							// SC呼出実行
							// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
							JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "視聴制御オーダ送信処理の実行");
							result = scCall.run(paramMap, handle);
							editResultRrr(result, param);
							if (JDKBPCommon.hasError(param))
							{
								throw new SCCallException("視聴制御オーダ送信失敗", "0", 
										Integer.parseInt(param.getControlMapData("returnCode").toString()));
							}
							
							templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
							msg = templates[0];
							
//IT1-2017-0000118 MOD START
//							// 登録結果を取得する
//							editResultSend(result, tmpParamMap);
							//視聴制御オーダ送信結果取得リスト
							tmpParamMap.put("EWC0011C010CBSMSG1LIST", msg);
//IT1-2017-0000118 MOD END
							
							// (a-8) 視聴制御オーダ結果登録サービスインターフェイスを呼出し、視聴制御パッケージへコマンド発行を行う。
							// 視聴制御オーダ結果登録パラメータセット
							editOrderResultRegistMsg(paramMap, inMap, tmpParamMap);
							
							// SC呼出実行
							// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
							JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "視聴制御オーダ結果登録処理の実行");
							result = scCall.run(paramMap, handle);
							editResultRrr(result, param);
							if (JDKBPCommon.hasError(param))
							{
								throw new SCCallException("視聴制御オーダ結果登録失敗", "0", 
										Integer.parseInt(param.getControlMapData("returnCode").toString()));
							}
							
							templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
							msg = templates[0];
							
						}
					}
				}
//IT1-2017-0000118 ADD START
				// アンリンク不要なステータスの場合、アンリンク不要フラグを返す
				else
				{
					tmpParamMap.put("key_not_unlink_flg", keyHmpinKikiNo);
					return tmpParamMap;
				}
//IT1-2017-0000118 ADD END
			}
		}
		return tmpParamMap;
	}
	
	/**
	 * ＳＴＢ情報更新処理を行う
	 * @param param
	 * @param unlinkMap
	 * @param scCall
	 * @param handle
	 * @throws Exception 
	 */
	@SuppressWarnings({ "unchecked" })
	public void updateSTB(IRequestParameterReadWrite param, List<HashMap<String, Object>> unlinkMap, 
			ServiceComponentRequestInvoker scCall, SessionHandle handle)throws Exception 
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		
		for(HashMap<String, Object> tmpParamMap : unlinkMap){
			paramMap = new HashMap<String, Object>();
			
			/* SCインプット共通データ */
			// **********************************************
			// 【取得元：電文ヘッダ(ヘッダ)】
			// **********************************************
			// 電文ID
			paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID());
			// ユースケースID
			paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID());
			// オペレーションID
			paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID());
			// サービス呼び出し区分
			paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType());
			
			// **********************************************
			// 【取得元：ユーザエリア(コントロールマップ)】
			// **********************************************
			// 依頼先ホスト名
			paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTNAME));
			// 依頼元IPアドレス
			paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTIP));
			// 依頼元画面ID
			paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, param.getControlMapData(SCControlMapKeys.REQ_VIEWID));
			// オペレータID
			paramMap.put(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
			
			HashMap inMap = null;
			/* ユーザデータ情報 */
			inMap = (HashMap)param.getData(DKSV008101CC);
			
			// ＳＴＢ情報更新サービスインターフェイスを呼出し、宅内管理システムに視聴制御情報を連携する。
			// ＳＴＢ情報更新パラメータセット
			CAANMsg template = new CAANMsg(EWCA0010003CBSMsg.class.getName());
			
			// テンプレートID
			template.set(EWCA0010003CBSMsg.TEMPLATEID, "EWCA0010003");
			
			editSTBUpdateMsg(paramMap, inMap, tmpParamMap);
			
			// SC呼出実行
			// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
			JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "ＳＴＢ情報更新処理の実行");
			Map<?, ?> result = scCall.run(paramMap, handle);
			editResultRrr(result, param);
			if (JDKBPCommon.hasError(param))
			{
				throw new SCCallException("ＳＴＢ情報更新失敗", "0", 
						Integer.parseInt(param.getControlMapData("returnCode").toString()));
			}
			
// ST-2017-0000015 DEL START
//			// SCからの戻り値からCAANMsgを取得する。
//			CAANMsg[] templates = (CAANMsg[]) result.get(JCMConstants.TEMPLATE_LIST_KEY);
//			CAANMsg parentTemplate = templates[0];
//			
//			if (!parentTemplate.isNull(EWCA0010003CBSMsg.RETURN_CD)
//					&& !"0".equals(parentTemplate.getString(EWCA0010003CBSMsg.RETURN_CD))) {
//				throw new SCCallException("返品承認処理失敗", "0", StatusCodes.RELATION_ERR);
//			}
// ST-2017-0000015 DEL END
		}
		return;
	}
// ANK-3080-00-00 ADD END

// ANK-2406-00-00 ADD START
	/**
	 * エラーリストを確認する
	 * @param ListName エラリスト名
	 * @return エラーがあった場合:true なかった場合:false
	 */
	@SuppressWarnings("unchecked")
	private boolean checkErrList(HashMap parentMap, String ListName, Map map)
	{
		if (!parentMap.containsKey(ListName))
		{
			return false;
		}

		for (HashMap<String, Object> error : (List<HashMap<String, Object>>)parentMap.get(ListName))
		{
			if (error.get("key_hmpin_kiki_no").toString().equals((String) map.get("key_hmpin_kiki_no"))) {
				return true;
			}
		}

		return false;
	}
// ANK-2406-00-00 ADD END

	/**
	 * SOD作業領域を取得する。
	 * @param param
	 * @return SOD作業領域
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private HashMap getSodWorkMap(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// 作業領域を取得
		Map workMap = (Map)param.getMappingWorkArea();
		if (workMap == null) {
			return null;
		}
		
		// SOD作業領域を取得
		HashMap sodWorkMap = (HashMap) workMap.get(SOD_WORKAREA_KEY);
		if (sodWorkMap == null)
		{
			return null;
		}
		
		return sodWorkMap;
	}
	
	/**
	 * オーダ発行条件登録情報SETメソッド<br>
	 * @throws RequestParameterException 
	 */
	@SuppressWarnings("unchecked")
	// IT1-2014-0000348 MOD START
	// private void setValueOdrHakkoJoken(Map<String, String> kikiInfoMap, String orderSbtCd, String svcOrderCd, String yokyuSbtCd, String sameTrnNo, IRequestParameterReadWrite param) throws RequestParameterException
	private void setValueOdrHakkoJoken(Map approvalMap, Map<String, String> kikiInfoMap, String orderSbtCd, String svcOrderCd, String yokyuSbtCd, String sameTrnNo, IRequestParameterReadWrite param) throws RequestParameterException
	// IT1-2014-0000348 MOD END
	{
		
		// SOD作業領域を取得
		HashMap<String, Object> sodWorkMap = (HashMap<String, Object>) this.getSodWorkMap(param);
		
		HashMap<String, String> inMap = new HashMap<String, String>();
		
		// 1.オーダ発行条件番号は自動採番
		
		// 2.サービス契約番号 ← 画面で選択された機器のサービス契約番号
		// IT1-2014-0000341 MOD START
		//inMap.put(EKK1081D010CBSMsg.SVC_KEI_NO, kikiInfoMap.get(EKK0341A010CBSMsg1List.SVC_KEI_NO));
		// サービス契約一意照会 下り
		HashMap ekk0081A010OutMap = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK0081A010BSMapper.TEMPLATE_ID);
		// 明細取得
		ArrayList ekk0081A010CbsMsg1List = (ArrayList) ekk0081A010OutMap.get(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);
		
		// サービス契約一意照会でレコードが取得できた場合
		if (ekk0081A010CbsMsg1List.size() > 0)
		{
			HashMap ekk0081A010CbsMsg = (HashMap) ekk0081A010CbsMsg1List.get(0);
			inMap.put(EKK1081D010CBSMsg.SVC_KEI_NO, (String) ekk0081A010CbsMsg.get(EKK0081A010CBSMsg1List.SVC_KEI_NO));
		}
		// IT1-2014-0000341 MOD END
		
		// IT1-2014-0000341 DEL START
		// 3.サービス契約内訳番号 ← 2.サービス契約番号に紐付くサービス契約内訳番号
		// サービス契約内訳番号一覧照会の結果を取得
		//HashMap ekk0161B004Map = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK0161B004BSMapper.TEMPLATEID);
		// サービス契約内訳番号一覧明細を取得
		//ArrayList ekk0161B004CbsMsg1List = (ArrayList) ekk0161B004Map.get(EKK0161B004CBSMsg.EKK0161B004CBSMSG1LIST);
		//
		// サービス契約内訳番号一覧照会でレコードが取得できた場合
		//if (ekk0161B004CbsMsg1List.size() > 0)
		//{
		//	HashMap ekk0161B004CbsMsg = (HashMap) ekk0161B004CbsMsg1List.get(0);
		//	
		//	inMap.put(EKK1081D010CBSMsg.SVC_KEI_UCWK_NO, (String) ekk0161B004CbsMsg.get(EKK0161B004CBSMsg1List.SVC_KEI_UCWK_NO));
		//}
		// IT1-2014-0000341 DEL END
		
		//  4.機器提供サービス契約番号 ← 画面で選択された機器の機器提供サービス契約番号
		inMap.put(EKK1081D010CBSMsg.KKTK_SVC_KEI_NO, kikiInfoMap.get(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO));
		
		//  8.オーダ種別コード（電話）
		inMap.put(EKK1081D010CBSMsg.ORDER_SBT_CD, orderSbtCd);
		//  9.サービスオーダコード（OLS)
		inMap.put(EKK1081D010CBSMsg.SVC_ORDER_CD, svcOrderCd);
		// 10.要求種別コード（解約)
		inMap.put(EKK1081D010CBSMsg.YOKYU_SBT_CD, yokyuSbtCd);
		// 11.オーダ発行条件コード（即時発行)
		inMap.put(EKK1081D010CBSMsg.ODR_HAKKO_JOKEN_CD, "01");
		// 12.同一処理番号
		inMap.put(EKK1081D010CBSMsg.SAME_TRN_NO, sameTrnNo);
		
		// IT1-2014-0000348 ADD START
		if (approvalMap.containsKey("key_tk_mdl_cd"))
		{
			// 13.宅内機器型式コード
			// IT1-2014-0000348 MOD START
			//inMap.put(EKK1081D010CBSMsg.TAKNKIKI_MODEL_CD, kikiInfoMap.get(EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD));
			inMap.put(EKK1081D010CBSMsg.TAKNKIKI_MODEL_CD, (String) approvalMap.get("key_tk_mdl_cd"));
			// IT1-2014-0000348 MOD END
		}
		// IT1-2014-0000348 ADD END
		
		// IT1-2014-0000348 ADD START
		if (approvalMap.containsKey("key_kk_seizo_no"))
		{
			// 14.機器製造番号
			// IT1-2014-0000348 MOD START
			// inMap.put(EKK1081D010CBSMsg.KIKI_SEIZO_NO, kikiInfoMap.get(EKK0341A010CBSMsg1List.KIKI_SEIZO_NO));
			inMap.put(EKK1081D010CBSMsg.KIKI_SEIZO_NO, (String) approvalMap.get("key_kk_seizo_no"));
			// IT1-2014-0000348 MOD END
		}
		// IT1-2014-0000348 ADD END
		
		// 17.サービス契約回線内訳番号 多機能ルータの場合のみ設定する
		// 宅内機器型式一意照会 下り
		HashMap ezm0411A010OutMap = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EZM0411A010BSMapper.TEMPLATEID);
		// 明細取得
		ArrayList ezm0411A010CbsMsg1List = (ArrayList) ezm0411A010OutMap.get(EZM0411A010CBSMsg.EZM0411A010CBSMSG1LIST);
		
		HashMap ezm0411A010CbsMsg = (HashMap) ezm0411A010CbsMsg1List.get(0);
		
		// 宅内機器種別コードを取得
		String tkniKikiSbtCd = (String) ezm0411A010CbsMsg.get(EZM0411A010CBSMsg1List.TAKNKIKI_SBT_CD);
		
		// ANK-4315-00-00 MOD START
		// 多機能ルータもしくはＨＧＷの場合
		//if (JKKStrConst.TAKNKIKI_SBT_CD_TAKINORT.equals(tkniKikiSbtCd))
		if (JKKStrConst.TAKNKIKI_SBT_CD_TAKINORT.equals(tkniKikiSbtCd) || JKKStrConst.TAKNKIKI_SBT_CD_HGW.equals(tkniKikiSbtCd))
		// ANK-4315-00-00 MOD END
		{
			// IT1-2014-0000368 ADD START
			// IT1-2014-0000369 DEL START
			// 3.サービス契約内訳番号 ← 2.サービス契約番号に紐付くサービス契約内訳番号
			// サービス契約内訳番号一覧照会の結果を取得
			//HashMap ekk0161B004Map = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK0161B004BSMapper.TEMPLATEID);
			// サービス契約内訳番号一覧明細を取得
			//ArrayList ekk0161B004CbsMsg1List = (ArrayList) ekk0161B004Map.get(EKK0161B004CBSMsg.EKK0161B004CBSMSG1LIST);
			//
			// サービス契約内訳番号一覧照会でレコードが取得できた場合
			//if (ekk0161B004CbsMsg1List.size() > 0)
			//{
			//	HashMap ekk0161B004CbsMsg = (HashMap) ekk0161B004CbsMsg1List.get(0);
			//	
			//	inMap.put(EKK1081D010CBSMsg.SVC_KEI_UCWK_NO, (String) ekk0161B004CbsMsg.get(EKK0161B004CBSMsg1List.SVC_KEI_UCWK_NO));
			//}
			// IT1-2014-0000369 DEL END
			// IT1-2014-0000368 ADD END 
			
			// IT1-2014-0000341 MOD START
			// サービス契約回線内訳一覧照会 下り
			//HashMap ekk0251B001OutMap = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK0251B001BSMapper.TEMPLATEID);
			// 明細取得
			//ArrayList ekk0251B001CbsMsg1List = (ArrayList) ekk0251B001OutMap.get(EKK0251B001CBSMsg.EKK0251B001CBSMSG1LIST);
			//
			// サービス契約回線内訳一覧照会で取得できた場合
			//if (ekk0251B001CbsMsg1List.size() > 0)
			//{
			//	HashMap ekk0251B001CbsMsg = (HashMap) ekk0251B001CbsMsg1List.get(0);
			//	
			//	inMap.put(EKK1081D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO, (String) ekk0251B001CbsMsg.get(EKK0251B001CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO));
			//}
			// サービス契約回線内訳番号を設定
			inMap.put(EKK1081D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO, (String) kikiInfoMap.get(EKK0341A010CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO));
			// IT1-2014-0000341 MOD END
		}
		
		// IT1-2014-0000368 ADD START
		// UQの場合
		if ("J0".equals(tkniKikiSbtCd))
		{
			// 3.サービス契約内訳番号 ← 2.サービス契約番号に紐付くサービス契約内訳番号
			// サービス契約内訳番号一覧照会の結果を取得
			HashMap ekk0161B004Map = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK0161B004BSMapper.TEMPLATEID);
			// サービス契約内訳番号一覧明細を取得
			ArrayList ekk0161B004CbsMsg1List = (ArrayList) ekk0161B004Map.get(EKK0161B004CBSMsg.EKK0161B004CBSMSG1LIST);
			//
			// サービス契約内訳番号一覧照会でレコードが取得できた場合
			if (ekk0161B004CbsMsg1List.size() > 0)
			{
				// IT1-2014-0000369 MOD START
				//HashMap ekk0161B004CbsMsg = (HashMap) ekk0161B004CbsMsg1List.get(0);
				//
				//inMap.put(EKK1081D010CBSMsg.SVC_KEI_UCWK_NO, (String) ekk0161B004CbsMsg.get(EKK0161B004CBSMsg1List.SVC_KEI_UCWK_NO));
				
				Iterator ekk0161B004Ite = ekk0161B004CbsMsg1List.iterator();
				
				while (ekk0161B004Ite.hasNext())
				{
					HashMap ekk0161B004CbsMsg = (HashMap) ekk0161B004Ite.next();
					
					// 料金コースコードを取得
					String pcrsCd = (String) ekk0161B004CbsMsg.get(EKK0161B004CBSMsg1List.PCRS_CD);
					
					// 取得した料金コースコードがA46(UQ　WiMAX 認証ID)の場合
					if (JKKStrConst.CD00134_MOB_WIMAX.equals(pcrsCd))
					{
						// サービス契約内訳番号を設定
						inMap.put(EKK1081D010CBSMsg.SVC_KEI_UCWK_NO, (String) ekk0161B004CbsMsg.get(EKK0161B004CBSMsg1List.SVC_KEI_UCWK_NO));
						break;
					}
				}
				// IT1-2014-0000369 MOD END
			}
			
			// IT1-2014-0000369 ADD START
			// 13.宅内機器型式コード
			inMap.put(EKK1081D010CBSMsg.TAKNKIKI_MODEL_CD, null);
			
			// 14.機器製造番号
			inMap.put(EKK1081D010CBSMsg.KIKI_SEIZO_NO, null);
			// IT1-2014-0000369 ADD END
		}
		// IT1-2014-0000368 ADD END
		
		// inMapを設定
		sodWorkMap.put(DKSV0081_DKSV0081OP_EKK1081D010BSMapper.TEMPLATEID, inMap);
	}
	
	/**
	 * オーダ情報作成ワーク登録情報SETメソッド
	 * @param odrNaiyoCd オーダ内容コード
	 * @param param IRequestParameterReadWriteオブジェクト
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private void setValueOdrInfSksiWk(String odrNaiyoCd, IRequestParameterReadWrite param) throws RequestParameterException
	{
		// SOD作業領域を取得
		HashMap<String, Object> sodWorkMap = (HashMap<String, Object>) this.getSodWorkMap(param);
		
		// オーダ発行条件登録後の情報を取得
		HashMap<String, String> ekk1081D010Map = (HashMap<String, String>) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK1081D010BSMapper.TEMPLATEID);
		
		HashMap<String, String> inMap = new HashMap<String, String>();
		
		// 2.オーダ発行条件番号（オーダ発行条件登録時に採番されたオーダ発行条件番号）
		inMap.put(EKK1551D010CBSMsg.ODR_HAKKO_JOKEN_NO, ekk1081D010Map.get(EKK1081D010CBSMsg.ODR_HAKKO_JOKEN_NO));
		
		// 3.オーダ内容コード
		inMap.put(EKK1551D010CBSMsg.ODR_NAIYO_CD, odrNaiyoCd);
		
		// 4.サービス契約番号
		// 5.サービス契約世代登録年月日時分秒
		// サービス契約一意照会 下り
		HashMap ekk0081A010OutMap = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK0081A010BSMapper.TEMPLATE_ID);
		// 明細取得
		ArrayList ekk0081A010CbsMsg1List = (ArrayList) ekk0081A010OutMap.get(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);
		
		// サービス契約一意照会でレコードが取得できた場合
		if (ekk0081A010CbsMsg1List.size() > 0)
		{
			
			HashMap ekk0081A010CbsMsg = (HashMap) ekk0081A010CbsMsg1List.get(0);
			
			// サービス契約番号
			inMap.put(EKK1551D010CBSMsg.SVC_KEI_NO, (String) ekk0081A010CbsMsg.get(EKK0081A010CBSMsg1List.SVC_KEI_NO));
			// サービス契約世代登録年月日時分秒
			inMap.put(EKK1551D010CBSMsg.SVKEI_GADTM, (String) ekk0081A010CbsMsg.get(EKK0081A010CBSMsg1List.GENE_ADD_DTM));
		}
		
		// IT1-2014-0000341 DEL START
		// 6.サービス契約内訳番号
		// 7. サービス契約内訳世代登録年月日時分秒
		// サービス契約内訳番号一覧照会の結果を取得
		//HashMap ekk0161B004Map = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK0161B004BSMapper.TEMPLATEID);
		// サービス契約内訳番号一覧明細を取得
		//ArrayList ekk0161B004CbsMsg1List = (ArrayList) ekk0161B004Map.get(EKK0161B004CBSMsg.EKK0161B004CBSMSG1LIST);
		//
		// サービス契約内訳番号一覧照会でレコードが取得できた場合
		//if (ekk0161B004CbsMsg1List.size() > 0)
		//{
		//	HashMap ekk0161B004CbsMsg = (HashMap) ekk0161B004CbsMsg1List.get(0);
		//	
		//	inMap.put(EKK1551D010CBSMsg.SVC_KEI_UCWK_NO, (String) ekk0161B004CbsMsg.get(EKK0161B004CBSMsg1List.SVC_KEI_UCWK_NO));
		//	inMap.put(EKK1551D010CBSMsg.SVKEIUW_GADTM, (String) ekk0161B004CbsMsg.get(EKK0161B004CBSMsg1List.GENE_ADD_DTM));
		//}
		// IT1-2014-0000341 DEL END
		
		// 機器提供サービス契約一意照会下り
		HashMap ekk0341A010_02OutMap = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK0341A010_02BSMapper.TEMPLATEID);
		// 明細取得
		List ekk0341A010CbsMsg1List = (List) ekk0341A010_02OutMap.get(EKK0341A010CBSMsg.EKK0341A010CBSMSG1LIST);
		
		HashMap ekk0341A010CbsMsg = (HashMap) ekk0341A010CbsMsg1List.get(0);
		
		// 8.機器提供サービス契約番号
		inMap.put(EKK1551D010CBSMsg.KKTK_SVC_KEI_NO, (String) ekk0341A010CbsMsg.get(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO));
		// 9.機器提供サービス契約世代登録年月日時分秒
		inMap.put(EKK1551D010CBSMsg.KKTSVKEI_GADTM, (String) ekk0341A010CbsMsg.get(EKK0341A010CBSMsg1List.GENE_ADD_DTM));
		
		// 多機能ルータの場合のみ設定する
		// 宅内機器型式一意照会 下り
		HashMap ezm0411A010OutMap = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EZM0411A010BSMapper.TEMPLATEID);
		// 明細取得
		ArrayList ezm0411A010CbsMsg1List = (ArrayList) ezm0411A010OutMap.get(EZM0411A010CBSMsg.EZM0411A010CBSMSG1LIST);
		
		HashMap ezm0411A010CbsMsg = (HashMap) ezm0411A010CbsMsg1List.get(0);
		
		// 宅内機器種別コードを取得
		String tkniKikiSbtCd = (String) ezm0411A010CbsMsg.get(EZM0411A010CBSMsg1List.TAKNKIKI_SBT_CD);
		
		// ANK-4315-00-00 MOD START
		// 多機能ルータもしくはＨＧＷの場合
		//if (JKKStrConst.TAKNKIKI_SBT_CD_TAKINORT.equals(tkniKikiSbtCd))
		if (JKKStrConst.TAKNKIKI_SBT_CD_TAKINORT.equals(tkniKikiSbtCd) || JKKStrConst.TAKNKIKI_SBT_CD_HGW.equals(tkniKikiSbtCd))
		// ANK-4315-00-00 MOD END
		{
			// 機器オプションサービス契約一覧照会下り
			HashMap ekk2811B010OutMap = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK2811B010BSMapper.TEMPLATEID);
			// 明細取得
			List ekk2811B010CbsMsg1List = (List) ekk2811B010OutMap.get(EKK2811B010CBSMsg.EKK2811B010CBSMSG1LIST);
			
			Iterator ite = ekk2811B010CbsMsg1List.iterator();
			while (ite.hasNext())
			{
				HashMap ekk2811B010CbsMsg = (HashMap) ite.next();
				
				String kkopSvcCd = (String) ekk2811B010CbsMsg.get(EKK2811B010CBSMsg1List.KKOP_SVC_CD);
				
				// 機器オプションサービスコードがG01(ルータ機能)
				if (JKKStrConst.CD00134_KKOP_YUSEN.equals(kkopSvcCd))
				{
					inMap.put(EKK1551D010CBSMsg.KKOP_SVC_KEI_NO_1, 
							(String) ekk2811B010CbsMsg.get(EKK2811B010CBSMsg1List.KKOP_SVC_KEI_NO));
					
					inMap.put(EKK1551D010CBSMsg.KKOSVKEI_GADTM_1, 
							(String) ekk2811B010CbsMsg.get(EKK2811B010CBSMsg1List.GENE_ADD_DTM));
				}
				// 機器オプションサービスコードがG02(VA機能)
				else if (JKKStrConst.CD00134_KKOP_MUSEN.equals(kkopSvcCd))
				{
					inMap.put(EKK1551D010CBSMsg.KKOP_SVC_KEI_NO_2, 
							(String) ekk2811B010CbsMsg.get(EKK2811B010CBSMsg1List.KKOP_SVC_KEI_NO));
					
					inMap.put(EKK1551D010CBSMsg.KKOSVKEI_GADTM_2, 
							(String) ekk2811B010CbsMsg.get(EKK2811B010CBSMsg1List.GENE_ADD_DTM));
				}
			}
		}
		
		// IT1-2014-0000368 ADD START
		// UQの場合
		if ("J0".equals(tkniKikiSbtCd))
		{
			// 6.サービス契約内訳番号
			// 7. サービス契約内訳世代登録年月日時分秒
			// サービス契約内訳番号一覧照会の結果を取得
			HashMap ekk0161B004Map = (HashMap) sodWorkMap.get(DKSV0081_DKSV0081OP_EKK0161B004BSMapper.TEMPLATEID);
			// サービス契約内訳番号一覧明細を取得
			ArrayList ekk0161B004CbsMsg1List = (ArrayList) ekk0161B004Map.get(EKK0161B004CBSMsg.EKK0161B004CBSMSG1LIST);
			//
			// サービス契約内訳番号一覧照会でレコードが取得できた場合
			if (ekk0161B004CbsMsg1List.size() > 0)
			{
				// IT1-2014-0000369 MOD START
				//HashMap ekk0161B004CbsMsg = (HashMap) ekk0161B004CbsMsg1List.get(0);
				//
				//inMap.put(EKK1551D010CBSMsg.SVC_KEI_UCWK_NO, (String) ekk0161B004CbsMsg.get(EKK0161B004CBSMsg1List.SVC_KEI_UCWK_NO));
				//inMap.put(EKK1551D010CBSMsg.SVKEIUW_GADTM, (String) ekk0161B004CbsMsg.get(EKK0161B004CBSMsg1List.GENE_ADD_DTM));
				
				Iterator ekk0161B004Ite = ekk0161B004CbsMsg1List.iterator();
				
				while (ekk0161B004Ite.hasNext())
				{
					HashMap ekk0161B004CbsMsg = (HashMap) ekk0161B004Ite.next();
					
					// 料金コースコードを取得
					String pcrsCd = (String) ekk0161B004CbsMsg.get(EKK0161B004CBSMsg1List.PCRS_CD);
					
					// 取得した料金コースコードがA46(UQ　WiMAX 認証ID)の場合
					if (JKKStrConst.CD00134_MOB_WIMAX.equals(pcrsCd))
					{
						// サービス契約内訳番号を設定
						inMap.put(EKK1551D010CBSMsg.SVC_KEI_UCWK_NO, (String) ekk0161B004CbsMsg.get(EKK0161B004CBSMsg1List.SVC_KEI_UCWK_NO));
						inMap.put(EKK1551D010CBSMsg.SVKEIUW_GADTM, (String) ekk0161B004CbsMsg.get(EKK0161B004CBSMsg1List.GENE_ADD_DTM));
						break;
					}
				}
				// IT1-2014-0000369 MOD END
			}
		}
		// IT1-2014-0000368 ADD END
		
		// inMapを設定
		sodWorkMap.put(DKSV0081_DKSV0081OP_EKK1551D010BSMapper.TEMPLATEID, inMap);
	}
	
	/**
	 * オーダ発行条件登録処理
	 * 
	 * @param kikiInfoMap 返品機器情報
	 * @param orderSbtCd オーダ種別コード
	 * @param svcOrderCd サービスオーダコード
	 * @param yokyuSbtCd 要求種別コード
	 * @param handle
	 * @param param
	 * @param scCall
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	// IT1-2014-0000348 MOD START
	// private void insertOdrHakkoJoken(Map kikiInfoMap, String orderSbtCd, String svcOrderCd, String yokyuSbtCd, String sameTrnNo,
	// 		SessionHandle handle, IRequestParameterReadWrite param, ServiceComponentRequestInvoker scCall) throws Exception
	private void insertOdrHakkoJoken(Map approvalMap, Map kikiInfoMap, String orderSbtCd, String svcOrderCd, String yokyuSbtCd, String sameTrnNo,
			SessionHandle handle, IRequestParameterReadWrite param, ServiceComponentRequestInvoker scCall) throws Exception
	// IT1-2014-0000348 MOD END
	{
		
		/* ユーザデータ情報 */
		HashMap inMap = (HashMap)param.getData(DKSV008101CC);
		
		// 機能コード2の場合
		if ("2".equals(inMap.get(EKK1081D010CBSMsg.FUNC_CODE)))
		{
			// 登録処理を行わない
			return;
		}
		
		// IT1-2014-0000348 MOD START
		// this.setValueOdrHakkoJoken(kikiInfoMap, orderSbtCd, svcOrderCd, yokyuSbtCd, sameTrnNo, param);
		this.setValueOdrHakkoJoken(approvalMap, kikiInfoMap, orderSbtCd, svcOrderCd, yokyuSbtCd, sameTrnNo, param);
		// IT1-2014-0000348 MOD END
		HashMap ekk1081D010Map = EKK1081D010BSMapper.editInMsg(param);
		JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "オーダ発行条件登録処理の実行");
		Map ekk1081D010Result = scCall.run(ekk1081D010Map, handle);
		param = EKK1081D010BSMapper.editResultRP(ekk1081D010Result, param);
		if (JDKBPCommon.hasError(param))
		{
			throw new SCCallException("オーダ発行条件登録処理失敗", "0", 
					Integer.parseInt(param.getControlMapData("returnCode").toString()));
		}
	}
	
	/**
	 * オーダ情報作成ワーク登録処理
	 * 
	 * @param odrNaiyoCd オーダ内容コード
	 * @param handle
	 * @param param
	 * @param scCall
	 * @throws Exception 
	 */
	@SuppressWarnings("unchecked")
	private void insertOdrInfSksiWk(String odrNaiyoCd, 
			SessionHandle handle, IRequestParameterReadWrite param, ServiceComponentRequestInvoker scCall) throws Exception
	{
		
		/* ユーザデータ情報 */
		HashMap inMap = (HashMap)param.getData(DKSV008101CC);
		
		// 機能コード2の場合
		if ("2".equals(inMap.get(EKK1081D010CBSMsg.FUNC_CODE)))
		{
			// 登録処理を行わない
			return;
		}
		
		this.setValueOdrInfSksiWk(odrNaiyoCd, param);
		HashMap ekk1551D010Map = EKK1551D010BSMapper.editInMsg(param);
		JSYejbLog.println(JSYejbLog.DEBUG, this.getClass(), "オーダ情報作成ワーク登録処理の実行");
		Map ekk1551D010Result = scCall.run(ekk1551D010Map, handle);
		param = EKK1551D010BSMapper.editResultRP(ekk1551D010Result, param);
		if (JDKBPCommon.hasError(param))
		{
			throw new SCCallException("オーダ情報作成ワーク登録処理失敗", "0", 
					Integer.parseInt(param.getControlMapData("returnCode").toString()));
		}
	}
	
	/**
	 * 返品SOD発行対象かどうかを判定する。
	 * @param tkniKikiSbtCd 宅内機器種別コード
	 * @return 判定結果
	 */
	private boolean checkTkniKikiSbtCd(String tkniKikiSbtCd)
	{
		// 返品ＳＯＤ対象抽出の宅内機器種別コードが "50"（光電話ＶＡ）の場合
		if ("50".equals(tkniKikiSbtCd))
		{
			return true;
		}
		// 返品ＳＯＤ対象抽出の宅内機器種別コードが "F0"（ＢＢＲ）の場合
		else if ("F0".equals(tkniKikiSbtCd))
		{
			return true;
		}
		// 返品ＳＯＤ対象抽出の宅内機器種別コードが "J0"（ＵＱ）の場合
		else if ("J0".equals(tkniKikiSbtCd))
		{
			return true;
		}
		// 返品ＳＯＤ対象抽出の宅内機器種別コードが "R0"（多機能ルータ）の場合
		else if (JKKStrConst.TAKNKIKI_SBT_CD_TAKINORT.equals(tkniKikiSbtCd))
		{
			return true;
		}
		// ANK-4315-00-00 ADD START
		// 返品ＳＯＤ対象抽出の宅内機器種別コードが "S0"（HGW）の場合
		else if (JKKStrConst.TAKNKIKI_SBT_CD_HGW.equals(tkniKikiSbtCd))
		{
			return true;
		}
		// ANK-4315-00-00 ADD END
		else
		{
			return false;
		}
	}
	// ANK-2119-00-00 ADD END
	
// ANK-3080-00-00 ADD START
	/**
	 * 宅内機器型式一意照会サービスのパラメータセット
	 * @param paramMap
	 * @param inMap
	 * @param tmpParamMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public HashMap<String, Object> editTkniKikiMsg(HashMap<String, Object> paramMap, HashMap inMap, HashMap<String, Object> tmpParamMap)throws RequestParameterException 
	{
		
		CAANMsg template = new CAANMsg(EZM0411A010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EZM0411A010CBSMsg.TEMPLATEID, "EZM0411A010");
		
		if(inMap != null)
		{
			// 機能コード（デフォルト：１）
			template.set(EZM0411A010CBSMsg.FUNC_CODE, "1");
			// 運用日付
			template.set(EZM0411A010CBSMsg.OPERATEDATE,tmpParamMap.get("operate_date_key"));
			// 運用日時
			template.set(EZM0411A010CBSMsg.OPERATEDATETIME,tmpParamMap.get("operate_datetime_key"));
			// オペレータID
			template.set(EZM0411A010CBSMsg.OPERATORID,tmpParamMap.get("operator_id"));
		}
		
		// 宅内機器形式コード
		if (tmpParamMap.get("taknkiki_mdl_cd")== null || "".equals(tmpParamMap.get("taknkiki_mdl_cd"))) 
		{
			template.setNull(EZM0411A010CBSMsg.KEY_TAKNKIKI_MODEL_CD);
		} 
		else 
		{
			template.set(EZM0411A010CBSMsg.KEY_TAKNKIKI_MODEL_CD, tmpParamMap.get("taknkiki_mdl_cd"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	/**
	 *宅内機器一覧照会(3)サービスのパラメータセット
	 * @param paramMap
	 * @param inMap
	 * @param tmpParamMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public HashMap<String, Object> editTkniKiki3Msg(HashMap<String, Object> paramMap, HashMap inMap, HashMap<String, Object> tmpParamMap)throws RequestParameterException 
	{
		
		CAANMsg template = new CAANMsg(EWCA0010001CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EWCA0010001CBSMsg.TEMPLATEID, "EWCA0010001");
		
		if(inMap != null)
		{
			// 機能コード（デフォルト：１）
			template.set(EWCA0010001CBSMsg.FUNC_CODE, "1");
			// 運用日付
			template.set(EWCA0010001CBSMsg.OPERATEDATE,tmpParamMap.get("operate_date_key"));
			// 運用日時
			template.set(EWCA0010001CBSMsg.OPERATEDATETIME,tmpParamMap.get("operate_datetime_key"));
			// オペレータID
			template.set(EWCA0010001CBSMsg.OPERATORID,tmpParamMap.get("operator_id"));
		}
		
// OM-2017-0001015 MOD START
//		if (tmpParamMap.get("taknkiki_mdl_cd")== null || "".equals(tmpParamMap.get("taknkiki_mdl_cd"))) 
		// ※宅内機器種別コードが「C-CAS」の場合は宅内機器型式コードをマッピングしない
		if (tmpParamMap.get("taknkiki_mdl_cd")== null || "".equals(tmpParamMap.get("taknkiki_mdl_cd"))
				|| JDKStrConst.CCAS.equals(tmpParamMap.get("taknkiki_sbt_cd"))) 
// OM-2017-0001015 MOD END
		{
			template.setNull(EWCA0010001CBSMsg.KEY_TK_MDL_CD);
		} 
		else 
		{
			template.set(EWCA0010001CBSMsg.KEY_TK_MDL_CD, tmpParamMap.get("taknkiki_mdl_cd"));
		}
		
		if (tmpParamMap.get("kiki_seizo_no") == null || "".equals(tmpParamMap.get("kiki_seizo_no"))) 
		{
			template.setNull(EWCA0010001CBSMsg.KEY_KK_SEIZO_NO);
		} 
		else 
		{
			template.set(EWCA0010001CBSMsg.KEY_KK_SEIZO_NO, tmpParamMap.get("kiki_seizo_no"));
		}
		// 宅内機器種別コード
		if (tmpParamMap.get("taknkiki_sbt_cd") == null || "".equals(tmpParamMap.get("taknkiki_sbt_cd"))) 
		{
			template.setNull(EWCA0010001CBSMsg.KEY_TK_SBT_CD);
		} 
		else 
		{
			template.set(EWCA0010001CBSMsg.KEY_TK_SBT_CD, tmpParamMap.get("taknkiki_sbt_cd"));
		}
		// STBID
		template.setNull(EWCA0010001CBSMsg.KEY_STBID);
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	/**
	 *視聴制御オーダ受付サービスのパラメータセット
	 * @param paramMap
	 * @param inMap
	 * @param tmpParamMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public HashMap<String, Object> editOrderUktkMsg(HashMap<String, Object> paramMap, HashMap inMap, HashMap<String, Object> tmpParamMap)throws RequestParameterException 
	{
		
		CAANMsg template = new CAANMsg(EWC0011D010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EWC0011D010CBSMsg.TEMPLATEID, "EWC0011D010");
		
		if(inMap != null)
		{
			// 機能コード（デフォルト：１）
			template.set(EWC0011D010CBSMsg.FUNC_CODE, "1");
			// 運用日付
			template.set(EWC0011D010CBSMsg.OPERATEDATE,tmpParamMap.get("operate_date_key"));
			// 運用日時
			template.set(EWC0011D010CBSMsg.OPERATEDATETIME,tmpParamMap.get("operate_datetime_key"));
			// オペレータID
			template.set(EWC0011D010CBSMsg.OPERATORID,tmpParamMap.get("operator_id"));
			// 視聴制御オーダステータス("000":正常)
			template.set(EWC0011D010CBSMsg.WCTRL_ORDER_STAT, "000");
			// 視聴制御オーダコード("02":仮登録（アンリンク）・撤去)
			template.set(EWC0011D010CBSMsg.WCTRL_ORDER_CD, JWCStrConst.CD_DIV_WCTRL_ORDER_UNSET);
			// 視聴制御依頼処理コード("88":STB直接制御(登録解除：アンリンク))
			template.set(EWC0011D010CBSMsg.WCTRL_REQ_TRN_CD, JWCStrConst.CD_DIV_WCTRL_REQ_TRN_CD_STBCTRL_UNSET);
			// SYSID(null)
			template.setNull(EWC0011D010CBSMsg.SYSID);
			// サービス契約内訳番号(null)
			template.setNull(EWC0011D010CBSMsg.SVC_KEI_UCWK_NO);
			// 制御タイプコード("0":リアル)
			template.set(EWC0011D010CBSMsg.CTRL_TYPE_CD, "0");
			// 制御モードコード("1")
			template.set(EWC0011D010CBSMsg.CTRL_MODE_CD, "1");
			// 課金フラグ(null)
			template.setNull(EWC0011D010CBSMsg.CHRG_FLG);
			// STBグループID7(null)
			template.setNull(EWC0011D010CBSMsg.STB_GRP_ID_7);
			// 再設定フラグ(null)
			template.setNull(EWC0011D010CBSMsg.RE_SETTE_FLG);
			// 実行結果コード(null)
			template.setNull(EWC0011D010CBSMsg.RUN_RSLT_CD);
			// 制御コマンド発行済フラグ("1":未発行)
			template.set(EWC0011D010CBSMsg.CTRL_CMD_HAKKO_ZUMI_FLG, "1");
			// 制御結果受信フラグ("1":未受信)
			template.set(EWC0011D010CBSMsg.RSLT_RCV_FLG, "1");
			// ディレイドフラグ("1":ディレイド対象外)
			template.set(EWC0011D010CBSMsg.DLYD_FLG, JWCStrConst.CD_DIV_DLYD_FLG_TAISYOGAI);
			// C-CAS初期化コマンド発行フラグ(null)
			template.setNull(EWC0011D010CBSMsg.CCAS_SHKKA_CMD_HAK_FLG);
			// オーダ受付年月日時分秒
			template.set(EWC0011D010CBSMsg.ORDER_UK_DTM, JCCBPCommon.getSysDateTimeStamp());
		}
		
// OM-2017-0001015 DEL START
//		// サービス契約番号
//		if (inMap.get("svc_kei_no")== null || "".equals(inMap.get("svc_kei_no"))) 
//		{
//			template.setNull(EWC0011D010CBSMsg.SVC_KEI_NO);
//		} 
//		else 
//		{
//			template.set(EWC0011D010CBSMsg.SVC_KEI_NO, tmpParamMap.get("svc_kei_no"));
//		}
// OM-2017-0001015 DEL END
		
		// 局コード
		if (tmpParamMap.get("kyoku_cd")== null || "".equals(tmpParamMap.get("kyoku_cd"))) 
		{
			template.setNull(EWC0011D010CBSMsg.KYOKU_CD);
		} 
		else 
		{
			template.set(EWC0011D010CBSMsg.KYOKU_CD, tmpParamMap.get("kyoku_cd"));
		}
		
		// 制御エリアコード
		if (tmpParamMap.get("ctrl_area_cd") == null || "".equals(tmpParamMap.get("ctrl_area_cd"))) 
		{
			template.setNull(EWC0011D010CBSMsg.CTRL_AREA_CD);
		} 
		else 
		{
			template.set(EWC0011D010CBSMsg.CTRL_AREA_CD, tmpParamMap.get("ctrl_area_cd"));
		}
		
		CAANMsg msgList = (CAANMsg)tmpParamMap.get("EWCA0010001CBSMSG1LIST");
		
		// STB宅内機器型式コード
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_TK_MDL_CD) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_TK_MDL_CD))) 
		{
			template.setNull(EWC0011D010CBSMsg.STB_TAKNKIKI_MODEL_CD);
		} 
		else 
		{
			template.set(EWC0011D010CBSMsg.STB_TAKNKIKI_MODEL_CD, msgList.getString(EWCA0010001CBSMsg1List.STB_TK_MDL_CD));
		}
		
		// STB機器製造番号
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_KK_SEIZO_NO) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_KK_SEIZO_NO))) 
		{
			template.setNull(EWC0011D010CBSMsg.STB_KIKI_SEIZO_NO);
		} 
		else 
		{
			template.set(EWC0011D010CBSMsg.STB_KIKI_SEIZO_NO, msgList.getString(EWCA0010001CBSMsg1List.STB_KK_SEIZO_NO));
		}
		
		// STB制御用機種コード
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_MAKER_KOYU_CTL_MDL_CD) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_MAKER_KOYU_CTL_MDL_CD))) 
		{
			template.setNull(EWC0011D010CBSMsg.STB_CTRL_MODEL_CD);
		} 
		else 
		{
			template.set(EWC0011D010CBSMsg.STB_CTRL_MODEL_CD, msgList.getString(EWCA0010001CBSMsg1List.STB_MAKER_KOYU_CTL_MDL_CD));
		}
		
		// STBID
		if (msgList.getString(EWCA0010001CBSMsg1List.STBID) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STBID))) 
		{
			template.setNull(EWC0011D010CBSMsg.STB_ID);
		} 
		else 
		{
			template.set(EWC0011D010CBSMsg.STB_ID, msgList.getString(EWCA0010001CBSMsg1List.STBID));
		}
		
		// STBCAS内蔵フラグ
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_NAIZOCAS_CD) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_NAIZOCAS_CD))) 
		{
			template.setNull(EWC0011D010CBSMsg.STB_CAS_NAIZO_FLG);
		} 
		else 
		{
			template.set(EWC0011D010CBSMsg.STB_CAS_NAIZO_FLG, msgList.getString(EWCA0010001CBSMsg1List.STB_NAIZOCAS_CD));
		}
		
		// C-CASカード番号
		if (msgList.getString(EWCA0010001CBSMsg1List.CCAS_KK_SEIZO_NO) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.CCAS_KK_SEIZO_NO))) 
		{
			template.setNull(EWC0011D010CBSMsg.CCAS_CARD_NO);
		} 
		else 
		{
			template.set(EWC0011D010CBSMsg.CCAS_CARD_NO, msgList.getString(EWCA0010001CBSMsg1List.CCAS_KK_SEIZO_NO));
		}
		
		// B-CASカード番号
		if (msgList.getString(EWCA0010001CBSMsg1List.BCAS_KK_SEIZO_NO) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.BCAS_KK_SEIZO_NO))) 
		{
			template.setNull(EWC0011D010CBSMsg.BCAS_CARD_NO);
		} 
		else 
		{
			template.set(EWC0011D010CBSMsg.BCAS_CARD_NO, msgList.getString(EWCA0010001CBSMsg1List.BCAS_KK_SEIZO_NO));
		}
		
		// STBグループID1
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID1) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID1))) 
		{
			template.setNull(EWC0011D010CBSMsg.STB_GRP_ID_1);
		} 
		else 
		{
			template.set(EWC0011D010CBSMsg.STB_GRP_ID_1, msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID1));
		}
		
		// STBグループID2
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID2) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID2))) 
		{
			template.setNull(EWC0011D010CBSMsg.STB_GRP_ID_2);
		} 
		else 
		{
			template.set(EWC0011D010CBSMsg.STB_GRP_ID_2, msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID2));
		}
		
		// STBグループID3
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID3) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID3))) 
		{
			template.setNull(EWC0011D010CBSMsg.STB_GRP_ID_3);
		} 
		else 
		{
			template.set(EWC0011D010CBSMsg.STB_GRP_ID_3, msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID3));
		}
		
		// STBグループID4
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID4) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID4))) 
		{
			template.setNull(EWC0011D010CBSMsg.STB_GRP_ID_4);
		} 
		else 
		{
			template.set(EWC0011D010CBSMsg.STB_GRP_ID_4, msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID4));
		}
		
		// STBグループID5
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID5) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID5))) 
		{
			template.setNull(EWC0011D010CBSMsg.STB_GRP_ID_5);
		} 
		else 
		{
			template.set(EWC0011D010CBSMsg.STB_GRP_ID_5, msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID5));
		}
		
		// STBグループID6
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID6) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID6))) 
		{
			template.setNull(EWC0011D010CBSMsg.STB_GRP_ID_6);
		} 
		else 
		{
			template.set(EWC0011D010CBSMsg.STB_GRP_ID_6, msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID6));
		}
		
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	/**
	 *視聴制御オーダ送信サービスのパラメータセット
	 * @param paramMap
	 * @param inMap
	 * @param tmpParamMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public HashMap<String, Object> editOrderSendMsg(HashMap<String, Object> paramMap, HashMap inMap, HashMap<String, Object> tmpParamMap)throws RequestParameterException 
	{
		
		CAANMsg template = new CAANMsg(EWC0011C010CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EWC0011C010CBSMsg.TEMPLATEID, "EWC0011C010");
		
		if(inMap != null)
		{
			// 機能コード（デフォルト：１）
			template.set(EWC0011C010CBSMsg.FUNC_CODE, "1");
			// 運用日付
			template.set(EWC0011C010CBSMsg.OPERATEDATE,tmpParamMap.get("operate_date_key"));
			// 運用日時
			template.set(EWC0011C010CBSMsg.OPERATEDATETIME,tmpParamMap.get("operate_datetime_key"));
			// オペレータID
			template.set(EWC0011C010CBSMsg.OPERATORID,tmpParamMap.get("operator_id"));
			// 視聴制御オーダコード("02":仮登録（アンリンク）・撤去)
			template.set(EWC0011C010CBSMsg.WCTRL_ORDER_CD, JWCStrConst.CD_DIV_WCTRL_ORDER_UNSET);
			// 制御タイプコード("0":リアル)
			template.set(EWC0011C010CBSMsg.CTRL_TYPE_CD, "0");
			// 制御モードコード("1")
			template.set(EWC0011C010CBSMsg.CTRL_MODE_CD, "1");
			
			// デジタルティア（Remux）明細(null)
			template.setNull(EWC0011C010CBSMsg.EWC0011D010CBSMSG1LIST);
			// デジタルティア（Remux）(null)
			// template.setNull(EWC0011C010CBSMsg.);
			// デジタルティア（TM）領域０明細(null)
			template.setNull(EWC0011C010CBSMsg.EWC0011D010CBSMSG2LIST);
			// デジタルティア（TM）領域１明細(null)
			template.setNull(EWC0011C010CBSMsg.EWC0011D010CBSMSG3LIST);
			// デジタルティア（TM）領域２明細(null)
			template.setNull(EWC0011C010CBSMsg.EWC0011D010CBSMSG4LIST);
			// デジタルティア（TM）領域３明細(null)
			template.setNull(EWC0011C010CBSMsg.EWC0011D010CBSMSG5LIST);
			
			// 課金フラグ(null)
			template.setNull(EWC0011C010CBSMsg.CHRG_FLG);
			// グループID明細(null)
			template.setNull(EWC0011C010CBSMsg.EWC0011D010CBSMSG6LIST);
			// C-CAS初期化コマンド発行フラグ(null)
			template.setNull(EWC0011C010CBSMsg.CCAS_SHKKA_CMD_HAK_FLG);
			// 再設定フラグ(null)
			template.setNull(EWC0011C010CBSMsg.RE_SETTE_FLG);
		}
		
		// 局コード
		if (tmpParamMap.get("kyoku_cd")== null || "".equals(tmpParamMap.get("kyoku_cd"))) 
		{
			template.setNull(EWC0011C010CBSMsg.KYOKU_CD);
		} 
		else 
		{
			template.set(EWC0011C010CBSMsg.KYOKU_CD, tmpParamMap.get("kyoku_cd"));
		}
		
		// 制御エリアコード
		if (tmpParamMap.get("ctrl_area_cd") == null || "".equals(tmpParamMap.get("ctrl_area_cd"))) 
		{
			template.setNull(EWC0011C010CBSMsg.CTRL_AREA_CD);
		} 
		else 
		{
			template.set(EWC0011C010CBSMsg.CTRL_AREA_CD, tmpParamMap.get("ctrl_area_cd"));
		}
		
		//制御要求キー
		if (tmpParamMap.get("ctrl_yokyu_key") == null || "".equals(tmpParamMap.get("ctrl_yokyu_key"))) 
		{
			template.setNull(EWC0011C010CBSMsg.CTRL_YOKYU_KEY);
		} 
		else 
		{
			template.set(EWC0011C010CBSMsg.CTRL_YOKYU_KEY, tmpParamMap.get("ctrl_yokyu_key"));
		}
		
		CAANMsg msgList = (CAANMsg)tmpParamMap.get("EWCA0010001CBSMSG1LIST");
		
		// STBID
		if (msgList.getString(EWCA0010001CBSMsg1List.STBID) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STBID))) 
		{
			template.setNull(EWC0011C010CBSMsg.STB_ID);
		} 
		else 
		{
			template.set(EWC0011C010CBSMsg.STB_ID, msgList.getString(EWCA0010001CBSMsg1List.STBID));
		}
		
		// 製造番号
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_KK_SEIZO_NO) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_KK_SEIZO_NO))) 
		{
			template.setNull(EWC0011C010CBSMsg.STB_KIKI_SEIZO_NO);
		} 
		else 
		{
			template.set(EWC0011C010CBSMsg.STB_KIKI_SEIZO_NO, msgList.getString(EWCA0010001CBSMsg1List.STB_KK_SEIZO_NO));
		}
		
		// 制御用機種コード
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_MAKER_KOYU_CTL_MDL_CD) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_MAKER_KOYU_CTL_MDL_CD))) 
		{
			template.setNull(EWC0011C010CBSMsg.STB_CTRL_MODEL_CD);
		} 
		else 
		{
			template.set(EWC0011C010CBSMsg.STB_CTRL_MODEL_CD, msgList.getString(EWCA0010001CBSMsg1List.STB_MAKER_KOYU_CTL_MDL_CD));
		}
		
		// CCAS内蔵タイプSTB
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_NAIZOCAS_CD) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_NAIZOCAS_CD))) 
		{
			template.setNull(EWC0011C010CBSMsg.STB_CAS_NAIZO_FLG);
		} 
		else 
		{
			template.set(EWC0011C010CBSMsg.STB_CAS_NAIZO_FLG, msgList.getString(EWCA0010001CBSMsg1List.STB_NAIZOCAS_CD));
		}
		
		// CCASID
		if (msgList.getString(EWCA0010001CBSMsg1List.CCAS_KK_SEIZO_NO) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.CCAS_KK_SEIZO_NO))) 
		{
			template.setNull(EWC0011C010CBSMsg.CCAS_CARD_NO);
		} 
		else 
		{
			template.set(EWC0011C010CBSMsg.CCAS_CARD_NO, msgList.getString(EWCA0010001CBSMsg1List.CCAS_KK_SEIZO_NO));
		}
		
		// BCASID
		if (msgList.getString(EWCA0010001CBSMsg1List.BCAS_KK_SEIZO_NO) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.BCAS_KK_SEIZO_NO))) 
		{
			template.setNull(EWC0011C010CBSMsg.BCAS_CARD_NO);
		} 
		else 
		{
			template.set(EWC0011C010CBSMsg.BCAS_CARD_NO, msgList.getString(EWCA0010001CBSMsg1List.BCAS_KK_SEIZO_NO));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	/**
	 *視聴制御オーダ結果登録サービスのパラメータセット
	 * @param paramMap
	 * @param inMap
	 * @param tmpParamMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public HashMap<String, Object> editOrderResultRegistMsg(HashMap<String, Object> paramMap, HashMap inMap, HashMap<String, Object> tmpParamMap)throws RequestParameterException 
	{
		
		CAANMsg template = new CAANMsg(EWC0011C020CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EWC0011C020CBSMsg.TEMPLATEID, "EWC0011C020");
		
		if(inMap != null)
		{
			// 機能コード（デフォルト：１）
			template.set(EWC0011C010CBSMsg.FUNC_CODE, "1");
//IT1-2017-0000118 DEL START
//			// 視聴制御オーダステータス("000":正常)
//			template.set(EWC0011C020CBSMsg.WCTRL_ORDER_STAT, "000");
//			// 制御コマンド発行済フラグ("0":発行済)
//			template.set(EWC0011C020CBSMsg.CTRL_CMD_HAKKO_ZUMI_FLG, "0");
//IT1-2017-0000118 DEL END
			// 運用日付
			template.set(EWC0011C020CBSMsg.OPERATEDATE,tmpParamMap.get("operate_date_key"));
			// 運用日時
			template.set(EWC0011C020CBSMsg.OPERATEDATETIME,tmpParamMap.get("operate_datetime_key"));
			// オペレータID
			template.set(EWC0011C020CBSMsg.OPERATORID,tmpParamMap.get("operator_id"));
		}
		
		// 視聴制御オーダ番号
		if (tmpParamMap.get("wctrl_order_no") == null || "".equals(tmpParamMap.get("wctrl_order_no"))) 
		{
			template.setNull(EWC0011C020CBSMsg.WCTRL_ORDER_NO);
		} 
		else 
		{
			template.set(EWC0011C020CBSMsg.WCTRL_ORDER_NO, tmpParamMap.get("wctrl_order_no"));
		}
		
//IT1-2017-0000118 ADD START
		CAANMsg msgList = (CAANMsg)tmpParamMap.get("EWC0011C010CBSMSG1LIST");
		
		// 視聴制御オーダステータス
		if (msgList.getString(EWC0011C010CBSMsg.WCTRL_ORDER_STAT) == null || "".equals(msgList.getString(EWC0011C010CBSMsg.WCTRL_ORDER_STAT))) 
		{
			template.setNull(EWC0011C020CBSMsg.WCTRL_ORDER_STAT);
		} 
		else 
		{
			template.set(EWC0011C020CBSMsg.WCTRL_ORDER_STAT, msgList.getString(EWC0011C010CBSMsg.WCTRL_ORDER_STAT));
		}
			
//IT1-2017-0000118 ADD END
//IT1-2017-0000118 MOD END
//		//オーダ送信年月日時分秒
//		if (tmpParamMap.get("order_send_dtm") == null || "".equals(tmpParamMap.get("order_send_dtm"))) 
//		{
//			template.setNull(EWC0011C020CBSMsg.ORDER_SEND_DTM);
//		} 
//		else 
//		{
//			template.set(EWC0011C020CBSMsg.ORDER_SEND_DTM, tmpParamMap.get("order_send_dtm"));
//		}
		
		//オーダ送信年月日時分秒
		if (msgList.getString(EWC0011C010CBSMsg.ORDER_SEND_DTM) == null || "".equals(msgList.getString(EWC0011C010CBSMsg.ORDER_SEND_DTM))) 
		{
			template.setNull(EWC0011C020CBSMsg.ORDER_SEND_DTM);
		} 
		else 
		{
			template.set(EWC0011C020CBSMsg.ORDER_SEND_DTM, msgList.getString(EWC0011C010CBSMsg.ORDER_SEND_DTM));
		}
//IT1-2017-0000118 MOD END
		
//IT1-2017-0000118 ADD START
		//制御コマンド発行済フラグ
		if (msgList.getString(EWC0011C010CBSMsg.CTRL_CMD_HAKKO_ZUMI_FLG) == null || "".equals(msgList.getString(EWC0011C010CBSMsg.CTRL_CMD_HAKKO_ZUMI_FLG))) 
		{
			template.setNull(EWC0011C020CBSMsg.CTRL_CMD_HAKKO_ZUMI_FLG);
		} 
		else 
		{
			template.set(EWC0011C020CBSMsg.CTRL_CMD_HAKKO_ZUMI_FLG, msgList.getString(EWC0011C010CBSMsg.CTRL_CMD_HAKKO_ZUMI_FLG));
		}
		//実行結果コード
		if (msgList.getString(EWC0011C010CBSMsg.RUN_RSLT_CD) == null || "".equals(msgList.getString(EWC0011C010CBSMsg.RUN_RSLT_CD))) 
		{
			template.setNull(EWC0011C020CBSMsg.RUN_RSLT_CD);
		} 
		else 
		{
			template.set(EWC0011C020CBSMsg.RUN_RSLT_CD, msgList.getString(EWC0011C010CBSMsg.RUN_RSLT_CD));
		}
//IT1-2017-0000118 ADD END

		// 更新前最終年月日時分秒
		if (tmpParamMap.get("last_upd_dtm_bf") == null || "".equals(tmpParamMap.get("last_upd_dtm_bf"))) 
		{
			template.setNull(EWC0011C020CBSMsg.LAST_UPD_DTM_BF);
		} 
		else 
		{
			template.set(EWC0011C020CBSMsg.LAST_UPD_DTM_BF, tmpParamMap.get("last_upd_dtm_bf"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	/**
	 *STB更新サービスのパラメータセット
	 * @param paramMap
	 * @param inMap
	 * @param tmpParamMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public HashMap<String, Object> editSTBUpdateMsg(HashMap<String, Object> paramMap, HashMap inMap, HashMap<String, Object> tmpParamMap)throws RequestParameterException 
	{
		
		CAANMsg template = new CAANMsg(EWCA0010003CBSMsg.class.getName());
		
		// テンプレートID
		template.set(EWCA0010003CBSMsg.TEMPLATEID, "EWCA0010003");
		
		if(inMap != null)
		{
			// 機能コード（デフォルト：１）
			template.set(EWCA0010003CBSMsg.FUNC_CODE, "1");
			// 運用日付
			template.set(EWCA0010003CBSMsg.OPERATEDATE,tmpParamMap.get("operate_date_key"));
			// 運用日時
			template.set(EWCA0010003CBSMsg.OPERATEDATETIME,tmpParamMap.get("operate_datetime_key"));
			// オペレータID
			template.set(EWCA0010003CBSMsg.OPERATORID,tmpParamMap.get("operator_id"));
// ST-2017-0000015 DEL START
//			// STB宅内機器更新日付
//			template.set(EWCA0010003CBSMsg.STB_UPD_DTTM, JCCBPCommon.getSysDateTimeStamp());
//			// CCAS宅内機器更新日時
//			template.set(EWCA0010003CBSMsg.CCAS_UPD_DTTM, JCCBPCommon.getSysDateTimeStamp());
// ST-2017-0000015 DEL END
		}
		
		CAANMsg msgList = (CAANMsg)tmpParamMap.get("EWCA0010001CBSMSG1LIST");
		
		// STB宅内機器型式コード
		
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_TK_MDL_CD) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_TK_MDL_CD))) 
		{
			template.setNull(EWCA0010003CBSMsg.STB_TK_MDL_CD);
		} 
		else 
		{
			template.set(EWCA0010003CBSMsg.STB_TK_MDL_CD, msgList.getString(EWCA0010001CBSMsg1List.STB_TK_MDL_CD));
		}
		
		// STB機器製造番号
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_KK_SEIZO_NO) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_KK_SEIZO_NO))) 
		{
			template.setNull(EWCA0010003CBSMsg.STB_KK_SEIZO_NO);
		} 
		else 
		{
			template.set(EWCA0010003CBSMsg.STB_KK_SEIZO_NO, msgList.getString(EWCA0010001CBSMsg1List.STB_KK_SEIZO_NO));
		}
		
		// STB宅内機器種別コード
// ST-2017-0000015 MOD START
//		if (tmpParamMap.get("taknkiki_sbt_cd") == null || "".equals(tmpParamMap.get("taknkiki_sbt_cd"))) 
//		{
//			template.setNull(EWCA0010003CBSMsg.STB_TK_SBT_CD);
//		} 
//		else 
//		{
//			template.set(EWCA0010003CBSMsg.STB_TK_SBT_CD, tmpParamMap.get("taknkiki_sbt_cd"));
		template.set(EWCA0010003CBSMsg.STB_TK_SBT_CD, JDKStrConst.STB);
//		}
// ST-2017-0000015 MOD END
		
		// STBステータスコード
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_STAT_CD) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_STAT_CD))) 
		{
			template.setNull(EWCA0010003CBSMsg.STB_STAT_CD);
		} 
		else 
		{
//IT1-2017-0000118 MOD START
//			template.set(EWCA0010003CBSMsg.STB_STAT_CD, msgList.getString(EWCA0010001CBSMsg1List.STB_STAT_CD));
			template.set(EWCA0010003CBSMsg.STB_STAT_CD, JWCStrConst.CD_DIV_WATCH_KIKI_KANRI_STAT_TEKKYOZUMI);
//IT1-2017-0000118 MOD END
		}
		
		// STB松下用グループID1
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID1) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID1))) 
		{
			template.setNull(EWCA0010003CBSMsg.STB_MATSU_YO_GRPID1);
		} 
		else 
		{
			template.set(EWCA0010003CBSMsg.STB_MATSU_YO_GRPID1, msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID1));
		}
		
		// STB松下用グループID2
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID2) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID2))) 
		{
			template.setNull(EWCA0010003CBSMsg.STB_MATSU_YO_GRPID2);
		} 
		else 
		{
			template.set(EWCA0010003CBSMsg.STB_MATSU_YO_GRPID2, msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID2));
		}
		
		// STB松下用グループID3
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID3) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID3))) 
		{
			template.setNull(EWCA0010003CBSMsg.STB_MATSU_YO_GRPID3);
		} 
		else 
		{
			template.set(EWCA0010003CBSMsg.STB_MATSU_YO_GRPID3, msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID3));
		}

		// STB松下用グループID4
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID4) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID4))) 
		{
			template.setNull(EWCA0010003CBSMsg.STB_MATSU_YO_GRPID4);
		} 
		else 
		{
			template.set(EWCA0010003CBSMsg.STB_MATSU_YO_GRPID4, msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID4));
		}
		
		// STB松下用グループID5
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID5) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID5))) 
		{
			template.setNull(EWCA0010003CBSMsg.STB_MATSU_YO_GRPID5);
		} 
		else 
		{
			template.set(EWCA0010003CBSMsg.STB_MATSU_YO_GRPID5, msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID5));
		}
		
		// STB松下用グループID6
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID6) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID6))) 
		{
			template.setNull(EWCA0010003CBSMsg.STB_MATSU_YO_GRPID6);
		} 
		else 
		{
			template.set(EWCA0010003CBSMsg.STB_MATSU_YO_GRPID6, msgList.getString(EWCA0010001CBSMsg1List.STB_MATSU_YO_GRPID6));
		}
		
		// 制御エリアコード
		if (tmpParamMap.get("ctrl_area_cd") == null || "".equals(tmpParamMap.get("ctrl_area_cd"))) 
		{
			template.setNull(EWCA0010003CBSMsg.CTL_AREA_CD);
		} 
		else 
		{
			template.set(EWCA0010003CBSMsg.CTL_AREA_CD, tmpParamMap.get("ctrl_area_cd"));
		}
		
// ST-2017-0000015 ADD START
		// ＳＴＢ宅内機器更新日時
		if (msgList.getString(EWCA0010001CBSMsg1List.STB_UPD_DTTM) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.STB_UPD_DTTM))) 
		{
			template.setNull(EWCA0010003CBSMsg.STB_UPD_DTTM);
		} 
		else 
		{
			template.set(EWCA0010003CBSMsg.STB_UPD_DTTM, msgList.getString(EWCA0010001CBSMsg1List.STB_UPD_DTTM));
		}
		
		// Ｃ−ＣＡＳ宅内機器更新日時
		if (msgList.getString(EWCA0010001CBSMsg1List.CCAS_CAST_UPD_DTTM) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.CCAS_CAST_UPD_DTTM))) 
		{
			template.setNull(EWCA0010003CBSMsg.CCAS_UPD_DTTM);
		} 
		else 
		{
			template.set(EWCA0010003CBSMsg.CCAS_UPD_DTTM, msgList.getString(EWCA0010001CBSMsg1List.CCAS_CAST_UPD_DTTM));
		}
// ST-2017-0000015 ADD END
		
		// CCASカードステータスコード
		if (msgList.getString(EWCA0010001CBSMsg1List.CCAS_CARD_STAT_CD) == null || "".equals(msgList.getString(EWCA0010001CBSMsg1List.CCAS_CARD_STAT_CD))) 
		{
			template.setNull(EWCA0010003CBSMsg.CCAS_CARD_STAT_CD);
		} 
		else 
		{
//IT1-2017-0000118 MOD START
//			template.set(EWCA0010003CBSMsg.CCAS_CARD_STAT_CD, msgList.getString(EWCA0010001CBSMsg1List.CCAS_CARD_STAT_CD));
			template.set(EWCA0010003CBSMsg.CCAS_CARD_STAT_CD, JWCStrConst.CD_DIV_CCAS_CARD_KANRI_STAT_MISYOKIKA);
//IT1-2017-0000118 MOD END
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		
		return paramMap;
	}
	
	/**
	 *視聴制御オーダ受付サービスの結果セット
	 * @param msgList
	 * @param tmpParamMap
	 * @throws RequestParameterException
	 */
	public void editResultUktk(Map<?, ?> msgList, HashMap<String, Object> tmpParamMap) throws RequestParameterException {
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];

		// 視聴制御オーダ番号
		if (parentTemplate.isNull(EWC0011D010CBSMsg.WCTRL_ORDER_NO)) {
			tmpParamMap.put("wctrl_order_no", new String());
		} else {
			tmpParamMap.put("wctrl_order_no", parentTemplate.getString(EWC0011D010CBSMsg.WCTRL_ORDER_NO));
		}

		// 制御要求キー
		if (parentTemplate.isNull(EWC0011D010CBSMsg.CTRL_YOKYU_KEY)) {
			tmpParamMap.put("ctrl_yokyu_key", new String());
		} else {
			tmpParamMap.put("ctrl_yokyu_key", parentTemplate.getString(EWC0011D010CBSMsg.CTRL_YOKYU_KEY));
		}

		// 更新年月日時分秒
		if (parentTemplate.isNull(EWC0011D010CBSMsg.UPD_DTM)) {
			tmpParamMap.put("last_upd_dtm_bf", new String());
		} else {
			tmpParamMap.put("last_upd_dtm_bf", parentTemplate.getString(EWC0011D010CBSMsg.UPD_DTM));
		}

		return;
	}
	
//IT1-2017-0000118 DEL START
//	/**
//	 *視聴制御オーダ送信サービスの結果セット
//	 * @param msgList
//	 * @param tmpParamMap
//	 * @throws RequestParameterException
//	 */
//	public void editResultSend(Map<?, ?> msgList, HashMap<String, Object> tmpParamMap) throws RequestParameterException {
//
//		// SCからの戻り値からCAANMsgを取得する。
//		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
//		CAANMsg parentTemplate = templates[0];
//
//		// オーダ送信年月日時分秒
//		if (parentTemplate.isNull(EWC0011C020CBSMsg.ORDER_SEND_DTM)) {
//			tmpParamMap.put("order_send_dtm", new String());
//		} else {
//			tmpParamMap.put("order_send_dtm", parentTemplate.getString(EWC0011C020CBSMsg.ORDER_SEND_DTM));
//		}
//		return;
//	}
//IT1-2017-0000118 END START
	
	/**
	 * 例外発生させるためのサービスIFエラー（ダミー）を設定します。
	 * @param param
	 * @param paramMap
	 * @param errIfId エラー発生サービスIFID
	 * @param errItem エラー発生項目
	 * @return パラメータマップ
	 * @throws RequestParameterException
	 */
	protected void setExceptionErr(IRequestParameterReadWrite param, Map<String, Object> inMap, String errIfId, String errItem)
			throws RequestParameterException
	{
		inMap.put(errItem, "EZ");
		
		int templateStatus = JPCModelConstant.RELATION_ERR;
		
		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);
		}
		
		// エラー情報のリストを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		HashMap<String, Object> errorMap = new HashMap<String, Object>();
		HashMap<String, String> errorMapChild = new HashMap<String, String>();
		
		errorMap.put(ErrorInfoMapKeys.RETURN_CODE, JPCModelConstant.NORMAL_END);
		errorMap.put(ErrorInfoMapKeys.TEMPLATE_ID, errIfId);
		errorMap.put(ErrorInfoMapKeys.STATUS, JPCModelConstant.RELATION_ERR);
		
		errorMapChild.put(errItem, "EZ");
		errorMap.put(ErrorInfoMapKeys.ITEM_CHECK_ERRORS, errorMapChild);
		
		errList.add(errorMap);
		
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, errList);
	}
	
	/**
	 *エラーチェック用にエラーコードのみマッピングする
	 * @param msgList S/IF実行結果 
	 * @param param パラメータ
	 * @return パラメータ
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editResultRrr(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception {
		
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// エラー情報の設定
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		param = editError(param, templates, (Integer)return_code);
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	/**
	 *エラーチェック用にエラーデータをマッピングする
	 * @param msgList S/IF実行結果 
	 * @param param パラメータ
	 * @param returnCode リターンコード
	 * @return パラメータ
	 */
	public IRequestParameterReadWrite editError(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode)
	throws Exception {
		if (templates.length == 0)
		{
			return param;
		}
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0161B004CBSMsg.STATUS);
		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);
		}
		return param;
	}
// ANK-3080-00-00 ADD END
}