/*********************************************************************
*	All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*   モジュール名    ：JKKStdardKojihiPrcChohyoCC
*   ソースファイル名：JKKStdardKojihiPrcChohyoCC.java
*   作成者          ：FJ
*   日付            ：2023年06月23日
*＜機能概要＞
*   工事費総額通知書帳票出力CC部品です。
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v67.00.00	2023/06/23	FJ) 藤本涼	【ANK-4401-00-00】インボイス対応
*	v67.00.01	2023/07/03	FJ) 藤本涼	【ANK-4401-00-00】インボイス対応
*	v67.00.02	2023/07/31	FJ) 田中	【ANK-4401-00-00】インボイス対応
*	v67.00.03	2023/10/02	FJ) 藤本涼	【ANK-4401-00-00】インボイス対応
*	v70.00.00	2024/02/06	FJ) 森本	【ANK-4539-00-00】インボイス対応 STEP3
**********************************************************************/
package com.fujitsu.futurity.bp.custom.common;

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

import com.fujitsu.futurity.bp.custom.constant.JKKStdardKojihiConstCC;
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.AttachmentFileMapKeys;
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.constant.JACStrConst;
import eo.common.constant.JKKStrConst;
import eo.common.constant.JPCModelConstant;
import eo.common.util.JACCommonUtil;
import eo.common.util.JCHCommonFormatUtil;
import eo.common.util.JKKStringUtil;
import eo.common.util.JPCUtilCommon;
import eo.ejb.cbs.cbsmsg.ECC0041A110CBSMsg;
import eo.ejb.cbs.cbsmsg.ECC0041A110CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0081B029CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0081B029CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0321B005CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0321B005CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK0491A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK0491A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EKK3131B070CBSMsg;
import eo.ejb.cbs.cbsmsg.EKK3131B070CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0311A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0311A010CBSMsg1List;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg;
import eo.ejb.cbs.cbsmsg.EZM0321A010CBSMsg1List;

/**
 * 工事費総額通知書発行より呼び出される工事費総額通知書帳票出力CC部品です。<p>
 * <BR>
 * @author FJ
 */
public class JKKStdardKojihiPrcChohyoCC extends AbstractCommonComponent
{

	/** マップID */
	private static final String MAP_ID = "STDARDKOJIHIPRCCHOHYOCC";

	/** テンプレートID(標準工事費総額通知書情報一覧照会) */
	// ANK-4401-00-01 MOD START
	//private static final String TEMPLATE_ID_EKK3511B010 = "EKK3511B010";
	private static final String TEMPLATE_ID_EKK3131B070 = "EKK3131B070";
	// ANK-4401-00-01 MOD END
	/** テンプレートID(請求契約一意照会) */
	private static final String TEMPLATE_ID_EKK0491A010 = "EKK0491A010";
	/** テンプレートID(業務パラメータ管理一意照会照会) */
	private static final String TEMPLATE_ID_EZM0321A010 = "EZM0321A010";
	/** テンプレートID(帳票生成) */
	private static final String TEMPLATE_ID_ECC0041A110 = "ECC0041A110";
	/** テンプレートID(システムパラメータ管理一意照会) */
	private static final String TEMPLATE_ID_EZM0311A010 = "EZM0311A010";
	/** テンプレートID(同一回線内訳サービス契約一覧照会) */
	private static final String TEMPLATE_ID_EKK0081B029 = "EKK0081B029";
	/** テンプレートID(サービス契約一意照会) */
	private static final String TEMPLATE_ID_EKK0081A010 = "EKK0081A010";
	/** テンプレートID(課金先一覧照会（サービス契約番号）) */
	private static final String TEMPLATE_ID_EKK0321B005 = "EKK0321B005";

	/** 帳票定義NO（工事費総額通知書） */
	private static final String CHOHYO_SVCR_NO = "PKKZ00000000012"; 

	/** 改行文字 */
	private static final String LINE_SEP = "line.separator";
	/**  カンマ区切り */
	public static final String CSV = ",";
	/** エスケープ文字 (")  */
	private static final String SINGLE_DBLQUOTE = "\"";

	/** 住所分割文字数(通常) */
	private static final int ADDRESS_NORMAL_LINE_LENGTH = 24;

	/** 住所分割文字数(小さいサイズ) */
	private static final int ADDRESS_SMALL_LINE_LENGTH = 31;

	/** 住所分割数 */
	private static final int ADDRESS_SPLIT_COUNT = 4;

	/** 送付先住所の編集部品の結果 を格納するmapのキー */
	private static final String EDIT_FLG_KEY = "EDIT_FLG";
	/** 送付先住所の編集部品の結果 正常サイズ */
	private static final String EDIT_FLG_NORMAL = "NORMAL";
	/** 送付先住所の編集部品の結果 小さいサイズ */
	private static final String EDIT_FLG_SMALL = "SMALL";

	/** 帳票出力＿お客様名文字数 */
	private static final int CHOHYO_OUT_NAME_LENGTH = 15;

	/** 置換用添え字 業務パラメータ */
	private static final String SOE = "1";

	/** 日付区分（年） */
	private static final String DATE_KBN_YEAR = "1";

	/** 日付区分（月） */
	private static final String DATE_KBN_MON = "2";

	/** 日付区分（日） */
	private static final String DATE_KBN_DAY = "3";

	/** 業務パラメータＩＤ１ */
	private static final String WK_PARA_ID1 = "KK_KJHSGTS_MGN_SGMS";
	/** 業務パラメータＩＤ２ */
	private static final String WK_PARA_ID2 = "KK_KJHSGTS_MGN_SGGK";
	/** 業務パラメータＩＤ３ */
	private static final String WK_PARA_ID3 = "KK_KJHSGTS_MGN_SZGK";

	/** 業務パラメータＩＤ配列 */
	private static final String[] WK_PARA_IDS = new String[] {WK_PARA_ID1, WK_PARA_ID2, WK_PARA_ID3};

	/** 業務パラメータ管理一意明細1 */
	private static final String COL_EZM0321A010LIST1 = "EZM0321A010CBSMsg1List1";
	/** 業務パラメータ管理一意明細2 */
	private static final String COL_EZM0321A010LIST2 = "EZM0321A010CBSMsg1List2";
	/** 業務パラメータ管理一意明細3 */
	private static final String COL_EZM0321A010LIST3 = "EZM0321A010CBSMsg1List3";

	/** 業務パラメータ管理一意明細配列 */
	private static final String[] COL_EZM0321A010LISTS = 
		new String[] {COL_EZM0321A010LIST1, COL_EZM0321A010LIST2, COL_EZM0321A010LIST3};

	/** 金額編集最大桁数 */
	private static final int AMNT_HENSHU_KETA_MAX = 9;

	/** 料金内訳帳票行数 */
	private static final int PRU_CHOHYO_ROW_MAX = 4;

	/**
	 * 工事費総額通知書帳票出力 
	 * @param handle
	 * @param param
	 * @param fixedText
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite outputStdardKojihiPrcChohyo(SessionHandle handle, 
			IRequestParameterReadWrite param, String fixedText) throws Exception
	{
		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_ID);

		if (inMap == null)
		{
			inMap = new HashMap<String, Object>();
			param.setData(MAP_ID, inMap);
		}

		// 機能コード ← 工事費総額通知書帳票マップ．機能コード
		String funcCd = (String)inMap.get(JKKStdardKojihiConstCC.FUNC_CD);
		
		IRequestParameterReadWrite rtnParam = null;

		// 工事費総額通知書情報取得
		getInfoKojihiChohyo(handle, param, fixedText, inMap);

		// ANK-4401-00-01 ADD START
		// 返却パラメータ格納用マップ生成
		Map<String, Object> userResult = new HashMap<String, Object>();

		if (JPCModelConstant.FUNC_CD_3.equals(funcCd))
		{
			// 返却パラメータ編集処理
			makeStdardKojihiPrcTcshoInfo(param, userResult);

			return param;
		}
		// ANK-4401-00-01 ADD END

		// CSV編集処理
		byte[] csvData = makeCSVDataStdardKojihiPrcChohyo(param);

		// 帳票生成処理
		rtnParam = createList(handle, param, csvData, funcCd, CHOHYO_SVCR_NO);

		return rtnParam;
	}

	// ▼▼ 帳票処理 ▼▼

	/**
	 * 工事費総額通知書帳票マップに指定されたキー情報を基に【工事費総額通知書】情報を取得します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param reHakko 再発行フラグ
	 * @return リクエストパラメータ
	 * @throws Exception 例外が発生した場合
	 */
	public IRequestParameterReadWrite getInfoKojihiChohyo(SessionHandle handle, 
			IRequestParameterReadWrite param, String fixedText, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		// ANK-4401-00-01 ADD START
		HashMap<String, Object> parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);
		// ANK-4401-00-01 ADD END

		// 送付先検索用請求契約番号取得処理
		getSohusSeikyKeiNo(handle, param, chohyoReqMap);

		/* ◇標準工事費総額通知書情報一覧照会サービスインターフェイス */
		// ANK-4401-00-00 MOD START
//		execEKK3511B010(handle, param, chohyoReqMap);
		execEKK3131B070(handle, param, chohyoReqMap);
		// ANK-4401-00-00 MOD END

		// ANK-4401-00-01 ADD START
		String seikyKeiNo = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0321B005_SEIKY_KEI_NO);
		if (!JKKStringUtil.isNullBlank(seikyKeiNo))
		{
		// ANK-4401-00-01 ADD END
			/* ◇請求契約一意照会サービスインターフェイス */
			execEKK0491A010(handle, param, chohyoReqMap);
		// ANK-4401-00-01 ADD START
		}
		// ANK-4401-00-01 ADD END

		/* ◇業務パラメータ管理一意照会サービスインターフェイス */
		execEZM0321A010(handle, param, chohyoReqMap);

		/* ◇システムパラメータ管理一意照会サービスインターフェイス */
		execEZM0311A010(handle, param, chohyoReqMap);

		return param;
	}

	/**
	 * 送付先検索用請求契約番号を取得します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param fixedText サービスメッセージ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param reHakko 再発行フラグ
	 * @throws Exception 例外が発生した場合
	 */
	@SuppressWarnings("unchecked")
	public void getSohusSeikyKeiNo(SessionHandle handle, 
			IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		HashMap<String, Object> parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		/* ◇同一回線内訳サービス契約一覧照会サービスインターフェイス */
		execEKK0081B029(handle, param, chohyoReqMap);

		ArrayList childList = (ArrayList)parentMapCC.get("EKK0081B029CBSMsg1List");
		// サービス契約番号
		String svcKeiNo = "";
		// 保持サービス契約番号
		String HojiSvcKeiNo = "";
		// 保持サービスコード
		String HojiSvcCd = "";
		// 保持サービス終了年月日
		String HojiSvcEndYmd = "";

		for (int i = 0; i < childList.size(); i++)
		{
			HashMap<String, Object> svcKeiNoListMap = (HashMap<String, Object>)childList.get(i);

			// サービス契約番号
			svcKeiNo = (String) svcKeiNoListMap.get(JKKStdardKojihiConstCC.EKK0081B029_SVC_KEI_NO);
			/* ◇サービス契約一意照会サービスインターフェイス */
			execEKK0081A010(handle, param, chohyoReqMap, svcKeiNo);

			// サービスコード
			String svcCd = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0081A010_SVC_CD);
			// サービス契約ステータス
			String svcKeiStat = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0081A010_SVC_KEI_STAT);
			// サービス終了年月日
			String svcEndYmd = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0081A010_SVC_ENDYMD);

			// サービスコード = 
			if (JKKStrConst.CD00130_01.equals(svcCd) || JKKStrConst.CD00130_02.equals(svcCd))
			{
				// サービス契約ステータス = "100":サービス提供中、"210":休止・中断中、"220":利用停止中、"910":解約済の場合
				if (JKKStrConst.CD00037_SVCTK_CHU.equals(svcKeiStat) || JKKStrConst.CD00037_STAT_PAUSE.equals(svcKeiStat) || 
						JKKStrConst.CD00037_STAT_STP.equals(svcKeiStat) || JKKStrConst.CD00037_DSL_ZM.equals(svcKeiStat))
				{
					// 保持サービス契約番号が未設定の場合
					if (JKKStringUtil.isNullBlank(HojiSvcKeiNo))
					{
						// 保持サービス契約番号
						HojiSvcKeiNo = svcKeiNo;
						// 保持サービスコード
						HojiSvcCd = svcCd;
						// 保持サービス終了年月日
						HojiSvcEndYmd = svcEndYmd;
						
						continue;
					}
					
					// サービス終了年月日 > 保持サービス終了年月日
					if (JKKStringUtil.nullToBlank(svcEndYmd).compareTo(JKKStringUtil.nullToBlank(HojiSvcEndYmd)) > 0)
					{
						// 保持サービス契約番号
						HojiSvcKeiNo = svcKeiNo;
						// 保持サービスコード
						HojiSvcCd = svcCd;
						// 保持サービス終了年月日
						HojiSvcEndYmd = svcEndYmd;

						continue;
					}
					
					// サービス終了年月日 == 保持サービス終了年月日
					if (JKKStringUtil.nullToBlank(svcEndYmd).compareTo(JKKStringUtil.nullToBlank(HojiSvcEndYmd)) == 0)
					{
						// サービスコード < 保持サービスコード
						if (JKKStringUtil.nullToBlank(svcCd).compareTo(JKKStringUtil.nullToBlank(HojiSvcCd)) < 0)
						{
							// 保持サービス契約番号
							HojiSvcKeiNo = svcKeiNo;
							// 保持サービスコード
							HojiSvcCd = svcCd;
							// 保持サービス終了年月日
							HojiSvcEndYmd = svcEndYmd;

							continue;
						}
					}
				}
			}
		}

		// ANK-4401-00-00 ADD START
		if (!JKKStringUtil.isNullBlank(HojiSvcKeiNo))
		{
		// ANK-4401-00-00 ADD END
			/* ◇課金先一覧照会（サービス契約番号）サービスインターフェイス */
			execEKK0321B005(handle, param, chohyoReqMap, HojiSvcKeiNo);
		// ANK-4401-00-00 ADD START
		}
		// ANK-4401-00-00 ADD END
		
	}

	/**
	 * 同一回線内訳サービス契約一覧照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK0081B029(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEKK0081B029 = editInMsgEKK0081B029(param, chohyoReqMap);
		for (CAANMsg msg : templateEKK0081B029)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEKK0081B029(result, param);
	}

	/**
	 * 同一回線内訳サービス契約一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEKK0081B029(IRequestParameterReadWrite param,
								HashMap<String, Object> chohyoReqMap) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EKK0081B029CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				EKK0081B029CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0081B029, EKK0081B029CBSMsg.FUNC_CODE);

		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		/* ◇業務データの設定 */
		// 機能コード
		
		// ANK-4401-00-00 MOD START
//		template.set(EKK0081B029CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);
		template.set(EKK0081B029CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_3);
		// ANK-4401-00-00 MOD END

		// 帳票出力依頼リストマップ.ＫＥＹ＿サービス契約番号 → ＫＥＹ＿サービス契約番号
		// ANK-4401-00-01 MOD START
		//String svcKeiNo = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_KEY_SVC_KEI_NO);
		String svcKeiNo = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0081B029_KEY_SVC_KEI_NO);
		// ANK-4401-00-01 MOD END
		if (parentMapCC == null || svcKeiNo == null || JACStrConst.KARA_MOJI.equals(svcKeiNo))
		{
			template.setNull(EKK0081B029CBSMsg.KEY_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0081B029CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * 同一回線内訳サービス契約一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0081B029(Map<?, ?> msgList,
			IRequestParameterReadWrite param) 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);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		ArrayList dataList = null;

		templateArray = parentTemplate.getCAANMsgList(EKK0081B029CBSMsg.EKK0081B029CBSMSG1LIST);

		dataList = (ArrayList)dataMap.get("EKK0081B029CBSMsg1List");

		if (dataList == null)
		{
			dataList = new ArrayList();
		}

		int uwSize = templateArray.length;

		if (templateArray != null)
		{
			for (int i = 0; i < uwSize; i++) 
			{
				CAANMsg childTemplate = templateArray[i];
				if (i >= dataList.size()) 
				{
					dataList.add(new HashMap());
				}
				HashMap<String, Object> childMap = (HashMap)dataList.get(i);

				// 同一回線内訳サービス契約一覧照会.サービス契約番号 ← 同一回線内訳サービス契約一覧照会明細.サービス契約番号
				if (childTemplate.isNull(EKK0081B029CBSMsg1List.SVC_KEI_NO)) 
				{
					childMap.put(JKKStdardKojihiConstCC.EKK0081B029_SVC_KEI_NO, new String());
				}
				else 
				{
					childMap.put(JKKStdardKojihiConstCC.EKK0081B029_SVC_KEI_NO, childTemplate.getString(EKK0081B029CBSMsg1List.SVC_KEI_NO));
				}
			}
		}

		dataMap.put("EKK0081B029CBSMsg1List", dataList);

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return param;
	}

	/**
	 * サービス契約一意照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * * @param svcKeiNo リクエスト.サービス契約番号
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK0081A010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap, String svcKeiNo) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEKK0081A010 = editInMsgEKK0081A010(param, chohyoReqMap, svcKeiNo);
		for (CAANMsg msg : templateEKK0081A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEKK0081A010(result, param);
	}

	/**
	 * サービス契約一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param svcKeiNo リクエスト.サービス契約番号
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEKK0081A010(IRequestParameterReadWrite param,
								HashMap<String, Object> chohyoReqMap, String svcKeiNo) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EKK0081A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				EKK0081A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0081A010, EKK0081A010CBSMsg.FUNC_CODE);

		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EKK0081A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// サービス契約一意照会リストマップ.ＫＥＹ＿サービス契約番号 → ＫＥＹ＿サービス契約番号
		if (parentMapCC == null || svcKeiNo == null || JACStrConst.KARA_MOJI.equals(svcKeiNo))
		{
			template.setNull(EKK0081A010CBSMsg.KEY_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0081A010CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);
		}

		// 部品呼び出し → ＫＥＹ＿予約適用年月日
		template.set(EKK0081A010CBSMsg.KEY_RSV_APLY_YMD, JPCBPCommon.getOpeDate(null));

		templateList.add(template);

		return templateList;
	}

	/**
	 * サービス契約一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0081A010(Map<?, ?> msgList,
			IRequestParameterReadWrite param) 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);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(EKK0081A010CBSMsg.EKK0081A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// サービス契約一意照会マップ.サービス契約番号 ← サービス契約一意照会明細.サービス契約番号
				if (childTemplate.isNull(EKK0081A010CBSMsg1List.SVC_KEI_NO))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0081A010_SVC_KEI_NO, new String());
				} 
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0081A010_SVC_KEI_NO, childTemplate.getString(EKK0081A010CBSMsg1List.SVC_KEI_NO));
				}
				// サービス契約一意照会マップ.サービスコード ← サービス契約一意照会明細.サービスコード
				if (childTemplate.isNull(EKK0081A010CBSMsg1List.SVC_CD))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0081A010_SVC_CD, new String());
				} 
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0081A010_SVC_CD, childTemplate.getString(EKK0081A010CBSMsg1List.SVC_CD));
				}
				// サービス契約一意照会マップ.サービス契約ステータス ← サービス契約一意照会明細.サービス契約ステータス
				if (childTemplate.isNull(EKK0081A010CBSMsg1List.SVC_KEI_STAT))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0081A010_SVC_KEI_STAT, new String());
				} 
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0081A010_SVC_KEI_STAT, childTemplate.getString(EKK0081A010CBSMsg1List.SVC_KEI_STAT));
				}
				// サービス契約一意照会マップ.サービス終了年月日 ← サービス契約一意照会明細.サービス終了年月日
				if (childTemplate.isNull(EKK0081A010CBSMsg1List.SVC_ENDYMD))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0081A010_SVC_ENDYMD, new String());
				} 
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0081A010_SVC_ENDYMD, childTemplate.getString(EKK0081A010CBSMsg1List.SVC_ENDYMD));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return param;
	}

	/**
	 * 課金先一覧照会（サービス契約番号）サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * * @param svcKeiNo リクエスト.サービス契約番号
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK0321B005(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap, String svcKeiNo) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEKK0321B005 = editInMsgEKK0321B005(param, chohyoReqMap, svcKeiNo);
		for (CAANMsg msg : templateEKK0321B005)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEKK0321B005(result, param);
	}

	/**
	 * 課金先一覧照会（サービス契約番号）サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param svcKeiNo リクエスト.サービス契約番号
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEKK0321B005(IRequestParameterReadWrite param,
								HashMap<String, Object> chohyoReqMap, String svcKeiNo) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EKK0321B005CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				EKK0321B005CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0321B005, EKK0321B005CBSMsg.FUNC_CODE);

		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EKK0321B005CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 課金先一覧照会（サービス契約番号）リストマップ.ＫＥＹ＿サービス契約番号 → ＫＥＹ＿サービス契約番号
		if (parentMapCC == null || svcKeiNo == null || JACStrConst.KARA_MOJI.equals(svcKeiNo))
		{
			template.setNull(EKK0321B005CBSMsg.KEY_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK0321B005CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);
		}

		templateList.add(template);

		return templateList;
	}

	/**
	 * 課金先一覧照会（サービス契約番号）サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0321B005(Map<?, ?> msgList,
			IRequestParameterReadWrite param) 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);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(EKK0321B005CBSMsg.EKK0321B005CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 課金先一覧照会（サービス契約番号）マップ.請求契約番号 ← 課金先一覧照会（サービス契約番号）明細.請求契約番号
				if (childTemplate.isNull(EKK0321B005CBSMsg1List.SEIKY_KEI_NO))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0321B005_SEIKY_KEI_NO, new String());
				} 
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0321B005_SEIKY_KEI_NO, childTemplate.getString(EKK0321B005CBSMsg1List.SEIKY_KEI_NO));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return param;
	}

	// ANK-4401-00-00 MOD START
	/**
	 * 標準工事費総額通知書情報一覧照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK3131B070(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws Exception
	//private void execEKK3511B010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws Exception
	// ANK-4401-00-00 MOD END
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
	// ANK-4401-00-00 MOD START
//		ArrayList<CAANMsg> templateEKK3511B010 = editInMsgEKK3511B010(param, chohyoReqMap);
//		for (CAANMsg msg : templateEKK3511B010)
		ArrayList<CAANMsg> templateEKK3131B070 = editInMsgEKK3131B070(param, chohyoReqMap);
		for (CAANMsg msg : templateEKK3131B070)
	// ANK-4401-00-00 MOD END
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		// ANK-4401-00-00 MOD START
//		editOutMsgEKK3511B010(result, param);
		editOutMsgEKK3131B070(result, param);
		// ANK-4401-00-00 MOD END
	}

	// ANK-4401-00-00 MOD START
	/**
	 * 標準工事費総額通知書情報一覧照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEKK3131B070(IRequestParameterReadWrite param,
								HashMap<String, Object> chohyoReqMap) throws RequestParameterException
//	private ArrayList<CAANMsg> editInMsgEKK3511B010(IRequestParameterReadWrite param,
//								HashMap<String, Object> chohyoReqMap) throws RequestParameterException
	// ANK-4401-00-00 MOD END
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// ANK-4401-00-01 MOD START
//		/* ◇ユーザデータ情報 */
//		CAANMsg template = new CAANMsg(EKK3511B010CBSMsg.class.getName());
//		this.setTemplateCommonItem(param, template, 
//				EKK3511B010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK3511B010, EKK3511B010CBSMsg.FUNC_CODE);
//
//		HashMap<String, Object> parentMapCC = null;
//		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);
//
//		/* ◇業務データの設定 */
//		// 機能コード
//		template.set(EKK3511B010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);
//
//		// 帳票出力依頼リストマップ.ＫＥＹ＿サービス契約番号 → ＫＥＹ＿サービス契約番号
//		String svcKeiNo = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_KEY_SVC_KEI_NO);
//		if (parentMapCC == null || svcKeiNo == null || JACStrConst.KARA_MOJI.equals(svcKeiNo))
//		{
//			template.setNull(EKK3511B010CBSMsg.KEY_SVC_KEI_NO);
//		}
//		else
//		{
//			template.set(EKK3511B010CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);
//		}
		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EKK3131B070CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				EKK3131B070CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK3131B070, EKK3131B070CBSMsg.FUNC_CODE);

		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EKK3131B070CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// 帳票出力依頼リストマップ.ＫＥＹ＿サービス契約番号 → ＫＥＹ＿サービス契約番号
		String svcKeiNo = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_KEY_SVC_KEI_NO);
		if (parentMapCC == null || svcKeiNo == null || JACStrConst.KARA_MOJI.equals(svcKeiNo))
		{
			template.setNull(EKK3131B070CBSMsg.KEY_SVC_KEI_NO);
		}
		else
		{
			template.set(EKK3131B070CBSMsg.KEY_SVC_KEI_NO, svcKeiNo);
		}
		// ANK-4401-00-01 MOD END

		templateList.add(template);

		return templateList;
	}

	// ANK-4401-00-00 MOD START
	/**
	 * 標準工事費総額通知書情報一覧照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK3131B070(Map<?, ?> msgList,
			IRequestParameterReadWrite param) throws Exception
//	private IRequestParameterReadWrite editOutMsgEKK3511B010(Map<?, ?> msgList,
//			IRequestParameterReadWrite param) throws Exception
	// ANK-4401-00-00 MOD END
	{

		// 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);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		
		// ANK-4401-00-00 MOD START
//		templateArray = parentTemplate.getCAANMsgList(EKK3511B010CBSMsg.EKK3511B010CBSMSG1LIST);
//		if (templateArray != null)
//		{
//			for (int i = 0; i < templateArray.length; i++)
//			{
//				CAANMsg childTemplate = templateArray[i];
//
//				// 工事費総額通知書マップ.申込番号 ← 標準工事費総額通知書情報一覧照会明細.申込番号
//				if (childTemplate.isNull(EKK3511B010CBSMsg1List.MSKM_NO))
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_MSKM_NO, new String());
//				} 
//				else
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_MSKM_NO, childTemplate.getString(EKK3511B010CBSMsg1List.MSKM_NO));
//				}
//				// 工事費総額通知書マップ.工事完了年月日 ← 標準工事費総額通知書情報一覧照会明細.工事完了年月日
//				if (childTemplate.isNull(EKK3511B010CBSMsg1List.KOJI_FIN_YMD))
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_KOJI_FIN_YMD, new String());
//				}
//				else 
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_KOJI_FIN_YMD, childTemplate.getString(EKK3511B010CBSMsg1List.KOJI_FIN_YMD));
//				}
//				// 工事費総額通知書マップ.標準工事費総額(明細)・金額 ← 標準工事費総額通知書情報一覧照会明細.標準工事費総額(明細)・金額
//				if (childTemplate.isNull(EKK3511B010CBSMsg1List.STDARD_KOJIHI_DTL_PRC))
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_STDARD_KOJIHI_DTL_PRC, new String());
//				} 
//				else
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_STDARD_KOJIHI_DTL_PRC, childTemplate.getString(EKK3511B010CBSMsg1List.STDARD_KOJIHI_DTL_PRC));
//				}
//				// 工事費総額通知書マップ.標準工事費総額(合計)・金額 ← 標準工事費総額通知書情報一覧照会明細.標準工事費総額(合計)・金額
//				if (childTemplate.isNull(EKK3511B010CBSMsg1List.STDARD_KOJIHI_GK_PRC))
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_STDARD_KOJIHI_GK_PRC, new String());
//				} 
//				else 
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_STDARD_KOJIHI_GK_PRC, childTemplate.getString(EKK3511B010CBSMsg1List.STDARD_KOJIHI_GK_PRC));
//				}
//				// 工事費総額通知書マップ.消費税合計額・税率 ← 標準工事費総額通知書情報一覧照会明細.消費税合計額・税率
//				if (childTemplate.isNull(EKK3511B010CBSMsg1List.STAX_GK_RT))
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_STAX_GK_RT, new String());
//				}
//				else
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_STAX_GK_RT, childTemplate.getString(EKK3511B010CBSMsg1List.STAX_GK_RT));
//				}
//				// 工事費総額通知書マップ.消費税合計額・金額 ← 標準工事費総額通知書情報一覧照会明細.消費税合計額・金額
//				if (childTemplate.isNull(EKK3511B010CBSMsg1List.STAX_GK_PRC)) 
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_STAX_GK_PRC, new String());
//				}
//				else
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_STAX_GK_PRC, childTemplate.getString(EKK3511B010CBSMsg1List.STAX_GK_PRC));
//				}
//				// ANK-4401-00-01 ADD START
//				// 工事費総額通知書マップ.サービス契約回線内訳番号 ← 標準工事費総額通知書情報一覧照会明細.サービス契約回線内訳番号
//				if (childTemplate.isNull(EKK3511B010CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO))
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_SVC_KEI_KAISEN_UCWK_NO, new String());
//				} 
//				else
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_SVC_KEI_KAISEN_UCWK_NO, childTemplate.getString(EKK3511B010CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO));
//				}
//				// 工事費総額通知書マップ.割賦販売形態コード ← 標準工事費総額通知書情報一覧照会明細.割賦販売形態コード
//				if (childTemplate.isNull(EKK3511B010CBSMsg1List.KAP_HAMBAI_FORM_CD))
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_KAP_HAMBAI_FORM_CD, new String());
//				} 
//				else
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_KAP_HAMBAI_FORM_CD, childTemplate.getString(EKK3511B010CBSMsg1List.KAP_HAMBAI_FORM_CD));
//				}
//				// 工事費総額通知書マップ.割賦契約課金開始年月日 ← 標準工事費総額通知書情報一覧照会明細.割賦契約課金開始年月日
//				if (childTemplate.isNull(EKK3511B010CBSMsg1List.KAP_KEI_CHRG_STAYMD))
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_KAP_KEI_CHRG_STAYMD, new String());
//				} 
//				else
//				{
//					dataMap.put(JKKStdardKojihiConstCC.EKK3511B010_KAP_KEI_CHRG_STAYMD, childTemplate.getString(EKK3511B010CBSMsg1List.KAP_KEI_CHRG_STAYMD));
//				}
//				// ANK-4401-00-01 ADD END
//			}
//		}
		templateArray = parentTemplate.getCAANMsgList(EKK3131B070CBSMsg.EKK3131B070CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 工事費総額通知書マップ.申込番号 ← 標準工事費総額通知書情報一覧照会明細.申込番号
				if (childTemplate.isNull(EKK3131B070CBSMsg1List.MSKM_NO))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_MSKM_NO, new String());
				} 
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_MSKM_NO, childTemplate.getString(EKK3131B070CBSMsg1List.MSKM_NO));
				}
				// 工事費総額通知書マップ.工事完了年月日 ← 標準工事費総額通知書情報一覧照会明細.工事完了年月日
				if (childTemplate.isNull(EKK3131B070CBSMsg1List.KOJI_FIN_YMD))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_KOJI_FIN_YMD, new String());
				}
				else 
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_KOJI_FIN_YMD, childTemplate.getString(EKK3131B070CBSMsg1List.KOJI_FIN_YMD));
				}
				// 工事費総額通知書マップ.標準工事費総額(明細)・金額 ← 標準工事費総額通知書情報一覧照会明細.標準工事費総額(明細)・金額
				if (childTemplate.isNull(EKK3131B070CBSMsg1List.STDARD_KOJIHI_DTL_PRC))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_STDARD_KOJIHI_DTL_PRC, new String());
				} 
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_STDARD_KOJIHI_DTL_PRC, childTemplate.getString(EKK3131B070CBSMsg1List.STDARD_KOJIHI_DTL_PRC));
				}
				// 工事費総額通知書マップ.標準工事費総額(合計)・金額 ← 標準工事費総額通知書情報一覧照会明細.標準工事費総額(合計)・金額
				if (childTemplate.isNull(EKK3131B070CBSMsg1List.STDARD_KOJIHI_GK_PRC))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_STDARD_KOJIHI_GK_PRC, new String());
				} 
				else 
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_STDARD_KOJIHI_GK_PRC, childTemplate.getString(EKK3131B070CBSMsg1List.STDARD_KOJIHI_GK_PRC));
				}
				// 工事費総額通知書マップ.消費税合計額・税率 ← 標準工事費総額通知書情報一覧照会明細.消費税合計額・税率
				if (childTemplate.isNull(EKK3131B070CBSMsg1List.STAX_GK_RT))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_STAX_GK_RT, new String());
				}
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_STAX_GK_RT, childTemplate.getString(EKK3131B070CBSMsg1List.STAX_GK_RT));
				}
				// 工事費総額通知書マップ.消費税合計額・金額 ← 標準工事費総額通知書情報一覧照会明細.消費税合計額・金額
				if (childTemplate.isNull(EKK3131B070CBSMsg1List.STAX_GK_PRC)) 
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_STAX_GK_PRC, new String());
				}
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_STAX_GK_PRC, childTemplate.getString(EKK3131B070CBSMsg1List.STAX_GK_PRC));
				}
				// 工事費総額通知書マップ.サービス契約回線内訳番号 ← 標準工事費総額通知書情報一覧照会明細.サービス契約回線内訳番号
				if (childTemplate.isNull(EKK3131B070CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_SVC_KEI_KAISEN_UCWK_NO, new String());
				} 
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_SVC_KEI_KAISEN_UCWK_NO, childTemplate.getString(EKK3131B070CBSMsg1List.SVC_KEI_KAISEN_UCWK_NO));
				}
				// 工事費総額通知書マップ.割賦販売形態コード ← 標準工事費総額通知書情報一覧照会明細.割賦販売形態コード
				if (childTemplate.isNull(EKK3131B070CBSMsg1List.KAP_HAMBAI_FORM_CD))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_KAP_HAMBAI_FORM_CD, new String());
				} 
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_KAP_HAMBAI_FORM_CD, childTemplate.getString(EKK3131B070CBSMsg1List.KAP_HAMBAI_FORM_CD));
				}
				// 工事費総額通知書マップ.割賦契約課金開始年月日 ← 標準工事費総額通知書情報一覧照会明細.割賦契約課金開始年月日
				if (childTemplate.isNull(EKK3131B070CBSMsg1List.KAP_KEI_CHRG_STAYMD))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_KAP_KEI_CHRG_STAYMD, new String());
				} 
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK3131B070_KAP_KEI_CHRG_STAYMD, childTemplate.getString(EKK3131B070CBSMsg1List.KAP_KEI_CHRG_STAYMD));
				}
			}
		}
		// ANK-4401-00-00 MOD END

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return param;
	}

	/**
	 * 請求契約一意照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEKK0491A010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEKK0491A010 = editInMsgEKK0491A010(param, chohyoReqMap);
		for (CAANMsg msg : templateEKK0491A010)
		{
			templateList.add(msg);
		}
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEKK0491A010(result, param);
	}

	/**
	 * 請求契約一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEKK0491A010(IRequestParameterReadWrite param,
								HashMap<String, Object> chohyoReqMap) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EKK0491A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				EKK0491A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EKK0491A010, EKK0491A010CBSMsg.FUNC_CODE);

		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EKK0491A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// 帳票出力依頼リストマップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号
		String seikyKeiNo = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0321B005_SEIKY_KEI_NO);
		if (parentMapCC == null || seikyKeiNo == null || JACStrConst.KARA_MOJI.equals(seikyKeiNo))
		{
			template.setNull(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO);
		}
		else
		{
			template.set(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO, seikyKeiNo);
		}

		// NULL → ＫＥＹ＿世代登録年月日時分秒
		template.setNull(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM);

		// 部品呼び出し → ＫＥＹ＿予約適用年月日
		template.set(EKK0491A010CBSMsg.KEY_RSV_APLY_YMD, JPCBPCommon.getOpeDate(null));

		templateList.add(template);

		return templateList;
	}

	/**
	 * テンプレートの共通項目を設定します。
	 * <br>
	 * @param param リクエストパラメータ
	 * @param template テンプレート
	 * @param templateIdKey テンプレートIDキー名
	 * @param templateIdVal テンプレートID値
	 * @param templateFuncCdKey テンプレート機能コードキー名
	 * @return template
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	private CAANMsg setTemplateCommonItem(IRequestParameterReadWrite param, CAANMsg template, 
											String templateIdKey, String templateIdVal, String templateFuncCdKey) throws RequestParameterException
	{
		// テンプレートID
		template.set(templateIdKey, templateIdVal);

		// 機能コード（デフォルト：１）
		template.set(templateFuncCdKey, JPCModelConstant.FUNC_CD_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);

		return template;
	}

	/**
	 * 請求契約一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEKK0491A010(Map<?, ?> msgList,
			IRequestParameterReadWrite param) 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);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(EKK0491A010CBSMsg.EKK0491A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// ANK-4539-00-00 ADD START
				// 通信サービス料金マップ.請求契約番号 ← 請求契約一意照会明細.請求契約番号
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SEIKY_KEI_NO))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SEIKY_KEI_NO, new String());
				} 
				else 
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SEIKY_KEI_NO, childTemplate.getString(EKK0491A010CBSMsg1List.SEIKY_KEI_NO));
				}
				// ANK-4539-00-00 ADD END
				// 通信サービス料金マップ.送付先名 ← 請求契約一意照会明細.送付先名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_NM))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_NM, new String());
				} 
				else 
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_NM));
				}
				// 通信サービス料金マップ.送付先部課名 ← 請求契約一意照会明細.送付先部課名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_BKM))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_BKM, new String());
				} 
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_BKM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_BKM));
				}
				// 通信サービス料金マップ.送付先担当者名 ← 請求契約一意照会明細.送付先担当者名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_TNTSHA_NM))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_TNTSHA_NM, new String());
				}
				else 
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_TNTSHA_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_TNTSHA_NM));
				}
				// 通信サービス料金マップ.送付先郵便番号 ← 請求契約一意照会明細.送付先郵便番号
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_PCD))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_PCD, new String());
				} 
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_PCD, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_PCD));
				}
				// 通信サービス料金マップ.送付先都道府県名 ← 請求契約一意照会明細.送付先都道府県名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_STATE_NM))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_STATE_NM, new String());
				} 
				else 
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_STATE_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_STATE_NM));
				}
				// 通信サービス料金マップ.送付先市区町村名 ← 請求契約一意照会明細.送付先市区町村名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_CITY_NM))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_CITY_NM, new String());
				}
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_CITY_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_CITY_NM));
				}
				// 通信サービス料金マップ.送付先大字通称名 ← 請求契約一意照会明細.送付先大字通称名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_OAZTSU_NM)) 
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_OAZTSU_NM, new String());
				}
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_OAZTSU_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_OAZTSU_NM));
				}
				// 通信サービス料金マップ.送付先字丁目名 ← 請求契約一意照会明細.送付先字丁目名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_AZCHO_NM))
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_AZCHO_NM, new String());
				} 
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_AZCHO_NM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_AZCHO_NM));
				}
				// 通信サービス料金マップ.送付先住所補記・建物名 ← 請求契約一意照会明細.送付先住所補記・建物名
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_ADRTTM)) 
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_ADRTTM, new String());
				}
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_ADRTTM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_ADRTTM));
				}
				// 通信サービス料金マップ.送付先住所補記・部屋番号 ← 請求契約一意照会明細.送付先住所補記・部屋番号
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_ADRRM)) 
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_ADRRM, new String());
				}
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_ADRRM, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_ADRRM));
				}
				// 通信サービス料金マップ.送付先番地号 ← 請求契約一意照会明細.送付先番地号
				if (childTemplate.isNull(EKK0491A010CBSMsg1List.SOHUS_BNCHIGO)) 
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_BNCHIGO, new String());
				}
				else
				{
					dataMap.put(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_BNCHIGO, childTemplate.getString(EKK0491A010CBSMsg1List.SOHUS_BNCHIGO));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

		//エラー情報のマップを取得
		ArrayList<Object> errList = (ArrayList<Object>)param.getControlMapData(SCControlMapKeys.ERROR_INFO);
		if(errList == null)
		{
			errList = new ArrayList<Object>();
		}
		// コントロールマップに設定
		param.setControlMapData(SCControlMapKeys.ERROR_INFO, TemplateErrorUtil.getErrorInfo(msgList, errList));

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return param;
	}

	/**
	 * 業務パラメータ管理一意照会サービスインタフェイスを実行します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @throws Exception 例外が発生した場合
	 */
	private void execEZM0321A010(SessionHandle handle, IRequestParameterReadWrite param, HashMap<String, Object> chohyoReqMap) throws Exception
	{
		// 料金内訳出力の業務パラメータ設定値を取得し、inMapにセットする。
		// 上りマッピングの処理結果を取得するためのマップを生成
		HashMap<String, Object> paramMap = new HashMap<String, Object>();

		// SC実行結果を格納するマップ
		Map<?, ?> result = null;

		// サービスI/F実行するサービスを生成
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();

		// 上りマッピング
		paramMap = editInMsgEZM0321A010(param);

		// ＳＣ呼出実行
		result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEZM0321A010(result, param, chohyoReqMap);
	}

	/**
	 * 上りマッピング（業務パラメータ管理一意照会）
	 * 
	 * @param param リクエストパラメータ
	 * @param workParamId 業務パラメータＩＤ
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	private HashMap<String, Object> editInMsgEZM0321A010(IRequestParameterReadWrite param) throws RequestParameterException
	{
		// 共通領域の設定
		HashMap<String, Object> paramMap = editInMsg(param);

		// テンプレート配列の作成
		CAANMsg[] templates = new CAANMsg[WK_PARA_IDS.length];
		
		// 業務パラメータ数分繰り返す
		for (int i = 0; i < WK_PARA_IDS.length; i++)
		{
			// 業務パラメータを取得
			String wkParaId = WK_PARA_IDS[i];

			// テンプレートを作成
			CAANMsg template = new CAANMsg(EZM0321A010CBSMsg.class.getName());

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

			// 機能コード
			template.set(EZM0321A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

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

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

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

			// 業務パラメータＩＤ → 業務パラメータ管理一意照会.業務パラメータＩＤ
			if (JKKBpCommon.isNull(wkParaId))
			{
				template.setNull(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID);
			}
			else
			{
				template.set(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID, wkParaId);
			}
		
			// テンプレート配列にテンプレートを格納
			templates[i] = template;
		}
		
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		return paramMap;
	}

	/**
	 * 下りマッピング（業務パラメータ管理一意照会）
	 * 
	 * @param msgList
	 * @param param リクエストパラメータ
	 * @param dataMap
	 * 
	 * @return IRequestParameterReadWrite
	 * 
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEZM0321A010(Map<?, ?> msgList,
																		IRequestParameterReadWrite param,
																		HashMap<String, Object> dataMap) throws Exception
	{
		// SCからの戻り値からCAANMsgを取得する
		CAANMsg[] templates = (CAANMsg[])msgList.get(JCMConstants.TEMPLATE_LIST_KEY);
		
		// リターンコード取得
		Object returnCode = msgList.get(JCMConstants.RET_CD_INT_KEY);
		
		// エラー情報の設定
		IRequestParameterReadWrite retParam = this.editErrorInfoEZM0321A010(param, dataMap, templates, (Integer)returnCode);
		
		//エラー情報のマップを取得
		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));
		
		/* ◇処理結果の判定 */
		//取得したリターンコード、ステータスの内容を見て異常かどうかの判断をする。
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		
		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}
		
		for (int i = 0; i < COL_EZM0321A010LISTS.length; i++)
		{
			ArrayList resultList = new ArrayList();
			dataMap.put(COL_EZM0321A010LISTS[i], resultList);
			CAANMsg[] msg1List = templates[i].getCAANMsgList(EZM0321A010CBSMsg.EZM0321A010CBSMSG1LIST);
		
			if (msg1List != null)
			{
				// 業務パラメータ管理一意明細件数分繰り返す
				for (CAANMsg msg : msg1List)
				{
					HashMap resultMap = new HashMap();
					resultList.add(resultMap);
			
					// 業務パラメータＩＤ ← 業務パラメータ管理一意明細.業務パラメータＩＤ
					resultMap.put(EZM0321A010CBSMsg1List.WORK_PARAM_ID, msg.getString(EZM0321A010CBSMsg1List.WORK_PARAM_ID));

					// 業務パラメータ設定値 ← 業務パラメータ管理一意明細.業務パラメータ設定値
					resultMap.put(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE, msg.getString(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE));
				}
			}
		}
		
		return retParam;
	}

	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * 
	 * @param param リクエストパラメータ
	 * @param inMap 入力情報
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	private IRequestParameterReadWrite editErrorInfoEZM0321A010(IRequestParameterReadWrite param, 
																	HashMap<String, Object> inMap,
																	CAANMsg[] templates,
																	int returnCode) throws RequestParameterException
	{
		for (int i = 0; i < templates.length; i++)
		{
		CAANMsg template = templates[i];

			int templateStatus = template.getInt(EZM0321A010CBSMsg.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);
			}
		
			// イベントコードエラー → 業務パラメータ管理一意照会.業務パラメータＩＤエラー
			if (!template.isNull(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID_ERR))
			{
				if (!inMap.containsKey(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID_ERR))
				{
					inMap.put(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID_ERR, template.getString(EZM0321A010CBSMsg.KEY_WORK_PARAM_ID_ERR));
				}
			}
		}
		
		return param;
	}

	/**
	 * 帳票生成処理
	 * @param handle
	 * @param param
	 * @param csvData
	 * @param funcCd
	 * @param chohyoTeigiNo
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite createList(SessionHandle handle, 
			IRequestParameterReadWrite param, byte[] csvData, String funcCd, String chohyoTeigiNo) throws Exception
	{
		if(!JPCModelConstant.FUNC_CD_1.equals(funcCd))
		{
			return param;
		}

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

		// リクエストパラメータ作成
		HashMap<String, Object> parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		String userId = parentMapCC.get(JKKStdardKojihiConstCC.ECC0041A110_USER_ID).toString();

		parentMapCC.put(JKKStdardKojihiConstCC.ECC0041A110_CHOHYO_TEIGI_NO, chohyoTeigiNo);
		parentMapCC.put(JKKStdardKojihiConstCC.ECC0041A110_DATA_FILE, (byte[])csvData);
		parentMapCC.put(JKKStdardKojihiConstCC.ECC0041A110_USER_ID, userId);
		// 帳票形成処理種別："1"（PDF形式）
		parentMapCC.put(JKKStdardKojihiConstCC.ECC0041A110_TRAN_SBT, "1");

		/*
		 * 上りマッピング処理
		 */
		paramMap = editInMsg(param);

		/*
		 * ＳＣ呼出実行
		 */
		// SC呼び出し部品のインスタンス生成（引数にはログに出力するクラス名を渡す。空文字を設定した場合はログに出力されない。
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		/*
		 * 下りマッピング処理
		 */
		IRequestParameterReadWrite rtnParam = editOutMsg(result, param);

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

		// 異常の場合、SCCallExceptionを生成してスローする
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status))) 
		{
			SCCallException scCallEx = new SCCallException("INVALID_RETURN_MESSAGE", rtnCode, Integer.parseInt(status));
			throw scCallEx;
		}

		return rtnParam;
	}

	/**
	 * 帳票生成処理用メッセージ設定処理
	 * @param param
	 * @param csvData
	 * @return HashMap<String, Object>
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, Object> editInMsg(IRequestParameterReadWrite param) throws RequestParameterException
	{
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);

		/* ユーザデータ情報 */
		HashMap inMap = (HashMap)param.getData(MAP_ID);

		CAANMsg template = new CAANMsg(ECC0041A110CBSMsg.class.getName());
		// テンプレートID
		template.set(ECC0041A110CBSMsg.TEMPLATEID, TEMPLATE_ID_ECC0041A110);

		// 機能コード
		template.set(ECC0041A110CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_2);

		// 検索処理パターン
		template.setNull(ECC0041A110CBSMsg.SEARCH_TYPE);

		// 最大検索件数
		template.setNull(ECC0041A110CBSMsg.MAX_SEARCH_NUM);

		// 表示件数
		template.setNull(ECC0041A110CBSMsg.DISPLAY_NUM);

		// 表示ページ番号
		template.setNull(ECC0041A110CBSMsg.DISPLAY_PAGE_NUM);

		// オペレータID
		template.set(ECC0041A110CBSMsg.OPERATORID, param.getControlMapData(SCControlMapKeys.OPERATOR_ID));

		// 運用日付
		template.set(ECC0041A110CBSMsg.OPERATEDATE, param.getControlMapData(SCControlMapKeys.OPE_DATE));

		// 運用日時
		template.set(ECC0041A110CBSMsg.OPERATEDATETIME,  param.getControlMapData(SCControlMapKeys.OPE_TIME));


		// ◇業務データの設定
		// 帳票定義体の電子ファイル管理番号
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JKKStdardKojihiConstCC.ECC0041A110_CHOHYO_TEIGI_NO))) 
		{
			template.setNull(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO, inMap.get(JKKStdardKojihiConstCC.ECC0041A110_CHOHYO_TEIGI_NO));
		}
		
		// データファイルの電子ファイル管理番号
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JKKStdardKojihiConstCC.ECC0041A110_DATA_FILE_NO))) 
		{
			template.setNull(ECC0041A110CBSMsg.DATA_FILE_NO);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.DATA_FILE_NO, inMap.get(JKKStdardKojihiConstCC.ECC0041A110_DATA_FILE_NO));
		}
		
		// データファイル
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JKKStdardKojihiConstCC.ECC0041A110_DATA_FILE))) 
		{
			template.setNull(ECC0041A110CBSMsg.DATA_FILE);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.DATA_FILE, inMap.get(JKKStdardKojihiConstCC.ECC0041A110_DATA_FILE));
		}

		// ユーザーID
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JKKStdardKojihiConstCC.ECC0041A110_USER_ID))) 
		{
			template.setNull(ECC0041A110CBSMsg.USER_ID);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.USER_ID, inMap.get(JKKStdardKojihiConstCC.ECC0041A110_USER_ID));
		}
		
		// 処理種別
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JKKStdardKojihiConstCC.ECC0041A110_TRAN_SBT))) 
		{
			template.setNull(ECC0041A110CBSMsg.TRAN_SBT);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.TRAN_SBT, inMap.get(JKKStdardKojihiConstCC.ECC0041A110_TRAN_SBT));
		}
		// 帳票出力環境識別コード
		if (JACStrConst.KARA_MOJI.equals(inMap.get(JKKStdardKojihiConstCC.ECC0041A110_CHOHYO_OPUT_ENV_SKBT_CD))) 
		{
			template.setNull(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD);
		}
		else
		{
			template.set(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD, inMap.get(JKKStdardKojihiConstCC.ECC0041A110_CHOHYO_OPUT_ENV_SKBT_CD));
		}

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

		return paramMap;
	}

	/**
	 * 帳票生成処理用メッセージ取得処理
	 * @param msgList
	 * @param param
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsg(Map<?, ?> msgList, IRequestParameterReadWrite param) 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);

		// 結果を詰めるマップを取得。
		HashMap<String, Object> dataMap = null;
		ArrayList dataList = null;

		/* 業務データ設定 */
		dataMap = (HashMap<String, Object>)param.getData(MAP_ID);

		if(dataMap == null) 
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		// 検索系 共通部
		dataMap.put(JKKStdardKojihiConstCC.ECC0041A110_TOTAL_SEARCH_NUM, parentTemplate.getString("total_search_num"));
		dataMap.put(JKKStdardKojihiConstCC.ECC0041A110_TOTAL_PAGE_NUM, parentTemplate.getString("total_page_num"));
		dataMap.put(JKKStdardKojihiConstCC.ECC0041A110_SEARCH_ERR_FLG, parentTemplate.getString("search_err_flg"));

		templateArray = parentTemplate.getCAANMsgList(ECC0041A110CBSMsg.ECC0041A110CBSMSG1LIST);
		dataList = (ArrayList)dataMap.get("ECC0041A110CBSMsg1List");

		if (dataList == null) 
		{
			dataList = new ArrayList();
		}

		int dataListNum = dataList.size();

		if (templateArray != null) 
		{
			for(int i = 0; i < templateArray.length; i++) 
			{
				CAANMsg childTemplate = templateArray[i];
				if(i >= dataList.size() - dataListNum)
				{
					dataList.add(new HashMap<String, Object>());
				}
				HashMap<String, Object> childMap = (HashMap<String, Object>)dataList.get(i + dataListNum);

				if (childTemplate.isNull(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO)) 
				{
					childMap.put(JKKStdardKojihiConstCC.ECC0041A110_OUTPUT_CHOHYO, new byte[0]);
				} 
				else
				{
					// byte配列の場合は添付ファイルエリアに格納する
					HashMap<Object, Object> map = new HashMap<Object, Object>();
					ArrayList<HashMap> list = (ArrayList)param.getControlMapData(SCControlMapKeys.ATTACHMENT_FILE_DOWN);
					if (list == null)
					{
						list = new  ArrayList<HashMap>();
					}
					
					map.put(AttachmentFileMapKeys.IDENTIFY_CD, MAP_ID);
					map.put(AttachmentFileMapKeys.LIST_NAME, "ECC0041A110CBSMsg1List");
					map.put(AttachmentFileMapKeys.ITEM_NAME, JKKStdardKojihiConstCC.ECC0041A110_OUTPUT_CHOHYO);
					map.put(AttachmentFileMapKeys.INDEX, Integer.toString(i));
					map.put(AttachmentFileMapKeys.FILE, childTemplate.getObject(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO));
					list.add(map);
					param.setControlMapData(SCControlMapKeys.ATTACHMENT_FILE_DOWN, list);
				}


				if (childTemplate.isNull(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO_NM)) 
				{
					childMap.put(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO_NM, JACStrConst.KARA_MOJI);
				} 
				else 
				{
					childMap.put(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO_NM, childTemplate.getString(ECC0041A110CBSMsg1List.OUTPUT_CHOHYO_NM));
				}
				
				if (childTemplate.isNull(ECC0041A110CBSMsg1List.SEND_RESULT_CD)) 
				{
					childMap.put(ECC0041A110CBSMsg1List.SEND_RESULT_CD, JACStrConst.KARA_MOJI);
				} 
				else 
				{
					childMap.put(ECC0041A110CBSMsg1List.SEND_RESULT_CD, childTemplate.getString(ECC0041A110CBSMsg1List.SEND_RESULT_CD));
				}
			}
		}
		dataMap.put("ECC0041A110CBSMsg1List", dataList);

		// エラー情報の設定
		IRequestParameterReadWrite rtnParam = editErrorInfo(param, templates, (Integer)return_code);

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

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

		return rtnParam;
	}

	/**
	 * サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	public IRequestParameterReadWrite editErrorInfo(IRequestParameterReadWrite param, 
									CAANMsg[] templates, int returnCode) throws RequestParameterException
	{

		for (CAANMsg template : templates)
		{
			String templateId = template.getString("templateID");
			CAANMsg[] workTemplates = { template };

			// ANK-4401-00-01 MOD START
			//if (TEMPLATE_ID_EKK3511B010.equals(templateId))
			if (TEMPLATE_ID_EKK3131B070.equals(templateId))
			// ANK-4401-00-01 MOD END
			{
				// 標準工事費総額通知書情報一覧照会
				// ANK-4401-00-00 MOD START
//				editErrorInfoEKK3511B010(param, workTemplates, returnCode);
				editErrorInfoEKK3131B070(param, workTemplates, returnCode);
				// ANK-4401-00-00 MOD START
			}
			else if (TEMPLATE_ID_EKK0491A010.equals(templateId))
			{
				// 請求契約一意照会
				editErrorInfoEKK0491A010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EZM0311A010.equals(templateId))
			{
				// システムパラメータ管理一意照会
				editErrorInfoEZM0311A010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_ECC0041A110.equals(templateId))
			{
				// 帳票生成
				editErrorInfoECC0041A110(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EKK0081B029.equals(templateId))
			{
				// 同一回線内訳サービス契約一覧照会
				editErrorInfoEKK0081B029(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EKK0081A010.equals(templateId))
			{
				// サービス契約一意照会
				editErrorInfoEKK0081A010(param, workTemplates, returnCode);
			}
			else if (TEMPLATE_ID_EKK0321B005.equals(templateId))
			{
				// 課金先一覧照会（サービス契約番号）
				editErrorInfoEKK0321B005(param, workTemplates, returnCode);
			}
		}

		return param;
	}

	// ANK-4401-00-00 MOD START
	/**
	 * 標準工事費総額通知書情報一覧照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoEKK3131B070(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
//	public IRequestParameterReadWrite editErrorInfoEKK3511B010(IRequestParameterReadWrite param
//			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	// ANK-4401-00-00 MOD END
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0491A010CBSMsg.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);
		}

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_ID);

		// 標準工事費総額通知書情報一覧照会マップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号 のエラー情報返却
		// ANK-4401-00-01 MOD START
		//if (!template.isNull(EKK3511B010CBSMsg.KEY_SVC_KEI_NO_ERR))
		//{
		//	if (!inMap.containsKey(EKK3511B010CBSMsg.KEY_SVC_KEI_NO_ERR))
		//	{
		//		inMap.put(EKK3511B010CBSMsg.KEY_SVC_KEI_NO_ERR, template.getString(EKK3511B010CBSMsg.KEY_SVC_KEI_NO_ERR));
		//	}
		//}
		if (!template.isNull(EKK3131B070CBSMsg.KEY_SVC_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EKK3131B070CBSMsg.KEY_SVC_KEI_NO_ERR))
			{
				inMap.put(EKK3131B070CBSMsg.KEY_SVC_KEI_NO_ERR, template.getString(EKK3131B070CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
		// ANK-4401-00-01 MOD END

		return param;
	}

	/**
	 * 請求契約一意照会サービスIF実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param リクエストパラメータ
	 * @param templates テンプレート
	 * @param returnCode リターンコード
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoEKK0491A010(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0491A010CBSMsg.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);
		}

		HashMap<String, Object> inMap = (HashMap<String, Object>)param.getData(MAP_ID);

		// 請求契約一意照会マップ.ＫＥＹ＿請求契約番号 → ＫＥＹ＿請求契約番号 のエラー情報返却
		if (!template.isNull(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR))
		{
			if (!inMap.containsKey(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR))
			{
				inMap.put(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR, template.getString(EKK0491A010CBSMsg.KEY_SEIKY_KEI_NO_ERR));
			}
		}
		// 請求契約一意照会マップ.ＫＥＹ＿世代登録年月日時分秒 → ＫＥＹ＿世代登録年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
		{
			if (!inMap.containsKey(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR))
			{
				inMap.put(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR, template.getString(EKK0491A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}

		return param;
	}

	/**
	 * システムパラメータ管理一意照会実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoEZM0311A010(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];
		
		int templateStatus = template.getInt(EZM0311A010CBSMsg.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);
		}
		
		HashMap<String, Object> inMap = null;
		
		/* ユーザデータ情報 */
		inMap = (HashMap<String, Object>)param.getData(MAP_ID);
		
		// システムパラメータ管理一意照会.ＫＥＹ＿システムパラメータ分類コードエラー → ＫＥＹ＿システムパラメータ分類コードエラー情報返却
		if (!template.isNull(EZM0311A010CBSMsg.KEY_SYS_PARAM_BUNRUI_CD_ERR)) 
		{
			if (!inMap.containsKey(EZM0311A010CBSMsg.KEY_SYS_PARAM_BUNRUI_CD_ERR)) 
			{
				inMap.put(EZM0311A010CBSMsg.KEY_SYS_PARAM_BUNRUI_CD_ERR, template.getString(EZM0311A010CBSMsg.KEY_SYS_PARAM_BUNRUI_CD_ERR));
			}
		}
		// システムパラメータ管理一意照会.ＫＥＹ＿システムパラメータＩＤエラー号→ ＫＥＹ＿システムパラメータＩＤエラー のエラー情報返却
		if (!template.isNull(EZM0311A010CBSMsg.KEY_SYS_PARAM_ID_ERR)) 
		{
			if (!inMap.containsKey(EZM0311A010CBSMsg.KEY_SYS_PARAM_ID_ERR)) 
			{
				inMap.put(EZM0311A010CBSMsg.KEY_SYS_PARAM_ID_ERR, template.getString(EZM0311A010CBSMsg.KEY_SYS_PARAM_ID_ERR));
			}
		}
		return param;
	}

	/**
	 * システムパラメータ管理一意照会サービスインターフェイス用メッセージ設定処理<br>
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private ArrayList<CAANMsg> editInMsgEZM0311A010(IRequestParameterReadWrite param,
								HashMap<String, Object> chohyoReqMap) throws RequestParameterException
	{
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		/* ◇ユーザデータ情報 */
		CAANMsg template = new CAANMsg(EZM0311A010CBSMsg.class.getName());
		this.setTemplateCommonItem(param, template, 
				EZM0311A010CBSMsg.TEMPLATEID, TEMPLATE_ID_EZM0311A010, EZM0311A010CBSMsg.FUNC_CODE);

		/* ◇業務データの設定 */
		// 機能コード
		template.set(EZM0311A010CBSMsg.FUNC_CODE, JPCModelConstant.FUNC_CD_1);

		// "INVOICE" → システムパラメータ管理一意照会明細マップ.ＫＥＹ＿システムパラメータ分類コード
		template.set(EZM0311A010CBSMsg.KEY_SYS_PARAM_BUNRUI_CD, JKKStrConst.SYS_PARAM_BUNRUI_CD_INVOICE);

		// "INV_BUZ_NO" → システムパラメータ管理一意照会明細マップ.ＫＥＹ＿システムパラメータID
		template.set(EZM0311A010CBSMsg.KEY_SYS_PARAM_ID, JKKStrConst.SYS_PARAM_ID_INV_BUZ_NO);

		templateList.add(template);

		return templateList;
	}

	/**
	 * システムパラメータ管理一意照会サービスインターフェイス用メッセージ取得処理<br>
	 * 
	 * @param msgList メッセージリスト
	 * @param param リクエストパラメータ
	 * @return IRequestParameterReadWrite
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private IRequestParameterReadWrite editOutMsgEZM0311A010(Map<?, ?> msgList,
			IRequestParameterReadWrite param) 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);

		// 業務データ設定
		HashMap<String, Object> dataMap = (HashMap<String, Object>)param.getData(MAP_ID);
		if (dataMap == null)
		{
			dataMap = new HashMap<String, Object>();
			param.setData(MAP_ID, dataMap);
		}

		templateArray = parentTemplate.getCAANMsgList(EZM0311A010CBSMsg.EZM0311A010CBSMSG1LIST);
		if (templateArray != null)
		{
			for (int i = 0; i < templateArray.length; i++)
			{
				CAANMsg childTemplate = templateArray[i];

				// 通信サービス料金マップ.システムパラメータ管理一意照会明細.システムパラメータ設定値1 ← システムパラメータ管理一意照会明細.システムパラメータ設定値1
				if (childTemplate.isNull(EZM0311A010CBSMsg1List.SYS_PARAM_SETTE_VALUE_1)) 
				{
					dataMap.put(JKKStdardKojihiConstCC.EZM0311A010_SYS_PARAM_SETTE_VALUE_1, new String());
				}
				else 
				{
					dataMap.put(JKKStdardKojihiConstCC.EZM0311A010_SYS_PARAM_SETTE_VALUE_1, childTemplate.getString(EZM0311A010CBSMsg1List.SYS_PARAM_SETTE_VALUE_1));
				}
			}
		}

		// エラー情報の設定
		editErrorInfo(param, templates, (Integer)return_code);

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

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

		// 例外通知
		String rtnCode = msgList.get(JCMConstants.RET_CD_INT_KEY).toString();
		String status = (String)param.getControlMapData(SCControlMapKeys.RETURN_CODE);
		if(!("0".equals(rtnCode) && 0 == Integer.parseInt(status)))
		{
			throw new Exception();
		}

		return param;
	}

	/**
	 * 
	 * システムパラメータ管理一意照会サービスインタフェイスを実行する<br>
	 * 
	 * @param param リクエストパラメータ
	 * @param chohyoReqMap 帳票出力依頼リストマップ
	 * @param isUcwkListPrint 内訳書を出力するかを判定するフラグ
	 * @return ArrayList<CAANMsg>
	 * @throws RequestParameterException
	 */
	private void execEZM0311A010(SessionHandle handle,
									IRequestParameterReadWrite param,
									HashMap<String, Object> chohyoReqMap) throws Exception {
		
		/* ◇パラメータマップ生成 */
		HashMap<String, Object> paramMap = this.createNewParamMap(param);
		/* ◇テンプレートリスト生成 */
		ArrayList<CAANMsg> templateList = new ArrayList<CAANMsg>();

		// 上りマッピング
		ArrayList<CAANMsg> templateEZM0311A010 = editInMsgEZM0311A010(param, chohyoReqMap);
		
		for (CAANMsg msg : templateEZM0311A010) {
			templateList.add(msg);
		}
		
		CAANMsg[] templates = templateList.toArray(new CAANMsg[templateList.size()]);
		paramMap.put(JCMConstants.TEMPLATE_LIST_KEY, templates);

		// ＳＣ呼出実行
		ServiceComponentRequestInvoker scCall = new ServiceComponentRequestInvoker();
		Map<?, ?> result = scCall.run(paramMap, handle);

		// 下りマッピング
		editOutMsgEZM0311A010(result, param);
	}

	/**
	 * 帳票生成サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoECC0041A110(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(ECC0041A110CBSMsg.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);
		}

		HashMap<String, Object> inMap = null;

		/* ユーザデータ情報 */
		inMap = (HashMap<String, Object>)param.getData(MAP_ID);

		// 帳票生成.帳票定義体の電子ファイル管理番号→ 帳票定義体の電子ファイル管理番号 のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO_ERR, template.getString(ECC0041A110CBSMsg.CHOHYO_TEIGI_NO_ERR));
			}
		}
		// 帳票生成.データファイルの電子ファイル管理番号→ データファイルの電子ファイル管理番号 のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.DATA_FILE_NO_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.DATA_FILE_NO_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.DATA_FILE_NO_ERR, template.getString(ECC0041A110CBSMsg.DATA_FILE_NO_ERR));
			}
		}
		// 帳票生成.データファイル→ データファイル のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.DATA_FILE_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.DATA_FILE_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.DATA_FILE_ERR, template.getString(ECC0041A110CBSMsg.DATA_FILE_ERR));
			}
		}
		// 帳票生成.ユーザーID→ ユーザーID のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.USER_ID_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.USER_ID_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.USER_ID_ERR, template.getString(ECC0041A110CBSMsg.USER_ID_ERR));
			}
		}
		// 帳票生成.処理種別→ 処理種別 のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.TRAN_SBT_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.TRAN_SBT_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.TRAN_SBT_ERR, template.getString(ECC0041A110CBSMsg.TRAN_SBT_ERR));
			}
		}

		// 帳票生成.FAX送信先コード区分→ FAX送信先コード区分 のエラー情報返却
		if (!template.isNull(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD_ERR)) 
		{
			if (!inMap.containsKey(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD_ERR)) 
			{
				inMap.put(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD_ERR, template.getString(ECC0041A110CBSMsg.CHOHYO_OPUT_ENV_SKBT_CD_ERR));
			}
		}

		return param;
	}

	/**
	 * 同一回線内訳サービス契約一覧照会サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoEKK0081B029(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0081B029CBSMsg.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);
		}

		HashMap<String, Object> inMap = null;

		/* ユーザデータ情報 */
		inMap = (HashMap<String, Object>)param.getData(MAP_ID);

		// 同一回線内訳サービス契約一覧照会.サービス契約番号→ サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0081B029CBSMsg.KEY_SVC_KEI_NO_ERR)) 
		{
			if (!inMap.containsKey(EKK0081B029CBSMsg.KEY_SVC_KEI_NO_ERR)) 
			{
				inMap.put(EKK0081B029CBSMsg.KEY_SVC_KEI_NO_ERR, template.getString(EKK0081B029CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}

		return param;
	}

	/**
	 * サービス契約一意照会サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoEKK0081A010(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0081A010CBSMsg.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);
		}

		HashMap<String, Object> inMap = null;

		/* ユーザデータ情報 */
		inMap = (HashMap<String, Object>)param.getData(MAP_ID);

		// サービス契約一意照会.ＫＥＹ＿サービス契約番号→ ＫＥＹ＿サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR)) 
		{
			if (!inMap.containsKey(EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR)) 
			{
				inMap.put(EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR, template.getString(EKK0081A010CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}
		// サービス契約一意照会.ＫＥＹ＿世代登録年月日時分秒→ ＫＥＹ＿世代登録年月日時分秒 のエラー情報返却
		if (!template.isNull(EKK0081A010CBSMsg.KEY_GENE_ADD_DTM_ERR)) 
		{
			if (!inMap.containsKey(EKK0081A010CBSMsg.KEY_GENE_ADD_DTM_ERR)) 
			{
				inMap.put(EKK0081A010CBSMsg.KEY_GENE_ADD_DTM_ERR, template.getString(EKK0081A010CBSMsg.KEY_GENE_ADD_DTM_ERR));
			}
		}
		// サービス契約一意照会.ＫＥＹ＿予約適用年月日→ ＫＥＹ＿予約適用年月日 のエラー情報返却
		if (!template.isNull(EKK0081A010CBSMsg.KEY_RSV_APLY_YMD_ERR)) 
		{
			if (!inMap.containsKey(EKK0081A010CBSMsg.KEY_RSV_APLY_YMD_ERR)) 
			{
				inMap.put(EKK0081A010CBSMsg.KEY_RSV_APLY_YMD_ERR, template.getString(EKK0081A010CBSMsg.KEY_RSV_APLY_YMD_ERR));
			}
		}

		return param;
	}

	/**
	 * 課金先一覧照会（サービス契約番号）サービスコンポーネント実行後に、IRequestParameterReadWriteにエラー情報をマッピングする
	 * @param param
	 * @param templates
	 * @param returnCode
	 * @return IRequestParameterReadWrite
	 * @throws RequestParameterException
	 */
	@SuppressWarnings("unchecked")
	public IRequestParameterReadWrite editErrorInfoEKK0321B005(IRequestParameterReadWrite param
			, CAANMsg[] templates, int returnCode) throws RequestParameterException
	{
		CAANMsg template = templates[0];

		int templateStatus = template.getInt(EKK0321B005CBSMsg.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);
		}

		HashMap<String, Object> inMap = null;

		/* ユーザデータ情報 */
		inMap = (HashMap<String, Object>)param.getData(MAP_ID);

		// 課金先一覧照会（サービス契約番号）.ＫＥＹ＿サービス契約番号→ ＫＥＹ＿サービス契約番号 のエラー情報返却
		if (!template.isNull(EKK0321B005CBSMsg.KEY_SVC_KEI_NO_ERR)) 
		{
			if (!inMap.containsKey(EKK0321B005CBSMsg.KEY_SVC_KEI_NO_ERR)) 
			{
				inMap.put(EKK0321B005CBSMsg.KEY_SVC_KEI_NO_ERR, template.getString(EKK0321B005CBSMsg.KEY_SVC_KEI_NO_ERR));
			}
		}

		return param;
	}

	/**
	 * 通事費総額通知書情報をCSV形式のバイナリデータに変換する。
	 * @param param
	 * @param bothDispMap 内訳両出力マップ
	 * @return byte[]
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private byte[] makeCSVDataStdardKojihiPrcChohyo(IRequestParameterReadWrite param) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		// 業務パラメータ管理情報取得
		HashMap<String, String> workParamMap = createWkParaMap(parentMapCC);

		StringBuffer sb = new StringBuffer();

		// フォーマット編集
		// 通常文字サイズ か 小さい文字サイズ かのフラグ
		HashMap<String, String> editFlgMap = new HashMap<String, String>();

		// 送付先
		ArrayList<String> addressList = editSohusaki(parentMapCC, editFlgMap);
		
		// 住所リストから更新用住所配列を取得
		String[] strAddress1 = getAddressArray(addressList.get(0), editFlgMap);
		String[] strAddress2 = getAddressArray(addressList.get(1), editFlgMap);
		String[] strAddress3 = getAddressArray(addressList.get(2), editFlgMap);
		String[] strAddress4 = getAddressArray(addressList.get(3), editFlgMap);

		// 送付先名・部課名・担当者名
		ArrayList<String> sohusNmList = editSohusakiName(parentMapCC);

		// 送付先郵便番号
		String sohusPcd = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_PCD);

		// 登録番号
		String addNo = (String)parentMapCC.get(JKKStdardKojihiConstCC.EZM0311A010_SYS_PARAM_SETTE_VALUE_1);
		// ANK-4401-00-01 ADD START
		if (JKKStringUtil.isNullBlank(addNo))
		{
			addNo = JACStrConst.KARA_MOJI;
		}
		// ANK-4401-00-01 ADD END

		// ANK-4539-00-00 ADD START
		// 請求契約番号
		String seiky_kei_no = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0491A010_SEIKY_KEI_NO);
		// ANK-4539-00-00 ADD END

		// 申込番号
		// ANK-4401-00-00 MOD START
//		String mskmNo = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_MSKM_NO);
		String mskmNo = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_MSKM_NO);
		// ANK-4401-00-00 MOD END

		// 工事完了年月日
		// ANK-4401-00-00 MOD START
//		String kojiFinYmd = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_KOJI_FIN_YMD);
		String kojiFinYmd = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_KOJI_FIN_YMD);
		// ANK-4401-00-00 MOD END
		String kojiFinYear = JACStrConst.KARA_MOJI;
		String kojiFinMonth = JACStrConst.KARA_MOJI;
		String kojiFinDay = JACStrConst.KARA_MOJI;
		if (!JKKStringUtil.isNullBlank(kojiFinYmd))
		{
			kojiFinYear = editYmd(kojiFinYmd, DATE_KBN_YEAR);
			kojiFinMonth = editYmd(kojiFinYmd, DATE_KBN_MON);
			kojiFinDay = editYmd(kojiFinYmd, DATE_KBN_DAY);
		}

		// 料金内訳配列作成
		String[][] pruArray  = pruArraySksi(parentMapCC, workParamMap);

		for (int i = 0; i < PRU_CHOHYO_ROW_MAX; i++)
		{
			sb.append(getStringToDblQuote(addNo))								// 登録番号
			.append(CSV + getStringToDblQuote(sohusPcd))						// 請求書送付先郵便番号
			.append(CSV + getStringToDblQuote(strAddress1[0]))					// 送付住所1-1
			.append(CSV + getStringToDblQuote(strAddress2[0]))					// 送付住所1-2
			.append(CSV + getStringToDblQuote(strAddress3[0]))					// 送付住所1-3
			.append(CSV + getStringToDblQuote(strAddress4[0]))					// 送付住所1-4
			.append(CSV + getStringToDblQuote(strAddress1[1]))					// 送付住所2-1
			.append(CSV + getStringToDblQuote(strAddress2[1]))					// 送付住所2-2
			.append(CSV + getStringToDblQuote(strAddress3[1]))					// 送付住所2-3
			.append(CSV + getStringToDblQuote(strAddress4[1]))					// 送付住所2-4
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(0)))		// 送付先名１
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(1)))		// 送付先名２
			.append(CSV + getStringToDblQuote((String)sohusNmList.get(2)))		// 送付先名３
			// ANK-4539-00-00 ADD START
			.append(CSV + getStringToDblQuote(seiky_kei_no))					// 請求契約番号
			// ANK-4539-00-00 ADD END
			.append(CSV + getStringToDblQuote(mskmNo))							// 申込番号
			.append(CSV + getStringToDblQuote(kojiFinYear))						// 工事完了年
			.append(CSV + getStringToDblQuote(kojiFinMonth))					// 工事完了月
			.append(CSV + getStringToDblQuote(kojiFinDay))						// 工事完了日
			.append(CSV + getStringToDblQuote(pruArray[i][0]))					// 料金内訳
			.append(CSV + getStringToDblQuote(pruArray[i][1]))					// 金額

			.append(System.getProperty(LINE_SEP));
		}

		//UTF-8のバイト配列に変換して返す
		return sb.toString().getBytes("UTF-8");
	}

	// ANK-4401-00-01 ADD START
	/**
	 * 標準工事費分割払い通知書情報をセット。
	 * @param param
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private void makeStdardKojihiPrcTcshoInfo(IRequestParameterReadWrite param, Map userData) throws Exception
	{
		HashMap<String, Object> parentMapCC = null;
		parentMapCC = (HashMap<String, Object>)param.getData(MAP_ID);

		// 業務パラメータ管理情報取得
		HashMap<String, String> workParamMap = createWkParaMap(parentMapCC);

		// フォーマット編集
		// 通常文字サイズ か 小さい文字サイズ かのフラグ
		HashMap<String, String> editFlgMap = new HashMap<String, String>();

		// サービス契約回線内訳番号
		// ANK-4401-00-00 MOD START
//		String svcKeiKaisenUcwkNo = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_SVC_KEI_KAISEN_UCWK_NO);
		String svcKeiKaisenUcwkNo = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_SVC_KEI_KAISEN_UCWK_NO);
		// ANK-4401-00-00 MOD END

		// 送付先
		ArrayList<String> addressList = editSohusaki(parentMapCC, editFlgMap);

		// 送付先名・部課名・担当者名
		ArrayList<String> sohusNmList = editSohusakiName(parentMapCC);

		// 送付先郵便番号
		String sohusPcd = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_PCD);

		// 登録番号
		String addNo = (String)parentMapCC.get(JKKStdardKojihiConstCC.EZM0311A010_SYS_PARAM_SETTE_VALUE_1);
		if (JKKStringUtil.isNullBlank(addNo))
		{
			addNo = JACStrConst.KARA_MOJI;
		}

		// 申込番号
		// ANK-4401-00-00 MOD START
//		String mskmNo = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_MSKM_NO);
		String mskmNo = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_MSKM_NO);
		// ANK-4401-00-00 MOD END

		// 工事完了年月日
		// ANK-4401-00-00 MOD START
//		String kojiFinYmd = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_KOJI_FIN_YMD);
		String kojiFinYmd = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_KOJI_FIN_YMD);
		// ANK-4401-00-00 MOD END

		// 標準工事費総額(明細)・名称
		String stdardKojihiDtlNm = workParamMap.get(JKKStrConst.WORK_PARAM_ID_KK_KJHSGTS_MGN_SGMS);
		if (JKKStringUtil.isNullBlank(stdardKojihiDtlNm))
		{
			stdardKojihiDtlNm = JACStrConst.KARA_MOJI;
		}
		// 31文字を超える場合は切り捨てる
		if (stdardKojihiDtlNm.length() > 31)
		{
			stdardKojihiDtlNm = stdardKojihiDtlNm.substring(0, 31);
		}
		// 標準工事費総額(明細)・金額
		// ANK-4401-00-00 MOD START
//		String stdardKojihiDtlPrc = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_STDARD_KOJIHI_DTL_PRC);
		String stdardKojihiDtlPrc = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_STDARD_KOJIHI_DTL_PRC);
		// ANK-4401-00-00 MOD END

		// 標準工事費総額(合計)・名称
		String stdardKojihiGkNm = workParamMap.get(JKKStrConst.WORK_PARAM_ID_KK_KJHSGTS_MGN_SGGK);
		if (JKKStringUtil.isNullBlank(stdardKojihiGkNm))
		{
			stdardKojihiGkNm = JACStrConst.KARA_MOJI;
		}
		// 31文字を超える場合は切り捨てる
		if (stdardKojihiGkNm.length() > 31)
		{
			stdardKojihiGkNm = stdardKojihiGkNm.substring(0, 31);
		}
		// 標準工事費総額(合計)・金額
		// ANK-4401-00-00 MOD START
//		String stdardKojihiGkPrc = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_STDARD_KOJIHI_GK_PRC);
		String stdardKojihiGkPrc = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_STDARD_KOJIHI_GK_PRC);
		// ANK-4401-00-00 MOD END

		// 消費税合計額・名称
		String staxGkNm = workParamMap.get(JKKStrConst.WORK_PARAM_ID_KK_KJHSGTS_MGN_SZGK);
		// 消費税合計額・税率
		// ANK-4401-00-00 MOD START
//		String staxGkRt = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_STAX_GK_RT);
		String staxGkRt = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_STAX_GK_RT);
		// ANK-4401-00-00 MOD END
		// 消費税合計額・金額
		// ANK-4401-00-00 MOD START
//		String staxGkPrc = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_STAX_GK_PRC);
		String staxGkPrc = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_STAX_GK_PRC);
		// ANK-4401-00-00 MOD END

		// 消費税合計額編集処理
		String staxGkUw = executeReplaceWork(staxGkNm, staxGkRt);
		staxGkUw = JPCUtilCommon.trim((String)staxGkUw);
		// 31文字を超える場合は切り捨てる
		if (staxGkUw.length() > 31)
		{
			staxGkUw = staxGkUw.substring(0, 31);
		}

		// 割賦販売形態コード
		// ANK-4401-00-00 MOD START
//		String kapHambaiFormCd = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_KAP_HAMBAI_FORM_CD);
		String kapHambaiFormCd = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_KAP_HAMBAI_FORM_CD);
		// ANK-4401-00-00 MOD END

		// 割賦契約課金開始年月日
		// ANK-4401-00-00 MOD START
//		String kapKeiChrgStaymd = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_KAP_KEI_CHRG_STAYMD);
		String kapKeiChrgStaymd = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_KAP_KEI_CHRG_STAYMD);
		// ANK-4401-00-00 MOD END

		/***************************************************/
		/** 返却パラメータ作成処理                         */
		/***************************************************/
		userData.put(JKKStdardKojihiConstCC.OUTPUT_SVC_KEI_KAISEN_UCWK_NO, svcKeiKaisenUcwkNo); // サービス契約回線内訳番号
		userData.put(JKKStdardKojihiConstCC.OUTPUT_TOROKU_NO, addNo); 							// 登録番号
		userData.put(JKKStdardKojihiConstCC.OUTPUT_SOHUS_PCD, sohusPcd); 						// 請求書送付先住所・郵便番号
		userData.put(JKKStdardKojihiConstCC.OUTPUT_SOHUS_STATE_NM, addressList.get(0)); 		// 請求書送付先住所・都道府県
		userData.put(JKKStdardKojihiConstCC.OUTPUT_SOHUS_CITY_NM, addressList.get(1)); 			// 請求書送付先住所・市区町村
		userData.put(JKKStdardKojihiConstCC.OUTPUT_SOHUS_AZACHO_NM, addressList.get(2)); 		// 請求書送付先住所・字町名
		userData.put(JKKStdardKojihiConstCC.OUTPUT_SOHUS_ADRRM, addressList.get(3)); 			// 請求書送付先住所・部屋番号
		userData.put(JKKStdardKojihiConstCC.OUTPUT_SOHUS_NM1, (String)sohusNmList.get(0)); 		// 請求書送付先名１
		userData.put(JKKStdardKojihiConstCC.OUTPUT_SOHUS_NM2, (String)sohusNmList.get(1)); 		// 請求書送付先名２
		userData.put(JKKStdardKojihiConstCC.OUTPUT_SOHUS_NM3, (String)sohusNmList.get(2)); 		// 請求書送付先名３
		userData.put(JKKStdardKojihiConstCC.OUTPUT_MSKM_NO, mskmNo); 							// 申込番号
		userData.put(JKKStdardKojihiConstCC.OUTPUT_KOJI_FIN_YMD, kojiFinYmd); 					// 工事完了年月日
		userData.put(JKKStdardKojihiConstCC.OUTPUT_HKJHSG_MSI_NM, stdardKojihiDtlNm); 			// 標準工事費総額(明細)・名称
		userData.put(JKKStdardKojihiConstCC.OUTPUT_HKJHSG_MSI_KNGK, stdardKojihiDtlPrc); 		// 標準工事費総額(明細)・金額
		userData.put(JKKStdardKojihiConstCC.OUTPUT_HKJHSG_GKI_NM, stdardKojihiGkNm); 			// 標準工事費総額(合計)・名称
		userData.put(JKKStdardKojihiConstCC.OUTPUT_HKJHSG_GKI_KNGK, stdardKojihiGkPrc); 		// 標準工事費総額(合計)・金額
		userData.put(JKKStdardKojihiConstCC.OUTPUT_SHZIGKIG_NM, staxGkUw); 						// 消費税合計額・名称
		userData.put(JKKStdardKojihiConstCC.OUTPUT_SHZIGKIG_ZIRT, staxGkRt); 					// 消費税合計額・税率
		userData.put(JKKStdardKojihiConstCC.OUTPUT_SHZIGKIG_KNGK, staxGkPrc); 					// 消費税合計額・金額
		userData.put(JKKStdardKojihiConstCC.OUTPUT_KAP_HAMBAI_FORM_CD, kapHambaiFormCd); 		// 割賦販売形態コード
		userData.put(JKKStdardKojihiConstCC.OUTPUT_KAP_KEI_CHRG_STAYMD, kapKeiChrgStaymd); 		// 割賦契約課金開始年月日

		// 取得したデータのセット
		if (userData != null)
		{
			Map<String, Object> userDataRef = (Map<String, Object>)param.getData(MAP_ID);
			Iterator iterator = userData.keySet().iterator();
			while (iterator.hasNext()) 
			{
				String mapKey = (String)iterator.next();
				Object mapVal = userData.get(mapKey);
				userDataRef.put(mapKey, mapVal);
			}
		}
	}
	// ANK-4401-00-01 ADD END

	/**
	 * サービスインタフェースに渡すパラメータマップを新規に作成します。
	 * マップには共通項目である電文ヘッダ、コントロールマップを設定します。
	 * <br>
	 * @param handle セッションハンドル
	 * @param param リクエストパラメータ
	 * @return paramMap
	 * @throws RequestParameterException パラメータ取得で例外が発生した場合
	 */
	private HashMap<String, Object> createNewParamMap(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;
	}

	/**
	 * 文字列を「"」で囲みます。
	 * @param arg0 対象文字列
	 * @return "対象文字列"
	 */
	private String getStringToDblQuote(String arg0)
	{
		return SINGLE_DBLQUOTE + arg0 + SINGLE_DBLQUOTE;
		
	}
	
	/**
	 * 編集した送付先住所を返します。
	 * @param parentMapCC
	 * @param editFlgMap
	 * @return ArrayList
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<String> editSohusaki(HashMap<String, Object> inMap, HashMap<String, String> editFlgMap) throws Exception
	{
		ArrayList<String> addList = new ArrayList<String>();
		addList.add("");
		addList.add("");
		addList.add("");
		addList.add("");

		String[] paramEditAddr = new String[7];

		paramEditAddr[0] = (String)inMap.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_STATE_NM);
		paramEditAddr[1] = (String)inMap.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_CITY_NM);
		paramEditAddr[2] = (String)inMap.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_OAZTSU_NM);
		paramEditAddr[3] = (String)inMap.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_AZCHO_NM);
		paramEditAddr[4] = (String)inMap.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_BNCHIGO);
		paramEditAddr[5] = (String)inMap.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_ADRTTM);
		paramEditAddr[6] = (String)inMap.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_ADRRM);

		JCHCommonFormatUtil chComFmtUtil = new JCHCommonFormatUtil();

		// 通常文字サイズで編集
		String[] retEditAddr = chComFmtUtil.editAddress(paramEditAddr, ADDRESS_NORMAL_LINE_LENGTH, ADDRESS_SPLIT_COUNT);

		if (retEditAddr != null)
		{
			editFlgMap.put(EDIT_FLG_KEY, EDIT_FLG_NORMAL);
			
			if (!retEditAddr[0].equals(JCHCommonFormatUtil.EDIT_RESULT_NORMAL))
			{
				// 小さい文字サイズで編集
				retEditAddr = chComFmtUtil.editAddress(paramEditAddr, ADDRESS_SMALL_LINE_LENGTH, ADDRESS_SPLIT_COUNT);

				editFlgMap.put(EDIT_FLG_KEY, EDIT_FLG_SMALL);

			}
			
			for (int i = 1; i < retEditAddr.length; i++)
			{
				addList.set(i - 1, retEditAddr[i]);
			}
		}

		return addList;
	}

	/**
	 * 住所配列取得処理。
	 * 「第2引数のeditFlgMap = NORMAL」である場合、返却配列の0番目の要素に住所を格納、
	 * それ以外場合、返却配列の1番目の要素に住所を格納し、返却する。
	 * 
	 * @param strAddress 住所文字列
	 * @param editFlgMap 正常サイズか小さいフォントサイズかのフラグも持つmap
	 * @return 住所配列
	 */
	private String[] getAddressArray(String strAddress, HashMap<String, String> editFlgMap)
	{
		String[] addressArray = new String[2];
		addressArray[0] = "";
		addressArray[1] = "";

		String editFlg = editFlgMap.get(EDIT_FLG_KEY);
		
		if (EDIT_FLG_NORMAL.equals(editFlg))
		{
			addressArray[0] = strAddress;
		}
		else
		{
			addressArray[1] = strAddress;
		}

		return addressArray;
	}

	/**
	 * 編集したお客様名を返します。
	 * @param parentMapCC
	 * @return String
	 * @throws Exception
	 */
	@SuppressWarnings("unchecked")
	private ArrayList<String> editSohusakiName(HashMap<String, Object> parentMapCC) throws Exception
	{
		ArrayList<String> nameList = new ArrayList<String>();

		String sohusNm = "";
		String sohusBkm = "";
		String sohusTntshaNm = "";
		
		// ANK-4401-00-01 MOD START
//		sohusNm = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_NM);
//		sohusBkm = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_BKM);
//		sohusTntshaNm = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_TNTSHA_NM);
		if ((String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_NM) != null)
		{
			sohusNm = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_NM);
		}
		if ((String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_BKM) != null)
		{
			sohusBkm = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_BKM);
		}
		if ((String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_TNTSHA_NM) != null)
		{
			sohusTntshaNm = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK0491A010_SOHUS_TNTSHA_NM);
		}
		// ANK-4401-00-01 MOD END

		nameList.add(JACCommonUtil.editStrLength(sohusNm, CHOHYO_OUT_NAME_LENGTH));
		nameList.add(JACCommonUtil.editStrLength(sohusBkm, CHOHYO_OUT_NAME_LENGTH));
		nameList.add(JACCommonUtil.editStrLength(sohusTntshaNm, CHOHYO_OUT_NAME_LENGTH));
		ArrayList<String> resultNameList = JACCommonUtil.editNameList(nameList);

		return resultNameList;
	}

	/**
	 * 業務パラメータ文章を配列で置換する
	 * @param value1 置換先業務パラメータ文字配列
	 * @param value2 業務パラメータ置換文字配列
	 * @return 置換済み文字列
	 */
	private String executeReplaceWork(String value1, String value2)
	{
		// 返却値
		String ckanValue = JACStrConst.KARA_MOJI;
		
		if (!JKKStringUtil.isNullBlank(value1) && !JKKStringUtil.isNullBlank(value2))
		{
			// 置換開始
			ckanValue = "　" + value1.replaceAll("%" + SOE + "%", value2);
		}
		
		return ckanValue;
	}

	/**
	 * 編集した年・月・日を返します。
	 * @param strDate
	 * @param kbnYmd
	 * @return String
	 * @throws Exception
	 */
	private String editYmd(String strDate, String kbnYmd) throws Exception
	{
		String rtnValue = JACStrConst.KARA_MOJI;

		if(strDate != null && !JACStrConst.KARA_MOJI.equals(strDate))
		{
			if (DATE_KBN_YEAR.equals(kbnYmd))
			{
				// 年の切り出し
				rtnValue = strDate.substring(0, 4);
			}
			else if (DATE_KBN_MON.equals(kbnYmd))
			{
				// 月の切り出し
				rtnValue = strDate.substring(4, 6);
			}
			else if (DATE_KBN_DAY.equals(kbnYmd))
			{
				// 日の切り出し
				rtnValue = strDate.substring(6, 8);
			}
		}

		return rtnValue;
	}

	/**
	 * 編集した金額を返します。
	 * @param strAmnt
	 * @param amntHenshuPtnCd
	 * @return String
	 * @throws Exception
	 */
	private String editAmnt(String strAmnt) throws Exception
	{
		String rtnValue = JACStrConst.KARA_MOJI;

		if(strAmnt != null && !JACStrConst.KARA_MOJI.equals(strAmnt))
		{
			rtnValue = JPCUtilCommon.fillHalfSpace(strAmnt, AMNT_HENSHU_KETA_MAX, false);
		}

		return rtnValue;
	}

	/**
	 * 業務パラメータ格納用マップの生成
	 * 
	 * @param inMap 入力マップ
	 * @return 業務パラメータ格納用マップ
	 */
	@SuppressWarnings("unchecked")
	private HashMap<String, String> createWkParaMap(HashMap<String, Object> inMap)
	{
		HashMap<String, String> wkParaMap = new HashMap<String, String>();
		
		for (int i = 0; i < COL_EZM0321A010LISTS.length; i++)
		{
			// 業務パラメータ一意明細を取得
			ArrayList<HashMap<String, Object>> msgList = (ArrayList<HashMap<String, Object>>)inMap.get(COL_EZM0321A010LISTS[i]);
			// 取得結果の0件判定
			if (msgList.size() > 0)
			{
				// 一意照会なので1件目のみ取得
				HashMap<String, Object> msgMap = (HashMap<String, Object>)msgList.get(0);
				if(msgMap != null)
				{
					// 業務パラメータ設定値を取得
					String wkParamSetteValue = (String)msgMap.get(EZM0321A010CBSMsg1List.WORK_PARAM_SETTE_VALUE);
					// 業務パラメータ格納用マップに追加
					wkParaMap.put(WK_PARA_IDS[i], wkParamSetteValue);
				}
			}
		}
		return wkParaMap;
		
	}

	/**
	 * 編集した料金内訳を返します。
	 * @param parentMapCC
	 * @param editFlgMap
	 * @return ArrayList
	 * @throws Exception 
	 * @throws Exception
	 */
	private String[][] pruArraySksi(HashMap<String, Object> parentMapCC, HashMap<String, String> workParamMap) throws Exception
	{
		String[][] ucwkArray = new String[4][2];

		// 標準工事費総額(明細)・名称
		String stdardKojihiDtlNm = workParamMap.get(JKKStrConst.WORK_PARAM_ID_KK_KJHSGTS_MGN_SGMS);
		if (JKKStringUtil.isNullBlank(stdardKojihiDtlNm))
		{
			stdardKojihiDtlNm = JACStrConst.KARA_MOJI;
		}
		// 31文字を超える場合は切り捨てる
		if (stdardKojihiDtlNm.length() > 31)
		{
			stdardKojihiDtlNm = stdardKojihiDtlNm.substring(0, 31);
		}
		// 標準工事費総額(明細)・金額
		// ANK-4401-00-00 MOD START
//		String stdardKojihiDtlPrc = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_STDARD_KOJIHI_DTL_PRC);
		String stdardKojihiDtlPrc = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_STDARD_KOJIHI_DTL_PRC);
		// ANK-4401-00-00 MOD END
		stdardKojihiDtlPrc = editAmnt(stdardKojihiDtlPrc);

		// 標準工事費総額(合計)・名称
		String stdardKojihiGkNm = workParamMap.get(JKKStrConst.WORK_PARAM_ID_KK_KJHSGTS_MGN_SGGK);
		if (JKKStringUtil.isNullBlank(stdardKojihiGkNm))
		{
			stdardKojihiGkNm = JACStrConst.KARA_MOJI;
		}
		// 31文字を超える場合は切り捨てる
		if (stdardKojihiGkNm.length() > 31)
		{
			stdardKojihiGkNm = stdardKojihiGkNm.substring(0, 31);
		}
		// 標準工事費総額(合計)・金額
		// ANK-4401-00-00 MOD START
//		String stdardKojihiGkPrc = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_STDARD_KOJIHI_GK_PRC);
		String stdardKojihiGkPrc = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_STDARD_KOJIHI_GK_PRC);
		// ANK-4401-00-00 MOD END
		stdardKojihiGkPrc = editAmnt(stdardKojihiGkPrc);

		// 消費税合計額・名称
		String staxGkNm = workParamMap.get(JKKStrConst.WORK_PARAM_ID_KK_KJHSGTS_MGN_SZGK);
		// 消費税合計額・税率
		// ANK-4401-00-00 MOD START
//		String staxGkRt = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_STAX_GK_RT);
		String staxGkRt = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_STAX_GK_RT);
		// ANK-4401-00-00 MOD END
		// 消費税合計額・金額
		// ANK-4401-00-00 MOD START
//		String staxGkPrc = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3511B010_STAX_GK_PRC);
		String staxGkPrc = (String)parentMapCC.get(JKKStdardKojihiConstCC.EKK3131B070_STAX_GK_PRC);
		// ANK-4401-00-00 MOD END
		staxGkPrc = editAmnt(staxGkPrc);

		// 消費税合計額編集処理
		String staxGkUw = executeReplaceWork(staxGkNm, staxGkRt);
		// 31文字を超える場合は切り捨てる
		if (staxGkUw.length() > 31)
		{
			staxGkUw = staxGkUw.substring(0, 31);
		}

		// 1行目
		ucwkArray[0][0] = stdardKojihiDtlNm;
		ucwkArray[0][1] = stdardKojihiDtlPrc;
		// 2行目
		ucwkArray[1][0] = "";
		ucwkArray[1][1] = "";
		// 3行目
		ucwkArray[2][0] = stdardKojihiGkNm;
		ucwkArray[2][1] = stdardKojihiGkPrc;
		// 4行目
		ucwkArray[3][0] = staxGkUw;
		ucwkArray[3][1] = staxGkPrc;

		return ucwkArray;
	}
}