/********************************************************************
 *  All Rights reserved,Copyright (c) K-Opticom
 ********************************************************************
 *＜プログラム内容＞
 *  システム名      ：eo顧客基幹システム
 *  モジュール名    ：住所情報変更コンポーネント部品クラス
 *  ソースファイル名：JKKUsePlaceAdInfUpdCC.java
 *  作成者          ：FJ
 *  日付            ：2021年12月15日
 *＜機能概要＞
 *  利用場所住所を変更する
 *＜修正履歴＞
 *  バージョン  修正日      修正者      修正内容
 *  v56.00.00    2021/12/15  FJ)舘山    【ANK-4174-00-00】開通前マイページ関連業務改善（2022年1月下旬リリース）
 *  v61.00.00    2023/04/11  FJ藤本涼   【ANK-4315-00-00】【eo定期】 eoホームゲートウェイ導入対応
 *  v72.00.00    2024/11/20  FJ)星野    【ANK-4494-27-00】【双方向番ポ対応】オーダ流通S向け番ポ工事編集仕様の変更対応
********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

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

import com.fujitsu.futurity.bp.custom.constant.JKKAdInfChgConstCC;
import com.fujitsu.futurity.bp.custom.constant.JKKAdchgConstCC;
import com.fujitsu.futurity.bp.custom.constant.JKKSvcConst;
import com.fujitsu.futurity.bp.x21.bpm.ServiceComponentRequestInvoker;
import com.fujitsu.futurity.bp.x21.bpm.db.SessionHandle;
import com.fujitsu.futurity.bp.x21.bpm.exception.RequestParameterException;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadWrite;
import com.fujitsu.futurity.bp.x21.cc.AbstractCommonComponent;
import com.fujitsu.futurity.bp.x21.cc.exception.CCException;
import com.fujitsu.futurity.bp.x21.sc.exception.SCException;
import com.fujitsu.futurity.common.x01.sc.SCControlMapKeys;
import com.fujitsu.futurity.model.base.CAANMsg;
import com.fujitsu.futurity.model.common.check.HalfCharCheck;
import com.fujitsu.futurity.model.common.check.LengthCheck;
import com.fujitsu.futurity.model.common.check.MixCharCheck;
import com.sun.enterprise.tools.common.util.StringUtils;

import eo.common.constant.JKKStrConst;
import eo.common.constant.JTUStrConst;
import eo.common.util.JKKStringUtil;
import eo.ejb.cbs.cbsmsg.ECK0011A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0011D020CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0011D020CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081B007CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0161A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0191A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0191B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0191C060CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0241B002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0251A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0251C030CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341B501CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341C200CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C220CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C230CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0341C234CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK2091B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2091B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK2101B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK2101B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK2401D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKKA0020002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKKA0020002CBSMsg2List;
import eo.ejb.cbs.cbsmsg.EKKA0020003CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKKA0020003CBSMsg2List;
import eo.ejb.cbs.cbsmsg.EKKA0020004CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ETU0011A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ETU0011B010CBSMsg;
import eo.ejb.cbs.cbsmsg.ETU0011B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ETU0011C010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0081B050CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0091B010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0301A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0411A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0411A010CBSMsg1List;

/**
 * 利用場所ｓ住所情報変更コンポーネント部品クラス.
 * <br>
 * @author FJ
 */
public class JKKUsePlaceAdInfUpdCC extends AbstractCommonComponent 
{

	/** 住所変更ＳＯＤ発行ＣＣ呼出文字列 */
	private static final String SOD_CC_FIXED_TEXT = "sod_trgt_data";
	
	// 進捗の特記事項に登録する補足事項の固定文言一覧
	
	// ※※※※※※※ 共通定数群 START ※※※※※※※
	/** 進捗特記事項の最大文字列許可数（） */
	private static final int PRG_TKJK_MAX_VALUE = 128 ;
	/** 共通句点（カンマ区切り） */
	private static final String PCG_KUTEN_CANMA = "、";
	// ※※※※※※※ 共通定数群 END ※※※※※※※
	
	// ※※※※※※※ 利用場所住所項目 START ※※※※※※※
	/** 利用場所住所_郵便番号 */
	private static final String PCG_RIYOBASHO_PCD_TEXT = "変更前郵便番号:";
	/** 利用場所住所_住所 */
	private static final String PCG_RIYOBASHO_AD_TEXT = "変更前住所:";
	/** 利用場所住所_住所未確定設定 */
	private static final String PCG_RIYOBASHO_AD_MI_FIX_TEXT = "変更前未確定:";
	/** 利用場所住所_住所未確定_確定 */
	private static final String PCG_RIYOBASHO_AD_FIX_FLG = "住所確定";
	/** 利用場所住所_住所未確定_確定 */
	private static final String PCG_RIYOBASHO_AD_MI_FIX_FLG = "住所未確定";
	/** 利用場所住所_郵便番号 */
	private static final String PCG_RIYOBASHO_PCD_TEXT_AF = "変更後郵便番号:";
	/** 利用場所住所_住所 */
	private static final String PCG_RIYOBASHO_AD_TEXT_AF = "変更後住所:";
	// ※※※※※※※ 利用場所住所項目 END ※※※※※※※
	
	// 入力パラメータ
	/** サービス契約回線内訳番号 */	
	private static final String PARAM_SVC_KEI_KAISEN_UCWK_NO = "svc_kei_kaisen_ucwk_no";
	/** 郵便番号 */
	private static final String PARAM_AD_PCD = "ad_pcd";
	/** 都道府県名 */	
	private static final String PARAM_AD_STATE_NM = "ad_state";
	/** 市区町村名 */	
	private static final String PARAM_AD_CITY_NM = "ad_city";
	/** 大字通称名 */	
	private static final String PARAM_AD_OAZTSU_NM = "ad_oaztsu";
	/** 字丁目名 */	
	private static final String PARAM_AD_AZCHO_NM = "ad_azcho";
	/** 番地号 */	
	private static final String PARAM_AD_BNCHIGO = "ad_bnchigo";
	/** 建物名 */	
	private static final String PARAM_AD_ADRTTM = "ad_adrttm";
	/** 部屋番号 */	
	private static final String PARAM_AD_ADRRM = "ad_adrrm";

	// 上記以外の住所情報
	/** 回線場所住所未確定フラグ */
	private static final String KISN_PLC_AD_MI_FIX_FLG = "kisn_plc_ad_mi_fix_flg";
	/** 回線場所_契約者住所差異フラグ */
	private static final String KAISEN_PLC_KSH_AD_SAI_FLG = "kaisen_plc_ksh_ad_sai_flg";
	/** 回線場所住所コード */
	private static final String KAISEN_PLACE_AD_CD = "kaisen_place_ad_cd";
	/** 手動入力フラグ */
	private static final String MAN_INPUT_FLG = "man_input_flg";

	// 更新対象の契約リスト
	/** サービス契約リスト */
	private static final String SVC_KEI_LIST = "svc_kei_list";
	
	/** サービス契約内訳リスト */
	private static final String SVC_KEI_UCWK_LIST = "svc_kei_ucwk_list";
	
	// サービスマップ内のキー情報
	/** サービス契約回線内訳マップ */
	private static final String SVC_KEI_KAISEN_UW_MAP = "target_svc_kei_kaisen_uw_map";

	// 特殊キー
	/** 工事案件更新をスキップする */
	private static final String KOJIAK_SKIP_FLG = "kojiak_skip_flg";
	
	// ---------------------------------------------------------
	// API向けの共通定数
	// ---------------------------------------------------------
	/** エラー情報マップキー*/
	private static final String KEY_ERROR_INFO = "ERROR_INFO";
	
	/** エラーコードマップキー*/
	private static final String KEY_ERR_CD = "errCode";

	/** エラーメッセージマップキー*/
	private static final String KEY_ERRMSG = "errMessage";
	
	/** 属性の種別 */
	private enum AttrType {
		NUM_ALF_1, NUM_1, NAME_AD
	}
	
	/** エラーコード 必須チェックエラー*/
	private static final String REQUIRED_ERROR  = "E1001";
	/** エラーコード 属性チェックエラー*/
	private static final String ATTRIBUTE_ERROR = "E2001";
	/** エラーコード 桁数チェックエラー*/
	private static final String LENGTH_ERROR    = "E3001";

	/**
	 * コンストラクタ.
	 * <br>
	 */
	public JKKUsePlaceAdInfUpdCC() 
	{
	}

	/**
	 * 住所情報変更反映処理.
	 * <br>
	 * @param   handle     セッションマネージャなどを持ったハンドル情報
	 * @param   param      モデルグループ、コントロールマップを含むリクエストパラメータ
	 * @param   fixedText  ユーザ任意文字列
	 * @throws  Throwable  例外が発生した場合
	 * @return  リクエストパラメータ(param)に戻り値を追加して返却する
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite execute( SessionHandle handle, IRequestParameterReadWrite param, String fixedText ) throws Throwable 
	{

		/** 事前準備 */
		HashMap<String, Object> paramMap = (HashMap<String, Object>)param.getData(fixedText);

		// レスポンス用のパラメータを作成する
		HashMap<String, Object> responseParam = new HashMap<String, Object>(paramMap);

		// パラメータチェックを実行する
		ArrayList errList = getParameterErrorInfo(paramMap);
		if (errList.size() > 0)
		{
			// エラー情報を設定
			responseParam.put(KEY_ERROR_INFO, errList);
			param.setData(fixedText, responseParam);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, JKKStrConst.RETURN_CD_1000);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, JKKStrConst.RETURN_MESSAGE_ZOKUSEI_CHECK_ERROR);
			return param;
		}

		try {
			/** 初期データセットアップ */
			int errCode = setupInitData(handle, param, fixedText);
			if (errCode != 0)
			{
				errList.add(createErrorMap(String.format("E%d", errCode), null, null));
				responseParam.put(KEY_ERROR_INFO, errList);
				param.setData(fixedText, responseParam);
				param.setControlMapData(SCControlMapKeys.RETURN_CODE, JKKStrConst.RETURN_CD_1050);
				param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, JKKStrConst.RETURN_MESSAGE_SEIGO_CHECK_ERROR);
				return param;
			}

			// 申込承認登録 
			addMskm(handle, param, fixedText);
			
			// 利用場所住所変更
			updateUsePlaceAd( handle, param, fixedText );

			// 工事情報変更
			variousChange(handle, param, fixedText); 
		} 
		catch (Throwable e)
		{
			// 更新に失敗した場合はCCException
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, JKKStrConst.RETURN_CD_9000);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, JKKStrConst.RETURN_MESSAGE_SYSTEM_ERROR);
			throw new CCException("", e);
		}
		
		// 返却値を設定する
		param.setData(fixedText, responseParam);

		return param;
	}

	/**
	 * パラメータ入力チェックを行いエラーのリストを返す
	 * <br>
	 * @param param 対象のパラメータ
	 * @return エラー情報のリスト（エラーがなければ空）
	 */
	private ArrayList<HashMap<String, Object>>  getParameterErrorInfo(HashMap<String, Object> dataMap)
	{
		ArrayList<HashMap<String, Object>> errList = new ArrayList<HashMap<String, Object>>();
		
		// サービス契約回線内訳番号 必須
		String svcKeiKaisenUWNo = (String)dataMap.get(PARAM_SVC_KEI_KAISEN_UCWK_NO); 
		{
			String errCd = checkError(svcKeiKaisenUWNo, true, AttrType.NUM_ALF_1, 12, 12);
			if (errCd != null)
			{
				errList.add(createErrorMap(errCd, PARAM_SVC_KEI_KAISEN_UCWK_NO, svcKeiKaisenUWNo));
				return errList;
			}
		}
		// 郵便番号　必須
		String postCd = (String)dataMap.get(PARAM_AD_PCD); 
		{
			String errCd = checkError(postCd, true, AttrType.NUM_1, 7, 7);
			if (errCd != null)
			{
				errList.add(createErrorMap(errCd, PARAM_AD_PCD, postCd));
				return errList;
			}
		}
		// 都道府県名　必須
		String state = (String)dataMap.get(PARAM_AD_STATE_NM); 
		{
			String errCd = checkError(state, true, AttrType.NAME_AD, 1, 4);
			if (errCd != null)
			{
				errList.add(createErrorMap(errCd, PARAM_AD_STATE_NM, state));
				return errList;
			}
		}
		// 市区町村名
		String city = (String)dataMap.get(PARAM_AD_CITY_NM); 
		{
			String errCd = checkError(city, false, AttrType.NAME_AD, 1, 12);
			if (errCd != null)
			{
				errList.add(createErrorMap(errCd, PARAM_AD_CITY_NM, city));
				return errList;
			}
		}
		// 大字通称名
		String oaztsu = (String)dataMap.get(PARAM_AD_OAZTSU_NM);
		{
			String errCd = checkError(oaztsu, false, AttrType.NAME_AD, 1, 18);
			if (errCd != null)
			{
				errList.add(createErrorMap(errCd, PARAM_AD_OAZTSU_NM, oaztsu));
				return errList;
			}
		}
		// 字丁目名
		String azcho = (String)dataMap.get(PARAM_AD_AZCHO_NM);
		{
			String errCd = checkError(azcho, false, AttrType.NAME_AD, 1, 12);
			if (errCd != null)
			{
				errList.add(createErrorMap(errCd, PARAM_AD_AZCHO_NM, azcho));
				return errList;
			}
		}
		// 番地号 必須
		String bnchigo = (String)dataMap.get(PARAM_AD_BNCHIGO);
		{
			String errCd = checkError(bnchigo, true, AttrType.NAME_AD, 1, 61);
			if (errCd != null)
			{
				errList.add(createErrorMap(errCd, PARAM_AD_BNCHIGO, bnchigo));
				return errList;
			}
		}
		// 建物名
		String adrttm = (String)dataMap.get(PARAM_AD_ADRTTM);
		{
			String errCd = checkError(adrttm, false, AttrType.NAME_AD, 1, 45);
			if (errCd != null)
			{
				errList.add(createErrorMap(errCd, PARAM_AD_ADRTTM, adrttm));
				return errList;
			}
		}
		// 部屋番号
		String adrrm = (String)dataMap.get(PARAM_AD_ADRRM);
		{
			String errCd = checkError(adrrm, false, AttrType.NAME_AD, 1, 15);
			if (errCd != null)
			{
				errList.add(createErrorMap(errCd, PARAM_AD_ADRRM, adrrm));
				return errList;
			}
		}
		return errList;
	}

	/**
	 * エラーチェックを行い、エラーが見つかった場合、エラーコードを返す。
	 * <br>
	 * @param src	対象のオブジェクト
	 * @param required	必須チェックを行うかを指定
	 * @param attrType	属性チェックの種類を指定
	 * @param size	桁数を指定
	 * @return エラーが無ければnull。エラーが見つかった場合はエラーコードを返す。
	 */
	private String checkError(Object src, boolean required, AttrType attrType, int min, int max)
	{
		String target = (String)src;
		
		// 必須チェック
		if (required && JKKStringUtil.isNullBlank((String)target))
		{
			return REQUIRED_ERROR;
		}
		// 属性チェックエラー(半角英数１)
		else if (AttrType.NUM_ALF_1.equals(attrType) && !JKKStringUtil.isNullBlank((String)target) && !HalfCharCheck.isEnNumber1Check(target))
		{
			return ATTRIBUTE_ERROR;
		}
		// 属性チェックエラー(半角数字１)
		else if (AttrType.NUM_1.equals(attrType) && !JKKStringUtil.isNullBlank((String)target) && !HalfCharCheck.isNumber1Check(target))
		{
			return ATTRIBUTE_ERROR;
		}
		// 属性チェックエラー(住所／氏名)
		else if (AttrType.NAME_AD.equals(attrType) && !JKKStringUtil.isNullBlank((String)target) && !MixCharCheck.isNameAddressCheck(target))
		{
			return ATTRIBUTE_ERROR;
		}
		// 桁数チェックエラー
		else if (min == max && !JKKStringUtil.isNullBlank((String)target) && !LengthCheck.isLength1Check(target, min))
		{
			return LENGTH_ERROR;
		}
		// 桁数チェックエラー
		else if (min != max && !JKKStringUtil.isNullBlank((String)target) && !LengthCheck.isLength2Check(target, min, max))
		{
			return LENGTH_ERROR;
		}
		return null;
	}
	
	/**
	 * エラーマップを作成する。
	 * <br>
	 * @param cd エラーコード
	 * @param msg エラーメッセージ
	 * @return
	 */
	private HashMap<String, Object> createErrorMap(String cd, String param, String value)
	{
		HashMap<String, Object> map = new HashMap<String, Object>();
		map.put(KEY_ERR_CD, cd);
		if (param == null)
		{
			map.put(KEY_ERRMSG, "");
		}
		else
		{
			map.put(KEY_ERRMSG, param + ":" + value);
		}
		return map;
	}

	/**
	 * 初期データのセットアップ
	 * <br>
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @throws CCException
	 */
	@SuppressWarnings("unchecked")
	private int setupInitData(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws CCException
	{
		try 
		{
			HashMap<String, String> condMap = new HashMap<String, String>();
			HashMap<String, Object> reqMap;
			Map<?, ?> resMap;
			ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

			// 共通のマッパ取得
			JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();
			
			HashMap<String, Object> paramMap = (HashMap<String, Object>)param.getData(fixedText);
			// 解約・キャンセル済を除外
			List<String> rejectStateList = Arrays.asList(new String[] {JKKStrConst.CD00037_DSL_ZM, JKKStrConst.CD00037_CANCEL_ZM});
			
			// サービス契約回線内訳一意照会
			condMap.clear();
			condMap.put( JKKAdInfChgConstCC.COND_KEY_SVC_KEI_KAIS_UCWK_NO, (String)paramMap.get( PARAM_SVC_KEI_KAISEN_UCWK_NO ) );
			condMap.put( JKKAdInfChgConstCC.COND_KEY_OPEDATE, JCCBPCommon.getOpeDate(null) );
			reqMap = mapper.setEKK0251A010( param, fixedText, condMap );
			resMap = scCall.run( reqMap, handle );
			ArrayList<HashMap<String, Object>> kk0251_a010_list = mapper.getEKK0251A010List( param, fixedText, resMap );
			mapper.scResultCheck( param );
			
			// 存在チェック
			if (kk0251_a010_list.size() == 0)
			{
				// 対象の回線内訳番号が存在しない
				return 5001;
			}
			// 変更チェック
			if (!isChanged(kk0251_a010_list.get(0), paramMap))
			{
				// 住所に変更がない
				return 5005;
			}
			// 対象のサービス契約回線内訳をマップに格納
			paramMap.put(SVC_KEI_KAISEN_UW_MAP, kk0251_a010_list.get(0));
			
			// サービス契約回線内訳番号からサービス契約一覧を取得 
			// EKK0241B002
			condMap.clear();
			condMap.put( JKKAdInfChgConstCC.COND_KEY_SVC_KEI_KAIS_UCWK_NO, (String)paramMap.get( PARAM_SVC_KEI_KAISEN_UCWK_NO ) );
			reqMap = mapper.setEKK0241B002( param, fixedText, condMap );
			resMap = scCall.run( reqMap, handle );
			ArrayList<HashMap<String, Object>> kk0241_b002_list = mapper.getEKK0241B002( param, fixedText, resMap );
			mapper.scResultCheck( param );
			
			// サービス契約のSYSIDが複数取得できないこと確認
			ArrayList<HashMap<String, Object>> svcList = new ArrayList<HashMap<String, Object>>();
			String svcKeiNoTel = null;
			for (HashMap<String, Object> kk0241_b010_map : kk0241_b002_list)
			{
				String svcKeiStat = (String)kk0241_b010_map.get(EKK0241B002CBSMsg1List.SVC_KEI_STAT);
				// 解約済、キャンセル済なら除外
				if (rejectStateList.contains(svcKeiStat))
				{
					continue;
				}
				String svcCd = (String)kk0241_b010_map.get(EKK0241B002CBSMsg1List.SVC_CD);
				if (JKKStrConst.CD00130_02.equals(svcCd))
				{
					if (svcKeiNoTel != null)
					{
						// 同一場所に有効な電話が複数ある場合はSYSIDが異なるはずなのでエラー
						return 5004;
					}
					svcKeiNoTel = (String)kk0241_b010_map.get(EKK0241B002CBSMsg1List.SVC_KEI_NO);
				}
				
				// サービス契約一意照会
				condMap.clear();
				condMap.put( "key_svc_kei_no", (String)kk0241_b010_map.get(EKK0241B002CBSMsg1List.SVC_KEI_NO) );
				condMap.put( "key_rsv_aply_ymd", JCCBPCommon.getOpeDate(null) );
				reqMap = mapper.setEKK0081A010( param, fixedText, condMap );
				resMap = scCall.run( reqMap, handle );
				HashMap<String, Object> kk0081_a010_map = mapper.getEKK0081A010( param, fixedText, resMap );
				mapper.scResultCheck( param );
				
				svcList.add(kk0081_a010_map);
				
			}
			// 有効なサービス契約が存在しない
			if (svcList.size() == 0)
			{
				return 5006;
			}
			// マップにサービス契約リストを追加する
			paramMap.put(SVC_KEI_LIST, svcList);
			
			// SYSIDを保持
			paramMap.put(JKKAdInfChgConstCC.PARAM_KEY_SYSID, getBaseSysid(svcList));
			
			// お客様を取得 ・ECK0011A010  お客様一意照会
			condMap.clear();
			condMap.put( JKKAdInfChgConstCC.COND_KEY_SYSID, (String)paramMap.get(JKKAdInfChgConstCC.PARAM_KEY_SYSID) );
			condMap.put( JKKAdInfChgConstCC.COND_KEY_OPEDATE, JCCBPCommon.getOpeDate(null) );
			reqMap = mapper.setECK0011A010( param, fixedText, condMap );
			resMap = scCall.run( reqMap, handle );
			HashMap<String, Object> ck0011_a010_map = mapper.getECK0011A010( param, fixedText, resMap );
			mapper.scResultCheck( param );
			
			// 住所マスタから住所コードを取得 EZM0081B100
			condMap.clear();
			condMap.put( JKKAdInfChgConstCC.COND_KEY_STATE_NM, (String)paramMap.get( PARAM_AD_STATE_NM ) );
			condMap.put( JKKAdInfChgConstCC.COND_KEY_CITY_NM, (String)paramMap.get( PARAM_AD_CITY_NM) );
			condMap.put( JKKAdInfChgConstCC.COND_KEY_OAZTSU_NM, (String)paramMap.get( PARAM_AD_OAZTSU_NM ) );
			condMap.put( JKKAdInfChgConstCC.COND_KEY_AZCHO_NM, (String)paramMap.get( PARAM_AD_AZCHO_NM ) );
			reqMap = mapper.setEZM0081B050( param, fixedText, condMap );
			resMap = scCall.run( reqMap, handle );
			ArrayList<HashMap<String, Object>> zm0081_b050_list = mapper.getEZM0081B050( param, fixedText, resMap );
			mapper.scResultCheck( param );
			
			// 住所コードが取れないもしくは郵便番号が一致しない
			HashMap<String, Object> zm0081_b050_map = getAdressMaster(zm0081_b050_list, (String)paramMap.get(PARAM_AD_PCD));
			if (zm0081_b050_map == null) 
			{
				return 5002;
			}
			// 住所コード
			paramMap.put(KAISEN_PLACE_AD_CD, zm0081_b050_map.get(EZM0081B050CBSMsg1List.AD_CD));
			// 住所確定情報(固定値)
			paramMap.put(KISN_PLC_AD_MI_FIX_FLG, JKKStrConst.CD00467_AD_FIX);
			// 回線場所_契約者住所差異フラグ
			paramMap.put(KAISEN_PLC_KSH_AD_SAI_FLG, checkKeishaAd(ck0011_a010_map, paramMap));
			
			// 内訳リスト
			ArrayList<HashMap<String, Object>> ucwkList = new ArrayList<HashMap<String, Object>> ();
			// 電話が存在する場合、
			if (svcKeiNoTel != null )
			{
				// 緊急通報除外リスト
				List<String> ignoreList = getIgnoreUcwkList(handle, param, fixedText, (String)paramMap.get(PARAM_SVC_KEI_KAISEN_UCWK_NO));
				
				// 住所からＭＡを取得
				condMap.clear();
				condMap.put( JKKAdInfChgConstCC.COND_KEY_AD_CD, (String)paramMap.get(KAISEN_PLACE_AD_CD) );
				reqMap = mapper.setEZM0091B010( param, fixedText, condMap );
				resMap = scCall.run( reqMap, handle );
				ArrayList<HashMap<String, Object>> zm0091_b010_list = mapper.getEZM0091B010( param, fixedText, resMap );
				mapper.scResultCheck( param );
				
				// 住所コードに一致する番号区画コードをリストに保持する
				ArrayList<String> maCheckList = new ArrayList<String>();
				for (HashMap<String, Object> zm0091_b010_map : zm0091_b010_list)
				{
					maCheckList.add((String)zm0091_b010_map.get(EZM0091B010CBSMsg1List.NO_KUKAKU_CD));
				}
				// 電話回線の一覧を取得
				condMap.clear();
				condMap.put( JKKAdInfChgConstCC.COND_KEY_SVC_KEI_NO, svcKeiNoTel );
				reqMap = mapper.setEKK0191B001( param, fixedText, condMap );
				resMap = scCall.run( reqMap, handle );
				ArrayList<HashMap<String, Object>> kk0191_b001_list = mapper.getEKK0191B001( param, fixedText, resMap );
				mapper.scResultCheck( param );
				
				// 電話番号毎に局番をチェックする
				for (HashMap<String, Object> kk0191_b001_map :  kk0191_b001_list)
				{
					String svcKeiUWStat = (String)kk0191_b001_map.get(EKK0191B001CBSMsg1List.SVC_KEI_UCWK_STAT);
					// 解約済、キャンセル済なら除外
					if (rejectStateList.contains(svcKeiUWStat))
					{
						continue;
					}
					
					// 電話番号毎にチェックする
					String tel = (String)kk0191_b001_map.get(EKK0191B001CBSMsg1List.TELNO);
					// もし住所変更先についている場合、対象外にしないとエラーとなる
					
					// 局番
					condMap.clear();
					condMap.put( JKKAdInfChgConstCC.COND_KEY_KYOKU_NO, tel.substring(0, 6) );
					reqMap = mapper.setEZM0301A010( param, fixedText, condMap );
					resMap = scCall.run( reqMap, handle );
					HashMap<String, Object> zm0301_a010_list = mapper.getEZM0301A010( param, fixedText, resMap );
					mapper.scResultCheck( param );
					// 区画番号が一致しない場合はエラー
					if (!maCheckList.contains(zm0301_a010_list.get(EZM0301A010CBSMsg1List.NO_KUKAKU_CD)))
					{
						return 5003;
					}
					if (!ignoreList.contains(kk0191_b001_map.get(EKK0191B001CBSMsg1List.SVC_KEI_UCWK_NO)))
					{
						// 内訳リストに追加する。
						ucwkList.add(kk0191_b001_map);
					}
				}
			}
			
			// 更新中の回線内訳番号が転居先回線内訳番号と一致の場合は更新しない
			// ・EKK2091B001 住所変更一覧照会(転居先回線指定）
			condMap.clear();
			condMap.put( EKK2091B001CBSMsg.KEY_ITENS_SVKEI_KISUW_NO, (String)paramMap.get( PARAM_SVC_KEI_KAISEN_UCWK_NO ) );
			reqMap = mapper.setEKK2091B001( param, fixedText, condMap );
			resMap = scCall.run( reqMap, handle );
			ArrayList<HashMap<String, Object>> kk2091_b001_list_Itns = mapper.getEKK2091B001( param, fixedText, resMap );
			mapper.scResultCheck( param );
			
			if ( kk2091_b001_list_Itns != null)
			{
				// 転居先回線で取得できる場合
				if (kk2091_b001_list_Itns!=null && kk2091_b001_list_Itns.size() > 0) {
					// 転居先回線のため判断を行う
					for( HashMap<String, Object> kk2091_b001_map : kk2091_b001_list_Itns ){
						String adchgStat = (String)kk2091_b001_map.get( EKK2091B001CBSMsg1List.ADCHG_STAT );
						if ("001".equals(adchgStat)) 
						{
							// 住所変更中の転居先回線は住所を変更できない
							return 5001;
						}
					}
				}
			}
			
			// 内訳リストをマップに格納
			paramMap.put(SVC_KEI_UCWK_LIST, ucwkList); 
			// 運用日を設定
			paramMap.put(JKKAdInfChgConstCC.PARAM_KEY_OPE_DATE,  JCCBPCommon.getOpeDate(null));
			// 異動区分
			paramMap.put(JKKAdInfChgConstCC.PARAM_KEY_IDO_DIV, JKKStrConst.CD00576_AD_IKT_UPD);
			// 手動入力フラグ
			paramMap.put(MAN_INPUT_FLG, JKKStrConst.CD01239_IS_NOT_MAN_INPUT);
			// 異動理由コード
			paramMap.put(JKKAdInfChgConstCC.PARAM_KEY_IDO_RSN_LIST,  new ArrayList<HashMap<String, Object>>());
			// 処理コード
			paramMap.put(JKKAdInfChgConstCC.PARAM_KEY_FUNC_CD, "1");
		}
		catch( Exception ex )
		{
			// CCExceptionにマッピングし、再スロー
			throw new CCException( JKKAdInfChgConstCC.ERR_STR_RESULT_CD, ex.getCause() );
		}
		return 0;
	}
	
	/**
	 * 住所マスタ一覧から住所を返却する
	 * <br>
	 * @param zm0081_b050_list
	 * @param pcd
	 * @return
	 */
	private HashMap<String, Object> getAdressMaster(ArrayList<HashMap<String, Object>> zm0081_b050_list, String targetPcd)
	{
		if (zm0081_b050_list == null || zm0081_b050_list.size() == 0)
		{
			return null;
		}
		for (HashMap<String, Object> zm0081_b050_map : zm0081_b050_list)
		{
			if (targetPcd.equals(zm0081_b050_map.get(EZM0081B050CBSMsg1List.PCD)))
			{
				return zm0081_b050_map;
			}
		}
		return null;
	}
	
	/**
	 * 主となるSYSIDを取得する
	 * <br>
	 * @param svc_kei_list
	 * @return
	 */
	private String getBaseSysid(ArrayList<HashMap<String, Object>> svc_kei_list)
	{
		String targetSysid = null;
		ArrayList<Object> sysidList = new  ArrayList<Object>();
		HashMap<Object, HashMap<Object, HashMap<String, Object>>> sysidMap = new HashMap<Object, HashMap<Object, HashMap<String, Object>>>();
		
		
		// SYSIDとSVC_CD毎に分類する
		for (HashMap<String, Object> kk0081_a010_map : svc_kei_list)
		{
			Object svcCd = kk0081_a010_map.get(EKK0081A010CBSMsg1List.SVC_CD);
			Object sysid = kk0081_a010_map.get(EKK0081A010CBSMsg1List.SYSID);
			if (!sysidList.contains(sysid))
			{
				sysidList.add(sysid);
				sysidMap.put(sysid, new HashMap<Object, HashMap<String, Object>>());
			}
			sysidMap.get(sysid).put(svcCd, kk0081_a010_map);
		}
		// SYSIDが複数に分かれている場合
		if (sysidList.size() > 1)
		{
			String netSysid = null;
			// 電話優先
			for (Object sysid : sysidList)
			{
				if (sysidMap.get(sysid).containsKey(JKKStrConst.CD00130_02))
				{
					targetSysid = (String)sysid;
					break;
				}
				else if (sysidMap.get(sysid).containsKey(JKKStrConst.CD00130_01))
				{
					// 次の候補はネットかつ受付済以外
					Object state = sysidMap.get(sysid).get(JKKStrConst.CD00130_01).get(EKK0081A010CBSMsg1List.SVC_KEI_STAT);
					// 受付済以外であれば
					if (!JKKSvcConst.SVC_KEI_STAT_010.equals(state))
					{
						netSysid = (String)sysid;
					}
				}
 			}
			if (targetSysid == null && netSysid != null)
			{
				targetSysid = netSysid;
			}
		}
		// 未設定の場合、リストの最初のSYSIDを設定する
		if (targetSysid == null)
		{
			targetSysid = (String)sysidList.get(0);
		}
		
		// 対象のSYSIDに対してネットと電話の両方を持っている場合
		if (sysidMap.get(targetSysid).containsKey(JKKStrConst.CD00130_01) &&
			sysidMap.get(targetSysid).containsKey(JKKStrConst.CD00130_02))
		{
			// 工事案件への反映をスキップする
			sysidMap.get(targetSysid).get(JKKStrConst.CD00130_02).put(KOJIAK_SKIP_FLG, "1");
		}
		return targetSysid;
	}
	/**
	 * 住所に変更があったかどうかを返す。
	 * <br>
	 * @param kk0251_a010_map 利用場所住所一意照会結果マップ
	 * @param updateMap 住所更新情報マップ
	 * @return true:変更あり false:変更なし
	 */
	private boolean isChanged(HashMap<String, Object> kk0251_a010_map, HashMap<String, Object> updateMap)
	{
		if (
				!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_PCD), updateMap.get( PARAM_AD_PCD )) 
			||	!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_CITY_NM), updateMap.get( PARAM_AD_CITY_NM )) 
			||	!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_OAZTSU_NM), updateMap.get( PARAM_AD_OAZTSU_NM )) 
			||	!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_AZCHO_NM), updateMap.get( PARAM_AD_AZCHO_NM )) 
			||	!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_BNCHIGO), updateMap.get( PARAM_AD_BNCHIGO )) 
			||	!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_ADRTTM), updateMap.get( PARAM_AD_ADRTTM )) 
			||	!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_ADRRM), updateMap.get( PARAM_AD_ADRRM )) 
			)
		{
			return true;
		}
		
		return false;
	}
	
	/**
	 * 契約者住所との比較する
	 * <br>
	 * @param ck0011_a010_map 契約者情報一意照会結果マップ
	 * @param updateMap 住所更新情報マップ
	 * @return 0:差異なし 1:差異あり
	 */
	private String checkKeishaAd(HashMap<String, Object> ck0011_a010_map, HashMap<String, Object> updateMap)
	{
		if (
				!isSameObj(ck0011_a010_map.get(ECK0011A010CBSMsg1List.KEISHA_AD_CD), updateMap.get( KAISEN_PLACE_AD_CD ))
			||	!isSameObj(ck0011_a010_map.get(ECK0011A010CBSMsg1List.KEISHA_PCD), updateMap.get( PARAM_AD_PCD ))
			||	!isSameObj(ck0011_a010_map.get(ECK0011A010CBSMsg1List.KEISHA_STATE_NM), updateMap.get( PARAM_AD_STATE_NM ))
			||	!isSameObj(ck0011_a010_map.get(ECK0011A010CBSMsg1List.KEISHA_CITY_NM), updateMap.get( PARAM_AD_CITY_NM ))
			||	!isSameObj(ck0011_a010_map.get(ECK0011A010CBSMsg1List.KEISHA_OAZTSU_NM), updateMap.get( PARAM_AD_OAZTSU_NM ))
			||	!isSameObj(ck0011_a010_map.get(ECK0011A010CBSMsg1List.KEISHA_AZCHO_NM), updateMap.get( PARAM_AD_AZCHO_NM ))
			||	!isSameObj(ck0011_a010_map.get(ECK0011A010CBSMsg1List.KEISHA_BNCHIGO), updateMap.get( PARAM_AD_BNCHIGO ))
			||	!isSameObj(ck0011_a010_map.get(ECK0011A010CBSMsg1List.KEISHA_ADRTTM), updateMap.get( PARAM_AD_ADRTTM ))
			||	!isSameObj(ck0011_a010_map.get(ECK0011A010CBSMsg1List.KEISHA_ADRRM), updateMap.get( PARAM_AD_ADRRM ))
			)
		{
			return "1"; // 差異有り
		}
		return "0"; // 差異無し
	}
	
	/**
	 * 申込内容承認登録
	 * <br>
	 * @param param
	 * @param fixedText
	 * @throws CCException
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private void addMskm(SessionHandle handle,IRequestParameterReadWrite param, String fixedText) throws CCException, RequestParameterException 
	{
		
		/** 事前準備 */
		HashMap<String, Object> paramMap = (HashMap<String, Object>)param.getData(fixedText);
		HashMap<String, Object> reqMap;
		Map<?, ?> resMap;

		// 全てのサービスが照査前の場合、申込明細は作成しない。
		if (beforeShosa(paramMap))
		{
			return ; 
		}
		try{

			// 住所情報変更コモンコンポーネントマッピングクラスインスタンスを取得
			JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();

			// SCリクエストInvokerを取得
			ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
			HashMap<String, Object> condMap = new HashMap<String, Object>();
			condMap.clear();
			
			// SYSID
			condMap.put(EKK0011D020CBSMsg.SYSID, (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_SYSID) );
			// 申込種別コード
			condMap.put(EKK0011D020CBSMsg.MSKM_SBT_CD, "90021" );
			// 申込書到着年月日
			condMap.put(EKK0011D020CBSMsg.MSKMSHO_ARIV_YMD, (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_OPE_DATE ) );
			// 申込受付年月日時分秒
			condMap.put(EKK0011D020CBSMsg.MSKM_UK_DTM, JCCBPCommon.getOpeDateTimeStamp(null) );
			// 申込受付担当ユーザーID 
			condMap.put(EKK0011D020CBSMsg.MSKM_UK_TNT_USER_ID, (String)paramMap.get("user_id") );
			// 申込年月日
			condMap.put(EKK0011D020CBSMsg.MSKM_YMD, (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_OPE_DATE ) );
			// 総合営業センター受付番号
			condMap.put(EKK0011D020CBSMsg.TTL_BUSINESS_CENTER_UK_NO, "" );
			// 総合営業申込契機コード
			condMap.put(EKK0011D020CBSMsg.TTL_BUSINESS_MSKM_OPT_CD, "" );
			// 申込連絡先電話番号
			condMap.put(EKK0011D020CBSMsg.MSKM_RRKS_TELNO, "" );
			// 申込実施者種別コード
			condMap.put(EKK0011D020CBSMsg.MSKM_JSSIS_SBT_CD, "" );
			// お客様ご要望事項
			condMap.put(EKK0011D020CBSMsg.CUST_YOBO_JIKO, "" );
			// 電話連絡希望日種別コード
			condMap.put(EKK0011D020CBSMsg.TEL_RRK_KIBOD_SBT_CD, "" );
			// 電話連絡希望時間帯コード
			condMap.put(EKK0011D020CBSMsg.TEL_RRK_KIBO_TIME_CD, "" );
			// 宅内調査希望日種別コード
			condMap.put(EKK0011D020CBSMsg.TAKCHO_KIBOD_SBT_CD, "" );
			// 宅内調査希望時間帯コード
			condMap.put(EKK0011D020CBSMsg.TAKCHO_KIBO_TIME_CD, "" );
			// 仮申込フラグ
			condMap.put(EKK0011D020CBSMsg.KARI_MSKM_FLG, "" );
			// リファラー
			condMap.put(EKK0011D020CBSMsg.REFERER, "" );
			// 関西電力お客様情報授受同意有無
			condMap.put(EKK0011D020CBSMsg.KEPCO_CUSTINFO_JUJU_DOI_UM, "1" );
			// 照査前連絡事項要否
			condMap.put(EKK0011D020CBSMsg.SHOSA_BF_RRK_JIKO_YH, "" );
			// 照査前連絡事項
			condMap.put(EKK0011D020CBSMsg.SHOSA_BF_RRK_JIKO, "" );
			// 利用サービス継続種別コード
			condMap.put(EKK0011D020CBSMsg.USE_SVC_KEIZK_SBT_CD, "" );
			// コンシューマ営業用申込状態識別コード
			condMap.put(EKK0011D020CBSMsg.CONSMBSN_MSKM_STAT_SKBT_CD, "03" );
			// 受付担当者識別コード
			condMap.put(EKK0011D020CBSMsg.UK_TNTSHA_SKBT_CD, "" );
			// 工事依頼情報連絡事項
			condMap.put(EKK0011D020CBSMsg.KOJI_REQ_INFO_RRK_JIKO, "" );
			// 申込経路識別コード
			condMap.put(EKK0011D020CBSMsg.MSKM_ROUTE_SKBT_CD, "1" );
			// 代理店申込取次有無
			condMap.put(EKK0011D020CBSMsg.AGNT_MSKM_TRTG_UM, "0" );
			// 異動区分
			condMap.put(EKK0011D020CBSMsg.IDO_DIV, (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_IDO_DIV  ) );
			
			ArrayList<HashMap<String,Object>> mskmDtlList = new ArrayList<HashMap<String,Object>>();
			HashMap<String, Object> mskmDtlMap = new HashMap<String, Object>();
			mskmDtlList.add(mskmDtlMap);
			
			// 申込書番号
			mskmDtlMap.put(EKK0011D020CBSMsg1List.MSKMSHO_NO, "" );
			// WEB受付番号
			mskmDtlMap.put(EKK0011D020CBSMsg1List.WEB_UK_NO, "" );
			// 申込形態コード
			mskmDtlMap.put(EKK0011D020CBSMsg1List.MSKM_FORM_CD, "" );
			// 申込明細種別コード
			mskmDtlMap.put(EKK0011D020CBSMsg1List.MSKM_DTL_SBT_CD, "" );
			// 連絡先携帯電話番号
			mskmDtlMap.put(EKK0011D020CBSMsg1List.RRKS_KTAI_TELNO, "" );
			// 連絡先勤務先名
			mskmDtlMap.put(EKK0011D020CBSMsg1List.RRKS_OFFC_NM, "" );
			// 昼間連絡先電話番号
			mskmDtlMap.put(EKK0011D020CBSMsg1List.DT_RRKS_TELNO, "" );
			// 新規申込種別コード
			mskmDtlMap.put(EKK0011D020CBSMsg1List.NEW_MSKM_SBT_CD, "" );
			// 申込契機コード
			mskmDtlMap.put(EKK0011D020CBSMsg1List.MSKM_OPTNTY_CD, "" );
			// 宅内調査希望アポ期限年月日
			mskmDtlMap.put(EKK0011D020CBSMsg1List.TAKCHO_KIBO_APO_KIGEN_YMD, "" );
			// 工事アポ連絡先指定コード
			mskmDtlMap.put(EKK0011D020CBSMsg1List.KOJI_APO_RRKS_SHITEI_CD, "" );
			// 工事アポ連絡先電話番号
			mskmDtlMap.put(EKK0011D020CBSMsg1List.KOJI_APO_RRKS_TELNO, "" );
			// 連絡事項登録年月日時分秒
			mskmDtlMap.put(EKK0011D020CBSMsg1List.RRK_JIKO_ADD_DTM, "" );
			// 申込連絡先メールアドレス
			mskmDtlMap.put(EKK0011D020CBSMsg1List.MSKM_RRKS_MLAD, "" );
			// 工事進捗通知メールアドレス
			mskmDtlMap.put(EKK0011D020CBSMsg1List.KOJI_PRG_TCHI_MLAD, "" );
			// 連絡事項
			mskmDtlMap.put(EKK0011D020CBSMsg1List.RRK_JIKO, "" );
			// 工事進捗通知携帯メールアドレス
			mskmDtlMap.put(EKK0011D020CBSMsg1List.KJSC_TCH_KTAI_MLAD, "" );
			// メール送信除外フラグ
			mskmDtlMap.put(EKK0011D020CBSMsg1List.ML_SEND_JGI_FLG, "0" );
			// メール送信除外理由メモ
			mskmDtlMap.put(EKK0011D020CBSMsg1List.ML_SEND_JGI_RSN_MEMO, "" );
			// 番ポ申込連絡先電話番号
			mskmDtlMap.put(EKK0011D020CBSMsg1List.BMP_MSKM_RRKS_TLN, "" );
			// オプションサービス引継有無
			mskmDtlMap.put(EKK0011D020CBSMsg1List.OP_SVC_HKTGI_UM, "0" );
			// 解約書類送付希望有無
			mskmDtlMap.put(EKK0011D020CBSMsg1List.DSL_ATICLE_SOHU_KIBO_UM, "" );
			// 連絡手段補記
			mskmDtlMap.put(EKK0011D020CBSMsg1List.RRK_WAY_HOKI, "" );
			// 新築物件コード
			mskmDtlMap.put(EKK0011D020CBSMsg1List.NEWCONST_BUKKEN_CD, "0" );
			// 復活案件フラグ
			mskmDtlMap.put(EKK0011D020CBSMsg1List.HUKKAT_ANKEN_FLG, "0" );
			// 同一設備再申込コード
			mskmDtlMap.put(EKK0011D020CBSMsg1List.SAME_EQUIP_RE_MSKM_CD, "0" );
			// 本人確認書類種別コード
			mskmDtlMap.put(EKK0011D020CBSMsg1List.HNIN_CFM_ATICLE_SBT_CD, "" );
			// 申込書種別コード
			mskmDtlMap.put(EKK0011D020CBSMsg1List.MSKMSHO_SBT_CD, "" );
			// 契約付加コード
			mskmDtlMap.put(EKK0011D020CBSMsg1List.KEI_HUKA_CD, "" );
			// 地図添付有無
			mskmDtlMap.put(EKK0011D020CBSMsg1List.MAP_TEMP_UM, "" );
			// KCNSTB申込台数
			mskmDtlMap.put(EKK0011D020CBSMsg1List.KCN_STB_MSKM_CNT, "0" );
			// KCNSTB種類コード
			mskmDtlMap.put(EKK0011D020CBSMsg1List.KCN_STB_KIND_CD, "" );
			// マンション設備システム連携用記事欄
			mskmDtlMap.put(EKK0011D020CBSMsg1List.MANSSBSYS_RNKI_YO_KIJIRAN, "" );
			// マンションID
			mskmDtlMap.put(EKK0011D020CBSMsg1List.MANSION_ID, "" );
			// CAT-ID
			mskmDtlMap.put(EKK0011D020CBSMsg1List.CATID, "" );
			// 申込受付種別コード
			mskmDtlMap.put(EKK0011D020CBSMsg1List.MKM_UK_SBT_CD, "" );
			// 申込書取扱情報担当者名
			mskmDtlMap.put(EKK0011D020CBSMsg1List.MSKMSHO_TRAT_IF_TNTSHA_NM, "" );
			// 申込書取扱情報電話番号
			mskmDtlMap.put(EKK0011D020CBSMsg1List.MSKMSHO_TRAT_IF_TELNO, "" );
			// 申込書明細番号
			mskmDtlMap.put(EKK0011D020CBSMsg1List.MSKMSHO_DTL_NO, "" );
			// 本人確認書類名
			mskmDtlMap.put(EKK0011D020CBSMsg1List.HNIN_CFM_ATICLE_NM, "" );
			// 割引自動適用対象外フラグ
			mskmDtlMap.put(EKK0011D020CBSMsg1List.WRIB_AUTO_APLY_TG_GAI_FLG, "0" );
			
			/** 申込内容承認登録 */
			// ・EKK0011D020  申込内容承認登録
			reqMap = mapper.setEKK0011D020( param, fixedText, condMap, mskmDtlList );
			resMap = scCall.run( reqMap, handle );
			HashMap<String, Object> kk0011_d020_map = mapper.getEKK0011D020( param, fixedText, resMap );
			mapper.scResultCheck( param );
			
			// 申込番号の保持
			paramMap.put(JKKAdInfChgConstCC.PARAM_KEY_MSKM_NO, kk0011_d020_map.get(EKK0011D020CBSMsg.MSKM_NO) );
			List<HashMap<String,Object>> mskmDtlListRet = (List<HashMap<String, Object>>) kk0011_d020_map.get(EKK0011D020CBSMsg.EKK0011D020CBSMSG1LIST);
			if(mskmDtlListRet != null && !mskmDtlListRet.isEmpty()){
				HashMap<String,Object> mskmDtlMapRet = mskmDtlListRet.get(0);
				// 申込明細番号の保持
				paramMap.put(JKKAdInfChgConstCC.PARAM_KEY_MSKM_DTL_NO, mskmDtlMapRet.get(EKK0011D020CBSMsg1List.MSKM_DTL_NO) );
			}
		} 
		catch( Exception ex )
		{
			// CCExceptionにマッピングし、再スロー
			throw new CCException( JKKAdInfChgConstCC.ERR_STR_RESULT_CD, ex.getCause() );
		}
	}

	/**
	 * 利用場所住所変更処理.
	 * <br>
	 * @param   handle 
	 * @param   param        モデルグループ、コントロールマップを含むリクエストパラメータ
	 * @param   fixedText    ユーザ任意文字列
	 */
	@SuppressWarnings("unchecked")
	private void updateUsePlaceAd(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable 
	{

		/** 事前準備 */
		HashMap<String, String> condMap = new HashMap<String, String>();
		HashMap<String, Object> paramMap = (HashMap<String, Object>)param.getData(fixedText);
		HashMap<String, Object> reqMap;
		Map<?, ?> resMap;

		try {

			// 住所情報変更コモンコンポーネントマッピングクラスインスタンスを取得
			JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();

			// SCリクエストInvokerを取得
			ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
			
			// ---------------------------------------------------------------------------------
			// 利用場所住所変更
			// ---------------------------------------------------------------------------------
			// ・EKK0251A010  サービス契約回線内訳一意照会
			HashMap<String, Object> kk0251_a010_map = (HashMap<String, Object>)paramMap.get(SVC_KEI_KAISEN_UW_MAP);

//					// 請求先部屋番号が必要な契約では必ず設定する必要があるが、ＡＰＩからは指定されない。
//					// その為、この条件でのエラーはとりあえずチェックしない
//					String getKaisenCd = (String)kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_CD);
//					String sks_adrrm = (String)cur_setplace.get(JKKAdInfChgConstCC.PARAM_KEY_SETPLACE_SKS_ADRRM);
//					// 回線コードが1002:光回線(マンションVDSL)、1003:光回線(マンションイーサネット)、
//					// 1004:光回線(マンション光配線)、1005:光配線(マンションタイプDOCSIS)かつ請求先部屋番号が入力されていない場合
//						if (("1002".equals(getKaisenCd) || "1003".equals(getKaisenCd) 
//							|| "1004".equals(getKaisenCd) || "1005".equals(getKaisenCd)) && sks_adrrm.length() == 0)
//					{
//						// マンションタイプに請求先部屋番号が設定されていないからエラー
//						return 5001;
//					}
			
			// 進捗特記事項を更新内容から作成する。
			HashMap<String, Object> prgMap = createPrgTokkiMapKaisen(kk0251_a010_map, paramMap);
			
			// ----------------------------------------------
			// 一意照会結果に更新内容を反映する
			// ----------------------------------------------
			// 契約者住所差異フラグ
			kk0251_a010_map.put( EKK0251A010CBSMsg1List.KAISEN_PLC_KSH_AD_SAI_FLG, paramMap.get(KAISEN_PLC_KSH_AD_SAI_FLG) );
			// 住所コード
			kk0251_a010_map.put( EKK0251A010CBSMsg1List.KAISEN_PLACE_AD_CD, paramMap.get( KAISEN_PLACE_AD_CD ) );
			// 郵便番号
			kk0251_a010_map.put( EKK0251A010CBSMsg1List.KAISEN_PLACE_PCD, paramMap.get( PARAM_AD_PCD ) );	
			// 住所
			kk0251_a010_map.put( EKK0251A010CBSMsg1List.KAISEN_PLACE_STATE_NM, paramMap.get( PARAM_AD_STATE_NM ) );
			kk0251_a010_map.put( EKK0251A010CBSMsg1List.KAISEN_PLACE_CITY_NM, paramMap.get( PARAM_AD_CITY_NM ) );
			kk0251_a010_map.put( EKK0251A010CBSMsg1List.KAISEN_PLACE_OAZTSU_NM, paramMap.get( PARAM_AD_OAZTSU_NM ) );
			kk0251_a010_map.put( EKK0251A010CBSMsg1List.KAISEN_PLACE_AZCHO_NM, paramMap.get( PARAM_AD_AZCHO_NM ) );
			kk0251_a010_map.put( EKK0251A010CBSMsg1List.KAISEN_PLACE_BNCHIGO, paramMap.get( PARAM_AD_BNCHIGO ) );
			kk0251_a010_map.put( EKK0251A010CBSMsg1List.KAISEN_PLACE_ADRTTM, paramMap.get( PARAM_AD_ADRTTM ) );
			kk0251_a010_map.put( EKK0251A010CBSMsg1List.KAISEN_PLACE_ADRRM, paramMap.get( PARAM_AD_ADRRM ) );

			// 住所未確定
			kk0251_a010_map.put( EKK0251A010CBSMsg1List.KISN_PLC_AD_MI_FIX_FLG, (String)paramMap.get(KISN_PLC_AD_MI_FIX_FLG));

			// 申込明細番号の更新
			if(!StringUtils.isEmpty((String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_MSKM_DTL_NO ))){
				kk0251_a010_map.put( EKK0251A010CBSMsg1List.MSKM_DTL_NO , (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_MSKM_DTL_NO ) );
			}
			// 更新年月日時分秒の退避
			kk0251_a010_map.put( JKKAdInfChgConstCC.UPD_DT_KEI_KAIS_UCWK_UPD_DTM_BEF, (String)kk0251_a010_map.get( EKK0251A010CBSMsg1List.LAST_UPD_DTM ) );

			// 場所番号が設定されている場合、新たな場所番号を取得
			if (!beforeShosa(paramMap))
			{
				// 利用場所住所_手動入力フラグ  → 設置場所住所手動入力フラグ（宅内機器管理システムへの連携用）
				kk0251_a010_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_AD_MAN_INPUT_FLG, paramMap.get(MAN_INPUT_FLG) );
				String setPlaceNo = executeEKKA0020002_Kaisen(handle, param, fixedText, kk0251_a010_map);
				if(!StringUtils.isEmpty(setPlaceNo))
				{
					kk0251_a010_map.put( EKK0251A010CBSMsg1List.KAISEN_PLACE_NO, setPlaceNo);
					// 共通設定
					paramMap.put( JKKAdInfChgConstCC.PARAM_KEY_ITENS_PLACE_NO, setPlaceNo );
				}
			}

			// ・EKK0251C030  サービス契約回線内訳内容変更
			reqMap = mapper.setEKK0251C030( param, fixedText, kk0251_a010_map );
			resMap = scCall.run( reqMap, handle );
			HashMap<String, Object> kk0251_c030_map = mapper.getEKK0251C030( param, fixedText, resMap );
			mapper.scResultCheck( param );
			
			// 戻り値を取得
			String ad_rm_no_res = (String)paramMap.get( EKK0251C030CBSMsg.SKS_YO_KISN_PLACE_AD_RM_NO_ERR );
			paramMap.put(JKKAdInfChgConstCC.PARAM_KEY_AD_RM_NO_RES, ad_rm_no_res);
			
			// 戻り値を取得
			String ad_chk_lv_res = (String)paramMap.get( EKK0251C030CBSMsg.KISN_AD_CHK_LV_ERR );
			if(!StringUtils.isEmpty(ad_chk_lv_res))
			{
				paramMap.put("ad_chk_lv_res", ad_chk_lv_res);
			}
			
			// ---------------------------------------------------------------------------------
			// 緊急通報先住所変更
			// ---------------------------------------------------------------------------------
			updateEmgContactAd(handle, param, fixedText, scCall, paramMap);
			
			// ---------------------------------------------------------------------------------
			// 回線機器の利用場所住所変更
			// ---------------------------------------------------------------------------------
			updateKikiUsedAd(handle, param, fixedText, scCall, paramMap);
			
			// ---------------------------------------------------------------------------------
			// 最後に進捗を登録
			// ---------------------------------------------------------------------------------
			/** 進捗登録(利用場所住所変更) */

			ArrayList<HashMap<String, Object>> svc_kei_list = (ArrayList<HashMap<String, Object>>)paramMap.get(SVC_KEI_LIST);
			
			for (HashMap<String, Object> kk0081_a010_map : svc_kei_list)
			{
				// サービス契約ステータスの取得
				String svcKeiStat = getMapString( kk0081_a010_map, EKK0081A010CBSMsg1List.SVC_KEI_STAT );
				
				// 異動区分の取得を行う
				String idoDiv = getMapString( kk0081_a010_map, EKK0081A010CBSMsg1List.IDO_DIV );
				String idoDtm = new String();
				
				if (JKKSvcConst.SVC_KEI_STAT_010.equals(svcKeiStat)) 
				{
					// 進捗の一覧照会
					condMap.clear();
					condMap.put( "key_svc_kei_no", (String)kk0081_a010_map.get(EKK0081A010CBSMsg1List.SVC_KEI_NO) );
					reqMap = mapper.setEKK1091B001( param, fixedText, condMap );
					resMap = scCall.run( reqMap, handle );
					HashMap<String, Object> kk1091_a010_map = mapper.getEKK1091B001( param, fixedText, resMap );
					mapper.scResultCheck( param );
					
					idoDtm = getMapString( kk1091_a010_map, EKK1091B001CBSMsg1List.IDO_DTM );
				}
				
				// 投入データ設定[単項目]
				HashMap<String, Object> parent_map = new HashMap<String, Object>();
				parent_map.put( EKK1091D010CBSMsg.SVC_KEI_NO, (String)kk0081_a010_map.get(EKK0081A010CBSMsg1List.SVC_KEI_NO) );
				parent_map.put( EKK1091D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO, (String)paramMap.get( PARAM_SVC_KEI_KAISEN_UCWK_NO ) );
		
				// カレントのサービス契約ステータスが受付済の場合、サービス契約の最新異動区分および異動時分秒をINパラメータに設定
				if (JKKSvcConst.SVC_KEI_STAT_010.equals(svcKeiStat) ) 
				{
					parent_map.put( EKK1091D010CBSMsg.IDO_DIV, idoDiv );
					parent_map.put( EKK1091D010CBSMsg.IDO_DTM, idoDtm);
				}
				// 上記条件以外の場合は異動区分「00048:住所一括更新」を設定
				else
				{
					parent_map.put( EKK1091D010CBSMsg.IDO_DIV, (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_IDO_DIV ) );
					parent_map.put( EKK1091D010CBSMsg.IDO_DTM, JCCBPCommon.getSysDateTimeStamp() );
				}
				parent_map.put( EKK1091D010CBSMsg.PRG_STAT, JKKAdInfChgConstCC.CD00647_E020 );
				parent_map.put( EKK1091D010CBSMsg.PRG_TKJK_1, prgMap.get(EKK1091D010CBSMsg.PRG_TKJK_1) );
				parent_map.put( EKK1091D010CBSMsg.PRG_TKJK_2, prgMap.get(EKK1091D010CBSMsg.PRG_TKJK_2) );
				if(!StringUtils.isEmpty((String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_MSKM_DTL_NO )))
				{
					parent_map.put( EKK1091D010CBSMsg.MSKM_DTL_NO , (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_MSKM_DTL_NO ) );
				}
		
				// ・EKK1091D010  進捗登録
				reqMap = mapper.setEKK1091D010( param, fixedText, parent_map, getIdoRsnList( param, fixedText ) );
				resMap = scCall.run( reqMap, handle );
				mapper.getEKK1091D010( param, fixedText, resMap );
				mapper.scResultCheck( param );
			}
		} 
		catch( Exception ex )
		{
			// CCExceptionにマッピングし、再スロー
			throw new CCException( JKKAdInfChgConstCC.ERR_STR_RESULT_CD, ex.getCause() );
		}
	}
	
	/**
	 * 照査前かどうかを返す
	 * @param paramMap パラメータマップ
	 * @return true: 照査前 false:照査後
	 */
	private boolean beforeShosa(HashMap<String, Object> paramMap)
	{
		
		ArrayList<HashMap<String, Object>> svc_kei_list = (ArrayList<HashMap<String, Object>>)paramMap.get(SVC_KEI_LIST);
		for (HashMap<String, Object> kk0081_a010_map : svc_kei_list)
		{
			if (!JKKSvcConst.SVC_KEI_STAT_010.equals(kk0081_a010_map.get(EKK0081A010CBSMsg1List.SVC_KEI_STAT)))
			{
				return false;
			}
		}
		return true;
	}
	
	/**
	 * サービス契約のレコードを取得する
	 * <br>
	 * @param paramMap パラメータマップ
	 * @param svcCd サービスコード
	 * @return 対象のサービス契約のレコード
	 */
	private HashMap<String, Object> getSvcKei(HashMap<String, Object> paramMap, String svcCd)
	{
		ArrayList<HashMap<String, Object>> svc_kei_list = (ArrayList<HashMap<String, Object>>)paramMap.get(SVC_KEI_LIST);
		for (HashMap<String, Object> kk0081_a010_map : svc_kei_list)
		{
			if (svcCd.equals(kk0081_a010_map.get(EKK0081A010CBSMsg1List.SVC_CD)))
			{
				return kk0081_a010_map;
			}
		}
		return null;
	}
	
	/**
	 * 緊急通報先住所更新
	 * <br>
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param scCall
	 * @param paramMap
	 * @return
	 * @throws Throwable
	 */
	private void updateEmgContactAd(
			SessionHandle handle
			, IRequestParameterReadWrite param
			, String fixedText
			, ServiceComponentRequestInvoker scCall
			, HashMap<String, Object> paramMap
			) throws Throwable 
	{
		HashMap<String, String> condMap = new HashMap<String, String>();
		HashMap<String, Object> reqMap;
		Map<?, ?> resMap;
		
		JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();

		ArrayList<HashMap<String, Object>> svc_kei_list = (ArrayList<HashMap<String, Object>>)paramMap.get(SVC_KEI_LIST);
		
		// 電話契約を取得する
		HashMap<String, Object> kk0081_a010_map = getSvcKei(paramMap, JKKStrConst.CD00130_02);
		if (kk0081_a010_map == null)
		{
			// 電話を持っていないので処理をスキップ
			return;
		}
		// サービス契約内訳リスト
		ArrayList<HashMap<String, Object>> kk0191_b001_list = (ArrayList<HashMap<String, Object>>)paramMap.get(SVC_KEI_UCWK_LIST);
		
		/** 緊急通報先住所変更ループ */
		for (HashMap<String, Object> kk0191_b001_map :  kk0191_b001_list)
		{
			
			/** 緊急通報先住所変更 */
			// ・EKK0161A010  サービス契約内訳一意照会
			condMap.clear();
			condMap.put( JKKAdInfChgConstCC.COND_KEY_SVC_KEI_UCWK_NO, (String)kk0191_b001_map.get( EKK0191B001CBSMsg1List.SVC_KEI_UCWK_NO ) );
			condMap.put( JKKAdInfChgConstCC.COND_KEY_OPEDATE, (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_OPE_DATE ) );
			reqMap = mapper.setEKK0161A010( param, fixedText, condMap );
			resMap = scCall.run( reqMap, handle );
			HashMap<String, Object> kk0161_a010_map = mapper.getEKK0161A010( param, fixedText, resMap );
			mapper.scResultCheck( param );

			// ・EKK0191A010  サービス契約内訳＜eo光電話＞一意照会
			condMap.clear();
			condMap.put( JKKAdInfChgConstCC.COND_KEY_SVC_KEI_UCWK_NO, (String)kk0191_b001_map.get( EKK0191B001CBSMsg1List.SVC_KEI_UCWK_NO ) );
			condMap.put( JKKAdInfChgConstCC.COND_KEY_OPEDATE, (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_OPE_DATE ) );
			reqMap = mapper.setEKK0191A010( param, fixedText, condMap );
			resMap = scCall.run( reqMap, handle );
			HashMap<String, Object> kk0191_a010_map = mapper.getEKK0191A010( param, fixedText, resMap );
			mapper.scResultCheck( param );
			
			// SOD発行に使用するため、更新前の世代登録年月日時分秒を保持
			String chbfSvcKeiUcwkGeneAddDtm = (String)kk0191_a010_map.get(EKK0191A010CBSMsg1List.GENE_ADD_DTM);

			// 一意照会で取得した内容に対して、更新対象項目を差替
			// ・サービス契約内訳
			kk0161_a010_map.put( EKK0161A010CBSMsg1List.RSV_APLY_YMD, (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_OPE_DATE ) );

			//サービス契約内訳ステータスが受付済の場合、申込明細番号・異動区分は変更しない。
			String svc_kei_ucwk_stat = (String)kk0161_a010_map.get(EKK0161A010CBSMsg1List.SVC_KEI_UCWK_STAT);
			if(!JKKSvcConst.SVC_KEI_STAT_010.equals(svc_kei_ucwk_stat))
			{
				if(!StringUtils.isEmpty((String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_MSKM_DTL_NO )))
				{
					kk0161_a010_map.put( EKK0161A010CBSMsg1List.MSKM_DTL_NO , (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_MSKM_DTL_NO ) );
				}
				// 異動区分
				kk0161_a010_map.put( EKK0161A010CBSMsg1List.IDO_DIV, (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_IDO_DIV ) );
			}
			kk0161_a010_map.put( JKKAdInfChgConstCC.UPD_DT_SVC_KEI_UCWK_UPD_DTM_BEF, (String)kk0161_a010_map.get( EKK0161A010CBSMsg1List.LAST_UPD_DTM ) );

			// 最初に緊急通報用の進捗マップを作成する。
			HashMap<String, Object> emgAdPrgMap = createPrgTokkiMapEmgAd(kk0191_a010_map, paramMap);
			
			// ・サービス契約内訳＜eo光電話＞
			// 緊急通報用住所コード
			kk0191_a010_map.put( EKK0191A010CBSMsg1List.EMG_AD_CD, (String)paramMap.get( KAISEN_PLACE_AD_CD ) );
			// 緊急通報用補正郵便番号
			kk0191_a010_map.put( EKK0191A010CBSMsg1List.EMG_HOSEI_PCD, (String)paramMap.get( PARAM_AD_PCD ) );
			// 緊急通報用都道府県名
			kk0191_a010_map.put( EKK0191A010CBSMsg1List.EMG_STATE_NM, (String)paramMap.get( PARAM_AD_STATE_NM ) );
			// 緊急通報用市区町村名
			kk0191_a010_map.put( EKK0191A010CBSMsg1List.EMG_CITY_NM, (String)paramMap.get( PARAM_AD_CITY_NM ) );
			// 緊急通報用大字通称名
			kk0191_a010_map.put( EKK0191A010CBSMsg1List.EMG_OAZTSU_NM, (String)paramMap.get( PARAM_AD_OAZTSU_NM ) );
			// 緊急通報用字丁目名
			kk0191_a010_map.put( EKK0191A010CBSMsg1List.EMG_AZCHO_NM, (String)paramMap.get( PARAM_AD_AZCHO_NM ) );
			// 緊急通報用番地号
			kk0191_a010_map.put( EKK0191A010CBSMsg1List.EMG_BNCHIGO, (String)paramMap.get( PARAM_AD_BNCHIGO ) );
			// 緊急通報用住所補記・建物名
			kk0191_a010_map.put( EKK0191A010CBSMsg1List.EMG_ADRTTM, (String)paramMap.get( PARAM_AD_ADRTTM ) );
			// 緊急通報用住所補記・部屋番号
			kk0191_a010_map.put( EKK0191A010CBSMsg1List.EMG_ADRRM, (String)paramMap.get( PARAM_AD_ADRRM ) );
			// 緊急通報用住所チェックレベル
			kk0191_a010_map.put( EKK0191C060CBSMsg.EMG_AD_CHK_LV, "1" );

			// ・EKK0191C060  サービス契約内訳＜eo光電話＞情報変更
			reqMap = mapper.setEKK0191C060( param, fixedText, kk0161_a010_map, kk0191_a010_map );
			resMap = scCall.run( reqMap, handle );
			HashMap<String, Object> kk0191_c060_map = mapper.getEKK0191C060( param, fixedText, resMap );
			mapper.scResultCheck( param );

			// 更新後の更新年月日時分秒をparamへ設定
			kk0191_b001_map.put( JKKAdInfChgConstCC.PARAM_KEY_EMG_UPD_DTM_AF, (String)kk0191_c060_map.get( EKK0191C060CBSMsg.UPD_DTM ) );
			// 戻り値を取得
			String ad_chk_lv_res = (String)paramMap.get( EKK0191C060CBSMsg.EMG_AD_CHK_LV_ERR );
			if(!StringUtils.isEmpty(ad_chk_lv_res)){
				paramMap.put("ad_chk_lv_res", ad_chk_lv_res);
			}
			// SOD発行に使用するため、更新後の世代登録年月日時分秒を保持
			String chafSvcKeiUcwkGeneAddDtm = (String)kk0191_c060_map.get(EKK0191C060CBSMsg.KK0161_GENE_ADD_DTM);
			
			// サービス契約ステータスの取得
			String svcKeiStat = getMapString( kk0081_a010_map, EKK0081A010CBSMsg1List.SVC_KEI_STAT );
			
			// 異動区分の取得を行う
			String idoDiv = getMapString( kk0081_a010_map, EKK0081A010CBSMsg1List.IDO_DIV );
			
			String idoDtm = new String();
			
			if (JKKSvcConst.SVC_KEI_STAT_010.equals(svcKeiStat)) {
				// 進捗の一覧照会
				condMap.clear();
				condMap.put("key_svc_kei_no", (String)kk0081_a010_map.get(EKK0081A010CBSMsg1List.SVC_KEI_NO));
				reqMap = mapper.setEKK1091B001( param, fixedText, condMap );
				resMap = scCall.run( reqMap, handle );
				HashMap<String, Object> kk1091_a010_map = mapper.getEKK1091B001( param, fixedText, resMap );
				mapper.scResultCheck( param );
				
				idoDtm = getMapString( kk1091_a010_map, EKK1091B001CBSMsg1List.IDO_DTM );
			}

			/** 進捗登録(緊急通報住所変更) */
			// 投入データ設定[単項目]
			emgAdPrgMap.put( EKK1091D010CBSMsg.SVC_KEI_NO, (String)kk0081_a010_map.get(EKK0081A010CBSMsg1List.SVC_KEI_NO) );
			emgAdPrgMap.put( EKK1091D010CBSMsg.SVC_KEI_UCWK_NO, (String)kk0191_b001_map.get( EKK0191B001CBSMsg1List.SVC_KEI_UCWK_NO ) );
			if (JKKSvcConst.SVC_KEI_STAT_010.equals(svcKeiStat) ) 
			{
				emgAdPrgMap.put( EKK1091D010CBSMsg.IDO_DIV, idoDiv );
				emgAdPrgMap.put( EKK1091D010CBSMsg.IDO_DTM, idoDtm);
			}
			// 上記条件以外の場合は異動区分「00048:住所一括更新」を設定
			else
			{
				emgAdPrgMap.put( EKK1091D010CBSMsg.IDO_DIV, (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_IDO_DIV ) );
				emgAdPrgMap.put( EKK1091D010CBSMsg.IDO_DTM, JCCBPCommon.getSysDateTimeStamp() );
			}
			emgAdPrgMap.put( EKK1091D010CBSMsg.PRG_STAT, JKKAdInfChgConstCC.CD00647_E040 );
			if(!StringUtils.isEmpty((String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_MSKM_DTL_NO ))){
				emgAdPrgMap.put( EKK1091D010CBSMsg.MSKM_DTL_NO , (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_MSKM_DTL_NO ) );
			}

			// ・EKK1091D010  進捗登録
			reqMap = mapper.setEKK1091D010( param, fixedText, emgAdPrgMap, getIdoRsnList( param, fixedText ) );
			resMap = scCall.run( reqMap, handle );
			mapper.getEKK1091D010( param, fixedText, resMap );
			mapper.scResultCheck( param );
			
			/***********************************/
			/** 緊急通報先住所変更ＳＯＤの発行 */
			/***********************************/
			hakkoSod(handle, param, paramMap, (String)kk0081_a010_map.get(EKK0081A010CBSMsg1List.SVC_KEI_NO), kk0191_b001_map, chbfSvcKeiUcwkGeneAddDtm, chafSvcKeiUcwkGeneAddDtm);
			
			/** 一覧照会 */
			// ・ETU0011B010 番ポ工事一覧照会
			condMap.clear();
			condMap.put(ETU0011B010CBSMsg.KEY_SVC_KEI_NO, (String)kk0081_a010_map.get(EKK0081A010CBSMsg1List.SVC_KEI_NO));
			condMap.put(ETU0011B010CBSMsg.KEY_NTT_KEI_TEL_KAISEN_NO, (String)kk0191_a010_map.get(EKK0191A010CBSMsg1List.TELNO));
			reqMap = mapper.setETU0011B010(param, fixedText, condMap);
			resMap = scCall.run(reqMap, handle);
			ArrayList<HashMap<String, Object>> tu0011_b010_list = mapper.getETU0011B010( param, fixedText, resMap );
			mapper.scResultCheck(param);
			
			if( tu0011_b010_list!=null ){
				for( HashMap<String, Object> tu0011_b010_map : tu0011_b010_list ){
					// 番ポ工事ステータスが
					// 「工事希望日未入力」
					// 「他事業者確認要」
					// 「他事業者依頼待ち」
					// 「他事業者調整不可」
					// 「ＮＴＴ申請待ち」
					// 「ＮＴＴ申請不可」
					// でない場合、処理対象外
					String bmpKojiStat = (String) tu0011_b010_map.get(ETU0011B010CBSMsg1List.BMP_KOJI_STAT);
					if( !"000".equals(bmpKojiStat) 
						&& !"010".equals(bmpKojiStat)
						&& !"011".equals(bmpKojiStat)
						&& !"021".equals(bmpKojiStat)
					){
						continue;
					}
					
					/** 番ポ工事一意照会 */
					condMap.clear();
					condMap.put( "key_bmp_koji_no", (String)tu0011_b010_map.get(ETU0011B010CBSMsg1List.BMP_KOJI_NO));
					reqMap = mapper.setETU0011A010( param, fixedText, condMap );
					resMap = scCall.run( reqMap, handle );
					HashMap<String, Object> tu0011_a010_map = mapper.getETU0011A010( param, fixedText, resMap );
					mapper.scResultCheck( param );
					
					if( tu0011_a010_map==null )
					{
						continue;
					}
// ANK-4494-27-00対応 20241120 星野 ADD START
					// 休止票送付先コード が「3(下記宛先に送付)」以外の場合
					if(!JTUStrConst.PAUSE_HYO_SOHUS_CD_KAKI.equals(tu0011_a010_map.get(ETU0011A010CBSMsg1List.PAUSE_HYO_SOHUS_CD))){
						// 更新対象項目がないので更新スキップ
						continue;
					}
//ANK-4494-27-00対応 20241120 星野 ADD END
					
					// 申込事業者記事欄1を番ポ工事一意照会より取得する
					String mskmJigKijiRan1 = (String)tu0011_a010_map.get(ETU0011C010CBSMsg.MSKMJIG_KIJIRAN_1);
					
// ANK-4494-27-00対応 20241120 星野 DEL START
//					// 電話加入権取扱コードを番ポ工事一意照会より取得する
//					// 電話加入権取扱コードが「1：移転」の場合、休止票送付先コードには「5：設置場所と同じ」しか設定できないため
//					// 加入権移転先住所の更新は行わない
//					String telKnknTratCd = (String)tu0011_a010_map.get(ETU0011C010CBSMsg.TEL_KNKN_TRAT_CD);
// ANK-4494-27-00対応 20241120 星野 DEL END
					
					// 文字列検索し、同番移転の文字列が存在すれば同番移転レコードとして判断
// ANK-4494-27-00対応 20241120 星野 MOD START
//					if (mskmJigKijiRan1 != null && !"".equals(mskmJigKijiRan1) && mskmJigKijiRan1.indexOf("同番移転") > -1 && !"1".equals(telKnknTratCd)) {
					if (mskmJigKijiRan1 != null && !"".equals(mskmJigKijiRan1) && mskmJigKijiRan1.indexOf("同番移転") > -1) {
// ANK-4494-27-00対応 20241120 星野 MOD END
						// 加入権移転先住所手動入力フラグ
						tu0011_a010_map.put(ETU0011C010CBSMsg.KNKN_ITNSAD_MAN_INPUT_FLG, "0");
						// 加入権移転先住所コード
						tu0011_a010_map.put(ETU0011C010CBSMsg.KANYKN_ITENS_AD_CD, (String)paramMap.get( KAISEN_PLACE_AD_CD ) );
						// 加入権移転先郵便番号
						tu0011_a010_map.put(ETU0011C010CBSMsg.KANYKN_ITENS_PCD, (String)paramMap.get( PARAM_AD_PCD ));
						// 加入権移転先都道府県名
						tu0011_a010_map.put(ETU0011C010CBSMsg.KANYKN_ITENS_STATE_NM, (String)paramMap.get( PARAM_AD_STATE_NM ));
						// 加入権移転先市区町村名
						tu0011_a010_map.put(ETU0011C010CBSMsg.KANYKN_ITENS_CITY_NM, (String)paramMap.get( PARAM_AD_CITY_NM ));
						// 加入権移転先大字通称名
						tu0011_a010_map.put(ETU0011C010CBSMsg.KANYKN_ITENS_OAZTSU_NM, (String)paramMap.get( PARAM_AD_OAZTSU_NM ));
						// 加入権移転先字丁目名
						tu0011_a010_map.put(ETU0011C010CBSMsg.KANYKN_ITENS_AZCHO_NM, (String)paramMap.get( PARAM_AD_AZCHO_NM ));
						// 加入権移転先番地号
						tu0011_a010_map.put(ETU0011C010CBSMsg.KANYKN_ITENS_BNCHIGO, (String)paramMap.get( PARAM_AD_BNCHIGO ));
						// 加入権移転先住所補記・建物名
						tu0011_a010_map.put(ETU0011C010CBSMsg.KANYKN_ITENS_ADRTTM, (String)paramMap.get( PARAM_AD_ADRTTM ));
						// 加入権移転先住所補記・部屋番号
						tu0011_a010_map.put(ETU0011C010CBSMsg.KANYKN_ITENS_ADRRM, (String)kk0191_b001_map.get( PARAM_AD_ADRRM ));
						
						// 休止票送付先コード 「3：下記宛先に送付」固定
						tu0011_a010_map.put(ETU0011C010CBSMsg.PAUSE_HYO_SOHUS_CD, "3");
					}
// ANK-4494-27-00対応 20241120 星野 DEL START
// 設置場所住所は更新対象外とし、一意照会結果をそのまま残す
//					// 同番移転の文字列が存在しない場合は設置場所住所を更新する
//					else
//					{
//						// 設置場所住所手動入力フラグ
//						tu0011_a010_map.put(ETU0011C010CBSMsg.SETPLACE_AD_MAN_INPUT_FLG, "0");
//						// 設置場所住所コード
//						tu0011_a010_map.put(ETU0011C010CBSMsg.SETPLACE_AD_CD, (String)paramMap.get( KAISEN_PLACE_AD_CD ) );
//						// 設置場所郵便番号
//						tu0011_a010_map.put(ETU0011C010CBSMsg.SETPLACE_PCD, (String)paramMap.get( PARAM_AD_PCD ));
//						// 設置場所都道府県名
//						tu0011_a010_map.put(ETU0011C010CBSMsg.SETPLACE_STATE_NM, (String)paramMap.get( PARAM_AD_STATE_NM ));
//						// 設置場所市区町村名
//						tu0011_a010_map.put(ETU0011C010CBSMsg.SETPLACE_CITY_NM, (String)paramMap.get( PARAM_AD_CITY_NM ));
//						// 設置場所大字通称名
//						tu0011_a010_map.put(ETU0011C010CBSMsg.SETPLACE_OAZTSU_NM, (String)paramMap.get( PARAM_AD_OAZTSU_NM ));
//						// 設置場所字丁目名
//						tu0011_a010_map.put(ETU0011C010CBSMsg.SETPLACE_AZCHO_NM, (String)paramMap.get( PARAM_AD_AZCHO_NM ));
//						// 設置場所番地号
//						tu0011_a010_map.put(ETU0011C010CBSMsg.SETPLACE_BNCHIGO, (String)paramMap.get( PARAM_AD_BNCHIGO ));
//						// 設置場所住所補記・建物名
//						tu0011_a010_map.put(ETU0011C010CBSMsg.SETPLACE_ADRTTM, (String)paramMap.get( PARAM_AD_ADRTTM ));
//						// 設置場所住所補記・部屋番号
//						tu0011_a010_map.put(ETU0011C010CBSMsg.SETPLACE_ADRRM, (String)paramMap.get( PARAM_AD_ADRRM ));
//					}
// ANK-4494-27-00対応 20241120 星野 DEL END
					// 更新前更新年月日時分秒
					tu0011_a010_map.put(ETU0011C010CBSMsg.UPD_DTM_BF, (String)tu0011_b010_map.get(ETU0011B010CBSMsg1List.UPD_DTM));

					/** 番ポ工事情報変更 */
					// ・ETU0011C010 番ポ工事内容変更
					reqMap = mapper.setETU0011C010(param, fixedText, tu0011_a010_map);
					resMap = scCall.run(reqMap, handle);
					mapper.getETU0011C010( param, fixedText, resMap);
					mapper.scResultCheck(param);
				}
			}
		}
	}
	
	/**
	 * 機器利用場所住所更新
	 * <br>
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @param scCall
	 * @param paramMap
	 * @return
	 * @throws Throwable
	 */
	private void updateKikiUsedAd(
			SessionHandle handle
			, IRequestParameterReadWrite param
			, String fixedText
			, ServiceComponentRequestInvoker scCall
			, HashMap<String, Object> paramMap
			) throws Throwable 
	{
		HashMap<String, String> condMap = new HashMap<String, String>();
		HashMap<String, Object> reqMap;
		Map<?, ?> resMap;
		
		JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();
		
		
		/** サービス契約回線内訳番号で紐付く機器の更新 */

		// サービス契約回線内訳番号設定
		String work_kaisen_ucwk_cd = (String)paramMap.get(PARAM_SVC_KEI_KAISEN_UCWK_NO); 
		
		// EKK00341B504 機器提供サービス契約一覧照会(サービス契約回線内訳)
		condMap.clear();
		condMap.put( JKKAdInfChgConstCC.COND_KEY_SVC_KEI_KAIS_UCWK_NO, work_kaisen_ucwk_cd );
		reqMap = mapper.setEKK0341B504( param, fixedText, condMap );
		resMap = scCall.run( reqMap, handle );
		List<HashMap<String, Object>> kk341_b504_lst = mapper.getEKK0341B504( param, fixedText, resMap );
		mapper.scResultCheck( param );
		
		// dtlDataMapへの設定処理
		Iterator<HashMap<String, Object>> kikiTk_ite = kk341_b504_lst.iterator();
		while( kikiTk_ite.hasNext() )
		{
			HashMap<String, Object> cur_kikiTk_list = kikiTk_ite.next();
			
			// 機器提供サービス契約番号
			String kktkSvcKeiNo = getMapString( cur_kikiTk_list, EKK0341B501CBSMsg1List.KKTK_SVC_KEI_NO );
			
			// EKK0341A010 機器提供サービス契約一意照会
			condMap.clear();
			condMap.put( JKKAdInfChgConstCC.COND_KEY_KKTK_SVC_KEI_NO, kktkSvcKeiNo );
			condMap.put( JKKAdInfChgConstCC.COND_KEY_OPEDATE, getMapString(paramMap, JKKAdInfChgConstCC.PARAM_KEY_OPE_DATE ) );
			reqMap = mapper.setEKK0341A010( param, fixedText, condMap );
			resMap = scCall.run( reqMap, handle );
			HashMap<String, Object> kk341_a010_map = mapper.getEKK0341A010( param, fixedText, resMap );
			mapper.scResultCheck( param );
			List<String> tgtStatList = Arrays.asList(JKKAdInfChgConstCC.CD00056_KKTK_STATUS_LIST);	// 除外すべきステータスをチェック用にリストに追加
			
			// サービス提供中以外は処理しない
			if (kk341_a010_map.containsKey(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_STAT)) 
			{
				String stat = (String)kk341_a010_map.get(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_STAT);
				if (!tgtStatList.contains(stat))
				{
					continue;
				}
			}
			// 利用場所住所_住所コード  → 機器設置先住所コード
			kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_AD_CD, paramMap.get(KAISEN_PLACE_AD_CD));
			// 利用場所住所_郵便番号  → 機器設置先郵便番号
			kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_PCD, paramMap.get(  PARAM_AD_PCD ));
			// 利用場所住所_都道府県名  → 機器設置先都道府県名
			kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_STATE_NM, paramMap.get(  PARAM_AD_STATE_NM ));
			// 利用場所住所_市区町村名  → 機器設置先市区町村名
			kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_CITY_NM, paramMap.get(  PARAM_AD_CITY_NM ));
			// 利用場所住所_大字通称名  → 機器設置先大字通称名
			kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_OAZTSU_NM, paramMap.get(  PARAM_AD_OAZTSU_NM ));
			// 利用場所住所_字丁目名  → 機器設置先字丁目名
			kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_AZCHO_NM, paramMap.get(  PARAM_AD_AZCHO_NM ));
			// 利用場所住所_番地号  → 機器設置先番地号
			kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_BNCHIGO, paramMap.get(  PARAM_AD_BNCHIGO ));
			// 利用場所住所_住所補記・建物名  → 機器設置先住所補記・建物名
			kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_ADRTTM, paramMap.get(  PARAM_AD_ADRTTM ) );
			// 利用場所住所_住所補記・部屋番号  → 機器設置先住所補記・部屋番号
			kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_ADRRM, paramMap.get(  PARAM_AD_ADRRM ) );
			// 利用場所住所_手動入力フラグ  → 設置場所住所手動入力フラグ（宅内機器管理システムへの連携用）
			kk341_a010_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_AD_MAN_INPUT_FLG, paramMap.get(MAN_INPUT_FLG) );
			kk341_a010_map.put( EKK0341C230CBSMsg.KIKI_STC_AD_CHK_LV, "1");
			// 更新年月日時分秒 → 更新年月日時分秒(更新前)
			kk341_a010_map.put( JKKAdchgMapperCC.UPD_DT_KKTK_SVC_KEI_UPD_DTM_BEF, kk341_a010_map.get(EKK0341A010CBSMsg1List.UPD_DTM));
			
			//利用場所住所_未確定 → 住所未確定フラグ
			kk341_a010_map.put( EKK0341A010CBSMsg1List.AD_MI_FIX_FLG, paramMap.get(KISN_PLC_AD_MI_FIX_FLG));
			
			// サービス契約回線内訳番号を元にサービス契約番号を取得
			condMap.clear();
			condMap.put( "key_svc_kei_kais_ucwk_no", work_kaisen_ucwk_cd );
			condMap.put( "key_ope_ymd", (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_OPE_DATE ) );
			reqMap = mapper.setEKK0081B007( param, fixedText, condMap );
			resMap = scCall.run( reqMap, handle );
			ArrayList<HashMap<String, Object>> kk0081_b007_lst = mapper.getEKK0081B007( param, fixedText, resMap );
			mapper.scResultCheck( param );
	
			// 機器提供サービスから得られた宅内機器種別コードを元に
			// 使用すべきサービス契約番号を選択する。
			String kiki_svc_kei_no = "";
			String kiki_sbt_cd = getMapString( kk341_a010_map, EKK0341A010CBSMsg1List.TAKNKIKI_SBT_CD );
			Iterator<HashMap<String, Object>> svc_ite = kk0081_b007_lst.iterator();
			while (svc_ite.hasNext()){
				HashMap<String, Object> kk0081_b007_map = svc_ite.next();
				String svc_cd = (String)kk0081_b007_map.get( EKK0081B007CBSMsg1List.SVC_CD );
				// 機器が"E0":V-ONU の場合
				if ("E0".equals(kiki_sbt_cd)){
					// サービスコードがテレビサービスの契約サービスの場合、契約サービス番号を取得して終了
					if ( "03".equals(svc_cd) ){
						kiki_svc_kei_no = (String)kk0081_b007_map.get( EKK0081B007CBSMsg1List.SVC_KEI_NO );
						break;
					}
				// 機器が"60":モデム、"70":スプリッター、"90":インラインフィルタ、"D0":ONU、"R0":多機能ルーターまたは"S0":HGW の場合
				} else if("60".equals(kiki_sbt_cd)
							|| "70".equals(kiki_sbt_cd)
							|| "90".equals(kiki_sbt_cd)
							|| "D0".equals(kiki_sbt_cd)
							|| "R0".equals(kiki_sbt_cd)
					// ANK-4315-00-00 ADD START
							|| "S0".equals(kiki_sbt_cd)
					// ANK-4315-00-00 ADD END
				){
					// サービスコードがネットサービスの契約サービスの場合、契約サービス番号を取得して終了
					if ( "01".equals(svc_cd) ){
						kiki_svc_kei_no = (String)kk0081_b007_map.get( EKK0081B007CBSMsg1List.SVC_KEI_NO );
						break;
					// サービスコードが電話サービスの契約サービスの場合、契約サービス番号を取得して続行
					} else if ( "02".equals(svc_cd) ){
						kiki_svc_kei_no = (String)kk0081_b007_map.get( EKK0081B007CBSMsg1List.SVC_KEI_NO );
						// ネットまたは電話に紐付く機器の場合、ネットを優先するため電話の場合のみbreakしない。
					}
				}
			}
			// 機器提供サービス契約の更新処理（宅内機器管理システムへの連携）
			chgIdodiv_EKK0341C200(handle, param, fixedText, kk341_a010_map, kiki_svc_kei_no);
			
		}
		
		// 契約系機器
		ArrayList<HashMap<String, Object>> svc_kei_list = (ArrayList<HashMap<String, Object>>)paramMap.get(SVC_KEI_LIST);
		for (HashMap<String, Object> kk0081_a010_map : svc_kei_list)
		{
			String kiki_svc_kei_no = (String)kk0081_a010_map.get(EKK0081A010CBSMsg1List.SVC_KEI_NO);
			
			if (!StringUtils.isEmpty(kiki_svc_kei_no)) {
				/** サービス契約番号で紐付く機器の更新 */
				// EKK00341B504 機器提供サービス契約一覧照会(サービス契約回線内訳)
				condMap.clear();
				condMap.put("key_svc_kei_no", kiki_svc_kei_no);
				reqMap = mapper.setEKK0341B002( param, fixedText, condMap );
				resMap = scCall.run( reqMap, handle );
				List<HashMap<String, Object>> kk341_b002_lst = mapper.getEKK0341B002( param, fixedText, resMap );
				mapper.scResultCheck( param );
				
				// 詳細設定処理
				Iterator<HashMap<String, Object>> kk341_b002_ite = kk341_b002_lst.iterator();
				while( kk341_b002_ite.hasNext() )
				{
					HashMap<String, Object> cur_kikiTk_list = kk341_b002_ite.next();
					
					// 機器提供サービス契約番号
					String kktkSvcKeiNo = getMapString( cur_kikiTk_list, EKK0341B501CBSMsg1List.KKTK_SVC_KEI_NO );
					
					// EKK0341A010 機器提供サービス契約一意照会
					condMap.clear();
					condMap.put( JKKAdInfChgConstCC.COND_KEY_KKTK_SVC_KEI_NO, kktkSvcKeiNo );
					condMap.put( JKKAdInfChgConstCC.COND_KEY_OPEDATE, getMapString(paramMap, JKKAdInfChgConstCC.PARAM_KEY_OPE_DATE ) );
					reqMap = mapper.setEKK0341A010( param, fixedText, condMap );
					resMap = scCall.run( reqMap, handle );
					HashMap<String, Object> kk341_a010_map = mapper.getEKK0341A010( param, fixedText, resMap );
					mapper.scResultCheck( param );
					List<String> tgtStatList = Arrays.asList(JKKAdInfChgConstCC.CD00056_KKTK_STATUS_LIST);	// 除外すべきステータスをチェック用にリストに追加
					
					// サービス提供中以外は処理しない
					if (kk341_a010_map.containsKey(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_STAT)) 
					{
						String stat = (String)kk341_a010_map.get(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_STAT);
						if (!tgtStatList.contains(stat))
						{
							continue;
						}
					}
					
					// 利用場所住所_住所コード  → 機器設置先住所コード
					kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_AD_CD, paramMap.get( KAISEN_PLACE_AD_CD ));
					// 利用場所住所_郵便番号  → 機器設置先郵便番号
					kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_PCD, paramMap.get( PARAM_AD_PCD ));
					// 利用場所住所_都道府県名  → 機器設置先都道府県名
					kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_STATE_NM, paramMap.get( PARAM_AD_STATE_NM ));
					// 利用場所住所_市区町村名  → 機器設置先市区町村名
					kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_CITY_NM, paramMap.get( PARAM_AD_CITY_NM ));
					// 利用場所住所_大字通称名  → 機器設置先大字通称名
					kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_OAZTSU_NM, paramMap.get( PARAM_AD_OAZTSU_NM ));
					// 利用場所住所_字丁目名  → 機器設置先字丁目名
					kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_AZCHO_NM, paramMap.get( PARAM_AD_AZCHO_NM ));
					// 利用場所住所_番地号  → 機器設置先番地号
					kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_BNCHIGO, paramMap.get( PARAM_AD_BNCHIGO ));
					// 利用場所住所_住所補記・建物名  → 機器設置先住所補記・建物名
					kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_ADRTTM, paramMap.get( PARAM_AD_ADRTTM ) );
					// 利用場所住所_住所補記・部屋番号  → 機器設置先住所補記・部屋番号
					kk341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_ADRRM, paramMap.get( PARAM_AD_ADRRM ) );
					// 利用場所住所_手動入力フラグ  → 設置場所住所手動入力フラグ（宅内機器管理システムへの連携用）
					kk341_a010_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_AD_MAN_INPUT_FLG, paramMap.get(MAN_INPUT_FLG) );
					kk341_a010_map.put( EKK0341C230CBSMsg.KIKI_STC_AD_CHK_LV, "1");
	
					// 更新年月日時分秒 → 更新年月日時分秒(更新前)
					kk341_a010_map.put( JKKAdchgMapperCC.UPD_DT_KKTK_SVC_KEI_UPD_DTM_BEF, kk341_a010_map.get(EKK0341A010CBSMsg1List.UPD_DTM));
					
					//利用場所住所_未確定 → 住所未確定フラグ
					kk341_a010_map.put( EKK0341A010CBSMsg1List.AD_MI_FIX_FLG, paramMap.get( KISN_PLC_AD_MI_FIX_FLG ) );
					
					// 機器提供サービス契約の更新処理（宅内機器管理システムへの連携）
					chgIdodiv_EKK0341C200(handle,  param, fixedText, kk341_a010_map, kiki_svc_kei_no);
				}
			}
		}
	}
	
	/**
	 * 更新不可サービス契約内訳一覧取得
	 * <br>
	 * @param param
	 * @param fixedText
	 * @param svcKeiKaisenUcwkNo
	 * @return
	 * @throws Exception
	 */
	private List<String> getIgnoreUcwkList(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, String svcKeiKaisenUcwkNo) throws Exception {
		
		List<String> ignoreUcwkList = new ArrayList<String>();
		
		/** 事前準備 */
		HashMap<String, String> condMap = new HashMap<String, String>();
		HashMap<String, Object> paramMap = (HashMap<String, Object>)param.getData(fixedText);
		HashMap<String, Object> reqMap;
		Map<?, ?> resMap;

		// 返却域を準備
		HashMap<String, ArrayList<HashMap<String, Object>>> resDtlDts = new HashMap<String, ArrayList<HashMap<String, Object>>>();

		// 住所情報変更コモンコンポーネントマッピングクラスインスタンスを取得
		JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();

		// SCリクエストInvokerを取得
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		/** 住所変更スキーマデータの取得 */
		// ・EKK2091B001 住所変更一覧照会
		condMap.clear();
		condMap.put( EKK2091B001CBSMsg.KEY_ITNM_SVKEI_KISUW_NO, svcKeiKaisenUcwkNo );
		reqMap = mapper.setEKK2091B001( param, fixedText, condMap );
		resMap = scCall.run( reqMap, handle );
		ArrayList<HashMap<String, Object>> kk2091_b001_list = mapper.getEKK2091B001( param, fixedText, resMap );
		mapper.scResultCheck( param );

		if( kk2091_b001_list==null ){
			// 空リスト返却
			return ignoreUcwkList;
		}
		
		for( HashMap<String, Object> kk2091_b001_map : kk2091_b001_list ){
			String adchgStat = (String)kk2091_b001_map.get( EKK2091B001CBSMsg1List.ADCHG_STAT );
			// 住所変更ステータス：登録中 以外は無視
			if( !"001".equals(adchgStat) ){
				continue;
			}
			
			String adchgNo = (String)kk2091_b001_map.get( EKK2091B001CBSMsg1List.ADCHG_NO );
			if(StringUtils.isEmpty(adchgNo)){
				continue;
			}
			/** 住所変更明細スキーマデータの取得 */
			condMap.clear();
			condMap.put( EKK2101B001CBSMsg.KEY_ADCHG_NO, adchgNo );
			condMap.put( EKK2101B001CBSMsg.KEY_ADCHG_DTL_SBT_CD, "02" );
			reqMap = mapper.setEKK2101B001( param, fixedText, condMap );
			resMap = scCall.run( reqMap, handle );
			ArrayList<HashMap<String, Object>> kk2101_b001_list = mapper.getEKK2101B001( param, fixedText, resMap );
			mapper.scResultCheck( param );
			
			if( kk2101_b001_list==null ){
				continue;
			}
			
			for( HashMap<String, Object> kk2101_b001_map : kk2101_b001_list ){
				String chbfSkbtNo = (String)kk2101_b001_map.get(EKK2101B001CBSMsg1List.CHBF_SKBT_NO);
				String chafSkbtNo = (String)kk2101_b001_map.get(EKK2101B001CBSMsg1List.CHAF_SKBT_NO);
				
				// 番号変更・番号追加の変更後番号は転居先にひもづくので、緊急通報住所更新対象外
				if( !StringUtils.isEmpty(chafSkbtNo) && !chafSkbtNo.equals(chbfSkbtNo) ){
					ignoreUcwkList.add(chafSkbtNo);
				}
			}
		}
		return ignoreUcwkList;
	}

	/**
	 * 緊急通報先住所変更ＳＯＤの発行
	 * <br>
	 * @param param
	 * @param paramMap
	 * @param svcKeiNo
	 * @param kk0191_b001_map
	 * @param chbfSvcKeiUcwkGeneAddDtm
	 * @param chafSvcKeiUcwkGeneAddDtm
	 * @throws RequestParameterException
	 * @throws Throwable
	 */
	private void hakkoSod(
			SessionHandle handle,
			IRequestParameterReadWrite param,
			HashMap<String, Object> paramMap, 
			String svcKeiNo,
			HashMap<String, Object> kk0191_b001_map,
			String chbfSvcKeiUcwkGeneAddDtm, 
			String chafSvcKeiUcwkGeneAddDtm
	) throws RequestParameterException, Throwable 
	{
		
		HashMap<String, Object> trgt_data = new HashMap<String, Object>();
		ArrayList<HashMap<String, Object>> trgt_data_list = new ArrayList<HashMap<String,Object>>();
		HashMap<String, Object> trgt_data_list_element = new HashMap<String, Object>();
		HashMap<String, Object> sod_kihon_info = new HashMap<String, Object>();
		HashMap<String, Object> svc_kei_info = new HashMap<String, Object>();
		HashMap<String, Object> svc_kei_ucwk_info = new HashMap<String, Object>();
		
		//--サービスオーダ発行データの生成
		//サービスオーダ発行データ
		// 共通情報のマッピング
		trgt_data.put("func_code", paramMap.get(JKKAdInfChgConstCC.PARAM_KEY_FUNC_CD));

		//対象データリスト
		trgt_data.put("trgt_data_list", trgt_data_list);
		
		//SODマップ
		trgt_data_list.add(trgt_data_list_element);
		
		//SOD基本情報
		trgt_data_list_element.put("sod_kihon_info", sod_kihon_info);
		
		//サービス契約情報
		trgt_data_list_element.put("svc_kei_info", svc_kei_info);
		
		//サービス契約内訳情報
		trgt_data_list_element.put("svc_kei_ucwk_info", svc_kei_ucwk_info);
		
		
		// SOD基本情報
		// SYSID
		sod_kihon_info.put("sysid", paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_SYSID ));
		// 異動区分
		sod_kihon_info.put("ido_div", paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_IDO_DIV  ));
		
		//--サービス契約情報
		// サービス契約番号
		svc_kei_info.put("svc_kei_no", svcKeiNo);
		
		//--サービス契約内訳情報
		// サービス契約内訳番号
		svc_kei_ucwk_info.put("svc_kei_ucwk_no", kk0191_b001_map.get( EKK0191B001CBSMsg1List.SVC_KEI_UCWK_NO ));
		// 変更前サービス契約内訳世代登録年月日時分秒
		svc_kei_ucwk_info.put("chbf_svc_kei_ucwk_gene_add_dtm",chbfSvcKeiUcwkGeneAddDtm);
		// 変更後サービス契約内訳世代登録年月日時分秒
		svc_kei_ucwk_info.put("chaf_svc_kei_ucwk_gene_add_dtm",chafSvcKeiUcwkGeneAddDtm);
		
		// 条件として設定
		param.setData(SOD_CC_FIXED_TEXT, trgt_data);
		
		/*********************************/
		/** 住所変更ＳＯＤ発行ＣＣの呼出 */
		/*********************************/
		JKKAdchgHakkoSODCC sodCC = new JKKAdchgHakkoSODCC();
		sodCC.hakkoSODAdInfChg(handle, param, SOD_CC_FIXED_TEXT);
		
	}

	/**
	 * 異動理由リスト 取得処理.
	 * <br>
	 * @param   param      モデルグループ、コントロールマップを含むリクエストパラメータ
	 * @throws  Exception  例外が発生した場合
	 * @return  進捗登録用の異動理由リスト
	 */
	private ArrayList<HashMap<String, Object>> getIdoRsnList( IRequestParameterReadWrite param, String fixedText ) throws Exception 
	{

		/** 事前準備 */
		HashMap<String, Object> paramMap = (HashMap<String, Object>)param.getData(fixedText);


		// 投入データ設定[異動理由リスト]
		ArrayList<HashMap<String, Object>> put_ido_rsn_list = new ArrayList<HashMap<String, Object>>();

		// param.異動理由リストの情報を投入データとして登録
		ArrayList<HashMap<String, Object>> prm_ido_rsn_list = (ArrayList<HashMap<String, Object>>)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_IDO_RSN_LIST );
		Iterator<HashMap<String, Object>> prm_ido_rsn_ite = prm_ido_rsn_list.iterator();
		while( prm_ido_rsn_ite.hasNext() ){

			HashMap<String, Object> cur_ido_rsn = prm_ido_rsn_ite.next();

			// 投入データを登録
			HashMap<String, Object> put_ido_rsn = new HashMap<String, Object>();
			put_ido_rsn.put( EKK1091D010CBSMsg1List.IDO_RSN_CD, (String)cur_ido_rsn.get( JKKAdInfChgConstCC.PARAM_KEY_IDO_RSN_CD ) );
			put_ido_rsn.put( EKK1091D010CBSMsg1List.IDO_RSN_MEMO, (String)cur_ido_rsn.get( JKKAdInfChgConstCC.PARAM_KEY_IDO_RSN_MEMO ) );
			put_ido_rsn_list.add( put_ido_rsn );
		}

		return put_ido_rsn_list;
	}

	/**
	 * チェック処理.
	 * <br>
	 * @param   handle     セッションマネージャなどを持ったハンドル情報
	 * @param   param      モデルグループ、コントロールマップを含むリクエストパラメータ
	 * @param   fixedText  ユーザ任意文字列
	 * @throws  Throwable  例外が発生した場合
	 * @return  リクエストパラメータ(param)に戻り値を追加して返却する
	 */
	public HashMap<String, Object> getInvokeCBS( SessionHandle handle, IRequestParameterReadWrite param, String fixedText ) throws Throwable 
	{

		/** 事前準備 */
		HashMap<String, Object> paramMap = (HashMap<String, Object>)param.getData(fixedText);

		// 住所情報変更コモンコンポーネントマッピングクラスインスタンスを取得
		JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();

		/** サービス契約回線内訳一意照会 上りマッピング生成 */
		// 検索条件格納マップ 生成
		HashMap<String, String> condMap = new HashMap<String, String>();
		condMap.put( JKKAdInfChgConstCC.COND_KEY_SVC_KEI_KAIS_UCWK_NO, (String)paramMap.get( PARAM_SVC_KEI_KAISEN_UCWK_NO ) );

		// 呼び元へ上りマッピングを返却
		HashMap<String, Object> reqMap = mapper.setEKK0251A010( param, fixedText, condMap);
		return reqMap;
	}

	/**
	 * 処理結果(エラー情報)取得処理.
	 * <br>
	 * @param   param      モデルグループ、コントロールマップを含むリクエストパラメータ
	 * @param   templates  テンプレート情報一覧
	 * @param   returnCd   リターンコード
	 * @throws  Throwable  例外が発生した場合
	 * @return  リクエストパラメータ(param)に戻り値を追加して返却する
	 */
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode) throws Throwable 
	{
		return param;
	}

	/**
	 * 機器提供サービス契約場所変更実施
	 * <br>
	 * @param  param            モデルグループ、コントロールマップを含むリクエストパラメータ
	 * @param  fixedText        ユーザ任意文字列
	 * @param  kk0341_a010_map  機器提供サービス契約一意照会マップ
	 * @param  svc_kei_no       サービス契約番号
	 * @throws 例外が発生した場合
	 */
	private void chgIdodiv_EKK0341C200(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, 
			HashMap<String, Object> kk0341_a010_map, String svc_kei_no ) throws Exception 
	{
		
		/** EKK0341C230_機器提供サービス契約情報変更 */
		executeEKK0341C230(handle, param, fixedText, kk0341_a010_map);
		
		// 受付済の場合、以降の処理は行わない
		if (JKKSvcConst.KKTK_SVC_KEI_STAT_010.equals(kk0341_a010_map.get(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_STAT)))
		{
			return ;
		}
		
		/** EKKA0020002 設置場所番号取得 **/
		executeEKKA0020002(handle, param, fixedText, kk0341_a010_map);
		
		/** EKK0341C200_機器提供サービス契約場所変更 */
		HashMap<String, Object> kk0341_c200_map = executeEKK0341C200(handle, param, fixedText, kk0341_a010_map);
		
		/** EKK0341C220_機器提供サービス契約場所変更確定 */
		executeEKK0341C220(handle, param, fixedText, kk0341_a010_map, kk0341_c200_map);
		
		/** 交換中レコードに対する住所情報変更 */
		kokanchuKikiAdInfChg(handle, param, fixedText, kk0341_a010_map);
		
		// サービス契約番号が設定されていれば、処理する
		if ( svc_kei_no != null && !StringUtils.isEmpty( svc_kei_no )  )
		{
			// 機器製造番号の取得
			String kiki_seizo_no = getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_SEIZO_NO );
			// 宅内機器型式コードを持つ場合、宅内機器型式コードを元に製造番号有無を取得
			String taknkiki_model_cd = getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD);
			String seizou_no_umu = null;
			if (taknkiki_model_cd == null || taknkiki_model_cd.isEmpty()) {
				// 宅内機器型式コードを持たない場合は、製造番号有無が"1":ありの場合と同じ処理を行う。
				seizou_no_umu = "1";
			} else {
				/** EZM0411A010 宅内機器型式一意照会 */
				seizou_no_umu = executeEZM0411A010(handle, param, fixedText, kk0341_a010_map);
			}
			// 製造番号有無が"0":なしの場合は処理を行わない
			if ( seizou_no_umu == null || "".equals(seizou_no_umu) || "0".equals( seizou_no_umu ) )
			{
				return;
			}
			if ( kiki_seizo_no == null || StringUtils.isEmpty( kiki_seizo_no ) 	) {
				String kiki_svc_kei_stat = (String)kk0341_a010_map.get(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_STAT);
				if ("110".equals(kiki_svc_kei_stat)) { // 契約変更中
					/* 変更前、変更後の製造番号を用意する。 */
				}
				/** EKK2401D010 場所番号連携対象機器ワーク登録 */
				executeEKK2401D010(handle, param, fixedText, kk0341_a010_map, svc_kei_no);
			} else {
				/** EKKA0020003 宅内機器一意照会（４） */
				String kihontUpdDttm = executeEKKA0020003(handle, param, fixedText, kk0341_a010_map);
				/** EKKA0020004 機器場所番号変更（宅内連携） */
				executeEKKA0020004(handle, param, fixedText, kk0341_a010_map, svc_kei_no, kihontUpdDttm);
			}
		}
	}

	/**
	 * 交換中機器の利用場所住所を更新する
	 * @param param
	 * @param fixedText
	 * @param kk0341_a010_map
	 * @throws RequestParameterException
	 * @throws SCException
	 * @throws Exception
	 * @throws CCException
	 */
	private void kokanchuKikiAdInfChg(SessionHandle handle, IRequestParameterReadWrite param,
			String fixedText, HashMap<String, Object> kk0341_a010_map)
			throws RequestParameterException, SCException, Exception,
			CCException 
	{
		/** 事前準備 */
		HashMap<String, String> condMap = new HashMap<String, String>();
		HashMap<String, Object> paramMap = (HashMap<String, Object>)param.getData(fixedText);
		HashMap<String, Object> reqMap;
		Map<?, ?> resMap;
		// 住所情報変更コモンコンポーネントマッピングクラスインスタンスを取得
		JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();
		JKKAdchgMapperCC adchgMapper = JKKAdchgMapperCC.getInstance();
		// SCリクエストInvokerを取得
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		String kktkSvcKeiNo = getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO );
		
		// 未来日レコードがないか確認
		
		// EKK0341A010 機器提供サービス契約一意照会　運用日指定
		condMap.clear();
		condMap.put( JKKAdInfChgConstCC.COND_KEY_KKTK_SVC_KEI_NO, kktkSvcKeiNo );
		condMap.put( JKKAdInfChgConstCC.COND_KEY_OPEDATE, getMapString( paramMap, JKKAdInfChgConstCC.PARAM_KEY_OPE_DATE ) );
		reqMap = mapper.setEKK0341A010( param, fixedText, condMap );
		resMap = scCall.run( reqMap, handle );
		HashMap<String, Object> current_kk341_a010_map = mapper.getEKK0341A010( param, fixedText, resMap );
		mapper.scResultCheck( param );
		
		// EKK0341A010 機器提供サービス契約一意照会　未来日指定
		condMap.clear();
		condMap.put( JKKAdInfChgConstCC.COND_KEY_KKTK_SVC_KEI_NO, kktkSvcKeiNo );
		condMap.put( JKKAdInfChgConstCC.COND_KEY_OPEDATE, JKKAdInfChgConstCC.DEFAULT_RSV_APLY_YMD );
		reqMap = mapper.setEKK0341A010( param, fixedText, condMap );
		resMap = scCall.run( reqMap, handle );
		HashMap<String, Object> mirai_kk341_a010_map = mapper.getEKK0341A010( param, fixedText, resMap );
		mapper.scResultCheck( param );

		String geneAddDtmCurrent = getMapString( current_kk341_a010_map, EKK0341A010CBSMsg1List.GENE_ADD_DTM );
		String geneAddDtmMirai = getMapString( mirai_kk341_a010_map, EKK0341A010CBSMsg1List.GENE_ADD_DTM );
		// 世代登録が一致の場合、未来日レコードなしと判断する
		if( !StringUtils.isEmpty(geneAddDtmMirai) && !StringUtils.isEmpty(geneAddDtmCurrent) && geneAddDtmMirai.equals(geneAddDtmCurrent) ){
			
			// 交換中レコードがないか確認
			// 機器提供サービス契約一意紹介
			condMap.clear();
			condMap.put(JKKAdchgMapperCC.COND_KEY_KKTK_SVC_KEI_NO, kktkSvcKeiNo);
			condMap.put(JKKAdchgMapperCC.COND_KEY_OPEDATE, JKKAdchgConstCC.DEFAULT_RSV_APLY_YMD);
			reqMap = adchgMapper.setEKK0341B032(param, fixedText, condMap);
			resMap = scCall.run(reqMap, handle);
			List<HashMap<String, Object>> kk0341_b032_map_af = adchgMapper.getEKK0341B032( param, fixedText, resMap );
			adchgMapper.scResultCheck(param);
			HashMap<String, Object> kokan_kk0341_a010_map = new HashMap<String, Object>();
			if (kk0341_b032_map_af.size() > 0) {
				kokan_kk0341_a010_map = kk0341_b032_map_af.get(0);
			}
			
			// ステータスによる交換中判定
			if("110".equals( getMapString( kokan_kk0341_a010_map, EKK0341A010CBSMsg1List.KKTK_SVC_KEI_STAT ) )){
				// 交換中レコードに対する住所更新
				
				String geneAddKokan = getMapString( kokan_kk0341_a010_map, EKK0341A010CBSMsg1List.GENE_ADD_DTM );
				kk0341_a010_map.put(EKK0341A010CBSMsg1List.GENE_ADD_DTM, geneAddKokan);
				
				// EKK0341C234 機器提供サービス契約情報変更
				reqMap = mapper.setEKK0341C234( param, fixedText, kk0341_a010_map );
				resMap = scCall.run( reqMap, handle );
				HashMap<String, Object> kk0341_c230_map = mapper.getEKK0341C234( param, fixedText, resMap );
				mapper.scResultCheck( param );
				
				// 排他情報の引継
				kk0341_a010_map.put( EKK0341A010CBSMsg1List.LAST_UPD_DTM, getMapString( kk0341_c230_map, EKK0341C234CBSMsg.UPD_DTM ) );
				// 戻り値を取得
				String ad_chk_lv_res = (String)paramMap.get( EKK0341C234CBSMsg.KIKI_STC_AD_CHK_LV_ERR );
				if(!StringUtils.isEmpty(ad_chk_lv_res)){
					paramMap.put("ad_chk_lv_res", ad_chk_lv_res);
				}
			}
		}
	}
	
	/**
	 * EKK0341C200_機器提供サービス契約場所変更実行処理
	 * @param  param            モデルグループ、コントロールマップを含むリクエストパラメータ
	 * @param  fixedText        ユーザ任意文字列
	 * @param  kk0341_a010_map  機器提供サービス契約一意照会マップ
	 * @return
	 */
	private HashMap<String, Object> executeEKK0341C200(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, 
			HashMap<String, Object> kk0341_a010_map ) throws Exception
	{
		/** 前準備 **/
		HashMap<String, Object> condMap;
		HashMap<String, Object> reqMap;
		Map<?, ?> resMap;

		// 住所変更登録コモンコンポーネントマッピングクラスインスタンス
		JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();
		// SCリクエストInvoker
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		HashMap<String, Object> paramMap = (HashMap<String, Object>)param.getData(fixedText);
		
		condMap = new HashMap<String, Object>();
		// 機器提供サービス契約番号
		condMap.put( EKK0341C200CBSMsg.KKTK_SVC_KEI_NO, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO ) );
		// 機器設置先場所番号
		condMap.put( EKK0341C200CBSMsg.KIKI_STC_SAKI_PLACE_NO, getMapString( paramMap, JKKAdInfChgConstCC.PARAM_KEY_ITENS_PLACE_NO ) );
		// 予約適用年月日
		condMap.put( EKK0341C200CBSMsg.RSV_APLY_YMD, (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_OPE_DATE ));
		// 異動区分
		condMap.put( EKK0341C200CBSMsg.IDO_DIV, getMapString( paramMap, JKKAdInfChgConstCC.PARAM_KEY_IDO_DIV ) );
		// 宅内機器異動コード
		condMap.put( EKK0341C200CBSMsg.TAKNKIKI_IDO_CD, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.TAKNKIKI_IDO_CD ) );
		
		if(!StringUtils.isEmpty((String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_MSKM_DTL_NO ))){
			condMap.put( EKK0341C200CBSMsg.MSKM_DTL_NO , (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_MSKM_DTL_NO ) );
		}
		// 更新年月日時分秒(更新前)
		condMap.put( JKKAdchgMapperCC.UPD_DT_KKTK_SVC_KEI_UPD_DTM_BEF, kk0341_a010_map.get( EKK0341A010CBSMsg1List.LAST_UPD_DTM ) );

		// EKK0341C200_機器提供サービス契約場所変更
		reqMap = mapper.setEKK0341C200( param, fixedText, condMap );
		resMap = scCall.run( reqMap, handle );
		HashMap<String, Object> kk0341_c200_map = mapper.getEKK0341C200( param, fixedText, resMap );
		mapper.scResultCheck( param );
		
		// 排他情報の引継
		kk0341_a010_map.put( EKK0341A010CBSMsg1List.LAST_UPD_DTM, getMapString( kk0341_c200_map, EKK0341C200CBSMsg.UPD_DTM ) );
		return kk0341_c200_map;
	}
	
	/**
	 * EKK0341C220 機器提供サービス契約場所変更確定実行処理
	 * @param  param            モデルグループ、コントロールマップを含むリクエストパラメータ
	 * @param  fixedText        ユーザ任意文字列
	 * @param  kk0341_a010_map  機器提供サービス契約一意照会マップ
	 * @param  kk0341_c200_map  機器提供サービス契約場所変更マップ
	 * @return
	 */
	private HashMap<String, Object> executeEKK0341C220(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, 
			HashMap<String, Object> kk0341_a010_map, HashMap<String, Object> kk0341_c200_map ) throws Exception
	{
		/** 前準備 **/
		HashMap<String, Object> condMap;
		HashMap<String, Object> reqMap;
		Map<?, ?> resMap;

		// 住所情報変更コモンコンポーネントマッピングクラスインスタンスを取得
		JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();
		// SCリクエストInvoker
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		HashMap<String, Object> paramMap = (HashMap<String, Object>)param.getData(fixedText);

		condMap = new HashMap<String, Object>();
		// 機器提供サービス契約番号
		condMap.put( EKK0341C220CBSMsg.KKTK_SVC_KEI_NO, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO ) );
		// 世代登録年月日時分秒
		condMap.put( EKK0341C220CBSMsg.GENE_ADD_DTM, getMapString( kk0341_c200_map, EKK0341C200CBSMsg.GENE_ADD_DTM ) );
		// 予約適用年月日
		condMap.put( EKK0341C220CBSMsg.RSV_APLY_YMD, (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_OPE_DATE ));
		// 異動区分
		condMap.put( EKK0341C220CBSMsg.IDO_DIV, getMapString( paramMap, JKKAdInfChgConstCC.PARAM_KEY_IDO_DIV ) );
		// 更新年月日時分秒(更新前)
		condMap.put( EKK0341C220CBSMsg.UPD_DTM_BF, kk0341_a010_map.get( EKK0341A010CBSMsg1List.LAST_UPD_DTM ) );

		// EKK0341C220 機器提供サービス契約場所変更確定
		reqMap = mapper.setEKK0341C220( param, fixedText, condMap );
		resMap = scCall.run( reqMap, handle );
		HashMap<String, Object> kk0341_c220_map = mapper.getEKK0341C220( param, fixedText, resMap );
		mapper.scResultCheck( param );
		
		// 排他情報の引継
		kk0341_a010_map.put( EKK0341A010CBSMsg1List.LAST_UPD_DTM, getMapString( kk0341_c220_map, EKK0341C220CBSMsg.UPD_DTM ) );
		return kk0341_c220_map;
	}
	
	/**
	 * EKK0341C230 機器提供サービス契約情報変更 実行処理
	 * @param  param            モデルグループ、コントロールマップを含むリクエストパラメータ
	 * @param  fixedText        ユーザ任意文字列
	 * @param  kk0341_a010_map  機器提供サービス契約一意照会マップ
	 * @return
	 * @throws Exception
	 */
	private HashMap<String, Object> executeEKK0341C230(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, 
			HashMap<String, Object> kk0341_a010_map ) throws Exception
	{
		/** 前準備 **/
		HashMap<String, Object> reqMap;
		Map<?, ?> resMap;

		// 住所変更登録コモンコンポーネントマッピングクラスインスタンス
		JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();
		// SCリクエストInvoker
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		HashMap<String, Object> paramMap = (HashMap<String, Object>)param.getData(fixedText);
		
		// 異動区分
		// 受付済の場合、異動区分を更新しない
		if (!JKKSvcConst.KKTK_SVC_KEI_STAT_010.equals(kk0341_a010_map.get(EKK0341A010CBSMsg1List.KKTK_SVC_KEI_STAT)))
		{
			kk0341_a010_map.put( EKK0341A010CBSMsg1List.IDO_DIV, getMapString( paramMap, JKKAdInfChgConstCC.PARAM_KEY_IDO_DIV ) );
		}
		// 機器設置先住所コード
		kk0341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_AD_CD, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_AD_CD ));
		// 機器設置先郵便番号
		kk0341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_PCD, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_PCD ));
		// 機器設置先都道府県名
		kk0341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_STATE_NM, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_STATE_NM ));
		// 機器設置先市区町村名
		kk0341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_CITY_NM, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_CITY_NM ));
		// 機器設置先大字通称名
		kk0341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_OAZTSU_NM, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_OAZTSU_NM ));
		// 機器設置先字丁目名
		kk0341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_AZCHO_NM, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_AZCHO_NM ));
		// 機器設置先番地号
		kk0341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_BNCHIGO, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_BNCHIGO ));
		// 機器設置先住所補記・建物名
		kk0341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_ADRTTM, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_ADRTTM ) );
		// 機器設置先住所補記・部屋番号
		kk0341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SAKI_ADRRM, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_ADRRM ) );
		// 機器設置先_契約者住所差異フラグ
		kk0341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SK_KSH_AD_SAI_FLG, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SK_KSH_AD_SAI_FLG ) );
		// 機器設置先電話番号
		kk0341_a010_map.put( EKK0341A010CBSMsg1List.KIKI_STC_SK_TELNO, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SK_TELNO ) );
		// 更新年月日時分秒(更新前)
		kk0341_a010_map.put( JKKAdchgMapperCC.UPD_DT_KKTK_SVC_KEI_UPD_DTM_BEF, kk0341_a010_map.get( EKK0341A010CBSMsg1List.LAST_UPD_DTM ) );
		// 予約適用年月日
		kk0341_a010_map.put( EKK0341A010CBSMsg1List.RSV_APLY_YMD, JKKAdInfChgConstCC.DEFAULT_RSV_APLY_YMD );

		// EKK0341C230 機器提供サービス契約情報変更
		reqMap = mapper.setEKK0341C230( param, fixedText, kk0341_a010_map );
		resMap = scCall.run( reqMap, handle );
		HashMap<String, Object> kk0341_c230_map = mapper.getEKK0341C230( param, fixedText, resMap );
		mapper.scResultCheck( param );
		
		// 排他情報の引継
		kk0341_a010_map.put( EKK0341A010CBSMsg1List.LAST_UPD_DTM, getMapString( kk0341_c230_map, EKK0341C230CBSMsg.UPD_DTM ) );
		// 戻り値を取得
		String ad_chk_lv_res = (String)paramMap.get( EKK0341C230CBSMsg.KIKI_SOHUS_AD_CHK_LV_ERR );
		if(!StringUtils.isEmpty(ad_chk_lv_res)){
			paramMap.put("ad_chk_lv_res", ad_chk_lv_res);
		}
		ad_chk_lv_res = (String)paramMap.get( EKK0341C230CBSMsg.KIKI_STC_AD_CHK_LV_ERR );
		if(!StringUtils.isEmpty(ad_chk_lv_res)){
			paramMap.put("ad_chk_lv_res", ad_chk_lv_res);
		}
		return kk0341_c230_map;
	}
		
	/**
	 * 転居先場所情報の登録.
	 * <br>
	 * @param   param      モデルグループ、コントロールマップを含むリクエストパラメータ
	 * @param   fixedText  ユーザ任意文字列
	 * @param   kk0341_a010_map  機器提供サービス契約一意照会マップ
	 * @throws  Exception  例外が発生した場合
	 */
	private void executeEKKA0020002(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> kk0341_a010_map ) throws Exception {

		/** 事前準備 */
		HashMap<String, Object> paramMap = (HashMap<String, Object>)( param.getData(fixedText) );
		HashMap<String, Object> reqMap;
		Map<?, ?> resMap;

		// 取得済の場合、処理しない
		if (paramMap.containsKey(JKKAdInfChgConstCC.PARAM_KEY_ITENS_PLACE_NO))
		{
			return ;
		}
		
		// 住所変更登録コモンコンポーネントマッピングクラスインスタンス
		JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();
		// SCリクエストInvokerを取得
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		// ■ EKKA0020002 設置場所番号取得
		// place_map生成
		HashMap<String, Object> place_meisai_map = new HashMap<String, Object>();
		ArrayList<HashMap<String, Object>> place_meisai_list = new ArrayList<HashMap<String, Object>>();

		// 場所住所コード
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_AD_CD, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_AD_CD ) );
		// 場所郵便番号
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_PCD, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_PCD ) );
		// 場所都道府県名
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_STATE_NM, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_STATE_NM ) );
		// 場所市区町村名
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_CITY_NM, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_CITY_NM ) );
		// 場所大字通称名
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_OAZTSU_NM, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_OAZTSU_NM ) );
		// 場所字丁目名
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_AZCHO_NM, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_AZCHO_NM ) );
		// 場所番地号
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_BNCHIGO, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_BNCHIGO ) );
		// 場所住所補記・建物名
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_ADRTTM, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_ADRTTM ) );
		// 場所住所補記・部屋番号
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_ADRRM, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_STC_SAKI_ADRRM ) );
		// 設置場所住所手動入力フラグ
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_AD_MAN_INPUT_FLG, getMapString( kk0341_a010_map, EKKA0020002CBSMsg1List.KEY_SETPLACE_AD_MAN_INPUT_FLG ) );
		place_meisai_list.add(place_meisai_map);

		reqMap = mapper.setEKKA0020002( param, fixedText, place_meisai_list );
		resMap = scCall.run( reqMap, handle );
		ArrayList<HashMap<String, Object>> ekka002_0002_map_list = mapper.getEKKA0020002( param, fixedText, resMap );
		mapper.scResultCheck( param );

		// 場所番号の引継
		if (ekka002_0002_map_list.isEmpty()) {
			// ■取得件数が0件の場合
			//   引継情報無しの為、以下の処理は行わない。
			return;
		}

		// ■取得件数が1件以上の場合
		//   EKKA0020002 設置場所番号取得にて取得した場所番号を引継情報として設定
		HashMap<String, Object> place_ret_map = ekka002_0002_map_list.get(0);
		paramMap.put( JKKAdInfChgConstCC.PARAM_KEY_ITENS_PLACE_NO, (String) place_ret_map.get( EKKA0020002CBSMsg2List.SETPLACE_NO ) );
	}

	/**
	 * 転居先場所情報の登録.
	 * <br>
	 * @param   param      モデルグループ、コントロールマップを含むリクエストパラメータ
	 * @param   fixedText  ユーザ任意文字列
	 * @param   kk0341_a010_map  機器提供サービス契約一意照会マップ
	 * @throws  Exception  例外が発生した場合
	 */
	private String executeEKKA0020002_Kaisen(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> kk0251_a010_map ) throws Exception {

		/** 事前準備 */
		HashMap<String, Object> paramMap = (HashMap<String, Object>)( param.getData(fixedText) );
		HashMap<String, Object> reqMap;
		Map<?, ?> resMap;

		// 住所変更登録コモンコンポーネントマッピングクラスインスタンス
		JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();
		// SCリクエストInvokerを取得
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		// ■ EKKA0020002 設置場所番号取得
		// place_map生成
		HashMap<String, Object> place_meisai_map = new HashMap<String, Object>();
		ArrayList<HashMap<String, Object>> place_meisai_list = new ArrayList<HashMap<String, Object>>();

		// 場所住所コード
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_AD_CD, getMapString( kk0251_a010_map,EKK0251A010CBSMsg1List.KAISEN_PLACE_AD_CD) );
		// 場所郵便番号
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_PCD, getMapString( kk0251_a010_map, EKK0251A010CBSMsg1List.KAISEN_PLACE_PCD) );
		// 場所都道府県名
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_STATE_NM, getMapString( kk0251_a010_map, EKK0251A010CBSMsg1List.KAISEN_PLACE_STATE_NM ) );
		// 場所市区町村名
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_CITY_NM, getMapString( kk0251_a010_map, EKK0251A010CBSMsg1List.KAISEN_PLACE_CITY_NM ) );
		// 場所大字通称名
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_OAZTSU_NM, getMapString( kk0251_a010_map, EKK0251A010CBSMsg1List.KAISEN_PLACE_OAZTSU_NM ) );
		// 場所字丁目名
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_AZCHO_NM, getMapString( kk0251_a010_map, EKK0251A010CBSMsg1List.KAISEN_PLACE_AZCHO_NM ) );
		// 場所番地号
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_BNCHIGO, getMapString( kk0251_a010_map, EKK0251A010CBSMsg1List.KAISEN_PLACE_BNCHIGO ) );
		// 場所住所補記・建物名
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_ADRTTM, getMapString( kk0251_a010_map, EKK0251A010CBSMsg1List.KAISEN_PLACE_ADRTTM ) );
		// 場所住所補記・部屋番号
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_ADRRM, getMapString( kk0251_a010_map, EKK0251A010CBSMsg1List.KAISEN_PLACE_ADRRM ) );
		// 設置場所住所手動入力フラグ
		place_meisai_map.put( EKKA0020002CBSMsg1List.KEY_SETPLACE_AD_MAN_INPUT_FLG, getMapString( kk0251_a010_map, EKKA0020002CBSMsg1List.KEY_SETPLACE_AD_MAN_INPUT_FLG ) );
		place_meisai_list.add(place_meisai_map);

		reqMap = mapper.setEKKA0020002( param, fixedText, place_meisai_list );
		resMap = scCall.run( reqMap, handle );
		ArrayList<HashMap<String, Object>> ekka002_0002_map_list = mapper.getEKKA0020002( param, fixedText, resMap );
		mapper.scResultCheck( param );

		// 場所番号の引継
		if (ekka002_0002_map_list.isEmpty()) {
			// ■取得件数が0件の場合
			//   引継情報無しの為、以下の処理は行わない。
			return "";
		}

		// ■取得件数が1件以上の場合
		//   EKKA0020002 設置場所番号取得にて取得した場所番号を引継情報として設定
		HashMap<String, Object> place_ret_map = ekka002_0002_map_list.get(0);
		return (String) place_ret_map.get( EKKA0020002CBSMsg2List.SETPLACE_NO );
	}

	/**
	 * 宅内機器一意照会（４）.
	 * <br>
	 * @param   param      モデルグループ、コントロールマップを含むリクエストパラメータ
	 * @param   fixedText  ユーザ任意文字列
	 * @param   kk0341_a010_map  機器提供サービス契約一意照会マップ
	 * @throws  Exception  例外が発生した場合
	 */
	private String executeEKKA0020003(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> kk0341_a010_map ) throws Exception
	{
		/** 事前準備 */
		HashMap<String, Object> paramMap = (HashMap<String, Object>)( param.getData(fixedText) );
		HashMap<String, Object> reqMap;
		Map<?, ?> resMap;
		
		// 住所変更登録コモンコンポーネントマッピングクラスインスタンス
		JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();
		// SCリクエストInvokerを取得
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// ■ EKKA0020003 宅内機器一意照会（４）
		// place_map生成
		HashMap<String, Object> kka002_0003_meisai_map = new HashMap<String, Object>();
		ArrayList<HashMap<String, Object>> kka002_0003_meisai_list = new ArrayList<HashMap<String, Object>>();
		
		// ＫＥＹ＿宅内機器型式コード
		kka002_0003_meisai_map.put( EKKA0020003CBSMsg1List.KEY_TK_MDL_CD, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD ));
		// ＫＥＹ＿機器製造番号
		kka002_0003_meisai_map.put( EKKA0020003CBSMsg1List.KEY_KK_SEIZO_NO, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_SEIZO_NO ));
		kka002_0003_meisai_list.add(kka002_0003_meisai_map);
		
		// 宅内機器一意照会（４）
		reqMap = mapper.setEKKA0020003( param, fixedText, kka002_0003_meisai_list );
		resMap = scCall.run( reqMap, handle );
		ArrayList<HashMap<String, Object>> ekka002_0003_map_list = mapper.getEKKA0020003( param, fixedText, resMap );
		mapper.scResultCheck( param );
		
		// 宅内機器基本Ｔ更新日付の取得
		if (ekka002_0003_map_list.isEmpty()) {
			// ■取得件数が0件の場合
			//   引継情報無しの為、以下の処理は行わない。
			return new String();
		}

		// ■取得件数が1件以上の場合
		//   EKKA0020003 宅内機器一意照会（４）にて取得した宅内機器基本Ｔ更新日付を返す
		HashMap<String, Object> ret_map = ekka002_0003_map_list.get(0);
		String kihont_upd_dttm = null;
		if ("A0".equals(getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD ))) {
			kihont_upd_dttm = (String) ret_map.get( EKKA0020003CBSMsg2List.STBT_UPD_DTTM );
		} else if ("B0".equals(getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD ))
				|| "C0".equals(getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD ))) {
			kihont_upd_dttm = (String) ret_map.get( EKKA0020003CBSMsg2List.CAST_UPD_DTTM );
		} else {
			kihont_upd_dttm = (String) ret_map.get( EKKA0020003CBSMsg2List.KIHONT_UPD_DTTM );
		}
		return kihont_upd_dttm;
	}

	/**
	 * 宅内機器管理システムへの連携.
	 * <br>
	 * @param   param      モデルグループ、コントロールマップを含むリクエストパラメータ
	 * @param   fixedText  ユーザ任意文字列
	 * @param   kk0341_a010_map  機器提供サービス契約一意照会マップ
	 * @param   kihontUpdDttm 宅内基本Ｔ更新日付
	 * @throws  Exception  例外が発生した場合
	 */
	private void executeEKKA0020004(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> kk0341_a010_map, String svc_kei_no, String kihontUpdDttm ) throws Exception
	{
		/** 事前準備 */
		HashMap<String, Object> paramMap = (HashMap<String, Object>)( param.getData(fixedText) );
		HashMap<String, Object> reqMap;
		Map<?, ?> resMap;

		// 住所変更登録コモンコンポーネントマッピングクラスインスタンス
		JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();
		// SCリクエストInvokerを取得
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// ■ EKKA0020004 機器場所番号変更（宅内連携）
		// place_map生成
		HashMap<String, Object> kka002_0004_meisai_map = new HashMap<String, Object>();
		ArrayList<HashMap<String, Object>> kka002_0004_meisai_list = new ArrayList<HashMap<String, Object>>();
		
		// ＫＥＹ＿宅内機器型式コード
		kka002_0004_meisai_map.put( EKKA0020004CBSMsg1List.KEY_TK_MDL_CD, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD ) );
		// ＫＥＹ＿機器製造番号
		kka002_0004_meisai_map.put( EKKA0020004CBSMsg1List.KEY_KK_SEIZO_NO, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_SEIZO_NO ) );
		// ＫＥＹ＿変更理由コード（1：場所番号変更）
		kka002_0004_meisai_map.put( EKKA0020004CBSMsg1List.KEY_CHG_RSN_CD, "1" );
		// ＫＥＹ＿宅内機器基本Ｔ更新日付
		kka002_0004_meisai_map.put( EKKA0020004CBSMsg1List.KEY_BTRY_UPD_DTTM, kihontUpdDttm );
		// 設置場所番号
		kka002_0004_meisai_map.put( EKKA0020004CBSMsg1List.SETPLACE_NO, getMapString( paramMap, JKKAdInfChgConstCC.PARAM_KEY_ITENS_PLACE_NO ) );
		// サービス契約番号
		kka002_0004_meisai_map.put( EKKA0020004CBSMsg1List.SVC_KEI_NO, svc_kei_no );
		kka002_0004_meisai_list.add(kka002_0004_meisai_map);
	
		// 機器場所番号変更(宅内連携）
		reqMap = mapper.setEKKA0020004( param, fixedText, kka002_0004_meisai_list );
		resMap = scCall.run( reqMap, handle );
		ArrayList<HashMap<String, Object>> ekka002_0004_map = mapper.getEKKA0020004( param, fixedText, resMap );
		mapper.scResultCheck( param );
	}

	/**
	 * パラメータ取得(HashMap).
	 * <br>
	 * @param  targetMap  取得元マップ
	 * @param  targetKey  取得元キー項目
	 * @return 取得文字列
	 */
	private String getMapString( HashMap targetMap, String targetKey ) {
		String resultStr = new String();

		if ( targetMap != null ) {
			if ( ( targetKey != null ) && ( !"".equals( targetKey ) ) ) {
				if ( targetMap.containsKey( targetKey ) ) {
					resultStr = (String) targetMap.get(targetKey);
				}
			}
		}
		return resultStr;
	}
	
	/**
	 * 場所番号連携対象機器ワークへの登録
	 * <br>
	 * @param   param      モデルグループ、コントロールマップを含むリクエストパラメータ
	 * @param   fixedText  ユーザ任意文字列
	 * @param   kk0341_a010_map  機器提供サービス契約一意照会マップ
	 * @throws  Exception  例外が発生した場合
	 */
	private void executeEKK2401D010(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> kk0341_a010_map, String svc_kei_no ) throws Exception
	{
		/** 事前準備 */
		HashMap<String, Object> paramMap = (HashMap<String, Object>)( param.getData(fixedText) );
		HashMap<String, Object> reqMap;
		Map<?, ?> resMap;

		// 住所変更登録コモンコンポーネントマッピングクラスインスタンス
		JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();
		// SCリクエストInvokerを取得
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// ■ EKK2401D010 場所番号連携対象機器ワーク登録
		// place_map生成
		HashMap<String, String> kk2401_d010_meisai_map = new HashMap<String, String>();
		
		// サービス契約番号
		kk2401_d010_meisai_map.put( EKK2401D010CBSMsg.SVC_KEI_NO, svc_kei_no );
		// 機器提供サービス契約番号
		kk2401_d010_meisai_map.put( EKK2401D010CBSMsg.KKTK_SVC_KEI_NO, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KKTK_SVC_KEI_NO ) );
		// 機器変更番号
		kk2401_d010_meisai_map.put( EKK2401D010CBSMsg.KIKI_CHG_NO, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.KIKI_CHG_NO ) );
		// 場所番号
		kk2401_d010_meisai_map.put( EKK2401D010CBSMsg.PLACE_NO, getMapString( paramMap, JKKAdInfChgConstCC.PARAM_KEY_ITENS_PLACE_NO ) );
		// 工事案件番号
		//kk2401_d010_meisai_map.put( EKK2401D010CBSMsg.KOJIAK_NO, "" );
		// 場所番号連携条件種別コード
		kk2401_d010_meisai_map.put( EKK2401D010CBSMsg.PLACE_NO_RNK_JKN_SBT_CD, "2" );
		// 場所番号連携状態コード
		kk2401_d010_meisai_map.put( EKK2401D010CBSMsg.PLACE_NO_RNK_STAT_CD, "1" );
	
		// 場所番号連携対象機器ワーク登録
		reqMap = mapper.setEKK2401D010( param, fixedText, kk2401_d010_meisai_map );
		resMap = scCall.run( reqMap, handle );
		HashMap<String, Object> kk2401_d010_map = mapper.getEKK2401D010( param, fixedText, resMap );
		mapper.scResultCheck( param );
	}
	
	/**
	 *  宅内機器型式一意照会から製造番号有無を返却する
	 * <br>
	 * @param   param      モデルグループ、コントロールマップを含むリクエストパラメータ
	 * @param   fixedText  ユーザ任意文字列
	 * @param   kk0341_a010_map  機器提供サービス契約一意照会マップ
	 * @throws  Exception  例外が発生した場合
	 */
	private String executeEZM0411A010(SessionHandle handle, IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> kk0341_a010_map ) throws Exception
	{
		/** 事前準備 */
		HashMap<String, Object> reqMap;
		Map<?, ?> resMap;

		// 住所変更登録コモンコンポーネントマッピングクラスインスタンス
		JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();
		
		// SCリクエストInvokerを取得
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		
		// ■ EZM0411A010  宅内機器型式一意照会
		// place_map生成
		HashMap<String, String> zm0411_a010_meisai_map = new HashMap<String, String>();
		
		// 機器提供サービス契約番号
		zm0411_a010_meisai_map.put( EZM0411A010CBSMsg.KEY_TAKNKIKI_MODEL_CD, getMapString( kk0341_a010_map, EKK0341A010CBSMsg1List.TAKNKIKI_MODEL_CD) );
	
		//  宅内機器型式一意照会
		reqMap = mapper.setEZM0411A010( param, fixedText, zm0411_a010_meisai_map );
		resMap = scCall.run( reqMap, handle );
		ArrayList<HashMap<String, Object>> zm0411_a010_lst = mapper.getEZM0411A010( param, fixedText, resMap );
		mapper.scResultCheck( param );
		
		// 製造番号有無の取得
		if (zm0411_a010_lst == null || zm0411_a010_lst.isEmpty()) {
			// ■取得件数が0件の場合
			//   紹介結果無しの為、以下の処理は行わない。
			return new String();
		}

		// ■取得件数が1件以上の場合
		//   EZM0411A010 宅内機器型式一意照会から取得した製造番号有無を返却
		HashMap<String, Object> ret_map = zm0411_a010_lst.get(0);
		String seizou_no_umu = (String) ret_map.get( EZM0411A010CBSMsg1List.SEIZO_NO_UM );

		return seizou_no_umu;
	}
	
	/**
	 * オブジェクトを比較して同じものか判定する
	 * @param param1
	 * @param param2
	 * @return
	 */
	private boolean isSameObj(Object param1, Object param2)
	{
		if (param1 == null) param1 = "";
		if (param2 == null) param2 = "";
		
		return param1.equals(param2);
	}

	/**
	 * 回線内訳更新の進捗の特記事項を作成する
	 * <br>
	 * @param kk0251_a010_map
	 * @param updateMap
	 * @return
	 */
	private HashMap<String, Object> createPrgTokkiMapKaisen(HashMap<String, Object> kk0251_a010_map, HashMap<String, Object> updateMap)
	{
		HashMap<String, Object> prgMap = new HashMap<String, Object>();
		String prg_tkjk = "";
		String prg_tkjk2 = "";
		
		// 進捗.特記事項編集対象 郵便番号	
		if (!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_PCD), updateMap.get( PARAM_AD_PCD ))) 
		{
			// 進捗の特記事項に郵便番号変更前情報を設定
			// 編集形式：固定文言（変更前○○:）+ 変更前DB値 + 固定文言（、）
			prg_tkjk = prg_tkjk + PCG_RIYOBASHO_PCD_TEXT + (String)kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_PCD) + PCG_KUTEN_CANMA;
			prg_tkjk2 = prg_tkjk2 + PCG_RIYOBASHO_PCD_TEXT_AF + (String)updateMap.get( PARAM_AD_PCD ) + PCG_KUTEN_CANMA;
		}
		
		// 利用場所住所に一項目えも変更があれば、住所全体を設定
		if (
				!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_CITY_NM), updateMap.get( PARAM_AD_STATE_NM )) 
			||	!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_CITY_NM), updateMap.get( PARAM_AD_CITY_NM )) 
			||	!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_OAZTSU_NM), updateMap.get( PARAM_AD_OAZTSU_NM )) 
			||	!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_AZCHO_NM), updateMap.get( PARAM_AD_AZCHO_NM )) 
			||	!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_BNCHIGO), updateMap.get( PARAM_AD_BNCHIGO )) 
			||	!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_ADRTTM), updateMap.get( PARAM_AD_ADRTTM )) 
			||	!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_ADRRM), updateMap.get( PARAM_AD_ADRRM )) 
			)
		{
			// 進捗の特記事項に郵便番号変更前情報を設定
			// 編集形式：固定文言（変更前○○:）+ 変更前DB値 + 固定文言（、）
			prg_tkjk = prg_tkjk + PCG_RIYOBASHO_AD_TEXT
			                    + (String)kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_STATE_NM)
			                    + (String)kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_CITY_NM)
			                    + (String)kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_OAZTSU_NM)
			                    + (String)kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_AZCHO_NM)
			                    + (String)kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_BNCHIGO)
			                    + (String)kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_ADRTTM)
			                    + (String)kk0251_a010_map.get(EKK0251A010CBSMsg1List.KAISEN_PLACE_ADRRM)
			                    + PCG_KUTEN_CANMA;
			prg_tkjk2 = prg_tkjk2 + PCG_RIYOBASHO_AD_TEXT_AF
								+ (String)updateMap.get( PARAM_AD_STATE_NM )
								+ (String)updateMap.get( PARAM_AD_CITY_NM )
								+ (String)updateMap.get( PARAM_AD_OAZTSU_NM )
								+ (String)updateMap.get( PARAM_AD_AZCHO_NM )
								+ (String)updateMap.get( PARAM_AD_BNCHIGO )
								+ (String)updateMap.get( PARAM_AD_ADRTTM )
								+ (String)updateMap.get( PARAM_AD_ADRRM )
								+ PCG_KUTEN_CANMA;
		}
		
		// 住所未確定
		if (!isSameObj(kk0251_a010_map.get(EKK0251A010CBSMsg1List.KISN_PLC_AD_MI_FIX_FLG), updateMap.get(KISN_PLC_AD_MI_FIX_FLG )))
		{
			// 進捗.特記事項編集対象 
			// 空白の場合はそのまま
			if ((String)kk0251_a010_map.get(EKK0251A010CBSMsg1List.KISN_PLC_AD_MI_FIX_FLG) == null 
					|| "".equals((String)kk0251_a010_map.get(EKK0251A010CBSMsg1List.KISN_PLC_AD_MI_FIX_FLG))) {
				prg_tkjk = prg_tkjk + PCG_RIYOBASHO_AD_MI_FIX_TEXT + (String)kk0251_a010_map.get(EKK0251A010CBSMsg1List.KISN_PLC_AD_MI_FIX_FLG) + PCG_KUTEN_CANMA;
			}
			else if ("0".equals((String)kk0251_a010_map.get(EKK0251A010CBSMsg1List.KISN_PLC_AD_MI_FIX_FLG))) {
				prg_tkjk = prg_tkjk + PCG_RIYOBASHO_AD_MI_FIX_TEXT + PCG_RIYOBASHO_AD_FIX_FLG + PCG_KUTEN_CANMA;
			}
			else if ("1".equals((String)kk0251_a010_map.get(EKK0251A010CBSMsg1List.KISN_PLC_AD_MI_FIX_FLG))) {
				prg_tkjk = prg_tkjk + PCG_RIYOBASHO_AD_MI_FIX_TEXT + PCG_RIYOBASHO_AD_MI_FIX_FLG + PCG_KUTEN_CANMA;
			}
		}
		
		// 文字列のサイズにより内容を調節する。
		int prg_tkjk_length = prg_tkjk.length();
		if (prg_tkjk != null && !"".equals(prg_tkjk) && prg_tkjk_length > 0) 
		{
			String prg_tkjk_getalue = prg_tkjk.substring(0, prg_tkjk_length-1);
			// 最後の文字を除いた編集分を再度代入
			prg_tkjk = prg_tkjk_getalue;
			// 特記事項の長さが256文字以上の場合、部分抽出を行う
			if (prg_tkjk_length-1 > PRG_TKJK_MAX_VALUE) 
			{
				String prg_tkjk_select = prg_tkjk.substring(0, PRG_TKJK_MAX_VALUE);
				// 256文字までの文字列を抽出して、最後進捗文言の変数に代入
				prg_tkjk = prg_tkjk_select;
			}
		}
		int prg_tkjk2_length = prg_tkjk2.length();
		if (prg_tkjk2 != null && !"".equals(prg_tkjk2) && prg_tkjk2_length > 0) 
		{
			String prg_tkjk2_getalue = prg_tkjk2.substring(0, prg_tkjk2_length-1);
			// 最後の文字を除いた編集分を再度代入
			prg_tkjk2 = prg_tkjk2_getalue;
			// 特記事項の長さが256文字以上の場合、部分抽出を行う
			if (prg_tkjk2_length-1 > PRG_TKJK_MAX_VALUE) 
			{
				String prg_tkjk2_select = prg_tkjk2.substring(0, PRG_TKJK_MAX_VALUE);
				// 256文字までの文字列を抽出して、最後進捗文言の変数に代入
				prg_tkjk2 = prg_tkjk2_select;
			}
		}
		// マップに特記事項を設定
		prgMap.put( EKK1091D010CBSMsg.PRG_TKJK_1, prg_tkjk );
		prgMap.put( EKK1091D010CBSMsg.PRG_TKJK_2, prg_tkjk2 );

		return prgMap;
	}

	/**
	 * 緊急通報先住所の進捗の特記事項を作成する
	 * <br>
	 * @param kk0191_a010_map
	 * @param updateMap
	 * @return
	 */
	private HashMap<String, Object> createPrgTokkiMapEmgAd(HashMap<String, Object> kk0191_a010_map, HashMap<String, Object> updateMap)
	{
		HashMap<String, Object> prgMap = new HashMap<String, Object>();
		String prg_tkjk_e040 = "";
		String prg_tkjk2_e040 = "";
		

		// ・サービス契約内訳＜eo光電話＞

		
		// 緊急通報用補正郵便番号
		if (!isSameObj(kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_HOSEI_PCD), updateMap.get( PARAM_AD_PCD )))
		{
			// 進捗.特記事項編集対象 
			prg_tkjk_e040 = prg_tkjk_e040 + PCG_RIYOBASHO_PCD_TEXT + (String)kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_HOSEI_PCD) + PCG_KUTEN_CANMA;
			prg_tkjk2_e040 = prg_tkjk2_e040 + PCG_RIYOBASHO_PCD_TEXT_AF + (String)updateMap.get( PARAM_AD_PCD ) + PCG_KUTEN_CANMA;
		}
		
		// 住所項目に１項目でも変更が発生した場合、全項目を設定する
		if (
				!isSameObj(kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_STATE_NM), updateMap.get( PARAM_AD_STATE_NM ))
			||	!isSameObj(kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_CITY_NM), updateMap.get( PARAM_AD_CITY_NM ))
			||	!isSameObj(kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_OAZTSU_NM), updateMap.get( PARAM_AD_OAZTSU_NM ))
			||	!isSameObj(kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_AZCHO_NM), updateMap.get( PARAM_AD_AZCHO_NM ))
			||	!isSameObj(kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_BNCHIGO), updateMap.get( PARAM_AD_BNCHIGO ))
			||	!isSameObj(kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_ADRTTM), updateMap.get( PARAM_AD_ADRTTM ))
			||	!isSameObj(kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_ADRRM), updateMap.get( PARAM_AD_ADRRM ))
			)
		{
			// 住所全項目
			prg_tkjk_e040 = prg_tkjk_e040 + PCG_RIYOBASHO_AD_TEXT 
			                + (String)kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_STATE_NM) 
			                + (String)kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_CITY_NM) 
			                + (String)kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_OAZTSU_NM) 
			                + (String)kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_AZCHO_NM) 
			                + (String)kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_BNCHIGO) 
			                + (String)kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_ADRTTM) 
			                + (String)kk0191_a010_map.get(EKK0191A010CBSMsg1List.EMG_ADRRM) 
			                + PCG_KUTEN_CANMA;
			prg_tkjk2_e040 = prg_tkjk2_e040 + PCG_RIYOBASHO_AD_TEXT_AF
						+ (String)updateMap.get( PARAM_AD_STATE_NM )
						+ (String)updateMap.get( PARAM_AD_CITY_NM )
						+ (String)updateMap.get( PARAM_AD_OAZTSU_NM )
						+ (String)updateMap.get( PARAM_AD_AZCHO_NM )
						+ (String)updateMap.get( PARAM_AD_BNCHIGO )
						+ (String)updateMap.get( PARAM_AD_ADRTTM )
						+ (String)updateMap.get( PARAM_AD_ADRRM )
						+ PCG_KUTEN_CANMA;
		}
		
		// 進捗.特記事項の最終編集を行う
		// スキーマの制限により、特記事項の文字列数を256文字まで許可する
		// 特記事項の最後のカンマ句点を消す（最後の文字を除いた部分を抽出）
		int prg_tkjk_length = prg_tkjk_e040.length();
		if (prg_tkjk_e040 != null && !"".equals(prg_tkjk_e040) && prg_tkjk_length > 0) 
		{
			String prg_tkjk_getalue = prg_tkjk_e040.substring(0, prg_tkjk_length-1);
			// 最後の文字を除いた編集分を再度代入
			prg_tkjk_e040 = prg_tkjk_getalue;
			// 特記事項の長さが256文字以上の場合、部分抽出を行う
			if (prg_tkjk_length-1 > PRG_TKJK_MAX_VALUE) 
			{
				String prg_tkjk_select = prg_tkjk_e040.substring(0, PRG_TKJK_MAX_VALUE);
				// 256文字までの文字列を抽出して、最後進捗文言の変数に代入
				prg_tkjk_e040 = prg_tkjk_select;
			}
		}
		int prg_tkjk2_length = prg_tkjk2_e040.length();
		if (prg_tkjk2_e040 != null && !"".equals(prg_tkjk2_e040) && prg_tkjk2_length > 0) 
		{
			String prg_tkjk2_getalue = prg_tkjk2_e040.substring(0, prg_tkjk2_length-1);
			// 最後の文字を除いた編集分を再度代入
			prg_tkjk2_e040 = prg_tkjk2_getalue;
			// 特記事項の長さが256文字以上の場合、部分抽出を行う
			if (prg_tkjk2_length-1 > PRG_TKJK_MAX_VALUE) 
			{
				String prg_tkjk2_select = prg_tkjk2_e040.substring(0, PRG_TKJK_MAX_VALUE);
				// 256文字までの文字列を抽出して、最後進捗文言の変数に代入
				prg_tkjk2_e040 = prg_tkjk2_select;
			}
		}
		
		// 進捗の特記事項を設定する
		prgMap.put( EKK1091D010CBSMsg.PRG_TKJK_1, prg_tkjk_e040 );
		prgMap.put( EKK1091D010CBSMsg.PRG_TKJK_2, prg_tkjk2_e040 );
		
		return prgMap;
	}
	
	/** 工事案件のキーワード */
	private static final String FIXED_TEXT_EXECUTE_KOJI_ANKEN = "fixed_text_kojiak_used_place_upd";

	/**
	 * 住所変更に伴う諸変更処理
	 * <br>
	 * @param handle
	 * @param request
	 * @param fixedText
	 */
	@SuppressWarnings("unchecked")
	private void variousChange(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable 
	{
		JKKUsePlaceAdKojiChgCC kojiChgCC = new JKKUsePlaceAdKojiChgCC();
		
		// 実行
		kojiChgCC.execute(handle, param, fixedText);
		
	}

//	/**
//	 * 住所変更に伴う諸変更処理
//	 * <br>
//	 * @param handle
//	 * @param request
//	 * @param fixedText
//	 */
//	@SuppressWarnings("unchecked")
//	private void variousChange2(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable 
//	{
//		
//		HashMap<String, Object> paramMap = (HashMap<String, Object>)param.getData(fixedText);
//
//		List<HashMap<String, Object>> svc_kei_list = (List<HashMap<String, Object>>)paramMap.get(SVC_KEI_LIST);
//		HashMap<String, String> condMap = new HashMap<String, String>();
//		HashMap<String, Object> reqMap;
//		Map<?, ?> resMap;
//		
//		for (HashMap<String, Object> kk0081_a010_map : svc_kei_list) 
//		{
//			// 工事案件をスキップするか判定する
//			if (kk0081_a010_map.containsKey(KOJIAK_SKIP_FLG))
//			{
//				continue;
//			}
//			
//			// サービス契約番号
//			String svcKeiNo = (String)kk0081_a010_map.get(EKK0081A010CBSMsg1List.SVC_KEI_NO);
//			String sysid = (String)kk0081_a010_map.get(EKK0081A010CBSMsg1List.SYSID);
//			HashMap<String, Object> kojiAkParam = new HashMap<String, Object>();
//			
//			// 共通情報のマッピング
//			kojiAkParam.put("func_code", paramMap.get(JKKAdInfChgConstCC.PARAM_KEY_FUNC_CD));
//			// "070:内容変更" → 工事案件CCマップ.工事受付コード
//			kojiAkParam.put("koji_uk_cd", "070");
//			// "A4:回線情報変える" → 工事案件CCマップ.工事受付詳細コード
//			kojiAkParam.put("koji_uk_dtl_cd", "A4");
//			// ＳＹＳＩＤ → 工事案件CCマップ.SYSID
//			kojiAkParam.put("sysid", sysid);
//			// 変更後_利用場所住所_サービス契約番号 → 工事案件CCマップ.サービス契約番号
//			kojiAkParam.put("svc_kei_no", svcKeiNo);
//			// 初期化
//			kojiAkParam.put("mskm_no", "");
//			kojiAkParam.put("mskm_dtl_no", "");
//			
//			// 連携すべき工事案件かチェックする
//			if (!doesKojiAkOfSvcKeiNoExist(handle, param, "EKU0011B030", svcKeiNo)) {
//				continue;
//			}
//			
//			// 申込明細番号をセットする
//			if (!JKKStringUtil.isNullBlank((String)paramMap.get(JKKAdInfChgConstCC.PARAM_KEY_MSKM_NO)))
//			{
//				kojiAkParam.put("mskm_no", paramMap.get(JKKAdInfChgConstCC.PARAM_KEY_MSKM_NO));
//			}
//			
//			// 申込明細番号をセットする
//			if (!JKKStringUtil.isNullBlank((String)paramMap.get(JKKAdInfChgConstCC.PARAM_KEY_MSKM_DTL_NO)))
//			{
//				kojiAkParam.put("mskm_dtl_no", paramMap.get(JKKAdInfChgConstCC.PARAM_KEY_MSKM_DTL_NO));
//			}
//			
//			// 工事案件ＣＣ呼出
//			JKKKojiAnkenCC kojiAnkenCC = new JKKKojiAnkenCC();
//			param.setData(FIXED_TEXT_EXECUTE_KOJI_ANKEN, kojiAkParam);
//			kojiAnkenCC.executeKojiAnken(handle, param, FIXED_TEXT_EXECUTE_KOJI_ANKEN);
//			param.removeData(FIXED_TEXT_EXECUTE_KOJI_ANKEN);
//			
//			// ---------------------------------------------------------------
//			// 進捗を登録する
//			// ---------------------------------------------------------------
//			JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();
//			ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
//			
//			// サービス契約ステータスの取得
//			String svcKeiStat = getMapString( kk0081_a010_map, EKK0081A010CBSMsg1List.SVC_KEI_STAT );
//			
//			// 異動区分の取得を行う
//			String idoDiv = getMapString( kk0081_a010_map, EKK0081A010CBSMsg1List.IDO_DIV );
//			String idoDtm = new String();
//			
//			if (JKKSvcConst.SVC_KEI_STAT_010.equals(svcKeiStat)) 
//			{
//				// 進捗の一覧照会
//				condMap.clear();
//				condMap.put( "key_svc_kei_no", svcKeiNo );
//				reqMap = mapper.setEKK1091B001( param, fixedText, condMap );
//				resMap = scCall.run( reqMap, handle );
//				HashMap<String, Object> kk1091_a010_map = mapper.getEKK1091B001( param, fixedText, resMap );
//				mapper.scResultCheck( param );
//				
//				idoDtm = getMapString( kk1091_a010_map, EKK1091B001CBSMsg1List.IDO_DTM );
//			}
//			
//			HashMap<String, Object> parent_map = new HashMap<String, Object>();
//			parent_map.put( EKK1091D010CBSMsg.SVC_KEI_NO, svcKeiNo );
//			parent_map.put( EKK1091D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO, paramMap.get( PARAM_SVC_KEI_KAISEN_UCWK_NO ) );
//			
//			// カレントのサービス契約ステータスが受付済の場合、サービス契約の最新異動区分および異動時分秒をINパラメータに設定
//			if (JKKSvcConst.SVC_KEI_STAT_010.equals(svcKeiStat) ) 
//			{
//				parent_map.put( EKK1091D010CBSMsg.IDO_DIV, idoDiv );
//				parent_map.put( EKK1091D010CBSMsg.IDO_DTM, idoDtm);
//			}
//			// 上記条件以外の場合は異動区分「00048:住所一括更新」を設定
//			else
//			{
//				parent_map.put( EKK1091D010CBSMsg.IDO_DIV, paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_IDO_DIV ) );
//				parent_map.put( EKK1091D010CBSMsg.IDO_DTM, JCCBPCommon.getSysDateTimeStamp() );
//			}
//			parent_map.put( EKK1091D010CBSMsg.PRG_STAT, JKKAdInfChgConstCC.CD00647_E030 );
//			parent_map.put( EKK1091D010CBSMsg.PRG_TKJK_1, "" );
//			parent_map.put( EKK1091D010CBSMsg.PRG_TKJK_2, "" );
//			if(!StringUtils.isEmpty((String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_MSKM_DTL_NO )))
//			{
//				parent_map.put( EKK1091D010CBSMsg.MSKM_DTL_NO , (String)paramMap.get( JKKAdInfChgConstCC.PARAM_KEY_MSKM_DTL_NO ) );
//			}
//			
//			// ・EKK1091D010  進捗登録
//			reqMap = mapper.setEKK1091D010( param, fixedText, parent_map, getIdoRsnList( param, fixedText ) );
//			resMap = scCall.run( reqMap, handle );
//			mapper.getEKK1091D010( param, fixedText, resMap );
//			mapper.scResultCheck( param );
//		}
//	}
//	
//	/**
//	 * 工事案件更新不要チェック
//	 * <br>
//	 * @param handle
//	 * @param request
//	 * @param fixedText
//	 * @param svcKeiNo
//	 * @return
//	 * @throws Throwable
//	 */
//	private boolean doesKojiAkOfSvcKeiNoExist(SessionHandle handle, IRequestParameterReadWrite request, String fixedText, String svcKeiNo)
//	throws Throwable{
//		JKKAdInfChgMapperCC mapper = JKKAdInfChgMapperCC.getInstance();
//		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
//
//		// 工事案件の一覧照会を行う。
//		HashMap<String, String> conditionMap = new HashMap<String, String>();
//		// サービス契約番号
//		conditionMap.put("key_svc_kei_no", svcKeiNo);
//		
//		// 工事案件ステータス
//		// 120 : 登録済, 130：受付済, 140：依頼済, 150：宅内調査完了済, 160：工事会社決定済, 170：宅内機器予定登録済, 180：仮鍵開発行依頼済, 190：現場作業完了済, 200：工事完了
//		conditionMap.put("key_kojiak_stat", "120,130,140,150,160,170,180,190,200");
//		
//		// 工事案件種別コード
//		// 001：新設, 003：住所変更(新設), 008：リンクSTB, 009：プラン変更(収容替), 012：面開発
//		conditionMap.put("key_kojiak_sbt_cd", "001,003,008,009,012");
//		HashMap<String, Object> reqMap = mapper.setEKU0011B030(request, fixedText, conditionMap );
//		Map<?, ?> resMap = scCall.run( reqMap, handle );
//		ArrayList<HashMap<String, Object>> ku0011_b030_list = mapper.getEKU0011B030(request, fixedText, resMap);
//		mapper.scResultCheck(request);
//		
//		// ステータスが未完了ならエラー 200でない場合
//		if (ku0011_b030_list == null || ku0011_b030_list.size()==0) {
//			return false;
//		}
//		return true;
//	}
}