/*********************************************************************
*  All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名			：eo顧客基幹システム
*	モジュール名		：JKKJdgCC
*	ソースファイル名	：JKKJdgCC.java
*	作成者				：富士通　
*	作成日				：2011年08月23日
*＜機能概要＞
*　審査部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v1.00				成
*	v2.00		2012/05/10	FJ)伊藤		住所課題に伴うSIFパラメータ追加
*	v3.00		2012/05/30	FJ)伊藤		エリアチェックSIF変更に伴う修正
*	v3.01		2012/06/05	FJ)伊藤		ロールバック暫定対応
*	v3.02		2012/06/06	FJ)伊藤		在庫数取得修正
*	v3.03		2012/08/03	FJ)砂川		在庫数取得修正
*	v4.00		2012/06/20	FJ)伊藤		ANK-0398-00-00 住所管理追加対応
*	v4.01		2012/10/03	FJ)藤原		【IT1-2012-0001075】住所不備電話番号情報審査S-IFに設定する更新年月日はサービス契約のものに修正
*	v4.02		2012/11/01	FJ)砂川		【IT1-2012-0001726】住所不備チェックのマンション部屋番号重複チェック対応
*	v4.03		2012/11/05	FJ)砂川		【ST1-2012-0000805】緊急通報用契約者名・カナ名の最大桁数チェックを追加
*   v4.04       2012/12/06  FJ)清崎     【TAI-2012-0000091】暫定ロジック修正対応
*   v4.05       2013/01/11  FJ)清崎     【IT1-2012-0000035】異動年月日時分秒対応
*   v4.06       2013/02/13  FJ)清崎     【OT-2013-0000106】エラー確認時の排他エラー対応
*   v4.07       2013/02/27  FJ)砂川     【ST3-2013-0000040】最下層チェックレベル指定対応
*   v4.08       2013/02/28  FJ)砂川     【OT-2013-0000090】電話またはテレビでマンション物件の場合、エリアチェックの審査レコードを作成しない対応
*   v5.00       2013/03/07  FJ)清崎     【ANK-1421-00-00】IP-STB対応
*   v4.09       2013/04/03  FJ)砂川     【IT1-2013-0000551】サービス契約番号がNULLの場合でも審査を実施する対応
*   v4.10       2013/04/08  FJ)清崎     【IT1-2013-0000757】番ポから新規発番に変更時、番ポエリアチェックの審査レコード削除対応
*   v5.01       2013/05/10  FJ)砂川     【IT1-2013-0001203】eoADSL(eAccess)をタイプ1からタイプ2にコース変更した際にエリアチェックの審査レコードを削除する対応
*   v9.00       2014/06/25  FJ)米田     【ST4-2014-0000030】�@異動年月日時分秒の取得(getIdoDtmメソッド)を1回で済ませるように修正
*                                                           �A異動年月日時分秒の取得で呼び出すサービスインターフェースを変更
*   v73.00      2024/11/05  FJ)吉田あ   【ANK-4427-00-00】NTT卸対応
*********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

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

import com.fujitsu.futurity.bp.x21.bpm.ServiceComponentRequestInvoker;
import com.fujitsu.futurity.bp.x21.bpm.db.SessionHandle;
import com.fujitsu.futurity.bp.x21.bpm.exception.RequestParameterException;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadOnly;
import com.fujitsu.futurity.bp.x21.bpm.parameter.IRequestParameterReadWrite;
import com.fujitsu.futurity.bp.x21.cc.AbstractCommonComponent;
import com.fujitsu.futurity.bp.x21.cc.exception.CCException;
import com.fujitsu.futurity.common.JCMConstants;
import com.fujitsu.futurity.common.x01.sc.SCControlMapKeys;
import com.fujitsu.futurity.mapping.bp.common.TemplateErrorUtil;
import com.fujitsu.futurity.model.base.CAANMsg;
import com.fujitsu.futurity.model.common.JCMAPLConstMgr;
import com.fujitsu.futurity.model.ejb.common.JSYejbLog;
import com.fujitsu.futurity.model.ejb.common.fw.AgentDispatchContext;

import eo.common.constant.JPCModelConstant;
import eo.common.util.JPCEditString;
import eo.ejb.cbm.entity.CK0011ETMsg;
import eo.ejb.cbm.entity.CK0021ETMsg;
import eo.ejb.cbm.entity.CK0031ETMsg;
import eo.ejb.cbm.entity.KK0021ETMsg;
import eo.ejb.cbm.entity.KK0081ETMsg;
import eo.ejb.cbm.entity.KK0191ETMsg;
import eo.ejb.cbm.entity.KK0251ETMsg;
import eo.ejb.cbm.entity.KK0341ETMsg;
import eo.ejb.cbm.entity.KK0451ETMsg;
import eo.ejb.cbm.entity.KK0491ETMsg;
import eo.ejb.cbm.entity.KK0521ETMsg;
import eo.ejb.cbm.entity.KK1071ETMsg;
import eo.ejb.cbm.entity.KK0791ETMsg;
import eo.ejb.cbs.cbsmsg.ECK0011A010CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0011A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.ECK0011B006CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0011B006CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0161B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0161B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0191A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0191A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0191B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0251A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0251A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0341B009CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0491A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0491A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0861A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0861A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0871A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0871A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0881A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0881A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0891A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0891A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1071B011CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071B011CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1071C010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1071C011CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C021CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C021CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1071C021CBSMsg2List;
import eo.ejb.cbs.cbsmsg.EKK1071C031CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C041CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C041CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1071C051CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C051CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1071C061CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C071CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C081CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C081CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1071C091CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C101CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C111CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C111CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1071C121CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C131CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C131CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1071C131CBSMsg2List;
import eo.ejb.cbs.cbsmsg.EKK1071C131CBSMsg3List;
import eo.ejb.cbs.cbsmsg.EKK1071C141CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C151CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071C151CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1071D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1071E010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1091B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091B002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1841B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1841B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1981B001CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1981B001CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK1981E010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKKA0020003CBSMsg;
import eo.ejb.cbs.cbsmsg.EKKA0020003CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKKA0020003CBSMsg2List;
import eo.ejb.cbs.cbsmsg.EKKA0020005CBSMsg;
import eo.ejb.cbs.cbsmsg.EKKA0020005CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg1List;

/**
 * 審査クラス
 * @author 富士通
 */
public class JKKJdgCC extends AbstractCommonComponent
{

	/** 進捗ステータスマップ */
	private static final HashMap<String, String> PRG_STAT_MAP = new HashMap<String, String>();

	// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
	/** 住所チェックレベル住所チェックレベル：最下層住所チェックを実施する */
	private static final String AD_CHK_LV_1 = "1";
	
	/** 住所チェックレベル住所チェックレベル：最下層住所チェックを実施しない */
	private static final String AD_CHK_LV_2 = "2";
	// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
	// ▼▼▼ OT-2013-0000090 Add Start    ▼▼▼
	/** マンション物件コード：マンション */
	private static final String MANSION_BUKKEN_CD_MANSION = "001";
	
	/** サービスコード：電話 */
	private static final String SVC_CD_TEL = JKKJudgeConstCC.TEL_SVC;
	
	/** サービスコード：テレビ */
	private static final String SVC_CD_TV = JKKJudgeConstCC.TV_SVC;
	
	/** 審査種別コード：エリアチェック */
	private static final String JUDGE_SBT_CD_AREA_CHECK = JKKJudgeConstCC.JUDGE_SBT_AREA;
	// ▲▲▲ OT-2013-0000090 Add End      ▲▲▲
	
	// 20140625 ST4-2014-0000030 Add Start
	/** 異動年月日時分秒 */
	private String m_idoDtm = null;
	// 20140625 ST4-2014-0000030 Add End
	
	// ANK-4427-00-00 ADD START
	/** 料金グループコード(eo光ネットホームタイプ) */
	private static final String EOH_NET_HOME = JKKJudgeConstCC.EOH_NET_HOME;
	// ANK-4427-00-00 ADD END

	static
	{
		// 多重登録チェックでNGの場合(多重申込登録有り)
		String key = JKKJudgeConstCC.JUDGE_SBT_TAJU_ADD;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_TAJU_MSKM_ARI);
		
		// 住所不備チェック−サービス契約情報でOKの場合(住所エラーチェックＯＫ−サービス設定)
		key = JKKJudgeConstCC.JUDGE_SBT_AD_HBI_SVC_KEI + JKKJudgeConstCC.RSLT_OK;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_AD_SVC_OK);
		
		// 住所不備チェック−サービス契約情報でNGの場合(住所エラーチェックＮＧ−サービス設定)
		key = JKKJudgeConstCC.JUDGE_SBT_AD_HBI_SVC_KEI;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_AD_SVC_NG);
		
		// 記載不備チェック−サービス契約情報でOKの場合(記載不備チェックＯＫ−サービス設定)
		key = JKKJudgeConstCC.JUDGE_SBT_KS_HBI_SVC_KEI + JKKJudgeConstCC.RSLT_OK;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_KS_SVC_OK);
		
		// 記載不備チェック−サービス契約情報でNGの場合(記載不備チェックＮＧ−サービス設定)
		key = JKKJudgeConstCC.JUDGE_SBT_KS_HBI_SVC_KEI;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_KS_SVC_NG);
		
		// 住所不備チェック−お客様情報でOKの場合(住所エラーチェックＯＫ−お客様情報)
		key = JKKJudgeConstCC.JUDGE_SBT_AD_HBI_CUST + JKKJudgeConstCC.RSLT_OK;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_AD_CUST_OK);
		
		// 住所不備チェック−お客様情報でNGの場合(住所エラーチェックＮＧ−お客様情報)
		key = JKKJudgeConstCC.JUDGE_SBT_AD_HBI_CUST;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_AD_CUST_NG);
		
		// 記載不備チェック−お客様情報でOKの場合(記載不備チェックＯＫ−お客様情報)
		key = JKKJudgeConstCC.JUDGE_SBT_KS_HBI_CUST + JKKJudgeConstCC.RSLT_OK;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_KS_CUST_OK);
		
		// 記載不備チェック−お客様情報でNGの場合(記載不備チェックＮＧ−お客様情報)
		key = JKKJudgeConstCC.JUDGE_SBT_KS_HBI_CUST;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_KS_CUST_NG);
		
		// 不良顧客チェックでOKの場合(不良顧客チェックＯＫ)
		key = JKKJudgeConstCC.JUDGE_SBT_HURYO_CUST + JKKJudgeConstCC.RSLT_OK;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_HURYO_CUST_OK);
		
		// 不良顧客チェックでNGの場合(不良顧客チェックＮＧ)
		key = JKKJudgeConstCC.JUDGE_SBT_HURYO_CUST;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_HURYO_CUST_NG);
		
		// 記載不備チェック−請求契約情報でOKの場合(記載不備チェックＯＫ−請求情報)
		key = JKKJudgeConstCC.JUDGE_SBT_KS_HBI_SEIKY_KEI + JKKJudgeConstCC.RSLT_OK;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_KS_SEIKY_OK);
		
		// 記載不備チェック−請求契約情報でNGの場合(記載不備チェックＮＧ−請求情報)
		key = JKKJudgeConstCC.JUDGE_SBT_KS_HBI_SEIKY_KEI;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_KS_SEIKY_NG);
		
		// 住所不備チェック−請求契約情報でOKの場合(住所エラーチェックＯＫ−請求情報)
		key = JKKJudgeConstCC.JUDGE_SBT_AD_HBI_SEIKY_KEI + JKKJudgeConstCC.RSLT_OK;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_AD_SEIKY_OK);
		
		// 住所不備チェック−請求契約情報でNGの場合(住所エラーチェックＮＧ−請求情報)
		key = JKKJudgeConstCC.JUDGE_SBT_AD_HBI_SEIKY_KEI;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_AD_SEIKY_NG);
		
		// 支払方法チェックでOKの場合(支払方法チェックＯＫ)
		key = JKKJudgeConstCC.JUDGE_SBT_PAY_WAY + JKKJudgeConstCC.RSLT_OK;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_PAY_WAY_OK);
		
		// 支払方法チェックでNGの場合(支払方法チェックＮＧ)
		key = JKKJudgeConstCC.JUDGE_SBT_PAY_WAY;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_PAY_WAY_NG);
		
		// 記載不備チェック−電話番号情報でOKの場合(記載不備チェックＯＫ−電話情報)
		key = JKKJudgeConstCC.JUDGE_SBT_KS_HBI_FOR_TEL_NO + JKKJudgeConstCC.RSLT_OK;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_KS_TEL_OK);
		
		// 記載不備チェック−電話番号情報でNGの場合(記載不備チェックＮＧ−電話情報)
		key = JKKJudgeConstCC.JUDGE_SBT_KS_HBI_FOR_TEL_NO;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_KS_TEL_NG);
		
		// 住所不備チェック−電話番号情報でOKの場合(住所不備チェックＯＫ−電話情報)
		key = JKKJudgeConstCC.JUDGE_SBT_AD_HBI_FOR_TEL_NO + JKKJudgeConstCC.RSLT_OK;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_AD_SVC_OK);
		
		// 住所不備チェック−電話番号情報でNGの場合(住所不備チェックＮＧ−電話情報)
		key = JKKJudgeConstCC.JUDGE_SBT_AD_HBI_FOR_TEL_NO;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_AD_SVC_NG);
		
		// 記載不備チェック−機器サービス契約情報でOKの場合(記載不備チェックＯＫ−機器接続情報)
		key = JKKJudgeConstCC.JUDGE_SBT_KS_HBI_KIKI_SVC_KEI + JKKJudgeConstCC.RSLT_OK;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_KS_KIKI_OK);
		
		// 記載不備チェック−機器サービス契約情報でNGの場合(記載不備チェックＮＧ−機器接続情報)
		key = JKKJudgeConstCC.JUDGE_SBT_KS_HBI_KIKI_SVC_KEI;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_KS_KIKI_NG);
		
		// 住所不備チェック−機器サービス契約情報でOKの場合(住所エラーチェックＯＫ−機器接続情報)
		key = JKKJudgeConstCC.JUDGE_SBT_AD_HBI_KIKI_SVC_KEI + JKKJudgeConstCC.RSLT_OK;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_AD_KIKI_OK);
		
		// 住所不備チェック−機器サービス契約情報でNGの場合(住所エラーチェックＮＧ−機器接続情報)
		key = JKKJudgeConstCC.JUDGE_SBT_AD_HBI_KIKI_SVC_KEI;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_AD_KIKI_NG);
		
		// 番ポエリアチェックでOKの場合(エリアチェックＯＫ)
		key = JKKJudgeConstCC.JUDGE_SBT_BMP_AREA + JKKJudgeConstCC.RSLT_OK;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_AREA_OK);
		
		// 番ポエリアチェックでNGの場合(エリアチェックＮＧ)
		key = JKKJudgeConstCC.JUDGE_SBT_BMP_AREA;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_AREA_NG);
		
		// エリアチェックでOKの場合(エリアチェックＯＫ)
		key = JKKJudgeConstCC.JUDGE_SBT_AREA + JKKJudgeConstCC.RSLT_OK;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_AREA_OK);
		
		// エリアチェックでNGの場合(エリアチェックＮＧ)
		key = JKKJudgeConstCC.JUDGE_SBT_AREA;
		PRG_STAT_MAP.put(key, JKKJudgeConstCC.PRG_STAT_AREA_NG);
	}

	
	/**
	 * 審査を実施する
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @return リクエストパラメータ
	 * @throws Throwable 
	 */
	public IRequestParameterReadWrite execute(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		// 審査情報を設定するマップ
		HashMap<String, HashMap<String, String>> jdgSetMap = new HashMap<String, HashMap<String, String>>();
		
		// サービス契約情報を取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		// お客様情報を取得
		ArrayList<HashMap<String, String>> custList = (ArrayList<HashMap<String, String>>)param.getData(CK0011ETMsg.getTableName());
		HashMap<String, String> custMap = custList.get(0);
		// 申込明細情報を取得
		ArrayList<HashMap<String, String>> mskmDtlList = (ArrayList<HashMap<String, String>>)param.getData(KK0021ETMsg.getTableName());
		HashMap<String, String> mskmDtlMap = mskmDtlList.get(0);
		
		// 20130404 IT1-2013-0000551 Add Start
		ArrayList<HashMap<String, String>> judgeNoList = new ArrayList<HashMap<String, String>>();
		// 20130404 IT1-2013-0000551 Add End

		// 20130403 IT1-2013-0000551 Add Start
		String svcKeiNo = svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO);
		
		if(null != svcKeiNo && !("".equals(svcKeiNo)))
		{
			// 申込明細情報を設定
			setMskmDtlInfo(mskmDtlMap, svcKeiMap, param, handle);
			
			// サービス契約情報を取得
			setSvcKeiOneInfo(handle, param);
		}
		else
		{
			// 申込明細情報.申込明細番号にNULLを設定
			mskmDtlMap.put(KK0021ETMsg.MSKM_DTL_NO, null);
			
			// サービス契約情報.最終更新年月日時分秒にダミー値を設定
			svcKeiMap.put(KK0081ETMsg.UPD_DTM, (String)JCCBPCommon.getOpeDate(null) + "000000000");
		}
		// 20130403 IT1-2013-0000551 Add End
		// 20130403 IT1-2013-0000551 Delete Start
//		// 申込明細情報を設定
//		setMskmDtlInfo(mskmDtlMap, svcKeiMap, param, handle);
//		
//		// サービス契約情報を取得
//		setSvcKeiOneInfo(handle, param);
		// 20130403 IT1-2013-0000551 Delete End
		
		// お客様情報を取得
		setCustOneInfo(handle, param);
		
		// 起動元機能種別を取得
		String kinoSkbt = (String)param.getData(JKKJudgeConstCC.KINO_SKBT);
		
		// 審査実施機能識別コードを設定
		String jdgJssiKinoSkbtCd = setJdgJssiKinoSkbtCd(kinoSkbt);
		
		// 料金グループコードを取得
		String prcGrpCd = JPCEditString.Rtrim(svcKeiMap.get(KK0081ETMsg.PRC_GRP_CD));
		// 料金コースコードを取得
		String pcrsCd = JPCEditString.Rtrim(svcKeiMap.get(KK0081ETMsg.PCRS_CD));
		
		// 即時フラグを取得
		String isSokuji = (String)param.getData(JKKJudgeConstCC.IS_SOKUJI);
		
		// 20130403 IT1-2013-0000551 Add Start
		HashMap<String, HashMap<String, String>> judgeMap = new HashMap<String, HashMap<String, String>>(); 
		if(null != svcKeiNo && !("".equals(svcKeiNo)))
		{
			// サービス契約番号が存在する場合、審査一覧照会を実施し、取得した結果をマップに設定する
			judgeMap = getJudgShokaiMap(svcKeiMap, param, handle);
		}
		// 20130403 IT1-2013-0000551 Add End
		
		// サービス契約から実施すると判定されたチェックが設定されたリストを取得
		ArrayList<String> svcJssiChkList = getJdgJsjkn(JKKJudgeConstCC.JDG_JSJKN_CD_0, prcGrpCd, pcrsCd, null, param, handle, judgeMap);
		
		// 起動元機能から実施すると判定されたチェックが設定されたリストを取得
		ArrayList<String> kinoJssiChkList = getKinoJssiChkList(isSokuji, kinoSkbt, pcrsCd, param, handle);
		
		// 審査の実施順が設定されたリストを取得
		ArrayList<String> jdgJunList = getWorkParam(JKKJudgeConstCC.KK_JDG_JUN, param, handle);
		
		// 20130403 IT1-2013-0000551 Delete Start
//		// 審査一覧照会を実施し、取得した結果を設定したマップ
//		HashMap<String, HashMap<String, String>> judgeMap = getJudgShokaiMap(svcKeiMap, param, handle);
		// 20130403 IT1-2013-0000551 Delete End
		
		// 料金グループより実施となった審査の登録処理
		svcJssiChkList = getChkList(svcJssiChkList, judgeMap, svcKeiMap, custMap, mskmDtlMap, param, handle, jdgSetMap, judgeNoList);
		
		// 実施チェックリストを取得
		ArrayList<String> exeChkList = getExeChkList(jdgJunList, svcJssiChkList, kinoJssiChkList, kinoSkbt, judgeMap);
		
		// 20140625 ST4-2014-0000030 Add Start
		// 異動年月日時分秒を取得
		this.m_idoDtm = getIdoDtm(svcKeiMap, param, handle);
		// 20140625 ST4-2014-0000030 Add End
		
		// 起動元機能識別が進捗登録を行う場合かつ、実施するチェックが存在し、サービス契約番号が存在する場合
		if(isPrgAdd(isSokuji, kinoSkbt) && exeChkList.size() != 0 && null != svcKeiNo && !("".equals(svcKeiNo)))
		{
			// 進捗ステータスを審査中で進捗の登録を実施
			executePrgAdd(svcKeiMap, mskmDtlMap, JKKJudgeConstCC.PRG_STAT_JDG_CHU, param, handle);
		}
		
		// 審査実施フラグ（無で初期化）
		String judgeJssiFlg = JKKJudgeConstCC.UM_CD_0;
		
		// 実施対象の審査をそれぞれ実施
		for(String jdgSbtCd : exeChkList)
		{
			// 審査詳細情報を削除
			delJdgDtl(jdgSbtCd, param, handle, jdgSetMap);
			
			// 審査を実施
			String judgeJudgeRsltCd = executeJdg(param, handle, jdgSbtCd, jdgSetMap, jdgJssiKinoSkbtCd);
			
			// 進捗ステータス
			String prgStat = null;
			// 審査の結果コードがＯＫの場合
			if(JKKJudgeConstCC.RSLT_OK.equals(judgeJudgeRsltCd))
			{
				// 審査種別コードと審査判定結果コードを連結して設定する進捗ステータスを取得
				prgStat = PRG_STAT_MAP.get(jdgSbtCd + judgeJudgeRsltCd);
			}
			// 審査の結果コードがＮＧまたは警告の場合
			else if(JKKJudgeConstCC.RSLT_NG.equals(judgeJudgeRsltCd) ||
					JKKJudgeConstCC.RSLT_EMG.equals(judgeJudgeRsltCd))
			{
				// 審査種別コードをキーに設定する進捗ステータスを取得
				prgStat = PRG_STAT_MAP.get(jdgSbtCd);
			}
			
			if(prgStat != null && null != svcKeiNo && !("".equals(svcKeiNo)))
			{
				// 進捗の登録を実施する
				executePrgAdd(svcKeiMap,  mskmDtlMap, prgStat, param, handle);
			}
			
			// 審査判定結果コードが空文字以外の場合
			if(!"".equals(judgeJudgeRsltCd))
			{
				// 審査実施フラグに有を設定
				judgeJssiFlg = JKKJudgeConstCC.UM_CD_1;
			}
		}
		
		
		// 起動元機能識別が進捗登録を行う場合かつ、実施するチェックが存在する場合
		if(isPrgAdd(isSokuji, kinoSkbt) && exeChkList.size() != 0 && null != svcKeiNo && !("".equals(svcKeiNo)))
		{
			// 審査情報の結果コードにNGが存在する場合
			if(isPrgStatNG(svcKeiMap, param, handle))
			{
				// 進捗ステータスを審査NGで進捗の登録を実施
				executePrgAdd(svcKeiMap, mskmDtlMap, JKKJudgeConstCC.PRG_STAT_JDG_NG, param, handle);
			}
			else
			{
				// 進捗ステータスを審査OKで進捗の登録を実施
				executePrgAdd(svcKeiMap, mskmDtlMap, JKKJudgeConstCC.PRG_STAT_JDG_OK, param, handle);
			}
		}
		
		
		// 審査実施フラグを設定
		param.setData(JKKJudgeConstCC.JUDGE_JSSI_FLG, judgeJssiFlg);
		
		// 20130404 IT1-2013-0000551 Add Start
		param.setData(KK1071ETMsg.getTableName(), judgeNoList);
		// 20130404 IT1-2013-0000551 Add End

		return param;
	}
	
	/**
	 * サービス契約より申込明細番号を取得し、申込明細情報に設定する処理
	 * @param mskmDtlMap 申込明細情報
	 * @param svcKeiMap サービス契約情報
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @throws Throwable 
	 */
	private void setMskmDtlInfo(HashMap<String, String> mskmDtlMap, HashMap<String, String> svcKeiMap, 
									IRequestParameterReadWrite param, SessionHandle handle) throws Throwable
	{
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		
		/* サービス契約一意照会サービスIF */
		CAANMsg svcKeiTemp = editInMsg(EKK0081A010CBSMsg.class.getName(), "EKK0081A010", "2", param);
		// サービス契約番号 → サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK0081A010CBSMsg.KEY_SVC_KEI_NO, svcKeiTemp);
		// 世代登録年月日時分秒 → 世代登録年月日時分秒
		setSvcIFMapping(null, EKK0081A010CBSMsg.KEY_GENE_ADD_DTM, svcKeiTemp);
		// 予約適用年月日 → 予約適用年月日
		setSvcIFMapping((String)JCCBPCommon.getOpeDate(null), EKK0081A010CBSMsg.KEY_RSV_APLY_YMD, svcKeiTemp);
		
		caanList.add(svcKeiTemp);
		
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0081A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg svcKeiRsltTemp = rsltCaanList.get(0);
		CAANMsg[] svcKeiRsltList = svcKeiRsltTemp.getCAANMsgList(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);
		
		if(svcKeiRsltList != null && svcKeiRsltList.length > 0)
		{
			// 申込明細番号を取得
			String mskmDtlNo = svcKeiRsltList[0].getString(EKK0081A010CBSMsg1List.MSKM_DTL_NO);
			// 申込明細番号を申込明細情報に設定
			mskmDtlMap.put(KK0021ETMsg.MSKM_DTL_NO, mskmDtlNo);
		}
		
	}
	
	/**
	 * 審査詳細削除を実施
	 * @param jdgSbtCd 審査種別コード
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @param jdgSetMap 審査情報マップ
	 * @throws Throwable 
	 */
	private void delJdgDtl(
			String jdgSbtCd, IRequestParameterReadWrite param, 
			SessionHandle handle, HashMap<String, HashMap<String, String>> jdgSetMap) throws Throwable
	{
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(jdgSbtCd);
		// 審査番号を取得
		String judgeNo = jdgInMap.get(KK1071ETMsg.JUDGE_NO);
		// 更新年月日時分秒を取得
		String updDtm = jdgInMap.get(KK1071ETMsg.UPD_DTM);
		
		// 審査詳細情報を取得
		CAANMsg[] judgeDtlArray = getJdgDtl(judgeNo, param, handle);
		
		// 審査詳細情報が取得できない場合
		if(judgeDtlArray == null)
		{
			return;
		}
		
		for(CAANMsg judgeDtlTemp : judgeDtlArray)
		{
			ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
			
			
			/* 審査詳細削除サービスIF */
			CAANMsg delJudgeDtlTemp = editInMsg(EKK1981E010CBSMsg.class.getName(), "EKK1981E010", "1", param);
			//  審査番号
			setSvcIFMapping(judgeDtlTemp.getString(EKK1981B001CBSMsg1List.JUDGE_NO), EKK1981E010CBSMsg.JUDGE_NO, delJudgeDtlTemp);
			//  審査詳細種別コード
			setSvcIFMapping(judgeDtlTemp.getString(EKK1981B001CBSMsg1List.JDG_DTL_SBT_CD), EKK1981E010CBSMsg.JDG_DTL_SBT_CD, delJudgeDtlTemp);
			//  更新年月日時分秒
			setSvcIFMapping(updDtm, EKK1981E010CBSMsg.UPD_DTM_BF, delJudgeDtlTemp);
			
			caanList.add(delJudgeDtlTemp);
			
			// サービスIFの実施
			executeSvcIF(caanList, param, handle);
		}
	}
	
	// 2013/04/08 [IT1-2013-0000757]番ポから新規発番に変更時、番ポエリアチェックの審査レコード削除対応 ADD START
	/**
	 * 審査削除を実施
	 * @param jdgSbtCd 審査種別コード
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @param jdgSetMap 審査情報マップ
	 * @throws Throwable 
	 */
	private void delJdg(
			String jdgSbtCd, IRequestParameterReadWrite param, 
			SessionHandle handle, HashMap<String, HashMap<String, String>> jdgSetMap) throws Throwable
	{
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(jdgSbtCd);
		// 審査番号を取得
		String judgeNo = jdgInMap.get(KK1071ETMsg.JUDGE_NO);
		// 更新年月日時分秒を取得
		String updDtm = jdgInMap.get(KK1071ETMsg.UPD_DTM);
		
			ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
				
			/* 審査詳細削除サービスIF */
			CAANMsg delJudgeTemp = editInMsg(EKK1071E010CBSMsg.class.getName(), "EKK1071E010", "1", param);
			//  審査番号
			setSvcIFMapping(judgeNo, EKK1071E010CBSMsg.JUDGE_NO, delJudgeTemp);
			//  更新年月日時分秒
			setSvcIFMapping(updDtm, EKK1071E010CBSMsg.UPD_DTM_BF, delJudgeTemp);
			
			caanList.add(delJudgeTemp);
			
			// サービスIFの実施
			executeSvcIF(caanList, param, handle);
		}
	// 2013/04/08 [IT1-2013-0000757]番ポから新規発番に変更時、番ポエリアチェックの審査レコード削除対応 ADD END
	
	/**
	 * 審査詳細一覧照会を実施
	 * @param judgeNo 審査番号
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @return 審査詳細一覧情報
	 * @throws Throwable 
	 */
	private CAANMsg[] getJdgDtl(String judgeNo, IRequestParameterReadWrite param, SessionHandle handle) throws Throwable
	{
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		
		/* 審査詳細一覧照会（審査番号）サービスIF */
		CAANMsg judgeDtlTemp = editInMsg(EKK1981B001CBSMsg.class.getName(), "EKK1981B001", "1", param);
		//  ＫＥＹ＿審査番号
		setSvcIFMapping(judgeNo, EKK1981B001CBSMsg.KEY_JUDGE_NO, judgeDtlTemp);
		//  ＫＥＹ＿審査詳細種別コード
		setSvcIFMapping(null, EKK1981B001CBSMsg.KEY_JDG_DTL_SBT_CD, judgeDtlTemp);
		
		caanList.add(judgeDtlTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1981B001(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg judgeRsltTemp = rsltCaanList.get(0);
		
		return judgeRsltTemp.getCAANMsgList(EKK1981B001CBSMsg.EKK1981B001CBSMSG1LIST);
		
	}
	
	/**
	 * 起動元機能から審査実施機能識別コードの特定を行う
	 * @param kinoSkbt 起動元昨日
	 * @return 審査実施機能識別コード
	 * @throws Throwable 
	 */
	private String setJdgJssiKinoSkbtCd(String kinoSkbt) throws Throwable
	{
		String jdgJssiKinoSkbtCd = "";
		
		// 起動元機能がお客様情報審査または不良顧客チェックまたは契約情報審査
		if(JKKJudgeConstCC.KIDO_MT_CUST_INFO_JUDGE.equals(kinoSkbt) ||
			JKKJudgeConstCC.KIDO_MT_HURYO_CUST_CHK.equals(kinoSkbt) ||
			JKKJudgeConstCC.KIDO_MT_KEI_INFO_JUDGE.equals(kinoSkbt))
		{
			jdgJssiKinoSkbtCd = JKKJudgeConstCC.JDG_JSSI_KINO_SKBT_BATCH;
		}
		// 自動エリアチェックまたは自動番ポエリアチェックまたは支払方法審査
		else if(JKKJudgeConstCC.KIDO_MT_AUTO_AREA_CHK.equals(kinoSkbt) ||
				JKKJudgeConstCC.KIDO_MT_AUTO_BMP_AREA_CHK.equals(kinoSkbt) ||
				JKKJudgeConstCC.KIDO_MT_PAY_WAY_JUDGE.equals(kinoSkbt)) 
		{
			jdgJssiKinoSkbtCd = JKKJudgeConstCC.JDG_JSSI_KINO_SKBT_BATCH;
		}
		// 多重登録チェックの場合
		else if(JKKJudgeConstCC.KIDO_MT_TAJU_WAY_JUDGE.equals(kinoSkbt))
		{
			jdgJssiKinoSkbtCd = JKKJudgeConstCC.JDG_JSSI_KINO_SKBT_BATCH;
		}
		// 起動元機能がの照査前登録画面−審査ボタン押下または
		// 照査前登録画面−不良顧客チェックボタン押下またはエリアチェック画面の場合
		else if(JKKJudgeConstCC.KIDO_MT_SHOSA_MAE_JDG_BTN.equals(kinoSkbt) ||
				JKKJudgeConstCC.KIDO_MT_SHOSA_MAE_HURYO_BTN.equals(kinoSkbt) ||
				JKKJudgeConstCC.KIDO_MT_AREA_CHK_SCREEN.equals(kinoSkbt))
		{
			jdgJssiKinoSkbtCd = JKKJudgeConstCC.JDG_JSSI_KINO_SKBT_WORK;
		}
		// 起動元機能がその他の場合
		else if(JKKJudgeConstCC.KIDO_MT_OTR.equals(kinoSkbt))
		{
			jdgJssiKinoSkbtCd = JKKJudgeConstCC.JDG_JSSI_KINO_SKBT_WED;
		}
		
		return jdgJssiKinoSkbtCd;
	}
	
	/**
	 * 起動元機能から進捗登録を実施するか判定を行う。
	 * @param svcKeiMap サービス契約情報
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @return 判定結果
	 * @throws Throwable 
	 */
	private boolean isPrgStatNG(HashMap<String, String> svcKeiMap, 
					IRequestParameterReadWrite param, SessionHandle handle) throws Throwable
	{
		boolean rslt = false;
		
		// 審査一覧照会を実施し、取得した結果を設定したマップ
		HashMap<String, HashMap<String, String>> judgeMap = getJudgShokaiMap(svcKeiMap, param, handle);
		Set<String> keySet = judgeMap.keySet();
		for(String key : keySet)
		{
			HashMap<String, String> inMap = judgeMap.get(key);
			
			// 結果コードがNGの場合
			if(JKKJudgeConstCC.RSLT_NG.equals(inMap.get(KK1071ETMsg.JUDGE_JUDGE_RSLT_CD)))
			{
				rslt = true;
			}
		}
		
		
		return rslt;
	}
	
	/**
	 * 起動元機能から進捗登録を実施するか判定を行う。
	 * @param isSokuji 即時フラグ
	 * @param kinoSkbt 起動元機能種別
	 * @return 判定結果
	 * @throws Throwable 
	 */
	private boolean isPrgAdd(String isSokuji, String kinoSkbt) throws Throwable
	{
		boolean rslt = false;
		
		// 起動元機能種別がお客様情報審査の場合
		if(JKKJudgeConstCC.KIDO_MT_CUST_INFO_JUDGE.equals(kinoSkbt))
		{
			rslt = true;
		}
		// 起動元機能種別が契約情報審査の場合
		else if(JKKJudgeConstCC.KIDO_MT_KEI_INFO_JUDGE.equals(kinoSkbt))
		{
			rslt = true;
		}
		// 起動元機能種別が照査前登録画面−審査ボタン押下の場合
		else if(JKKJudgeConstCC.KIDO_MT_SHOSA_MAE_JDG_BTN.equals(kinoSkbt))
		{
			rslt = true;
		}
		// 起動元機能種別がその他かつ即時フラグがtrueの場合
		else if(JKKJudgeConstCC.KIDO_MT_OTR.equals(kinoSkbt) && JKKJudgeConstCC.SOKUJI_TRUE.equals(isSokuji))
		{
			rslt = true;
		}
		
		
		return rslt;
	}
	
	/**
	 * 進捗登録を行う。
	 * @param svcKeiMap サービス契約情報
	 * @param mskmDtlMap 申込詳細情報
	 * @param prgStat 進捗ステータス
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @return 判定結果
	 * @throws Throwable 
	 */
	private void executePrgAdd(
			HashMap<String, String> svcKeiMap, HashMap<String, String> mskmDtlMap, String prgStat, 
			IRequestParameterReadWrite param, SessionHandle handle) throws Throwable
	{
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		
		/* 進捗登録SIF */
		CAANMsg judgeTemp = editInMsg(EKK1091D010CBSMsg.class.getName(), "EKK1091D010", "1", param);
		// サービス契約マップ.サービス契約番号 → サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1091D010CBSMsg.SVC_KEI_NO, judgeTemp);
		// サービス契約マップ.異動区分 → 異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1091D010CBSMsg.IDO_DIV, judgeTemp);
		// システム日付 → 異動年月日時分秒
		// 20140625 ST4-2014-0000030 Mod Start
//		setSvcIFMapping(getIdoDtm(svcKeiMap, param, handle), EKK1091D010CBSMsg.IDO_DTM, judgeTemp);
		setSvcIFMapping(this.m_idoDtm, EKK1091D010CBSMsg.IDO_DTM, judgeTemp);
		// 20140625 ST4-2014-0000030 Mod End
		// 進捗ステータス → 進捗ステータス
		setSvcIFMapping(prgStat, EKK1091D010CBSMsg.PRG_STAT, judgeTemp);
		// 申込明細番号
		setSvcIFMapping(mskmDtlMap.get(KK0021ETMsg.MSKM_DTL_NO), EKK1091D010CBSMsg.MSKM_DTL_NO, judgeTemp);
		// オプションサービス契約番号
		setSvcIFMapping(null, EKK1091D010CBSMsg.OP_SVC_KEI_NO, judgeTemp);
		// 進捗メモ
		setSvcIFMapping(null, EKK1091D010CBSMsg.PRG_MEMO, judgeTemp);
		// 進捗特記事項1
		setSvcIFMapping(null, EKK1091D010CBSMsg.PRG_TKJK_1, judgeTemp);
		// 進捗特記事項2
		setSvcIFMapping(null, EKK1091D010CBSMsg.PRG_TKJK_2, judgeTemp);
		// 機器提供サービス契約番号
		setSvcIFMapping(null, EKK1091D010CBSMsg.KKTK_SVC_KEI_NO, judgeTemp);
		// サブオプションサービス契約番号
		setSvcIFMapping(null, EKK1091D010CBSMsg.SBOP_SVC_KEI_NO, judgeTemp);
		// 請求方法番号(クレジットカード)
		setSvcIFMapping(null, EKK1091D010CBSMsg.SEIKY_WAY_NO_CRECARD, judgeTemp);
		// 請求方法番号(口座)
		setSvcIFMapping(null, EKK1091D010CBSMsg.SEIKY_WAY_NO_KOZA, judgeTemp);
		// 請求オプションサービス契約番号
		setSvcIFMapping(null, EKK1091D010CBSMsg.SEIOPSVC_KEI_NO, judgeTemp);
		// サービス契約回線内訳番号
		setSvcIFMapping(null, EKK1091D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO, judgeTemp);
		// 割引サービス契約番号
		setSvcIFMapping(null, EKK1091D010CBSMsg.WRIB_SVC_KEI_NO, judgeTemp);
		// 請求契約番号
		setSvcIFMapping(null, EKK1091D010CBSMsg.SEIKY_KEI_NO, judgeTemp);
		// サービス契約内訳番号
		setSvcIFMapping(null, EKK1091D010CBSMsg.SVC_KEI_UCWK_NO, judgeTemp);
		
		judgeTemp.set(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST, 
				new CAANMsg[0]);
		caanList.add(judgeTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1091D010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
	}
	
	/**
	 * 進捗の照会を行い、異動年月日時分秒を取得する。
	 * @param svcKeiMap サービス契約情報
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @return 異動年月日時分秒
	 * @throws Throwable 
	 */
	private String getIdoDtm(HashMap<String, String> svcKeiMap, IRequestParameterReadWrite param, SessionHandle handle) throws Throwable
	{
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		// 20140625 ST4-2014-0000030 Del Start
//		/* 進捗一覧照会SIF */
//		CAANMsg prgTemp = editInMsg(EKK1091B001CBSMsg.class.getName(), "EKK1091B001", "1", param);
//		// サービス契約マップ.サービス契約番号 → サービス契約番号
//		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1091B001CBSMsg.KEY_SVC_KEI_NO, prgTemp);
//		// サービス契約マップ.異動区分 → 異動区分
//		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1091B001CBSMsg.KEY_IDO_DIV, prgTemp);
//		// "2"：進捗年月日時分秒 → ソート項目
//		setSvcIFMapping("2", EKK1091B001CBSMsg.KEY_SORT_ITEM, prgTemp);
//		// "2"：降順 → ソート順
//		setSvcIFMapping("2", EKK1091B001CBSMsg.KEY_SORT_ORDER, prgTemp);
		// 20140625 ST4-2014-0000030 Del End

		// 20140625 ST4-2014-0000030 Add Start
		/* 進捗一覧照会SIF */
		CAANMsg prgTemp = editInMsg(EKK1091B002CBSMsg.class.getName(), "EKK1091B002", "1", param);
		// サービス契約マップ.サービス契約番号 → サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1091B002CBSMsg.KEY_SVC_KEI_NO, prgTemp);
		// サービス契約マップ.異動区分 → 異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1091B002CBSMsg.KEY_IDO_DIV, prgTemp);
		// サービス契約マップ.申込明細番号
		setSvcIFMapping(null, EKK1091B002CBSMsg.KEY_MSKM_DTL_NO, prgTemp);
		// サービス契約マップ.請求契約番号
		setSvcIFMapping(null, EKK1091B002CBSMsg.KEY_SEIKY_KEI_NO, prgTemp);
		// サービス契約マップ.サービス契約内訳番号
		setSvcIFMapping(null, EKK1091B002CBSMsg.KEY_SVC_KEI_UCWK_NO, prgTemp);
		// サービス契約マップ.サービス契約回線内訳番号
		setSvcIFMapping(null, EKK1091B002CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO, prgTemp);
		// サービス契約マップ.機器提供サービス契約番号
		setSvcIFMapping(null, EKK1091B002CBSMsg.KEY_KKTK_SVC_KEI_NO, prgTemp);
		// サービス契約マップ.オプションサービス契約番号
		setSvcIFMapping(null, EKK1091B002CBSMsg.KEY_OP_SVC_KEI_NO, prgTemp);
		// サービス契約マップ.請求オプションサービス契約番号
		setSvcIFMapping(null, EKK1091B002CBSMsg.KEY_SEIOPSVC_KEI_NO, prgTemp);
		// サービス契約マップ.サブオプションサービス契約番号
		setSvcIFMapping(null, EKK1091B002CBSMsg.KEY_SBOP_SVC_KEI_NO, prgTemp);
		// サービス契約マップ.割引サービス契約番号
		setSvcIFMapping(null, EKK1091B002CBSMsg.KEY_WRIB_SVC_KEI_NO, prgTemp);
		// "0"：進捗年月日時分秒 → ソート項目
		setSvcIFMapping("0", EKK1091B002CBSMsg.KEY_SORT_ITEM_NO, prgTemp);
		// "2"：降順 → ソート順
		setSvcIFMapping("2", EKK1091B002CBSMsg.KEY_SORT_KBN, prgTemp);
		// 20140625 ST4-2014-0000030 Add End

		caanList.add(prgTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		// 20140625 ST4-2014-0000030 Mod Start
//		editErrorInfoEKK1091B001(param, rsltMap);
		editErrorInfoEKK1091B002(param, rsltMap);
		// 20140625 ST4-2014-0000030 Mod End
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);

		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 異動年月日時分秒を返却
		String idoDtm = "";
		
		CAANMsg rsltTemp = rsltCaanList.get(0);
		// 20140625 ST4-2014-0000030 Mod Start
//		CAANMsg[] templateArray = rsltTemp.getCAANMsgList(EKK1091B001CBSMsg.EKK1091B001CBSMSG1LIST);
		CAANMsg[] templateArray = rsltTemp.getCAANMsgList(EKK1091B002CBSMsg.EKK1091B002CBSMSG1LIST);
		// 20140625 ST4-2014-0000030 Mod End
		if(templateArray != null && templateArray.length != 0)
		{
			// 20140625 ST4-2014-0000030 Mod Start
//			idoDtm = templateArray[0].getString(EKK1091B001CBSMsg1List.IDO_DTM);
			idoDtm = templateArray[0].getString(EKK1091B002CBSMsg1List.IDO_DTM);
			// 20140625 ST4-2014-0000030 Mod End
		}
		else
		{
			// 2013/01/11 [IT1-2013-0000035]異動年月日時分秒対応 MOD START
//			idoDtm = JCCBPCommon.getOpeDateTimeStamp(null);
			idoDtm = JCCBPCommon.getSysDateTimeStamp();
			// 2013/01/11 [IT1-2013-0000035]異動年月日時分秒対応 MOD END
		}

		return idoDtm;
	}
	
	/**
	 * 起動元機能から実施すると判定されたチェックが設定されたリストを取得する。
	 * @param isSokuji 即時フラグ
	 * @param kinoSkbt 起動元機能種別
	 * @param 料金グループコード
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @return 起動元機能から実施すると判定されたチェックが設定されたリスト
	 * @throws Throwable 
	 */
	private ArrayList<String> getKinoJssiChkList(String isSokuji, String kinoSkbt, String pcrsCd,
									IRequestParameterReadWrite param, SessionHandle handle) throws Throwable
	{
		ArrayList<String> ctrlList = new ArrayList<String>();;
		
		// 起動元機能種別がその他以外または即時フラグがtrueの場合
		if(!JKKJudgeConstCC.KIDO_MT_OTR.equals(kinoSkbt) || JKKJudgeConstCC.SOKUJI_TRUE.equals(isSokuji))
		{
			// 審査実施条件より制御
			ctrlList = getJdgJsjkn(JKKJudgeConstCC.JDG_JSJKN_CD_1, null, pcrsCd, kinoSkbt, param, handle, null);
		}
		
		return ctrlList;
	}
	
	/**
	 * 審査一覧照会を実施し、審査情報を取得する。
	 * @param svcKeiMap サービス契約情報
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @return 審査情報
	 * @throws Throwable 
	 */
	private HashMap<String, HashMap<String, String>> getJudgShokaiMap(HashMap<String, String> svcKeiMap,
																IRequestParameterReadWrite param, SessionHandle handle)  throws Throwable
	{
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		
		/* 審査一覧照会サービスIF */
		CAANMsg judgeTemp = editInMsg(EKK1071B011CBSMsg.class.getName(), "EKK1071B011", "1", param);
		// サービス契約マップ.サービス契約番号 → サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071B011CBSMsg.KEY_SVC_KEI_NO, judgeTemp);
		//  審査番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_JUDGE_NO, judgeTemp);
		//  審査種別コード
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_JUDGE_SBT_CD, judgeTemp);
		//  審査対象種別コード
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_JUDGE_TG_SBT_CD, judgeTemp);
		//  機器提供サービス契約番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_KKTK_SVC_KEI_NO, judgeTemp);
		//  申込番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_MSKM_DTL_NO, judgeTemp);
		//  オプションサービス契約番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_OP_SVC_KEI_NO, judgeTemp);
		//  サブオプションサービス契約番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_SBOP_SVC_KEI_NO, judgeTemp);
		//  請求オプションサービス契約番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_SEIOPSVC_KEI_NO, judgeTemp);
		//  サービス契約内訳番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_SVC_KEI_UCWK_NO, judgeTemp);
		//  SYSID
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_SYSID, judgeTemp);
		//  割引サービス契約番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_WRIB_SVC_KEI_NO, judgeTemp);
		
		
		caanList.add(judgeTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071B011(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 審査一覧照会で取得した結果コードを設定するMap
		HashMap<String, HashMap<String, String>> judgeMap = new HashMap<String, HashMap<String, String>>();
		
		CAANMsg judgeRsltTemp = rsltCaanList.get(0);
		CAANMsg[] judgeRsltList = judgeRsltTemp.getCAANMsgList(EKK1071B011CBSMsg.EKK1071B011CBSMSG1LIST);
		if(judgeRsltList != null)
		{
			for(CAANMsg judgeInTemp : judgeRsltList)
			{
				// 審査種別コードを取得
				String judgeSbtCd = judgeInTemp.getString(EKK1071B011CBSMsg1List.JUDGE_SBT_CD);
				// 審査番号を取得
				String jdgNo = judgeInTemp.getString(EKK1071B011CBSMsg1List.JUDGE_NO);
				// 結果コードを取得
				String rsltCd = judgeInTemp.getString(EKK1071B011CBSMsg1List.JUDGE_JUDGE_RSLT_CD);
				// 更新年月日時分秒を取得
				String updDtm = judgeInTemp.getString(EKK1071B011CBSMsg1List.UPD_DTM);
				HashMap<String, String> inMap = new HashMap<String, String>();
				inMap.put(KK1071ETMsg.JUDGE_NO, jdgNo);
				inMap.put(KK1071ETMsg.JUDGE_JUDGE_RSLT_CD, rsltCd);
				inMap.put(KK1071ETMsg.UPD_DTM, updDtm);
				judgeMap.put(judgeSbtCd, inMap);
			}
		}
		
		return judgeMap;
	}
	
	/**
	 * 業務パラメータより業務設定値を取得し、制御リストを取得する処理
	 * @param workParamId 業務パラメータID
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @return 制御リスト
	 * @throws Throwable 
	 */
	private ArrayList<String> getWorkParam(String workParamId,
							IRequestParameterReadWrite param, SessionHandle handle) throws Throwable
	{
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		
		/* 業務パラメータ一覧照会サービスIF */
		CAANMsg workParamTemp = editInMsg(EZM0321A010CBSMsg.class.getName(), "EZM0321A010", "1", param);
		// 業務パラメータID → 業務パラメータID
		setSvcIFMapping(workParamId, EZM0321A010CBSMsg.KEY_WORK_PARAM_ID, workParamTemp);
		caanList.add(workParamTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEZM0321A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 取得した業務パラメータより取得した制御リストを設定する変数
		ArrayList<String> ctrlList = new ArrayList<String>();
		
		CAANMsg workParamRsltTemp = rsltCaanList.get(0);
		CAANMsg[] workParamRsltList = workParamRsltTemp.getCAANMsgList(EZM0321A010CBSMsg.EZM0321A010CBSMSG1LIST);
		
		if(workParamRsltList != null)
		{
			// 業務パラメータ設定値を取得
			String paramValue = workParamRsltList[0].getString(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE);
			// 業務パラメータ設定値より制御リストを取得
			ctrlList = getCtrlList(paramValue);
		}
		
		return ctrlList;
	}
	
	/**
	 * 審査実施条件より審査実施要否を取得し、制御リストを取得する処理
	 * @param jdgJsjknSbtCd 審査実施条件種別コード
	 * @param prcGrp 料金グループコード
	 * @param pcrsCd 料金コースコード
	 * @param sjssiKinoDtlSkbtCd 審査実施機能詳細識別コード
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @return 制御リスト
	 * @throws Throwable 
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<String> getJdgJsjkn(String jdgJsjknSbtCd, String prcGrp, String pcrsCd, String sjssiKinoDtlSkbtCd, 
							IRequestParameterReadWrite param, SessionHandle handle, HashMap<String, HashMap<String, String>> judgeMap) 
							throws Throwable
	{
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		
		/* 審査実施条件一覧照会サービスIF */
		CAANMsg jdgJsjknTemp = editInMsg(EKK1841B001CBSMsg.class.getName(), "EKK1841B001", "1", param);
		// ＫＥＹ＿審査実施条件種別コード
		setSvcIFMapping(jdgJsjknSbtCd, EKK1841B001CBSMsg.KEY_JDG_JSJKN_SBT_CD, jdgJsjknTemp);
		// ＫＥＹ＿料金グループコード
		setSvcIFMapping(prcGrp, EKK1841B001CBSMsg.KEY_PRC_GRP_CD, jdgJsjknTemp);
		// ＫＥＹ＿審査実施機能詳細識別コード
		setSvcIFMapping(sjssiKinoDtlSkbtCd, EKK1841B001CBSMsg.KEY_SJSSI_KINO_DTL_SKBT_CD, jdgJsjknTemp);
		
		caanList.add(jdgJsjknTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1841B001(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 取得した審査実施要否より取得した制御リストを設定する変数
		ArrayList<String> ctrlList = new ArrayList<String>();
		
		CAANMsg rsltTemp = rsltCaanList.get(0);
		CAANMsg[] rsltList = rsltTemp.getCAANMsgList(EKK1841B001CBSMsg.EKK1841B001CBSMSG1LIST);
		
		
		if(rsltList != null)
		{
			String jssiYh = null;
			String judgeSbtCd = null;
			String rstPcrsCd = null;
			// 20130510 IT1-2013-0001203 Add Start
			ArrayList<String> deleteJdgsbtList = new ArrayList<String>();
			HashMap<String, String> deleteJdgsbtMap = new HashMap<String, String>();
			// 20130510 IT1-2013-0001203 Add End
			
			// ▼▼▼ OT-2013-0000090 Add Start    ▼▼▼
			//サービス契約リストを取得
			ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
			//サービス契約マップを取得
			HashMap<String, String> svcKeiMap = svcKeiList.get(0);
			// サービスコード
			String svcCd = (String)svcKeiMap.get(KK0081ETMsg.SVC_CD);
			boolean mansionFlg = false;
			// ANK-4427-00-00 ADD START
			// 料金グループコード
			String prcGrpCd = (String)svcKeiMap.get(KK0081ETMsg.PRC_GRP_CD);
			// 料金コースコード
			String pcrCd = (String)svcKeiMap.get(KK0081ETMsg.PCRS_CD);
			boolean typeNFlg = false;
			// ANK-4427-00-00 ADD END
			if(SVC_CD_TEL.equals(svcCd) || SVC_CD_TV.equals(svcCd))
			{
				// 電話またはテレビの場合、マンションか否かを判定する
				mansionFlg = chkMansion(handle, param);
			}
			// ▲▲▲ OT-2013-0000090 Add End      ▲▲▲
			// ANK-4427-00-00 ADD START
			else if (EOH_NET_HOME.equals(prcGrpCd)){
				// ホームタイプの場合、typeNか否かを判定する
				typeNFlg = chkTypeN(handle, param, prcGrpCd, pcrCd);
			}
			// ANK-4427-00-00 ADD END
			
			for(CAANMsg caan : rsltList)
			{
				// 審査実施要否を取得
				jssiYh = caan.getString(EKK1841B001CBSMsg1List.JUDGE_JSSI_YH);
				// 審査種別コードを取得
				judgeSbtCd = caan.getString(EKK1841B001CBSMsg1List.JUDGE_SBT_CD);
				// 料金コースコード
				rstPcrsCd = caan.getString(EKK1841B001CBSMsg1List.PCRS_CD);
				
				// ▼▼▼ OT-2013-0000090 Add Start    ▼▼▼
				if(JUDGE_SBT_CD_AREA_CHECK.equals(judgeSbtCd))
				{
					if(mansionFlg)
					{
						// 利用場所がマンションの場合、エリアチェックの審査を実施しない
						continue;
					}
					// ANK-4427-00-00 ADD START
					else if(typeNFlg)
					{
						// 利用場所がTypeNの場合、エリアチェックの審査を実施しない
						continue;
					}
					// ANK-4427-00-00 ADD END
				}
				// ▲▲▲ OT-2013-0000090 Add End      ▲▲▲
				
				// 審査実施要否が要の場合
				if(JKKJudgeConstCC.JUDGE_JSSI_YH_1.equals(jssiYh))
				{
					// 料金コースコードが存在しない場合
					if (null == rstPcrsCd)
					{
						// 審査実施要となった審査種別コードをリストに追加
						ctrlList.add(judgeSbtCd);
					}
					// 料金コースコードが存在する場合
					// eAccessの特定のコースの場合のみ実施とする
					// 20130510 IT1-2013-0001203 Delete Start
//					else if ((JKKJudgeConstCC.PCRS_CD_ADSL_EACCESS12M1.equals(rstPcrsCd)
//							|| JKKJudgeConstCC.PCRS_CD_ADSL_EACCESS24M1.equals(rstPcrsCd)
//							|| JKKJudgeConstCC.PCRS_CD_ADSL_EACCESS1M1.equals(rstPcrsCd)
//							|| JKKJudgeConstCC.PCRS_CD_ADSL_EACCESS40M1.equals(rstPcrsCd)
//							|| JKKJudgeConstCC.PCRS_CD_ADSL_EACCESS50M1.equals(rstPcrsCd))
//							&& pcrsCd.equals(rstPcrsCd))
//					{
//						ctrlList.add(judgeSbtCd);
//					}
					// 20130510 IT1-2013-0001203 Delete End
					// 20130510 IT1-2013-0001203 Add Start
					else if (pcrsCd.equals(rstPcrsCd))
					{
						ctrlList.add(judgeSbtCd);
					}
					else
					{
						if(!deleteJdgsbtMap.containsKey(judgeSbtCd))
						{
							deleteJdgsbtMap.put(judgeSbtCd, judgeSbtCd);
							deleteJdgsbtList.add(judgeSbtCd);
						}
					}
					// 20130510 IT1-2013-0001203 Add End
				}
			}
			// 20130510 IT1-2013-0001203 Add Start
			for(String deleteJdgSbtCd : deleteJdgsbtList)
			{
				boolean hitFlg = false;
				for(String addJudgeSbtCd : ctrlList)
				{
					if(deleteJdgSbtCd.equals(addJudgeSbtCd))
					{
						hitFlg = true;
						break;
					}
				}
				if(!hitFlg)
				{
					if(null != judgeMap && null != judgeMap.get(deleteJdgSbtCd))
					{
						HashMap<String, String> inMap = judgeMap.get(deleteJdgSbtCd);

						HashMap<String, String> jdgInMap = new HashMap<String, String>();
						
						HashMap<String, HashMap<String, String>> jdgSetMap = new HashMap<String, HashMap<String, String>>();
						
						// 審査番号を設定
						jdgInMap.put(KK1071ETMsg.JUDGE_NO, inMap.get(KK1071ETMsg.JUDGE_NO));
						// 更新年月日時分秒を設定
						jdgInMap.put(KK1071ETMsg.UPD_DTM, inMap.get(KK1071ETMsg.UPD_DTM));

						jdgSetMap.put(deleteJdgSbtCd, jdgInMap);

						// 審査詳細情報を削除
						delJdgDtl(deleteJdgSbtCd, param, handle, jdgSetMap);

						// 審査情報を削除
						delJdg(deleteJdgSbtCd, param, handle, jdgSetMap);
					}
				}
			}
			// 20130510 IT1-2013-0001203 Add End
		}
		
		return ctrlList;
	}
	
	/**
	 * 料金グループから実施対象となった審査種別コードの審査登録を実施する
	 * @param svcJssiChkList 審査実施制御リスト（料金グループ）
	 * @param judgeMap 審査情報
	 * @param svcKeiMap サービス契約情報
	 * @param custMap お客様情報
	 * @param mskmDtlMap 申込明細情報
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @param jdgSetMap 審査設定情報
	 * @return 実施するチェックリスト
	 * @throws Throwable 
	 */
	private ArrayList<String> getChkList(
			ArrayList<String> svcJssiChkList, HashMap<String, HashMap<String, String>> judgeMap, 
			HashMap<String, String> svcKeiMap, HashMap<String, String> custMap,
			HashMap<String, String> mskmDtlMap, IRequestParameterReadWrite param, SessionHandle handle,
			HashMap<String, HashMap<String, String>> jdgSetMap, ArrayList<HashMap<String, String>> judgeNoList) throws Throwable
	{
		ArrayList<String> jssiChkList = new ArrayList<String>();
		
		// 料金グループで実施となった審査の登録を実施
		for(String jdgSbtCd : svcJssiChkList)
		{
			// チェック対象の審査種別コードで審査一覧照会で取得した審査情報を取得する
			HashMap<String, String> inMap = judgeMap.get(jdgSbtCd);

			HashMap<String, String> jdgInMap = new HashMap<String, String>();

			// チェック対象が番ポエリアチェックかつ、番ポ有の情報が存在しない場合
			if(JKKJudgeConstCC.JUDGE_SBT_BMP_AREA.equals(jdgSbtCd) && !isBmpAri(param))
			{
				// 2013/04/08 [IT1-2013-0000757]番ポから新規発番に変更時、番ポエリアチェックの審査レコード削除対応 ADD START
				// 番ポの審査情報がnullでない場合、審査情報・審査詳細情報を削除する
				if(inMap != null)
				{
					// 審査番号を設定
					jdgInMap.put(KK1071ETMsg.JUDGE_NO, inMap.get(KK1071ETMsg.JUDGE_NO));
					// 更新年月日時分秒を設定
					jdgInMap.put(KK1071ETMsg.UPD_DTM, inMap.get(KK1071ETMsg.UPD_DTM));

					jdgSetMap.put(jdgSbtCd, jdgInMap);

					// 審査詳細情報を削除
					delJdgDtl(jdgSbtCd, param, handle, jdgSetMap);

					// 審査情報を削除
					delJdg(jdgSbtCd, param, handle, jdgSetMap);

				}
				// 2013/04/08 [IT1-2013-0000757]番ポから新規発番に変更時、番ポエリアチェックの審査レコード削除対応 ADD END
				continue;
			}
			
			// 審査情報が存在しない場合
			if(inMap == null)
			{
				// 審査テーブルに登録し、審査番号を設定する
				executeAddJdg(jdgInMap, svcKeiMap, custMap, mskmDtlMap, jdgSbtCd, param, handle);
			}
			else
			{
				// 審査番号を設定
				jdgInMap.put(KK1071ETMsg.JUDGE_NO, inMap.get(KK1071ETMsg.JUDGE_NO));
				// 更新年月日時分秒を設定
				jdgInMap.put(KK1071ETMsg.UPD_DTM, inMap.get(KK1071ETMsg.UPD_DTM));
			}
			
			jssiChkList.add(jdgSbtCd);
			
			jdgSetMap.put(jdgSbtCd, jdgInMap);
			
			// 20130404 IT1-2013-0000551 Add Start
			judgeNoList.add(jdgInMap);
			// 20130404 IT1-2013-0000551 Add End
		}
		
		return jssiChkList;
	}
	
	/**
	 * 料金グループと起動元機能から実施となった審査から実施する審査の制御リストを取得する
	 * @param param リクエストパラメータ
	 * @return 番ポ有：true 番ポ無:false
	 * @throws Throwable 
	 */
	private boolean isBmpAri(IRequestParameterReadWrite param) throws Throwable
	{
		// サービス契約情報を取得
		ArrayList<HashMap<String, String>> svkeiuwEohTelList = (ArrayList<HashMap<String, String>>)param.getData(KK0191ETMsg.getTableName());
		// 番ポ有フラグ
		boolean isBmpAri = false;
		
		if(svkeiuwEohTelList != null)
		{
			for(HashMap<String, String> svkeiuwEohTelMap : svkeiuwEohTelList)
			{
				// 番ポ有無を取得
				String bmpUm = svkeiuwEohTelMap.get(KK0191ETMsg.BMP_UM);
				// 番ポ有無が有の場合
				if(JKKJudgeConstCC.UM_CD_1.equals(bmpUm))
				{
					isBmpAri = true;
				}
			}
		}
		
		
		return isBmpAri;
	}
	
	/**
	 * 料金グループと起動元機能から実施となった審査から実施する審査の制御リストを取得する
	 * @param jdgJunList 審査実施順リスト
	 * @param svcJssiChkList 審査実施制御リスト（料金グループ）
	 * @param kinoJssiChkList 審査実施制御リスト（起動元機能）
	 * @param kinoSkbt 起動元機能識別
	 * @param judgeMap 審査情報
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @return 審査実施対象リスト
	 * @throws Throwable 
	 */
	private ArrayList<String> getExeChkList(ArrayList<String> jdgJunList, ArrayList<String> svcJssiChkList, 
			ArrayList<String> kinoJssiChkList, String kinoSkbt, HashMap<String, HashMap<String, String>> judgeMap) throws Throwable
	{
		// 実施チェックリスト
		ArrayList<String> exeChkList = new ArrayList<String>();
		
		// 実施順に繰り返し処理を実施
		for(String jdgSbtCd : jdgJunList)
		{
			// 実施対象外なら次チェックに移る
			if(!svcJssiChkList.contains(jdgSbtCd) || !kinoJssiChkList.contains(jdgSbtCd))
			{
				continue;
			}
			
			// チェック対象の審査種別コードで審査一覧照会で取得した審査情報を取得する
			HashMap<String, String> inMap = judgeMap.get(jdgSbtCd);
			
			// 起動元機能がバッチの場合かつ審査情報が存在する場合
			if(isKidoKinoBat(kinoSkbt) && inMap != null)
			{
				String rsltCd = JPCEditString.Rtrim(inMap.get(KK1071ETMsg.JUDGE_JUDGE_RSLT_CD));
				
				// 結果コードがnull以外かつ空白以外の場合
				if(rsltCd != null && !"".equals(rsltCd))
				{
					continue;
				}
			}
			
			// 実施チェックリストに追加
			exeChkList.add(jdgSbtCd);
		}
		
		return exeChkList;
	}
	
	/**
	 * 識別文字列から実施するチェックの審査種別コードを格納したリストを返却する
	 * @param paramValue 業務パラメータより取得した設定値
	 * @return 実施チェックが格納されたリスト
	 */
	private static ArrayList<String> getCtrlList(String paramValue)
	{
		String[] values = paramValue.split(",");
		ArrayList<String> ctrlList = new ArrayList<String>();
		for(int cnt = 0; cnt < values.length; cnt++)
		{
			ctrlList.add(values[cnt]);
		}
		
		return ctrlList;
	}
	
	/**
	 * 審査の登録処理を実施する
	 * @param jdgInMap 審査情報
	 * @param svcKeiMap サービス契約情報
	 * @param custMap お客様情報
	 * @param mskmDtlMap 申込明細情報
	 * @param judSbtCd 審査種別コード
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @return 審査番号
	 * @throws Throwable 
	 */
	private void executeAddJdg(HashMap<String, String> jdgInMap, HashMap<String, String> svcKeiMap, 
						HashMap<String, String> custMap, HashMap<String, String> mskmDtlMap, String judSbtCd, 
						IRequestParameterReadWrite param, SessionHandle handle) throws Throwable
	{
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		// 審査対象種別コードを取得
		String jdgTgSbtCd = getJdgTgSbtCd(judSbtCd);
		
		/* 審査登録サービスIF */
		CAANMsg judgeTemp = editInMsg(EKK1071D010CBSMsg.class.getName(), "EKK1071D010", "1", param);
		// 審査マップ.サービス契約番号 → サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071D010CBSMsg.SVC_KEI_NO, judgeTemp);
		// 審査種別コード → 審査種別コード
		setSvcIFMapping(judSbtCd, EKK1071D010CBSMsg.JUDGE_SBT_CD, judgeTemp);
		// 審査対象種別コード → 審査対象種別コード
		setSvcIFMapping(jdgTgSbtCd, EKK1071D010CBSMsg.JUDGE_TG_SBT_CD, judgeTemp);
		// SYSID → SYSID
		setSvcIFMapping(custMap.get(CK0011ETMsg.SYSID), EKK1071D010CBSMsg.SYSID, judgeTemp);
		// 申込明細番号 → 申込明細番号
		setSvcIFMapping(mskmDtlMap.get(KK0021ETMsg.MSKM_DTL_NO), EKK1071D010CBSMsg.MSKM_DTL_NO, judgeTemp);
		// 機器提供サービス契約番号 → 機器提供サービス契約番号
		setSvcIFMapping(null, EKK1071D010CBSMsg.KKTK_SVC_KEI_NO, judgeTemp);
		// オプションサービス契約番号 → オプションサービス契約番号
		setSvcIFMapping(null, EKK1071D010CBSMsg.OP_SVC_KEI_NO, judgeTemp);
		// サブオプションサービス契約番号 → サブオプションサービス契約番号
		setSvcIFMapping(null, EKK1071D010CBSMsg.SBOP_SVC_KEI_NO, judgeTemp);
		// 請求オプションサービス契約番号 → 請求オプションサービス契約番号
		setSvcIFMapping(null, EKK1071D010CBSMsg.SEIOPSVC_KEI_NO, judgeTemp);
		// サービス契約内訳番号 → サービス契約内訳番号
		setSvcIFMapping(null, EKK1071D010CBSMsg.SVC_KEI_UCWK_NO, judgeTemp);
		// 割引サービス契約番号 → 割引サービス契約番号
		setSvcIFMapping(null, EKK1071D010CBSMsg.WRIB_SVC_KEI_NO, judgeTemp);
		
		caanList.add(judgeTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071D010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg judgeRsltTemp = rsltCaanList.get(0);
		
		// 審査番号をログに出力
		JSYejbLog.println(JSYejbLog.Template_Dump,this.getClass(), "審査番号払出調査ログ ------------------------------ ST");
		JSYejbLog.println(JSYejbLog.Template_Dump,this.getClass(), "審査番号 = " + judgeRsltTemp.getString(EKK1071D010CBSMsg.JUDGE_NO));
		JSYejbLog.println(JSYejbLog.Template_Dump,this.getClass(), "審査番号払出調査ログ ------------------------------ ED");
		
		// 審査番号を設定
		jdgInMap.put(KK1071ETMsg.JUDGE_NO, judgeRsltTemp.getString(EKK1071D010CBSMsg.JUDGE_NO));
		// 更新年月日時分秒を設定
		jdgInMap.put(KK1071ETMsg.UPD_DTM, judgeRsltTemp.getString(EKK1071D010CBSMsg.UPD_DTM));
	}
	
	/**
	 * 審査種別コードより設定する審査対象種別コードを取得する
	 * @param judSbtCd 審査種別コード
	 * @return 審査対象種別コード
	 * @throws Throwable 
	 */
	private String getJdgTgSbtCd(String judSbtCd) throws Throwable
	{
		String jdgTgSbtCd = "";
		
		// 審査種別コードが住所不備チェック−サービス契約情報または、エリアチェックまたは、記載不備チェック−サービス契約情報の場合
		if(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_SVC_KEI.equals(judSbtCd) ||
				JKKJudgeConstCC.JUDGE_SBT_AREA.equals(judSbtCd) ||
			JKKJudgeConstCC.JUDGE_SBT_KS_HBI_SVC_KEI.equals(judSbtCd))
		{
			jdgTgSbtCd = JKKJudgeConstCC.JDG_TG_SBT_SVC_KEI;
		}
		// 審査種別コードが記載不備チェック−お客様情報または、住所不備チェック−お客様情報または
		// 不良顧客チェックまたは、多重登録チェックの場合
		else if(isJdgTgSbtForCust(judSbtCd))
		{
			jdgTgSbtCd = JKKJudgeConstCC.JDG_TG_SBT_CUST;
		}
		// 審査種別コードが記載不備チェック−機器サービス契約情報または、住所不備チェック−機器サービス契約情報
		if(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_KIKI_SVC_KEI.equals(judSbtCd) ||
			JKKJudgeConstCC.JUDGE_SBT_AD_HBI_KIKI_SVC_KEI.equals(judSbtCd))
		{
			jdgTgSbtCd = JKKJudgeConstCC.JDG_TG_SBT_KKTK_SVC_KEI;
		}
		// 審査種別コードが記載不備チェック−請求契約情報または、住所不備チェック−請求契約情報
		// または支払方法チェックの場合
		if(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_SEIKY_KEI.equals(judSbtCd) ||
			JKKJudgeConstCC.JUDGE_SBT_AD_HBI_SEIKY_KEI.equals(judSbtCd) ||
			JKKJudgeConstCC.JUDGE_SBT_PAY_WAY.equals(judSbtCd))
		{
			jdgTgSbtCd = JKKJudgeConstCC.JDG_TG_SBT_SEIKY_KEI;
		}
		// 審査種別コードが記載不備チェック−電話番号情報または、住所不備チェック−電話番号情報または、番ポエリアチェックの場合
		if(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_FOR_TEL_NO.equals(judSbtCd) ||
			JKKJudgeConstCC.JUDGE_SBT_AD_HBI_FOR_TEL_NO.equals(judSbtCd) ||
			JKKJudgeConstCC.JUDGE_SBT_BMP_AREA.equals(judSbtCd))
		{
			jdgTgSbtCd = JKKJudgeConstCC.JDG_TG_SBT_SVCUW_KEI;
		}
		
		return jdgTgSbtCd;
	}
	
	/**
	 * 審査対象種別コードがお客様となるチェック種類を判定
	 * @param judSbtCd 審査種別コード
	 * @return 判定結果
	 * @throws Throwable 
	 */
	private boolean isJdgTgSbtForCust(String judSbtCd) throws Throwable
	{
		boolean rlst = false;
		
		// 審査種別コードが記載不備チェック−お客様情報の場合
		if(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_CUST.equals(judSbtCd))
		{
			rlst = true;
		}
		// 審査種別コードが住所不備チェック−お客様情報の場合
		else if(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_CUST.equals(judSbtCd))
		{
			rlst = true;
		}
		// 審査種別コードが不良顧客チェックの場合
		else if(JKKJudgeConstCC.JUDGE_SBT_HURYO_CUST.equals(judSbtCd))
		{
			rlst = true;
		}
		// 審査種別コードが多重登録チェックの場合
		else if(JKKJudgeConstCC.JUDGE_SBT_TAJU_ADD.equals(judSbtCd))
		{
			rlst = true;
		}
		
		return rlst;
	}
	
	/**
	 * 起動元機能種別がバッチかどうか判定を行う。
	 * @param kinoSkbt 起動元機能種別
	 * @return 判定結果
	 */
	private boolean isKidoKinoBat(String kinoSkbt)
	{
		boolean result = false;
		
		// 起動元機能種別がお客様情報審査の場合
		if(JKKJudgeConstCC.KIDO_MT_CUST_INFO_JUDGE.equals(kinoSkbt))
		{
			result = true;
		}
		// 起動元機能種別が不良顧客チェックの場合
		else if(JKKJudgeConstCC.KIDO_MT_HURYO_CUST_CHK.equals(kinoSkbt))
		{
			result = true;
		}
		// 起動元機能種別が契約情報審査の場合
		else if(JKKJudgeConstCC.KIDO_MT_KEI_INFO_JUDGE.equals(kinoSkbt))
		{
			result = true;
		}
		// 起動元機能種別が自動エリアチェックの場合
		else if(JKKJudgeConstCC.KIDO_MT_AUTO_AREA_CHK.equals(kinoSkbt))
		{
			result = true;
		}
		// 起動元機能種別が自動番ポエリアチェックの場合
		else if(JKKJudgeConstCC.KIDO_MT_AUTO_BMP_AREA_CHK.equals(kinoSkbt))
		{
			result = true;
		}
		// 起動元機能種別が支払方法審査の場合
		else if(JKKJudgeConstCC.KIDO_MT_PAY_WAY_JUDGE.equals(kinoSkbt))
		{
			result = true;
		}
		// 起動元機能種別が多重登録チェックの場合
		else if(JKKJudgeConstCC.KIDO_MT_TAJU_WAY_JUDGE.equals(kinoSkbt))
		{
			result = true;
		}
		
		
		return result;
	}
	
	/**
	 * パラメータのチェック内容のチェックを実施する。
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @param chkNaiyo チェック内容
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @return 審査判定結果コード
	 * @throws Throwable
	 */
	private String executeJdg(IRequestParameterReadWrite param, SessionHandle handle, String chkNaiyo,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		// 審査判定結果コード
		String judgeJudgeRsltCd = "";
		
		// チェック内容が住所不備チェック（サービス契約情報）の場合
		if(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_SVC_KEI.equals(chkNaiyo))
		{
			// 住所不備チェック（サービス契約情報）を実施
			judgeJudgeRsltCd = execAdHbiErrForSvcKei(handle, param, jdgSetMap, jdgJssiKinoSkbtCd);
		}
		// チェック内容が記載不備チェック（サービス契約情報）の場合
		else if(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_SVC_KEI.equals(chkNaiyo))
		{
			// 記載不備チェック（サービス契約情報）を実施
			judgeJudgeRsltCd = execKshbiErrForSvcKei(handle, param, jdgSetMap, jdgJssiKinoSkbtCd);
		}
		// チェック内容が住所不備チェック（お客様情報）の場合
		else if(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_CUST.equals(chkNaiyo))
		{
			// 住所不備チェック（お客様情報）を実施
			judgeJudgeRsltCd = execAdHbiErrForCust(handle, param, jdgSetMap, jdgJssiKinoSkbtCd);
		}
		// チェック内容が記載不備チェック（お客様情報）の場合
		else if(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_CUST.equals(chkNaiyo))
		{
			// 記載不備チェック（お客様情報）を実施
			judgeJudgeRsltCd = execKshbiErrForCust(handle, param, jdgSetMap, jdgJssiKinoSkbtCd);
		}
		// チェック内容が住所不備チェック（機器サービス契約情報）の場合
		else if(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_KIKI_SVC_KEI.equals(chkNaiyo))
		{
			// 住所不備チェック（機器サービス契約情報）を実施
			judgeJudgeRsltCd = execAdHbiErrForKikiSvcKei(handle, param, jdgSetMap, jdgJssiKinoSkbtCd);
		}
		// チェック内容が記載不備チェック（機器サービス契約情報）の場合
		else if(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_KIKI_SVC_KEI.equals(chkNaiyo))
		{
			// 記載不備チェック（機器サービス契約情報）を実施
			judgeJudgeRsltCd = execKshbiErrForKikiSvcKei(handle, param, jdgSetMap, jdgJssiKinoSkbtCd);
		}
		// チェック内容が住所不備チェック（請求契約情報）の場合
		else if(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_SEIKY_KEI.equals(chkNaiyo))
		{
			// 住所不備チェック（請求契約情報）を実施
			judgeJudgeRsltCd = execAdHbiErrForSeikyKei(handle, param, jdgSetMap, jdgJssiKinoSkbtCd);
		}
		// チェック内容が記載不備チェック（請求契約情報）の場合
		else if(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_SEIKY_KEI.equals(chkNaiyo))
		{
			// 記載不備チェック（請求契約情報）を実施
			judgeJudgeRsltCd = execKshbiErrForSeikyKei(handle, param, jdgSetMap, jdgJssiKinoSkbtCd);
		}
		// チェック内容が記載不備チェック（電話番号情報）の場合
		else if(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_FOR_TEL_NO.equals(chkNaiyo))
		{
			// 記載不備チェック（電話番号情報）を実施
			judgeJudgeRsltCd = execKshbiErrForTelNoInfo(handle, param, jdgSetMap, jdgJssiKinoSkbtCd);
		}
		// チェック内容がエリアチェックの場合
		else if(JKKJudgeConstCC.JUDGE_SBT_AREA.equals(chkNaiyo))
		{
			// エリアチェックを実施
			judgeJudgeRsltCd = execAreaErr(handle, param, jdgSetMap, jdgJssiKinoSkbtCd);
		}
		// チェック内容が不良顧客チェックの場合
		else if(JKKJudgeConstCC.JUDGE_SBT_HURYO_CUST.equals(chkNaiyo))
		{
			// 不良顧客チェックを実施
			judgeJudgeRsltCd = execHuryoCustErr(handle, param, jdgSetMap, jdgJssiKinoSkbtCd);
		}
		// チェック内容が番ポエリアチェックの場合
		else if(JKKJudgeConstCC.JUDGE_SBT_BMP_AREA.equals(chkNaiyo))
		{
			// 番ポエリアチェック
			judgeJudgeRsltCd = execBmpAreaErr(handle, param, jdgSetMap, jdgJssiKinoSkbtCd);
		}
		// チェック内容が支払方法チェックの場合
		else if(JKKJudgeConstCC.JUDGE_SBT_PAY_WAY.equals(chkNaiyo))
		{
			// 支払方法チェックを実施
			judgeJudgeRsltCd = execPayWayErr(handle, param, jdgSetMap, jdgJssiKinoSkbtCd);
		}
		// チェック内容が多重登録チェックの場合
		else if(JKKJudgeConstCC.JUDGE_SBT_TAJU_ADD.equals(chkNaiyo))
		{
			// 多重登録チェックを実施
			judgeJudgeRsltCd = execTajuAddErr(handle, param, jdgSetMap, jdgJssiKinoSkbtCd);
		}
		// チェック内容が住所不備チェック（電話番号情報）の場合
		else if(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_FOR_TEL_NO.equals(chkNaiyo))
		{
			// 住所不備チェック（電話番号情報）を実施
			judgeJudgeRsltCd = execAdHbiErrForTelNoInfo(handle, param, jdgSetMap, jdgJssiKinoSkbtCd);
		}
		
		return judgeJudgeRsltCd;
	}
	
	/**
	 * マッピングする際に行う共通の判定を行い、項目を設定する。
	 * @param setValue 設定項目値
	 * @param key マッピングキー
	 * @param template CAANMsgクラス
	 * @throws Throwable
	 */
	private void setSvcIFMapping(Object setValue, String key, CAANMsg template) throws Throwable
	{
		// 設定項目値が空文字またはnullの場合
		if ("".equals(setValue) || setValue == null)
		{
			template.setNull(key);
		// 設定値がある場合
		}
		else
		{
			template.set(key, setValue);
		}
	}
	
	
	/**
	 * 共通の設定項目を設定する
	 * @param schemaClassNm スキーマクラス名
	 * @param templateID テンプレートID
	 * @param funcCd 機能ID
	 * @param param リクエストパラメータ
	 * @return CAANMsgクラス
	 * @throws Throwable 
	 */
	private CAANMsg editInMsg(String schemaClassNm, String templateID, String funcCd,
							IRequestParameterReadWrite param) throws Throwable
	{
		CAANMsg template = new CAANMsg(schemaClassNm);
		
		// テンプレートID
		template.set(JCMConstants.TEMPLATE_ID_KEY, templateID);
		
		// 機能コード
		template.set(JCMConstants.FUNC_CODE_KEY, funcCd);
		
		// オペレータID
		Object operatorId = param.getControlMapData(SCControlMapKeys.OPERATOR_ID);
		template.set(JCMConstants.OPERATOR_ID_KEY, operatorId);
		
		// 運用日付
		Object operateDate = param.getControlMapData(SCControlMapKeys.OPE_DATE);
		template.set(JCMConstants.OPERATE_DATE_KEY, operateDate);
		
		// 運用日時
		Object operateDateTime = param.getControlMapData(SCControlMapKeys.OPE_TIME);
		template.set(JCMConstants.OPERATE_DATETIME_KEY, operateDateTime);
		
		return template;
	}
	
	/**
	 * CAANMsgに必要なデータをマッピングします。<br>
	 * <br>
	 * @param param (I) 業務データ取得用I/F
	 * @param fixedText (I) ユーザ定義文字列
	 * @return サービスコンポーネント実行用CAANMsg
	 * @exception RequestParameterExceptionがスローされます。
	 */
	private HashMap<String, Object> editInMsg(IRequestParameterReadOnly param, String fixedText) throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

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

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

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

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

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

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

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

		// 機能コード
		template.set(EKK0341B009CBSMsg.FUNC_CODE, "1");
		template.set(EKK0341B009CBSMsg.KEY_SVC_KEI_NO, "9546081001");

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

		return paramMap;
	}
	
	/**
	 * サービスIFを呼び出し、その結果を取得する。
	 * @param caanList サービスIFリスト
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @return templateList 結果が格納されたリスト
	 * @throws Throwable 
	 */
	private Map<?, ?> executeSvcIF(ArrayList<CAANMsg> caanList, 
			IRequestParameterReadWrite param, SessionHandle handle) throws Throwable
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		CAANMsg[] caan = new CAANMsg[caanList.size()];
		int count = 0;
		for(CAANMsg template : caanList)
		{
			caan[count++] = template;
		}
		
		// **********************************************
		// 【取得元：電文ヘッダ(ヘッダ)】
		// **********************************************
		// 電文ID
		paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID());
		// ユースケースID
		paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID());
		// オペレーションID
		paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID());
		// サービス呼び出し区分
		paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType());
		
		// **********************************************
		// 【取得元：ユーザエリア(コントロールマップ)】
		// **********************************************
		// 依頼先ホスト名
		paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTNAME));
		// 依頼元IPアドレス
		paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTIP));
		// 依頼元画面ID
		paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, param.getControlMapData(SCControlMapKeys.REQ_VIEWID));
		// オペレータID
		paramMap.put(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, caan);
		
		// SC呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		return scCall.run(paramMap, handle);
	}
	
	
	/**
	 * <dd>メソッド名	：execAdHbiErrForSvcKei
	 * <dd>メソッド説明	：住所不備チェック(サービス契約情報)を行います。サービス契約回線情報を元に
	 *                    チェックを行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @return 審査判定結果コード
	 * @throws Throwable 
	 */
	public String execAdHbiErrForSvcKei(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		//サービス契約リスト取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		//サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		//サービス契約回線内訳リストを取得
		ArrayList<HashMap<String, String>> svcKeiKaisenUwList = (ArrayList<HashMap<String, String>>)param.getData(KK0251ETMsg.getTableName());
		
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_SVC_KEI);
		
		/* 住所不備サービス契約情報審査SIF */
		// サービスIF共通の設定処理を実施
		CAANMsg adHbiErrForSvcTemp = editInMsg(EKK1071C011CBSMsg.class.getName(), "EKK1071C011", "1", param);
		// 審査実施機能識別コード
		setSvcIFMapping(jdgJssiKinoSkbtCd, EKK1071C011CBSMsg.JDG_JSSI_KINO_SKBT_CD, adHbiErrForSvcTemp);
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071C011CBSMsg.SVC_KEI_NO, adHbiErrForSvcTemp);
		// 異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1071C011CBSMsg.IDO_DIV, adHbiErrForSvcTemp);
		// 審査番号
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C011CBSMsg.JUDGE_NO, adHbiErrForSvcTemp);
		
		// 提供方式契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.TK_HOSHIKI_KEI_NO), EKK1071C011CBSMsg.TK_HOSHIKI_KEI_NO, adHbiErrForSvcTemp);
		
		// サービス契約回線内訳情報が取得できない場合
		if(isListNull(svcKeiKaisenUwList))
		{
			//回線場所住所コード
			setSvcIFMapping(null, EKK1071C011CBSMsg.KAISEN_PLACE_AD_CD, adHbiErrForSvcTemp);
			//回線場所郵便番号
			setSvcIFMapping(null, EKK1071C011CBSMsg.KAISEN_PLACE_PCD, adHbiErrForSvcTemp);
			//回線場所都道府県名
			setSvcIFMapping(null, EKK1071C011CBSMsg.KAISEN_PLACE_STATE_NM, adHbiErrForSvcTemp);
			//回線場所市区町村名
			setSvcIFMapping(null, EKK1071C011CBSMsg.KAISEN_PLACE_CITY_NM, adHbiErrForSvcTemp);
			//回線場所大字通称名
			setSvcIFMapping(null, EKK1071C011CBSMsg.KAISEN_PLACE_OAZTSU_NM, adHbiErrForSvcTemp);
			//回線場所字丁目名
			setSvcIFMapping(null, EKK1071C011CBSMsg.KAISEN_PLACE_AZCHO_NM, adHbiErrForSvcTemp);
			// 回線場所番地号
			setSvcIFMapping(null, EKK1071C011CBSMsg.KAISEN_PLACE_BNCHIGO, adHbiErrForSvcTemp);
			// 回線場所住所未確定フラグ
			setSvcIFMapping(null, EKK1071C011CBSMsg.KISN_PLC_AD_MI_FIX_FLG, adHbiErrForSvcTemp);
			// マンション物件番号
			setSvcIFMapping(null, EKK1071C011CBSMsg.MANSION_BUKKEN_NO, adHbiErrForSvcTemp);
			// 請求書用回線場所住所部屋番号
			setSvcIFMapping(null, EKK1071C011CBSMsg.SKS_YO_KISN_PLACE_AD_RM_NO, adHbiErrForSvcTemp);
			// ▼▼▼ IT1-2012-0001726 2012/11/01 Add Start ▼▼▼
			// サービス契約回線内訳番号
			setSvcIFMapping(null, EKK1071C011CBSMsg.SVC_KEI_KAISEN_UCWK_NO, adHbiErrForSvcTemp);
			// ▲▲▲ IT1-2012-0001726 2012/11/01 Add Start ▲▲▲
			// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
			// サービス契約回線内訳_回線場所住所チェックレベル
			setSvcIFMapping(null, EKK1071C011CBSMsg.KAISEN_PLACE_AD_CHK_LV, adHbiErrForSvcTemp);
			// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
			
		}
		else
		{
			//サービス契約回線内訳マップを取得
			HashMap<String, String> svcKeiKaisenUwMap = svcKeiKaisenUwList.get(0);
			//回線場所住所コード
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_AD_CD), EKK1071C011CBSMsg.KAISEN_PLACE_AD_CD, adHbiErrForSvcTemp);
			//回線場所郵便番号
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_PCD), EKK1071C011CBSMsg.KAISEN_PLACE_PCD, adHbiErrForSvcTemp);
			//回線場所都道府県名
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_STATE_NM), EKK1071C011CBSMsg.KAISEN_PLACE_STATE_NM, adHbiErrForSvcTemp);
			//回線場所市区町村名
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_CITY_NM), EKK1071C011CBSMsg.KAISEN_PLACE_CITY_NM, adHbiErrForSvcTemp);
			//回線場所大字通称名
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_OAZTSU_NM), EKK1071C011CBSMsg.KAISEN_PLACE_OAZTSU_NM, adHbiErrForSvcTemp);
			//回線場所字丁目名
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_AZCHO_NM), EKK1071C011CBSMsg.KAISEN_PLACE_AZCHO_NM, adHbiErrForSvcTemp);
			// 回線場所番地号
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_BNCHIGO), EKK1071C011CBSMsg.KAISEN_PLACE_BNCHIGO, adHbiErrForSvcTemp);
			// 回線場所住所未確定フラグ
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KISN_PLC_AD_MI_FIX_FLG), EKK1071C011CBSMsg.KISN_PLC_AD_MI_FIX_FLG, adHbiErrForSvcTemp);
			// マンション物件番号
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.MANSION_BUKKEN_NO), EKK1071C011CBSMsg.MANSION_BUKKEN_NO, adHbiErrForSvcTemp);
			// 請求書用回線場所住所部屋番号
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.SKS_YO_KISN_PLACE_AD_RM_NO), EKK1071C011CBSMsg.SKS_YO_KISN_PLACE_AD_RM_NO, adHbiErrForSvcTemp);
			// ▼▼▼ IT1-2012-0001726 2012/11/01 Add Start ▼▼▼
			// 請求書用回線場所住所部屋番号
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.SVC_KEI_KAISEN_UCWK_NO), EKK1071C011CBSMsg.SVC_KEI_KAISEN_UCWK_NO, adHbiErrForSvcTemp);
			// ▲▲▲ IT1-2012-0001726 2012/11/01 Add Start ▲▲▲
			// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
			if(null != svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_AD_CD) 
					&& !("".equals(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_AD_CD))) 
					&& null != svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_PCD) 
					&& !("".equals(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_PCD))))
			{
				// サービス契約回線内訳_回線場所住所チェックレベル
				setSvcIFMapping(AD_CHK_LV_1, EKK1071C011CBSMsg.KAISEN_PLACE_AD_CHK_LV, adHbiErrForSvcTemp);
			}
			else
			{
				// サービス契約回線内訳_回線場所住所チェックレベル
				setSvcIFMapping(null, EKK1071C011CBSMsg.KAISEN_PLACE_AD_CHK_LV, adHbiErrForSvcTemp);
			}
			// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
			
		}
		
		// 更新年月日時分秒(更新前)
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.UPD_DTM), EKK1071C011CBSMsg.UPD_DTM_BF, adHbiErrForSvcTemp);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();

		caanList.add(adHbiErrForSvcTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071C011(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 審査判定結果を返却
		CAANMsg rsltTemp = rsltCaanList.get(0);
		
		svcKeiMap.put(KK0081ETMsg.UPD_DTM, rsltTemp.getString(EKK1071C011CBSMsg.UPD_DTM));
		
		return rsltTemp.getString(EKK1071C011CBSMsg.JUDGE_JUDGE_RSLT_CD);
	}
	
	/**
	 * <dd>メソッド名	：execKshbiErrForSvcKei
	 * <dd>メソッド説明	：記載不備チェック(サービス契約情報)を行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @return 審査判定結果コード
	 * @throws Throwable 業務サービス内で発生した例外全般。
	 */
	public String execKshbiErrForSvcKei(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		//サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		//サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		//申込明細リストを取得
		ArrayList<HashMap<String, String>> mskmDtlList = (ArrayList<HashMap<String, String>>)param.getData(KK0021ETMsg.getTableName());
		//申込明細マップを取得
		HashMap<String, String> mskmDtlMap = mskmDtlList.get(0);
		
		//機器提供サービス契約リストを取得
		ArrayList<HashMap<String, String>> kktkSvcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0341ETMsg.getTableName());
		
		//割引サービス契約リストを取得
		ArrayList<HashMap<String, String>> wribSvcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0451ETMsg.getTableName());
		
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_SVC_KEI);
		
		/* 記載不備サービス契約情報審査SIF */
		// サービスIF共通の設定処理を実施
		CAANMsg ksHbiErrForSvcKei = editInMsg(EKK1071C021CBSMsg.class.getName(), "EKK1071C021", "1", param);
		// 審査実施機能識別コード
		setSvcIFMapping(jdgJssiKinoSkbtCd, EKK1071C021CBSMsg.JDG_JSSI_KINO_SKBT_CD, ksHbiErrForSvcKei);
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071C021CBSMsg.SVC_KEI_NO, ksHbiErrForSvcKei);
		// 異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1071C021CBSMsg.IDO_DIV, ksHbiErrForSvcKei);
		// 料金コースコード
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.PCRS_CD), EKK1071C021CBSMsg.PCRS_CD, ksHbiErrForSvcKei);
		// 審査番号
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C021CBSMsg.JUDGE_NO, ksHbiErrForSvcKei);
		//申込番号
		setSvcIFMapping(mskmDtlMap.get(KK0021ETMsg.MSKM_NO), EKK1071C021CBSMsg.MSKM_NO, ksHbiErrForSvcKei);
		//申込書番号
		setSvcIFMapping(mskmDtlMap.get(KK0021ETMsg.MSKMSHO_NO), EKK1071C021CBSMsg.MSKMSHO_NO, ksHbiErrForSvcKei);
		//申込年月日
		setSvcIFMapping(mskmDtlMap.get(KK0021ETMsg.MSKM_YMD), EKK1071C021CBSMsg.MSKM_YMD, ksHbiErrForSvcKei);
		//面開発番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.MENKAIHAT_ANKEN_NO), EKK1071C021CBSMsg.MENKAIHAT_ANKEN_NO, ksHbiErrForSvcKei);
		
		// 機器提供サービスコード明細
		setKktkSvcCdList(kktkSvcKeiList, ksHbiErrForSvcKei);
		
		// 割引サービスコード明細
		setWribSvcCdList(wribSvcKeiList, ksHbiErrForSvcKei);
		
		// 更新年月日時分秒(更新前)
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.UPD_DTM), EKK1071C021CBSMsg.UPD_DTM_BF, ksHbiErrForSvcKei);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		caanList.add(ksHbiErrForSvcKei);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071C021(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 審査判定結果を返却
		CAANMsg rsltTemp = rsltCaanList.get(0);
		
		svcKeiMap.put(KK0081ETMsg.UPD_DTM, rsltTemp.getString(EKK1071C021CBSMsg.UPD_DTM));
		
		return rsltTemp.getString(EKK1071C021CBSMsg.JUDGE_JUDGE_RSLT_CD);
	}
	
	/**
	 * <dd>メソッド名	：execAdHbiErrForCust
	 * <dd>メソッド説明	：住所不備チェック(お客様情報)を行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @return 審査判定結果コード
	 * @throws Throwable 業務サービス内で発生した例外全般。
	 */
	public String execAdHbiErrForCust(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		//サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		//サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		//お客様リストを取得
		ArrayList<HashMap<String, String>> custList = (ArrayList<HashMap<String, String>>)param.getData(CK0011ETMsg.getTableName());
		//お客様マップを取得
		HashMap<String, String> custMap = custList.get(0);
		
		//お客様<個人>リストを取得
		ArrayList<HashMap<String, String>> custKojinList = (ArrayList<HashMap<String, String>>)param.getData(CK0021ETMsg.getTableName());
		
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_CUST);
		
		/* 住所不備お客様情報審査SIF */
		// サービスIF共通の設定処理を実施
		CAANMsg ksHbiErrForCust = editInMsg(EKK1071C031CBSMsg.class.getName(), "EKK1071C031", "1", param);
		// 審査実施機能識別コード
		setSvcIFMapping(jdgJssiKinoSkbtCd, EKK1071C031CBSMsg.JDG_JSSI_KINO_SKBT_CD, ksHbiErrForCust);
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071C031CBSMsg.SVC_KEI_NO, ksHbiErrForCust);
		//異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1071C031CBSMsg.IDO_DIV, ksHbiErrForCust);
		//審査番号
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C031CBSMsg.JUDGE_NO, ksHbiErrForCust);
		//契約者住所コード
		setSvcIFMapping(custMap.get(CK0011ETMsg.KEISHA_AD_CD), EKK1071C031CBSMsg.KEISHA_AD_CD, ksHbiErrForCust);
		//契約者郵便番号
		setSvcIFMapping(custMap.get(CK0011ETMsg.KEISHA_PCD), EKK1071C031CBSMsg.KEISHA_PCD, ksHbiErrForCust);
		//契約者都道府県名
		setSvcIFMapping(custMap.get(CK0011ETMsg.KEISHA_STATE_NM), EKK1071C031CBSMsg.KEISHA_STATE_NM, ksHbiErrForCust);
		//契約者市区町村名
		setSvcIFMapping(custMap.get(CK0011ETMsg.KEISHA_CITY_NM), EKK1071C031CBSMsg.KEISHA_CITY_NM, ksHbiErrForCust);
		//契約者大字通称名
		setSvcIFMapping(custMap.get(CK0011ETMsg.KEISHA_OAZTSU_NM), EKK1071C031CBSMsg.KEISHA_OAZTSU_NM, ksHbiErrForCust);
		//契約者字丁目名
		setSvcIFMapping(custMap.get(CK0011ETMsg.KEISHA_AZCHO_NM), EKK1071C031CBSMsg.KEISHA_AZCHO_NM, ksHbiErrForCust);
		// --住所課題対応-STR-----------------------
		// 契約者番地号
		setSvcIFMapping(custMap.get(CK0011ETMsg.KEISHA_BNCHIGO), EKK1071C031CBSMsg.KEISHA_BNCHIGO, ksHbiErrForCust);
		// 契約者住所手動入力フラグ
		setSvcIFMapping(custMap.get(JKKJudgeConstCC.KEISHA_AD_MAN_INPUT_FLG), EKK1071C031CBSMsg.KEISHA_AD_MAN_INPUT_FLG, ksHbiErrForCust);
		// --住所課題対応-END-----------------------
		
		// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
		if(null != custMap.get(CK0011ETMsg.KEISHA_AD_CD) 
				&& !("".equals(custMap.get(CK0011ETMsg.KEISHA_AD_CD))) 
				&& null != custMap.get(CK0011ETMsg.KEISHA_PCD) 
				&& !("".equals(custMap.get(CK0011ETMsg.KEISHA_PCD))))
		{
			// お客様_契約者住所チェックレベル
			setSvcIFMapping(AD_CHK_LV_2, EKK1071C031CBSMsg.KEISHA_AD_CHK_LV, ksHbiErrForCust);
		}
		else
		{
			// お客様_契約者住所チェックレベル
			setSvcIFMapping(null, EKK1071C031CBSMsg.KEISHA_AD_CHK_LV, ksHbiErrForCust);
		}
		// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
		
		// お客様＜個人＞情報を取得できない場合
		if(isListNull(custKojinList))
		{
			//親権者住所コード
			setSvcIFMapping(null, EKK1071C031CBSMsg.SKSHA_AD_CD, ksHbiErrForCust);
			//親権者郵便番号
			setSvcIFMapping(null, EKK1071C031CBSMsg.SKSHA_PCD, ksHbiErrForCust);
			//親権者都道府県名
			setSvcIFMapping(null, EKK1071C031CBSMsg.SKSHA_STATE_NM, ksHbiErrForCust);
			//親権者市区町村名
			setSvcIFMapping(null, EKK1071C031CBSMsg.SKSHA_CITY_NM, ksHbiErrForCust);
			//親権者大字通称名
			setSvcIFMapping(null, EKK1071C031CBSMsg.SKSHA_OAZTSU_NM, ksHbiErrForCust);
			//親権者字丁目名
			setSvcIFMapping(null, EKK1071C031CBSMsg.SKSHA_AZCHO_NM, ksHbiErrForCust);
			// --住所課題対応-STR-----------------------
			// 親権者番地号
			setSvcIFMapping(null, EKK1071C031CBSMsg.SKSHA_AD_BNCHIGO, ksHbiErrForCust);
			// 親権者住所手動入力フラグ
			setSvcIFMapping(null, EKK1071C031CBSMsg.SKSHA_AD_MAN_INPUT_FLG, ksHbiErrForCust);
			// --住所課題対応-END-----------------------
			// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
			// お客様＜個人＞_親権者住所チェックレベル
			setSvcIFMapping(null, EKK1071C031CBSMsg.SKSHA_AD_CHK_LV, ksHbiErrForCust);
			// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
		}
		else
		{
			//お客様<個人>マップを取得
			HashMap<String, String> custKojinMap = custKojinList.get(0);
			
			//親権者住所コード
			setSvcIFMapping(custKojinMap.get(CK0021ETMsg.SKSHA_AD_CD), EKK1071C031CBSMsg.SKSHA_AD_CD, ksHbiErrForCust);
			//親権者郵便番号
			setSvcIFMapping(custKojinMap.get(CK0021ETMsg.SKSHA_PCD), EKK1071C031CBSMsg.SKSHA_PCD, ksHbiErrForCust);
			//親権者都道府県名
			setSvcIFMapping(custKojinMap.get(CK0021ETMsg.SKSHA_STATE_NM), EKK1071C031CBSMsg.SKSHA_STATE_NM, ksHbiErrForCust);
			//親権者市区町村名
			setSvcIFMapping(custKojinMap.get(CK0021ETMsg.SKSHA_CITY_NM), EKK1071C031CBSMsg.SKSHA_CITY_NM, ksHbiErrForCust);
			//親権者大字通称名
			setSvcIFMapping(custKojinMap.get(CK0021ETMsg.SKSHA_OAZTSU_NM), EKK1071C031CBSMsg.SKSHA_OAZTSU_NM, ksHbiErrForCust);
			//親権者字丁目名
			setSvcIFMapping(custKojinMap.get(CK0021ETMsg.SKSHA_AZCHO_NM), EKK1071C031CBSMsg.SKSHA_AZCHO_NM, ksHbiErrForCust);
			// --住所課題対応-STR-----------------------
			// 親権者番地号
			setSvcIFMapping(custKojinMap.get(CK0021ETMsg.SKSHA_AD_BNCHIGO), EKK1071C031CBSMsg.SKSHA_AD_BNCHIGO, ksHbiErrForCust);
			// 親権者住所手動入力フラグ
			setSvcIFMapping(custKojinMap.get(JKKJudgeConstCC.SKSHA_AD_MAN_INPUT_FLG), EKK1071C031CBSMsg.SKSHA_AD_MAN_INPUT_FLG, ksHbiErrForCust);
			// --住所課題対応-END-----------------------
			// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
			if( null != custKojinMap.get(CK0021ETMsg.SKSHA_AD_CD) 
					&& !("".equals(custKojinMap.get(CK0021ETMsg.SKSHA_AD_CD))) 
					&& null != custKojinMap.get(CK0021ETMsg.SKSHA_PCD) 
					&& !("".equals(custKojinMap.get(CK0021ETMsg.SKSHA_PCD))))
			{
				// お客様＜個人＞_親権者住所チェックレベル
				setSvcIFMapping(AD_CHK_LV_2, EKK1071C031CBSMsg.SKSHA_AD_CHK_LV, ksHbiErrForCust);
			}
			else
			{
				// お客様＜個人＞_親権者住所チェックレベル
				setSvcIFMapping(null, EKK1071C031CBSMsg.SKSHA_AD_CHK_LV, ksHbiErrForCust);
			}
			// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
		}
		// 更新年月日時分秒(更新前)
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.UPD_DTM), EKK1071C031CBSMsg.UPD_DTM_BF, ksHbiErrForCust);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		caanList.add(ksHbiErrForCust);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071C031(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 審査判定結果を返却
		CAANMsg rsltTemp = rsltCaanList.get(0);
		
		return rsltTemp.getString(EKK1071C031CBSMsg.JUDGE_JUDGE_RSLT_CD);
	}
	
	/**
	 * <dd>メソッド名	：execKshbiErrForCust
	 * <dd>メソッド説明	：記載不備チェック(お客様情報)を行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @return 審査判定結果コード
	 * @throws Throwable 業務サービス内で発生した例外全般。
	 */
	public String execKshbiErrForCust(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		//サービス契約リスト
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		//サービス契約マップ
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		//お客様リストを取得
		ArrayList<HashMap<String, String>> custList = (ArrayList<HashMap<String, String>>)param.getData(CK0011ETMsg.getTableName());
		//お客様マップを取得
		HashMap<String, String> custMap = custList.get(0);
		
		//サービス契約回線内訳リストを取得
		ArrayList<HashMap<String, String>> svcKeiKaisenUwList = (ArrayList<HashMap<String, String>>)param.getData(KK0251ETMsg.getTableName());
		
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_CUST);
		
		// お客様＜個人＞リストを取得
		ArrayList<HashMap<String, String>> custKojinList = (ArrayList<HashMap<String, String>>)param.getData(CK0021ETMsg.getTableName());
		
		// お客様＜法人＞リストを取得
		ArrayList<HashMap<String, String>> custHojinList = (ArrayList<HashMap<String, String>>)param.getData(CK0031ETMsg.getTableName());
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		/* 記載不備お客様情報審査SIF */
		// サービスIF共通の設定処理を実施
		CAANMsg kshbiErrForCust = editInMsg(EKK1071C041CBSMsg.class.getName(), "EKK1071C041", "1", param);
		// 審査実施機能識別コード
		setSvcIFMapping(jdgJssiKinoSkbtCd, EKK1071C041CBSMsg.JDG_JSSI_KINO_SKBT_CD, kshbiErrForCust);
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071C041CBSMsg.SVC_KEI_NO, kshbiErrForCust);
		//異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1071C041CBSMsg.IDO_DIV, kshbiErrForCust);
		//審査番号
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C041CBSMsg.JUDGE_NO, kshbiErrForCust);
		
		// 記載不備お客様情報審査明細
		setSysidList(handle, param, custMap, kshbiErrForCust);
		
		// サービス契約回線内訳情報を取得できない場合
		if(isListNull(svcKeiKaisenUwList))
		{
			//サービス契約回線内訳番号
			setSvcIFMapping(null, EKK1071C041CBSMsg.SVC_KEI_KAISEN_UCWK_NO, kshbiErrForCust);
			//回線場所郵便番号
			setSvcIFMapping(null, EKK1071C041CBSMsg.KAISEN_PLACE_PCD, kshbiErrForCust);
			//回線場所都道府県名
			setSvcIFMapping(null, EKK1071C041CBSMsg.KAISEN_PLACE_STATE_NM, kshbiErrForCust);
			//回線場所市区町村名
			setSvcIFMapping(null, EKK1071C041CBSMsg.KAISEN_PLACE_CITY_NM, kshbiErrForCust);
			//回線場所大字通称名
			setSvcIFMapping(null, EKK1071C041CBSMsg.KAISEN_PLACE_OAZTSU_NM, kshbiErrForCust);
			//回線場所字丁目名
			setSvcIFMapping(null, EKK1071C041CBSMsg.KAISEN_PLACE_AZCHO_NM, kshbiErrForCust);
			//回線場所番地号
			setSvcIFMapping(null, EKK1071C041CBSMsg.KAISEN_PLACE_BNCHIGO, kshbiErrForCust);
			//回線場所住所補記・建物名
			setSvcIFMapping(null, EKK1071C041CBSMsg.KAISEN_PLACE_ADRTTM, kshbiErrForCust);
			//回線場所住所補記・部屋番号
			setSvcIFMapping(null, EKK1071C041CBSMsg.KAISEN_PLACE_ADRRM, kshbiErrForCust);
		}
		else
		{
			//サービス契約回線内訳マップを取得
			HashMap<String, String> svcKeiKaisenUwMap = svcKeiKaisenUwList.get(0);
			//サービス契約回線内訳番号
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.SVC_KEI_KAISEN_UCWK_NO), EKK1071C041CBSMsg.SVC_KEI_KAISEN_UCWK_NO, kshbiErrForCust);
			//回線場所郵便番号
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_PCD), EKK1071C041CBSMsg.KAISEN_PLACE_PCD, kshbiErrForCust);
			//回線場所都道府県名
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_STATE_NM), EKK1071C041CBSMsg.KAISEN_PLACE_STATE_NM, kshbiErrForCust);
			//回線場所市区町村名
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_CITY_NM), EKK1071C041CBSMsg.KAISEN_PLACE_CITY_NM, kshbiErrForCust);
			//回線場所大字通称名
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_OAZTSU_NM), EKK1071C041CBSMsg.KAISEN_PLACE_OAZTSU_NM, kshbiErrForCust);
			//回線場所字丁目名
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_AZCHO_NM), EKK1071C041CBSMsg.KAISEN_PLACE_AZCHO_NM, kshbiErrForCust);
			//回線場所番地号
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_BNCHIGO), EKK1071C041CBSMsg.KAISEN_PLACE_BNCHIGO, kshbiErrForCust);
			//回線場所住所補記・建物名
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_ADRTTM), EKK1071C041CBSMsg.KAISEN_PLACE_ADRTTM, kshbiErrForCust);
			//回線場所住所補記・部屋番号
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_ADRRM), EKK1071C041CBSMsg.KAISEN_PLACE_ADRRM, kshbiErrForCust);
		}
		
		// お客様生年月日
		setSvcIFMapping(custMap.get(CK0011ETMsg.CUST_BIRTHD), EKK1071C041CBSMsg.CUST_BIRTHD, kshbiErrForCust);
		// 契約者タイプコード
		setSvcIFMapping(custMap.get(CK0011ETMsg.KEISHA_TYPE_CD), EKK1071C041CBSMsg.KEISHA_TYPE_CD, kshbiErrForCust);
		
		if(isListNull(custKojinList))
		{
			// 親権者名
			setSvcIFMapping(null, EKK1071C041CBSMsg.SKSHA_NM, kshbiErrForCust);
			// 親権者カナ名
			setSvcIFMapping(null, EKK1071C041CBSMsg.SKSHA_KANA, kshbiErrForCust);
			// 親権者生年月日
			setSvcIFMapping(null, EKK1071C041CBSMsg.SKSHA_BIRTHD, kshbiErrForCust);
			// 親権者続柄コード
			setSvcIFMapping(null, EKK1071C041CBSMsg.SKSHA_ZOKUGARA_CD, kshbiErrForCust);
			// 親権者電話番号
			setSvcIFMapping(null, EKK1071C041CBSMsg.SKSHA_TELNO, kshbiErrForCust);
		}
		else
		{
			HashMap<String, String> custKojinMap = custKojinList.get(0);
			// 親権者名
			setSvcIFMapping(custKojinMap.get(CK0021ETMsg.SKSHA_NM), EKK1071C041CBSMsg.SKSHA_NM, kshbiErrForCust);
			// 親権者カナ名
			setSvcIFMapping(custKojinMap.get(CK0021ETMsg.SKSHA_KANA), EKK1071C041CBSMsg.SKSHA_KANA, kshbiErrForCust);
			// 親権者生年月日
			setSvcIFMapping(custKojinMap.get(CK0021ETMsg.SKSHA_BIRTHD), EKK1071C041CBSMsg.SKSHA_BIRTHD, kshbiErrForCust);
			// 親権者続柄コード
			setSvcIFMapping(custKojinMap.get(CK0021ETMsg.SKSHA_ZOKUGARA_CD), EKK1071C041CBSMsg.SKSHA_ZOKUGARA_CD, kshbiErrForCust);
			// 親権者電話番号
			setSvcIFMapping(custKojinMap.get(CK0021ETMsg.SKSHA_TELNO), EKK1071C041CBSMsg.SKSHA_TELNO, kshbiErrForCust);
		}

		if(isListNull(custHojinList))
		{
			// 法人格種別コード
			setSvcIFMapping(null, EKK1071C041CBSMsg.HOJIN_SBT_CD, kshbiErrForCust);
			// 法人格前後指定コード
			setSvcIFMapping(null, EKK1071C041CBSMsg.HOJIN_ZENGO_SHITEI_CD, kshbiErrForCust);
		}
		else
		{
			// お客様＜法人＞マップを取得
			HashMap<String, String> custHojinMap = custHojinList.get(0);
			// 法人格種別コード
			setSvcIFMapping(custHojinMap.get(CK0031ETMsg.HOJIN_SBT_CD), EKK1071C041CBSMsg.HOJIN_SBT_CD, kshbiErrForCust);
			// 法人格前後指定コード
			setSvcIFMapping(custHojinMap.get(CK0031ETMsg.HOJIN_ZENGO_SHITEI_CD), EKK1071C041CBSMsg.HOJIN_ZENGO_SHITEI_CD, kshbiErrForCust);
		}
		
		// 更新年月日時分秒(更新前)
		setSvcIFMapping(custMap.get(CK0011ETMsg.UPD_DTM), EKK1071C041CBSMsg.UPD_DTM_BF, kshbiErrForCust);
		
		caanList.add(kshbiErrForCust);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071C041(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 審査判定結果を返却
		CAANMsg rsltTemp = rsltCaanList.get(0);
		
		custMap.put(CK0011ETMsg.UPD_DTM, rsltTemp.getString(EKK1071C041CBSMsg.UPD_DTM));
		
		return rsltTemp.getString(EKK1071C041CBSMsg.JUDGE_JUDGE_RSLT_CD);
	}
	
	/**
	 * <dd>メソッド名	：execAdHbiErrForKikiSvcKei
	 * <dd>メソッド説明	：住所不備チェック(機器サービス契約情報)を行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @return 審査判定結果コード
	 * @throws Throwable 業務サービス内で発生した例外全般。
	 */
	public String execAdHbiErrForKikiSvcKei(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		/* 住所不備サービス契約情報審査SIF */
		// サービスIF共通の設定処理を実施
		CAANMsg adHbiErrForKikiSvcKei = editInMsg(EKK1071C051CBSMsg.class.getName(), "EKK1071C051", "1", param);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		//サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		//サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_KIKI_SVC_KEI);
		
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071C051CBSMsg.SVC_KEI_NO, adHbiErrForKikiSvcKei);
		//異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1071C051CBSMsg.IDO_DIV, adHbiErrForKikiSvcKei);
		//審査実施機能識別コード
		setSvcIFMapping(jdgJssiKinoSkbtCd, EKK1071C051CBSMsg.JDG_JSSI_KINO_SKBT_CD, adHbiErrForKikiSvcKei);
		//審査番号
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C051CBSMsg.JUDGE_NO, adHbiErrForKikiSvcKei);
		//料金グループコード
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.PRC_GRP_CD), EKK1071C051CBSMsg.PRC_GRP_CD, adHbiErrForKikiSvcKei);
		
		//機器提供サービス契約リストを取得
		ArrayList<HashMap<String, String>> kktkSvcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0341ETMsg.getTableName());
		// 機器提供サービス契約明細
		setKktkInfoList(kktkSvcKeiList, adHbiErrForKikiSvcKei);
		
		// 更新年月日時分秒(更新前)
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.UPD_DTM), EKK1071C051CBSMsg.UPD_DTM_BF, adHbiErrForKikiSvcKei);
		
		caanList.add(adHbiErrForKikiSvcKei);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071C051(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 審査判定結果を返却
		CAANMsg rsltTemp = rsltCaanList.get(0);
		
		svcKeiMap.put(KK0081ETMsg.UPD_DTM, rsltTemp.getString(EKK1071C051CBSMsg.UPD_DTM));
		
		return rsltTemp.getString(EKK1071C051CBSMsg.JUDGE_JUDGE_RSLT_CD);
	}
	
	/**
	 * <dd>メソッド名	：execAdHbiErrForSeikyKei
	 * <dd>メソッド説明	：住所不備チェック(請求契約情報)を行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @return 審査判定結果コード
	 * @throws Throwable 業務サービス内で発生した例外全般。
	 */
	public String execAdHbiErrForSeikyKei(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		/* 住所不備請求契約情報審査SIF */
		// サービスIF共通の設定処理を実施
		CAANMsg adHbiErrForSeikyKeiTemp = editInMsg(EKK1071C061CBSMsg.class.getName(), "EKK1071C061", "1", param);
		
		
		//サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		//サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_SEIKY_KEI);
		
		// 審査実施機能識別コード
		setSvcIFMapping(jdgJssiKinoSkbtCd, EKK1071C061CBSMsg.JDG_JSSI_KINO_SKBT_CD, adHbiErrForSeikyKeiTemp);
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071C061CBSMsg.SVC_KEI_NO, adHbiErrForSeikyKeiTemp);
		// 審査番号
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C061CBSMsg.JUDGE_NO, adHbiErrForSeikyKeiTemp);
		//異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1071C061CBSMsg.IDO_DIV, adHbiErrForSeikyKeiTemp);
		
		//請求契約リスト
		ArrayList<HashMap<String, String>> seikyuKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0491ETMsg.getTableName());
		//請求契約マップを取得
		HashMap<String, String> seikyuKeiMap = seikyuKeiList.get(0);
		//送付先住所コード
		setSvcIFMapping(seikyuKeiMap.get(KK0491ETMsg.SOHUS_AD_CD), EKK1071C061CBSMsg.SOHUS_AD_CD, adHbiErrForSeikyKeiTemp);
		//送付先郵便番号
		setSvcIFMapping(seikyuKeiMap.get(KK0491ETMsg.SOHUS_PCD), EKK1071C061CBSMsg.SOHUS_PCD, adHbiErrForSeikyKeiTemp);
		//送付先都道府県名
		setSvcIFMapping(seikyuKeiMap.get(KK0491ETMsg.SOHUS_STATE_NM), EKK1071C061CBSMsg.SOHUS_STATE_NM, adHbiErrForSeikyKeiTemp);
		//送付先市区町村名
		setSvcIFMapping(seikyuKeiMap.get(KK0491ETMsg.SOHUS_CITY_NM), EKK1071C061CBSMsg.SOHUS_CITY_NM, adHbiErrForSeikyKeiTemp);
		//送付先大字通称名
		setSvcIFMapping(seikyuKeiMap.get(KK0491ETMsg.SOHUS_OAZTSU_NM), EKK1071C061CBSMsg.SOHUS_OAZTSU_NM, adHbiErrForSeikyKeiTemp);
		//送付先字丁目名
		setSvcIFMapping(seikyuKeiMap.get(KK0491ETMsg.SOHUS_AZCHO_NM), EKK1071C061CBSMsg.SOHUS_AZCHO_NM, adHbiErrForSeikyKeiTemp);
		// --住所課題対応-STR-----------------------
		// 送付先番地号
		setSvcIFMapping(seikyuKeiMap.get(KK0491ETMsg.SOHUS_BNCHIGO), EKK1071C061CBSMsg.SOHUS_BNCHIGO, adHbiErrForSeikyKeiTemp);
		// 送付先住所手動入力フラグ
		setSvcIFMapping(seikyuKeiMap.get(JKKJudgeConstCC.SOHUS_AD_MAN_INPUT_FLG), EKK1071C061CBSMsg.SOHUS_AD_MAN_INPUT_FLG, adHbiErrForSeikyKeiTemp);
		// --住所課題対応-END-----------------------
		// 更新年月日時分秒(更新前)
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.UPD_DTM), EKK1071C061CBSMsg.UPD_DTM_BF, adHbiErrForSeikyKeiTemp);
		// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
		if(null != seikyuKeiMap.get(KK0491ETMsg.SOHUS_AD_CD) 
				&& !("".equals(seikyuKeiMap.get(KK0491ETMsg.SOHUS_AD_CD))) 
				&& null != seikyuKeiMap.get(KK0491ETMsg.SOHUS_PCD) 
				&& !("".equals(seikyuKeiMap.get(KK0491ETMsg.SOHUS_PCD))))
		{
			// 送付先住所チェックレベル
			setSvcIFMapping(AD_CHK_LV_2, EKK1071C061CBSMsg.SOHUS_AD_CHK_LV, adHbiErrForSeikyKeiTemp);
		}
		else
		{
			// 送付先住所チェックレベル
			setSvcIFMapping(null, EKK1071C061CBSMsg.SOHUS_AD_CHK_LV, adHbiErrForSeikyKeiTemp);
		}
		// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
		// 20130403 IT1-2013-0000551 Add Start
		// 請求契約番号
		setSvcIFMapping(seikyuKeiMap.get(KK0491ETMsg.SEIKY_KEI_NO), EKK1071C061CBSMsg.SEIKY_KEI_NO, adHbiErrForSeikyKeiTemp);
		// 20130403 IT1-2013-0000551 Add End

		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();

		caanList.add(adHbiErrForSeikyKeiTemp);

		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071C061(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 審査判定結果を返却
		CAANMsg rsltTemp = rsltCaanList.get(0);
		
		return rsltTemp.getString(EKK1071C061CBSMsg.JUDGE_JUDGE_RSLT_CD);

	}
	
	/**
	 * <dd>メソッド名	：execKshbiErrForSeikyKei
	 * <dd>メソッド説明	：記載不備チェック(請求契約情報)を行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @return 審査判定結果コード
	 * @throws Throwable 業務サービス内で発生した例外全般。
	 */
	public String execKshbiErrForSeikyKei(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		/* 記載不備請求契約情報審査SIF */
		// サービスIF共通の設定処理を実施
		CAANMsg kshbiErrForSeikyKeiTemp = editInMsg(EKK1071C071CBSMsg.class.getName(), "EKK1071C071", "1", param);
		
		
		//サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		//サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_SEIKY_KEI);
		
		// 審査実施機能識別コード
		setSvcIFMapping(jdgJssiKinoSkbtCd, EKK1071C071CBSMsg.JDG_JSSI_KINO_SKBT_CD, kshbiErrForSeikyKeiTemp);
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071C071CBSMsg.SVC_KEI_NO, kshbiErrForSeikyKeiTemp);
		// 審査番号
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C071CBSMsg.JUDGE_NO, kshbiErrForSeikyKeiTemp);
		//異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1071C071CBSMsg.IDO_DIV, kshbiErrForSeikyKeiTemp);
		
		//クレジットカードリスト
		ArrayList<HashMap<String, String>> creCardList = (ArrayList<HashMap<String, String>>)param.getData(KK0521ETMsg.getTableName());
		if(isListNull(creCardList))
		{
			//クレジットカード会社コード
			setSvcIFMapping(null, EKK1071C071CBSMsg.CRECARD_COMP_CD, kshbiErrForSeikyKeiTemp);
			//クレジットカード事業コード
			setSvcIFMapping(null, EKK1071C071CBSMsg.CRECARD_JIGYO_CD, kshbiErrForSeikyKeiTemp);
			//クレジットカード番号
			setSvcIFMapping(null, EKK1071C071CBSMsg.CRECARD_NO, kshbiErrForSeikyKeiTemp);
		}
		else
		{
			//クレジットカードマップを取得
			HashMap<String, String> creCardMap = creCardList.get(0);
			//クレジットカード会社コード
			setSvcIFMapping(creCardMap.get(KK0521ETMsg.CRECARD_COMP_CD), EKK1071C071CBSMsg.CRECARD_COMP_CD, kshbiErrForSeikyKeiTemp);
			//クレジットカード事業コード
			setSvcIFMapping(creCardMap.get(KK0521ETMsg.CRECARD_JIGYO_CD), EKK1071C071CBSMsg.CRECARD_JIGYO_CD, kshbiErrForSeikyKeiTemp);
			//クレジットカード番号
			setSvcIFMapping(JPCEditString.Rtrim(creCardMap.get(KK0521ETMsg.CRECARD_NO)), EKK1071C071CBSMsg.CRECARD_NO, kshbiErrForSeikyKeiTemp);
		}
		
		//請求契約リスト
		ArrayList<HashMap<String, String>> seikyuKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0491ETMsg.getTableName());
		//請求契約マップを取得
		HashMap<String, String> seikyuKeiMap = seikyuKeiList.get(0);
		//請求契約番号
		setSvcIFMapping(seikyuKeiMap.get(KK0491ETMsg.SEIKY_KEI_NO), EKK1071C071CBSMsg.SEIKY_KEI_NO, kshbiErrForSeikyKeiTemp);
		
		// 請求契約情報を取得
		setSeikyKeiOneInfo(handle, param);
		
		// 更新年月日時分秒(更新前)
		setSvcIFMapping(seikyuKeiMap.get(KK0491ETMsg.UPD_DTM), EKK1071C071CBSMsg.UPD_DTM_BF, kshbiErrForSeikyKeiTemp);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();

		caanList.add(kshbiErrForSeikyKeiTemp);

		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071C071(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 審査判定結果を返却
		CAANMsg rsltTemp = rsltCaanList.get(0);
		
		seikyuKeiMap.put(KK0491ETMsg.UPD_DTM, rsltTemp.getString(EKK1071C071CBSMsg.UPD_DTM));
		
		return rsltTemp.getString(EKK1071C071CBSMsg.JUDGE_JUDGE_RSLT_CD);

	}
	
	/**
	 * <dd>メソッド名	：execKshbiErrForTelNoInfo
	 * <dd>メソッド説明	：記載不備チェック(電話番号情報)を行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @return 審査判定結果コード
	 * @throws Throwable 業務サービス内で発生した例外全般。
	 */
	public String execKshbiErrForTelNoInfo(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		/* 記載不備電話番号情報審査SIF */
		// サービスIF共通の設定処理を実施
		CAANMsg kshbiErrForTelNoInfoTemp = editInMsg(EKK1071C081CBSMsg.class.getName(), "EKK1071C081", "1", param);
		
		
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_FOR_TEL_NO);
		
		//サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		//サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		// 審査実施機能識別コード
		setSvcIFMapping(jdgJssiKinoSkbtCd, EKK1071C081CBSMsg.JDG_JSSI_KINO_SKBT_CD, kshbiErrForTelNoInfoTemp);
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071C081CBSMsg.SVC_KEI_NO, kshbiErrForTelNoInfoTemp);
		//異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1071C081CBSMsg.IDO_DIV, kshbiErrForTelNoInfoTemp);
		// 審査番号
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C081CBSMsg.JUDGE_NO, kshbiErrForTelNoInfoTemp);
		
		//サービス契約内訳<eo光電話>リストを取得
		ArrayList<HashMap<String, String>> svcKeiUwEohTelList = (ArrayList<HashMap<String, String>>)param.getData(KK0191ETMsg.getTableName());
		// サービス契約内訳<eo光電話>リストを設定
		setEmgNoList(svcKeiUwEohTelList, kshbiErrForTelNoInfoTemp);
		
		// 更新年月日時分秒(更新前)
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.UPD_DTM), EKK1071C081CBSMsg.UPD_DTM_BF, kshbiErrForTelNoInfoTemp);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();

		caanList.add(kshbiErrForTelNoInfoTemp);

		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071C081(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 審査判定結果を返却
		CAANMsg rsltTemp = rsltCaanList.get(0);
		
		// 20130409 IT1-2013-0000551 Delete Start
//		// ▼▼▼ 2012/11/5 ST1-2012-0000805 Add Start ▼▼▼
//		// 審査判定結果コードが"01"(NG)の場合、桁数チェックをせずにコードを返す
//		if(!(JKKJudgeConstCC.RSLT_OK.equals(rsltTemp.getString(EKK1071C081CBSMsg.JUDGE_JUDGE_RSLT_CD))))
//		{
//			return rsltTemp.getString(EKK1071C081CBSMsg.JUDGE_JUDGE_RSLT_CD);
//		}
//		
//		ArrayList<String> telNoList = new ArrayList<String>();
//		
//		// サービス契約内訳リストから電話番号のリストを作成
//		for(HashMap<String, String> svcKeiUwEohTelMap : svcKeiUwEohTelList)
//		{
//			String trgTelNo = svcKeiUwEohTelMap.get(KK0191ETMsg.TELNO);
//			if(null != trgTelNo && !("".equals(trgTelNo)))
//			{
//				telNoList.add(trgTelNo);
//			}
//		}
//		
//		/* サービス契約内訳一覧照会SIF */
//		// サービスIF共通の設定処理を実施
//		CAANMsg svcKeiUcwkMap = editInMsg(EKK0161B001CBSMsg.class.getName(), "EKK0161B001", "1", param);
//		
//		// サービス契約番号
//		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK0161B001CBSMsg.KEY_SVC_KEI_NO, svcKeiUcwkMap);
//
//		caanList = new ArrayList<CAANMsg>();
//		caanList.add(svcKeiUcwkMap);
//
//		// サービスIFの実施
//		Map<?, ?> rsltMap2 = executeSvcIF(caanList, param, handle);
//
//		editErrorInfoEKK0161B001(param, rsltMap2);
//		//エラー情報のマップを取得
//		errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
//		if(errList == null)
//		{
//			errList = new ArrayList<Object>();
//		}
//		// コントロールマップに設定
//		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap2, errList));
//		// 結果をリストで取得
//		ArrayList<CAANMsg> rsltCaanList2 = getRsltList(rsltMap2);
//		
//		CAANMsg svcKeiUcwkRsltTemp = rsltCaanList2.get(0);
//		CAANMsg[] svcKeiUcwkRsltList = svcKeiUcwkRsltTemp.getCAANMsgList(EKK0161B001CBSMsg.EKK0161B001CBSMSG1LIST);
//		
//		// サービス契約内訳の取得結果数繰り返す
//		for(int i = 0; svcKeiUcwkRsltList.length > i; i++)
//		{
//			String telNo = "";			// 電話番号
//			String emgKshNm = "";		// 緊急通報用契約者名
//			String emgKshKana = "";		// 緊急通報用契約者カナ名
//			
//			// サービス契約内訳ステータスが"受付済","照査済","締結済","サービス提供中"以外の場合は対象外
//			String svcKeiUcwkStat = svcKeiUcwkRsltList[i].getString(EKK0161B001CBSMsg1List.SVC_KEI_UCWK_STAT);
//			if(!("010".equals(svcKeiUcwkStat) || "020".equals(svcKeiUcwkStat) 
//					|| "030".equals(svcKeiUcwkStat) || "100".equals(svcKeiUcwkStat)))
//			{
//				continue;
//			}
//			/* サービス契約内訳<eo光電話>一意照会SIF */
//			// サービスIF共通の設定処理を実施
//			CAANMsg svcKeiUcwkTelMap = editInMsg(EKK0191A010CBSMsg.class.getName(), "EKK0191A010", "1", param);
//			
//			// サービス契約内訳番号
//			setSvcIFMapping(svcKeiUcwkRsltList[i].getString(EKK0161B001CBSMsg1List.SVC_KEI_UCWK_NO), EKK0191A010CBSMsg.KEY_SVC_KEI_UCWK_NO, svcKeiUcwkTelMap);
//			// 世代登録年月日時分秒
//			setSvcIFMapping(svcKeiUcwkRsltList[i].getString(EKK0161B001CBSMsg1List.GENE_ADD_DTM), EKK0191A010CBSMsg.KEY_GENE_ADD_DTM, svcKeiUcwkTelMap);
//			
//			caanList = new ArrayList<CAANMsg>();
//			caanList.add(svcKeiUcwkTelMap);
//
//			// サービスIFの実施
//			Map<?, ?> rsltMap3 = executeSvcIF(caanList, param, handle);
//
//			editErrorInfoEKK0191A010(param, rsltMap3);
//			//エラー情報のマップを取得
//			errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
//			if(errList == null)
//			{
//				errList = new ArrayList<Object>();
//			}
//			// コントロールマップに設定
//			param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap3, errList));
//			// 結果をリストで取得
//			ArrayList<CAANMsg> rsltCaanList3 = getRsltList(rsltMap3);
//			
//			CAANMsg svcKeiUcwkTelRsltTemp = rsltCaanList3.get(0);
//			CAANMsg[] svcKeiUcwkTelRsltList = svcKeiUcwkTelRsltTemp.getCAANMsgList(EKK0191A010CBSMsg.EKK0191A010CBSMSG1LIST);
//			
//			// 内訳情報から電話番号を取得
//			telNo = svcKeiUcwkTelRsltList[0].getString(EKK0191A010CBSMsg1List.TELNO);
//			
//			if(null == telNo || "".equals(telNo))
//			{
//				continue;
//			}
//			// 電話番号リストと照合し、一致した番号の緊急通報用契約者名と緊急通報用契約者カナ名を取得
////			for(int j = 0; j < telNoList.size(); j++)
////			{
////				if(telNo.equals(telNoList.get(j)))
////				{
////					emgKshNm = svcKeiUcwkTelRsltList[0].getString(EKK0191A010CBSMsg1List.EMG_KSH_NM);
////					emgKshKana = svcKeiUcwkTelRsltList[0].getString(EKK0191A010CBSMsg1List.EMG_KSH_KANA);
////					break;
////				}
////			}
////			if(null == emgKshNm || "".equals(emgKshNm) || null == emgKshKana || "".equals(emgKshKana))
////			{
////				continue;
////			}
////			// 緊急通報用契約者名と緊急通報用契約者カナ名のいずれかが最大桁数を超えている場合はＮＧを返す
////			if(emgKshNm.length() > JKKJudgeConstCC.EMG_KSH_NM_SIZE || emgKshKana.length() > JKKJudgeConstCC.EMG_KSH_KANA_SIZE)
////			{
////				/* 審査結果反映SIF */
////				// サービスIF共通の設定処理を実施
////				CAANMsg jdgRsltHaneiMap = editInMsg(EKK1071C010CBSMsg.class.getName(), "EKK1071C010", "1", param);
////				
////				CAANMsg[] caanlist = new CAANMsg[1];
////				
////				CAANMsg caan = new CAANMsg(EKK1071C010CBSMsg1List.class.getName());
////				
////				// 審査番号
////				setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C010CBSMsg1List.JUDGE_NO, caan);
////				
////				// 審査年月日 ← 運用年月日
////				setSvcIFMapping(JCCBPCommon.getOpeDate(null), EKK1071C010CBSMsg1List.JUDGE_YMD, caan);
////				
////				// 審査判定結果コード ← 審査判定結果コード（ＮＧ）
////				setSvcIFMapping(JKKJudgeConstCC.RSLT_NG, EKK1071C010CBSMsg1List.JUDGE_JUDGE_RSLT_CD, caan);
////				
////				// 更新年月日時分秒（更新前）
////				setSvcIFMapping(rsltTemp.getString(EKK1071C081CBSMsg.UPD_DTM), EKK1071C010CBSMsg1List.UPD_DTM_BF, caan);
////				
////				caanlist[0] = caan;
////				
////				// 審査更新明細を設定
////				jdgRsltHaneiMap.set(EKK1071C010CBSMsg.EKK1071C010CBSMSG1LIST, caanlist);
////				
////				caanList = new ArrayList<CAANMsg>();
////				caanList.add(jdgRsltHaneiMap);
////				
////				// サービスIFの実施
////				Map<?, ?> rsltMap4 = executeSvcIF(caanList, param, handle);
////
////				editErrorInfoEKK1071C010(param, rsltMap4);
////				//エラー情報のマップを取得
////				errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
////				if(errList == null)
////				{
////					errList = new ArrayList<Object>();
////				}
////				// コントロールマップに設定
////				param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap4, errList));
////				
////				return JKKJudgeConstCC.RSLT_NG;
////			}
//		}
//		// ▲▲▲ 2012/11/5 ST1-2012-0000805 Add End ▲▲▲
		// 20130409 IT1-2013-0000551 Delete End
		
		return rsltTemp.getString(EKK1071C081CBSMsg.JUDGE_JUDGE_RSLT_CD);

	}
	
	/**
	 * <dd>メソッド名	：execAdhbiErrForTelNoInfo
	 * <dd>メソッド説明	：住所不備チェック(電話番号情報)を行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @return 審査判定結果コード
	 * @throws Throwable 業務サービス内で発生した例外全般。
	 */
	public String execAdHbiErrForTelNoInfo(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		/* 住所不備電話番号情報審査SIF */
		// サービスIF共通の設定処理を実施
		CAANMsg kshbiErrForTelNoInfoTemp = editInMsg(EKK1071C151CBSMsg.class.getName(), "EKK1071C151", "1", param);
		
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_FOR_TEL_NO);
		
		//サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		//サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		// 審査実施機能識別コード
		setSvcIFMapping(jdgJssiKinoSkbtCd, EKK1071C151CBSMsg.JDG_JSSI_KINO_SKBT_CD, kshbiErrForTelNoInfoTemp);
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071C151CBSMsg.SVC_KEI_NO, kshbiErrForTelNoInfoTemp);
		// 異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1071C151CBSMsg.IDO_DIV, kshbiErrForTelNoInfoTemp);
		// 審査番号
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C151CBSMsg.JUDGE_NO, kshbiErrForTelNoInfoTemp);
		
		// サービス契約回線内訳リストを取得
		ArrayList<HashMap<String, String>> svcKeiKaiUwList = (ArrayList<HashMap<String, String>>)param.getData(KK0251ETMsg.getTableName());
		// サービス契約回線内訳マップを取得
		HashMap<String, String> svcKeiKaiUwMap = svcKeiKaiUwList.get(0);
		// 回線場所住所コード
		setSvcIFMapping(svcKeiKaiUwMap.get(KK0251ETMsg.KAISEN_PLACE_AD_CD), EKK1071C151CBSMsg.KAISEN_PLACE_AD_CD, kshbiErrForTelNoInfoTemp);
		// 回線場所郵便番号
		setSvcIFMapping(svcKeiKaiUwMap.get(KK0251ETMsg.KAISEN_PLACE_PCD), EKK1071C151CBSMsg.KAISEN_PLACE_PCD, kshbiErrForTelNoInfoTemp);
		// 回線場所都道府県名
		setSvcIFMapping(svcKeiKaiUwMap.get(KK0251ETMsg.KAISEN_PLACE_STATE_NM), EKK1071C151CBSMsg.KAISEN_PLACE_STATE_NM, kshbiErrForTelNoInfoTemp);
		// 回線場所市区町村名
		setSvcIFMapping(svcKeiKaiUwMap.get(KK0251ETMsg.KAISEN_PLACE_CITY_NM), EKK1071C151CBSMsg.KAISEN_PLACE_CITY_NM, kshbiErrForTelNoInfoTemp);
		// 回線場所大字通称名
		setSvcIFMapping(svcKeiKaiUwMap.get(KK0251ETMsg.KAISEN_PLACE_OAZTSU_NM), EKK1071C151CBSMsg.KAISEN_PLACE_OAZTSU_NM, kshbiErrForTelNoInfoTemp);
		// 回線場所字丁目名
		setSvcIFMapping(svcKeiKaiUwMap.get(KK0251ETMsg.KAISEN_PLACE_AZCHO_NM), EKK1071C151CBSMsg.KAISEN_PLACE_AZCHO_NM, kshbiErrForTelNoInfoTemp);
		// 回線場所番地号
		setSvcIFMapping(svcKeiKaiUwMap.get(KK0251ETMsg.KAISEN_PLACE_BNCHIGO), EKK1071C151CBSMsg.KAISEN_PLACE_BNCHIGO, kshbiErrForTelNoInfoTemp);
		// 回線場所住所未確定フラグ
		setSvcIFMapping(svcKeiKaiUwMap.get(KK0251ETMsg.KISN_PLC_AD_MI_FIX_FLG), EKK1071C151CBSMsg.KISN_PLC_AD_MI_FIX_FLG, kshbiErrForTelNoInfoTemp);
		
		//サービス契約内訳<eo光電話>リストを取得
		ArrayList<HashMap<String, String>> svcKeiUwEohTelList = (ArrayList<HashMap<String, String>>)param.getData(KK0191ETMsg.getTableName());
		// サービス契約内訳<eo光電話>リストを設定
		CAANMsg[] caanlist = new CAANMsg[0];
		
		// サービス契約内訳＜eo光電話＞リストがnull以外かつ、サイズが0以上の場合
		if(svcKeiUwEohTelList != null && svcKeiUwEohTelList.size() > 0)
		{
			caanlist = new CAANMsg[svcKeiUwEohTelList.size()];
			
			int cnt = 0;
			for(HashMap<String, String> svcKeiUwEohTelMap : svcKeiUwEohTelList)
			{
				CAANMsg caan = new CAANMsg(EKK1071C151CBSMsg1List.class.getName());
				
				if(null == svcKeiUwEohTelMap)
				{
					// 緊急通報用住所コード
					setSvcIFMapping(null, EKK1071C151CBSMsg1List.EMG_AD_CD, caan);
					// 緊急通報用郵便番号
					setSvcIFMapping(null, EKK1071C151CBSMsg1List.EMG_HOSEI_PCD, caan);
					// 緊急通報用都道府県名
					setSvcIFMapping(null, EKK1071C151CBSMsg1List.EMG_STATE_NM, caan);
					// 緊急通報用市区町村名
					setSvcIFMapping(null, EKK1071C151CBSMsg1List.EMG_CITY_NM, caan);
					// 緊急通報用大字通称名
					setSvcIFMapping(null, EKK1071C151CBSMsg1List.EMG_OAZTSU_NM, caan);
					// 緊急通報用字丁目名
					setSvcIFMapping(null, EKK1071C151CBSMsg1List.EMG_AZCHO_NM, caan);
					// 緊急通報用番地号
					setSvcIFMapping(null, EKK1071C151CBSMsg1List.EMG_BNCHIGO, caan);
					// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
					// 緊急通報用住所チェックレベル
					setSvcIFMapping(null, EKK1071C151CBSMsg1List.EMG_AD_CHK_LV, caan);
					// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
				}
				else
				{
					// 緊急通報用住所コード
					setSvcIFMapping(svcKeiUwEohTelMap.get(KK0191ETMsg.EMG_AD_CD), EKK1071C151CBSMsg1List.EMG_AD_CD, caan);
					// 緊急通報用郵便番号
					setSvcIFMapping(svcKeiUwEohTelMap.get(KK0191ETMsg.EMG_HOSEI_PCD), EKK1071C151CBSMsg1List.EMG_HOSEI_PCD, caan);
					// 緊急通報用都道府県名
					setSvcIFMapping(svcKeiUwEohTelMap.get(KK0191ETMsg.EMG_STATE_NM), EKK1071C151CBSMsg1List.EMG_STATE_NM, caan);
					// 緊急通報用市区町村名
					setSvcIFMapping(svcKeiUwEohTelMap.get(KK0191ETMsg.EMG_CITY_NM), EKK1071C151CBSMsg1List.EMG_CITY_NM, caan);
					// 緊急通報用大字通称名
					setSvcIFMapping(svcKeiUwEohTelMap.get(KK0191ETMsg.EMG_OAZTSU_NM), EKK1071C151CBSMsg1List.EMG_OAZTSU_NM, caan);
					// 緊急通報用字丁目名
					setSvcIFMapping(svcKeiUwEohTelMap.get(KK0191ETMsg.EMG_AZCHO_NM), EKK1071C151CBSMsg1List.EMG_AZCHO_NM, caan);
					// 緊急通報用番地号
					setSvcIFMapping(svcKeiUwEohTelMap.get(KK0191ETMsg.EMG_BNCHIGO), EKK1071C151CBSMsg1List.EMG_BNCHIGO, caan);
					// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
					if(null != svcKeiUwEohTelMap.get(KK0191ETMsg.EMG_AD_CD) 
							&& !("".equals(svcKeiUwEohTelMap.get(KK0191ETMsg.EMG_AD_CD))) 
							&& null != svcKeiUwEohTelMap.get(KK0191ETMsg.EMG_HOSEI_PCD) 
							&& !("".equals(svcKeiUwEohTelMap.get(KK0191ETMsg.EMG_HOSEI_PCD))))
					{
						// 緊急通報用住所チェックレベル
						setSvcIFMapping(AD_CHK_LV_1, EKK1071C151CBSMsg1List.EMG_AD_CHK_LV, caan);
					}
					else
					{
						// 緊急通報用住所チェックレベル
						setSvcIFMapping(null, EKK1071C151CBSMsg1List.EMG_AD_CHK_LV, caan);
					}
					// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
				}
				
				caanlist[cnt++] = caan;
			}
		}
		
		// 緊急通報用住所コードリストを設定
		kshbiErrForTelNoInfoTemp.set(EKK1071C151CBSMsg.EKK1071C151CBSMSG1LIST, caanlist);
		
		// 更新年月日時分秒(更新前)
// 2012/10/03 IT1-2012-0001075 del start
//		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.UPD_DTM), EKK1071C151CBSMsg.UPD_DTM_BF, kshbiErrForTelNoInfoTemp);
// 2012/10/03 IT1-2012-0001075 del end
// 2012/10/03 IT1-2012-0001075 add start
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.UPD_DTM), EKK1071C151CBSMsg.UPD_DTM_BF, kshbiErrForTelNoInfoTemp);
// 2012/10/03 IT1-2012-0001075 add end
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();

		caanList.add(kshbiErrForTelNoInfoTemp);

		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071C151(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 審査判定結果を返却
		CAANMsg rsltTemp = rsltCaanList.get(0);
		
		return rsltTemp.getString(EKK1071C151CBSMsg.JUDGE_JUDGE_RSLT_CD);

	}
	
	/**
	 * <dd>メソッド名	：execAreaErr
	 * <dd>メソッド説明	：エリアチェックを行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @param funcCd 機能コード
	 * @return 審査判定結果コード
	 * @throws Throwable 業務サービス内で発生した例外全般。
	 */
	public String execAreaErr(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		// 住所不備(サービス契約情報)でエラーが発生している場合はチェックを実施しない。
		if(!isAdHbiOK(handle, param))
		{
			return "";
		}
		
		/* エリアチェック審査SIF */
		// サービスIF共通の設定処理を実施
		CAANMsg areaErrTemp = editInMsg(EKK1071C091CBSMsg.class.getName(), "EKK1071C091", "1", param);
		
		
		//サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		//サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		//サービス契約回線内訳リスト
		ArrayList<HashMap<String, String>> svcKeiKaisenUwList = (ArrayList<HashMap<String, String>>)param.getData(KK0251ETMsg.getTableName());
		
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(JKKJudgeConstCC.JUDGE_SBT_AREA);
		
		// 審査実施機能識別コード
		setSvcIFMapping(jdgJssiKinoSkbtCd, EKK1071C091CBSMsg.JDG_JSSI_KINO_SKBT_CD, areaErrTemp);
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071C091CBSMsg.SVC_KEI_NO, areaErrTemp);
		// 審査番号
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C091CBSMsg.JUDGE_NO, areaErrTemp);
		// 異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1071C091CBSMsg.IDO_DIV, areaErrTemp);
		// サービスコード
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_CD), EKK1071C091CBSMsg.SVC_CD, areaErrTemp);
		// 料金グループコード
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.PRC_GRP_CD), EKK1071C091CBSMsg.PRC_GRP_CD, areaErrTemp);
		// 料金コースコード
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.PCRS_CD), EKK1071C091CBSMsg.PCRS_CD, areaErrTemp);
		// 料金プランコード
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.PPLAN_CD), EKK1071C091CBSMsg.PPLAN_CD, areaErrTemp);
		
		// サービス契約回線内訳情報が取得できない場合
		if(isListNull(svcKeiKaisenUwList))
		{
			//回線場所住所コード
			setSvcIFMapping(null, EKK1071C091CBSMsg.KAISEN_PLACE_AD_CD, areaErrTemp);
			//回線場所郵便番号
			setSvcIFMapping(null, EKK1071C091CBSMsg.KAISEN_PLACE_PCD, areaErrTemp);
			//回線場所都道府県名
			setSvcIFMapping(null, EKK1071C091CBSMsg.KAISEN_PLACE_STATE_NM, areaErrTemp);
			//回線場所市区町村名
			setSvcIFMapping(null, EKK1071C091CBSMsg.KAISEN_PLACE_CITY_NM, areaErrTemp);
			//回線場所大字通称名
			setSvcIFMapping(null, EKK1071C091CBSMsg.KAISEN_PLACE_OAZTSU_NM, areaErrTemp);
			//回線場所字丁目名
			setSvcIFMapping(null, EKK1071C091CBSMsg.KAISEN_PLACE_AZCHO_NM, areaErrTemp);
			//回線場所番地号
			setSvcIFMapping(null, EKK1071C091CBSMsg.KAISEN_PLACE_BNCHIGO, areaErrTemp);
			//経度
			setSvcIFMapping(null, EKK1071C091CBSMsg.LGTD, areaErrTemp);
			//緯度
			setSvcIFMapping(null, EKK1071C091CBSMsg.LTTD, areaErrTemp);
		}
		else
		{
			//サービス契約回線内訳マップを取得
			HashMap<String, String> svcKeiKaisenUwMap = svcKeiKaisenUwList.get(0);
			
			// サービス契約回線内訳マップに経度、緯度を設定
			setSvcKeiKaisenInfo(svcKeiKaisenUwMap, param, handle);
			
			//回線場所住所コード
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_AD_CD), EKK1071C091CBSMsg.KAISEN_PLACE_AD_CD, areaErrTemp);
			//回線場所郵便番号
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_PCD), EKK1071C091CBSMsg.KAISEN_PLACE_PCD, areaErrTemp);
			//回線場所都道府県名
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_STATE_NM), EKK1071C091CBSMsg.KAISEN_PLACE_STATE_NM, areaErrTemp);
			//回線場所市区町村名
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_CITY_NM), EKK1071C091CBSMsg.KAISEN_PLACE_CITY_NM, areaErrTemp);
			//回線場所大字通称名
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_OAZTSU_NM), EKK1071C091CBSMsg.KAISEN_PLACE_OAZTSU_NM, areaErrTemp);
			//回線場所字丁目名
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_AZCHO_NM), EKK1071C091CBSMsg.KAISEN_PLACE_AZCHO_NM, areaErrTemp);
			//回線場所番地号
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_BNCHIGO), EKK1071C091CBSMsg.KAISEN_PLACE_BNCHIGO, areaErrTemp);
			//経度
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.LGTD), EKK1071C091CBSMsg.LGTD, areaErrTemp);
			//緯度
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.LTTD), EKK1071C091CBSMsg.LTTD, areaErrTemp);
			// マンション物件番号
			setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.MANSION_BUKKEN_NO), EKK1071C091CBSMsg.MANSION_BUKKEN_NO, areaErrTemp);
		}

		// 更新年月日時分秒(更新前)
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.UPD_DTM), EKK1071C091CBSMsg.UPD_DTM_BF, areaErrTemp);


		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();

		caanList.add(areaErrTemp);

		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071C091(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 審査判定結果を返却
		CAANMsg rsltTemp = rsltCaanList.get(0);
		
		return rsltTemp.getString(EKK1071C091CBSMsg.JUDGE_JUDGE_RSLT_CD);
	}
	
	/**
	 * <dd>メソッド名	：execHuryoCustErr
	 * <dd>メソッド説明	：不良顧客チェックを行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @return 審査判定結果コード
	 * @throws Throwable 業務サービス内で発生した例外全般。
	 */
	public String execHuryoCustErr(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		// サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		// サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		// お客様リストを取得
		ArrayList<HashMap<String, String>> custList = (ArrayList<HashMap<String, String>>)param.getData(CK0011ETMsg.getTableName());
		// お客様マップを取得
		HashMap<String, String> custMap = custList.get(0);
		
		// 請求契約リストを取得
		ArrayList<HashMap<String, String>> seikyKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0491ETMsg.getTableName());
		// 請求契約マップを取得
		HashMap<String, String> seikyKeiMap = seikyKeiList.get(0);
		
		// お客様＜個人＞リストを取得
		ArrayList<HashMap<String, String>> custKojinList = (ArrayList<HashMap<String, String>>)param.getData(CK0021ETMsg.getTableName());
		
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(JKKJudgeConstCC.JUDGE_SBT_HURYO_CUST);
		
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		
		/* 不良顧客審査SIF */
		// サービスIF共通の設定処理を実施
		CAANMsg huryoCustErr = editInMsg(EKK1071C101CBSMsg.class.getName(), "EKK1071C101", "1", param);
		// 審査実施機能識別コード
		setSvcIFMapping(jdgJssiKinoSkbtCd, EKK1071C101CBSMsg.JDG_JSSI_KINO_SKBT_CD, huryoCustErr);
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071C101CBSMsg.SVC_KEI_NO, huryoCustErr);
		// 異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1071C101CBSMsg.IDO_DIV, huryoCustErr);
		// 審査番号
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C101CBSMsg.JUDGE_NO, huryoCustErr);
		//お客様名
		setSvcIFMapping(custMap.get(CK0011ETMsg.CUST_NM), EKK1071C101CBSMsg.CUST_NM, huryoCustErr);
		//お客様カナ名
		setSvcIFMapping(custMap.get(CK0011ETMsg.CUST_KANA), EKK1071C101CBSMsg.CUST_KANA, huryoCustErr);
		//契約者電話番号
		setSvcIFMapping(custMap.get(CK0011ETMsg.KEISHA_TELNO), EKK1071C101CBSMsg.KEISHA_TELNO, huryoCustErr);
		
		// お客様＜個人＞が設定されていない場合
		if(isListNull(custKojinList))
		{
			// 親権者名
			setSvcIFMapping(null, EKK1071C101CBSMsg.SKSHA_NM, huryoCustErr);
			// 親権者カナ名
			setSvcIFMapping(null, EKK1071C101CBSMsg.SKSHA_KANA, huryoCustErr);
			// 親権者電話番号
			setSvcIFMapping(null, EKK1071C101CBSMsg.SKSHA_TELNO, huryoCustErr);
		}
		else
		{
			HashMap<String, String> custKojinMap = custKojinList.get(0);
			// 親権者名
			setSvcIFMapping(custKojinMap.get(CK0021ETMsg.SKSHA_NM), EKK1071C101CBSMsg.SKSHA_NM, huryoCustErr);
			// 親権者カナ名
			setSvcIFMapping(custKojinMap.get(CK0021ETMsg.SKSHA_KANA), EKK1071C101CBSMsg.SKSHA_KANA, huryoCustErr);
			// 親権者電話番号
			setSvcIFMapping(custKojinMap.get(CK0021ETMsg.SKSHA_TELNO), EKK1071C101CBSMsg.SKSHA_TELNO, huryoCustErr);
		}
		//送付先カナ名
		setSvcIFMapping(seikyKeiMap.get(KK0491ETMsg.SHS_KANA), EKK1071C101CBSMsg.SHS_KANA, huryoCustErr);
		//送付先電話番号
		setSvcIFMapping(seikyKeiMap.get(KK0491ETMsg.SOHUS_TELNO), EKK1071C101CBSMsg.SOHUS_TELNO, huryoCustErr);
		// 更新年月日時分秒(更新前)
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.UPD_DTM), EKK1071C101CBSMsg.UPD_DTM_BF, huryoCustErr);
		
		
		caanList.add(huryoCustErr);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071C101(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 審査判定結果を返却
		CAANMsg rsltTemp = rsltCaanList.get(0);
		
		return rsltTemp.getString(EKK1071C101CBSMsg.JUDGE_JUDGE_RSLT_CD);
	}
	
	/**
	 * <dd>メソッド名	：execBmpAreaErr
	 * <dd>メソッド説明	：番ポエリアチェックを行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @param funcCd 機能コード
	 * @return 審査判定結果コード
	 * @throws Throwable 業務サービス内で発生した例外全般。
	 */
	public String execBmpAreaErr(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		// 20130410 IT1-2013-0000551 Delete Start
//		// 住所不備(サービス契約情報)でエラーが発生している場合はチェックを実施しない。
//		if(!isAdHbiOK(handle, param))
//		{
//			return "";
//		}
		// 20130410 IT1-2013-0000551 Delete End
		
		// サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		// サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);

		// サービス契約内訳＜eo光電話＞リストを取得
		ArrayList<HashMap<String, String>> svkeiuwEohTelList = (ArrayList<HashMap<String, String>>)param.getData(KK0191ETMsg.getTableName());

		// サービス契約回線内訳リストを取得
		ArrayList<HashMap<String, String>> svkeiKaisenUwList = (ArrayList<HashMap<String, String>>)param.getData(KK0251ETMsg.getTableName());

		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(JKKJudgeConstCC.JUDGE_SBT_BMP_AREA);

		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();


		/* 番ポエリア審査SIF */
		// サービスIF共通の設定処理を実施
		CAANMsg bmpAreaErr = editInMsg(EKK1071C111CBSMsg.class.getName(), "EKK1071C111", "1", param);
		
		// 審査実施機能識別コード
		setSvcIFMapping(jdgJssiKinoSkbtCd, EKK1071C111CBSMsg.JDG_JSSI_KINO_SKBT_CD, bmpAreaErr);
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071C111CBSMsg.SVC_KEI_NO, bmpAreaErr);
		// 異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1071C111CBSMsg.IDO_DIV, bmpAreaErr);
		// 審査番号
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C111CBSMsg.JUDGE_NO, bmpAreaErr);
		
		
		// サービス契約内訳＜eo光電話＞リスト（電話番号）を設定
		setTelNoList(svkeiuwEohTelList, bmpAreaErr);
		
		// サービス契約回線内訳情報が取得できなかった場合
		if(isListNull(svkeiKaisenUwList))
		{
			// 回線場所住所コード
			setSvcIFMapping(null, EKK1071C111CBSMsg.KAISEN_PLACE_AD_CD, bmpAreaErr);
		}
		else
		{
			HashMap<String, String> svkeiKaisenUwMap = svkeiKaisenUwList.get(0);
			// 回線場所住所コード
			setSvcIFMapping(svkeiKaisenUwMap.get(KK0251ETMsg.KAISEN_PLACE_AD_CD), EKK1071C111CBSMsg.KAISEN_PLACE_AD_CD, bmpAreaErr);
		}
		
		// 更新年月日時分秒(更新前)
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.UPD_DTM), EKK1071C111CBSMsg.UPD_DTM_BF, bmpAreaErr);

		caanList.add(bmpAreaErr);

		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071C111(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 審査判定結果を返却
		CAANMsg rsltTemp = rsltCaanList.get(0);
		
		return rsltTemp.getString(EKK1071C111CBSMsg.JUDGE_JUDGE_RSLT_CD);

	}
	
	/**
	 * <dd>メソッド名	：execTajuAddErr
	 * <dd>メソッド説明	：多重登録チェックを行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @return 審査判定結果コード
	 * @throws Throwable 業務サービス内で発生した例外全般。
	 */
	public String execTajuAddErr(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		// サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		// サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		// お客様リストを取得
		ArrayList<HashMap<String, String>> custList = (ArrayList<HashMap<String, String>>)param.getData(CK0011ETMsg.getTableName());
		// お客様マップを取得
		HashMap<String, String> custMap = custList.get(0);
		
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(JKKJudgeConstCC.JUDGE_SBT_TAJU_ADD);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		/* 多重登録審査SIF */
		// サービスIF共通の設定処理を実施
		CAANMsg tajuAddErr = editInMsg(EKK1071C121CBSMsg.class.getName(), "EKK1071C121", "1", param);
		
		// 審査実施機能識別コード
		setSvcIFMapping(jdgJssiKinoSkbtCd, EKK1071C121CBSMsg.JDG_JSSI_KINO_SKBT_CD, tajuAddErr);
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071C121CBSMsg.SVC_KEI_NO, tajuAddErr);
		// 異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1071C121CBSMsg.IDO_DIV, tajuAddErr);
		// 審査番号
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C121CBSMsg.JUDGE_NO, tajuAddErr);
		// お客様名
		setSvcIFMapping(custMap.get(CK0011ETMsg.CUST_NM), EKK1071C121CBSMsg.CUST_NM, tajuAddErr);
		// お客様カナ名
		setSvcIFMapping(custMap.get(CK0011ETMsg.CUST_KANA), EKK1071C121CBSMsg.CUST_KANA, tajuAddErr);
		// お客様生年月日
		setSvcIFMapping(custMap.get(CK0011ETMsg.CUST_BIRTHD), EKK1071C121CBSMsg.CUST_BIRTHD, tajuAddErr);
		// SYSID
		setSvcIFMapping(custMap.get(CK0011ETMsg.SYSID), EKK1071C121CBSMsg.SYSID, tajuAddErr);
		
		// 更新年月日時分秒(更新前)
		setSvcIFMapping(custMap.get(CK0011ETMsg.UPD_DTM), EKK1071C121CBSMsg.UPD_DTM_BF, tajuAddErr);
		
		caanList.add(tajuAddErr);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071C121(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// 審査判定結果を返却
		CAANMsg rsltTemp = rsltCaanList.get(0);
		
		custMap.put(CK0011ETMsg.UPD_DTM, rsltTemp.getString(EKK1071C121CBSMsg.UPD_DTM));
		
		return rsltTemp.getString(EKK1071C121CBSMsg.JUDGE_JUDGE_RSLT_CD);
	}
	
	/**
	 * <dd>メソッド名	：execKshbiErrForKikiSvcKei
	 * <dd>メソッド説明	：記載不備（機器サービス契約）チェックを行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @return 審査判定結果コード
	 * @throws Throwable 業務サービス内で発生した例外全般。
	 */
	public String execKshbiErrForKikiSvcKei(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		// サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		// サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		//機器提供サービス契約リストを取得
		ArrayList<HashMap<String, String>> kktkSvcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0341ETMsg.getTableName());
		
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(JKKJudgeConstCC.JUDGE_SBT_KS_HBI_KIKI_SVC_KEI);
		
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		/* 記載不備(機器サービス契約)審査SIF */
		// サービスIF共通の設定処理を実施
		CAANMsg kshbiErrForKikiSvcKei = editInMsg(EKK1071C131CBSMsg.class.getName(), "EKK1071C131", "1", param);
		
		// 審査実施機能識別コード
		setSvcIFMapping(jdgJssiKinoSkbtCd, EKK1071C131CBSMsg.JDG_JSSI_KINO_SKBT_CD, kshbiErrForKikiSvcKei);
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071C131CBSMsg.SVC_KEI_NO, kshbiErrForKikiSvcKei);
		// 異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1071C131CBSMsg.IDO_DIV, kshbiErrForKikiSvcKei);
		// 審査番号
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C131CBSMsg.JUDGE_NO, kshbiErrForKikiSvcKei);
		// 料金グループコード
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.PRC_GRP_CD), EKK1071C131CBSMsg.PRC_GRP_CD, kshbiErrForKikiSvcKei);
		// 料金コースコード
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.PCRS_CD), EKK1071C131CBSMsg.PCRS_CD, kshbiErrForKikiSvcKei);
		
		// 機器提供サービス契約明細
		setKktkSvcKeiList(kktkSvcKeiList, kshbiErrForKikiSvcKei);
		// 機器在庫情報明細
		setZaikoInfoList(handle, param, kktkSvcKeiList, kshbiErrForKikiSvcKei);
		// 機器MACアドレス明細
		setMacadList(handle, param, kktkSvcKeiList, kshbiErrForKikiSvcKei);
		
		// 更新年月日時分秒(更新前)
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.UPD_DTM), EKK1071C131CBSMsg.UPD_DTM_BF, kshbiErrForKikiSvcKei);
		
		caanList.add(kshbiErrForKikiSvcKei);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071C131(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		// 審査判定結果を返却
		CAANMsg rsltTemp = rsltCaanList.get(0);
		
		svcKeiMap.put(KK0081ETMsg.UPD_DTM, rsltTemp.getString(EKK1071C131CBSMsg.UPD_DTM));
		
		return rsltTemp.getString(EKK1071C131CBSMsg.JUDGE_JUDGE_RSLT_CD);
	}
	
	
	/**
	 * <dd>メソッド名	：execPayWayErr
	 * <dd>メソッド説明	：支払方法チェックを行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param jdgSetMap 審査情報マップ
	 * @param jdgJssiKinoSkbtCd 審査実施機能識別コード
	 * @return 審査判定結果コード
	 * @throws Throwable 業務サービス内で発生した例外全般。
	 */
	public String execPayWayErr(SessionHandle handle, IRequestParameterReadWrite param,
			HashMap<String, HashMap<String, String>> jdgSetMap, String jdgJssiKinoSkbtCd) throws Throwable
	{
		// サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		// サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		// 請求契約リストを取得
		ArrayList<HashMap<String, String>> seikyKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0491ETMsg.getTableName());
		// 請求契約マップを取得
		HashMap<String, String> seikyKeiMap = seikyKeiList.get(0);
		
		//クレジットカードリスト
		ArrayList<HashMap<String, String>> creCardList = (ArrayList<HashMap<String, String>>)param.getData(KK0521ETMsg.getTableName());
		
		// 審査設定情報を取得
		HashMap<String, String> jdgInMap = jdgSetMap.get(JKKJudgeConstCC.JUDGE_SBT_PAY_WAY);
		
		// 請求方法番号（クレジットカード）を取得
		String[] seikyWayNoInfo = getSeikyWayNoCrecard(handle, param);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		/* 支払方法審査SIF */
		// サービスIF共通の設定処理を実施
		CAANMsg payWayErr = editInMsg(EKK1071C141CBSMsg.class.getName(), "EKK1071C141", "1", param);
		
		// 審査実施機能識別コード
		setSvcIFMapping(jdgJssiKinoSkbtCd, EKK1071C141CBSMsg.JDG_JSSI_KINO_SKBT_CD, payWayErr);
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071C141CBSMsg.SVC_KEI_NO, payWayErr);
		// 異動区分
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.IDO_DIV), EKK1071C141CBSMsg.IDO_DIV, payWayErr);
		// 審査番号
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.JUDGE_NO), EKK1071C141CBSMsg.JUDGE_NO, payWayErr);
		// 請求契約番号
		setSvcIFMapping(seikyKeiMap.get(KK0491ETMsg.SEIKY_KEI_NO), EKK1071C141CBSMsg.SEIKY_KEI_NO, payWayErr);
		// 請求契約_世代登録年月日時分秒
		setSvcIFMapping(seikyKeiMap.get(KK0491ETMsg.GENE_ADD_DTM), EKK1071C141CBSMsg.KK0491_GENE_ADD_DTM, payWayErr);
		
		// クレジットカード情報を取得できない場合
		if(isListNull(creCardList))
		{
			// 請求方法番号（クレジットカード）
			setSvcIFMapping(null, EKK1071C141CBSMsg.SEIKY_WAY_NO_CRECARD, payWayErr);
			// クレジットカード_世代登録年月日時分秒
			setSvcIFMapping(null, EKK1071C141CBSMsg.KK0521_GENE_ADD_DTM, payWayErr);
			// クレジットカード会社コード
			setSvcIFMapping(null, EKK1071C141CBSMsg.CRECARD_COMP_CD, payWayErr);
			// クレジットカード番号
			setSvcIFMapping(null, EKK1071C141CBSMsg.CRECARD_NO, payWayErr);

		}
		else
		{
			//クレジットカードマップを取得
			HashMap<String, String> creCardMap = creCardList.get(0);
			
			// 請求方法番号（クレジットカード）
			setSvcIFMapping(seikyWayNoInfo[0], EKK1071C141CBSMsg.SEIKY_WAY_NO_CRECARD, payWayErr);
			// クレジットカード_世代登録年月日時分秒
			setSvcIFMapping(creCardMap.get(KK0521ETMsg.GENE_ADD_DTM), EKK1071C141CBSMsg.KK0521_GENE_ADD_DTM, payWayErr);
			// クレジットカード会社コード
			setSvcIFMapping(creCardMap.get(KK0521ETMsg.CRECARD_COMP_CD), EKK1071C141CBSMsg.CRECARD_COMP_CD, payWayErr);
			// クレジットカード番号
			setSvcIFMapping(creCardMap.get(KK0521ETMsg.CRECARD_NO), EKK1071C141CBSMsg.CRECARD_NO, payWayErr);

		}
		
		if (null == seikyWayNoInfo[1])
		{
			// 請求方法番号（口座）
			setSvcIFMapping(null, EKK1071C141CBSMsg.SEIKY_WAY_NO_KOZA, payWayErr);
		}
		else
		{
			// 請求方法番号（口座）
			setSvcIFMapping(seikyWayNoInfo[1], EKK1071C141CBSMsg.SEIKY_WAY_NO_KOZA, payWayErr);
		}
		
		// 更新年月日時分秒(更新前)
		setSvcIFMapping(jdgInMap.get(KK1071ETMsg.UPD_DTM), EKK1071C141CBSMsg.UPD_DTM_BF, payWayErr);
		
		caanList.add(payWayErr);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071C141(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		// 審査判定結果を返却
		CAANMsg rsltTemp = rsltCaanList.get(0);
		
		return rsltTemp.getString(EKK1071C141CBSMsg.JUDGE_JUDGE_RSLT_CD);
	}
	
	
	/**
	 * 機器提供サービス契約の機器提供サービスコードのマッピングを実施する。
	 * @param kktkSvcKeiList 機器提供サービス契約リスト
	 * @param ksHbiErrForSvcKei 記載不備チェック(サービス契約情報)メッセージ
	 * @throws Throwable
	 */
	private void setKktkSvcCdList(ArrayList<HashMap<String, String>> kktkSvcKeiList, CAANMsg ksHbiErrForSvcKei) throws Throwable
	{
		CAANMsg[] caanlist = new CAANMsg[0];
		// 機器提供サービス契約情報がnull以外かつ、サイズが0以上の場合
		if(kktkSvcKeiList != null && kktkSvcKeiList.size() > 0)
		{
			caanlist = new CAANMsg[kktkSvcKeiList.size()];
			
			int cnt = 0;
			for(HashMap<String, String> kktkSvcKeiMap : kktkSvcKeiList)
			{
				CAANMsg caan = new CAANMsg(EKK1071C021CBSMsg1List.class.getName());
				
				if(kktkSvcKeiMap == null)
				{
					// 機器提供サービスコード
					setSvcIFMapping(null, EKK1071C021CBSMsg1List.KKTK_SVC_CD, caan);
				}
				else
				{
					// 機器提供サービスコード
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KKTK_SVC_CD), EKK1071C021CBSMsg1List.KKTK_SVC_CD, caan);
				}
				
				caanlist[cnt++] = caan;
			}
		}
		// 機器提供サービスコード明細
		ksHbiErrForSvcKei.set(EKK1071C021CBSMsg.EKK1071C021CBSMSG1LIST, caanlist);
	}
	
	/**
	 * 割引サービス契約の割引サービスコードのマッピングを実施する。
	 * @param wribSvcKeiList 割引サービス契約リスト
	 * @param ksHbiErrForSvcKei 記載不備チェック(サービス契約情報)メッセージ
	 * @throws Throwable
	 */
	private void setWribSvcCdList(ArrayList<HashMap<String, String>> wribSvcKeiList, CAANMsg ksHbiErrForSvcKei) throws Throwable
	{
		CAANMsg[] caanlist = new CAANMsg[0];
		// 割引サービス契約情報がnull以外かつ、サイズが0以上の場合
		if(wribSvcKeiList != null && wribSvcKeiList.size() > 0)
		{
			caanlist = new CAANMsg[wribSvcKeiList.size()];
			
			int cnt = 0;
			for(HashMap<String, String> wribSvcKeiMap : wribSvcKeiList)
			{
				CAANMsg caan = new CAANMsg(EKK1071C021CBSMsg2List.class.getName());
				
				if(wribSvcKeiMap == null)
				{
					// 割引サービスコード
					setSvcIFMapping(null, EKK1071C021CBSMsg2List.WRIB_SVC_CD, caan);
				}
				else
				{
					// 割引サービスコード
					setSvcIFMapping(wribSvcKeiMap.get(KK0451ETMsg.WRIB_SVC_CD), EKK1071C021CBSMsg2List.WRIB_SVC_CD, caan);
				}
				
				caanlist[cnt++] = caan;
			}
		}
		
		
		// 割引サービスコード明細
		ksHbiErrForSvcKei.set(EKK1071C021CBSMsg.EKK1071C021CBSMSG2LIST, caanlist);
	}
	
	/**
	 * お客様のＳＹＳＩＤのマッピングを実施する。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param custMap お客様情報
	 * @param kshbiErrForCust 記載不備チェック(サービス契約情報)メッセージ
	 * @throws Throwable
	 */
	private void setSysidList(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, String> custMap, 
						CAANMsg kshbiErrForCust) throws Throwable
	{
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		
		/* お客様一覧照会（姓一致）サービスIF */
		CAANMsg custTemp = editInMsg(ECK0011B006CBSMsg.class.getName(), "ECK0011B006", "1", param);
		
		// お客様名の姓のみを取得
		String custNm = custMap.get(CK0011ETMsg.CUST_NM);
		if(custNm != null)
		{
			String[] custNmArray = custNm.split("　");
			custNm = custNmArray[0];
		}
		
		// お客様名
		setSvcIFMapping(custNm, ECK0011B006CBSMsg.KEY_CUST_NM, custTemp);
		
		caanList.add(custTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoECK0011B006(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		// お客様一覧照会（姓一致）の結果を記載不備お客様情報審査明細に設定
		CAANMsg rsltTemp = rsltCaanList.get(0);
		CAANMsg[] rsltList = rsltTemp.getCAANMsgList(ECK0011B006CBSMsg.ECK0011B006CBSMSG1LIST);
		
		ArrayList<String> custList = new ArrayList<String>();
		// １件目に審査対象のSYSIDを設定
		custList.add(custMap.get(CK0011ETMsg.SYSID));
		
		if(rsltList != null && rsltList.length > 0)
		{
			// SYSIDリストの１件目に入力のSYSIDを設定
			for(CAANMsg rsltInTemp : rsltList)
			{
				if(!custMap.get(CK0011ETMsg.SYSID).equals(rsltInTemp.getString(ECK0011B006CBSMsg1List.SYSID)))
				{
					// SYSID
					custList.add(rsltInTemp.getString(ECK0011B006CBSMsg1List.SYSID));
				}
			}
		}
		
		CAANMsg[] caanlist = new CAANMsg[custList.size()];
		
		// SYSIDリストの１件目に入力のSYSIDを設定
		for(int i = 0; i < custList.size() ; i++)
		{
			CAANMsg caan = new CAANMsg(EKK1071C041CBSMsg1List.class.getName());
			// SYSID
			setSvcIFMapping(custList.get(i), EKK1071C041CBSMsg1List.SYSID, caan);
			caanlist[i] = caan;
		}
		// 記載不備お客様情報審査明細
		kshbiErrForCust.set(EKK1071C041CBSMsg.EKK1071C041CBSMSG1LIST, caanlist);
	}
	
	/**
	 * 機器提供サービス契約の情報のマッピングを実施する。
	 * @param kktkSvcKeiList 機器提供サービス契約情報
	 * @param adHbiErrForKikiSvcKei 記載不備チェック(サービス契約情報)メッセージ
	 * @throws Throwable
	 */
	private void setKktkInfoList(ArrayList<HashMap<String, String>> kktkSvcKeiList, CAANMsg adHbiErrForKikiSvcKei) throws Throwable
	{
		CAANMsg[] caanlist = new CAANMsg[0];
		
		// 機器提供サービス契約情報がnull以外かつ、サイズが0以上の場合
		if(kktkSvcKeiList != null && kktkSvcKeiList.size() > 0)
		{
			caanlist = new CAANMsg[kktkSvcKeiList.size()];
			
			int cnt = 0;
			for(HashMap<String, String> kktkSvcKeiMap : kktkSvcKeiList)
			{
				CAANMsg caan = new CAANMsg(EKK1071C051CBSMsg1List.class.getName());
				
				if(kktkSvcKeiMap == null)
				{
					//機器送付先住所コード
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_SOHUS_AD_CD, caan);
					//機器送付先郵便番号
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_SOHUS_PCD, caan);
					//機器送付先都道府県名
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_SOHUS_STATE_NM, caan);
					//機器送付先市区町村名
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_SOHUS_CITY_NM, caan);
					//機器送付先大字通称名
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_SOHUS_OAZTSU_NM, caan);
					//機器送付先字丁目名
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_SOHUS_AZCHO_NM, caan);
					// --住所課題対応-STR-----------------------
					// 機器送付先番地号
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_SOHUS_BNCHIGO, caan);
					// 機器送付先住所手動入力フラグ
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_SOHUS_AD_MAN_INPUT_FLG, caan);
					// --住所課題対応-END-----------------------
					//機器設置先住所コード
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_AD_CD, caan);
					//機器設置先郵便番号
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_PCD, caan);
					//機器設置先都道府県名
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_STATE_NM, caan);
					//機器設置先市区町村名
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_CITY_NM, caan);
					//機器設置先大字通称名
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_OAZTSU_NM, caan);
					//機器設置先字丁目名
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_AZCHO_NM, caan);
					//機器提供サービスコード
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KKTK_SVC_CD, caan);
					// --住所課題対応-STR-----------------------
					// 機器設置先番地号
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_BNCHIGO, caan);
					// 機器設置先住所未確定フラグ
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_STC_AD_MI_FIX_FLG, caan);
					// --住所課題対応-END-----------------------
					// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
					// 機器送付先住所チェックレベル
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_SOHUS_AD_CHK_LV, caan);
					
					// 機器設置先住所チェックレベル
					setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_AD_CHK_LV, caan);
					// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
				}
				else
				{
					//機器送付先住所コード
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SOHUS_AD_CD), EKK1071C051CBSMsg1List.KIKI_SOHUS_AD_CD, caan);
					//機器送付先郵便番号
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SOHUS_PCD), EKK1071C051CBSMsg1List.KIKI_SOHUS_PCD, caan);
					//機器送付先都道府県名
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SOHUS_STATE_NM), EKK1071C051CBSMsg1List.KIKI_SOHUS_STATE_NM, caan);
					//機器送付先市区町村名
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SOHUS_CITY_NM), EKK1071C051CBSMsg1List.KIKI_SOHUS_CITY_NM, caan);
					//機器送付先大字通称名
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SOHUS_OAZTSU_NM), EKK1071C051CBSMsg1List.KIKI_SOHUS_OAZTSU_NM, caan);
					//機器送付先字丁目名
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SOHUS_AZCHO_NM), EKK1071C051CBSMsg1List.KIKI_SOHUS_AZCHO_NM, caan);
					// --住所課題対応-STR-----------------------
					// 機器送付先番地号
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SOHUS_BNCHIGO), EKK1071C051CBSMsg1List.KIKI_SOHUS_BNCHIGO, caan);
					// 機器送付先住所手動入力フラグ
					setSvcIFMapping(kktkSvcKeiMap.get(JKKJudgeConstCC.KIKI_SOHUS_AD_MAN_INPUT_FLG), EKK1071C051CBSMsg1List.KIKI_SOHUS_AD_MAN_INPUT_FLG, caan);
					// --住所課題対応-END-----------------------
					//機器設置先住所コード
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_STC_SAKI_AD_CD), EKK1071C051CBSMsg1List.KIKI_STC_SAKI_AD_CD, caan);
					//機器設置先郵便番号
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_STC_SAKI_PCD), EKK1071C051CBSMsg1List.KIKI_STC_SAKI_PCD, caan);
					//機器設置先都道府県名
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_STC_SAKI_STATE_NM), EKK1071C051CBSMsg1List.KIKI_STC_SAKI_STATE_NM, caan);
					//機器設置先市区町村名
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_STC_SAKI_CITY_NM), EKK1071C051CBSMsg1List.KIKI_STC_SAKI_CITY_NM, caan);
					//機器設置先大字通称名
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_STC_SAKI_OAZTSU_NM), EKK1071C051CBSMsg1List.KIKI_STC_SAKI_OAZTSU_NM, caan);
					//機器設置先字丁目名
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_STC_SAKI_AZCHO_NM), EKK1071C051CBSMsg1List.KIKI_STC_SAKI_AZCHO_NM, caan);
					//機器提供サービスコード
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KKTK_SVC_CD), EKK1071C051CBSMsg1List.KKTK_SVC_CD, caan);
					// --住所課題対応-STR-----------------------
					// 機器設置先番地号
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_STC_SAKI_BNCHIGO), EKK1071C051CBSMsg1List.KIKI_STC_SAKI_BNCHIGO, caan);
					// 機器設置先住所未確定フラグ
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.AD_MI_FIX_FLG), EKK1071C051CBSMsg1List.KIKI_STC_AD_MI_FIX_FLG, caan);
					// --住所課題対応-END-----------------------
					// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
					if(null != kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SOHUS_AD_CD) 
							&& !("".equals(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SOHUS_AD_CD))) 
							&& null != kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SOHUS_PCD) 
							&& !("".equals(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SOHUS_PCD))))
					{
						// 機器送付先住所チェックレベル
						setSvcIFMapping(AD_CHK_LV_2, EKK1071C051CBSMsg1List.KIKI_SOHUS_AD_CHK_LV, caan);
					}
					else
					{
						// 機器送付先住所チェックレベル
						setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_SOHUS_AD_CHK_LV, caan);
					}
					if(null != kktkSvcKeiMap.get(KK0341ETMsg.KIKI_STC_SAKI_AD_CD) 
							&& !("".equals(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_STC_SAKI_AD_CD))) 
							&& null != kktkSvcKeiMap.get(KK0341ETMsg.KIKI_STC_SAKI_PCD) 
							&& !("".equals(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_STC_SAKI_PCD))))
					{
						// 機器設置先住所チェックレベル
						setSvcIFMapping(AD_CHK_LV_1, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_AD_CHK_LV, caan);
					}
					else
					{
						// 機器設置先住所チェックレベル
						setSvcIFMapping(null, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_AD_CHK_LV, caan);
					}
					// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
				}
				
				caanlist[cnt++] = caan;
			}
		}
		
		
		// 機器提供サービス契約明細
		adHbiErrForKikiSvcKei.set(EKK1071C051CBSMsg.EKK1071C051CBSMSG1LIST, caanlist);
	}
	
	/**
	 * サービス契約内訳<eo光電話>の電話番号のマッピングを実施する。
	 * @param svkeiuwEohTelList サービス契約内訳<eo光電話>リスト
	 * @param ksHbiErrForSvcKei 
	 * @throws Throwable
	 */
	private void setTelNoList(ArrayList<HashMap<String, String>> svkeiuwEohTelList, CAANMsg ksHbiErrForSvcKei) throws Throwable
	{
		CAANMsg[] caanlist = new CAANMsg[0];
		
		// サービス契約内訳<eo光電話>情報がnull以外かつ、サイズが0以上の場合
		if(svkeiuwEohTelList != null && svkeiuwEohTelList.size() > 0)
		{
			ArrayList<CAANMsg> list = new ArrayList<CAANMsg>();
			
			for(HashMap<String, String> svkeiuwEohTelMap : svkeiuwEohTelList)
			{
				CAANMsg caan = new CAANMsg(EKK1071C111CBSMsg1List.class.getName());
				
				if(svkeiuwEohTelMap == null)
				{
					continue;
				}
				else
				{
					// 番ポ有無を取得
					String bmpUm = svkeiuwEohTelMap.get(KK0191ETMsg.BMP_UM);
					// 番ポ有無が有の場合
					if(JKKJudgeConstCC.UM_CD_1.equals(bmpUm))
					{
						// 電話番号
						setSvcIFMapping(svkeiuwEohTelMap.get(KK0191ETMsg.TELNO), EKK1071C111CBSMsg1List.TELNO, caan);
						// 番ポ有無
						setSvcIFMapping(svkeiuwEohTelMap.get(KK0191ETMsg.BMP_UM), EKK1071C111CBSMsg1List.BMP_UM, caan);
					}
					else
					{
						continue;
					}
				}
				list.add(caan);
			}
			
			caanlist = new CAANMsg[list.size()];
			int cnt = 0;
			for(CAANMsg temp : list)
			{
				caanlist[cnt++] = temp;
			}
		}
		
		// 電話番号
		ksHbiErrForSvcKei.set(EKK1071C111CBSMsg.EKK1071C111CBSMSG1LIST, caanlist);
	}
	
	/**
	 * サービス契約内訳<光電話>リストに設定値があるか判定をする。
	 * @param svcKeiUwEohTelList サービス契約内訳<eo光電話>リスト
	 * @param kshbiErrForTelNoInfoTemp
	 * @throws Throwable
	 */
	private void setEmgNoList(ArrayList<HashMap<String, String>> svcKeiUwEohTelList, CAANMsg kshbiErrForTelNoInfoTemp) throws Throwable
	{
		CAANMsg[] caanlist = new CAANMsg[0];
		
		// サービス契約内訳＜eo光電話＞リストがnull以外かつ、サイズが0以上の場合
		if(svcKeiUwEohTelList != null && svcKeiUwEohTelList.size() > 0)
		{
			caanlist = new CAANMsg[svcKeiUwEohTelList.size()];
			
			int cnt = 0;
			for(HashMap<String, String> svcKeiUwEohTelMap : svcKeiUwEohTelList)
			{
				CAANMsg caan = new CAANMsg(EKK1071C081CBSMsg1List.class.getName());
				
				if(svcKeiUwEohTelMap == null)
				{
					// 緊急通報用住所コード
					setSvcIFMapping(null, EKK1071C081CBSMsg1List.EMG_AD_CD, caan);
					// 電話番号
					setSvcIFMapping(null, EKK1071C081CBSMsg1List.TELNO, caan);
					// 緊急通報用契約者名
					setSvcIFMapping(null, EKK1071C081CBSMsg1List.EMG_KSH_NM, caan);
					// 緊急通報用契約者カナ名
					setSvcIFMapping(null, EKK1071C081CBSMsg1List.EMG_KSH_KANA, caan);
					// 20130410 IT1-2013-0000551 Add Start
					// 番ポ有無
					setSvcIFMapping(null, EKK1071C081CBSMsg1List.BMP_UM, caan);
					// 20130410 IT1-2013-0000551 Add End
				}
				else
				{
					// 緊急通報用住所コード
					setSvcIFMapping(svcKeiUwEohTelMap.get(KK0191ETMsg.EMG_AD_CD), EKK1071C081CBSMsg1List.EMG_AD_CD, caan);
					// 電話番号
					setSvcIFMapping(svcKeiUwEohTelMap.get(KK0191ETMsg.TELNO), EKK1071C081CBSMsg1List.TELNO, caan);
					// 緊急通報用契約者名
					setSvcIFMapping(svcKeiUwEohTelMap.get(KK0191ETMsg.EMG_KSH_NM), EKK1071C081CBSMsg1List.EMG_KSH_NM, caan);
					// 緊急通報用契約者カナ名
					setSvcIFMapping(svcKeiUwEohTelMap.get(KK0191ETMsg.EMG_KSH_KANA), EKK1071C081CBSMsg1List.EMG_KSH_KANA, caan);
					// 20130410 IT1-2013-0000551 Add Start
					// 番ポ有無
					setSvcIFMapping(svcKeiUwEohTelMap.get(KK0191ETMsg.BMP_UM), EKK1071C081CBSMsg1List.BMP_UM, caan);
					// 20130410 IT1-2013-0000551 Add End
				}
				
				caanlist[cnt++] = caan;
			}
		}
		
		// 緊急通報用住所コードリストを設定
		kshbiErrForTelNoInfoTemp.set(EKK1071C081CBSMsg.EKK1071C081CBSMSG1LIST, caanlist);
	}
	
	/**
	 * 機器提供サービス契約の情報のマッピングを実施する。
	 * @param kktkSvcKeiList 機器提供サービス契約リスト
	 * @param kshbiErrForKikiSvcKei 記載不備チェック(機器提供サービス契約情報)メッセージ
	 * @throws Throwable
	 */
	private void setKktkSvcKeiList(ArrayList<HashMap<String, String>> kktkSvcKeiList, CAANMsg kshbiErrForKikiSvcKei) throws Throwable
	{
		CAANMsg[] caanlist = new CAANMsg[0];
		// 機器提供サービス契約情報がnullまたは、サイズが0の場合
		if(kktkSvcKeiList != null && kktkSvcKeiList.size() > 0)
		{
			caanlist = new CAANMsg[kktkSvcKeiList.size()];
			
			int cnt = 0;
			for(HashMap<String, String> kktkSvcKeiMap : kktkSvcKeiList)
			{
				CAANMsg caan = new CAANMsg(EKK1071C131CBSMsg1List.class.getName());
				
				if(kktkSvcKeiMap == null)
				{
					// 機器提供サービスコード
					setSvcIFMapping(null, EKK1071C131CBSMsg1List.KKTK_SVC_CD, caan);
					// 宅内機器型式コード(機器提供サービス契約)
					setSvcIFMapping(null, EKK1071C131CBSMsg1List.KK0341_01_TAKNKIKI_MODEL_CD, caan);
					// 機器製造番号(機器提供サービス契約)
					setSvcIFMapping(null, EKK1071C131CBSMsg1List.KK0341_01_KIKI_SEIZO_NO, caan);
				}
				else
				{
					// 機器提供サービスコード
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KKTK_SVC_CD), EKK1071C131CBSMsg1List.KKTK_SVC_CD, caan);
					// 宅内機器型式コード(機器提供サービス契約)
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.TAKNKIKI_MODEL_CD), EKK1071C131CBSMsg1List.KK0341_01_TAKNKIKI_MODEL_CD, caan);
					// 機器製造番号(機器提供サービス契約)
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SEIZO_NO), EKK1071C131CBSMsg1List.KK0341_01_KIKI_SEIZO_NO, caan);
				}
				
				caanlist[cnt++] = caan;
			}
		}
		// 機器提供サービス契約明細
		kshbiErrForKikiSvcKei.set(EKK1071C131CBSMsg.EKK1071C131CBSMSG1LIST, caanlist);
	}
	
	/**
	 * 機器提供サービス契約の機器在庫のマッピングを実施する。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiList 機器提供サービス契約リスト
	 * @param kshbiErrForKikiSvcKei 記載不備チェック(機器提供サービス契約情報)メッセージ
	 * @throws Throwable
	 */
	private void setZaikoInfoList(SessionHandle handle, IRequestParameterReadWrite param, 
					ArrayList<HashMap<String, String>> kktkSvcKeiList, CAANMsg kshbiErrForKikiSvcKei) throws Throwable
	{
		CAANMsg[] caanlist = new CAANMsg[0];
		// ST1-2012-0000212 DELETE START
//		// 機器提供サービス契約情報がnull以外かつ、サイズが0以上の場合
//		if(kktkSvcKeiList != null && kktkSvcKeiList.size() > 0)
//		{
//			caanlist = new CAANMsg[kktkSvcKeiList.size()];
//			
//			int cnt = 0;
//			for(HashMap<String, String> kktkSvcKeiMap : kktkSvcKeiList)
//			{
//				CAANMsg caan = new CAANMsg(EKK1071C131CBSMsg2List.class.getName());
//				
//				if(kktkSvcKeiMap == null 
//						|| null == kktkSvcKeiMap.get(KK0341ETMsg.TAKNKIKI_MODEL_CD) 
//						|| "".equals(kktkSvcKeiMap.get(KK0341ETMsg.TAKNKIKI_MODEL_CD)))
//				{
//					// 宅内機器型式コード(機器在庫情報)
//					setSvcIFMapping(null, EKK1071C131CBSMsg2List.KK0341_02_TAKNKIKI_MODEL_CD, caan);
//					// 在庫数
//					setSvcIFMapping(null, EKK1071C131CBSMsg2List.ZAIKO_CNT, caan);
//				}
//				else
//				{
//					/* 宅内機器物流在庫一覧照会サービスIF**/
//					// サービスIF共通の設定処理を実施する
////					CAANMsg zaikoTemp = editInMsg(ETN0091B010CBSMsg.class.getName(), "ETN0091B010", "1", param);
//					CAANMsg zaikoTemp = editInMsg(EKKA0020005CBSMsg.class.getName(), "EKKA0020005", "1", param);
//					
//					ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
//					
////					// ＫＥＹ＿倉庫コード
////					setSvcIFMapping(null, ETN0091B010CBSMsg.KEY_SOKO_CD, zaikoTemp);
////					// ＫＥＹ＿棚コード
////					setSvcIFMapping(null, ETN0091B010CBSMsg.KEY_SHELF_CD, zaikoTemp);
////					// ＫＥＹ＿宅内機器型式コード
////					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.TAKNKIKI_MODEL_CD), ETN0091B010CBSMsg.KEY_TAKNKIKI_MODEL_CD, zaikoTemp);
////					// ＫＥＹ＿付属品型式コード
////					setSvcIFMapping(null, ETN0091B010CBSMsg.KEY_HUZOKUHIN_MODEL_CD, zaikoTemp);
//					
//					CAANMsg[] childList = new CAANMsg[1];
//					CAANMsg childTemplate = new CAANMsg(EKKA0020005CBSMsg1List.class.getName());
//					
//					// ＫＥＹ＿管理場所識別コード
//					setSvcIFMapping(null, EKKA0020005CBSMsg1List.KEY_KNRI_PLC_SKBT_CD, childTemplate);
//					// ＫＥＹ＿管理場所コード
//					setSvcIFMapping(null, EKKA0020005CBSMsg1List.KEY_KNRI_PLC_CD, childTemplate);
//					// ＫＥＹ＿管理場所棚コード
//					setSvcIFMapping(null, EKKA0020005CBSMsg1List.KEY_KNRI_PLC_SLF_CD, childTemplate);
//					// ＫＥＹ＿宅内機器型式コード
//					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.TAKNKIKI_MODEL_CD), EKKA0020005CBSMsg1List.KEY_TK_MDL_CD, childTemplate);
//					
//					childList[0] = childTemplate;
//					
//					zaikoTemp.set(EKKA0020005CBSMsg.EKKA0020005CBSMSG1LIST, childList);
//					
//					caanList.add(zaikoTemp);
//					
//					// サービスIFの実施
//					Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
//			        // エラー情報の設定
////					editErrorInfoETN0091B010(param, rsltMap);
//					editErrorInfoEKKA0020005(param, rsltMap);
//					//エラー情報のマップを取得
//					ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
//					if(errList == null)
//					{
//						errList = new ArrayList<Object>();
//					}
//					// コントロールマップに設定
//					param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
//					// 実行結果確認
//					scResultCheck(param, rsltMap);
//					// 結果をリストで取得
//					ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
//					
//					// 宅内機器物流在庫一覧照会の結果を機器在庫情報明細に設定
//					CAANMsg rsltTemp = rsltCaanList.get(0);
////					CAANMsg[] rsltList = rsltTemp.getCAANMsgList(ETN0091B010CBSMsg.ETN0091B010CBSMSG1LIST);
//					CAANMsg[] rsltList = rsltTemp.getCAANMsgList(EKKA0020005CBSMsg.EKKA0020005CBSMSG2LIST);
//					
//					// 宅内機器物流在庫一覧照会の結果を取得できなかった場合
//					if(rsltList == null || rsltList.length == 0)
//					{
//						// 宅内機器型式コード(機器在庫情報)
//						setSvcIFMapping(null, EKK1071C131CBSMsg2List.KK0341_02_TAKNKIKI_MODEL_CD, caan);
//						// 在庫数
//						setSvcIFMapping(null, EKK1071C131CBSMsg2List.ZAIKO_CNT, caan);
//					}
//					else
//					{
//						// 宅内機器物流在庫一覧照会で取得した在庫数を合計
//						long allZaikoCnt = 0;
//						for(CAANMsg zaikoRslt : rsltList)
//						{
////							long zaikoCnt = zaikoRslt.getLong(ETN0091B010CBSMsg1List.JZAIKO_CNT);
//							String zaikoCntStr = zaikoRslt.getString(EKKA0020005CBSMsg2List.JZAIKO_CNT);
//							if (null != zaikoCntStr && !"".equals(zaikoCntStr))
//							{
//								long zaikoCnt = new Long(zaikoCntStr).longValue();
//								allZaikoCnt = allZaikoCnt + zaikoCnt;
//							}
//						}
//						
//						// 宅内機器型式コード(機器在庫情報)
//						setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.TAKNKIKI_MODEL_CD), EKK1071C131CBSMsg2List.KK0341_02_TAKNKIKI_MODEL_CD, caan);
//						// 在庫数
//						String zaikoStr = new StringBuilder().append(allZaikoCnt).toString();
//						caan.set(EKK1071C131CBSMsg2List.ZAIKO_CNT, zaikoStr);
//
//					}
//				}
//				
//				caanlist[cnt++] = caan;
//			}
//		}
		// ST1-2012-0000212 DELETE END
		// 機器在庫情報明細
		kshbiErrForKikiSvcKei.set(EKK1071C131CBSMsg.EKK1071C131CBSMSG2LIST, caanlist);
	}
	
	/**
	 * 機器提供サービス契約のMACアドレスのマッピングを実施する。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param kktkSvcKeiList 機器提供サービス契約リスト
	 * @param kshbiErrForKikiSvcKei 記載不備チェック(機器提供サービス契約情報)メッセージ
	 * @throws Throwable
	 */
	private void setMacadList(SessionHandle handle, IRequestParameterReadWrite param, 
					ArrayList<HashMap<String, String>> kktkSvcKeiList, CAANMsg kshbiErrForKikiSvcKei) throws Throwable
	{
		CAANMsg[] caanlist = new CAANMsg[0];
		// 機器提供サービス契約情報がnullかつ、サイズが0以上の場合
		if(kktkSvcKeiList != null && kktkSvcKeiList.size() > 0)
		{
			caanlist = new CAANMsg[kktkSvcKeiList.size()];
			
			int cnt = 0;
			for(HashMap<String, String> kktkSvcKeiMap : kktkSvcKeiList)
			{
				CAANMsg caan = new CAANMsg(EKK1071C131CBSMsg3List.class.getName());
				// 2013/03/07 [ANK-1421-00-00]IP-STB対応 MOD START
				if(kktkSvcKeiMap == null || kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SEIZO_NO) == null || "".equals(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SEIZO_NO)))
				// 2013/03/07 [ANK-1421-00-00]IP-STB対応 MOD END
				{
					// 機器製造番号(機器MACアドレス)
					setSvcIFMapping(null, EKK1071C131CBSMsg3List.KK0341_02_KIKI_SEIZO_NO, caan);
					// MACアドレス
					setSvcIFMapping(null, EKK1071C131CBSMsg3List.MACAD, caan);
				}
				else
				{
					/* 宅内機器一意照会サービスIF**/
					// 2012/12/06 [TAI-2012-0000091]暫定ロジック修正対応 ADD START
					// サービスIF共通の設定処理を実施する
					CAANMsg kikiTemp = editInMsg(EKKA0020003CBSMsg.class.getName(), "EKKA0020003", "1", param);
					ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
					CAANMsg[] childList = new CAANMsg[1];
					CAANMsg childTemplate = new CAANMsg(EKKA0020003CBSMsg1List.class.getName());

					// ＫＥＹ＿宅内機器型式コード
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.TAKNKIKI_MODEL_CD), EKKA0020003CBSMsg1List.KEY_TK_MDL_CD, childTemplate);
					// ＫＥＹ＿機器製造番号
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SEIZO_NO), EKKA0020003CBSMsg1List.KEY_KK_SEIZO_NO, childTemplate);

					childList[0] = childTemplate;
					
					kikiTemp.set(EKKA0020003CBSMsg.EKKA0020003CBSMSG1LIST, childList);
					
					caanList.add(kikiTemp);

					// サービスIFの実施
					Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
			        // エラー情報の設定
					editErrorInfoEKKA0020003(param, rsltMap);
					//エラー情報のマップを取得
					ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
					if(errList == null)
					{
						errList = new ArrayList<Object>();
					}
					
					// コントロールマップに設定
					param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
					// 実行結果確認
					scResultCheck(param, rsltMap);
					// 結果をリストで取得
					ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
					
					// 宅内機器一意照会の結果を宅内機器情報明細に設定
					CAANMsg rsltTemp = rsltCaanList.get(0);
					CAANMsg[] rsltList = rsltTemp.getCAANMsgList(EKKA0020003CBSMsg.EKKA0020003CBSMSG2LIST);
					// MACアドレスを取得
					String macAd = null;
					if(rsltList != null && rsltList.length > 0)
					{
					 macAd = rsltList[0].getString(EKKA0020003CBSMsg2List.MAC_AD);
					}
					
					// 2012/12/06 [TAI-2012-0000091]暫定ロジック修正対応 ADD END

					// 機器製造番号(機器MACアドレス)
					setSvcIFMapping(kktkSvcKeiMap.get(KK0341ETMsg.KIKI_SEIZO_NO), EKK1071C131CBSMsg3List.KK0341_02_KIKI_SEIZO_NO, caan);
					// 2012/12/06 [TAI-2012-0000091]暫定ロジック修正対応 MOD START
//					setSvcIFMapping("111222333444", EKK1071C131CBSMsg3List.MACAD, caan);
					setSvcIFMapping(macAd, EKK1071C131CBSMsg3List.MACAD, caan);
					// 2012/12/06 [TAI-2012-0000091]暫定ロジック修正対応 MOD END
				}
				
				caanlist[cnt++] = caan;
			}
		}
		// 機器MACアドレス明細
		kshbiErrForKikiSvcKei.set(EKK1071C131CBSMsg.EKK1071C131CBSMSG3LIST, caanlist);
	}
	
	/**
	 * 請求契約の情報を取得する。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return 請求方法番号（クレジットカード）
	 * @throws Throwable
	 */
	private String[] getSeikyWayNoCrecard(SessionHandle handle, IRequestParameterReadWrite param) throws Throwable
	{
		
		// 請求契約リストを取得
		ArrayList<HashMap<String, String>> seikyList = (ArrayList<HashMap<String, String>>)param.getData(KK0491ETMsg.getTableName());
		// 請求契約マップを取得
		HashMap<String, String> seikyMap = seikyList.get(0);

		/* 請求契約一意照会サービスIF */
		CAANMsg seikyTemp = editInMsg(EKK0491A010CBSMsg.class.getName(), "EKK0491A010", "1", param);
		// ＫＥＹ＿請求契約番号
		setSvcIFMapping(seikyMap.get(KK0491ETMsg.SEIKY_KEI_NO), EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO, seikyTemp);
		// ＫＥＹ＿世代登録年月日時分秒
		setSvcIFMapping(seikyMap.get(KK0491ETMsg.GENE_ADD_DTM), EKK0491A010CBSMsg.KEY_GENE_ADD_DTM, seikyTemp);
		// ＫＥＹ＿予約適用年月日
		setSvcIFMapping(null, EKK0491A010CBSMsg.KEY_RSV_APLY_YMD, seikyTemp);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		caanList.add(seikyTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0491A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg rsltTemp = rsltCaanList.get(0);
		CAANMsg[] rsltList = rsltTemp.getCAANMsgList(EKK0491A010CBSMsg.EKK0491A010CBSMSG1LIST);
		String[] seikyWayNoInfo = new String[2];
		if(rsltList != null)
		{
			for(CAANMsg inTemp : rsltList)
			{
				// 結果コードを取得
				// 請求方法番号(クレジットカード)
				seikyWayNoInfo[0] = inTemp.getString(EKK0491A010CBSMsg1List.SEIKY_WAY_NO_CRECARD);
				// 請求方法番号(口座)
				seikyWayNoInfo[1] = inTemp.getString(EKK0491A010CBSMsg1List.SEIKY_WAY_NO_KOZA);
			}
		}
		
		return seikyWayNoInfo;
	}
	
	/**
	 * サービス契約回線内訳より経度、緯度を取得し、サービス契約回線内訳情報に設定する処理
	 * @param svcKeiKaisenUwMap サービス契約回線内訳情報
	 * @param param リクエストパラメータ
	 * @param handle セッションハンドル
	 * @throws Throwable 
	 */
	private void setSvcKeiKaisenInfo(HashMap<String, String> svcKeiKaisenUwMap, 
							IRequestParameterReadWrite param, SessionHandle handle) throws Throwable
	{
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		
		
		/* サービス契約回線内訳一意照会サービスIF */
		CAANMsg svcKeiKaisenUwTemp = editInMsg(EKK0251A010CBSMsg.class.getName(), "EKK0251A010", "2", param);
		// サービス契約回線内訳番号 → サービス契約回線内訳番号
		setSvcIFMapping(svcKeiKaisenUwMap.get(KK0251ETMsg.SVC_KEI_KAISEN_UCWK_NO), EKK0251A010CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO, svcKeiKaisenUwTemp);
		// 世代登録年月日時分秒 → 世代登録年月日時分秒
		setSvcIFMapping(null, EKK0251A010CBSMsg.KEY_GENE_ADD_DTM, svcKeiKaisenUwTemp);
		
		caanList.add(svcKeiKaisenUwTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0251A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg svcKeiKaisenUwRsltTemp = rsltCaanList.get(0);
		CAANMsg[] svcKeiKaisenUwRsltList = svcKeiKaisenUwRsltTemp.getCAANMsgList(EKK0251A010CBSMsg.EKK0251A010CBSMSG1LIST);
		
		if(svcKeiKaisenUwRsltList != null && svcKeiKaisenUwRsltList.length > 0)
		{
			// 経度を取得
			String lgtd = svcKeiKaisenUwRsltList[0].getString(EKK0251A010CBSMsg1List.LGTD);
			// 緯度を取得
			String lttd = svcKeiKaisenUwRsltList[0].getString(EKK0251A010CBSMsg1List.LTTD);
			// マンション物件番号を取得
			String mansionBukkenNo = svcKeiKaisenUwRsltList[0].getString(EKK0251A010CBSMsg1List.MANSION_BUKKEN_NO);
			// 経度をサービス契約回線内訳情報に設定
			svcKeiKaisenUwMap.put(KK0251ETMsg.LGTD, lgtd);
			// 緯度をサービス契約回線内訳情報に設定
			svcKeiKaisenUwMap.put(KK0251ETMsg.LTTD, lttd);
			// マンション物件番号をサービス契約回線内訳情報に設定
			svcKeiKaisenUwMap.put(KK0251ETMsg.MANSION_BUKKEN_NO, mansionBukkenNo);
		}
		
	}
	
	/**
	 * 住所不備チェック(サービス契約情報)でチェックエラーが発生しているか判定します。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return true：OK false：エラー
	 * @throws Throwable
	 */
	private boolean isAdHbiOK(SessionHandle handle, IRequestParameterReadWrite param) throws Throwable
	{
		
		// サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		// サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);

		// 審査結果の取得
		/* 審査一覧照会サービスIF */
		CAANMsg judgeTemp = editInMsg(EKK1071B011CBSMsg.class.getName(), "EKK1071B011", "1", param);
		// サービス契約番号
		setSvcIFMapping(svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK1071B011CBSMsg.KEY_SVC_KEI_NO, judgeTemp);
		//  審査番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_JUDGE_NO, judgeTemp);
		//  審査種別コード
		setSvcIFMapping(JKKJudgeConstCC.JUDGE_SBT_AD_HBI_SVC_KEI, EKK1071B011CBSMsg.KEY_JUDGE_SBT_CD, judgeTemp);
		//  審査対象種別コード
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_JUDGE_TG_SBT_CD, judgeTemp);
		//  機器提供サービス契約番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_KKTK_SVC_KEI_NO, judgeTemp);
		//  申込番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_MSKM_DTL_NO, judgeTemp);
		//  オプションサービス契約番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_OP_SVC_KEI_NO, judgeTemp);
		//  サブオプションサービス契約番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_SBOP_SVC_KEI_NO, judgeTemp);
		//  請求オプションサービス契約番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_SEIOPSVC_KEI_NO, judgeTemp);
		//  サービス契約内訳番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_SVC_KEI_UCWK_NO, judgeTemp);
		//  SYSID
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_SYSID, judgeTemp);
		//  割引サービス契約番号
		setSvcIFMapping(null, EKK1071B011CBSMsg.KEY_WRIB_SVC_KEI_NO, judgeTemp);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		caanList.add(judgeTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK1071B011(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg judgeRsltTemp = rsltCaanList.get(0);
		CAANMsg[] judgeRsltList = judgeRsltTemp.getCAANMsgList(EKK1071B011CBSMsg.EKK1071B011CBSMSG1LIST);
		String rsltCd = "";
		if(judgeRsltList != null)
		{
			for(CAANMsg judgeInTemp : judgeRsltList)
			{
				// 結果コードを取得
				rsltCd = judgeInTemp.getString(EKK1071B011CBSMsg1List.JUDGE_JUDGE_RSLT_CD);
			}
		}

		// 審査結果コードがNGかどうかを判定
		if(JKKJudgeConstCC.RSLT_NG.equals(rsltCd)) 
		{
			return false;
		} 
		else 
		{
			return true;
		}
	}
	
	/**
	 * お客様一意照会を実施
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return お客様情報
	 * @throws Throwable
	 */
	private void setCustOneInfo(SessionHandle handle, IRequestParameterReadWrite param) throws Throwable
	{
		
		// お客様リストを取得
		ArrayList<HashMap<String, String>> custList = (ArrayList<HashMap<String, String>>)param.getData(CK0011ETMsg.getTableName());
		// お客様マップを取得
		HashMap<String, String> custMap = custList.get(0);

		/* お客様一意照会サービスIF */
		CAANMsg custTemp = editInMsg(ECK0011A010CBSMsg.class.getName(), "ECK0011A010", "2", param);
		//  SYSID
		setSvcIFMapping((String)custMap.get(CK0011ETMsg.SYSID), ECK0011A010CBSMsg.KEY_SYSID, custTemp);
		//  世代登録年月日
		setSvcIFMapping(null, ECK0011A010CBSMsg.KEY_GENE_ADD_DTM, custTemp);
		//  予約適用年月日
		setSvcIFMapping((String)JCCBPCommon.getOpeDate(null), ECK0011A010CBSMsg.KEY_RSV_APLY_YMD, custTemp);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		caanList.add(custTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoECK0011A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg custRsltTemp = rsltCaanList.get(0);
		CAANMsg[] custRsltList = custRsltTemp.getCAANMsgList(ECK0011A010CBSMsg.ECK0011A010CBSMSG1LIST);
		
		custMap.put(CK0011ETMsg.UPD_DTM, custRsltList[0].getString(ECK0011A010CBSMsg1List.LAST_UPD_DTM));
	}
	
	/**
	 * 請求契約一意照会を実施
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return 請求契約情報
	 * @throws Throwable
	 */
	private void setSeikyKeiOneInfo(SessionHandle handle, IRequestParameterReadWrite param) throws Throwable
	{
		
		// 請求契約リストを取得
		ArrayList<HashMap<String, String>> seikyKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0491ETMsg.getTableName());
		// 請求契約マップを取得
		HashMap<String, String> seikyKeiMap = seikyKeiList.get(0);

		/* 請求契約一意照会サービスIF */
		CAANMsg judgeTemp = editInMsg(EKK0491A010CBSMsg.class.getName(), "EKK0491A010", "2", param);
		//  請求契約番号
		setSvcIFMapping((String)seikyKeiMap.get(KK0491ETMsg.SEIKY_KEI_NO), EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO, judgeTemp);
		//  世代登録年月日
		setSvcIFMapping(null, EKK0491A010CBSMsg.KEY_GENE_ADD_DTM, judgeTemp);
		//  予約適用年月日
		setSvcIFMapping("20991231", EKK0491A010CBSMsg.KEY_RSV_APLY_YMD, judgeTemp);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		caanList.add(judgeTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0491A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg seikyKeiRsltTemp = rsltCaanList.get(0);
		CAANMsg[] seikyKeiRsltList = seikyKeiRsltTemp.getCAANMsgList(EKK0491A010CBSMsg.EKK0491A010CBSMSG1LIST);
		
		seikyKeiMap.put(KK0491ETMsg.UPD_DTM, seikyKeiRsltList[0].getString(EKK0491A010CBSMsg1List.LAST_UPD_DTM));
	}
	
	/**
	 * サービス契約一意照会を実施
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return サービス契約情報
	 * @throws Throwable
	 */
	private void setSvcKeiOneInfo(SessionHandle handle, IRequestParameterReadWrite param) throws Throwable
	{
		// サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		// サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);

		/* サービス契約一意照会サービスIF */
		CAANMsg judgeTemp = editInMsg(EKK0081A010CBSMsg.class.getName(), "EKK0081A010", "2", param);
		//  サービス契約番号
		setSvcIFMapping((String)svcKeiMap.get(KK0081ETMsg.SVC_KEI_NO), EKK0081A010CBSMsg.KEY_SVC_KEI_NO, judgeTemp);
		//  世代登録年月日
		setSvcIFMapping(null, EKK0081A010CBSMsg.KEY_GENE_ADD_DTM, judgeTemp);
		//  予約適用年月日
		setSvcIFMapping((String)JCCBPCommon.getOpeDate(null), EKK0081A010CBSMsg.KEY_RSV_APLY_YMD, judgeTemp);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		caanList.add(judgeTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0081A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg svcKeiRsltTemp = rsltCaanList.get(0);
		CAANMsg[] svcKeiRsltList = svcKeiRsltTemp.getCAANMsgList(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);
		
		// 更新年月日時分秒を設定
		// 2013/02/13 [OT-2013-0000106]エラー確認時の排他エラー対応 MOD START
//		svcKeiMap.put(KK0081ETMsg.UPD_DTM, svcKeiRsltList[0].getString(EKK0081A010CBSMsg1List.UPD_DTM));
		svcKeiMap.put(KK0081ETMsg.UPD_DTM, svcKeiRsltList[0].getString(EKK0081A010CBSMsg1List.LAST_UPD_DTM));
		// 2013/02/13 [OT-2013-0000106]エラー確認時の排他エラー対応 MOD END
		// 20130403 IT1-2013-0000551 Add Start
		String svcCd = svcKeiMap.get(KK0081ETMsg.SVC_CD);
		String tkHoshikiKeiNo = svcKeiMap.get(KK0081ETMsg.TK_HOSHIKI_KEI_NO);
		if(null == svcCd || "".equals(svcCd))
		{
			// サービスコードを設定
			svcKeiMap.put(KK0081ETMsg.SVC_CD, svcKeiRsltList[0].getString(EKK0081A010CBSMsg1List.SVC_CD));
		}
		if(null == tkHoshikiKeiNo || "".equals(tkHoshikiKeiNo))
		{
			// 提供方式契約番号を設定
			svcKeiMap.put(KK0081ETMsg.TK_HOSHIKI_KEI_NO, svcKeiRsltList[0].getString(EKK0081A010CBSMsg1List.TK_HOSHIKI_KEI_NO));
		}
		// 20130403 IT1-2013-0000551 Add End
		// 20130403 IT1-2013-0000551 Delete Start
//		// ▼▼▼ OT-2013-0000090 Add Start    ▼▼▼
//		// サービスコードを設定
//		svcKeiMap.put(KK0081ETMsg.SVC_CD, svcKeiRsltList[0].getString(EKK0081A010CBSMsg1List.SVC_CD));
//		// 提供方式契約番号を設定
//		svcKeiMap.put(KK0081ETMsg.TK_HOSHIKI_KEI_NO, svcKeiRsltList[0].getString(EKK0081A010CBSMsg1List.TK_HOSHIKI_KEI_NO));
//		// ▲▲▲ OT-2013-0000090 Add End      ▲▲▲
		// 20130403 IT1-2013-0000551 Delete End
	}
	
	// ▼▼▼ OT-2013-0000090 Add Start    ▼▼▼
	/**
	 * 利用場所がマンションか否かを判定する。
	 * @return マンションの場合はTrue,そうでなければFalse
	 * @throws Throwable 
	 */
	@SuppressWarnings("unchecked")
	private boolean chkMansion(SessionHandle handle, IRequestParameterReadWrite param) throws Throwable
	{
		//サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		//サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);
		
		if(null == svcKeiMap.get(KK0081ETMsg.TK_HOSHIKI_KEI_NO) || "".equals(svcKeiMap.get(KK0081ETMsg.TK_HOSHIKI_KEI_NO)))
		{
			// 提供方式契約番号がない（ホーム）
			return false;
		}
		
		// 提供方式契約一意照会
		String kaisenUseKeiNo = setTkHoshikiKeiInfo(handle, param);
		
		// 回線使用契約一意照会
		String ownrKeiNo = setKaisenUseKeiInfo(handle, param, kaisenUseKeiNo);
		
		// オーナー契約一意照会
		String mansionBukkenNo = setOwnrKeiInfo(handle, param, ownrKeiNo);
		
		// マンション物件一意照会
		String mansionBukkenCd = setMansionBukkenInfo(handle, param, mansionBukkenNo);
		
		if(MANSION_BUKKEN_CD_MANSION.equals(mansionBukkenCd))
		{
			return true;
		}
		
		return false;
	}

	/**
	 * 提供方式契約一意照会を実施
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return 回線使用契約番号
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private String setTkHoshikiKeiInfo(SessionHandle handle, IRequestParameterReadWrite param) throws Throwable
	{
		// サービス契約リストを取得
		ArrayList<HashMap<String, String>> svcKeiList = (ArrayList<HashMap<String, String>>)param.getData(KK0081ETMsg.getTableName());
		// サービス契約マップを取得
		HashMap<String, String> svcKeiMap = svcKeiList.get(0);

		/* 提供方式契約一意照会サービスIF */
		CAANMsg judgeTemp = editInMsg(EKK0891A010CBSMsg.class.getName(), "EKK0891A010", "1", param);
		//  提供方式契約番号
		setSvcIFMapping((String)svcKeiMap.get(KK0081ETMsg.TK_HOSHIKI_KEI_NO), EKK0891A010CBSMsg.KEY_TK_HOSHIKI_KEI_NO, judgeTemp);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		caanList.add(judgeTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0891A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg tkHoshikiKeiRsltTemp = rsltCaanList.get(0);
		CAANMsg[] tkHoshikiKeiRsltList = tkHoshikiKeiRsltTemp.getCAANMsgList(EKK0891A010CBSMsg.EKK0891A010CBSMSG1LIST);
		
		// 回線使用契約番号を設定
		String kaisenUseKeiNo = tkHoshikiKeiRsltList[0].getString(EKK0891A010CBSMsg1List.KAISEN_USE_KEI_NO);
		
		return kaisenUseKeiNo;
	}
	
	/**
	 * 回線使用契約一意照会を実施
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return オーナー契約番号
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private String setKaisenUseKeiInfo(SessionHandle handle, IRequestParameterReadWrite param, String kaisenUseKeiNo) throws Throwable
	{
		/* 回線使用契約一意照会サービスIF */
		CAANMsg judgeTemp = editInMsg(EKK0881A010CBSMsg.class.getName(), "EKK0881A010", "1", param);
		//  提供方式契約番号
		setSvcIFMapping(kaisenUseKeiNo, EKK0881A010CBSMsg.KEY_KAISEN_USE_KEI_NO, judgeTemp);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		caanList.add(judgeTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0881A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg kaisenUseKeiRsltTemp = rsltCaanList.get(0);
		CAANMsg[] kaisenUseKeiRsltList = kaisenUseKeiRsltTemp.getCAANMsgList(EKK0881A010CBSMsg.EKK0881A010CBSMSG1LIST);
		
		// オーナー契約番号を設定
		String ownrKeiNo = kaisenUseKeiRsltList[0].getString(EKK0881A010CBSMsg1List.OWNR_KEI_NO);
		
		return ownrKeiNo;
	}
	
	/**
	 * オーナー契約一意照会を実施
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return マンション物件番号
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private String setOwnrKeiInfo(SessionHandle handle, IRequestParameterReadWrite param, String ownrKeiNo) throws Throwable
	{
		/* オーナー契約一意照会サービスIF */
		CAANMsg judgeTemp = editInMsg(EKK0871A010CBSMsg.class.getName(), "EKK0871A010", "1", param);
		//  オーナー契約番号
		setSvcIFMapping(ownrKeiNo, EKK0871A010CBSMsg.KEY_OWNR_KEI_NO, judgeTemp);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		caanList.add(judgeTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0871A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg ownrKeiRsltTemp = rsltCaanList.get(0);
		CAANMsg[] ownrKeiRsltList = ownrKeiRsltTemp.getCAANMsgList(EKK0871A010CBSMsg.EKK0871A010CBSMSG1LIST);
		
		// マンション物件番号を設定
		String mansionBukkenNo = ownrKeiRsltList[0].getString(EKK0871A010CBSMsg1List.MANSION_BUKKEN_NO);
		
		return mansionBukkenNo;
	}
	
	/**
	 * マンション物件一意照会を実施
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return マンション物件コード
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private String setMansionBukkenInfo(SessionHandle handle, IRequestParameterReadWrite param, String mansionBukkenNo) throws Throwable
	{
		/* マンション物件一意照会サービスIF */
		CAANMsg judgeTemp = editInMsg(EKK0861A010CBSMsg.class.getName(), "EKK0861A010", "1", param);
		//  マンション物件番号
		setSvcIFMapping(mansionBukkenNo, EKK0861A010CBSMsg.KEY_MANSION_BUKKEN_NO, judgeTemp);
		
		ArrayList<CAANMsg> caanList = new ArrayList<CAANMsg>();
		caanList.add(judgeTemp);
		
		// サービスIFの実施
		Map<?, ?> rsltMap = executeSvcIF(caanList, param, handle);
        // エラー情報の設定
		editErrorInfoEKK0861A010(param, rsltMap);
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(rsltMap, errList));
		// 実行結果確認
		scResultCheck(param, rsltMap);
		// 結果をリストで取得
		ArrayList<CAANMsg> rsltCaanList = getRsltList(rsltMap);
		
		CAANMsg mansionBukkenRsltTemp = rsltCaanList.get(0);
		CAANMsg[] mansionBukkenRsltList = mansionBukkenRsltTemp.getCAANMsgList(EKK0861A010CBSMsg.EKK0861A010CBSMSG1LIST);
		
		// マンション物件コードを設定
		String mansionBukkenCd = mansionBukkenRsltList[0].getString(EKK0861A010CBSMsg1List.MANSION_BUKKEN_CD);
		
		return mansionBukkenCd;
	}
	// ▲▲▲ OT-2013-0000090 Add End      ▲▲▲
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(住所不備サービス契約情報審査)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C011(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071C011CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 住所不備サービス契約情報審査マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.JUDGE_NO_ERR);
		// 住所不備サービス契約情報審査マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.SVC_KEI_NO_ERR);
		// 住所不備サービス契約情報審査マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.IDO_DIV_ERR);
		// 住所不備サービス契約情報審査マップ.提供方式契約番号 → 提供方式契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.TK_HOSHIKI_KEI_NO_ERR);
		// 住所不備サービス契約情報審査マップ.審査実施機能識別コード → 審査実施機能識別コード のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.JDG_JSSI_KINO_SKBT_CD_ERR);
		// 住所不備サービス契約情報審査マップ.回線場所住所コード → 回線場所住所コード のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.KAISEN_PLACE_AD_CD_ERR);
		// 住所不備サービス契約情報審査マップ.回線場所郵便番号 → 回線場所郵便番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.KAISEN_PLACE_PCD_ERR);
		// 住所不備サービス契約情報審査マップ.回線場所都道府県名 → 回線場所都道府県名 のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.KAISEN_PLACE_STATE_NM_ERR);
		// 住所不備サービス契約情報審査マップ.回線場所市区町村名 → 回線場所市区町村名 のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.KAISEN_PLACE_CITY_NM_ERR);
		// 住所不備サービス契約情報審査マップ.回線場所大字通称名 → 回線場所大字通称名 のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.KAISEN_PLACE_OAZTSU_NM_ERR);
		// 住所不備サービス契約情報審査マップ.回線場所字丁目名 → 回線場所字丁目名 のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.KAISEN_PLACE_AZCHO_NM_ERR);
		// 住所不備サービス契約情報審査マップ.回線場所番地号 → 回線場所番地号 のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.KAISEN_PLACE_BNCHIGO_ERR);
		// 住所不備サービス契約情報審査マップ.回線場所住所未確定フラグ → 回線場所住所未確定フラグ のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.KISN_PLC_AD_MI_FIX_FLG_ERR);
		// 住所不備サービス契約情報審査マップ.マンション物件番号 → マンション物件番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.MANSION_BUKKEN_NO);
		// 住所不備サービス契約情報審査マップ.請求書用回線場所住所部屋番号 → 請求書用回線場所住所部屋番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.SKS_YO_KISN_PLACE_AD_RM_NO);
		// 記載不備サービス契約情報審査マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.UPD_DTM_BF_ERR);
		// ▼▼▼ IT1-2012-0001726 2012/11/01 Add Start ▼▼▼
		// 記載不備サービス契約情報審査マップ.サービス契約回線内訳番号 → サービス契約回線内訳番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR);
		// ▲▲▲ IT1-2012-0001726 2012/11/01 Add Start ▲▲▲
		// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
		// 記載不備サービス契約情報審査マップ.サービス契約回線内訳_回線場所住所チェックレベル → サービス契約回線内訳_回線場所住所チェックレベル のエラー情報返却
		errMapping(template, inMap, EKK1071C011CBSMsg.KAISEN_PLACE_AD_CHK_LV_ERR);
		// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(記載不備サービス契約情報審査)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C021(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071C021CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 記載不備サービス契約情報審査マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C021CBSMsg.JUDGE_NO_ERR);
		// 記載不備サービス契約情報審査マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C021CBSMsg.SVC_KEI_NO_ERR);
		// 記載不備サービス契約情報審査マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1071C021CBSMsg.IDO_DIV_ERR);
		// 記載不備サービス契約情報審査マップ.審査実施機能識別コード → 審査実施機能識別コード のエラー情報返却
		errMapping(template, inMap, EKK1071C021CBSMsg.JDG_JSSI_KINO_SKBT_CD_ERR);
		// 記載不備サービス契約情報審査マップ.料金コースコード → 料金コースコード のエラー情報返却
		errMapping(template, inMap, EKK1071C021CBSMsg.PCRS_CD_ERR);
		// 記載不備サービス契約情報審査マップ.申込番号 → 申込番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C021CBSMsg.MSKM_NO_ERR);
		// 記載不備サービス契約情報審査マップ.申込書番号 → 申込書番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C021CBSMsg.MSKMSHO_NO_ERR);
		// 記載不備サービス契約情報審査マップ.申込年月日 → 申込年月日 のエラー情報返却
		errMapping(template, inMap, EKK1071C021CBSMsg.MSKM_YMD_ERR);
		// 記載不備サービス契約情報審査マップ.面開発案件番号 → 面開発案件番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C021CBSMsg.MENKAIHAT_ANKEN_NO_ERR);
		
		ArrayList msg1List = (ArrayList)inMap.get(EKK1071C021CBSMsg.EKK1071C021CBSMSG1LIST);
		if (msg1List == null)
		{
			msg1List = new ArrayList();
			inMap.put(EKK1071C021CBSMsg.EKK1071C021CBSMSG1LIST, msg1List);
		}
		CAANMsg[] templateArray = template.getCAANMsgList(EKK1071C021CBSMsg.EKK1071C021CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				if (i >= msg1List.size())
				{
					msg1List.add(new HashMap());
				}
				HashMap childMap = (HashMap)msg1List.get(i);
				CAANMsg childTemplate = templateArray[i];
				// 記載不備サービス契約情報審査マップ.機器提供サービスコード → 機器提供サービスコード のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C021CBSMsg1List.KKTK_SVC_CD_ERR);
			}
		}
		// 記載不備サービス契約情報審査マップ.機器提供サービスコード明細 → 機器提供サービスコード明細 のエラー情報返却
		errMapping(template, inMap, EKK1071C021CBSMsg.EKK1071C021CBSMSG1LIST_ERR);
		
		ArrayList msg2List = (ArrayList)inMap.get(EKK1071C021CBSMsg.EKK1071C021CBSMSG2LIST);
		if (msg2List == null)
		{
			msg2List = new ArrayList();
			inMap.put(EKK1071C021CBSMsg.EKK1071C021CBSMSG2LIST, msg2List);
		}
		templateArray = template.getCAANMsgList(EKK1071C021CBSMsg.EKK1071C021CBSMSG2LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				if (i >= msg2List.size())
				{
					msg2List.add(new HashMap());
				}
				HashMap childMap = (HashMap)msg2List.get(i);
				CAANMsg childTemplate = templateArray[i];
				// 記載不備サービス契約情報審査マップ.割引サービスコード → 割引サービスコード のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C021CBSMsg2List.WRIB_SVC_CD_ERR);
			}
		}
		// 記載不備サービス契約情報審査マップ.割引サービスコード明細 → 割引サービスコード明細 のエラー情報返却
		errMapping(template, inMap, EKK1071C021CBSMsg.EKK1071C021CBSMSG2LIST_ERR);
		
		// 記載不備サービス契約情報審査マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK1071C021CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(住所不備お客様情報審査)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C031(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071C031CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 住所不備お客様情報審査マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.JUDGE_NO_ERR);
		// 住所不備お客様情報審査マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.SVC_KEI_NO_ERR);
		// 住所不備お客様情報審査マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.IDO_DIV_ERR);
		// 住所不備お客様情報審査マップ.審査実施機能識別コード → 審査実施機能識別コード のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.JDG_JSSI_KINO_SKBT_CD_ERR);
		// 住所不備お客様情報審査マップ.契約者住所コード → 契約者住所コード のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.KEISHA_AD_CD_ERR);
		// 住所不備お客様情報審査マップ.契約者郵便番号 → 契約者郵便番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.KEISHA_PCD_ERR);
		// 住所不備お客様情報審査マップ.契約者都道府県名 → 契約者都道府県名 のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.KEISHA_STATE_NM_ERR);
		// 住所不備お客様情報審査マップ.契約者市区町村名 → 契約者市区町村名 のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.KEISHA_CITY_NM_ERR);
		// 住所不備お客様情報審査マップ.契約者大字通称名 → 契約者大字通称名 のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.KEISHA_OAZTSU_NM_ERR);
		// 住所不備お客様情報審査マップ.契約者字丁目名 → 契約者字丁目名 のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.KEISHA_AZCHO_NM_ERR);
		// --住所課題対応-STR-----------------------
		// 住所不備お客様情報審査マップ.契約者番地号
		errMapping(template, inMap, EKK1071C031CBSMsg.KEISHA_BNCHIGO_ERR);
		// 住所不備お客様情報審査マップ.契約者住所手動入力フラグ
		errMapping(template, inMap, EKK1071C031CBSMsg.KEISHA_AD_MAN_INPUT_FLG_ERR);
		// --住所課題対応-END-----------------------
		// 住所不備お客様情報審査マップ.親権者住所コード → 親権者住所コード のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.SKSHA_AD_CD_ERR);
		// 住所不備お客様情報審査マップ.親権者郵便番号 → 親権者郵便番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.SKSHA_PCD_ERR);
		// 住所不備お客様情報審査マップ.親権者都道府県名 → 親権者都道府県名 のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.SKSHA_STATE_NM_ERR);
		// 住所不備お客様情報審査マップ.親権者市区町村名 → 親権者市区町村名 のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.SKSHA_CITY_NM_ERR);
		// 住所不備お客様情報審査マップ.親権者大字通称名 → 親権者大字通称名 のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.SKSHA_OAZTSU_NM_ERR);
		// 住所不備お客様情報審査マップ.親権者字丁目名 → 親権者字丁目名 のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.SKSHA_AZCHO_NM_ERR);
		// --住所課題対応-STR-----------------------
		// 住所不備お客様情報審査マップ.親権者番地号 → 親権者番地号 のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.SKSHA_AD_BNCHIGO_ERR);
		// 住所不備お客様情報審査マップ.親権者住所手動入力フラグ → 親権者住所手動入力フラグ のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.SKSHA_AD_MAN_INPUT_FLG_ERR);
		// --住所課題対応-END-----------------------
		// 住所不備お客様情報審査マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.UPD_DTM_BF_ERR);
		// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
		// 住所不備お客様情報審査マップ.お客様_契約者住所チェックレベル → お客様_契約者住所チェックレベル のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.KEISHA_AD_CHK_LV_ERR);
		// 住所不備お客様情報審査マップ.お客様＜個人＞_親権者住所チェックレベル → お客様＜個人＞_親権者住所チェックレベル のエラー情報返却
		errMapping(template, inMap, EKK1071C031CBSMsg.SKSHA_AD_CHK_LV_ERR);
		// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(記載不備お客様情報審査)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C041(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071C041CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 記載不備お客様情報審査マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.JUDGE_NO_ERR);
		// 記載不備お客様情報審査マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.SVC_KEI_NO_ERR);
		// 記載不備お客様情報審査マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.IDO_DIV_ERR);
		// 記載不備お客様情報審査マップ.審査実施機能識別コード → 審査実施機能識別コード のエラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.JDG_JSSI_KINO_SKBT_CD_ERR);
		// 記載不備お客様情報審査マップ.サービス契約回線内訳番号 → サービス契約回線内訳番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR);
		// 記載不備お客様情報審査マップ.回線場所郵便番号 → 回線場所郵便番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.KAISEN_PLACE_PCD_ERR);
		// 記載不備お客様情報審査マップ.回線場所都道府県名 → 回線場所都道府県名 のエラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.KAISEN_PLACE_STATE_NM_ERR);
		// 記載不備お客様情報審査マップ.回線場所市区町村名 → 回線場所市区町村名 のエラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.KAISEN_PLACE_CITY_NM_ERR);
		// 記載不備お客様情報審査マップ.回線場所大字通称名 → 回線場所大字通称名 のエラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.KAISEN_PLACE_OAZTSU_NM_ERR);
		// 記載不備お客様情報審査マップ.回線場所字丁目名 → 回線場所字丁目名 のエラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.KAISEN_PLACE_AZCHO_NM_ERR);
		// 記載不備お客様情報審査マップ.回線場所番地号 → 回線場所番地号 のエラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.KAISEN_PLACE_BNCHIGO_ERR);
		// 記載不備お客様情報審査マップ.回線場所住所補記・建物名 → 回線場所住所補記・建物名 のエラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.KAISEN_PLACE_ADRTTM_ERR);
		// 記載不備お客様情報審査マップ.回線場所住所補記・部屋番号 → 回線場所住所補記・部屋番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.KAISEN_PLACE_ADRRM_ERR);
		
		// 記載不備お客様情報審査マップ.お客様生年月日 → お客様生年月日 の エラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.CUST_BIRTHD_ERR);
		// 記載不備お客様情報審査マップ.契約者タイプコード → 契約者タイプコード の エラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.KEISHA_TYPE_CD_ERR);
		// 記載不備お客様情報審査マップ.親権者名 → 親権者名 の エラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.SKSHA_NM_ERR);
		// 記載不備お客様情報審査マップ.親権者カナ名 → 親権者カナ名 の エラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.SKSHA_KANA_ERR);
		// 記載不備お客様情報審査マップ.親権者生年月日 → 親権者生年月日 の エラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.SKSHA_BIRTHD_ERR);
		// 記載不備お客様情報審査マップ.親権者続柄コード → 親権者続柄コード の エラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.SKSHA_ZOKUGARA_CD_ERR);
		// 記載不備お客様情報審査マップ.親権者電話番号 → 親権者電話番号 の エラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.SKSHA_TELNO_ERR);
		// 記載不備お客様情報審査マップ.法人格種別コード → 法人格種別コード の エラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.HOJIN_SBT_CD_ERR);
		// 記載不備お客様情報審査マップ.法人格前後指定コード → 法人格前後指定コード の エラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.HOJIN_ZENGO_SHITEI_CD_ERR);
		
		ArrayList msg1List = (ArrayList)inMap.get(EKK1071C041CBSMsg.EKK1071C041CBSMSG1LIST);
		if (msg1List == null)
		{
			msg1List = new ArrayList();
			inMap.put(EKK1071C041CBSMsg.EKK1071C041CBSMSG1LIST, msg1List);
		}
		CAANMsg[] templateArray = template.getCAANMsgList(EKK1071C041CBSMsg.EKK1071C041CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				if (i >= msg1List.size())
				{
					msg1List.add(new HashMap());
				}
				HashMap childMap = (HashMap)msg1List.get(i);
				CAANMsg childTemplate = templateArray[i];
				// 記載不備お客様情報審査マップ.SYSID → SYSID のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C041CBSMsg1List.SYSID_ERR);
			}
		}
		// 記載不備お客様情報審査マップ.記載不備お客様情報審査明細 → 記載不備お客様情報審査明細 のエラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.EKK1071C041CBSMSG1LIST_ERR);
		
		// 記載不備お客様情報審査マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK1071C041CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(住所不備機器サービス契約情報審査)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C051(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071C051CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 住所不備機器サービス契約情報審査マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C051CBSMsg.JUDGE_NO_ERR);
		// 住所不備機器サービス契約情報審査マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C051CBSMsg.SVC_KEI_NO_ERR);
		// 住所不備機器サービス契約情報審査マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1071C051CBSMsg.IDO_DIV_ERR);
		// 住所不備機器サービス契約情報審査マップ.審査実施機能識別コード → 審査実施機能識別コード のエラー情報返却
		errMapping(template, inMap, EKK1071C051CBSMsg.JDG_JSSI_KINO_SKBT_CD_ERR);
		// 住所不備機器サービス契約情報審査マップ.料金グループコード → 料金グループコード のエラー情報返却
		errMapping(template, inMap, EKK1071C051CBSMsg.PRC_GRP_CD_ERR);
		// 住所不備機器サービス契約情報審査マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK1071C051CBSMsg.UPD_DTM_BF_ERR);
		
		ArrayList msg1List = (ArrayList)inMap.get(EKK1071C051CBSMsg.EKK1071C051CBSMSG1LIST);
		if (msg1List == null)
		{
			msg1List = new ArrayList();
			inMap.put(EKK1071C051CBSMsg.EKK1071C051CBSMSG1LIST, msg1List);
		}
		CAANMsg[] templateArray = template.getCAANMsgList(EKK1071C051CBSMsg.EKK1071C051CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				if (i >= msg1List.size())
				{
					msg1List.add(new HashMap());
				}
				HashMap childMap = (HashMap)msg1List.get(i);
				CAANMsg childTemplate = templateArray[i];
				// 住所不備機器サービス契約情報審査マップ.機器提供サービスコード → 機器提供サービスコード のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KKTK_SVC_CD_ERR);
				// 住所不備機器サービス契約情報審査マップ.機器送付先住所コード → 機器送付先住所コード のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_SOHUS_AD_CD_ERR);
				// 住所不備機器サービス契約情報審査マップ.機器送付先郵便番号 → 機器送付先郵便番号 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_SOHUS_PCD_ERR);
				// 住所不備機器サービス契約情報審査マップ.機器送付先都道府県名 → 機器送付先都道府県名 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_SOHUS_STATE_NM_ERR);
				// 住所不備機器サービス契約情報審査マップ.機器送付先市区町村名 → 機器送付先市区町村名 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_SOHUS_CITY_NM_ERR);
				// 住所不備機器サービス契約情報審査マップ.機器送付先大字通称名 → 機器送付先大字通称名 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_SOHUS_OAZTSU_NM_ERR);
				// 住所不備機器サービス契約情報審査マップ.機器送付先字丁目名 → 機器送付先字丁目名 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_SOHUS_AZCHO_NM_ERR);
				// --住所課題対応-STR-----------------------
				// 住所不備機器サービス契約情報審査マップ.機器送付先番地号 → 機器送付先番地号 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_SOHUS_BNCHIGO_ERR);
				// 住所不備機器サービス契約情報審査マップ.機器送付先住所手動入力フラグ → 機器送付先住所手動入力フラグ のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_SOHUS_AD_MAN_INPUT_FLG_ERR);
				// --住所課題対応-END-----------------------
				// 住所不備機器サービス契約情報審査マップ.機器設置先住所コード → 機器設置先住所コード のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_AD_CD_ERR);
				// 住所不備機器サービス契約情報審査マップ.機器設置先郵便番号 → 機器設置先郵便番号 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_PCD_ERR);
				// 住所不備機器サービス契約情報審査マップ.機器設置先都道府県名 → 機器設置先都道府県名 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_STATE_NM_ERR);
				// 住所不備機器サービス契約情報審査マップ.機器設置先市区町村名 → 機器設置先市区町村名 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_CITY_NM_ERR);
				// 住所不備機器サービス契約情報審査マップ.機器設置先大字通称名 → 機器設置先大字通称名 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_OAZTSU_NM_ERR);
				// 住所不備機器サービス契約情報審査マップ.機器設置先字丁目名 → 機器設置先字丁目名 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_AZCHO_NM_ERR);
				// --住所課題対応-STR-----------------------
				// 住所不備機器サービス契約情報審査マップ.機器設置先番地号 → 機器設置先番地号 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_BNCHIGO_ERR);
				// 住所不備機器サービス契約情報審査マップ.機器設置先住所未確定フラグ → 機器設置先住所未確定フラグ のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_STC_AD_MI_FIX_FLG_ERR);
				// --住所課題対応-END-----------------------
				// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
				// 住所不備機器サービス契約情報審査マップ.機器送付先住所チェックレベル → 機器送付先住所チェックレベル のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_SOHUS_AD_CHK_LV_ERR);
				// 住所不備機器サービス契約情報審査マップ.機器設置先住所チェックレベル → 機器設置先住所チェックレベル のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C051CBSMsg1List.KIKI_STC_SAKI_AD_CHK_LV_ERR);
				// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
			}
		}
		// 住所不備機器サービス契約情報審査マップ.機器提供サービス契約明細 → 機器提供サービス契約明細 のエラー情報返却
		errMapping(template, inMap, EKK1071C051CBSMsg.EKK1071C051CBSMSG1LIST_ERR);
		
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(住所不備請求契約情報審査)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C061(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071C061CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 住所不備請求契約情報審査マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C061CBSMsg.JUDGE_NO_ERR);
		// 住所不備請求契約情報審査マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C061CBSMsg.SVC_KEI_NO_ERR);
		// 住所不備請求契約情報審査マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1071C061CBSMsg.IDO_DIV_ERR);
		// 住所不備請求契約情報審査マップ.送付先住所コード → 送付先住所コード のエラー情報返却
		errMapping(template, inMap, EKK1071C061CBSMsg.SOHUS_AD_CD_ERR);
		// 住所不備請求契約情報審査マップ.送付先郵便番号 → 送付先郵便番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C061CBSMsg.SOHUS_PCD_ERR);
		// 住所不備請求契約情報審査マップ.送付先都道府県名 → 送付先都道府県名 のエラー情報返却
		errMapping(template, inMap, EKK1071C061CBSMsg.SOHUS_STATE_NM_ERR);
		// 住所不備請求契約情報審査マップ.送付先市区町村名 → 送付先市区町村名 のエラー情報返却
		errMapping(template, inMap, EKK1071C061CBSMsg.SOHUS_CITY_NM_ERR);
		// 住所不備請求契約情報審査マップ.送付先大字通称名 → 送付先大字通称名 のエラー情報返却
		errMapping(template, inMap, EKK1071C061CBSMsg.SOHUS_OAZTSU_NM_ERR);
		// 住所不備請求契約情報審査マップ.送付先字丁目名 → 送付先字丁目名 のエラー情報返却
		errMapping(template, inMap, EKK1071C061CBSMsg.SOHUS_AZCHO_NM_ERR);
		// 住所不備請求契約情報審査マップ.審査実施機能識別コード → 審査実施機能識別コード のエラー情報返却
		errMapping(template, inMap, EKK1071C061CBSMsg.JDG_JSSI_KINO_SKBT_CD_ERR);
		// --住所課題対応-STR-----------------------
		// 住所不備請求契約情報審査マップ.送付先番地号 → 送付先番地号 のエラー情報返却
		errMapping(template, inMap, EKK1071C061CBSMsg.SOHUS_BNCHIGO_ERR);
		// 住所不備請求契約情報審査マップ.送付先住所手動入力フラグ → 送付先住所手動入力フラグ のエラー情報返却
		errMapping(template, inMap, EKK1071C061CBSMsg.SOHUS_AD_MAN_INPUT_FLG_ERR);
		// --住所課題対応-END-----------------------
		// 住所不備請求契約情報審査マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK1071C061CBSMsg.UPD_DTM_BF_ERR);
		// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
		// 住所不備請求契約情報審査マップ.送付先住所チェックレベル → 送付先住所チェックレベル のエラー情報返却
		errMapping(template, inMap, EKK1071C061CBSMsg.SOHUS_AD_CHK_LV_ERR);
		// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(記載不備請求契約情報審査)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C071(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071C071CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 記載不備請求契約情報審査マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C071CBSMsg.JUDGE_NO_ERR);
		// 記載不備請求契約情報審査マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C071CBSMsg.SVC_KEI_NO_ERR);
		// 記載不備請求契約情報審査マップ.審査実施機能識別コード → 審査実施機能識別コード のエラー情報返却
		errMapping(template, inMap, EKK1071C071CBSMsg.JDG_JSSI_KINO_SKBT_CD_ERR);
		// 記載不備請求契約情報審査マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1071C071CBSMsg.IDO_DIV_ERR);
		// 記載不備請求契約情報審査マップ.クレジットカード_クレジットカード会社コード → クレジットカード_クレジットカード会社コード のエラー情報返却
		errMapping(template, inMap, EKK1071C071CBSMsg.CRECARD_COMP_CD_ERR);
		// 記載不備請求契約情報審査マップ.クレジットカード_クレジットカード事業コード → クレジットカード_クレジットカード事業コード のエラー情報返却
		errMapping(template, inMap, EKK1071C071CBSMsg.CRECARD_JIGYO_CD_ERR);
		// 記載不備請求契約情報審査マップ.クレジットカード_クレジットカード番号 → クレジットカード_クレジットカード番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C071CBSMsg.CRECARD_NO_ERR);
		// 記載不備請求契約情報審査マップ.請求契約_請求契約番号 → 請求契約_請求契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C071CBSMsg.SEIKY_KEI_NO_ERR);
		// 記載不備請求契約情報審査マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK1071C071CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(記載不備電話番号情報審査)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C081(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071C081CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 記載不備電話番号情報審査マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C081CBSMsg.JUDGE_NO_ERR);
		// 記載不備電話番号情報審査マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C081CBSMsg.SVC_KEI_NO_ERR);
		// 記載不備電話番号情報審査マップ.審査実施機能識別コード → 審査実施機能識別コード のエラー情報返却
		errMapping(template, inMap, EKK1071C081CBSMsg.JDG_JSSI_KINO_SKBT_CD_ERR);
		// 記載不備電話番号情報審査マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1071C081CBSMsg.IDO_DIV_ERR);
		
		ArrayList msg1List = (ArrayList)inMap.get(EKK1071C081CBSMsg.EKK1071C081CBSMSG1LIST);
		if (msg1List == null)
		{
			msg1List = new ArrayList();
			inMap.put(EKK1071C081CBSMsg.EKK1071C081CBSMSG1LIST, msg1List);
		}
		CAANMsg[] templateArray = template.getCAANMsgList(EKK1071C081CBSMsg.EKK1071C081CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				if (i >= msg1List.size())
				{
					msg1List.add(new HashMap());
				}
				HashMap childMap = (HashMap)msg1List.get(i);
				CAANMsg childTemplate = templateArray[i];
				// 記載不備電話番号情報審査マップ.サービス契約内訳<eo光電話>_電話番号 → サービス契約内訳<eo光電話>_電話番号 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C081CBSMsg1List.TELNO_ERR);
				// 記載不備電話番号情報審査マップ.サービス契約内訳<eo光電話>_緊急通報用住所コード
				// → サービス契約内訳<eo光電話>_緊急通報用住所コード のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C081CBSMsg1List.EMG_AD_CD_ERR);
			}
		}
		// 記載不備電話番号情報審査マップ.記載不備電話番号情報審査明細 → 記載不備電話番号情報審査明細 のエラー情報返却
		errMapping(template, inMap, EKK1071C081CBSMsg.EKK1071C081CBSMSG1LIST_ERR);
		
		// 記載不備電話番号情報審査マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK1071C081CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(エリア審査)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C091(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071C091CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// エリア審査マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.JUDGE_NO_ERR);
		// エリア審査マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.SVC_KEI_NO_ERR);
		// エリア審査マップ.サービス契約_サービスコード → サービス契約_サービスコード のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.SVC_CD_ERR);
		// エリア審査マップ.サービス契約_料金グループコード → サービス契約_料金グループコード のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.PRC_GRP_CD_ERR);
		// エリア審査マップ.サービス契約_料金コースコード → サービス契約_料金コースコード のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.PCRS_CD_ERR);
		// エリア審査マップ.サービス契約_料金プランコード → サービス契約_料金プランコード のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.PPLAN_CD_ERR);
		// エリア審査マップ.サービス契約回線内訳_回線場所住所コード → サービス契約回線内訳_回線場所住所コード のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.KAISEN_PLACE_AD_CD_ERR);
		// エリア審査マップ.サービス契約回線内訳_回線場所郵便番号 → サービス契約回線内訳_回線場所郵便番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.KAISEN_PLACE_PCD_ERR);
		// エリア審査マップ.サービス契約回線内訳_回線場所都道府県名 → サービス契約回線内訳_回線場所都道府県名 のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.KAISEN_PLACE_STATE_NM_ERR);
		// エリア審査マップ.サービス契約回線内訳_回線場所市区町村名 → サービス契約回線内訳_回線場所市区町村名 のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.KAISEN_PLACE_CITY_NM_ERR);
		// エリア審査マップ.サービス契約回線内訳_大字通称名 → サービス契約回線内訳_大字通称名 のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.KAISEN_PLACE_OAZTSU_NM_ERR);
		// エリア審査マップ.サービス契約回線内訳_回線場所字丁目名 → サービス契約回線内訳_回線場所字丁目名 のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.KAISEN_PLACE_AZCHO_NM_ERR);
		// エリア審査マップ.サービス契約回線内訳_回線場所番地号 → サービス契約回線内訳_回線場所番地号 のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.KAISEN_PLACE_BNCHIGO_ERR);
		// エリア審査マップ.サービス契約回線内訳_経度 → サービス契約回線内訳_経度 のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.LGTD_ERR);
		// エリア審査マップ.サービス契約回線内訳_緯度 → サービス契約回線内訳_緯度 のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.LTTD_ERR);
		// エリア審査マップ.サービス契約回線内訳_緯度 → サービス契約回線内訳_緯度 のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.LTTD_ERR);
		// エリア審査マップ.審査実施機能識別コード → 審査実施機能識別コード のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.JDG_JSSI_KINO_SKBT_CD_ERR);
		// エリア審査マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.IDO_DIV_ERR);
		// エリア審査マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK1071C091CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(不良顧客審査)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C101(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071C101CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 不良顧客審査マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C101CBSMsg.JUDGE_NO_ERR);
		// 不良顧客審査マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C101CBSMsg.SVC_KEI_NO_ERR);
		// 不良顧客審査マップ.お客様_お客様名 → お客様_お客様名 のエラー情報返却
		errMapping(template, inMap, EKK1071C101CBSMsg.CUST_NM_ERR);
		// 不良顧客審査マップ.お客様_お客様カナ名 → お客様_お客様カナ名 のエラー情報返却
		errMapping(template, inMap, EKK1071C101CBSMsg.CUST_KANA_ERR);
		// 不良顧客審査マップ.お客様_契約者電話番号 → お客様_契約者電話番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C101CBSMsg.KEISHA_TELNO_ERR);
		// 不良顧客審査マップ.お客様＜個人＞_親権者名 → お客様＜個人＞_親権者名 のエラー情報返却
		errMapping(template, inMap, EKK1071C101CBSMsg.SKSHA_NM_ERR);
		// 不良顧客審査マップ.お客様＜個人＞_親権者カナ名 → お客様＜個人＞_親権者カナ名 のエラー情報返却
		errMapping(template, inMap, EKK1071C101CBSMsg.SKSHA_KANA_ERR);
		// 不良顧客審査マップ.お客様＜個人＞_親権者電話番号 → お客様＜個人＞_親権者電話番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C101CBSMsg.SKSHA_TELNO_ERR);
		// 不良顧客審査マップ.請求契約_送付先カナ名 → 請求契約_送付先カナ名 のエラー情報返却
		errMapping(template, inMap, EKK1071C101CBSMsg.SHS_KANA_ERR);
		// 不良顧客審査マップ.請求契約_送付先電話番号 → 請求契約_送付先電話番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C101CBSMsg.SOHUS_TELNO_ERR);
		// 不良顧客審査マップ.審査実施機能識別コード → 審査実施機能識別コード のエラー情報返却
		errMapping(template, inMap, EKK1071C101CBSMsg.JDG_JSSI_KINO_SKBT_CD_ERR);
		// 不良顧客審査マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1071C101CBSMsg.IDO_DIV_ERR);
		// 不良顧客審査マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK1071C101CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(番ポエリア審査)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C111(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071C111CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 番ポエリア審査マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C111CBSMsg.JUDGE_NO_ERR);
		// 番ポエリア審査マップ.審査実施機能識別コード → 審査実施機能識別コード のエラー情報返却
		errMapping(template, inMap, EKK1071C111CBSMsg.JDG_JSSI_KINO_SKBT_CD_ERR);
		// 番ポエリア審査マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C111CBSMsg.SVC_KEI_NO_ERR);
		// 番ポエリア審査マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1071C111CBSMsg.IDO_DIV_ERR);
		// 番ポエリア審査マップ.サービス契約回線内訳_回線場所住所コード → サービス契約回線内訳_回線場所住所コード のエラー情報返却
		errMapping(template, inMap, EKK1071C111CBSMsg.KAISEN_PLACE_AD_CD_ERR);
		
		ArrayList msg1List = (ArrayList)inMap.get(EKK1071C111CBSMsg.EKK1071C111CBSMSG1LIST);
		if (msg1List == null)
		{
			msg1List = new ArrayList();
			inMap.put(EKK1071C111CBSMsg.EKK1071C111CBSMSG1LIST, msg1List);
		}
		CAANMsg[] templateArray = template.getCAANMsgList(EKK1071C111CBSMsg.EKK1071C111CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				if (i >= msg1List.size())
				{
					msg1List.add(new HashMap());
				}
				HashMap childMap = (HashMap)msg1List.get(i);
				CAANMsg childTemplate = templateArray[i];
				// 記載不備機器サービス契約情報審査マップ.サービス契約内訳<eo光電話>_電話番号 → サービス契約内訳<eo光電話>_電話番号のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C111CBSMsg1List.TELNO_ERR);
			}
		}
		// 記載不備機器サービス契約情報審査マップ.番ポエリア審査明細 → 番ポエリア審査明細 のエラー情報返却
		errMapping(template, inMap, EKK1071C111CBSMsg.EKK1071C111CBSMSG1LIST_ERR);
		
		// 番ポエリア審査マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK1071C111CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(多重登録審査)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C121(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071C121CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 多重登録審査マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C121CBSMsg.JUDGE_NO_ERR);
		// 多重登録審査マップ.審査実施機能識別コード → 審査実施機能識別コード のエラー情報返却
		errMapping(template, inMap, EKK1071C121CBSMsg.JDG_JSSI_KINO_SKBT_CD_ERR);
		// 多重登録審査マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C121CBSMsg.SVC_KEI_NO_ERR);
		// 多重登録審査マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1071C121CBSMsg.IDO_DIV_ERR);
		// 多重登録審査マップ.お客様_お客様名 → お客様_お客様名 のエラー情報返却
		errMapping(template, inMap, EKK1071C121CBSMsg.CUST_NM_ERR);
		// 多重登録審査マップ.お客様_お客様カナ名 → お客様_お客様カナ名 のエラー情報返却
		errMapping(template, inMap, EKK1071C121CBSMsg.CUST_KANA_ERR);
		// 多重登録審査マップ.お客様_お客様生年月日 → お客様_お客様生年月日 のエラー情報返却
		errMapping(template, inMap, EKK1071C121CBSMsg.CUST_BIRTHD_ERR);
		// 多重登録審査マップ.お客様_ＳＹＳＩＤ → お客様_ＳＹＳＩＤ のエラー情報返却
		errMapping(template, inMap, EKK1071C121CBSMsg.SYSID_ERR);
		// 多重登録審査マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK1071C121CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(記載不備機器サービス契約情報審査)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C131(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071C131CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 記載不備機器サービス契約情報審査マップ.審査実施機能識別コード → 審査実施機能識別コード のエラー情報返却
		errMapping(template, inMap, EKK1071C131CBSMsg.JDG_JSSI_KINO_SKBT_CD_ERR);
		// 記載不備機器サービス契約情報審査マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C131CBSMsg.SVC_KEI_NO_ERR);
		// 記載不備機器サービス契約情報審査マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1071C131CBSMsg.IDO_DIV_ERR);
		// 記載不備機器サービス契約情報審査マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C131CBSMsg.JUDGE_NO_ERR);
		// 記載不備機器サービス契約情報審査マップ.料金グループコード → 料金グループコード のエラー情報返却
		errMapping(template, inMap, EKK1071C131CBSMsg.PRC_GRP_CD_ERR);
		// 記載不備機器サービス契約情報審査マップ.料金コースコード → 料金コースコード のエラー情報返却
		errMapping(template, inMap, EKK1071C131CBSMsg.PCRS_CD_ERR);
		
		ArrayList msg1List = (ArrayList)inMap.get(EKK1071C131CBSMsg.EKK1071C131CBSMSG1LIST);
		if (msg1List == null)
		{
			msg1List = new ArrayList();
			inMap.put(EKK1071C131CBSMsg.EKK1071C131CBSMSG1LIST, msg1List);
		}
		CAANMsg[] templateArray = template.getCAANMsgList(EKK1071C131CBSMsg.EKK1071C131CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				if (i >= msg1List.size())
				{
					msg1List.add(new HashMap());
				}
			
				HashMap childMap = (HashMap)msg1List.get(i);
				CAANMsg childTemplate = templateArray[i];
				// 記載不備機器サービス契約情報審査マップ.機器提供サービスコード → 機器提供サービスコードのエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C131CBSMsg1List.KKTK_SVC_CD_ERR);
				// 記載不備機器サービス契約情報審査マップ.宅内機器型式コード(機器提供サービス契約) → 宅内機器型式コード(機器提供サービス契約)のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C131CBSMsg1List.KK0341_01_TAKNKIKI_MODEL_CD_ERR);
				// 記載不備機器サービス契約情報審査マップ.機器製造番号(機器提供サービス契約) → 機器製造番号(機器提供サービス契約)のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C131CBSMsg1List.KK0341_01_KIKI_SEIZO_NO_ERR);
			}
		}
		// 記載不備機器サービス契約情報審査マップ.機器提供サービス契約明細 → 機器提供サービス契約明細 のエラー情報返却
		errMapping(template, inMap, EKK1071C131CBSMsg.EKK1071C131CBSMSG1LIST_ERR);
		
		ArrayList msg2List = (ArrayList)inMap.get(EKK1071C131CBSMsg.EKK1071C131CBSMSG2LIST);
		if (msg2List == null)
		{
			msg2List = new ArrayList();
			inMap.put(EKK1071C131CBSMsg.EKK1071C131CBSMSG2LIST, msg2List);
		}
		templateArray = template.getCAANMsgList(EKK1071C131CBSMsg.EKK1071C131CBSMSG2LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				if (i >= msg2List.size())
				{
					msg2List.add(new HashMap());
				}
				HashMap childMap = (HashMap)msg2List.get(i);
				CAANMsg childTemplate = templateArray[i];
				// 記載不備機器サービス契約情報審査マップ.宅内機器型式コード(機器在庫情報) → 宅内機器型式コード(機器在庫情報)のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C131CBSMsg2List.KK0341_02_TAKNKIKI_MODEL_CD_ERR);
				// 記載不備機器サービス契約情報審査マップ.在庫数 → 在庫数のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C131CBSMsg2List.ZAIKO_CNT_ERR);
			}
		}
		// 記載不備機器サービス契約情報審査マップ.機器在庫情報明細 → 機器在庫情報明細 のエラー情報返却
		errMapping(template, inMap, EKK1071C131CBSMsg.EKK1071C131CBSMSG2LIST_ERR);
		
		ArrayList msg3List = (ArrayList)inMap.get(EKK1071C131CBSMsg.EKK1071C131CBSMSG3LIST);
		if (msg3List == null)
		{
			msg3List = new ArrayList();
			inMap.put(EKK1071C131CBSMsg.EKK1071C131CBSMSG3LIST, msg3List);
		}
		templateArray = template.getCAANMsgList(EKK1071C131CBSMsg.EKK1071C131CBSMSG3LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				if (i >= msg3List.size())
				{
					msg3List.add(new HashMap());
				}
				HashMap childMap = (HashMap)msg3List.get(i);
				CAANMsg childTemplate = templateArray[i];
				// 記載不備機器サービス契約情報審査マップ.宅内機器型式コード(機器在庫情報) → 宅内機器型式コード(機器在庫情報)のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C131CBSMsg3List.KK0341_02_KIKI_SEIZO_NO_ERR);
				// 記載不備機器サービス契約情報審査マップ.在庫数 → 在庫数のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C131CBSMsg3List.MACAD_ERR);
			}
		}
		// 記載不備機器サービス契約情報審査マップ.機器MACアドレス明細 → 機器MACアドレス明細 のエラー情報返却
		errMapping(template, inMap, EKK1071C131CBSMsg.EKK1071C131CBSMSG3LIST_ERR);
		
		// 記載不備機器サービス契約情報審査マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK1071C131CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(支払方法審査)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C141(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071C141CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 支払方法審査マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C141CBSMsg.JUDGE_NO_ERR);
		// 支払方法審査マップ.審査実施機能識別コード → 審査実施機能識別コード のエラー情報返却
		errMapping(template, inMap, EKK1071C141CBSMsg.JDG_JSSI_KINO_SKBT_CD_ERR);
		// 支払方法審査マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C141CBSMsg.SVC_KEI_NO_ERR);
		// 支払方法審査マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1071C141CBSMsg.IDO_DIV_ERR);
		// 支払方法審査マップ.請求契約_請求契約番号 → 請求契約_請求契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C141CBSMsg.SEIKY_KEI_NO_ERR);
		// 支払方法審査マップ.請求契約_世代登録年月日時分秒 → 請求契約_世代登録年月日時分秒 のエラー情報返却
		errMapping(template, inMap, EKK1071C141CBSMsg.KK0491_GENE_ADD_DTM_ERR);
		// 支払方法審査マップ.クレジットカード_請求方法番号（クレジットカード） → クレジットカード_請求方法番号（クレジットカード） のエラー情報返却
		errMapping(template, inMap, EKK1071C141CBSMsg.SEIKY_WAY_NO_CRECARD_ERR);
		// 支払方法審査マップ.クレジットカード_世代登録年月日時分秒 → クレジットカード_世代登録年月日時分秒 のエラー情報返却
		errMapping(template, inMap, EKK1071C141CBSMsg.KK0521_GENE_ADD_DTM_ERR);
		// 支払方法審査マップ.クレジットカード_クレジットカード会社コード → クレジットカード_クレジットカード会社コード のエラー情報返却
		errMapping(template, inMap, EKK1071C141CBSMsg.CRECARD_COMP_CD_ERR);
		// 支払方法審査マップ.クレジットカード_クレジットカード番号 → クレジットカード_クレジットカード番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C141CBSMsg.CRECARD_NO_ERR);
		// 支払方法審査マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK1071C141CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(住所不備電話番号情報審査)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C151(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071C151CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 住所不備電話番号情報審査マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C151CBSMsg.JUDGE_NO_ERR);
		// 住所不備電話番号情報審査マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C151CBSMsg.SVC_KEI_NO_ERR);
		// 住所不備電話番号情報審査マップ.審査実施機能識別コード → 審査実施機能識別コード のエラー情報返却
		errMapping(template, inMap, EKK1071C151CBSMsg.JDG_JSSI_KINO_SKBT_CD_ERR);
		// 住所不備電話番号情報審査マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1071C151CBSMsg.IDO_DIV_ERR);
		// 住所不備電話番号情報審査マップ.回線場所住所コード → 回線場所住所コード のエラー情報返却
		errMapping(template, inMap, EKK1071C151CBSMsg.KAISEN_PLACE_AD_CD_ERR);
		// 住所不備電話番号情報審査マップ.回線場所郵便番号 → 回線場所郵便番号 のエラー情報返却
		errMapping(template, inMap, EKK1071C151CBSMsg.KAISEN_PLACE_PCD_ERR);
		// 住所不備電話番号情報審査マップ.回線場所都道府県名 → 回線場所都道府県名 のエラー情報返却
		errMapping(template, inMap, EKK1071C151CBSMsg.KAISEN_PLACE_STATE_NM_ERR);
		// 住所不備電話番号情報審査マップ.回線場所市区町村名 → 回線場所市区町村名 のエラー情報返却
		errMapping(template, inMap, EKK1071C151CBSMsg.KAISEN_PLACE_CITY_NM_ERR);
		// 住所不備電話番号情報審査マップ.回線場所大字通称名 → 回線場所大字通称名 のエラー情報返却
		errMapping(template, inMap, EKK1071C151CBSMsg.KAISEN_PLACE_OAZTSU_NM_ERR);
		// 住所不備電話番号情報審査マップ.回線場所字丁目名 → 回線場所字丁目名 のエラー情報返却
		errMapping(template, inMap, EKK1071C151CBSMsg.KAISEN_PLACE_AZCHO_NM_ERR);
		// 住所不備電話番号情報審査マップ.回線場所番地号 → 回線場所番地号 のエラー情報返却
		errMapping(template, inMap, EKK1071C151CBSMsg.KAISEN_PLACE_BNCHIGO_ERR);
		// 住所不備電話番号情報審査マップ.回線場所住所未確定フラグ → 回線場所住所未確定フラグ のエラー情報返却
		errMapping(template, inMap, EKK1071C151CBSMsg.KISN_PLC_AD_MI_FIX_FLG_ERR);
		// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
		// 住所不備電話番号情報審査マップ.回線場所住所チェックレベル → 回線場所住所チェックレベル のエラー情報返却
		errMapping(template, inMap, EKK1071C151CBSMsg.KAISEN_PLACE_AD_CHK_LV_ERR);
		// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
		
		ArrayList msg1List = (ArrayList)inMap.get(EKK1071C151CBSMsg.EKK1071C151CBSMSG1LIST);
		if (msg1List == null)
		{
			msg1List = new ArrayList();
			inMap.put(EKK1071C151CBSMsg.EKK1071C151CBSMSG1LIST, msg1List);
		}
		CAANMsg[] templateArray = template.getCAANMsgList(EKK1071C151CBSMsg.EKK1071C151CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				if (i >= msg1List.size())
				{
					msg1List.add(new HashMap());
				}
				HashMap childMap = (HashMap)msg1List.get(i);
				CAANMsg childTemplate = templateArray[i];
				// 住所不備電話番号情報審査マップ.サービス契約内訳<eo光電話>_緊急通報用住所コード
				// → サービス契約内訳<eo光電話>_緊急通報用住所コード のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C151CBSMsg1List.EMG_AD_CD_ERR);
				// 住所不備電話番号情報審査マップ.サービス契約内訳<eo光電話>_緊急通報用郵便番号
				// → サービス契約内訳<eo光電話>_緊急通報用郵便番号 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C151CBSMsg1List.EMG_HOSEI_PCD_ERR);
				// 住所不備電話番号情報審査マップ.サービス契約内訳<eo光電話>_緊急通報用都道府県名
				// → サービス契約内訳<eo光電話>_緊急通報用都道府県名 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C151CBSMsg1List.EMG_STATE_NM_ERR);
				// 住所不備電話番号情報審査マップ.サービス契約内訳<eo光電話>_緊急通報用市区町村名
				// → サービス契約内訳<eo光電話>_緊急通報用市区町村名 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C151CBSMsg1List.EMG_CITY_NM_ERR);
				// 住所不備電話番号情報審査マップ.サービス契約内訳<eo光電話>_緊急通報用大字通称名
				// → サービス契約内訳<eo光電話>_緊急通報用大字通称名 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C151CBSMsg1List.EMG_OAZTSU_NM_ERR);
				// 住所不備電話番号情報審査マップ.サービス契約内訳<eo光電話>_緊急通報用字丁目名
				// → サービス契約内訳<eo光電話>_緊急通報用字丁目名 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C151CBSMsg1List.EMG_AZCHO_NM_ERR);
				// 住所不備電話番号情報審査マップ.サービス契約内訳<eo光電話>_緊急通報用番地号
				// → サービス契約内訳<eo光電話>_緊急通報用番地号 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C151CBSMsg1List.EMG_BNCHIGO_ERR);
				// ▼▼▼ ST3-2013-0000040 AS ▼▼▼
				// → 緊急通報用住所チェックレベル のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C151CBSMsg1List.EMG_AD_CHK_LV_ERR);
				// ▲▲▲ ST3-2013-0000040 AE ▲▲▲
			}
		}
		// 住所不備電話番号情報審査マップ.住所不備電話番号情報審査明細 → 住所不備電話番号情報審査明細 のエラー情報返却
		errMapping(template, inMap, EKK1071C151CBSMsg.EKK1071C151CBSMSG1LIST_ERR);
		
		// 住所不備電話番号情報審査マップ.更新年月日時分秒(更新前) → 更新年月日時分秒(更新前) のエラー情報返却
		errMapping(template, inMap, EKK1071C151CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(サービス契約一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0081A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0081A010CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// サービス契約一意照会マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR);
		// サービス契約一意照会マップ.予約適用年月日 → 予約適用年月日 のエラー情報返却
		errMapping(template, inMap, EKK0081A010CBSMsg.KEY_RSV_APLY_YMD_ERR);
		// サービス契約一意照会マップ.世代登録年月日時分秒 → 世代登録年月日時分秒 のエラー情報返却
		errMapping(template, inMap, EKK0081A010CBSMsg.KEY_GENE_ADD_DTM_ERR);
		
		return param;
	}
	
	// ▼▼▼ 2012/11/5 ST1-2012-0000805 Add Start ▼▼▼
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(サービス契約内訳一覧照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0161B001(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0081A010CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// サービス契約内訳一覧照会マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0161B001CBSMsg.KEY_SVC_KEI_NO_ERR);
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(サービス契約内訳<eo光電話>一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0191A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0081A010CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// サービス契約内訳<eo光電話>一意照会マップ.サービス契約内訳番号 → サービス契約内訳番号 のエラー情報返却
		errMapping(template, inMap, EKK0191A010CBSMsg.KEY_SVC_KEI_UCWK_NO_ERR);
		
		// サービス契約内訳<eo光電話>一意照会マップ.世代登録年月日時分秒 → 世代登録年月日時分秒 のエラー情報返却
		errMapping(template, inMap, EKK0191A010CBSMsg.KEY_GENE_ADD_DTM_ERR);
		
		return param;
	}

	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(審査結果反映)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071C010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0081A010CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		ArrayList msg1List = (ArrayList)inMap.get(EKK1071C010CBSMsg.EKK1071C010CBSMSG1LIST);
		if (msg1List == null)
		{
			msg1List = new ArrayList();
			inMap.put(EKK1071C010CBSMsg.EKK1071C010CBSMSG1LIST, msg1List);
		}
		CAANMsg[] templateArray = template.getCAANMsgList(EKK1071C010CBSMsg.EKK1071C010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				if (i >= msg1List.size())
				{
					msg1List.add(new HashMap());
				}
				HashMap childMap = (HashMap)msg1List.get(i);
				CAANMsg childTemplate = templateArray[i];
				// 審査結果反映マップ.審査番号 → 審査番号 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C010CBSMsg1List.JUDGE_NO_ERR);
				// 審査結果反映マップ.審査年月日 → 審査年月日 のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C010CBSMsg1List.JUDGE_YMD_ERR);
				// 審査結果反映マップ.審査判定結果コード → 審査判定結果コード のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C010CBSMsg1List.JUDGE_JUDGE_RSLT_CD_ERR);
				// 審査結果反映マップ.更新年月日時分秒（更新前） → 更新年月日時分秒（更新前） のエラー情報返却
				errMapping(childTemplate, childMap, EKK1071C010CBSMsg1List.UPD_DTM_BF_ERR);
			}
		}
		
		return param;
	}
	// ▲▲▲ 2012/11/5 ST1-2012-0000805 Add End ▲▲▲

	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(審査詳細一覧照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1981B001(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1981B001CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 審査詳細一覧照会マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1981B001CBSMsg.KEY_JUDGE_NO_ERR);
		// 審査詳細一覧照会マップ.審査詳細種別コード → 審査詳細種別コード のエラー情報返却
		errMapping(template, inMap, EKK1981B001CBSMsg.KEY_JDG_DTL_SBT_CD_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(審査一覧照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071B011(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071B011CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 審査詳細一覧照会マップ.審査番号 → 審査番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_JUDGE_NO_ERR);
		// 審査詳細一覧照会マップ.審査種別コード → 審査種別コード のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_JUDGE_SBT_CD_ERR);
		// 審査詳細一覧照会マップ.審査対象種別コード → 審査対象種別コード のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_JUDGE_TG_SBT_CD_ERR);
		// 審査詳細一覧照会マップ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR);
		// 審査詳細一覧照会マップ.申込明細番号 → 申込明細番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_MSKM_DTL_NO_ERR);
		// 審査詳細一覧照会マップ.オプションサービス契約番号 → オプションサービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_OP_SVC_KEI_NO_ERR);
		// 審査詳細一覧照会マップ.サブオプションサービス契約番号 → サブオプションサービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_SBOP_SVC_KEI_NO_ERR);
		// 審査詳細一覧照会マップ.請求オプションサービス契約番号 → 請求オプションサービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_SEIOPSVC_KEI_NO_ERR);
		// 審査詳細一覧照会マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_SVC_KEI_NO_ERR);
		// 審査詳細一覧照会マップ.サービス契約内訳番号 → サービス契約内訳番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_SVC_KEI_UCWK_NO_ERR);
		// 審査詳細一覧照会マップ.SYSID → SYSID のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_SYSID_ERR);
		// 審査詳細一覧照会マップ.割引サービス契約番号 → 割引サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071B011CBSMsg.KEY_WRIB_SVC_KEI_NO_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(進捗登録)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1091D010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1091D010CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 進捗登録マップ.申込明細番号 → 申込明細番号 のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.MSKM_DTL_NO_ERR);
		// 進捗登録マップ.請求契約番号 → 請求契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.SEIKY_KEI_NO_ERR);
		// 進捗登録マップ.請求方法番号(口座) → 請求方法番号(口座) のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.SEIKY_WAY_NO_KOZA_ERR);
		// 進捗登録マップ.請求方法番号(クレジットカード) → 請求方法番号(クレジットカード) のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.SEIKY_WAY_NO_CRECARD_ERR);
		// 進捗登録マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.SVC_KEI_NO_ERR);
		// 進捗登録マップ.サービス契約内訳番号 → サービス契約内訳番号 のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.SVC_KEI_UCWK_NO_ERR);
		// 進捗登録マップ.サービス契約回線内訳番号 → サービス契約回線内訳番号 のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR);
		// 進捗登録マップ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.KKTK_SVC_KEI_NO_ERR);
		// 進捗登録マップ.オプションサービス契約番号 → オプションサービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.OP_SVC_KEI_NO_ERR);
		// 進捗登録マップ.請求オプションサービス契約番号 → 請求オプションサービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.SEIOPSVC_KEI_NO_ERR);
		// 進捗登録マップ.サブオプションサービス契約番号 → サブオプションサービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.SBOP_SVC_KEI_NO_ERR);
		// 進捗登録マップ.割引サービス契約番号 → 割引サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.WRIB_SVC_KEI_NO_ERR);
		// 進捗登録マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.IDO_DIV_ERR);
		// 進捗登録マップ.異動年月日時分秒 → 異動年月日時分秒 のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.IDO_DTM_ERR);
		// 進捗登録マップ.進捗ステータス → 進捗ステータス のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.PRG_STAT_ERR);
		// 進捗登録マップ.進捗メモ → 進捗メモ のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.PRG_MEMO_ERR);
		// 進捗登録マップ.進捗特記事項1 → 進捗特記事項1 のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.PRG_TKJK_1_ERR);
		// 進捗登録マップ.進捗特記事項2 → 進捗特記事項2 のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.PRG_TKJK_2_ERR);

		ArrayList msgList = (ArrayList)inMap.get(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST);
		if (msgList == null)
		{
			msgList = new ArrayList();
			inMap.put(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST, msgList);
		}
		CAANMsg[] templateArray = template.getCAANMsgList(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				if (i >= msgList.size())
				{
					msgList.add(new HashMap());
				}
				HashMap childMap = (HashMap)msgList.get(i);
				CAANMsg childTemplate = templateArray[i];
				// 進捗登録マップ.異動理由コード → 異動理由コードのエラー情報返却
				errMapping(childTemplate, childMap, EKK1091D010CBSMsg1List.IDO_RSN_CD_ERR);
				// 進捗登録マップ.異動理由メモ → 異動理由メモのエラー情報返却
				errMapping(childTemplate, childMap, EKK1091D010CBSMsg1List.IDO_RSN_MEMO_ERR);
			}
		}
		// 進捗登録マップ.異動理由明細 → 異動理由明細 のエラー情報返却
		errMapping(template, inMap, EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(進捗一覧照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	// 20140625 ST4-2014-0000030 Mod Start
//	private IRequestParameterReadWrite editErrorInfoEKK1091B001(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
//	throws Throwable
	private IRequestParameterReadWrite editErrorInfoEKK1091B002(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	// 20140625 ST4-2014-0000030 Mod End
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		// 20140625 ST4-2014-0000030 Mod Start
//		int templateStatus = template.getInt(EKK1091B001CBSMsg.STATUS);
		int templateStatus = template.getInt(EKK1091B002CBSMsg.STATUS);
		// 20140625 ST4-2014-0000030 Mod Start
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 20140625 ST4-2014-0000030 Del Start
//		// 進捗一覧照会マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
//		errMapping(template, inMap, EKK1091B001CBSMsg.KEY_SVC_KEI_NO_ERR);
//		// 進捗一覧照会マップ.異動区分 → 異動区分 のエラー情報返却
//		errMapping(template, inMap, EKK1091B001CBSMsg.KEY_IDO_DIV_ERR);
//		// 進捗一覧照会マップ.ソート項目 → ソート項目 のエラー情報返却
//		errMapping(template, inMap, EKK1091B001CBSMsg.KEY_SORT_ITEM);
//		// 進捗一覧照会マップ.ソート順 → ソート順 のエラー情報返却
//		errMapping(template, inMap, EKK1091B001CBSMsg.KEY_SORT_ORDER);
		// 20140625 ST4-2014-0000030 Del End

		// 20140625 ST4-2014-0000030 Add Start
		// 進捗一覧照会マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1091B002CBSMsg.KEY_SVC_KEI_NO_ERR);
		// 進捗一覧照会マップ.異動区分 → 異動区分 のエラー情報返却
		errMapping(template, inMap, EKK1091B002CBSMsg.KEY_IDO_DIV_ERR);
	    // 進捗一覧照会マップ.申込明細番号 → 申込明細番 のエラー情報返却
		errMapping(template, inMap, EKK1091B002CBSMsg.KEY_MSKM_DTL_NO_ERR);
	    // 進捗一覧照会マップ.請求契約番号 → 請求契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1091B002CBSMsg.KEY_SEIKY_KEI_NO_ERR);
	    // 進捗一覧照会マップ.サービス契約内訳番号 → サービス契約内訳番号 のエラー情報返却
		errMapping(template, inMap, EKK1091B002CBSMsg.KEY_SVC_KEI_UCWK_NO_ERR);
	    // 進捗一覧照会マップ.サービス契約回線内訳番号 → サービス契約回線内訳番号 のエラー情報返却
		errMapping(template, inMap, EKK1091B002CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO_ERR);
	    // 進捗一覧照会マップ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1091B002CBSMsg.KEY_KKTK_SVC_KEI_NO_ERR);
	    // 進捗一覧照会マップ.オプションサービス契約番号 → オプションサービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1091B002CBSMsg.KEY_OP_SVC_KEI_NO_ERR);
	    // 進捗一覧照会マップ.請求オプションサービス契約番号 → 請求オプションサービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1091B002CBSMsg.KEY_SEIOPSVC_KEI_NO_ERR);
	    // 進捗一覧照会マップ.サブオプションサービス契約番号 → サブオプションサービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1091B002CBSMsg.KEY_SBOP_SVC_KEI_NO_ERR);
	    // 進捗一覧照会マップ.割引サービス契約番号 → 割引サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1091B002CBSMsg.KEY_WRIB_SVC_KEI_NO_ERR);
		// 進捗一覧照会マップ.ソート項目 → ソート項目 のエラー情報返却
		errMapping(template, inMap, EKK1091B002CBSMsg.KEY_SORT_ITEM_NO_ERR);
		// 進捗一覧照会マップ.ソート順 → ソート順 のエラー情報返却
		errMapping(template, inMap, EKK1091B002CBSMsg.KEY_SORT_KBN_ERR);
		// 20140625 ST4-2014-0000030 Add End

		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(業務パラメータ一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEZM0321A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EZM0321A010CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 業務パラメータ一意照会マップ.業務パラメータＩＤ → 業務パラメータＩＤ のエラー情報返却
		errMapping(template, inMap, EZM0321A010CBSMsg.KEY_WORK_PARAM_ID_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(審査実施条件一覧照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1841B001(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1841B001CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 審査実施条件一覧照会マップ.審査実施条件種別コード → 審査実施条件種別コード のエラー情報返却
		errMapping(template, inMap, EKK1841B001CBSMsg.KEY_JDG_JSJKN_SBT_CD_ERR);
		// 審査実施条件一覧照会マップ.料金グループコード → 料金グループコード のエラー情報返却
		errMapping(template, inMap, EKK1841B001CBSMsg.KEY_PRC_GRP_CD_ERR);
		// 審査実施条件一覧照会マップ.審査実施機能詳細種別コード → 審査実施機能詳細種別コード のエラー情報返却
		errMapping(template, inMap, EKK1841B001CBSMsg.KEY_SJSSI_KINO_DTL_SKBT_CD_ERR);
		
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(審査登録)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK1071D010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK1071D010CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 審査登録マップ.審査種別コード → 審査種別コード のエラー情報返却
		errMapping(template, inMap, EKK1071D010CBSMsg.JUDGE_SBT_CD_ERR);
		// 審査登録マップ.審査対象種別コード → 審査対象種別コード のエラー情報返却
		errMapping(template, inMap, EKK1071D010CBSMsg.JUDGE_TG_SBT_CD_ERR);
		// 審査登録マップ.機器提供サービス契約番号 → 機器提供サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071D010CBSMsg.KKTK_SVC_KEI_NO_ERR);
		// 審査登録マップ.申込明細番号 → 申込明細番号 のエラー情報返却
		errMapping(template, inMap, EKK1071D010CBSMsg.MSKM_DTL_NO_ERR);
		// 審査登録マップ.オプションサービス契約番号 → オプションサービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071D010CBSMsg.OP_SVC_KEI_NO_ERR);
		// 審査登録マップ.サブオプションサービス契約番号 → サブオプションサービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071D010CBSMsg.SBOP_SVC_KEI_NO_ERR);
		// 審査登録マップ.請求サブオプションサービス契約番号 → 請求オプションサービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071D010CBSMsg.SEIOPSVC_KEI_NO_ERR);
		// 審査登録マップ.サービス契約番号 → サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071D010CBSMsg.SVC_KEI_NO_ERR);
		// 審査登録マップ.サービス契約内訳番号 → サービス契約内訳番号 のエラー情報返却
		errMapping(template, inMap, EKK1071D010CBSMsg.SVC_KEI_UCWK_NO_ERR);
		// 審査登録マップ.SYSID → SYSID のエラー情報返却
		errMapping(template, inMap, EKK1071D010CBSMsg.SYSID_ERR);
		// 審査登録マップ.割引サービス契約番号 → 割引サービス契約番号 のエラー情報返却
		errMapping(template, inMap, EKK1071D010CBSMsg.WRIB_SVC_KEI_NO_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(お客様一覧照会（姓一致）)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoECK0011B006(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(ECK0011B006CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// お客様一覧照会（姓一致）マップ.お客様名 → お客様名 のエラー情報返却
		errMapping(template, inMap, ECK0011B006CBSMsg.KEY_CUST_NM_ERR);
		
		return param;
	}
	
//	/**
//	 *<DL>
//	 *<DT>処理概要:
//	 *<DD>サービスコンポーネント(宅内機器物流倉庫一覧照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
//	 *<DT>入力パラメータ説明:
//	 *<DD>特になし
//	 *<DT>入力パラメータ説明：
//	 *<DD>特になし
//	 *<DT>出力パラメータ説明:
//	 *<DD>特になし
//	 *</DL>
//	 * @param param (I) 業務データ取得・書込用I/F
//	 * @param templates (I) CAANMsgクラス配列
//	 * @param returnCode (I) リターンコード
//	 * @return 業務データ取得・書込用I/F
//	 * @since 2011.11.04
//	 */
//	@SuppressWarnings("unchecked")
//	private IRequestParameterReadWrite editErrorInfoETN0091B010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
//	throws Throwable {
//		// SCからの戻り値からCAANMsgを取得
//		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
//		// リターンコード取得
//		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
//		
//		CAANMsg template = templates[0];
//		int templateStatus = template.getInt(ETN0091B010CBSMsg.STATUS);
//		if (returnCode.intValue() != 0) {
//			templateStatus = 9000;
//		}
//		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null) {
//			templateStatus = 0;
//		}
//		
//		int bpStatus = 0;
//		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
//		if (obj == null) {
//			bpStatus = -1;
//		} else {
//			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
//		}
//
//		if (templateStatus > bpStatus) {
//			// BPにサービスコンポーネントのステータスを設定する。
//			String formatStatus = String.format("%1$04d", templateStatus);
//			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
//			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
//			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
//		}
//		
//		HashMap inMap = null;
//		
//		// 作業項目領域
//		Map workMap = param.getMappingWorkArea();
//		if (workMap == null) {
//			workMap = new HashMap();
//			param.setMappingWorkArea(workMap);
//		}
//		
//		/* ユーザデータ情報 */
//		inMap = (HashMap)param.getData("err_map");
//		if (inMap == null) {
//			inMap = new HashMap();
//			param.setData("err_map", inMap);
//		}
//
//		// 宅内機器物流倉庫一覧照会マップ.倉庫コード → 倉庫コード のエラー情報返却
//		errMapping(template, inMap, ETN0091B010CBSMsg.KEY_SOKO_CD_ERR);
//		// 宅内機器物流倉庫一覧照会マップ.棚コード → 棚コード のエラー情報返却
//		errMapping(template, inMap, ETN0091B010CBSMsg.KEY_SHELF_CD_ERR);
//		// 宅内機器物流倉庫一覧照会マップ.付属品型式コード → 付属品型式コード のエラー情報返却
//		errMapping(template, inMap, ETN0091B010CBSMsg.KEY_HUZOKUHIN_MODEL_CD_ERR);
//		// 宅内機器物流倉庫一覧照会マップ.宅内機器型式コード → 宅内機器型式コード のエラー情報返却
//		errMapping(template, inMap, ETN0091B010CBSMsg.KEY_TAKNKIKI_MODEL_CD_ERR);
//		
//		return param;
//	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(宅内機器物流倉庫一覧照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKKA0020005(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
//		Integer returnCode = (Integer)rsltMap.get(EKKA0020005CBSMsg.RETURN_CD);
		String returnCode = (String)rsltMap.get(EKKA0020005CBSMsg.RETURN_CD);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKKA0020005CBSMsg.STATUS);
//		if (returnCode.intValue() != 0) {
		if (!"".equals(returnCode) && null != returnCode)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}
		
		// 宅内機器物流倉庫一覧照会マップ.管理場所識別コード → ＫＥＹ＿管理場所識別コード のエラー情報返却
		errMapping(template, inMap, EKKA0020005CBSMsg1List.KEY_KNRI_PLC_SKBT_CD_ERR);
		// 宅内機器物流倉庫一覧照会マップ.管理場所コード → ＫＥＹ＿管理場所コード のエラー情報返却
		errMapping(template, inMap, EKKA0020005CBSMsg1List.KEY_KNRI_PLC_CD_ERR);
		// 宅内機器物流倉庫一覧照会マップ.管理場所棚コード → ＫＥＹ＿管理場所棚コード のエラー情報返却
		errMapping(template, inMap, EKKA0020005CBSMsg1List.KEY_KNRI_PLC_SLF_CD_ERR);
		// 宅内機器物流倉庫一覧照会マップ.宅内機器型式コード → ＫＥＹ＿宅内機器型式コード のエラー情報返却
		errMapping(template, inMap, EKKA0020005CBSMsg1List.KEY_TK_MDL_CD_ERR);
		
		return param;
	}
	
	// 2012/12/06 [TAI-2012-0000091]暫定ロジック修正対応 ADD START
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(宅内機器一意照会（４）)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKKA0020003(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		String returnCode = (String)rsltMap.get(EKKA0020003CBSMsg.RETURN_CD);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKKA0020003CBSMsg.STATUS);
		if (!"".equals(returnCode) && null != returnCode)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}
		
		// 宅内機器一意照会（４）マップ.宅内機器型式コード → ＫＥＹ＿宅内機器型式コード のエラー情報返却
		errMapping(template, inMap, EKKA0020003CBSMsg1List.KEY_TK_MDL_CD_ERR);
		// 宅内機器一意照会（４）マップ.機器製造番号 → ＫＥＹ＿機器製造番号 のエラー情報返却
		errMapping(template, inMap, EKKA0020003CBSMsg1List.KEY_KK_SEIZO_NO_ERR);
		
		return param;
	}
	// 2012/12/06 [TAI-2012-0000091]暫定ロジック修正対応 ADD END
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(請求契約一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0491A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0491A010CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 請求契約一意照会マップ.請求契約番号 → 請求契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR);
		// 請求契約一意照会マップ.予約適用年月日 → 予約適用年月日 のエラー情報返却
		errMapping(template, inMap, EKK0491A010CBSMsg.KEY_RSV_APLY_YMD_ERR);
		// 請求契約一意照会マップ.世代登録年月日時分秒 → 世代登録年月日時分秒 のエラー情報返却
		errMapping(template, inMap, EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(サービス契約回線内訳一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0251A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0251A010CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// サービス契約回線内訳一意照会マップ.サービス契約回線内訳番号 → サービス契約回線内訳番号 のエラー情報返却
		errMapping(template, inMap, EKK0251A010CBSMsg.KEY_SVC_KEI_KAISEN_UCWK_NO_ERR);
		// サービス契約回線内訳一意照会マップ.世代登録年月日時分秒 → 世代登録年月日時分秒 のエラー情報返却
		errMapping(template, inMap, EKK0251A010CBSMsg.KEY_GENE_ADD_DTM_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(お客様一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2011.11.04
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoECK0011A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(ECK0011A010CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// お客様一意照会マップ.SYSID → SYSID のエラー情報返却
		errMapping(template, inMap, ECK0011A010CBSMsg.KEY_SYSID_ERR);
		// お客様一意照会マップ.予約適用年月日 → 予約適用年月日 のエラー情報返却
		errMapping(template, inMap, ECK0011A010CBSMsg.KEY_RSV_APLY_YMD_ERR);
		// お客様一意照会マップ.世代登録年月日時分秒 → 世代登録年月日時分秒 のエラー情報返却
		errMapping(template, inMap, ECK0011A010CBSMsg.KEY_GENE_ADD_DTM_ERR);
		
		return param;
	}
	
	// ▼▼▼ OT-2013-0000090 Add Start    ▼▼▼
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(提供方式契約一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.02.28
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0891A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0891A010CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 提供方式契約一意照会マップ.提供方式契約番号 → 提供方式契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0891A010CBSMsg.KEY_TK_HOSHIKI_KEI_NO_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(回線使用契約一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.02.28
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0881A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0881A010CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// 回線使用契約一意照会マップ.回線使用契約番号 → 回線使用契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0881A010CBSMsg.KEY_KAISEN_USE_KEI_NO_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(オーナー契約一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.02.28
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0871A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0871A010CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// オーナー契約一意照会マップ.オーナー契約番号 → オーナー契約番号 のエラー情報返却
		errMapping(template, inMap, EKK0871A010CBSMsg.KEY_OWNR_KEI_NO_ERR);
		
		return param;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント(マンション物件一意照会)実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param rsltMap (I) CAANMsgクラス配列
	 * @return 業務データ取得・書込用I/F
	 * @throws Throwable
	 * @since 2013.02.28
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editErrorInfoEKK0861A010(IRequestParameterReadWrite param, Map<?, ?> rsltMap)
	throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		// リターンコード取得
		Integer returnCode = (Integer)rsltMap.get(JCMConstants.RET_CD_INT_KEY);
		
		CAANMsg template = templates[0];
		int templateStatus = template.getInt(EKK0861A010CBSMsg.STATUS);
		if (returnCode.intValue() != 0)
		{
			templateStatus = 9000;
		}
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		HashMap inMap = null;
		
		// 作業項目領域
		Map workMap = param.getMappingWorkArea();
		if (workMap == null)
		{
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		/* ユーザデータ情報 */
		inMap = (HashMap)param.getData("err_map");
		if (inMap == null)
		{
			inMap = new HashMap();
			param.setData("err_map", inMap);
		}

		// マンション物件一意照会マップ.マンション物件番号 → マンション物件番号 のエラー情報返却
		errMapping(template, inMap, EKK0861A010CBSMsg.KEY_MANSION_BUKKEN_NO_ERR);
		
		return param;
	}
	// ▲▲▲ OT-2013-0000090 Add End      ▲▲▲
	
	/**
	 * サービスIFの結果を取得する。
	 * @param rsltMap サービスIFリスト
	 * @return templateList 結果が格納されたリスト
	 * @throws Throwable 
	 */
	private ArrayList<CAANMsg> getRsltList(Map<?, ?> rsltMap) throws Throwable
	{
		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[])rsltMap.get(JCMConstants.TEMPLATE_LIST_KEY);
		ArrayList<CAANMsg> rsltCaanList = new ArrayList<CAANMsg>();
		for(int i = 0; i < templates.length; i++)
		{
			rsltCaanList.add(templates[i]);
		}
		
		return rsltCaanList;
	}
	
	/**
	 * 単項目のエラーマッピング.
	 * <br>
	 * @param  template  テンプレート情報
	 * @param  dataMap   マップ情報
	 * @param  targetNm  マッピング対象項目
	 */
	@SuppressWarnings("unchecked")
	private void errMapping(CAANMsg template, HashMap dataMap, String targetNm)
	{
		if ((!template.isNull(targetNm)) && (!dataMap.containsKey(targetNm)))
		{
			dataMap.put(targetNm, template.getString(targetNm));
		}
	}
	
	/**
	 * サービスコンポーネント実行結果確認.
	 * <br>
	 * @param param 
	 * @param resultMap     セッションマネージャなどを持ったハンドル情報
	 * @throws Throwable  例外が発生した場合
	 */
	private void scResultCheck(IRequestParameterReadWrite param, Map<?, ?> resultMap) throws Throwable
	{
		int rtnCode = Integer.parseInt(param.getControlMapData(SCControlMapKeys.RETURN_CODE).toString());
		// サービスコンポーネントの実行結果に単項目以上のエラーがある場合、例外とする
		if (rtnCode >= JPCModelConstant.SINGLEDATA_ERR)
		{
			throw new CCException("", new Exception());
		}
	}
	// TODO エラーリファレンス終了
	
	/**
	 * リストに設定値があるか判定をする。
	 * @param list エンティティリスト
	 * @return 判定結果
	 * @throws Throwable
	 */
	private boolean isListNull(ArrayList<HashMap<String, String>> list) throws Throwable
	{
		boolean rslt = false;
		
		if(list == null || list.size() == 0)
		{
			rslt = true;
		}
		else
		{
			if(list.get(0) == null)
			{
				rslt = true;
			}
		}
		
		return rslt;
	}
	
	/**
	 * 審査CC処理チェック処理です。<br>
	 * <br>
	 * @param handle セッションマネージャなどを持ったハンドル
	 * @param param モデルグループ、コントロールマップを含むパラメータオブジェクト
	 * @param fixedText ユーザ任意文字列
	 * @return サービスコンポーネント実行用CAANMsg
	 * @exception RequestParameterExceptionがスローされます。
	 */
	public HashMap<String, Object> getInvokeCBS(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) 
	throws RequestParameterException
	{
		// 審査CC用メッセージ設定処理
		HashMap<String, Object> paramMap = editInMsg(param, fixedText);
		return paramMap;
	}

	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 *</DL>
	 * 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @param templates (I) CAANMsgクラス配列
	 * @param returnCode (I) リターンコード
	 * @param fixedText (I) ユーザ任意文字列
	 * @return 業務データ取得・書込用I/F
	 * @exception RequestParameterExceptionがスローされます。
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, CAANMsg[] templates, int returnCode) 
	throws RequestParameterException
	{
		return param;
	}
// ANK-4427-00-00 ADD START	
	/**
	 * 契約がTypeNか否かを判定する。
	 * @return TypeNの場合はTrue,そうでなければFalse
	 * @throws Throwable 
	 */
	@SuppressWarnings("unchecked")
	private boolean chkTypeN(SessionHandle handle, IRequestParameterReadWrite param, String prcGrpCd, String pcrsCd) throws Throwable
	{
		if (JKKBpCommon.isTypeNHantei(param, handle, prcGrpCd, pcrsCd)){
			return true;
		}
		return false;
	}
// ANK-4427-00-00 ADD END
}