/*********************************************************************
*	All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*	システム名		：eo顧客基幹システム
*	モジュール名	：JKKCreateNhkDntIktCC
*	ソースファイル名：JKKCreateNhkDntIktCC.java
*	作成者			：Fujitsu
*	日付			：2014年10月01日
*＜機能概要＞
*	NHK団体一括解約者情報ファイル作成の共通コンポーネント
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v11.00.00	2014/10/01	Fujitsu		新規作成
*
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

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

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

import eo.common.util.JPCUtilCommon;
import eo.ejb.cbs.cbsmsg.ECK0011B007CBSMsg;
import eo.ejb.cbs.cbsmsg.ECK0011B007CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0011D020CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0011D020CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0021C060CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B027CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0321B002CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0321B002CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0441A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0441A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0441B003CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0441B003CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0441C330CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0441C340CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0441D020CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0491A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK1091D010CBSMsg1List;

/**
 * NHK団体一括情報の取得をします。<p>
 * <BR>
 * @author 富士通
 */
public class JKKCreateNhkDntIktCC extends AbstractCommonComponent
{
	/** テンプレートID(EKK0011D020) 申込内容承認登録 */
	private static final String TEMPLATE_ID_EKK0011D020 = "EKK0011D020";
	/** 申込明細照査・後続業務依頼 */
	private static final String TEMPLATE_ID_EKK0021C060 = "EKK0021C060";
	/** お客様情報履歴一覧照会（サービス契約番号） */
	private static final String TEMPLATE_ID_ECK0011B007 = "ECK0011B007";
	/** テンプレートID(EKK0321B002) 課金先一覧照会 */
	private static final String TEMPLATE_ID_EKK0321B002 = "EKK0321B002";
	/** 請求契約一意照会 */
	private static final String TEMPLATE_ID_EKK0491A010 = "EKK0491A010";
	/** 請求オプションサービス契約一意照会 */
	private static final String TEMPLATE_ID_EKK0441A010 = "EKK0441A010";
	/**請求オプションサービス契約一覧照会 */
	private static final String TEMPLATE_ID_EKK0441B003 = "EKK0441B003";	
	/** テンプレートID(EKK0441C330) 請求オプションサービス契約解約 */
	private static final String TEMPLATE_ID_EKK0441D020 = "EKK0441D020";
	/** テンプレートID(EKK0441C330) 請求オプションサービス契約変更 */
	private static final String TEMPLATE_ID_EKK0441C330 = "EKK0441C330";
	/** テンプレートID(EKK0441C340) 請求オプションサービス契約解約 */
	private static final String TEMPLATE_ID_EKK0441C340 = "EKK0441C340";	
	/** テンプレートID(EKK1091D010) 進捗登録 */
	private static final String TEMPLATE_ID_EKK1091D010 = "EKK1091D010";
	/** 機能コード（チェック＆登録） */
	private static final String FUNC_CODE_1 = "1";
	/** 機能コード（チェックのみ） */
	private static final String FUNC_CODE_2 = "2";
	/** エラーフラグ（エラー）*/
	private static final String ERR_FLG_ERR = "E";
	/** エラーフラグ（ワーニング）*/
	private static final String ERR_FLG_WARNING = "W";	
	/**
	 * 
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite seikyOpUpd(SessionHandle handle, IRequestParameterReadWrite param, String fixedText) throws Throwable
	{
		
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(fixedText);
		
		
		// エラーフラグ
		ccMsg.put("err_flg", "");
		
		// メッセージ情報
		ArrayList<HashMap<String, Object>> messageInfo = new ArrayList<HashMap<String, Object>>();
		
		// メッセージコードリスト
		ccMsg.put("message_list", messageInfo);
		
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない）
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		HashMap<String, Object> childMap = new HashMap<String, Object>();
		
		// 機能コード取得
		String func_code = (String)ccMsg.get("func_code");
		childMap.put(JCMConstants.FUNC_CODE_KEY, func_code);
		
		// 画面モード（0：更新確認、1：契約内容変）
		String s_mode = (String)ccMsg.get("s_mode");
		
		// 更新区分（01：追加、02：再利用 03:更新 04:解約）
		String upd_div = (String)ccMsg.get("upd_div");
		// ＮＨＫ外部連携契約コード
		String nhk_out_rnki_kei_cd = (String)ccMsg.get("nhk_out_rnki_kei_cd");
		// 元請求契約番号
		String moto_seiky_kei_no = (String)ccMsg.get("moto_seiky_kei_no");
		// 請求契契約番号
		String seiky_kei_no = (String)ccMsg.get("seiky_kei_no");
		// 元請求契オプションサービス契約番号
		String moto_seiopsvc_kei_no = (String)ccMsg.get("moto_seiopsvc_kei_no");
		// 先請求オプションサービス契約番号
		String saki_seiopsvc_kei_no = (String)ccMsg.get("saki_seiopsvc_kei_no");
		// 請求契オプションサービス契約番号
		String seiopsvc_kei_no = (String)ccMsg.get("seiopsvc_kei_no");
		// 予約適用年月日
		String tekiyoYmd = (String)ccMsg.get("tekiyoYmd");
		// 元適用
		String moto_prg_tkjk_1 = (String)ccMsg.get("moto_prg_tkjk_1");
		// 適用
		String prg_tkjk_1 = (String)ccMsg.get("prg_tkjk_1");
		// チェック又は加入者コード変更地の場合、実行します。
		if(FUNC_CODE_2.equals(func_code) || "1".equals(s_mode))
		{		
			// 申込内容承認登録
			kanrenChk(handle, param, scCall, ccMsg, childMap, fixedText);
		}
		// 画面モードが更新確認の場合、実行します。
		if("0".equals(s_mode))
		{
			if(FUNC_CODE_1.equals(func_code))
			{		
				// 申込内容承認登録
				execEKK0011D020(handle, param, scCall, ccMsg, childMap);
				// 申込明細照査・後続業務依頼SCの実行
				execEKK0021C060(handle, scCall, param, fixedText, ccMsg, childMap, tekiyoYmd);
			}
			if("01".equals(upd_div))
			{
				// 請求契約一意照会
				execEKK0491A010(handle, param, scCall, ccMsg, childMap, fixedText,  seiky_kei_no, tekiyoYmd);
				// 請求オプションサービス契約登録
				execEKK0441D020(handle, param, scCall, ccMsg, childMap);
				seiopsvc_kei_no = (String)childMap.get("EKK0441D020_seiopsvc_kei_no");
			} else if("02".equals(upd_div))
			{
					// 請求オプションサービス契約自動解約
					// 請求オプションサービス一意照会
					execEKK0441B003(handle, param, scCall, ccMsg, childMap, fixedText,  nhk_out_rnki_kei_cd);
					// 請求オプションサービス契約ステータス
					String seiopsvcKeiNo = (String)ccMsg.get("EKK0441B003_seiopsvc_kei_no");
					// 請求契約番号
					String seiKeiNo = (String)ccMsg.get("EKK0441B003_seiky_kei_no");
					if (!"".equals(seiopsvcKeiNo) && seiopsvcKeiNo != null)
					{
						if (!saki_seiopsvc_kei_no.equals(seiopsvcKeiNo))
						{
							// 請求オプションサービス一意照会
							execEKK0441A010(handle, param, scCall, ccMsg, childMap, fixedText,  seiopsvcKeiNo, tekiyoYmd);
							// 自動解約
							execEKK0441C340(handle, param, scCall, ccMsg, childMap, seiopsvcKeiNo);
							if(FUNC_CODE_1.equals(func_code))
							{		
								// 自動進捗登録
								execEKK1091D010(handle, param, scCall, ccMsg, childMap, seiKeiNo, moto_prg_tkjk_1);
							}
						}
					}
					// 請求契約一意照会
					execEKK0491A010(handle, param, scCall, ccMsg, childMap, fixedText,  seiky_kei_no, tekiyoYmd);
					// 請求オプションサービス契約登録
					execEKK0441D020(handle, param, scCall, ccMsg, childMap);
					seiopsvc_kei_no = (String)childMap.get("EKK0441D020_seiopsvc_kei_no");
				} else if("03".equals(upd_div))
						{
							// 請求オプションサービス一意照会
							execEKK0441B003(handle, param, scCall, ccMsg, childMap, fixedText,  nhk_out_rnki_kei_cd);
							// 求オプションサービス契約ステータス
							String seiopsvcKeiNo = (String)ccMsg.get("EKK0441B003_seiopsvc_kei_no");
							// 請求契約番号
							String seiKeiNo = (String)ccMsg.get("EKK0441B003_seiky_kei_no");
							if (!"".equals(seiopsvcKeiNo) && seiopsvcKeiNo != null)
							{
								if (!saki_seiopsvc_kei_no.equals(seiopsvcKeiNo))
								{
									// 請求オプションサービス一意照会
									execEKK0441A010(handle, param, scCall, ccMsg, childMap, fixedText,  seiopsvcKeiNo, tekiyoYmd);
									// 自動解約
									execEKK0441C340(handle, param, scCall, ccMsg, childMap, seiopsvcKeiNo);
									if(FUNC_CODE_1.equals(func_code))
									{		
										// 自動進捗登録
										execEKK1091D010(handle, param, scCall, ccMsg, childMap, seiKeiNo, moto_prg_tkjk_1);
									}
								}
							}
							// 請求オプションサービス一意照会
							execEKK0441A010(handle, param, scCall, ccMsg, childMap, fixedText, seiopsvc_kei_no, tekiyoYmd);
							// 変更
							execEKK0441C330(handle, param, scCall, ccMsg, childMap, seiopsvc_kei_no);
						} else if("04".equals(upd_div))
								{
								// 請求オプションサービス一意照会
								execEKK0441A010(handle, param, scCall, ccMsg, childMap, fixedText,  seiopsvc_kei_no, tekiyoYmd);
								// 求オプションサービス契約ステータス
								String seiopsvc_kei_stat = (String)ccMsg.get("seiopsvc_kei_stat");
								if (!"910".equals(seiopsvc_kei_stat))
								{
									// 解約
									execEKK0441C340(handle, param, scCall, ccMsg, childMap, seiopsvc_kei_no);
								}
			}
			if(FUNC_CODE_1.equals(func_code))
			{		
				// 請求オプションサービス一意照会
				execEKK0441A010(handle, param, scCall, ccMsg, childMap, fixedText,  seiopsvc_kei_no, tekiyoYmd);
				// 進捗登録
				execEKK1091D010(handle, param, scCall, ccMsg, childMap, seiky_kei_no, prg_tkjk_1);
			}
		}
		
		return param;
	}
	
	/**
	 * 関連チェックを行います。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param scCall 
	 * @param dataMap リクエストデータ
	 * @throws Exception 
	 */
	private boolean kanrenChk(SessionHandle handle,
									IRequestParameterReadWrite param,
									ServiceComponentRequestInvoker scCall,
									HashMap<String, Object> ccMsg,
									HashMap<String, Object> childMap,
									String fixedText) throws Exception
	{
		// 遷移モード
		String sMode = (String)ccMsg.get("s_mode");
		// 更新区分
		String updDiv = (String)ccMsg.get("upd_div");
		// ＳＹＳＩＤ
		String sys_id = (String)ccMsg.get("sysid");
		
		// ＮＨＫ外部連携契約コード
		String nhk_out_rnki_kei_cd = (String)ccMsg.get("nhk_out_rnki_kei_cd");
		
		// 先請求契約番号
		String saki_seiky_kei_no = (String)ccMsg.get("saki_seiky_kei_no");
		// 元請求契約番号
		String moto_seiky_kei_no = (String)ccMsg.get("moto_seiky_kei_no");
		// 元請求オプションサービス契約番号
		String moto_seiopsvc_kei_no = (String)ccMsg.get("moto_seiopsvc_kei_no");
		// 先請求オプションサービス契約番号
		String saki_seiopsvc_kei_no = (String)ccMsg.get("saki_seiopsvc_kei_no");
		// 予約適用年月日
		String tekiyoYmd = (String)ccMsg.get("tekiyoYmd");
		childMap.put("tekiyoYmd", tekiyoYmd);
		// エラーフラグ
		ccMsg.put("err_flg", "");
		
		// 更新確認時かつ再利用又は変更で外部連携コードの移動がある場合
		if ("0".equals(sMode) && ("02".equals(updDiv) || "03".equals(updDiv)) && !"".equals(moto_seiky_kei_no))
		{
			// 請求オプションサービス一意照会
			execEKK0441B003(handle, param, scCall, ccMsg, childMap, fixedText,  nhk_out_rnki_kei_cd);
			// 請求オプションサービス契約ステータス
			String seiopsvc_kei_no = (String)ccMsg.get("EKK0441B003_seiopsvc_kei_no");
			if (!"".equals(seiopsvc_kei_no) && seiopsvc_kei_no != null)
			{
				if (!saki_seiopsvc_kei_no.equals(seiopsvc_kei_no))
				{
					// ワーンイングメッセージを設定
					// 「対象の加入者コードを使用している請求オプションサービス契約の解約を行います。よろしいですか？」
					setMessageInfo(ccMsg, "EKBE171-KQ", "", "", ERR_FLG_WARNING);
				}
			}
			// ＳＹＳＩＤ
			HashMap<String, Object> sysIdMap = new HashMap<String, Object>();
			
			// 課金先一覧照会
			Object[][] ekk0321b002In = {{EKK0321B002CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0321B002},
										{EKK0321B002CBSMsg.FUNC_CODE, "4"},
										{EKK0321B002CBSMsg.KEY_SEIKY_KEI_NO, moto_seiky_kei_no},
										{EKK0321B002CBSMsg.KEY_RSV_APLY_YMD, tekiyoYmd}
										};
			
			CAANMsg[] ekk0321b002Out = callSC(handle, scCall, param, fixedText, ekk0321b002In).getCAANMsgList(EKK0321B002CBSMsg.EKK0321B002CBSMSG1LIST);
			if (ekk0321b002Out != null && ekk0321b002Out.length > 0)
			{
				for (int i = 0; i < ekk0321b002Out.length; i++)
				{
					// サービス契約番号
					String svc_kei_no = getNullToStr(ekk0321b002Out[i].getString(EKK0321B002CBSMsg1List.SVC_KEI_NO));
					if ("".equals(svc_kei_no))
					{
						continue;
					}
					// お客様情報履歴一覧照会（サービス契約番号）
					Object[][] ECK0011B007in = {{ECK0011B007CBSMsg.TEMPLATEID, TEMPLATE_ID_ECK0011B007},
												{ECK0011B007CBSMsg.FUNC_CODE, "1"},
												{ECK0011B007CBSMsg.KEY_SVC_KEI_NO, svc_kei_no},
												};
					
					// お客様情報履歴一覧照会（サービス契約番号）
					CAANMsg[] ECK0011B007Out = callSC(handle, scCall, param, fixedText, ECK0011B007in).getCAANMsgList(ECK0011B007CBSMsg.ECK0011B007CBSMSG1LIST);
					if (ECK0011B007Out != null && ECK0011B007Out.length > 0)
					{
						for (int j = 0; j < ECK0011B007Out.length; j++)
						{
							sysIdMap.put(getNullToStr(ECK0011B007Out[j].getString(ECK0011B007CBSMsg1List.SYSID)), svc_kei_no);
						}
					}
				}
				// 自分が存在する
				boolean myFlg = false;
				// 他人が存在する
				boolean otherFlg = false;
				Iterator keys = sysIdMap.keySet().iterator();
				while (keys.hasNext())
				{
					Object key = keys.next();
					String sysid = key.toString();
					if (!"".equals(sysid))
					{
						// 自分が存在する
						if (sys_id.equals(sysid))
						{
							myFlg = true;
						}
						// 他人も存在する
						if (!sys_id.equals(sysid))
						{
							otherFlg = true;
						}
					}
				}
				if (!myFlg && otherFlg)
				{
					// ワーンイングメッセージを設定
					// 「他のお客様が使用している加入者コードを再利用します。よろしいですか？」
					setMessageInfo(ccMsg, "EKBE169-KQ", "", "", ERR_FLG_WARNING);
				}
				if (myFlg && otherFlg && !(moto_seiopsvc_kei_no.equals(saki_seiopsvc_kei_no)))
				{
					// ワーンイングメッセージを設定
					// 「他のお客様も使用できる加入者コードを再利用します。よろしいですか？」
					setMessageInfo(ccMsg, "EKBE170-KQ", "", "", ERR_FLG_WARNING);
				}
			}
		}
		
	return true;

	}
	
	/**
	 * 請求オプション一意照会を取得します。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param scCall 
	 * @param dataMap リクエストデータ
	 * @throws Exception 
	 */
	private void execEKK0491A010(SessionHandle handle,
									IRequestParameterReadWrite param,
									ServiceComponentRequestInvoker scCall,
									Map<String, Object> dataMap,
									HashMap<String, Object> childMap,
									String fixedText,
									String seikyKeiNo,
									String opeDate) throws Exception
	{
		
		// 請求契約一意照会
		Object[][] ekk0491a010In = {{EKK0491A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0491A010},
									{EKK0491A010CBSMsg.FUNC_CODE, "2"},
									{EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO, seikyKeiNo},
									{EKK0491A010CBSMsg.KEY_RSV_APLY_YMD, opeDate}};
		CAANMsg[]  ekk0491a010Out = callSC(handle, scCall, param, fixedText, ekk0491a010In).getCAANMsgList(EKK0491A010CBSMsg.EKK0491A010CBSMSG1LIST);;
		if (ekk0491a010Out != null && ekk0491a010Out.length > 0)
		{
			// 請求契約最終更新日
			dataMap.put("EKK0491A010_seikyu_upd_dtm", getNullToStr(ekk0491a010Out[0].getString(EKK0441A010CBSMsg1List.LAST_UPD_DTM)));
			
		}
	}
	
	/**
	 * 請求オプション一意照会を取得します。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param scCall 
	 * @param dataMap リクエストデータ
	 * @throws Exception 
	 */
	private void execEKK0441A010(SessionHandle handle,
									IRequestParameterReadWrite param,
									ServiceComponentRequestInvoker scCall,
									Map<String, Object> dataMap,
									HashMap<String, Object> childMap,
									String fixedText,
									String seiopSvcKeiNo,
									String opeDate) throws Exception
	{
		
		// 請求オプション契約一意照会
		Object[][] ekk0441A010In = {{EKK0441A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0441A010},
									{EKK0441A010CBSMsg.FUNC_CODE, "2"},
									{EKK0441A010CBSMsg.KEY_SEIOPSVC_KEI_NO, seiopSvcKeiNo},
									{EKK0441A010CBSMsg.KEY_RSV_APLY_YMD, opeDate}};
		CAANMsg[]  ekk0441a010Out = callSC(handle, scCall, param, fixedText, ekk0441A010In).getCAANMsgList(EKK0441A010CBSMsg.EKK0441A010CBSMSG1LIST);;
		if (ekk0441a010Out != null && ekk0441a010Out.length > 0)
		{
			// 請求オプションサービス契約ステータス
			dataMap.put("EKK0441A010_seiopsvc_kei_stat", getNullToStr(ekk0441a010Out[0].getString(EKK0441A010CBSMsg1List.SEIOPSVC_KEI_STAT)));
			// 請求契約最終更新日
			dataMap.put("EKK0441A010_seikyu_upd_dtm", getNullToStr(ekk0441a010Out[0].getString(EKK0441A010CBSMsg1List.LAST_UPD_DTM)));
			// NHK外部連携契約コード
			dataMap.put("EKK0441A010_nhk_out_rnki_kei_cd", getNullToStr(ekk0441a010Out[0].getString(EKK0441A010CBSMsg1List.NHK_OUT_RNKI_KEI_CD)));
			// SYSID
			dataMap.put("EKK0441A010_sysid", getNullToStr(ekk0441a010Out[0].getString(EKK0441A010CBSMsg1List.SYSID)));
			
		}
	}
	
	/**
	 * 請求オプション一覧照会を取得します。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param scCall 
	 * @param dataMap リクエストデータ
	 * @throws Exception 
	 */
	private void execEKK0441B003(SessionHandle handle,
									IRequestParameterReadWrite param,
									ServiceComponentRequestInvoker scCall,
									Map<String, Object> dataMap,
									HashMap<String, Object> childMap,
									String fixedText,
									String nhk_out_rnki_kei_cd) throws Exception
	{
		
		// 請求オプション契約一意照会
		Object[][] ekk0441b003In = {{EKK0441B003CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0441B003},
									{EKK0441B003CBSMsg.FUNC_CODE, "2"},
									{EKK0441B003CBSMsg.KEY_NHK_OUT_RNKI_KEI_CD, nhk_out_rnki_kei_cd}
									};
		CAANMsg[]  ekk0441b003Out = callSC(handle, scCall, param, fixedText, ekk0441b003In).getCAANMsgList(EKK0441B003CBSMsg.EKK0441B003CBSMSG1LIST);;
		if (ekk0441b003Out != null && ekk0441b003Out.length > 0)
		{
			// 請求オプションサービス契約番号
			dataMap.put("EKK0441B003_seiopsvc_kei_no", getNullToStr(ekk0441b003Out[0].getString(EKK0441B003CBSMsg1List.SEIOPSVC_KEI_NO)));
			// 請求オプションサービス契約ステータス
			dataMap.put("EKK0441B003_seiopsvc_kei_stat", getNullToStr(ekk0441b003Out[0].getString(EKK0441B003CBSMsg1List.SEIOPSVC_KEI_STAT)));
			// 請求契約番号
			dataMap.put("EKK0441B003_seiky_kei_no", getNullToStr(ekk0441b003Out[0].getString(EKK0441B003CBSMsg1List.SEIKY_KEI_NO)));
			
		}
	}
	
	/**
	 * 申込内容承認登録サービスを実行し値を取得します。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param scCall 
	 * @param dataMap リクエストデータ
	 * @throws Exception 
	 */
	private void execEKK0011D020(SessionHandle handle,
									IRequestParameterReadWrite param,
									ServiceComponentRequestInvoker scCall,
									Map<String, Object> dataMap,
									HashMap<String, Object> childMap) throws Exception
	{
		
		// ◇ 上りマッピング処理
		// リクエストパラメータを引数に上りマッピング処理メソッドを実行
		HashMap<String, Object> paramMap = editInMsg_EKK0011D020(param, dataMap, childMap);
		
		// ◇ SC呼出実行 (サービス契約一意照会)
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		editOutMsg_EKK0011D020(result, param, dataMap, childMap);
		
		//処理結果判定
		jdgErrRslt(result, 0);
	}
	
	/**
	 * 申込内容承認登録のメッセージを作成します。
	 * 
	 * @param param
	 * @param inMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> editInMsg_EKK0011D020(IRequestParameterReadWrite param,
																Map<String, Object> dataMap,
																HashMap<String, Object> childMap) throws RequestParameterException
	{
		
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

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

		// テンプレートID
		template.set(EKK0011D020CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0011D020);

		template.set(EKK0011D020CBSMsg.FUNC_CODE, "1");

		// オペレータ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);

		CAANMsg[] templateArray = null;

		ArrayList inList = null;
		
		// 機能コード
		template.set(EKK0011D020CBSMsg.FUNC_CODE, dataMap.get(JCMConstants.FUNC_CODE_KEY));

		// 申込内容承認登録マップ.SYSID → SYSID
		if ((String)dataMap.get("sysid") == null || "".equals(dataMap.get("sysid"))) {
			template.setNull(EKK0011D020CBSMsg.SYSID);
		} else {
			template.set(EKK0011D020CBSMsg.SYSID, (String) dataMap.get("sysid"));
		}

		// 申込内容承認登録マップ.申込種別コード → 申込種別コード
		if ((String)dataMap.get("mskm_sbt_cd") == null ||"".equals(dataMap.get("mskm_sbt_cd"))) {
			template.setNull(EKK0011D020CBSMsg.MSKM_SBT_CD);
		} else {
			template.set(EKK0011D020CBSMsg.MSKM_SBT_CD, (String) dataMap.get("mskm_sbt_cd"));
		}

		// 申込内容承認登録マップ.申込書到着年月日 → 申込書到着年月日
		if ((String)dataMap.get("mskmsho_ariv_ymd") == null ||"".equals(dataMap.get("mskmsho_ariv_ymd"))) {
			template.setNull(EKK0011D020CBSMsg.MSKMSHO_ARIV_YMD);
		} else {
			template.set(EKK0011D020CBSMsg.MSKMSHO_ARIV_YMD, (String) dataMap.get("mskmsho_ariv_ymd"));
		}

		// 申込内容承認登録マップ.申込受付年月日時分秒 → 申込受付年月日時分秒
		if ((String)dataMap.get("mskm_uk_dtm") == null ||"".equals(dataMap.get("mskm_uk_dtm"))) {
			template.setNull(EKK0011D020CBSMsg.MSKM_UK_DTM);
		} else {
			template.set(EKK0011D020CBSMsg.MSKM_UK_DTM, (String) dataMap.get("mskm_uk_dtm"));
		}

		// 申込内容承認登録マップ.申込受付担当ユーザーID → 申込受付担当ユーザーID
		if ((String)dataMap.get("mskm_uk_tnt_user_id") == null ||"".equals(dataMap.get("mskm_uk_tnt_user_id"))) {
			template.setNull(EKK0011D020CBSMsg.MSKM_UK_TNT_USER_ID);
		} else {
			template.set(EKK0011D020CBSMsg.MSKM_UK_TNT_USER_ID, (String) dataMap.get("mskm_uk_tnt_user_id"));
		}

		// 申込内容承認登録マップ.申込年月日 → 申込年月日
		if ((String)dataMap.get("mskm_ymd") == null ||"".equals(dataMap.get("mskm_ymd"))) {
			template.setNull(EKK0011D020CBSMsg.MSKM_YMD);
		} else {
			template.set(EKK0011D020CBSMsg.MSKM_YMD, (String)dataMap.get("mskm_ymd"));
		}

		// 申込内容承認登録マップ.総合営業センター受付番号 → 総合営業センター受付番号
		if ((String)dataMap.get("ttl_business_center_uk_no") == null ||"".equals(dataMap.get("ttl_business_center_uk_no"))) {
			template.setNull(EKK0011D020CBSMsg.TTL_BUSINESS_CENTER_UK_NO);
		} else {
			template.set(EKK0011D020CBSMsg.TTL_BUSINESS_CENTER_UK_NO, (String) dataMap.get("ttl_business_center_uk_no"));
		}

		// 申込内容承認登録マップ.総合営業申込契機コード → 総合営業申込契機コード
		if ((String)dataMap.get("ttl_business_mskm_opt_cd") == null ||"".equals(dataMap.get("ttl_business_mskm_opt_cd"))) {
			template.setNull(EKK0011D020CBSMsg.TTL_BUSINESS_MSKM_OPT_CD);
		} else {
			template.set(EKK0011D020CBSMsg.TTL_BUSINESS_MSKM_OPT_CD, (String) dataMap.get("ttl_business_mskm_opt_cd"));
		}

		// 申込内容承認登録マップ.申込連絡先電話番号 → 申込連絡先電話番号
		if ((String)dataMap.get("mskm_rrks_telno") == null ||"".equals(dataMap.get("mskm_rrks_telno"))) {
			template.setNull(EKK0011D020CBSMsg.MSKM_RRKS_TELNO);
		} else {
			template.set(EKK0011D020CBSMsg.MSKM_RRKS_TELNO, (String) dataMap.get("mskm_rrks_telno"));
		}

		// 申込内容承認登録マップ.申込実施者種別コード → 申込実施者種別コード
		if ((String)dataMap.get("mskm_jssis_sbt_cd") == null ||"".equals(dataMap.get("mskm_jssis_sbt_cd"))) {
			template.setNull(EKK0011D020CBSMsg.MSKM_JSSIS_SBT_CD);
		} else {
			template.set(EKK0011D020CBSMsg.MSKM_JSSIS_SBT_CD, (String) dataMap.get("mskm_jssis_sbt_cd"));
		}

		// 申込内容承認登録マップ.お客様ご要望事項 → お客様ご要望事項
		if ((String)dataMap.get("cust_yobo_jiko") == null ||"".equals(dataMap.get("cust_yobo_jiko"))) {
			template.setNull(EKK0011D020CBSMsg.CUST_YOBO_JIKO);
		} else {
			template.set(EKK0011D020CBSMsg.CUST_YOBO_JIKO, (String) dataMap.get("cust_yobo_jiko"));
		}

		// 申込内容承認登録マップ.電話連絡希望時間帯コード → 電話連絡希望時間帯コード
		if ((String)dataMap.get("tel_rrk_kibo_time_cd") == null ||"".equals(dataMap.get("tel_rrk_kibo_time_cd"))) {
			template.setNull(EKK0011D020CBSMsg.TEL_RRK_KIBO_TIME_CD);
		} else {
			template.set(EKK0011D020CBSMsg.TEL_RRK_KIBO_TIME_CD, (String) dataMap.get("tel_rrk_kibo_time_cd"));
		}

		// 申込内容承認登録マップ.宅内調査希望時間帯コード → 宅内調査希望時間帯コード
		if ((String)dataMap.get("takcho_kibo_time_cd") == null ||"".equals(dataMap.get("takcho_kibo_time_cd"))) {
			template.setNull(EKK0011D020CBSMsg.TAKCHO_KIBO_TIME_CD);
		} else {
			template.set(EKK0011D020CBSMsg.TAKCHO_KIBO_TIME_CD, (String) dataMap.get("takcho_kibo_time_cd"));
		}

		// 申込内容承認登録マップ.仮申込フラグ → 仮申込フラグ
		if ((String)dataMap.get("kari_mskm_flg") == null ||"".equals(dataMap.get("kari_mskm_flg"))) {
			template.setNull(EKK0011D020CBSMsg.KARI_MSKM_FLG);
		} else {
			template.set(EKK0011D020CBSMsg.KARI_MSKM_FLG, (String) dataMap.get("kari_mskm_flg"));
		}

		// 申込内容承認登録マップ.リファラー → リファラー
		if ((String)dataMap.get("referer") == null ||"".equals(dataMap.get("referer"))) {
			template.setNull(EKK0011D020CBSMsg.REFERER);
		} else {
			template.set(EKK0011D020CBSMsg.REFERER, (String) dataMap.get("referer"));
		}

		// 申込内容承認登録マップ.関西電力お客様情報授受同意有無 → 関西電力お客様情報授受同意有無
		if ((String)dataMap.get("kepco_custinfo_juju_doi_um") == null ||"".equals(dataMap.get("kepco_custinfo_juju_doi_um"))) {
			template.setNull(EKK0011D020CBSMsg.KEPCO_CUSTINFO_JUJU_DOI_UM);
		} else {
			template.set(EKK0011D020CBSMsg.KEPCO_CUSTINFO_JUJU_DOI_UM, (String) dataMap.get("kepco_custinfo_juju_doi_um"));
		}

		// 申込内容承認登録マップ.コンシューマ営業用申込状態識別コード → コンシューマ営業用申込状態識別コード
		if ((String)dataMap.get("consmbsn_mskm_stat_skbt_cd") == null ||"".equals(dataMap.get("consmbsn_mskm_stat_skbt_cd"))) {
			template.setNull(EKK0011D020CBSMsg.CONSMBSN_MSKM_STAT_SKBT_CD);
		} else {
			template.set(EKK0011D020CBSMsg.CONSMBSN_MSKM_STAT_SKBT_CD, (String) dataMap.get("consmbsn_mskm_stat_skbt_cd"));
		}
		
		template.setNull(EKK0011D020CBSMsg.TAKCHO_KIBOD_SBT_CD);
		template.setNull(EKK0011D020CBSMsg.TEL_RRK_KIBOD_SBT_CD);
		template.setNull(EKK0011D020CBSMsg.SHOSA_BF_RRK_JIKO_YH);
		template.setNull(EKK0011D020CBSMsg.SHOSA_BF_RRK_JIKO);
		template.setNull(EKK0011D020CBSMsg.USE_SVC_KEIZK_SBT_CD);
		template.setNull(EKK0011D020CBSMsg.KOJI_REQ_INFO_RRK_JIKO);
		template.setNull(EKK0011D020CBSMsg.UK_TNTSHA_SKBT_CD);
		template.setNull(EKK0011D020CBSMsg.MSKM_ROUTE_SKBT_CD);


		inList = (ArrayList)dataMap.get("EKK0011D020CBSMsg1List");
		if (inList == null) {
			templateArray = new CAANMsg[1];
			templateArray[0] = new CAANMsg(EKK0011D020CBSMsg1List.class.getName());
			
			// 申込書番号
			templateArray[0].setNull(EKK0011D020CBSMsg1List.MSKMSHO_NO);
			// WEB受付番号
			templateArray[0].setNull(EKK0011D020CBSMsg1List.WEB_UK_NO);
			// 申込形態コード
			templateArray[0].setNull(EKK0011D020CBSMsg1List.MSKM_FORM_CD);
			// 申込明細種別コード
			templateArray[0].setNull(EKK0011D020CBSMsg1List.MSKM_DTL_SBT_CD);
			// 連絡先携帯電話番号
			templateArray[0].setNull(EKK0011D020CBSMsg1List.RRKS_KTAI_TELNO);
			// 連絡先勤務先名
			templateArray[0].setNull(EKK0011D020CBSMsg1List.RRKS_OFFC_NM);
			// 昼間連絡先電話番号
			templateArray[0].setNull(EKK0011D020CBSMsg1List.DT_RRKS_TELNO);
			// 新規申込種別コード
			templateArray[0].setNull(EKK0011D020CBSMsg1List.NEW_MSKM_SBT_CD);
			// 申込契機コード
			templateArray[0].setNull(EKK0011D020CBSMsg1List.MSKM_OPTNTY_CD);
			// 宅内調査希望アポ期限年月日
			templateArray[0].setNull(EKK0011D020CBSMsg1List.TAKCHO_KIBO_APO_KIGEN_YMD);
			// 	工事アポ連絡先指定コード
			templateArray[0].setNull(EKK0011D020CBSMsg1List.KOJI_APO_RRKS_SHITEI_CD);
			// 工事アポ連絡先電話番号
			templateArray[0].setNull(EKK0011D020CBSMsg1List.KOJI_APO_RRKS_TELNO);
			// 連絡事項登録年月日時分秒
			templateArray[0].setNull(EKK0011D020CBSMsg1List.RRK_JIKO_ADD_DTM);
			// 申込連絡先メールアドレス
			templateArray[0].setNull(EKK0011D020CBSMsg1List.MSKM_RRKS_MLAD);
			// 工事進捗通知メールアドレス
			templateArray[0].setNull(EKK0011D020CBSMsg1List.KOJI_PRG_TCHI_MLAD);
			// 連絡事項
			templateArray[0].setNull(EKK0011D020CBSMsg1List.RRK_JIKO);
			// 工事進捗通知携帯メールアドレス
			templateArray[0].setNull(EKK0011D020CBSMsg1List.KJSC_TCH_KTAI_MLAD);
			// メール送信除外フラグ
			templateArray[0].setNull(EKK0011D020CBSMsg1List.ML_SEND_JGI_FLG);
			// メール送信除外理由メモ
			templateArray[0].setNull(EKK0011D020CBSMsg1List.ML_SEND_JGI_RSN_MEMO);
			// 番ポ申込連絡先電話番号
			templateArray[0].setNull(EKK0011D020CBSMsg1List.BMP_MSKM_RRKS_TLN);
			// 連絡手段補記
			templateArray[0].setNull(EKK0011D020CBSMsg1List.RRK_WAY_HOKI);
			// 新築物件コード
			templateArray[0].setNull(EKK0011D020CBSMsg1List.NEWCONST_BUKKEN_CD);
			// 復活案件フラグ
			templateArray[0].setNull(EKK0011D020CBSMsg1List.HUKKAT_ANKEN_FLG);
			// 同一設備再申込コード
			templateArray[0].setNull(EKK0011D020CBSMsg1List.SAME_EQUIP_RE_MSKM_CD);
			
			templateArray[0].setNull(EKK0011D020CBSMsg1List.OP_SVC_HKTGI_UM);
			templateArray[0].setNull(EKK0011D020CBSMsg1List.MSKMSHO_SBT_CD);
			templateArray[0].setNull(EKK0011D020CBSMsg1List.DSL_ATICLE_SOHU_KIBO_UM);
			templateArray[0].setNull(EKK0011D020CBSMsg1List.MAP_TEMP_UM);
			templateArray[0].setNull(EKK0011D020CBSMsg1List.KCN_STB_KIND_CD);
			templateArray[0].setNull(EKK0011D020CBSMsg1List.KCN_STB_MSKM_CNT);
			templateArray[0].setNull(EKK0011D020CBSMsg1List.HNIN_CFM_ATICLE_SBT_CD);
			
			// 契約付加コード
			templateArray[0].setNull(EKK0011D020CBSMsg1List.KEI_HUKA_CD);
			// マンション設備システム連携用記事欄
			templateArray[0].setNull(EKK0011D020CBSMsg1List.MANSSBSYS_RNKI_YO_KIJIRAN);
			// マンションID
			templateArray[0].setNull(EKK0011D020CBSMsg1List.MANSION_ID);
			// CAT-ID
			templateArray[0].setNull(EKK0011D020CBSMsg1List.CATID);
			// 申込受付種別コード
			templateArray[0].setNull(EKK0011D020CBSMsg1List.MKM_UK_SBT_CD);
			// 申込書取扱情報担当者名
			templateArray[0].setNull(EKK0011D020CBSMsg1List.MSKMSHO_TRAT_IF_TNTSHA_NM);
			// 申込書取扱情報電話番号
			templateArray[0].setNull(EKK0011D020CBSMsg1List.MSKMSHO_TRAT_IF_TELNO);
			
			template.set(EKK0011D020CBSMsg.EKK0011D020CBSMSG1LIST, templateArray);
			
		}
		
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @return 業務データ取得・書込用I/F
	 * @since 2011.11.25
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editOutMsg_EKK0011D020(Map<?, ?> msgList,
			IRequestParameterReadWrite param,
			Map<String, Object> dataMap,
			HashMap<String, Object> childMap) throws Exception {

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = (Map)param.getMappingWorkArea();
		if (workMap == null) {
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// 結果を詰めるマップを取得。
//		HashMap dataMap = null;// WORK取得できない場合定義
		ArrayList dataList = null;

		
		
		// 申込内容承認登録マップ.申込番号 ← 申込番号
		if (parentTemplate.isNull(EKK0011D020CBSMsg.MSKM_NO)) {
			dataMap.put("mskm_no", new String());
		} else {
			dataMap.put("mskm_no", parentTemplate.getString(EKK0011D020CBSMsg.MSKM_NO));
		}
		// 申込内容承認登録マップ.更新年月日時分秒 ← 更新年月日時分秒
		if (parentTemplate.isNull(EKK0011D020CBSMsg.UPD_DTM)) {
			dataMap.put("upd_dtm", new String());
		} else {
			dataMap.put("upd_dtm", parentTemplate.getString(EKK0011D020CBSMsg.UPD_DTM));
		}
		
		
		/* 業務データ設定 */
		HashMap workDataMap = (HashMap)workMap.get("KKSV079901CCWORK");
		if (workDataMap == null) {
			workDataMap = new HashMap();
			workMap.put("KKSV079901CCWORK", workDataMap);
		}
		templateArray = parentTemplate.getCAANMsgList(EKK0011D020CBSMsg.EKK0011D020CBSMSG1LIST);
		dataList = (ArrayList)workDataMap.get("KKSV079901CCWORKLIST");
		  
		if (dataList == null) {
			dataList = new ArrayList();
		}

		if (templateArray != null) {
			for (int i = 0; i < templateArray.length; i++) {
				CAANMsg childTemplate = templateArray[i];
				if ( i >= dataList.size()) {
					dataList.add(new HashMap());
				}
				HashMap resultMap = (HashMap)dataList.get(i);
				
				// 申込内容承認登録マップ.申込登録明細.申込明細番号 ← 申込登録明細.申込明細番号
				if (childTemplate.isNull(EKK0011D020CBSMsg1List.MSKM_DTL_NO)) {
					resultMap.put("mskm_dtl_no", new String());
					dataMap.put("mskm_dtl_no_out", new String());
				} else {
					resultMap.put("mskm_dtl_no", childTemplate.getString(EKK0011D020CBSMsg1List.MSKM_DTL_NO));
					dataMap.put("mskm_dtl_no_out", childTemplate.getString(EKK0011D020CBSMsg1List.MSKM_DTL_NO));
				}
				break;
			}
		}

		workDataMap.put("KKSV079901CCWORKLIST", dataList);

		
		// エラー情報の設定
        param = editErrorInfo_EKK0011D020(param, dataMap, templates, (Integer)return_code, childMap);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
        
		
		return param;
	}
	
	/**
	 * 申込内容承認登録エラー処理メソッド
	 * @param param
	 * @param inMap
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0011D020(IRequestParameterReadWrite param, 
																	Map<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode,
																	HashMap<String, Object> childMap) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0011D020CBSMsg.STATUS);
		if(returnCode != 0)
		{
			templateStatus = 9000;
		}

		if(JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if(templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		// SYSID
		setErrDataMap(childMap, template, EKK0011D020CBSMsg.SYSID_ERR);
		// 申込種別コード
		setErrDataMap(childMap, template, EKK0011D020CBSMsg.MSKM_SBT_CD_ERR);
		// 申込受付年月日時分秒
		setErrDataMap(childMap, template, EKK0011D020CBSMsg.MSKM_UK_DTM_ERR);
		// 申込年月日
		setErrDataMap(childMap, template, EKK0011D020CBSMsg.MSKM_YMD_ERR);
		// コンシューマ営業用申込状態識別コード
		setErrDataMap(childMap, template, EKK0011D020CBSMsg.CONSMBSN_MSKM_STAT_SKBT_CD_ERR);
		
		return param;
	}
	/**
	 * 申込明細照査・後続業務依頼処理
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param temporaryData
	 * @throws Throwable
	 */
	@SuppressWarnings("unchecked")
	private void execEKK0021C060(SessionHandle handle, 
									ServiceComponentRequestInvoker scCall, 
									IRequestParameterReadWrite param, 
									String dataMapKey,
									Map<String, Object> dataMap,
									HashMap<String, Object> childMap,
									String tekiyoYmd) throws Exception
	{
		HashMap<String, Object> ccMsg = (HashMap<String, Object>)param.getData(dataMapKey);
		
		Map<Object, Object> workMap = param.getMappingWorkArea();
		String upd_dtm_bf = (String)dataMap.get(EKK0011D020CBSMsg.UPD_DTM);
		
		HashMap<String,ArrayList> map = (HashMap<String,ArrayList>)workMap.get("KKSV079901CCWORK");
		
		String msk_dtl_no = "";
		if(map == null)
		{
			msk_dtl_no = null;
		}
		else
		{
			ArrayList<HashMap<String,String>> workList = (ArrayList<HashMap<String,String>>)map.get("KKSV079901CCWORKLIST");
			if(workList != null && workList.size() != 0){
				
				HashMap reMap = (HashMap)workList.get(0);
				String meisai = (String)reMap.get("mskm_dtl_no");
				
				
				// 作業項目.申込明細番号 → 申込明細番号
				if (meisai == null || "".equals(meisai)) {
					msk_dtl_no = null;
				} else {
					msk_dtl_no = meisai;
				}
			}else{
				msk_dtl_no = null;
			}
		}
		
		// ***** EKK0021C060（申込明細照査・後続業務依頼）*****
		Object[][] ekk0021c060IN = {
				{EKK0021C060CBSMsg.TEMPLATEID,      TEMPLATE_ID_EKK0021C060},
				{EKK0021C060CBSMsg.FUNC_CODE,       ccMsg.get("func_code")},
				{EKK0021C060CBSMsg.KZKWRK_REQYMD,   tekiyoYmd},
				{EKK0021C060CBSMsg.MSKM_DTL_NO,     msk_dtl_no},
				{EKK0021C060CBSMsg.IDO_DIV,         ccMsg.get("ido_div")},
				{EKK0021C060CBSMsg.UPD_DTM_BF,      upd_dtm_bf}
		};
		// S-I/F 実行
		callSC(handle, scCall, param, dataMapKey, ekk0021c060IN);
		
	}
	
	/**
	 * 請求オプションサービス契約登録サービスを実行し値を取得します。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param scCall 
	 * @param dataMap リクエストデータ
	 * @throws Exception 
	 */
	private void execEKK0441D020(SessionHandle handle,
									IRequestParameterReadWrite param,
									ServiceComponentRequestInvoker scCall,
									Map<String, Object> dataMap,
									HashMap<String, Object> childMap) throws Exception
	{
		// ◇ 上りマッピング処理
		// リクエストパラメータを引数に上りマッピング処理メソッドを実行
		HashMap<String, Object> paramMap = editInMsg_EKK0441D020(param, dataMap, childMap);
		
		// ◇ SC呼出実行 (請求オプションサービス契約登録)
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// ◇ 下りマッピング処理
		editOutMsg_EKK0441D020(result, param, dataMap, childMap);
		
		//処理結果判定
		jdgErrRslt(result, 0);
	}
	
	/**
	 * 請求オプションサービス契約登録のメッセージを作成します。
	 * 
	 * @param param
	 * @param inMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> editInMsg_EKK0441D020(IRequestParameterReadWrite param,
																Map<String, Object> dataMap,
																HashMap<String, Object> childMap) throws RequestParameterException
	{
		
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

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

		// テンプレートID
		template.set(EKK0441D020CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0441D020);

		template.set(EKK0441D020CBSMsg.FUNC_CODE, "1");

		// オペレータ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);

		
		// 作業領域の取得
		Map<Object, Object> workMap = param.getMappingWorkArea();
		
		HashMap<String,ArrayList> map = (HashMap<String,ArrayList>)workMap.get("KKSV079901CCWORK");
		
		if(map == null)
		{
			template.setNull(EKK1091D010CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			ArrayList<HashMap<String,String>> workList = (ArrayList<HashMap<String,String>>)map.get("KKSV079901CCWORKLIST");
			if(workList != null && workList.size() != 0){
				
				HashMap reMap = (HashMap)workList.get(0);
				String meisai = (String)reMap.get("mskm_dtl_no");
				
				
				// 作業項目.申込明細番号 → 申込明細番号
				if (meisai == null || "".equals(meisai)) {
					template.setNull(EKK0441D020CBSMsg.MSKM_DTL_NO);
				} else {
					template.set(EKK0441D020CBSMsg.MSKM_DTL_NO, meisai);
				}
			}else{
				template.setNull(EKK0441D020CBSMsg.MSKM_DTL_NO);
			}
		}
		
		// 機能コード
		template.set(EKK0441D020CBSMsg.FUNC_CODE, dataMap.get(JCMConstants.FUNC_CODE_KEY));
		
		
		// 更新年月日時分秒 → 更新年月日時分秒（更新前）
		if ((String)dataMap.get("EKK0491A010_seikyu_upd_dtm") == null || !dataMap.containsKey("EKK0491A010_seikyu_upd_dtm")) 
		{
			template.setNull(EKK0441D020CBSMsg.UPD_DTM_BF);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.UPD_DTM_BF, (String)dataMap.get("EKK0491A010_seikyu_upd_dtm"));
		}
		
		// 請求オプションサービス契約登録マップ.請求契約番号 → 請求契約番号
		if ((String)dataMap.get("seiky_kei_no") == null || "".equals(dataMap.get("seiky_kei_no"))) 
		{
			template.setNull(EKK0441D020CBSMsg.SEIKY_KEI_NO);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.SEIKY_KEI_NO, (String)dataMap.get("seiky_kei_no"));
		}

		if ((String)dataMap.get("sysid") == null || "".equals(dataMap.get("sysid"))) 
		{
			template.setNull(EKK0441D020CBSMsg.SYSID);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.SYSID, (String)dataMap.get("sysid"));
		}

		// 請求オプションサービス契約登録マップ.請求オプションサービスコード → 請求オプションサービスコード
		if ((String)dataMap.get("seiopsvc_cd") == null || "".equals(dataMap.get("seiopsvc_cd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.SEIOPSVC_CD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.SEIOPSVC_CD, (String)dataMap.get("seiopsvc_cd"));
		}

		// 請求オプションサービス契約登録マップ.料金コースコード → 料金コースコード
		if ((String)dataMap.get("pcrs_cd") == null || "".equals(dataMap.get("pcrs_cd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.PCRS_CD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.PCRS_CD, (String)dataMap.get("pcrs_cd"));
		}

		// 請求オプションサービス契約登録マップ.料金プランコード → 料金プランコード
		if ((String)dataMap.get("pplan_cd") == null || "".equals(dataMap.get("pplan_cd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.PPLAN_CD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.PPLAN_CD, (String)dataMap.get("pplan_cd"));
		}
		// 請求オプションサービス契約登録マップ.料金サービス利用開始希望年月日 → 料金サービス利用開始希望年月日
		if ((String)dataMap.get("seiopsvc_use_sta_kibo_ymd") == null || "".equals(dataMap.get("seiopsvc_use_sta_kibo_ymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.SVC_USE_STA_KIBO_YMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.SVC_USE_STA_KIBO_YMD, (String)dataMap.get("seiopsvc_use_sta_kibo_ymd"));
		}

		// 請求オプションサービス契約登録マップ.サービス契約番号 → サービス契約番号
		if ((String)dataMap.get("svc_kei_no") == null || "".equals(dataMap.get("svc_kei_no"))) 
		{
			template.setNull(EKK0441D020CBSMsg.SVC_KEI_NO);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.SVC_KEI_NO, (String)dataMap.get("svc_kei_no"));
		}

		// 請求オプションサービス契約登録マップ.試用加入年月日 → 試用加入年月日
		if ((String)dataMap.get("ftrial_kanyu_ymd") == null || "".equals(dataMap.get("ftrial_kanyu_ymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.FTRIAL_KANYU_YMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.FTRIAL_KANYU_YMD, (String)dataMap.get("ftrial_kanyu_ymd"));
		}

		// 請求オプションサービス契約登録マップ.試用期間終了年月日 → 試用期間終了年月日
		if ((String)dataMap.get("ftrial_prd_endymd") == null || "".equals(dataMap.get("ftrial_prd_endymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.FTRIAL_PRD_ENDYMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.FTRIAL_PRD_ENDYMD, (String)dataMap.get("ftrial_prd_endymd"));
		}

		// 請求オプションサービス契約登録マップ.本加入年月日 → 本加入年月日
		if ((String)dataMap.get("honkanyu_ymd") == null || "".equals(dataMap.get("honkanyu_ymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.HONKANYU_YMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.HONKANYU_YMD, (String)dataMap.get("honkanyu_ymd"));
		}

		// 請求オプションサービス契約登録マップ.本加入移行期限年月日 → 本加入移行期限年月日
		if ((String)dataMap.get("honkanyu_iko_kigen_ymd") == null || "".equals(dataMap.get("honkanyu_iko_kigen_ymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.HONKANYU_IKO_KIGEN_YMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.HONKANYU_IKO_KIGEN_YMD, (String)dataMap.get("honkanyu_iko_kigen_ymd"));
		}

		// 請求オプションサービス契約登録マップ.予約適用開始希望年月日 → 予約適用開始希望年月日
		if ((String)dataMap.get("rsv_tsta_kibo_ymd") == null || "".equals(dataMap.get("rsv_tsta_kibo_ymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.RSV_TSTA_KIBO_YMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.RSV_TSTA_KIBO_YMD, (String)dataMap.get("rsv_tsta_kibo_ymd"));
		}

		// 請求オプションサービス契約登録マップ.照査年月日 → 照査年月日
		if ((String)dataMap.get("shosa_ymd") == null || "".equals(dataMap.get("shosa_ymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.SHOSA_YMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.SHOSA_YMD, (String)dataMap.get("shosa_ymd"));
		}

		// 請求オプションサービス契約登録マップ.契約締結年月日 → 契約締結年月日
		if ((String)dataMap.get("kei_cnc_ymd") == null || "".equals(dataMap.get("kei_cnc_ymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.KEI_CNC_YMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.KEI_CNC_YMD, (String)dataMap.get("kei_cnc_ymd"));
		}

		// 請求オプションサービス契約登録マップ.予約適用年月日 → 予約適用年月日
		if ((String)dataMap.get("rsv_aply_ymd") == null || "".equals(dataMap.get("rsv_aply_ymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.RSV_APLY_YMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.RSV_APLY_YMD, (String)dataMap.get("rsv_aply_ymd"));
		}

		// 請求オプションサービス契約登録マップ.予約適用コード → 予約適用コード
		if ((String)dataMap.get("rsv_aply_cd") == null || "".equals(dataMap.get("rsv_aply_cd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.RSV_APLY_YMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.RSV_APLY_YMD, (String)dataMap.get("rsv_aply_cd"));
		}

		// 請求オプションサービス契約登録マップ.プラン開始年月日 → プラン開始年月日
		if ((String)dataMap.get("plan_staymd") == null || "".equals(dataMap.get("plan_staymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.PLAN_STAYMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.PLAN_STAYMD, (String)dataMap.get("plan_staymd"));
		}

		// 請求オプションサービス契約登録マップ.プラン終了年月日 → プラン終了年月日
		if ((String)dataMap.get("plan_endymd") == null || "".equals(dataMap.get("plan_endymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.PLAN_ENDYMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.PLAN_ENDYMD, (String)dataMap.get("plan_endymd"));
		}

		// 請求オプションサービス契約登録マップ.プラン課金開始年月日 → プラン課金開始年月日
		if ((String)dataMap.get("plan_chrg_staymd") == null || "".equals(dataMap.get("plan_chrg_staymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.PLAN_CHRG_STAYMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.PLAN_CHRG_STAYMD, (String)dataMap.get("plan_chrg_staymd"));
		}

		// 請求オプションサービス契約登録マップ.プラン課金終了年月日 → プラン課金終了年月日
		if ((String)dataMap.get("plan_chrg_endymd") == null || "".equals(dataMap.get("plan_chrg_endymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.PLAN_CHRG_ENDYMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.PLAN_CHRG_ENDYMD, (String)dataMap.get("plan_chrg_endymd"));
		}

		// 請求オプションサービス契約登録マップ.サービス開始年月日 → サービス開始年月日
		if ((String)dataMap.get("svc_sta_ymd") == null || "".equals(dataMap.get("svc_sta_ymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.SVC_STA_YMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.SVC_STA_YMD, (String)dataMap.get("svc_sta_ymd"));
		}

		// 請求オプションサービス契約登録マップ.サービス終了年月日 → サービス終了年月日
		if ((String)dataMap.get("svc_endymd") == null || "".equals(dataMap.get("svc_endymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.SVC_ENDYMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.SVC_ENDYMD, (String)dataMap.get("svc_endymd"));
		}

		// 請求オプションサービス契約登録マップ.サービス課金開始年月日 → サービス課金開始年月日
		if ((String)dataMap.get("svc_chrg_staymd") == null || "".equals(dataMap.get("svc_chrg_staymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.SVC_CHRG_STAYMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.SVC_CHRG_STAYMD, (String)dataMap.get("svc_chrg_staymd"));
		}

		// 請求オプションサービス契約登録マップ.サービス課金終了年月日 → サービス課金終了年月日
		if ((String)dataMap.get("svc_chrg_endymd") == null || "".equals(dataMap.get("svc_chrg_endymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.SVC_CHRG_ENDYMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.SVC_CHRG_ENDYMD, (String)dataMap.get("svc_chrg_endymd"));
		}

		// 請求オプションサービス契約登録マップ.異動区分 → 異動区分
		if ((String)dataMap.get("ido_div") == null || "".equals(dataMap.get("ido_div"))) 
		{
			template.setNull(EKK0441D020CBSMsg.IDO_DIV);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.IDO_DIV, (String)dataMap.get("ido_div"));
		}

		// 請求オプションサービス契約登録マップ.料金項目コード → 料金項目コード
		if ((String)dataMap.get("prc_kmk_cd") == null || "".equals(dataMap.get("prc_kmk_cd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.PRC_KMK_CD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.PRC_KMK_CD, (String)dataMap.get("prc_kmk_cd"));
		}
		
		// 請求オプションサービス契約登録マップ.NHK団体一括支払サイクルコード
		if ((String)dataMap.get("nhk_grp_ikt_pay_cycle_cd") == null || "".equals(dataMap.get("nhk_grp_ikt_pay_cycle_cd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.NHK_GRP_IKT_PAY_CYCLE_CD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.NHK_GRP_IKT_PAY_CYCLE_CD, (String)dataMap.get("nhk_grp_ikt_pay_cycle_cd"));
		}
		
		// 請求オプションサービス契約登録マップ.NHK団体一括契約初回請求年月日
		if ((String)dataMap.get("nhk_dntiktkei_first_seiymd") == null || "".equals(dataMap.get("nhk_dntiktkei_first_seiymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.NHK_DNTIKTKEI_FIRST_SEIYMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.NHK_DNTIKTKEI_FIRST_SEIYMD, (String)dataMap.get("nhk_dntiktkei_first_seiymd"));
		}
		
		// 請求オプションサービス契約登録マップ.NHKお客様番号
		if ((String)dataMap.get("nhk_cust_no") == null || "".equals(dataMap.get("nhk_cust_no"))) 
		{
			template.setNull(EKK0441D020CBSMsg.NHK_CUST_NO);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.NHK_CUST_NO, (String)dataMap.get("nhk_cust_no"));
		}
		
		// 請求オプションサービス契約登録マップ.NHK団体一括契約NHK締結年月日
		if ((String)dataMap.get("nhk_dntiktkei_nhk_cnc_ymd") == null || "".equals(dataMap.get("nhk_dntiktkei_nhk_cnc_ymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.NHK_DNTIKTKEI_NHK_CNC_YMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.NHK_DNTIKTKEI_NHK_CNC_YMD, (String)dataMap.get("nhk_dntiktkei_nhk_cnc_ymd"));
		}
		
		// 請求オプションサービス契約登録マップ.NHK団体一括契約変更届年月日
		if ((String)dataMap.get("nhk_dntiktkei_hktdk_ymd") == null || "".equals(dataMap.get("nhk_dntiktkei_hktdk_ymd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.NHK_DNTIKTKEI_HKTDK_YMD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.NHK_DNTIKTKEI_HKTDK_YMD, (String)dataMap.get("nhk_dntiktkei_hktdk_ymd"));
		}
		
		// 請求オプションサービス契約登録マップ.NHK団体一括契約変更理由メモ
		if ((String)dataMap.get("nhk_dntiktkei_chrge_memo") == null || "".equals(dataMap.get("nhk_dntiktkei_chrge_memo"))) 
		{
			template.setNull(EKK0441D020CBSMsg.NHK_DNTIKTKEI_CHGRE_MEMO);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.NHK_DNTIKTKEI_CHGRE_MEMO, (String)dataMap.get("nhk_dntiktkei_chrge_memo"));
		}
		
		// 請求オプションサービス契約登録マップ.NHK団体一括契約登録メモ
		if ((String)dataMap.get("nhk_dntiktkei_add_memo") == null || "".equals(dataMap.get("nhk_dntiktkei_add_memo"))) 
		{
			template.setNull(EKK0441D020CBSMsg.NHK_DNTIKTKEI_ADD_MEMO);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.NHK_DNTIKTKEI_ADD_MEMO, (String)dataMap.get("nhk_dntiktkei_add_memo"));
		}
		
		// 請求オプションサービス契約登録マップ.NHK外部連携契約コード
		if ((String)dataMap.get("nhk_out_rnki_kei_cd") == null || "".equals(dataMap.get("nhk_out_rnki_kei_cd"))) 
		{
			template.setNull(EKK0441D020CBSMsg.NHK_OUT_RNKI_KEI_CD);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.NHK_OUT_RNKI_KEI_CD, (String)dataMap.get("nhk_out_rnki_kei_cd"));
		}
		
		// 請求オプションサービス契約登録マップ.NHK団体一括契約住所メモ
		if ((String)dataMap.get("nhk_dntiktkei_ad_memo") == null || "".equals(dataMap.get("nhk_dntiktkei_ad_memo"))) 
		{
			template.setNull(EKK0441D020CBSMsg.NHK_DNTIKTKEI_AD_MEMO);
		} 
		else 
		{
			template.set(EKK0441D020CBSMsg.NHK_DNTIKTKEI_AD_MEMO, (String)dataMap.get("nhk_dntiktkei_ad_memo"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @return 業務データ取得・書込用I/F
	 * @since 2012.06.04
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editOutMsg_EKK0441D020(Map<?, ?> msgList,
			IRequestParameterReadWrite param,
			Map<String, Object> dataMap,
			HashMap<String, Object> childMap) throws Exception {

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = (Map)param.getMappingWorkArea();
		if (workMap == null) {
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// 請求オプションサービス契約番号WORK(EKK0441D020) ← 請求オプションサービス契約番号
		if (parentTemplate.isNull(EKK0441D020CBSMsg.SEIOPSVC_KEI_NO)) 
		{
			childMap.put("EKK0441D020_seiopsvc_kei_no", new String());
		} 
		else 
		{
			childMap.put("EKK0441D020_seiopsvc_kei_no", parentTemplate.getString(EKK0441D020CBSMsg.SEIOPSVC_KEI_NO));
		}
		// 世代登録年月日時分秒WORK(EKK0441D020) ← 世代登録年月日時分秒
		if (parentTemplate.isNull(EKK0441D020CBSMsg.GENE_ADD_DTM)) 
		{
			childMap.put("out_opt_gene_add_dtm", new String());
		} 
		else 
		{
			childMap.put("out_opt_gene_add_dtm", parentTemplate.getString(EKK0441D020CBSMsg.GENE_ADD_DTM));
		}
		// 予約適用コードWORK(EKK0441D020) ← 予約適用コード
		if (parentTemplate.isNull(EKK0441D020CBSMsg.RSV_APLY_CD)) 
		{
			childMap.put("EKK0441D020_rsv_aply_cd", new String());
		} 
		else 
		{
			childMap.put("EKK0441D020_rsv_aply_cd", parentTemplate.getString(EKK0441D020CBSMsg.RSV_APLY_CD));
		}
		// 更新年月日時分秒WORK(EKK0441D020) ← 更新年月日時分秒
		if (parentTemplate.isNull(EKK0441D020CBSMsg.UPD_DTM)) 
		{
			childMap.put("EKK0441D020_upd_dtm", new String());
		} 
		else 
		{
			childMap.put("EKK0441D020_upd_dtm", parentTemplate.getString(EKK0441D020CBSMsg.UPD_DTM));
		}
		
		// 登録／変更区分(ＮＨＫ請求オプション登録CC) ← "01"「登録」
		childMap.put("wrisvcautoaplycc_add_chge_div", "01");
		// 請求オプションサービス契約ステータス(ＮＨＫ請求オプション登録CC) ← 請求オプションサービス契約ステータス
		if (parentTemplate.isNull(EKK0441D020CBSMsg.SEIOPSVC_KEI_STAT)) 
		{
			childMap.put("wrisvcautoaplycc_seiopsvc_kei_stat", new String());
		} 
		else 
		{
			childMap.put("wrisvcautoaplycc_seiopsvc_kei_stat", parentTemplate.getString(EKK0441D020CBSMsg.SEIOPSVC_KEI_STAT));
		}
		
		// エラー情報の設定
		param = editErrorInfo_EKK0441D020(param, dataMap, templates, (Integer)return_code, childMap);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	/**
	 * 請求オプションサービス契約登録エラー処理メソッド
	 * @param param
	 * @param inMap
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0441D020(IRequestParameterReadWrite param, 
																	Map<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode,
																	HashMap<String, Object> childMap) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0441D020CBSMsg.STATUS);
		if(returnCode != 0)
		{
			templateStatus = 9000;
		}

		if(JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if(templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		// 請求契約番号
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.SEIKY_KEI_NO_ERR);
		// SYSID
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.SYSID_ERR);
		// 申込明細番号
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.MSKM_DTL_NO_ERR);
		// サービス契約番号
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.SVC_KEI_NO_ERR);
		// 試用加入年月日
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.FTRIAL_KANYU_YMD_ERR);
		// 試用期間終了年月日
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.FTRIAL_PRD_ENDYMD_ERR);
		// 本加入年月日
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.HONKANYU_YMD_ERR);
		// 本加入移行期限年月日
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.HONKANYU_IKO_KIGEN_YMD_ERR);
		// サービス利用開始希望年月日
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.SVC_USE_STA_KIBO_YMD_ERR);
		// 予約適用開始希望年月日
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.RSV_TSTA_KIBO_YMD_ERR);
		// 違約金発生コード
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.PNLTY_HASSEI_CD_ERR);
		// 異動区分
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.IDO_DIV_ERR);
		// 料金項目コード
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.PRC_KMK_CD_ERR);
		// NHK団体一括支払サイクルコード
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.NHK_GRP_IKT_PAY_CYCLE_CD_ERR);
		// NHK団体一括契約初回請求年月日
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.NHK_DNTIKTKEI_FIRST_SEIYMD_ERR);
		// NHKお客様番号
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.NHK_CUST_NO_ERR);
		// NHK団体一括契約NHK締結年月日
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.NHK_DNTIKTKEI_NHK_CNC_YMD_ERR);
		// NHK団体一括契約変更届年月日
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.NHK_CUST_NO_ERR);
		// NHK団体一括契約変更理由メモ
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.NHK_DNTIKTKEI_CHGRE_MEMO_ERR);
		// NHK団体一括契約登録メモ
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.NHK_DNTIKTKEI_ADD_MEMO_ERR);
		// NHK外部連携契約コード
		setErrDataMap(childMap, template, EKK0441D020CBSMsg.NHK_OUT_RNKI_KEI_CD_ERR);
		// NHK団体一括契約住所メモ
		setErrDataMap(childMap, template, EKK0441C330CBSMsg.NHK_DNTIKTKEI_AD_MEMO_ERR);		
		return param;
	}
	
	/**
	 * 課金先一覧照会（請求契約番号/サービス契約番号）を実行し値を取得します。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param scCall 
	 * @param dataMap リクエストデータ
	 * @param ptn
	 * @throws Exception 
	 */
	private CAANMsg[] execEKK0321B002(SessionHandle handle,
									IRequestParameterReadWrite param,
									ServiceComponentRequestInvoker scCall,
									Map<String, Object> dataMap,
									HashMap<String, Object> childMap) throws Exception
	{
		CAANMsg[] templateArray = null;
		// ◇ 上りマッピング処理
		// リクエストパラメータを引数に上りマッピング処理メソッドを実行
		HashMap<String, Object> paramMap = editInMsg_EKK0321B002(param, dataMap, childMap);
		
		// ◇ SC呼出実行 (サービス契約一意照会)
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		templateArray = editOutMsg_EKK0321B002(result, param, dataMap, childMap);
		
		//処理結果判定
		jdgErrRslt(result, 0);
		
		return templateArray;
	}
	
	/**
	 * 課金先一覧照会（請求契約番号/サービス契約番号）のメッセージを作成します。
	 * 
	 * @param param
	 * @param kakinsNo
	 * @param ptn
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsg_EKK0321B002(IRequestParameterReadWrite param,
															Map<String, Object> dateMap,
															HashMap<String, Object> childMap) throws RequestParameterException
	{
		
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

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

		// テンプレートID
		template.set(EKK0321B002CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0321B002);

		template.set(EKK0321B002CBSMsg.FUNC_CODE, "1");

		// オペレータ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);

		// ◇ 業務データの設定
		
		// ＫＥＹ＿請求契約番号
		if((String)dateMap.get("seiky_kei_no") == null || "".equals((String)childMap.get("seiky_kei_no")))
		{
			template.setNull(EKK0321B002CBSMsg.KEY_SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK0321B002CBSMsg.KEY_SEIKY_KEI_NO, (String)childMap.get("seiky_kei_no"));
		}
		// ＫＥＹ＿予約適用年月日
		if((String)dateMap.get("tekiyoYmd") == null || "".equals((String)dateMap.get("tekiyoYmd")))
		{
			template.setNull(EKK0321B002CBSMsg.KEY_RSV_APLY_YMD);
		}
		else
		{
			template.set(EKK0321B002CBSMsg.KEY_RSV_APLY_YMD, (String)dateMap.get("tekiyoYmd"));
		}
		

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

		return paramMap;
	}

	
	/**
	 * 課金先一覧照会（請求契約番号/サービス契約番号）検索結果格納メソッド
	 * 
	 * @param msgList 検索結果
	 * @param param リクエストパラメータ
	 * @param dataMap パラメータ
	 * @return CAANMsg[]
	 * @throws Exception
	 */
	private CAANMsg[] editOutMsg_EKK0441B003(Map<?, ?> msgList,
														IRequestParameterReadWrite param,
														Map<String, Object> dataMap,
														HashMap<String, Object> childMap) throws Exception
	
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		// 作業領域の取得
		Map<Object, Object> workMap = param.getMappingWorkArea();

		// 検索結果格納Map
		Map<String, Object> EKK0441B003Map = new HashMap<String, Object>();

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		CAANMsg[] templateArray = null;
		
		templateArray = template.getCAANMsgList(EKK0441B003CBSMsg.EKK0441B003CBSMSG1LIST);

		
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfo_EKK0441B003(param, dataMap, templates, (Integer)return_code);

		// エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		return templateArray;
	}
	
	
	/**
	 * 課金先一覧照会（請求契約番号/サービス契約番号）エラー処理メソッド
	 * @param param
	 * @param inMap
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0441B003(IRequestParameterReadWrite param, 
																	Map<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0441B003CBSMsg.STATUS);
		if(returnCode != 0)
		{
			templateStatus = 9000;
		}

		if(JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if(templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		// 予約適用年月日
		setErrDataMap(inMap, template, EKK0441B003CBSMsg.KEY_SYSID_ERR);
		
		return param;
	}
	
	/**
	 * 課金先一覧照会（請求契約番号/サービス契約番号）検索結果格納メソッド
	 * 
	 * @param msgList 検索結果
	 * @param param リクエストパラメータ
	 * @param dataMap パラメータ
	 * @return CAANMsg[]
	 * @throws Exception
	 */
	private CAANMsg[] editOutMsg_EKK0321B002(Map<?, ?> msgList,
														IRequestParameterReadWrite param,
														Map<String, Object> dataMap,
														HashMap<String, Object> childMap) throws Exception
	
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg template = templates[0];

		// 作業領域の取得
		Map<Object, Object> workMap = param.getMappingWorkArea();

		// 検索結果格納Map
		Map<String, Object> EKK0321B002Map = new HashMap<String, Object>();

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		CAANMsg[] templateArray = null;
		
		templateArray = template.getCAANMsgList(EKK0321B002CBSMsg.EKK0321B002CBSMSG1LIST);

		
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfo_EKK0321B002(param, dataMap, templates, (Integer)return_code);

		// エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)retParam.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}

		// コントロールマップに設定
		retParam.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		return templateArray;
	}
	
	
	/**
	 * 課金先一覧照会（請求契約番号/サービス契約番号）エラー処理メソッド
	 * @param param
	 * @param inMap
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0321B002(IRequestParameterReadWrite param, 
																	Map<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0321B002CBSMsg.STATUS);
		if(returnCode != 0)
		{
			templateStatus = 9000;
		}

		if(JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if(templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		// サービス契約番号
		setErrDataMap(inMap, template, EKK0321B002CBSMsg.KEY_SEIKY_KEI_NO_ERR);
		// 予約適用年月日
		setErrDataMap(inMap, template, EKK0321B002CBSMsg.KEY_RSV_APLY_YMD_ERR);
		
		return param;
	}
	
	/**
	 * 請求オプションサービス契約解約サービスを実行し値を取得します。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param scCall 
	 * @param dataMap リクエストデータ
	 * @throws Exception 
	 */
	private void execEKK0441C330(SessionHandle handle,
									IRequestParameterReadWrite param,
									ServiceComponentRequestInvoker scCall,
									Map<String, Object> dataMap,
									HashMap<String, Object> childMap,
									String seiopsvc_kei_no) throws Exception
	{
		
		// ◇ 上りマッピング処理
		// リクエストパラメータを引数に上りマッピング処理メソッドを実行
		HashMap<String, Object> paramMap = editInMsg_EKK0441C330(param, dataMap, childMap, seiopsvc_kei_no);
		
		// ◇ SC呼出実行 (請求オプションサービス契約解約)
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// ◇ 下りマッピング処理
		editOutMsg_EKK0441C330(result, param, dataMap, childMap);
		
		//処理結果判定
		jdgErrRslt(result, 0);
	}
	
	/**
	 * 請求オプションサービス契約解約のメッセージを作成します。
	 * 
	 * @param param
	 * @param inMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> editInMsg_EKK0441C330(IRequestParameterReadWrite param,
																Map<String, Object> dataMap,
																HashMap<String, Object> childMap,
																String seiopsvc_kei_no) throws RequestParameterException
	{
		
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);
		
		CAANMsg template = new CAANMsg(EKK0441C330CBSMsg.class.getName());
		
		// 作業領域の取得
		Map<Object, Object> workMap = param.getMappingWorkArea();
		
		HashMap<String,ArrayList> map = (HashMap<String,ArrayList>)workMap.get("KKSV079901CCWORK");
		
		if(map == null)
		{
			template.setNull(EKK1091D010CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			ArrayList<HashMap<String,String>> workList = (ArrayList<HashMap<String,String>>)map.get("KKSV079901CCWORKLIST");
			if(workList != null && workList.size() != 0){
				
				HashMap reMap = (HashMap)workList.get(0);
				String meisai = (String)reMap.get("mskm_dtl_no");
				
				
				// 作業項目.申込明細番号 → 申込明細番号
				if (meisai == null || "".equals(meisai)) {
					template.setNull(EKK0441C330CBSMsg.MSKM_DTL_NO);
				} else {
					template.set(EKK0441C330CBSMsg.MSKM_DTL_NO, meisai);
				}
			}else{
				template.setNull(EKK0441C330CBSMsg.MSKM_DTL_NO);
			}
		}

		// テンプレートID
		template.set(EKK0441C330CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0441C330);

		template.set(EKK0441C330CBSMsg.FUNC_CODE, "1");

		// オペレータ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(EKK0441C330CBSMsg.FUNC_CODE, dataMap.get(JCMConstants.FUNC_CODE_KEY));
		
		// 請求オプションサービス契約解約マップ.請求オプションサービス契約番号 → 請求オプションサービス契約番号
		if (seiopsvc_kei_no == null || "".equals(seiopsvc_kei_no))
		{
			template.setNull(EKK0441C330CBSMsg.SEIOPSVC_KEI_NO);
		} 
		else 
		{
			template.set(EKK0441C330CBSMsg.SEIOPSVC_KEI_NO, seiopsvc_kei_no);
		}
		
		// 更新年月日時分秒 → 更新年月日時分秒（更新前）
		if ("".equals(dataMap.get("EKK0441A010_seikyu_upd_dtm")) || !dataMap.containsKey("EKK0441A010_seikyu_upd_dtm")) 
		{
			template.setNull(EKK0441C330CBSMsg.UPD_DTM_BF);
		} 
		else 
		{
			template.set(EKK0441C330CBSMsg.UPD_DTM_BF, (String)dataMap.get("EKK0441A010_seikyu_upd_dtm"));
		}
		
		// 請求オプションサービス契約登録マップ.異動区分
		if ((String)dataMap.get("ido_div") == null || "".equals(dataMap.get("ido_div"))) 
		{
			template.setNull(EKK0441C330CBSMsg.IDO_DIV);
		} 
		else 
		{
			template.set(EKK0441C330CBSMsg.IDO_DIV, (String)dataMap.get("ido_div"));
		}
		
		// 請求オプションサービス契約登録マップ.NHKお客様番号
		if ((String)dataMap.get("nhk_cust_no") == null || "".equals(dataMap.get("nhk_cust_no"))) 
		{
			template.setNull(EKK0441C330CBSMsg.NHK_CUST_NO);
		} 
		else 
		{
			template.set(EKK0441C330CBSMsg.NHK_CUST_NO, (String)dataMap.get("nhk_cust_no"));
		}
		
		// 請求オプションサービス契約登録マップ.NHK団体一括支払サイクルコード
		if ((String)dataMap.get("nhk_grp_ikt_pay_cycle_cd") == null || "".equals(dataMap.get("nhk_grp_ikt_pay_cycle_cd"))) 
		{
			template.setNull(EKK0441C330CBSMsg.NHK_GRP_IKT_PAY_CYCLE_CD);
		} 
		else 
		{
			template.set(EKK0441C330CBSMsg.NHK_GRP_IKT_PAY_CYCLE_CD, (String)dataMap.get("nhk_grp_ikt_pay_cycle_cd"));
		}
		
		// 請求オプションサービス契約登録マップ.NHK団体一括契約変更届年月日
		if ((String)dataMap.get("nhk_dntiktkei_hktdk_ymd") == null || "".equals(dataMap.get("nhk_dntiktkei_hktdk_ymd"))) 
		{
			template.setNull(EKK0441C330CBSMsg.NHK_DNTIKTKEI_HKTDK_YMD);
		} 
		else 
		{
			template.set(EKK0441C330CBSMsg.NHK_DNTIKTKEI_HKTDK_YMD, (String)dataMap.get("nhk_dntiktkei_hktdk_ymd"));
		}
		
		// 請求オプションサービス契約登録マップ.NHK団体一括契約変更理由メモ
		if ((String)dataMap.get("nhk_dntiktkei_chrge_memo") == null || "".equals(dataMap.get("nhk_dntiktkei_chrge_memo"))) 
		{
			template.setNull(EKK0441C330CBSMsg.NHK_DNTIKTKEI_CHGRE_MEMO);
		} 
		else 
		{
			template.set(EKK0441C330CBSMsg.NHK_DNTIKTKEI_CHGRE_MEMO, (String)dataMap.get("nhk_dntiktkei_chrge_memo"));
		}
		
		// 請求オプションサービス契約登録マップ.NHK団体一括契約登録メモ
		if ((String)dataMap.get("nhk_dntiktkei_add_memo") == null || "".equals(dataMap.get("nhk_dntiktkei_add_memo"))) 
		{
			template.setNull(EKK0441C330CBSMsg.NHK_DNTIKTKEI_ADD_MEMO);
		} 
		else 
		{
			template.set(EKK0441C330CBSMsg.NHK_DNTIKTKEI_ADD_MEMO, (String)dataMap.get("nhk_dntiktkei_add_memo"));
		}
		
		// 請求オプションサービス契約登録マップ.NHK外部連携契約コード
		if ((String)dataMap.get("nhk_out_rnki_kei_cd") == null || "".equals(dataMap.get("nhk_out_rnki_kei_cd"))) 
		{
			template.setNull(EKK0441C330CBSMsg.NHK_OUT_RNKI_KEI_CD);
		} 
		else 
		{
			template.set(EKK0441C330CBSMsg.NHK_OUT_RNKI_KEI_CD, (String)dataMap.get("nhk_out_rnki_kei_cd"));
		}
		
		// 請求オプションサービス契約登録マップ.NHK団体一括契約住所メモ
		if ((String)dataMap.get("nhk_dntiktkei_ad_memo") == null || "".equals(dataMap.get("nhk_dntiktkei_ad_memo"))) 
		{
			template.setNull(EKK0441C330CBSMsg.NHK_DNTIKTKEI_AD_MEMO);
		} 
		else 
		{
			template.set(EKK0441C330CBSMsg.NHK_DNTIKTKEI_AD_MEMO, (String)dataMap.get("nhk_dntiktkei_ad_memo"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @return 業務データ取得・書込用I/F
	 * @since 2012.06.04
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editOutMsg_EKK0441C330(Map<?, ?> msgList,
			IRequestParameterReadWrite param,
			Map<String, Object> dataMap,
			HashMap<String, Object> childMap) throws Exception {

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = (Map)param.getMappingWorkArea();
		if (workMap == null) {
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
		// 世代登録年月日時分秒WORK(EKK0441C330) ← 世代登録年月日時分秒
		if (parentTemplate.isNull(EKK0441C330CBSMsg.GENE_ADD_DTM)) 
		{
			childMap.put("EKK0441C330_gene_add_dtm", new String());
		} 
		else 
		{
			childMap.put("EKK0441C330_gene_add_dtm", parentTemplate.getString(EKK0441C330CBSMsg.GENE_ADD_DTM));
		}
		// 更新年月日時分秒WORK(EKK0441C330) ← 更新年月日時分秒
		if (parentTemplate.isNull(EKK0441C330CBSMsg.UPD_DTM)) 
		{
			childMap.put("EKK0441C330_upd_dtm", new String());
		} 
		else 
		{
			childMap.put("EKK0441C330_upd_dtm", parentTemplate.getString(EKK0441C330CBSMsg.UPD_DTM));
		}
		
        // エラー情報の設定
        param = editErrorInfo_EKK0441C330(param, dataMap, templates, (Integer)return_code, childMap);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
		
		return param;
	}
	
	/**
	 * 請求オプションサービス契約解約エラー処理メソッド
	 * @param param
	 * @param inMap
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0441C330(IRequestParameterReadWrite param, 
																	Map<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode,
																	HashMap<String, Object> childMap) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0441C330CBSMsg.STATUS);
		if(returnCode != 0)
		{
			templateStatus = 9000;
		}

		if(JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if(templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		// 請求オプションサービス契約番号
		setErrDataMap(childMap, template, EKK0441C330CBSMsg.SEIOPSVC_KEI_NO_ERR);
		// 申込明細番号
		setErrDataMap(childMap, template, EKK0441C330CBSMsg.MSKM_DTL_NO_ERR);
		// 異動区分
		setErrDataMap(childMap, template, EKK0441C330CBSMsg.IDO_DIV_ERR);
		// NHK団体一括支払サイクルコード
		setErrDataMap(childMap, template, EKK0441C330CBSMsg.NHK_GRP_IKT_PAY_CYCLE_CD_ERR);
		// NHKお客様番号
		setErrDataMap(childMap, template, EKK0441C330CBSMsg.NHK_CUST_NO_ERR);
		// NHK団体一括契約変更届年月日
		setErrDataMap(childMap, template, EKK0441C330CBSMsg.NHK_CUST_NO_ERR);
		// NHK団体一括契約変更理由メモ
		setErrDataMap(childMap, template, EKK0441C330CBSMsg.NHK_DNTIKTKEI_CHGRE_MEMO_ERR);
		// NHK外部連携契約コード
		setErrDataMap(childMap, template, EKK0441C330CBSMsg.NHK_OUT_RNKI_KEI_CD_ERR);
		// NHK団体一括契約住所メモ
		setErrDataMap(childMap, template, EKK0441C330CBSMsg.NHK_DNTIKTKEI_AD_MEMO_ERR);
		// 更新年月日時分秒（更新前）
		setErrDataMap(childMap, template, EKK0441C330CBSMsg.UPD_DTM_BF_ERR);
		
		return param;
	}
	
	/**
	 * 請求オプションサービス契約解約確定サービスを実行し値を取得します。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param scCall 
	 * @param dataMap リクエストデータ
	 * @throws Exception 
	 */
	private void execEKK0441C340(SessionHandle handle,
									IRequestParameterReadWrite param,
									ServiceComponentRequestInvoker scCall,
									Map<String, Object> dataMap,
									HashMap<String, Object> childMap,
									String seiopsvc_kei_no) throws Exception
	{
		
		// ◇ 上りマッピング処理
		// リクエストパラメータを引数に上りマッピング処理メソッドを実行
		HashMap<String, Object> paramMap = editInMsg_EKK0441C340(param, dataMap, childMap, seiopsvc_kei_no);
		
		// ◇ SC呼出実行 (請求オプションサービス契約解約確定)
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		// ◇ 下りマッピング処理
		editOutMsg_EKK0441C340(result, param, dataMap, childMap);
		
		//処理結果判定
		jdgErrRslt(result, 0);
	}
	
	/**
	 * 請求オプションサービス契約解約確定のメッセージを作成します。
	 * 
	 * @param param
	 * @param inMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> editInMsg_EKK0441C340(IRequestParameterReadWrite param,
																Map<String, Object> dataMap,
																HashMap<String, Object> childMap,
																String seiopsvc_kei_no) throws RequestParameterException
	{
		
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

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

		// テンプレートID
		template.set(EKK0441C340CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0441C340);

		template.set(EKK0441C340CBSMsg.FUNC_CODE, "1");

		// オペレータ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);
		
		// 作業領域の取得
		Map<Object, Object> workMap = param.getMappingWorkArea();
		
		HashMap<String,ArrayList> map = (HashMap<String,ArrayList>)workMap.get("KKSV079901CCWORK");
		
		if(map == null)
		{
			template.setNull(EKK1091D010CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			ArrayList<HashMap<String,String>> workList = (ArrayList<HashMap<String,String>>)map.get("KKSV079901CCWORKLIST");
			if(workList != null && workList.size() != 0){
				
				HashMap reMap = (HashMap)workList.get(0);
				String meisai = (String)reMap.get("mskm_dtl_no");
				
				
				// 作業項目.申込明細番号 → 申込明細番号
				if (meisai == null || "".equals(meisai)) {
					template.setNull(EKK0441C340CBSMsg.MSKM_DTL_NO);
				} else {
					template.set(EKK0441C340CBSMsg.MSKM_DTL_NO, meisai);
				}
			}else{
				template.setNull(EKK0441C340CBSMsg.MSKM_DTL_NO);
			}
		}
		
		// 機能コード
		template.set(EKK0441C340CBSMsg.FUNC_CODE, dataMap.get(JCMConstants.FUNC_CODE_KEY));
		
		// 更新年月日時分秒 → 更新年月日時分秒（更新前）
		if ("".equals(dataMap.get("EKK0441A010_seikyu_upd_dtm")) || !dataMap.containsKey("EKK0441A010_seikyu_upd_dtm")) 
		{
			template.setNull(EKK0441C340CBSMsg.UPD_DTM_BF);
		} 
		else 
		{
			template.set(EKK0441C340CBSMsg.UPD_DTM_BF, (String)dataMap.get("EKK0441A010_seikyu_upd_dtm"));
		}
		// 請求オプションサービス契約解約マップ.請求オプションサービス契約番号 → 請求オプションサービス契約番号
		if ("".equals(seiopsvc_kei_no))
		{
			template.setNull(EKK0441C340CBSMsg.SEIOPSVC_KEI_NO);
		} 
		else 
		{
			template.set(EKK0441C340CBSMsg.SEIOPSVC_KEI_NO, seiopsvc_kei_no);
		}
		// 請求オプションサービス契約解約マップ.異動区分 → 異動区分
		if ("".equals(dataMap.get("ido_div")) || !dataMap.containsKey("ido_div")) 
		{
			template.setNull(EKK0441C340CBSMsg.IDO_DIV);
		} 
		else 
		{
			template.set(EKK0441C340CBSMsg.IDO_DIV, (String)dataMap.get("ido_div"));
		}		
		// 請求オプションサービス契約解約マップ.サービス終了年月日 → サービス終了年月日
		if ("".equals(dataMap.get("dsl_svc_endymd")) || !dataMap.containsKey("dsl_svc_endymd")) 
		{
			template.setNull(EKK0441C340CBSMsg.SVC_ENDYMD);
		} 
		else 
		{
			template.set(EKK0441C340CBSMsg.SVC_ENDYMD, (String)dataMap.get("dsl_svc_endymd"));
		}

		// 請求オプションサービス契約解約マップ.サービス課金終了年月日 → サービス課金終了年月日
		if ("".equals(dataMap.get("dsl_svc_chrg_endymd")) || !dataMap.containsKey("dsl_svc_chrg_endymd")) 
		{
			template.setNull(EKK0441C340CBSMsg.SVC_CHRG_ENDYMD);
		} 
		else 
		{
			template.set(EKK0441C340CBSMsg.SVC_CHRG_ENDYMD, (String)dataMap.get("dsl_svc_chrg_endymd"));
		}

		// 請求オプションサービス契約解約マップ.サービス解約年月日 → サービス解約年月日
		if ("".equals(dataMap.get("dsl_svc_dsl_ymd")) || !dataMap.containsKey("dsl_svc_dsl_ymd")) 
		{
			template.setNull(EKK0441C340CBSMsg.SVC_DSL_YMD);
		} 
		else 
		{
			template.set(EKK0441C340CBSMsg.SVC_DSL_YMD, (String)dataMap.get("dsl_svc_dsl_ymd"));
		}

		// 請求オプションサービス契約解約マップ.サービス解約理由コード → サービス解約理由コード
		if ("".equals(dataMap.get("dsl_svc_dlre_cd")) || !dataMap.containsKey("dsl_svc_dlre_cd")) 
		{
			template.setNull(EKK0441C340CBSMsg.SVC_DLRE_CD);
		} 
		else 
		{
			template.set(EKK0441C340CBSMsg.SVC_DLRE_CD, (String)dataMap.get("dsl_svc_dlre_cd"));
		}

		// 請求オプションサービス契約登録マップ.違約金発生コード → 違約金発生コード
		if ((String)dataMap.get("dsl_pnlty_hassei_cd") == null || "".equals(dataMap.get("dsl_pnlty_hassei_cd"))) 
		{
			template.setNull(EKK0441C340CBSMsg.PNLTY_HASSEI_CD);
		} 
		else 
		{
			template.set(EKK0441C340CBSMsg.PNLTY_HASSEI_CD, (String)dataMap.get("dsl_pnlty_hassei_cd"));
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @return 業務データ取得・書込用I/F
	 * @since 2012.06.04
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editOutMsg_EKK0441C340(Map<?, ?> msgList,
			IRequestParameterReadWrite param,
			Map<String, Object> dataMap,
			HashMap<String, Object> childMap) throws Exception {

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = (Map)param.getMappingWorkArea();
		if (workMap == null) {
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
 		
        // エラー情報の設定
        param = editErrorInfo_EKK0441C340(param, dataMap, templates, (Integer)return_code, childMap);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
        
		
		return param;
	}
	
	/**
	 * 請求オプションサービス契約解約確定エラー処理メソッド
	 * @param param
	 * @param inMap
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK0441C340(IRequestParameterReadWrite param, 
																	Map<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode,
																	HashMap<String, Object> childMap) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0441C340CBSMsg.STATUS);
		if(returnCode != 0)
		{
			templateStatus = 9000;
		}

		if(JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if(templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		// 請求オプションサービス契約番号
		setErrDataMap(childMap, template, EKK0441C340CBSMsg.SEIOPSVC_KEI_NO_ERR);
		// 申込明細番号
		setErrDataMap(childMap, template, EKK0441C340CBSMsg.MSKM_DTL_NO_ERR);
		// 予約適用開始希望年月日エラー
		setErrDataMap(childMap, template, EKK0441C340CBSMsg.SEIOPSVC_KEI_NO_ERR);
		// サービス終了年月日
		setErrDataMap(childMap, template, EKK0441C340CBSMsg.SVC_ENDYMD_ERR);
		// サービス課金終了年月日
		setErrDataMap(childMap, template, EKK0441C340CBSMsg.SVC_CHRG_ENDYMD_ERR);
		// サービス解約年月日
		setErrDataMap(childMap, template, EKK0441C340CBSMsg.SVC_DSL_YMD_ERR);
		// サービス解約理由コード
		setErrDataMap(childMap, template, EKK0441C340CBSMsg.SVC_DLRE_CD_ERR);
		// サービス解約理由メモ
		setErrDataMap(childMap, template, EKK0441C340CBSMsg.SVC_DLRE_MEMO_ERR);
		// 異動区分エラー
		setErrDataMap(childMap, template, EKK0441C340CBSMsg.IDO_DIV_ERR);
		// 更新年月日時分秒(更新前)
		setErrDataMap(childMap, template, EKK0441C340CBSMsg.UPD_DTM_BF_ERR);
		// 違約金発生コード
		setErrDataMap(childMap, template, EKK0441C340CBSMsg.PNLTY_HASSEI_CD_ERR);
		
		return param;
	}
	
	/**
	 * 進捗登録サービスを実行し値を取得します。
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param scCall 
	 * @param dataMap リクエストデータ
	 * @param childMap
	 * @param flg 請求元、請求先判定フラグ
	 * @throws Exception 
	 */
	private void execEKK1091D010(SessionHandle handle,
									IRequestParameterReadWrite param,
									ServiceComponentRequestInvoker scCall,
									Map<String, Object> dataMap,
									HashMap<String, Object> childMap,
									String jidokaiyaku,
									String prg_tkjk_1) throws Exception
	{
		
		// ◇ 上りマッピング処理
		// リクエストパラメータを引数に上りマッピング処理メソッドを実行
		HashMap<String, Object> paramMap = editInMsg_EKK1091D010(param, dataMap, childMap, jidokaiyaku, prg_tkjk_1);
		
		// ◇ SC呼出実行 (サービス契約一意照会)
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		editOutMsg_EKK1091D010(result, param, dataMap, childMap);
		
		//処理結果判定
		jdgErrRslt(result, 0);
	}
	
	/**
	 * 進捗登録のメッセージを作成します。
	 * 
	 * @param param
	 * @param inMap
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> editInMsg_EKK1091D010(IRequestParameterReadWrite param,
																Map<String, Object> dataMap,
																HashMap<String, Object> childMap,
																String seiky_kei_no,
																String prg_tkjk_1) throws RequestParameterException
	{
		
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

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

		// テンプレートID
		template.set(EKK1091D010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK1091D010);

		template.set(EKK1091D010CBSMsg.FUNC_CODE, "1");

		// オペレータ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);

		CAANMsg[] templateArray = null;
		HashMap inMap = null;
		ArrayList inList = null;
		
		// 作業領域の取得
		Map<Object, Object> workMap = param.getMappingWorkArea();
		
		HashMap<String,ArrayList> map = (HashMap<String,ArrayList>)workMap.get("KKSV079901CCWORK");
		
		if(map == null)
		{
			template.setNull(EKK1091D010CBSMsg.MSKM_DTL_NO);
		}
		else
		{
			ArrayList<HashMap<String,String>> workList = (ArrayList<HashMap<String,String>>)map.get("KKSV079901CCWORKLIST");
			if(workList != null && workList.size() != 0){
				
				HashMap reMap = (HashMap)workList.get(0);
				String meisai = (String)reMap.get("mskm_dtl_no");
				
				
				// 作業項目.申込明細番号 → 申込明細番号
				if (meisai == null || "".equals(meisai)) {
					template.setNull(EKK1091D010CBSMsg.MSKM_DTL_NO);
				} else {
					template.set(EKK1091D010CBSMsg.MSKM_DTL_NO, meisai);
				}
			}else{
				template.setNull(EKK1091D010CBSMsg.MSKM_DTL_NO);
			}
		}
		
		// 機能コード
		template.set(EKK1091D010CBSMsg.FUNC_CODE, dataMap.get(JCMConstants.FUNC_CODE_KEY));


		// 進捗登録マップ.請求契約番号 → 請求契約番号
		// 請求契約番号
		if (seiky_kei_no == null || "".equals(seiky_kei_no)) {
			template.setNull(EKK1091D010CBSMsg.SEIKY_KEI_NO);
		} else {
			template.set(EKK1091D010CBSMsg.SEIKY_KEI_NO, seiky_kei_no);
		}

		// 進捗登録マップ.請求方法番号（口座） → 請求方法番号(口座)
		if ((String)dataMap.get("seiky_way_no_koza") == null || "".equals(dataMap.get("seiky_way_no_koza"))) {
			template.setNull(EKK1091D010CBSMsg.SEIKY_WAY_NO_KOZA);
		} else {
			template.set(EKK1091D010CBSMsg.SEIKY_WAY_NO_KOZA, (String) dataMap.get("seiky_way_no_koza"));
		}

		// 進捗登録マップ.請求方法番号（クレジットカード） → 請求方法番号(クレジットカード)
		if ((String)dataMap.get("seiky_way_no_crecard") == null || "".equals(dataMap.get("seiky_way_no_crecard"))) {
			template.setNull(EKK1091D010CBSMsg.SEIKY_WAY_NO_CRECARD);
		} else {
			template.set(EKK1091D010CBSMsg.SEIKY_WAY_NO_CRECARD, (String) dataMap.get("seiky_way_no_crecard"));
		}

		// 進捗登録マップ.サービス契約番号 → サービス契約番号
		if ((String)dataMap.get("key_svc_kei_no") == null || "".equals(dataMap.get("key_svc_kei_no"))) {
			template.setNull(EKK1091D010CBSMsg.SVC_KEI_NO);
		} else {
			template.set(EKK1091D010CBSMsg.SVC_KEI_NO, (String) dataMap.get("key_svc_kei_no"));
		}

		// 進捗登録マップ.サービス契約内訳番号 → サービス契約内訳番号
		if ((String)dataMap.get("svc_kei_ucwk_no") == null || "".equals(dataMap.get("svc_kei_ucwk_no"))) {
			template.setNull(EKK1091D010CBSMsg.SVC_KEI_UCWK_NO);
		} else {
			template.set(EKK1091D010CBSMsg.SVC_KEI_UCWK_NO, (String) dataMap.get("svc_kei_ucwk_no"));
		}

		// 進捗登録マップ.サービス契約回線内訳番号 → サービス契約回線内訳番号
		if ((String)dataMap.get("svc_kei_kaisen_ucwk_no") == null || "".equals(dataMap.get("svc_kei_kaisen_ucwk_no"))) {
			template.setNull(EKK1091D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO);
		} else {
			template.set(EKK1091D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO, (String) dataMap.get("svc_kei_kaisen_ucwk_no"));
		}

		// 進捗登録マップ.機器提供サービス契約番号 → 機器提供サービス契約番号
		if ((String)dataMap.get("kktk_svc_kei_no") == null || "".equals(dataMap.get("kktk_svc_kei_no"))) {
			template.setNull(EKK1091D010CBSMsg.KKTK_SVC_KEI_NO);
		} else {
			template.set(EKK1091D010CBSMsg.KKTK_SVC_KEI_NO, (String) dataMap.get("kktk_svc_kei_no"));
		}

		// 進捗登録マップ.オプションサービス契約番号 → オプションサービス契約番号
		if ((String)dataMap.get("op_svc_kei_no") == null || "".equals(dataMap.get("op_svc_kei_no"))) {
			template.setNull(EKK1091D010CBSMsg.OP_SVC_KEI_NO);
		} else {
			template.set(EKK1091D010CBSMsg.OP_SVC_KEI_NO, (String) dataMap.get("op_svc_kei_no"));
		}

		// 進捗登録マップ.サブオプションサービス契約番号 → サブオプションサービス契約番号
		if ((String)dataMap.get("sbop_svc_kei_no") == null || "".equals(dataMap.get("sbop_svc_kei_no"))) {
			template.setNull(EKK1091D010CBSMsg.SBOP_SVC_KEI_NO);
		} else {
			template.set(EKK1091D010CBSMsg.SBOP_SVC_KEI_NO, (String) dataMap.get("sbop_svc_kei_no"));
		}

		// 進捗登録マップ.割引サービス契約番号 → 割引サービス契約番号
		if ((String)dataMap.get("wrib_svc_kei_no") == null || "".equals(dataMap.get("wrib_svc_kei_no"))) {
			template.setNull(EKK1091D010CBSMsg.WRIB_SVC_KEI_NO);
		} else {
			template.set(EKK1091D010CBSMsg.WRIB_SVC_KEI_NO, (String) dataMap.get("wrib_svc_kei_no"));
		}

		// 進捗登録マップ.異動区分 → 異動区分
		if ((String)dataMap.get("prg_ido_div") == null || "".equals(dataMap.get("prg_ido_div"))) {
			template.setNull(EKK1091D010CBSMsg.IDO_DIV);
		} else {
			template.set(EKK1091D010CBSMsg.IDO_DIV, (String) dataMap.get("prg_ido_div"));
		}

		// 進捗登録マップ.異動年月日時分秒 → 異動年月日時分秒
		if ((String)dataMap.get("ido_dtm") == null || "".equals(dataMap.get("ido_dtm"))) {
			template.setNull(EKK1091D010CBSMsg.IDO_DTM);
		} else {
			template.set(EKK1091D010CBSMsg.IDO_DTM, (String) dataMap.get("ido_dtm"));
		}

		// 進捗登録マップ.進捗ステータス → 進捗ステータス
		if ((String)dataMap.get("prg_stat") == null || "".equals(dataMap.get("prg_stat"))) {
			template.setNull(EKK1091D010CBSMsg.PRG_STAT);
		} else {
			template.set(EKK1091D010CBSMsg.PRG_STAT, (String) dataMap.get("prg_stat"));
		}

		// 進捗登録マップ.進捗メモ → 進捗メモ
		if ((String)dataMap.get("prg_memo") == null || "".equals(dataMap.get("prg_memo"))) {
			template.setNull(EKK1091D010CBSMsg.PRG_MEMO);
		} else {
			template.set(EKK1091D010CBSMsg.PRG_MEMO, (String) dataMap.get("prg_memo"));
		}
		// 進捗登録マップ.進捗特記事項1 → 進捗特記事項1
		if (prg_tkjk_1 == null || "".equals(prg_tkjk_1)) {
			template.setNull(EKK1091D010CBSMsg.PRG_TKJK_1);
		} else {
			template.set(EKK1091D010CBSMsg.PRG_TKJK_1, prg_tkjk_1 + dataMap.get("EKK0441A010_nhk_out_rnki_kei_cd"));
		}
		// 進捗登録マップ.進捗特記事項2 → 進捗特記事項2
		if ((String)dataMap.get("prg_tkjk_2") == null || "".equals(dataMap.get("prg_tkjk_2"))) {
			template.setNull(EKK1091D010CBSMsg.PRG_TKJK_2);
		} else {
			template.set(EKK1091D010CBSMsg.PRG_TKJK_2, (String) dataMap.get("prg_tkjk_2"));
		}
		
		// 異動理由明細
		inList = (ArrayList)dataMap.get("EKK1091D010CBSMsg1List");
		
		if (inList == null) {
			templateArray = new CAANMsg[1];
			templateArray[0] = new CAANMsg(EKK1091D010CBSMsg1List.class.getName());
			
			// 進捗登録マップ.異動理由コード → 異動理由コード
			if ((String)dataMap.get("ido_rsn_cd") == null || "".equals(dataMap.get("ido_rsn_cd"))) {
				templateArray[0].setNull(EKK1091D010CBSMsg1List.IDO_RSN_CD);
			}else{
				templateArray[0].set(EKK1091D010CBSMsg1List.IDO_RSN_CD, (String) dataMap.get("ido_rsn_cd"));
			}
			
			// 進捗登録マップ.異動理由メモ → 異動理由メモ
			if ((String)dataMap.get("ido_rsn_memo") == null || "".equals(dataMap.get("ido_rsn_memo"))) {
				templateArray[0].setNull(EKK1091D010CBSMsg1List.IDO_RSN_MEMO);
			}else{
				templateArray[0].set(EKK1091D010CBSMsg1List.IDO_RSN_MEMO, (String) dataMap.get("ido_rsn_memo"));
			}
			
			template.set(EKK1091D010CBSMsg.EKK1091D010CBSMSG1LIST, templateArray);
		}
		
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}
	
	/**
	 *<DL>
	 *<DT>処理概要:
	 *<DD>サービスコンポーネント実行後に、IRequestParameterReadWriteに必要なデータをマッピングする
	 *<DT>入力パラメータ説明:
	 *<DD>特になし
	 *<DT>入力パラメータ説明：
	 *<DD>特になし
	 *<DT>出力パラメータ説明:
	 *<DD>特になし
	 *</DL>
	 * @param msgList (I) CAANMsgクラス 
	 * @param param (I) 業務データ取得・書込用I/F
	 * @return 業務データ取得・書込用I/F
	 * @since 2011.11.25
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editOutMsg_EKK1091D010(Map<?, ?> msgList,
			IRequestParameterReadWrite param,
			Map<String, Object> dataMap,
			HashMap<String, Object> childMap) throws Exception {

		// SCからの戻り値からCAANMsgを取得する。
		CAANMsg[] templates = (CAANMsg[]) msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg parentTemplate = templates[0];
		CAANMsg[] templateArray = null;

		// リターンコード取得
		Object return_code = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// 作業領域の取得
		Map workMap = (Map)param.getMappingWorkArea();
		if (workMap == null) {
			workMap = new HashMap();
			param.setMappingWorkArea(workMap);
		}
		
        // エラー情報の設定
        param = editErrorInfo_EKK1091D010(param, dataMap, templates, (Integer)return_code, childMap);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null){
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));
        
		
		return param;
	}
	
	/**
	 * 進捗登録エラー処理メソッド
	 * @param param
	 * @param inMap
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfo_EKK1091D010(IRequestParameterReadWrite param, 
																	Map<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode,
																	HashMap<String, Object> childMap) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK1091D010CBSMsg.STATUS);
		if(returnCode != 0)
		{
			templateStatus = 9000;
		}

		if(JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}

		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}

		if(templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}

		// 申込明細番号
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.MSKM_DTL_NO_ERR);
		// 請求契約番号
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.SEIKY_KEI_NO_ERR);
		// 請求方法番号（口座）
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.SEIKY_WAY_NO_KOZA_ERR);
		// 請求方法番号（クレジットカード）
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.SEIKY_WAY_NO_CRECARD_ERR);
		// サービス契約番号
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.SVC_KEI_NO_ERR);
		// サービス契約内訳番号
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.SVC_KEI_UCWK_NO_ERR);
		// サービス契約回線内訳番号
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.SVC_KEI_KAISEN_UCWK_NO_ERR);
		// 機器提供サービス契約番号
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.KKTK_SVC_KEI_NO_ERR);
		// オプションサービス契約番号
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.OP_SVC_KEI_NO_ERR);
		// 請求オプションサービス契約番号
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.SEIOPSVC_KEI_NO_ERR);
		// サブオプションサービス契約番号
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.SBOP_SVC_KEI_NO_ERR);
		// 割引サービス契約番号
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.WRIB_SVC_KEI_NO_ERR);
		// 異動区分
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.IDO_DIV_ERR);
		// 異動年月日時分秒
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.IDO_DTM_ERR);
		// 進捗ステータス
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.PRG_STAT_ERR);
		// 進捗メモ
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.PRG_MEMO_ERR);
		// 進捗特記事項1
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.PRG_TKJK_1_ERR);
		// 進捗特記事項2
		setErrDataMap(childMap, template, EKK1091D010CBSMsg.PRG_TKJK_2_ERR);
		return param;
	}
	
	/**
	 * Mapにエラーデータを格納します。
	 * @param inMap データ格納Map
	 * @param template CAANMsgクラス
	 * @param mapKey 取得と格納するキー
	 */
	private void setErrDataMap(Map<String, Object> inMap, CAANMsg template, String mapKey)
	{
		if(!template.isNull(mapKey))
		{
			if(!inMap.containsKey(mapKey))
			{
				inMap.put(mapKey, template.getString(mapKey));
			}
		}
	}
	
	
	
	/**
	 * 共通項目の設定
	 * @param param
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsg(IRequestParameterReadWrite param) throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

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

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

		return paramMap;
	}
	
	/**
	 * IFの戻り値を判定し、結果が異常の場合、SCCallExceptionを発生させます。
	 * @param result CAANMsgクラス
	 * @param cnt CAANMsgの対象位置
	 * @throws Exception
	 */
	private void jdgErrRslt(Map<?, ?> result, int cnt) throws Exception
	{
		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg msg = templates[cnt];

		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		Integer status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		Integer zero = 0;

		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && zero.equals(status)))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
	}
	
	@SuppressWarnings("unchecked")
	private void setNullToMsg(CAANMsg msg)
	{
		Iterator<String> caanMsgKeys = msg.getSchema().getSchemaKeySet().iterator();
		while (caanMsgKeys.hasNext())
		{
			String key = caanMsgKeys.next();
			if (key.endsWith("_err"))
			{
				String tmpKey = key.substring(0, key.length() - 4);
				
				if (!msg.containsKeyOfMsgData(tmpKey) || "".equals(msg.getObject(tmpKey)))
				{
					msg.setNull(tmpKey);
					continue;
				}
				Object obj = msg.getObject(tmpKey);
				if (obj instanceof CAANMsg[])
				{
					for (CAANMsg submsg : (CAANMsg[]) obj)
					{
						setNullToMsg(submsg);
					}
				}
			}
		}
	}
	
	/**
	 * 請求契約変更ＣＣのチェック処理用サービスインターフェイス作成。<br>
	 * <br>
	 * @param handle セッションマネージャなどを持ったハンドル
	 * @param param モデルグループ、コントロールマップを含むパラメータオブジェクト
	 * @param fixedText ユーザ任意文字列
	 * @return サービスコンポーネント実行用CAANMsg
	 * @exception RequestParameterExceptionがスローされます。
	 */
	@SuppressWarnings("unchecked")
	public  HashMap<String, Object> getInvokeCBS(SessionHandle handle, IRequestParameterReadWrite param, String fixedText)
	throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		
		List<CAANMsg> templates = new ArrayList<CAANMsg>();
		
		// チェック用サービスインターフェイス
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, Arrays.asList(templates));
		
		return paramMap;
	}
	
	/**
	 * メッセージIDを設定します。
	 * @param ccMsg パラメータMap
	 * @param pMessageId メッセージID
	 * @param pReplaceCha 置換文字列
	 * @param pErrItem エラー設定項目
	 * @param pErrFlg エラーフラグ
	 */
	private void setMessageInfo(HashMap<String, Object> ccMsg, String pMessageId, String pReplaceCha, String pErrItem, String pErrFlg)
	{
	
		// エラーフラグの設定
		// エラーの場合はそのまま設定。　ワーニングの場合はエラーが設定されていない場合、設定
		String errFlg = (String)ccMsg.get("err_flg");
	
		if("".equals(errFlg) || ERR_FLG_WARNING.equals(errFlg))
		{
			ccMsg.put("err_flg", pErrFlg);
		}
	
		HashMap<String, Object> messageMap = new HashMap<String, Object>();
		// メッセージIDを設定
		messageMap.put("messageId", pMessageId);
		// 置換文字列
		messageMap.put("replaceCha", pReplaceCha);
		// エラー設定項目
		messageMap.put("errItem", pErrItem);
	
		ArrayList<HashMap<String, Object>> messageInfo = (ArrayList<HashMap<String, Object>>)ccMsg.get("message_list");
		messageInfo.add(messageMap);
	
	}
	
	/**
	 * SC(サービスインターフェイス）を呼び出す。
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param mappingData
	 * @return CAANMsg
	 * @throws Exception
	 */
	private CAANMsg callSC(SessionHandle handle,
							ServiceComponentRequestInvoker scCall,
							IRequestParameterReadWrite param,
							String dataMapKey,
							Object[][] mappingData) throws Exception
	{
		return callSC(handle, scCall, param, dataMapKey, mappingData, null);
	}
	
	/**
	 * SC(サービスインターフェイス）を呼び出す。
	 * 
	 * @param handle
	 * @param scCall
	 * @param param
	 * @param dataMapKey
	 * @param mappingData
	 * @param csvData
	 * @return CAANMsg
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private CAANMsg callSC(SessionHandle handle,
							ServiceComponentRequestInvoker scCall,
							IRequestParameterReadWrite param,
							String dataMapKey,
							Object[][] mappingData,
							byte[] csvData) throws Exception
	{
		HashMap<String, Object> paramMap = editInMsg(param, mappingData, csvData);
		
		Map<?, ?> result = scCall.run(paramMap, handle);
		
		CAANMsg[] templates = (CAANMsg[])result.get(JCMConstants.TEMPLATE_LIST_KEY);
		CAANMsg msg = templates[0];
		
		// リターンコード取得
		int returnCode = (Integer)result.get(JCMConstants.RET_CD_INT_KEY);
		
		int templateStatus = msg.getInt(EKK0081B027CBSMsg.STATUS);
		
		if (returnCode != 0)
		{
			templateStatus = 9000;
		}
		
		if (JCMAPLConstMgr.getString("RETURN_MESSAGE_" + String.format("%1$04d", templateStatus)) == null)
		{
			templateStatus = 0;
		}
		
		int bpStatus = 0;
		Object obj = param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		if (obj == null)
		{
			bpStatus = -1;
		}
		else
		{
			bpStatus = Integer.parseInt((String)param.getControlMapData(SCControlMapKeys.RETURN_CODE));
		}
		
		if (templateStatus > bpStatus)
		{
			// BPにサービスコンポーネントのステータスを設定する。
			String formatStatus = String.format("%1$04d", templateStatus);
			String message = JCMAPLConstMgr.getString("RETURN_MESSAGE_" + formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_CODE, formatStatus);
			param.setControlMapData(SCControlMapKeys.RETURN_MESSAGE, message);
		}
		
		setErrorInf(msg, (HashMap<String, Object>)param.getData(dataMapKey));
		
		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if (errList == null)
		{
			errList = new ArrayList<Object>();
		}
		
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(result, errList));
		
		/* ◇処理結果の判定*/
		// 取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = result.get(JCMConstants.RET_CD_INT_KEY).toString();
		Integer status = msg.getInt(JCMConstants.STATUS_INT_KEY);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == status.intValue()))
		{
			SCCallException scCallEx = new SCCallException("戻り値不正", rtnCode, status);
			throw scCallEx;
		}
		return msg;
	}
	
	/**
	 * @param param
	 * @param mappingData
	 * @param csvData
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsg(IRequestParameterReadWrite param,
												Object[][] mappingData,
												byte[] csvData) throws RequestParameterException
	{
		HashMap<String, Object> paramMap = new HashMap<String, Object>();
		
		// 【取得元：電文ヘッダ(ヘッダ)】
		// 電文ID
		paramMap.put(JCMConstants.TRANZACTION_ID_KEY, param.getTelegramID());
		// ユースケースID
		paramMap.put(JCMConstants.USECASE_ID_KEY, param.getUsecaseID());
		// オペレーションID
		paramMap.put(JCMConstants.OPERATION_ID_KEY, param.getOperationID());
		// サービス呼び出し区分
		paramMap.put(JCMConstants.CALL_TYPE_KEY, param.getCallType());
		
		// 【取得元：ユーザエリア(コントロールマップ)】
		// 依頼先ホスト名
		paramMap.put(JCMConstants.CLIENT_HOST_NAME_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTNAME));
		// 依頼元IPアドレス
		paramMap.put(JCMConstants.CLIENT_IP_ADDRESS_KEY, param.getControlMapData(SCControlMapKeys.REQ_HOSTIP));
		// 依頼元画面ID
		paramMap.put(JCMConstants.INVOKE_GAMEN_ID_KEY, param.getControlMapData(SCControlMapKeys.REQ_VIEWID));
		// オペレータID
		paramMap.put(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		
		String svcIf = (String)mappingData[0][1];
		
		CAANMsg template = new CAANMsg(String.format("eo.ejb.cbs.cbsmsg.%sCBSMsg", svcIf));
		
		// オペレータID
		template.set(JCMConstants.OPERATOR_ID_KEY, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));
		// 運用日付
		template.set(JCMConstants.OPERATE_DATE_KEY, param.getControlMapData(SCControlMapKeys.OPE_DATE));
		// 運用日時
		template.set(JCMConstants.OPERATE_DATETIME_KEY, param.getControlMapData(SCControlMapKeys.OPE_TIME));
		
		for (int i = 0; i < mappingData.length; i++)
		{
			template = setMsgVal(template, (String)mappingData[i][0], (String)mappingData[i][1]);
		}
		
		CAANMsg[] templates = new CAANMsg[1];
		templates[0] = template;
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);
		return paramMap;
	}
	
	/**
	 * エラー情報を設定します。
	 * 
	 * @param msg
	 * @param map
	 * 
	 */
	@SuppressWarnings("unchecked")
	private void setErrorInf(CAANMsg msg, HashMap<String, Object> map)
	{
		Iterator<String> msgKey = msg.getSchema().getSchemaKeySet().iterator();
		
		while (msgKey.hasNext())
		{
			String key = msgKey.next();
			
			if (key.endsWith("_err"))
			{
				if (!msg.isNull(key))
				{
					if (!map.containsKey(key))
					{
						map.put(key, msg.getString(key));
					}
				}
			}
		}
	}
	
	/**
	 * 値を設定します。
	 * 
	 * @param msg
	 * @param key
	 * @param value
	 * @return CAANMsg
	 */
	private CAANMsg setMsgVal(CAANMsg msg, String key, String value)
	{
		if (value == null || "".equals(value))
		{
			msg.setNull(key);
		}
		else
		{
			msg.set(key, value);
		}
		return msg;
	}
	
	/**
	 * パラメタがNullの場合空白を返却します。
	 * 
	 * @param str
	 *            文字列
	 * @return str
	 */
	private String getNullToStr(String str)
	{
		return JPCUtilCommon.Rtrim(str);
	}
}