/*********************************************************************
* All Rights reserved,Copyright (c) K-Opticom
**********************************************************************
*＜プログラム内容＞
*   システム名      ：eo顧客基幹システム
*	モジュール名	：JCCWebBusinessLogic
*	ソースファイル名：JCCWebBusinessLogic.java
*	作成者			：富士通
*	日付			：
*＜機能概要＞
*	ビジネスロジッククラス
*＜修正履歴＞
*	バージョン	修正日		修正者		修正内容
*	v24.00.00	2016/02/24 	FJ)中原		ANK-2680-00-00_eoアクセスログ収集対応

*
**********************************************************************/

package eo.web.webview;

import static com.fujitsu.futurity.web.x31.X31SWebLog.DEBUG_LOG;

import java.beans.XMLEncoder;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.io.InputStream;
import java.io.OutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.UUID;
import java.util.Set;
import java.util.Iterator;
import java.util.Map;
import java.util.zip.CRC32;
import java.util.zip.CheckedInputStream;
import java.util.zip.ZipEntry;
import java.util.zip.ZipOutputStream;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

import com.fujitsu.futurity.common.JSYwebLog;
import com.fujitsu.futurity.model.common.JCMAPLConstMgr;
import com.fujitsu.futurity.web.x00.JCCWebServiceException;
import com.fujitsu.futurity.web.x31.X31CHashMap;
import com.fujitsu.futurity.web.x31.X31BWebBusinessLogic;
import com.fujitsu.futurity.web.x31.X31CMessageResult;
import com.fujitsu.futurity.web.x31.X31CWebConst;
import com.fujitsu.futurity.web.x31.X31SDataBeanAccess;
import com.fujitsu.futurity.web.x33.DispatchContext;
import com.fujitsu.futurity.web.x33.DispatchContextFactory;
import com.fujitsu.futurity.web.x33.HttpDispatchContext;
import com.fujitsu.futurity.web.x33.X33CHashMap;
import com.fujitsu.futurity.web.x33.X33CVector;
import com.fujitsu.futurity.web.x33.X33SException;

import eo.common.util.JCCFrameworkException;
import eo.common.util.JPCEditString;
import eo.web.webview.CommonInfoCF.CommonInfoCFConst;
import eo.web.webview.common.JCCAuthorityCtrlApi;
import eo.web.webview.common.JCCBusinessControlApi;
import eo.web.webview.common.JCCDownloadRestrictionCache;
import eo.web.webview.common.JCCRequestProcessLogic;
import eo.web.webview.common.JCCWebCommon;
import eo.web.webview.common.JCCUploadRestrictionCache;
import eo.web.webview.common.JCCBusinessControl;
import eo.web.webview.common.JCCBusinessControlStatus;
import eo.web.webview.common.JCCAuthorityCtrl;
import eo.web.webview.common.JCCAuthorityCtrlStatus;
import eo.web.webview.common.JCCWorkRestrictionCache;
import eo.web.webview.common.JCCsvlGetOperationDateUtil;
import eo.web.webview.mapping.CCSV0001_CCSV0001OPDBMapper;
import eo.web.webview.mapping.CCSV0008_CCSV0008OPDBMapper;

/**
 * ファイルアップロード／ダウンロードの制御を行うクラス。
 * Viewロジックが呼び出します。
 * 
 * @author 富士通
 */
public class JCCWebBusinessLogic extends X31BWebBusinessLogic 
{

	/** 空文チェック用の定数 */
	static final String CHKNULL = "";
	
	/** 処理継続判定フラグADD START */
	private boolean continueNextProc = true;
	
	/** ダウンロードファイル連番 */
	private int downLoadRenban = 1;
	
	/** テスト用ファイル連番保持変数 */
	protected static String testRenban = null;
	
	/** システム全機能の参照/更新停止規制コード */
	public final String RESTRICTION_ALL_SELECT_UPDATE = "PCGKA0001";
	
	/** システム全機能の更新停止規制コード */
	public final String RESTRICTION_ALL_UPDATE = "PCGKA0002";


	/**
	 * 親クラスX31BWebBusinessLogicのpostreceiveMessageWebを
	 * オーバーライドして自動生成されたメソッドです。
	 * リクエストの後処理時に呼ばれます。
	 * @param
	 * @return
	 */
	@Override
	protected void postreceiveMessageWeb() 
	{
		// 20121220 定期リクエストは初期処理をしない fst)yanagihara start
		if(JCCRequestProcessLogic.isKeepAliveEvent(DispatchContextFactory.getInstance().getHttpDispatchContext()))
		{
			return;
		}
		// 20121220 定期リクエストは初期処理をしない fst)yanagihara end

		// 自動生成されたメソッドスタブ
		// 業務規制
		JCCBusinessControlStatus jbc = new JCCBusinessControlStatus();
		jbc.setBusinessControl(this);
		
		// 権限制御
		JCCAuthorityCtrlStatus.setAuthorityCtrl(this);
		
		// 運用日付セッションクリア
		JCCsvlGetOperationDateUtil.clearSession(this);
		
		// IPアドレスを共有フォームBeanに設定
		setIPAddressToCommonInfoBean();
	}

	/**
	 * 親クラスX31BWebBusinessLogicのpostreceiveMessageWebを
	 * オーバーライドして自動生成されたメソッドです。
	 * リクエストの前処理時で呼ばれます。
	 * @param
	 * @return
	 */
	@Override
	protected void prereceiveMessageWeb()
	{
		// 20121220 定期リクエストは初期処理をしない fst)yanagihara start
		if(JCCRequestProcessLogic.isKeepAliveEvent(DispatchContextFactory.getInstance().getHttpDispatchContext()))
		{
			return;
		}
		// 20121220 定期リクエストは初期処理をしない fst)yanagihara end
		
		super.prereceiveMessageWeb();

		X31SDataBeanAccess bean = getCommonInfoBean();
		// リクエストフラグを取得
		String reqestFlg = bean.sendMessageString(CommonInfoCFConst.REQUEST_FLG, X31CWebConst.DATABEAN_GET_VALUE);
		if("1".equals(reqestFlg))
		{
			// リクエストフラグを落とす
			bean.sendMessageString(CommonInfoCFConst.REQUEST_FLG, X31CWebConst.DATABEAN_SET_VALUE, "0");
			String targetSystem = JCMAPLConstMgr.getString("TARGET_SYSTEM");
			// ターゲットシステム存在チェック
			if(targetSystem == null || "".equals(targetSystem))
			{
				throw new JCCFrameworkException("AplConst.propertiseからプロジェクト種別の取得に失敗しました。");
			}
			if("API".equals(targetSystem))
			{
				// 業務規制(API連携)
				JCCBusinessControlApi jbcApi = new JCCBusinessControlApi();
				jbcApi.searchBusinessControl(this);
				
				// 権限制御(API連携)
				// 2012/03/29 呼出権限無しの場合はHTTP404をセットして例外をスロー start
				if(JCCAuthorityCtrlApi.judgeAuthorityCtrl(this) == false)
				{
					DispatchContext context = DispatchContextFactory.getInstance().getHttpDispatchContext();
					HttpServletRequest req = ((HttpDispatchContext)context).getServletRequest();
					HttpServletResponse res = ((HttpDispatchContext)context).getServletResponse();
					res.setStatus(HttpServletResponse.SC_NOT_FOUND);
					throw new JCCFrameworkException("APIを呼出す権限がありません。呼出し元IPアドレス:" + req.getRemoteAddr());
				}
				// 2012/03/29 呼出権限無しの場合はHTTP404をセットして例外をスロー end
			}
			else
			{
				// 業務規制(オンライン)
				JCCBusinessControl jbc = new JCCBusinessControl();
				// 業務規制あり:trueの場合、処理継続不可
				continueNextProc = !jbc.searchBusinessControl(this);
				
				// 権限制御(オンライン)
				// 2012/11/27 FST_mukuo) FW高速化 権限のリクエスト単位でのリアルタイム判定をやめる start
				//JCCAuthorityCtrl.judgeAuthorityCtrl(this);
				// 2012/11/27 FST_mukuo) FW高速化 権限のリクエスト単位でのリアルタイム判定をやめる end
			}
		}
		// 2011/11/08 FST)arata API対応 start
		else if("".equals(reqestFlg))
		{
			
			String targetSystem = JCMAPLConstMgr.getString("TARGET_SYSTEM");
			// ターゲットシステム存在チェック
			if(targetSystem == null || "".equals(targetSystem))
			{
				throw new JCCFrameworkException("AplConst.propertiseからプロジェクト種別の取得に失敗しました。");
			}
			if("API".equals(targetSystem) || "FRONT".equals(targetSystem))
			{
				// 業務規制(API連携)
				JCCBusinessControlApi jbcApi = new JCCBusinessControlApi();
				jbcApi.searchBusinessControl(this);
				
				// 権限制御(API連携)
				// 2012/03/29 呼出権限無しの場合はHTTP404をセットして例外をスロー start
				if(JCCAuthorityCtrlApi.judgeAuthorityCtrl(this) == false)
				{
					DispatchContext context = DispatchContextFactory.getInstance().getHttpDispatchContext();
					HttpServletRequest req = ((HttpDispatchContext)context).getServletRequest();
					HttpServletResponse res = ((HttpDispatchContext)context).getServletResponse();
					res.setStatus(HttpServletResponse.SC_NOT_FOUND);
					throw new JCCFrameworkException("APIを呼出す権限がありません。呼出し元IPアドレス:" + req.getRemoteAddr());
				}
				// 2012/03/29 呼出権限無しの場合はHTTP404をセットして例外をスロー end
			}
		}
		//  2011/11/08 FST)arata API対応 end
		
// 2016/02/24 ANK-2680-00-00 DEL START
//		// 2012/05/17 VIEW層の操作からのアクセスログ出力対応 start
//		try
//		{
//			super.printViewOperateAccessLog();
//		}
//		catch(Throwable th)
//		{
//			throw new JCCFrameworkException("VIEW層からのアクセスログ出力に失敗しました。", th);
//		}
//		// 2012/05/17 VIEW層の操作からのアクセスログ出力対応 end
// 2016/02/24 ANK-2680-00-00 DEL END

	}

	/**
	 * エラーメッセージを返却します
	 * 
	 * @param paramMap
	 * @param inputMap
	 * @param outputMap
	 * @return X31CMessageResult
	 */
	public X31CMessageResult invokeService(Map paramMap, Map inputMap, Map outputMap)
	{
		X31CMessageResult messageResult = null;
		if(!chkWksijService((String)paramMap.get(X31CWebConst.TELEGRAM_INFO_USECASE_ID)))
		{
			messageResult = wksijInvokeService((String)paramMap.get(X31CWebConst.TELEGRAM_INFO_USECASE_ID),
					paramMap, inputMap, outputMap);
		}
		else
		{
			messageResult = super.invokeService(paramMap, inputMap, outputMap);
		}

		if(messageResult != null)
		{
			throw new JCCWebServiceException(messageResult);
		}
		
		// 電子ファイル管理番号付け替え処理
		getReplaceNoMap((HashMap) outputMap, paramMap);
		return messageResult;
	}
	
	/**
	 * 親クラスX31BWebBusinessLogicのinvokeService(Map paramMap, Map inputMap, Map outputMap, Map attachFile)を
	 * オーバーライドして自動生成されたメソッドです。
	 * @param paramMap
	 * @param inputMap
	 * @param outputMap
	 * @param attachFile
	 * @return X31CMessageResult
	 */
	@Override
	public X31CMessageResult invokeService(Map paramMap, Map inputMap,
			Map outputMap, Map attachFile)
	{
		
		X31CMessageResult messageResult =  super.invokeService(paramMap, inputMap, outputMap, attachFile);

		if(messageResult != null)
		{
			throw new JCCWebServiceException(messageResult);
		}
		
		// 電子ファイル管理番号付け替え処理
		getReplaceNoMap((HashMap) outputMap, paramMap);
		return messageResult;
	}

	/**
	 * リクエストに含まれるアップロードファイルの一時ファイルを作成し、
	 * アップロード一時ファイル数分の配列を持つハッシュマップのリストを返却します。
	 * ハッシュマップにはキーと値の組合せでアップロードファイル情報が格納されます。
	 * @return 拡張子リスト。
	 */	
	public ArrayList<HashMap<String, Object>> getFileInfoArray()
	{
		return getFileInfoArrayBase(false);
	}

	/**
	 * リクエストに含まれるアップロードファイルの一時ファイルを作成し、
	 * アップロード一時ファイル数分の配列を持つハッシュマップのリストを返却します。
	 * ハッシュマップにはキーと値の組合せでアップロードファイル情報が格納されます。
	 * @param zipFlg 圧縮フラグ(false:ファイル圧縮なし true:ファイル圧縮有り
	 * @return 拡張子リスト。
	 */	
	public ArrayList<HashMap<String, Object>> getFileInfoArray(boolean zipFlg)
	{
		return getFileInfoArrayBase(zipFlg);
	}
	
	/**
	 * リクエストに含まれるアップロードファイルの一時ファイルを作成し、
	 * アップロード一時ファイル数分の配列を持つハッシュマップのリストを返却します。
	 * ハッシュマップにはキーと値の組合せでアップロードファイル情報が格納されます。
	 * @param zipFlg 圧縮フラグ(false:ファイル圧縮なし true:ファイル圧縮有り
	 * @return 拡張子リスト。
	 */	
	private ArrayList<HashMap<String, Object>> getFileInfoArrayBase(boolean zipFlg)
	{	
		//読出し中のアップロード定義ファイルのキー文字列（例外処理用）
		String keyProperties = null;
		
		//ファイル読み書き用のストリーム
		InputStream is = null;
		OutputStream os = null;
		BufferedInputStream bis = null;
		BufferedOutputStream bos = null;
		// 2012/06/07 ファイル圧縮用に追加 start
		CheckedInputStream cis = null;
		ZipOutputStream zos = null;
		// 2012/06/07 ファイル圧縮用に追加 end
		
		// アプリケーションプロパティファイルのパスを設定
		JCCUploadRestrictionCache.setPath();
		
		// 復帰値格納用のリスト
		HashMap<String, Object> reslutMap = null;
		ArrayList<HashMap<String, Object>> resultList = new ArrayList<HashMap<String, Object>>();
		
		// セッション領域上の情報の一時読出し領域
		X31CHashMap<String, Object> seMap = new X31CHashMap<String, Object>();
		HashMap<String, Object> poolMap = new HashMap<String, Object>();
		
		// ファイル連番の保存領域
		ArrayList<String> listSeriesNum = new ArrayList<String>();
		
		// ファイル合計値格納用変数
		long fileSizeSum = 0;
		
		// ファイル保存先をセッションにする場合のフラグ
		boolean saveSessionMode = false;
		
		// リクエストに含まれるすべてのアップロードファイルの情報を取得
		X33CVector<X33CHashMap> fileSizeVec = null;
		try
		{
			fileSizeVec = this.getTempUploadFileSizeAll();
		}
		// ファイル情報の取得に失敗した場合は結果コードを格納して復帰
		catch(X33SException x33)
		{
			// 2013/01/10 FST_mukuo)getTempUploadFileSizeAllで発生したExceptionはそのままスローする start
			//reslutMap = new HashMap<String, Object>();
			//reslutMap.put("resultCode", "FILE_INFO_READ_ERROR");
			//resultList.add(reslutMap);
			//return resultList;
			throw new JCCFrameworkException(x33);
			// 2013/01/10 FST_mukuo)getTempUploadFileSizeAllで発生したExceptionはそのままスローする end
		}
		// アップロードファイルが存在しない場合は結果コードを格納して復帰
		if(fileSizeVec == null || fileSizeVec.size() == 0)
		{
			reslutMap = new HashMap<String, Object>();
			reslutMap.put("resultCode", "FILE_NOT_EXIST");
			resultList.add(reslutMap);
			return resultList;
		}
		
		// PT用ログ
		DEBUG_LOG.debug("getFileInfoArray:リクエストファイルの読出に成功しました。");
		
		// 画面IDとイベントIDを取得
		String gamenID = super.getGamenId();
		String eventID = super.getSession().getViewParamId().getEventID();
		
		try
		{
			//----------------------------------------------------------
			// 指定ファイルが拡張子制限に該当しているかどうかを確認する
			//----------------------------------------------------------
			// OK,NG拡張子リスト
			ArrayList<String> listExtOK = new ArrayList<String>();
			ArrayList<String> listExtNG = new ArrayList<String>();
			
			// 全体禁止定義
			String allForbidExt = "";
			keyProperties = "FILEUPLOAD_NG_EXTENSION";
			allForbidExt = JCCUploadRestrictionCache.getValue(keyProperties);
			if(allForbidExt == null)
			{
				allForbidExt = "";
			}
			
			// 指定がある場合は禁止リストに登録
			if(CHKNULL.equals(allForbidExt) == false)
			{
				listExtNG.addAll(getSeparateList(allForbidExt, ";"));
			}
			
			// 個別禁止定義
			String uniForbidExt = "";
			uniForbidExt = JCCUploadRestrictionCache.getValue(gamenID + ";" + eventID);
			if(uniForbidExt == null)
			{
				uniForbidExt = "";
			}
			
			// 該当する画面ID＆イベントIDがある場合はOK/NGリストを作成
			if(CHKNULL.equals(uniForbidExt) == false)
			{
				// 区切り文字","以降が拡張子の文字列
				int offset = uniForbidExt.indexOf(",");
				if(uniForbidExt.substring(0, 2).equals("NG"))
				{
					// NGリスト作成(または追加)
					listExtNG.addAll(getSeparateList(uniForbidExt.substring(offset + 1), ";"));
				}
				else if(uniForbidExt.substring(0, 2).equals("OK"))
				{
					// OKリスト作成
					listExtOK.addAll(getSeparateList(uniForbidExt.substring(offset + 1), ";"));
				}
			}
			// 読み出したファイル情報の拡張子がアップロード可能かどうか確認する
			for(int i = 0; i < fileSizeVec.size(); i++)
			{
				reslutMap = new HashMap<String, Object>();
				
				// vector形式のファイル情報ハッシュマップに変換
				X33CHashMap tmpMap = fileSizeVec.elementAt(i);
				if(tmpMap == null || tmpMap.isEmpty())
				{
					continue;
				}
				// ファイル名から拡張子を取得
				String fileName = tmpMap.getString("ファイル名");
				if(CHKNULL.equals(fileName) == true)
				{
					continue;
				}
				String extName = fileName.substring(fileName.lastIndexOf(".") + 1);
				
				// 拡張子無しのファイルが指定されている場合は特殊判断
				if(fileName.equals(extName) == true)
				{
					extName = ":::";
				}
				// NGリストに拡張子が合致するかどうか検索
				boolean hit = false;
				if(listExtNG.contains(extName) == true)
				{
					hit = true;
				}
				// 更にOKリストが存在する場合は、OKリストに無いファイル名はNG扱い
				if(hit == false && listExtOK.size() > 0)
				{
					if(listExtOK.contains(extName) == false)
					{
						hit = true;
					}
				}
				// 制限拡張子に該当した場合は結果コードにファイルをセット
				if(hit == true)
				{
					reslutMap.put("resultCode", "FILE_EXTENSION_ERROR");
					reslutMap.put("fileName", fileName);
					reslutMap.put("nameValue", tmpMap.getString("パラメータ名"));
					resultList.add(reslutMap);
				}
			}
			// 拡張子制限に該当した場合はここで作成したリストを復帰
			if(resultList.size() > 0)
			{
				return resultList;
			}
			
			// PT用ログ
			DEBUG_LOG.debug("getFileInfoArray:拡張子制限に該当しませんでした。");
			
			//----------------------------------------------------------
			// ファイルの保存先をセッションにするかHDDにするか決定
			//----------------------------------------------------------
			keyProperties = "FILEUPLOAD_TEMPORARILY_SESSION";
			String saveSession = JCCUploadRestrictionCache.getValue(keyProperties);
			
			ArrayList<String> listSession = new ArrayList<String>();
			listSession.addAll(getSeparateList(saveSession, ","));
			
			// 指定の画面IDとイベントIDに合致を確認
			for(int i = 0; i < listSession.size(); i++)
			{
				String tmpGamen = "";
				String tmpEvent = "";
				// リスト内の画面ID,イベントIDを取得
				String tmpStr = listSession.get(i);
				// 画面ID
				tmpGamen = tmpStr.substring(0, tmpStr.indexOf(";"));
				tmpStr = tmpStr.substring(tmpStr.indexOf(";") + 1);
				// イベントID
				tmpEvent = tmpStr;
				
				// 画面IDとイベントIDが合致する場合はセッション保存フラグを立てる
				if(tmpGamen.equals(gamenID) == true &&  tmpEvent.equals(eventID) == true)
				{
					saveSessionMode = true;
					break;
				}
			}
			//----------------------------------------------------------
			// 0バイトファイルの有無チェック
			//----------------------------------------------------------
			// ファイル中に0バイトのファイルがある場合は結果コードを格納して復帰
			for(int i = 0; i < fileSizeVec.size(); i++)
			{
				reslutMap = new HashMap<String, Object>();
				
				X33CHashMap tmpMap = fileSizeVec.elementAt(i);
				if(tmpMap == null || tmpMap.isEmpty())
				{
					continue;
				}
				// ファイル名無しの場合はチェックしない
				if(CHKNULL.equals(tmpMap.get("ファイル名")) == true)
				{
					continue;
				}
				// ファイルサイズを取得して0バイトならば結果コードを格納して復帰
				Long fileSize =  (Long)(tmpMap.get("ファイルサイズ"));
				if(fileSize.longValue() == 0)
				{
					reslutMap.put("resultCode", "FILE_SIZE_ZERO");
					reslutMap.put("fileName", tmpMap.getString("ファイル名"));
					reslutMap.put("nameValue", tmpMap.getString("パラメータ名"));
					resultList.add(reslutMap);
					reslutMap = new HashMap<String, Object>();
				}
				
				// ファイルサイズの合計値を加算
				fileSizeSum += fileSize;
			}
			// ファイルサイズが0のファイルが存在した場合はここで作成したリストを復帰
			if(resultList.size() > 0)
			{
				return resultList;
			}
			
			// PT用ログ
			DEBUG_LOG.debug("getFileInfoArray:0バイトのファイルは存在しませんでした。");

			// 既に同一セッション上で一時ファイルを作成している場合はサイズを加算
// 2013/01/09 FST_mukuo) 同一セッション上で保持していてもサイズ加算はしない start
/**
			FileInputStream sizeIs = null;
			byte[] poolData = null;
			if(saveSessionMode == true)
			{
				seMap = getSessionObject("SESSION_RENBAN");
				if(seMap != null)
				{
					poolMap = (HashMap<String, Object>)seMap.get(true);
					if(poolMap != null && poolMap.size() > 0)
					{
						Set keySet = poolMap.keySet();
						Iterator keyIte = keySet.iterator();
						while(keyIte.hasNext())
						{
							String key = (String)keyIte.next();
							if(poolMap.containsKey(key) == true)
							{
								poolData = (byte[])poolMap.get(key);
								fileSizeSum += poolData.length;
							}
						}
					}
				}
			}
			else
			{
				seMap = getSessionObject("FILE_RENBAN");
				if(seMap != null)
				{
					poolMap = (HashMap<String, Object>)seMap.get(true);
					if(poolMap != null && poolMap.size() > 0)
					{
						Set keySet = poolMap.keySet();
						Iterator keyIte = keySet.iterator();
						while(keyIte.hasNext())
						{
							String key = (String)keyIte.next();
							if(poolMap.containsKey(key) == true)
							{
								File fl = new File((String)poolMap.get(key));
								if(fl.exists() == true)
								{
// 2012/08/17 FST)arata Fortify対応 start
									try
									{
										sizeIs = new FileInputStream((String)poolMap.get(key));
										fileSizeSum += sizeIs.available();
									}
									finally
									{
										if(sizeIs != null)
										{
											sizeIs.close();
										}
									}
// 2012/08/17 FST)arata Fortify対応 end
								}
							}
						}
					}
				}
			}
**/
// 2013/01/09 FST_mukuo) 同一セッション上で保持していてもサイズ加算はしない end
			//----------------------------------------------------------
			//	アップロードファイルサイズ制限値チェック
			//----------------------------------------------------------
			// アップロードファイルサイズ個別制限値の取得
			keyProperties = "FILEUPLOAD_CUSTOM_SIZE";
			String uniSize = JCCUploadRestrictionCache.getValue(keyProperties);
			keyProperties = "FILEUPLOAD_DEFAULT_SIZE";
			String zenSize = JCCUploadRestrictionCache.getValue(keyProperties);
			
			// 設定値が無い場合はデフォルトの制限値5Mとする
			if(zenSize == null || CHKNULL.equals(zenSize) == true)
			{
				zenSize = "5";
			}
			if(uniSize == null)
			{
				uniSize = "";
			}
			
			// 文字列の設定値を数値に変換
			long allSize = Long.parseLong(zenSize);
			boolean over = false;
			boolean hit = false;
			
			// 比較用に単位を揃える(MByte->Byte)
			allSize <<= 20;
			// 個別の画面IDとイベントIDとサイズの値を区切り文字単位で分割
			ArrayList<String> listKobetu = new ArrayList<String>();
			listKobetu.addAll(getSeparateList(uniSize, ","));
			
			// 個別指定の画面IDとイベントIDに合致する場合は、その値を制限値とする
			for(int i = 0; i < listKobetu.size(); i++)
			{
				String tmpGamen = "";
				String tmpEvent = "";
				String tmpStrSize = "";
				long  tmpSize = 0;
				// リスト内の画面ID,イベントID,サイズ指定を取得
				String tmpStr = listKobetu.get(i);
				// サイズ指定値を取得
				tmpStrSize =  tmpStr.substring(tmpStr.lastIndexOf(";") + 1);
				// 画面IDとイベントIDが合致する場合はサイズ超過を確認
				if(listKobetu.contains((gamenID + ";" + eventID + ";" + tmpStrSize)))
				{
					hit = true;
					
					tmpSize = Long.parseLong(tmpStrSize);
					// 比較用に単位を揃える(MByte->Byte)
					tmpSize <<= 20;
					if(fileSizeSum > tmpSize)
					{
						over = true;
						break;
					}
				}
			}
			// 個別指定に該当しない場合は、全体サイズをチェック
			if(hit == false)
			{
				if(fileSizeSum > allSize)
				{
					over = true;
				}
			}
			if(over == true)
			{
				reslutMap = new HashMap<String, Object>();
				
				reslutMap.put("resultCode", "FILE_SIZE_NG");
				reslutMap.put("fileSize", (Long)fileSizeSum);
				resultList.add(reslutMap);
			}
			// ファイルサイズ超過ならばここで作成したリストを復帰
			if(resultList.size() > 0)
			{
				return resultList;
			}
			
			// PT用ログ
			DEBUG_LOG.debug("getFileInfoArray:ファイルサイズ制限を超過しませんでした。");
			
			//--------------------------------------------------------------
			// ファイルの連番を発行する
			//--------------------------------------------------------------
			String tmpNum = "";
			int seriesIndex = 0;
			// 既に同一セッション上で連番を発行している場合はその分の連番を加算
// 2013/01/09 FST_mukuo) 同一セッション上で保持していても連番の加算はしない start
/**
			if(saveSessionMode == true)
			{
				seMap = getSessionObject("SESSION_RENBAN");
			}
			else
			{
				seMap = getSessionObject("FILE_RENBAN");
			}
			if(seMap != null)
			{
				poolMap = (HashMap<String, Object>)seMap.get(true);
				if(poolMap.isEmpty() == false)
				{
					seriesIndex += poolMap.size();
				}
			}
**/
// 2013/01/09 FST_mukuo) 同一セッション上で保持していても連番の加算はしない end
			// ファイルの数分連番を発行
			for(int i = 0; i < fileSizeVec.size(); i++)
			{
				// vector形式のファイル情報ハッシュマップに変換
				X33CHashMap tmpMap = fileSizeVec.elementAt(i);
				if(tmpMap == null || tmpMap.isEmpty())
				{
					continue;
				}
				// ファイル名無しの場合はチェックしない
				if(CHKNULL.equals(tmpMap.get("ファイル名")) == true)
				{
					continue;
				}
				// 連番を生成( 連番は0001からスタート )
				tmpNum = tmpNum.format("%04d_", seriesIndex+1);
				// セッション保存かHDD保存かの識別子を付与
				if(saveSessionMode == true)
				{
					// セッション保存識別子
					tmpNum = tmpNum + "S_";
					// ファイル名付与
					tmpNum = tmpNum + tmpMap.getString("ファイル名");
				}
				else
				{
					// HDD保存識別子
					tmpNum = tmpNum + "F_";
					tmpNum = tmpNum + UUID.randomUUID();
					// ファイル名に使用できない記号は置換する
					tmpNum = tmpNum.replace(":", "_");
					tmpNum = tmpNum.replace("-", "0");
				}
				// 連番をリストにセット
				listSeriesNum.add(tmpNum);
				
				seriesIndex++;
			}
			//--------------------------------------------------------------
			// 一時ファイルを生成する
			//--------------------------------------------------------------
			File fl = null;
			String sessionKey = "";
			HashMap<String, Object> saveMap = new HashMap<String, Object>();
			seriesIndex = 0;
			// ファイルをセッションに保存する場合
			if(saveSessionMode == true)
			{
				// セッション名
				sessionKey = "SESSION_RENBAN";
				
				//既に同一セッションで登録されている連番が存在する場合はHashMapを連結
				seMap = getSessionObject(sessionKey);
				if(seMap != null)
				{
					poolMap = (HashMap<String, Object>)seMap.get(true);
					if(poolMap.isEmpty() == false)
					{
						saveMap.putAll((HashMap)poolMap);
					}
				}
				// 一時ファイルの実体をメモリ上に生成（セッション登録は最後）
				for(int i = 0; i < fileSizeVec.size(); i++)
				{
					reslutMap = new HashMap<String, Object>();
					
					// vector形式のファイル情報ハッシュマップに変換
					X33CHashMap tmpMap = fileSizeVec.elementAt(i);
					if(tmpMap == null || tmpMap.isEmpty())
					{
						continue;
					}
					// ファイル名無しの場合はチェックしない
					if(CHKNULL.equals(tmpMap.get("ファイル名")) == true)
					{
						continue;
					}
					//ファイルサイズ分の領域を確保
					Long lSize = (Long)(tmpMap.get("ファイルサイズ"));
					String strSize = String.valueOf(lSize);
					int size = Integer.parseInt(strSize);
					byte[] area = new byte[(size + 1)];
					int ret = 0;
					
					// 管理領域からファイルの入力ストリームを取得
					is = super.getTempUploadFileStream(tmpMap.getString("パラメータ名"));
					bis = new BufferedInputStream(is, 5120);
					// ファイル読出し
					while(ret != -1)
					{
						ret = bis.read(area);
						if(ret == -1)
						{
							break;
						}
					}
					// ファイル連番と実体を紐付けてハッシュマップに登録
					saveMap.put(listSeriesNum.get(seriesIndex), (byte[])area);
					
					// 結果コードの作成
					reslutMap.put("resultCode", "FILE_INFO_OK");
					reslutMap.put("fileKey", listSeriesNum.get(seriesIndex));
					reslutMap.put("fileName", tmpMap.getString("ファイル名"));
					reslutMap.put("fileSize", (Long)(tmpMap.get("ファイルサイズ")));
					reslutMap.put("nameValue", tmpMap.get("パラメータ名"));	
					resultList.add(reslutMap);
					
					seriesIndex++;
				}
			}
			// ファイルをHDDに保存する場合
			else
			{
				//OS固有の区切り文字を取得
				String sep = "";
				sep = File.separator;
				// セッション名
				sessionKey = "FILE_RENBAN";
				//既に同一セッションで登録されている連番が存在する場合はHashMapを連結
				seMap = getSessionObject(sessionKey);
				if(seMap != null)
				{
					poolMap = (HashMap<String, Object>)seMap.get(true);
					if(poolMap.isEmpty() == false)
					{
						saveMap.putAll((HashMap)poolMap);
					}
				}
				// 一時ファイル保存先のパスを取得
				String fullPath = "";
				keyProperties = "FILEUPLOAD_TEMPORARILY_PATH";
				// 2012/03/28 アプリケーションプロパティファイルからの取得に変更 start
				//String savePath = JCCUploadRestrictionCache.getValue(keyProperties);
				String savePath = JCCWebCommon.getApplicationConst(keyProperties);
				// 2012/03/28 アプリケーションプロパティファイルからの取得に変更 end
				
				// パス設定無しは不可
				if(savePath == null || CHKNULL.equals(savePath))
				{
					reslutMap = new HashMap<String, Object>();
					reslutMap.put("resultCode", "PROPERTY_READ_ERROR");
					resultList.add(reslutMap);
					return resultList;
				}
				
				savePath = savePath + ((sep + JCCWebCommon.getSysDate() + sep));
				
				// ディレクトリが存在しない場合はディレクトリを作成(排他制御属性のメソッド)
				if(makeDir(savePath) == false)
				{
					// ディレクトリ作成失敗でも処理継続
					DEBUG_LOG.error("getFileInfoArray:一時ファイル保存先ディレクトリの作成に失敗しました。");
				}
				// 一時ファイルの生成及びセッション領域での連番とフルパスの管理
				
				// ファイル作成失敗時ファイル削除パスを格納するリスト
				ArrayList<String> zipFilePathList = new ArrayList<String>();
				for(int i = 0; i < fileSizeVec.size(); i++)
				{
					reslutMap = new HashMap<String, Object>();
					
					// vector形式のファイル情報ハッシュマップに変換
					X33CHashMap tmpMap = fileSizeVec.elementAt(i);
					if(tmpMap == null || tmpMap.isEmpty())
					{
						continue;
					}
					// ファイル名無しの場合はチェックしない
					if(CHKNULL.equals(tmpMap.get("ファイル名")) == true)
					{
						continue;
					}
					// 管理領域からファイルの入力ストリームを取得
					is = super.getTempUploadFileStream(tmpMap.getString("パラメータ名"));
					
					// 2012/06/07 ファイル圧縮フラグがtrueの場合は圧縮ファイルで一時ファイル化する start
					if(zipFlg == true)
					{
						File zipFile = null;
						FileOutputStream fos = null;
						try 
						{
							// 出力ファイルパス
							fullPath = (savePath + listSeriesNum.get(seriesIndex));
							// 出力する圧縮ファイルのFileインスタンス生成
							zipFile = new File(fullPath); 
							zipFilePathList.add(fullPath);
							// zipファイルoutputStream
							fos = new FileOutputStream(zipFile);
							zos = new ZipOutputStream(fos);
							// エントリー用のファイル名の取得
							ZipEntry ztarget = new ZipEntry((String)tmpMap.get("ファイル名")); 
							// 圧縮レベルを設定をする
							zos.setLevel(Integer.valueOf(JCCWebCommon.getApplicationConst("COMP_LEVEL")));
							// ZIP ファイルエントリの書き込みを開始
							zos.putNextEntry(ztarget);
							// 読込データのチェックサムも保持する入力ストリームを生成
							cis = new CheckedInputStream(is, new CRC32());
							bis = new BufferedInputStream(cis, 5120);
							//ファイルサイズ
							int filesize = 0;
							//読込サイズ
							int readsize = 0;
							//データの読込先のバッファ
							byte buf[] = new byte[5120];
							//読込ファイルが終了するまで読み込み、出力ストリームで書き出す。
							while((readsize = bis.read(buf, 0, buf.length)) != -1)
							{
								filesize += readsize;
								zos.write(buf, 0, readsize);
							}
							//CRC32チェックサム
							ztarget.setCrc(cis.getChecksum().getValue());
							//圧縮解除時サイズ
							ztarget.setSize(filesize);
							// 本物のファイル名にzip拡張子をつける
							tmpMap.put("ファイル名",tmpMap.getString("ファイル名") + ".zip");
						}
						catch(Exception e)
						{
							if(null != zipFile)
							{
								if(zipFile.length() != 0)
								{
									zos.close();
								}
							}
							for(int list = 0; list < zipFilePathList.size(); list++)
							{
								new File(zipFilePathList.get(list)).delete();
							}
							throw new JCCFrameworkException("ファイル圧縮処理でエラーが発生しました。", e);
						}
						finally
						{
							try
							{
								if(bis != null)
								{
									bis.close();
								}
								if(cis != null)
								{
									cis.close();
								}
								if(zos != null)
								{
									if(zipFile.length() > 0)
									{
										zos.close();
									}
								}
								if(fos != null)
								{
									fos.close();
								}
							}
							catch(Exception ex)
							{
								throw new JCCFrameworkException(ex);
							}
						}
					}
					// 2012/06/07 ファイル圧縮フラグがtrueの場合は圧縮ファイルで一時ファイル化する end
					else
					{
						// ファイルのフルパスを生成して、出力ストリームを作る
						fullPath = (savePath + listSeriesNum.get(seriesIndex));
						os = new FileOutputStream(fullPath);
						
						bis = new BufferedInputStream(is, 5120);
						bos = new BufferedOutputStream(os, 5120);
						// ファイルの書込み
						int ret = 0;
						while(ret != -1)
						{
							ret = bis.read();
							if(ret == -1)
							{
								break;
							}
							bos.write(ret);
						}
						bos.flush();
						bos.close();
						bis.close();
						os.close();
					}
					is.close();
					
					// 連番とフルパスをハッシュマップに登録
					saveMap.put(listSeriesNum.get(seriesIndex), fullPath);
					
					// 結果コードの作成
					reslutMap.put("resultCode", "FILE_INFO_OK");
					reslutMap.put("fileKey", listSeriesNum.get(seriesIndex));
					reslutMap.put("fileName", tmpMap.getString("ファイル名"));
					reslutMap.put("fileSize", (Long)(tmpMap.get("ファイルサイズ")));
					reslutMap.put("nameValue", tmpMap.get("パラメータ名"));	
					resultList.add(reslutMap);
					
					seriesIndex++;
				}
			}
			// セッション領域に作成したハッシュマップを登録	
			try
			{
				super.setSessionObject(sessionKey, saveMap);
			}
			catch(X33SException x33)
			{
				DEBUG_LOG.error("getFileInfoArray:セッション領域へのアクセスに失敗しました。");
				resultList.clear();
				return resultList;
			}
		}
// 2013/01/10 FST_mukuo) エラーハンドリング方法を変更(ランタイム系Exceptionはそのままスロー) start
		catch(Exception e)
		{
			throw new JCCFrameworkException(e);
		}
/**
		// ファイル情報の読出しに失敗した場合
		catch(X33SException x33)
		{
			reslutMap = new HashMap<String, Object>();
			reslutMap.put("resultCode", "FILE_INFO_READ_ERROR");
			resultList.add(reslutMap);
			return resultList;
		}
		// ファイルの書込みに失敗した場合
		catch(IOException io)
		{
			DEBUG_LOG.error("getFileInfoArray:ファイルの読書きに失敗しました。");
			resultList.clear();
		}
		catch(Exception e)
		{
			String err1 = e.getMessage();
			String err2 = "プロパティファイルパスまたは文字コードの設定がありません" + keyProperties;
			String err3 = "Upload.propertiesのキーが重複しています。"+ keyProperties;
			// プロパティファイルの読出しに失敗した場合
			if(err1.equals(err2) == true || err1.equals(err3) == true)
			{
				reslutMap = new HashMap<String, Object>();
				reslutMap.put("resultCode", "PROPERTY_READ_ERROR");
				resultList.add(reslutMap);
			}
			else
			{
				DEBUG_LOG.error("getFileInfoArray:予期せぬシステムエラーが発生しました。");
				resultList.clear();
			}
			return resultList;
		}
**/
// 2013/01/10 FST_mukuo) エラーハンドリング方法を変更(ランタイム系Exceptionはそのままスロー) end
		finally
		{
			try
			{
				// ストリームを閉じる
				if(is != null)
				{
					is.close();
				}
				if(os != null)
				{
					os.close();
				}
				if(bis != null)
				{
					bis.close();
				}
				if(bos != null)
				{
					bos.close();
				}
			}
			catch (IOException io)
			{
				; // 何もしない
			}
		}
		return resultList;
	}
	
	/**
	 * アップロード一時ファイルをバイナリ形式で取得する。
	 * 
	 * @param fileKey アップロードファイルに紐づくキー。（ファイル連番）	
	 * @return byte[] アップロード対象となるファイルのバイナリデータ
	 * 			       ファイル読出しエラー時やファイルが存在しない場合はnull復帰。
	 */	
	public byte[] getFile(String fileKey)
	{
		// ファイル読出し用のストリーム
		InputStream is = null;
		BufferedInputStream bis = null;
		// 読み出したファイル格納用領域(nullで初期化)
		
		// ファイル読出し結果復帰値(念のためnull初期化)
		byte[] readData = null;
		
		// ファイル連番読出し用のハッシュマップ
		X31CHashMap<String, Object> tmpMap = new X31CHashMap<String, Object>();
		HashMap<String, Object> readMap = new HashMap<String, Object>();
		try
		{
			// fileKeyがnull指定の場合はエラー
			if(fileKey == null || fileKey.length() <= 6) 
			{
				DEBUG_LOG.error("getFile:ファイルキーが指定されていません。");
				return (readData = null);
			}
			// ファイルの保存先がセッション領域の場合
			else if(fileKey.substring(5, 6).equals("S"))
			{
				// セッション領域から連番を格納したハッシュマップを取得
				tmpMap = super.getSessionObject("SESSION_RENBAN");
				if(tmpMap != null)
				{
					readMap = (HashMap<String, Object>)tmpMap.get(true);
					if(readMap.containsKey(fileKey) == false)
					{
						DEBUG_LOG.error("getFile:キーに該当するファイルが見つかりません。fileKey=" + fileKey);
						return (readData = null); 
					}
					//キー名からファイルを取得
					readData = (byte[])readMap.get(fileKey);
				}
				else
				{
					DEBUG_LOG.error("getFile:セッション領域情報の読出しに失敗しました。");
					return (readData = null);
				}
			}
			// ファイルの保存先がHDD上の場合
			else if(fileKey.substring(5, 6).equals("F"))
			{
				//セッション領域から連番を格納したハッシュマップを取得
				tmpMap = super.getSessionObject("FILE_RENBAN");
				if(tmpMap != null)
				{
					readMap = (HashMap<String, Object>)tmpMap.get(true);
					if(readMap.containsKey(fileKey) == false)
					{
						DEBUG_LOG.error("getFile:キーに該当するファイルが見つかりません。fileKey=" + fileKey);
						return (readData = null); 
					}
					String filePath = (String)readMap.get(fileKey);
					//ファイルパスからストリームを取得
					is = new FileInputStream(filePath);
					readData = new byte[is.available()];
					int ret = 0;
					bis = new BufferedInputStream(is, 5120);
					while(ret != -1)
					{
						ret = bis.read(readData);
						if(ret == -1)
						{
							break;
						}
					}
					bis.close();
					is.close();
				}
				else
				{
					DEBUG_LOG.error("getFile:セッション領域情報の読出しに失敗しました。");
					return (readData = null);
				}
			}
			// 命名規則違反の場合もnull復帰
			else
			{
				DEBUG_LOG.error("getFile:キーに該当するファイルが見つかりません。fileKey=" + fileKey);
				return (readData = null);
			}
		}
		// セッション領域読出しエラー
		catch(X33SException x33)
		{
			DEBUG_LOG.error("getFile:セッション領域情報の読出しに失敗しました。");
			return (readData = null);
		}
		// ファイル読込みエラー
		catch(FileNotFoundException nf)
		{
			DEBUG_LOG.error("getFile:ファイルの読込みに失敗しました。");
			return (readData = null);
		}
		//ファイルデータリードエラー
		catch(IOException io)
		{
			DEBUG_LOG.error("getFile:ファイル読出中に異常が発生しました。");
			return (readData = null);
		}
		finally
		{
			try
			{
				// ストリームを閉じる
				if (is != null)
				{
					is.close();
				}
				if(bis != null)
				{
					bis.close();
				}
			}
			catch (IOException io)
			{
				;// 何もしない
			}
		}
		return readData;
	}
	
	/**
	 * アップロード一時ファイルを削除する。
	 * 
	 * @param fileKey アップロードファイルに紐づくキー。（ファイル連番）	
	 * @return なし（ファイルが存在しない場合は読出しエラー時は何もしないで復帰）
	 */	
	public void deleteFile(String fileKey)
	{
		// ファイル連番読出し用のハッシュマップ
		X31CHashMap<String, Object> tmpMap = new X31CHashMap<String, Object>();
		HashMap<String, Object> readMap = new HashMap<String, Object>();
	
		// セッション領域に保存した連番情報を読出し
		try
		{
			// fileKeyがnull指定の場合は何もせずに復帰
			if(fileKey == null || fileKey.length() <= 6) 
			{
				DEBUG_LOG.error("deleteFile:ファイルキーが指定されていません。");
				return;
			}
			// ファイルの保存先がセッション領域の場合
			else if(fileKey.substring(5, 6).equals("S"))
			{
				// セッション領域から連番を格納したハッシュマップを取得
				tmpMap = super.getSessionObject("SESSION_RENBAN");
				if(tmpMap != null)
				{
					readMap = (HashMap<String, Object>)tmpMap.get(true);
					// ファイルが存在しない場合は復帰
					if(readMap.containsKey(fileKey) == false)
					{
						DEBUG_LOG.error("deleteFile:キーに該当するファイルが見つかりません。" + fileKey);
						return;
					}
					// キーに紐づいたファイルの削除
					readMap.remove(fileKey);
				}
				else
				{
					DEBUG_LOG.error("deleteFile:セッション領域の読出しに失敗しました。");
					DEBUG_LOG.error("deleteFile:指定のファイル削除に失敗している可能性があります。fileKey=" + fileKey);
					return;
				}
			}
			// ファイルの保存先がHDD上の場合
			else if	(fileKey.substring(5, 6).equals("F"))
			{
				//セッション領域から連番を格納したハッシュマップを取得
				tmpMap = super.getSessionObject("FILE_RENBAN");
				if(tmpMap != null)
				{
					readMap = (HashMap<String, Object>)tmpMap.get(true);
					// ファイルが存在しない場合は復帰
					if(readMap.containsKey(fileKey) == false)
					{
						DEBUG_LOG.error("deleteFile:キーに該当するファイルが見つかりません。" + fileKey);
						return;
					}
					// キーに紐づいたファイルパスの取得
					String filePath = (String)readMap.get(fileKey);
					// ファイルの削除
					if(delFile(filePath) == false)
					{
						DEBUG_LOG.error("deleteFile:一時ファイルの削除に失敗しました。" + filePath);
						DEBUG_LOG.error("deleteFile:一時ファイルが残存する可能性があります。");
					}
					// 連番の削除
					readMap.remove(fileKey);
				}
				else
				{
					DEBUG_LOG.error("deleteFile:セッション領域の読出しに失敗しました。");
					DEBUG_LOG.error("deleteFile:指定のファイル削除に失敗している可能性があります。fileKey=" + fileKey);
					return;
				}				
			}
			// 命名規則違反の場合は何もせずに復帰
			else
			{
				DEBUG_LOG.error("deleteFile:キーに該当するファイルが見つかりません。" + fileKey);
				return;
			}
		}
		catch(X33SException x33)
		{
			//セッション領域読出し失敗の場合は何もしないで復帰
			DEBUG_LOG.error("deleteFile:セッション領域の読出しに失敗しました。");
			DEBUG_LOG.error("deleteFile:指定のファイル削除に失敗している可能性があります。fileKey=" + fileKey);
			return;
		}
		return;	
	}
	
	/**
	 * アップロードが完了した一時ファイルを、セッション領域またはHDD上から削除する。
	 * 
	 * @param
	 * @return
	 */	
	public void deleteCache()
	{
		//ファイル連番読出し用のハッシュマップ
		X31CHashMap<String, Object> tmpMap = new X31CHashMap<String, Object>();
		HashMap<String, Object> readSessionMap = new HashMap<String, Object>();
		HashMap<String, Object> readFileMap = new HashMap<String, Object>();
		
		// セッション領域に保存した連番情報を読出し
		try
		{
			// セッション上の実データ削除（連番管理領域=実データ領域）
			tmpMap = super.getSessionObject("SESSION_RENBAN");
			if(tmpMap != null)
			{
				readSessionMap = (HashMap<String, Object>)tmpMap.get(true);
				if(readSessionMap != null && readSessionMap.size() > 0)
				{
					readSessionMap.clear();
				}
			}
			// HDD上のデータ削除
			tmpMap = super.getSessionObject("FILE_RENBAN");
			if(tmpMap != null)
			{
				readFileMap = (HashMap<String, Object>)tmpMap.get(true);
				if(readFileMap != null && readFileMap.size() > 0)
				{
					Set keySet = readFileMap.keySet();
					Iterator keyIte = keySet.iterator();
					while(keyIte.hasNext())
					{
						String key = (String)keyIte.next();
						String filePath = (String)readFileMap.get(key);
						if(delFile(filePath) == false)
						{
							DEBUG_LOG.error("deleteCache:一時ファイルの削除に失敗しました。" + filePath);
							DEBUG_LOG.error("deleteCache:一時ファイルが残存する可能性があります。");
						}
					}
					readFileMap.clear();
				}
			}
		}
		catch(X33SException x33)
		{
			//セッション領域読出し失敗の場合は何もしないで復帰
			DEBUG_LOG.error("deleteCache:セッション領域の読出しに失敗しました。");
			DEBUG_LOG.error("deleteCache:一時ファイルが残存する可能性があります。");
			return;
		}
		return;
	}
	
	/**
	 * 任意の文字列と区切り文字を指定して、区切り文字を除いたリストを作る。
	 * 
	 * @param arg1	  リストの元になる文字列
	 * @param kugiri 指定の区切り文字
	 * @return 文字列リスト。
	 */	
	private ArrayList<String> getSeparateList(String arg1, String kugiri)
	{
		ArrayList<String> list = new ArrayList<String>();
		if(arg1 == null || kugiri == null)
		{
			return list;
		}
		int offset = 0;
		int length = arg1.length();
		int extlen = 0;
		String tmpStr1 = arg1;
		String tmpStr2 = "";
		
		while(offset < length)
		{
			// 区切り文字を検出して、そこまでの文字列をリストに追加
			extlen = tmpStr1.indexOf(kugiri);
			if(extlen == 0)
			{
				//拡張子無しファイルを指定する場合は特殊文字をリストにセット
				list.add(":::");
			}
			else if(extlen != -1)
			{
				tmpStr2 = tmpStr1.substring(0, extlen);
				// 前後のスペースは削除して登録
				list.add(tmpStr2.trim());
			}
			// 区切り文字が見つからない場合は残り文字列を全て格納してbreak
			else
			{
				// 前後のスペースは削除して登録
				list.add(tmpStr1.trim());
				break;
			}
			// offset値の加算と読み出した分の文字列をトリミング（
			offset += (extlen + 1);
			tmpStr1 = tmpStr1.substring(extlen + 1);
		}
		return list;
	}
	
	/**
	 * 指定されたパスに対してディレクトリが存在しなければ
	 * ディレクトリを作成する（排他制御）
	 * 
	 * @param path	ディレクトリを作るパス
	 * @return 作成成否
	 */	
	private synchronized boolean makeDir(String path)
	{
		File fl = null;
		boolean ret = true;
		if(path == null)
		{
			return ret;
		}		
		fl = new File(path);
		if(fl.exists() == false)
		{
			if(fl.mkdirs() == true)
			{
				ret = true;
			}
			else
			{
				ret = false;
			}
		}
		return ret;
	}
	
	/**
	 * 指定されたパスに対してファイルが存在する場合は
	 * ファイルを削除する（排他制御）
	 * 
	 * @param path	ディレクトリを作るパス
	 * @return 削除成否（無い場合はtrue）
	 */	
	private synchronized boolean delFile(String path)
	{
		boolean ret = true;
		if(path == null)
		{
			return ret;
		}
		File deleteFile = new File(path);
		
		// ファイルが存在する場合のみ削除
		if(deleteFile.exists() == true)
		{
			if(deleteFile.delete() == true)
			{
				ret = true;
			}
			else
			{
				ret = false;
			}
		}
		return ret;
	}
	
	
	/**
	 * 一時ファイルダウンロード処理です。
	 * 一時ファイルを生成し、呼び出し元へダウンロードします。電子ファイル管理は行いません。
	 * 
	 * @param downloadData ダウンロード対象となるファイルのバイナリデータ
	 * @param fileName ダウンロード対象となるファイルの実ファイル名
	 * @throws JCCFrameworkException 
	 */
	public void setTempDownloadFile(byte[] downloadData, String fileName) throws JCCFrameworkException
	{
		// バイナリファイルチェック
		if (null == downloadData || 0 == downloadData.length)
		{
			throw new JCCFrameworkException("バイナリファイルがnullもしくは要素数が0です");
		}
		// ファイル名チェック
		String strFileName = null;
		if(null != fileName)
		{
			strFileName = JPCEditString.trim(fileName);
		}
		if (null == fileName || true == "".equals(strFileName))
		{
			throw new JCCFrameworkException("ファイル名がnullもしくは空白です");
		}
		
		// 禁止拡張子をチェック
		String newFileName = checkExension(fileName);

		// 一時ファイルのファイル名（フルパス）を取得
		String tmpFullPathName = getTmpFullPath();
		
		// 一時ファイルを出力
		if(!outputTmpFile(downloadData, tmpFullPathName))
		{
			throw new JCCFrameworkException("一時ファイル作成に失敗しました");
		}

		// ファイルダウンロード情報の設定
		super.setDownloadFile(tmpFullPathName, newFileName, true);
		// 2016/02/24 ANK-2680-00-00 ADD START
		// アクセスログ出力サービスIF呼び出し
		accessLogInvokeService(fileName);
		// 2016/02/24 ANK-2680-00-00 ADD END
		
	}

	/**
	 * 電子管理ファイルダウンロード処理です。
	 * 電子ファイル検索を行い、呼び出し元へダウンロードします。
	 * 
	 * @param fileKey ダウンロードファイルに紐づくファイルキー
	 * @param fileName ダウンロード対象となるファイルの実ファイル名
	 * @throws JCCFrameworkException 
	 */
	public void setDownloadFile(String fileKey, String fileName) throws JCCFrameworkException
	{
		// ファイルキーチェック
		String strfileKey = null;
		if(null != fileKey)
		{
			strfileKey = JPCEditString.trim(fileKey);
		}
		if (null == fileKey || true == "".equals(strfileKey))
		{
			throw new JCCFrameworkException("ファイルキーがnullもしくは空白です");
		}
		// ファイル名チェック
		String strfileName = null;
		if(null != fileName)
		{
			strfileName = JPCEditString.trim(fileName);
		}
		if (null == fileName || true == "".equals(strfileName))
		{
			throw new JCCFrameworkException("ファイル名がnullもしくは空白です");
		}
		
		// 電子ファイル番号付け替え
		String fileKanriNo = getReplaceNoString(fileKey);

		if (null == fileKanriNo)
		{
			throw new JCCFrameworkException("ダウンロードファイルを管理するキーがセッションにありません");
		}
		
		// 電子ファイル管理サービスIF呼び出し
		byte [] downloadData = efielInvokeService(fileKanriNo);
		
		
		// 禁止拡張子をチェック
		String newFileName = checkExension(fileName);

		// 一時ファイルのファイル名（フルパス）を取得
		String tmpFullPathName = getTmpFullPath();
		
		
		// 一時ファイルを出力
		if(!outputTmpFile(downloadData, tmpFullPathName))
		{
			throw new JCCFrameworkException("一時ファイル作成に失敗しました");
		}

		// ファイルダウンロード情報の設定
		super.setDownloadFile(tmpFullPathName, newFileName, true);
		// 2016/02/24 ANK-2680-00-00 ADD START
		// アクセスログ出力サービスIF呼び出し
		accessLogInvokeService(fileName);
		// 2016/02/24 ANK-2680-00-00 ADD END

	}

	/**
	 * 電子ファイル管理サービスIF呼び出し処理です。
	 * 
	 * @param fileKanriNo 電子ファイル管理番号
	 * @return []
	 */
	private byte [] efielInvokeService(String fileKanriNo)
	{
		byte [] retFileData = null;

		String fileKey = fileKanriNo;
		
		JCCWebCommon.getScreenInfo(this);
		// パラメータ作成
		X31SDataBeanAccess bean = super.getServiceFormBean();
		
		X31SDataBeanAccess[] paramBean = {bean};
		// ユースケースID格納用マップを生成。
		HashMap paramMap = new HashMap();
		paramMap.put(X31CWebConst.TELEGRAM_INFO_USECASE_ID, "CCSV0001");
		HashMap inputMap = new HashMap();
		HashMap outputMap = new HashMap();
		HashMap attachMap = new HashMap();
		
		// 上りマッピング
		CCSV0001_CCSV0001OPDBMapper mapper = new CCSV0001_CCSV0001OPDBMapper();
		mapper.setCCSV0001SC(paramBean, inputMap, "2", fileKey);
		
		// 電子ファイル管理サービス呼び出し
		// 電子ファイル番号付け替え処理を走らさないためにスーパークラスのメソッドを呼ぶ
		X31CMessageResult msgResult = super.invokeService(paramMap, inputMap, outputMap, attachMap);
		if(msgResult != null)
		{
			throw new JCCWebServiceException(msgResult);
		}

		// 下りマッピング
		retFileData = mapper.getCCSV0001SC(paramBean, outputMap, attachMap) ;
		
		return retFileData;
	}

	/**
	 * 電子ファイル管理番号付け替え処理です。
	 * 業務テーブルより取得した電子ファイル管理番号をファイル連番に変換します。
	 * 
	 * @param outputMap invokeServiceの出力用引数
	 * @param paramMap invokeServiceの入力用引数
	 */
	private void getReplaceNoMap(HashMap<String,Object> outputMap, Map paramMap)
	{
	
		// 引数チェック
		if(null == outputMap)
		{
			JSYwebLog.println(JSYwebLog.ERROR, getClass(), null, "BPCON0I002", new String[]{"出力用Mapがnullです"}, null);
			return;
		}
			
		// 定義ファイル読み込み
		JCCDownloadRestrictionCache.setPath();
		String strKey = null;
		try 
		{
			strKey = JCCDownloadRestrictionCache.getValue("EFILE_KANRI_NO_KEY");
		}
		catch(Exception e)
		{
			JSYwebLog.println(JSYwebLog.ERROR, getClass(), null, "BPCON0I002", new String[]{"定義ファイル読み込みに失敗しました"}, null);
			return;
		}
		
		// 2011/11/15 「EFILE_KANRI_NO_INDIVIDUAL_KEY」が複数の場合を考慮 start
		ArrayList<String> strKeyList = new ArrayList<String>();
		strKeyList.add(strKey);
		String[] strIndividualKeyList = null;
		try 
		{
			String strIndividualKey = JCCDownloadRestrictionCache.getValue("EFILE_KANRI_NO_INDIVIDUAL_KEY");
			if(!(strIndividualKey == null || "".equals(strIndividualKey)))
			{
				strIndividualKeyList = strIndividualKey.split(",");
				for(int i = 0 ; i < strIndividualKeyList.length; i++)
				{
					String[] separate = strIndividualKeyList[i].split(";");
					if(separate[0].equals((String)paramMap.get(X31CWebConst.TELEGRAM_INFO_USECASE_ID)))
					{
						strKeyList.add(separate[1]);
					}
				}
			}
		} 
		catch (Exception e) 
		{
			throw new JCCFrameworkException("ダウンロード定義ファイル読み込みに失敗しました(EFILE_KANRI_NO_INDIVIDUAL_KEY)");
		}
		// 2011/11/15 「EFILE_KANRI_NO_INDIVIDUAL_KEY」が複数の場合を考慮 end
		
		downLoadRenban = 1; // ファイル連番を初期化
		// 引数をコピー
		HashMap<String, Object> tempMap = new HashMap<String, Object>(outputMap);
		
		// マップ内の電子ファイル管理番号を検索
		ArrayList<HashMap<String, String>> saveMapList = new ArrayList<HashMap<String, String>>();
		
		// 2011/11/15 対象電子ファイル管理番号が複数の場合を考慮 start
		boolean kakikaeListFlg = true;
		for(int i = 0 ; i < strKeyList.size(); i++)
		{
			boolean kakikaeFlg = searchMapReplace(tempMap, strKeyList.get(i), saveMapList, true);
			if(!kakikaeFlg)
			{
				kakikaeListFlg = false;
			}
		}
		// 2011/11/15 対象電子ファイル管理番号が複数の場合を考慮 end

		// ファイル連番Mapをセッションに保存
		if(0 != saveMapList.size())
		{
			// 2011/11/15 書き換えフラグがfalse時にセッションのデータを置き換える
			if(!kakikaeListFlg)
			{
				super.setSessionObject("0001_S_UID", saveMapList);
			}
			// 2011/11/15 書き換えフラグがfalse時にセッションのデータを置き換える
		}
		
		// 電子ファイル管理番号更新	
		outputMap = tempMap;

		downLoadRenban = 1; // ファイル連番を初期化
	
	}
	
	/**
	 * テストメソッドです
	 * 
	 * @param outputMap invokeServiceの出力用引数
	 */
	protected void testgetReplaceNoMap(HashMap<String, Object> outputMap)
	{
		getReplaceNoMap(outputMap, new HashMap<String, Object>());
	}
	/**
	 * マップを検索し電子ファイル管理番号を置換します。
	 * 
	 * @param tempMap  検索対象のMap
	 * @param key      電子ファイル管理番号HashMapキー
	 * @param retList 返却用リスト
	 * @param kakikaeFlg セッションデータ書き換えフラグ（true:書き換えない、false:書き換える）
	 */
	
// 2011/11/15 セッション書き換えフラグを追加 start
	private boolean searchMapReplace(HashMap<String, Object> tempMap, String key,
			ArrayList<HashMap<String, String>> retList , boolean kakikaeFlg)
// 2011/11/15 セッション書き換えフラグを追加 end
	{
		for(Iterator<String> ite = tempMap.keySet().iterator(); ite.hasNext();)
		{
			// 項目IDを取得
			String itemId = ite.next();
			if(itemId.equals(key)) // キーが電子ファイル管理番号の場合
			{
				// 電子ファイル管理番号がセッションに登録されているか確認
				String fileRenban = checkKanriNo((String)tempMap.get(itemId));
				String renban = null;
				if(null != fileRenban)
				{
					// 元のファイル連番を使用する。
					renban = fileRenban;
					if(null == testRenban)
					{
						testRenban = renban;
					}
				}
				else
				{
					// 2011/11/15 セッション書き換えフラグをfalseにする start
					kakikaeFlg = false;
					// 2011/11/15 セッション書き換えフラグをfalseにする end
					// ファイル連番を発行
					renban = getFileRenban();

					if(null == testRenban)
					{
						testRenban = renban;
					}
				}
				// 返却用リストに格納
				HashMap<String, String> inMap = new HashMap<String, String>();
				inMap.put(renban, (String)tempMap.get(itemId));
				retList.add(inMap);
				
				// マップの管理番号を更新
				tempMap.put(key, renban);

			}
			else 				   // キーが電子ファイル管理番号の以外場合
			{
				Object value = tempMap.get(itemId);
				
				if(value instanceof ArrayList)// 値が配列型の場合
				{
					ArrayList list = (ArrayList)value;
					if(0 >= list.size())
					{
						continue;// 空配列の場合はスキップ
					}
					// 要素数分繰り返し
					for(int i = 0; i < list.size(); i++)
					{
						Object elem = list.get(i);
						
						if(null == elem)
						{
							continue;// 空の場合はスキップ
						}
						if(elem instanceof HashMap)// ハッシュの場合は子項目の分再帰呼び出し
						{
							
							HashMap<String, Object> subMap = (HashMap<String, Object>)elem;
							// 2011/11/15 セッション書き換えフラグ追加対応 start
							kakikaeFlg = searchMapReplace(subMap, key, retList, kakikaeFlg);
							// 2011/11/15 セッション書き換えフラグ追加対応 end
						}
						else
						{
							continue;		// 値がハッシュ以外場合はスキップ
						}

						
					}
				}
				else// 値が配列型以外の場合
				{
					Object elem = tempMap.get(itemId);
					
					if(null == elem)
					{
						continue;// 空の場合はスキップ
					}
					if(elem instanceof HashMap)// ハッシュの場合は子項目の分再帰呼び出し
					{
						
						HashMap<String, Object> subMap = (HashMap<String, Object>)elem;
						// 2011/11/15 セッション書き換えフラグ追加対応 start
						kakikaeFlg = searchMapReplace(subMap, key, retList, kakikaeFlg);
						// 2011/11/15 セッション書き換えフラグ追加対応 end
					}
					else
					{
						continue;		// 値がハッシュ以外場合はスキップ
					}
				}
			}
				
		}
		// 2011/11/15 セッション書き換えフラグを返却値にセットする start
		return kakikaeFlg;
		// 2011/11/15 セッション書き換えフラグを返却値にセットする end
	}
	
	/**
	 * 電子ファイル管理番号に紐付くファイル連番があるか検索し
	 * あればファイル連番を、無ければNULLを返します。
	 * 
	 * @param kanriNo ファイル連番
	 * @return ファイル管理番号
	 */
	private String checkKanriNo(String kanriNo)
	{
		String ret = null;
		X31CHashMap<String, Object> seMap = new X31CHashMap<String, Object>();
		ArrayList<HashMap<String, String>> MapList = new ArrayList<HashMap<String, String>>();
		String retStr = null;
		seMap = getSessionObject("0001_S_UID");
		
		if(null == seMap)
		{
			return null;
		}
		else
		{
			MapList = (ArrayList<HashMap<String, String>>)seMap.get(true);
			if(null != MapList)
			{
				for(int i = 0; i < MapList.size(); i++)
				{
					// セッション内に目当ての電子ファイル番号があった場合
					if(MapList.get(i).containsValue(kanriNo))
					{
						HashMap<String, String> inMap = MapList.get(i);
						for (Iterator<String> ite = inMap.keySet().iterator(); ite.hasNext();)
						{
							// 格納されているキーを取得
							String key = (String)ite.next();
							// 格納されているデータを取得
							String setData = (String)inMap.get(key);
							if(kanriNo.equals(setData))
							{
								ret = key;
								return ret;
							}
						}
					}
				}

			}
		}
		return null;
	}
	
	/**
	 * ファイル連番採番処理です。
	 * 
	 * @return ファイル連番
	 */
	private String getFileRenban()
	{
		String tmpNum = String.format("%04d_", downLoadRenban);
		tmpNum = tmpNum + "S_";
		tmpNum = tmpNum + UUID.randomUUID();
		downLoadRenban++;
		return tmpNum;
	}

	/**
	 * 電子ファイル管理番号付け替え処理です。
	 * ファイル連番を電子ファイル管理番号に変換します。
	 * 
	 * @param fileKey ファイル連番
	 * @return ファイル管理番号
	 */
	public String getReplaceNoString(String fileKey)
	{
		
		// 引数チェック
		if (null == fileKey)
		{
			JSYwebLog.println(JSYwebLog.ERROR, getClass(), null, "BPCON0I002", new String[]{"ファイルキーがnullです"}, null);
			return null;
		}
		X31CHashMap<String, Object> seMap = new X31CHashMap<String, Object>();
		ArrayList<HashMap<String, String>> MapList = new ArrayList<HashMap<String, String>>();
		String retStr = null;
		seMap = getSessionObject("0001_S_UID");
		
		if(null == seMap)
		{
			JSYwebLog.println(JSYwebLog.ERROR, getClass(), null, "BPCON0I002", new String[]{"管理番号取得に失敗しました"}, null);
			return null;
		}
		else
		{
			MapList = (ArrayList<HashMap<String, String>>)seMap.get(true);
			if(null != MapList)
			{
				for(int i = 0; i < MapList.size(); i++)
				{
					if(MapList.get(i).containsKey(fileKey))
					{
						retStr = MapList.get(i).get(fileKey);
					}
				}

			}
		}
		
		return retStr;
	}

	/**
	 * 禁止拡張子チェック処理です。
	 * ファイル名が禁止拡張子であった場合、拡張子を変更します。
	 * 
	 * @param fileName チェック対象ファイル名
	 * @return 変換後ファイル名（禁止拡張子でなかった場合は変更せずに返却）
	 */
	private String checkExension(String fileName)
	{
		
		try 
		{
			// アプリケーションプロパティファイルのパスを設定
			JCCDownloadRestrictionCache.setPath();
			String strKinshi = JCCDownloadRestrictionCache.getValue("FILEDOWNLOAD_NG_EXTENSION");
			
			if(null != strKinshi)
			{
				ArrayList<HashMap<String, String>> kinshiList = new ArrayList<HashMap<String, String>>();
				ArrayList<String> tmpList = new ArrayList<String>();
				tmpList.addAll(getSeparateList(strKinshi, ","));
				
				//プロパティーファイルの禁止拡張子と変更文字列を対にしてHashMapに格納
				for(int i = 0; i < tmpList.size(); i++)
				{
					HashMap<String, String> kakucyoshiMap = new 	HashMap<String, String>();
					String tmpStr = tmpList.get(i);
					kakucyoshiMap.put("kakuchoshi_str", tmpStr.substring(0, tmpStr.indexOf(";")));
					kakucyoshiMap.put("henko_str", tmpStr.substring(tmpStr.indexOf(";") + 1));
					kinshiList.add(kakucyoshiMap);
				}
				
				//ファイル名の拡張子と禁止拡張子を比較
				String extName = fileName.substring(fileName.lastIndexOf( "." ) + 1);
				
				// 拡張子無しのファイルの場合はそのまま返却
				if(true == fileName.equals(extName))
				{
					return fileName;
				}
				
				for(int i = 0; i < kinshiList.size(); i++)
				{
					//禁止拡張子だった場合、置換して返却
					if(extName.equals(kinshiList.get(i).get("kakuchoshi_str")))
					{
						return fileName.substring(0, fileName.lastIndexOf( "." ) + 1) + kinshiList.get(i).get("henko_str");
					}
				}
				
			}

		} catch (Exception e) 
		{
			// プロパティファイルの読出しに失敗した場合はスルー
			return fileName;
		}
		
		return fileName;
	}
	
	/**
	 * 一時ファイルのフルパス文字列を取得します。
	 * 
	 * @return 一時ファイルのフルパス
	 */
	private String getTmpFullPath()
	{
		
		String path = this.getDownloadTempDirAbsolutePath();
		String tmpFilename = this.getUniqueFileName();
		
		return path + File.separator + tmpFilename;
	}
	
	/**
	 * 一時ファイルを出力します。
	 * 
	 * @param downloadData ダウンロード対象となるファイルのバイナリデータ
	 * @param tmpFilename 一時ファイルのフルパス
	 * @return 結果（成功：true／失敗：false） 
	 */
	private boolean outputTmpFile(byte[] downloadData, String tmpFilename)
	{

		FileOutputStream fstream = null;
		BufferedOutputStream stream = null;
		try 
		{
			String dirPath = tmpFilename.substring(0, tmpFilename.lastIndexOf(File.separator));
			File dir = new File(dirPath);
			if(!dir.exists())
			{
				if(false == dir.mkdirs())
				{
					JSYwebLog.println(JSYwebLog.ERROR, getClass(), null, "BPCON0I002", new String[]{"作業ディレクトリの作成に失敗しました"}, null);
					return false;
				}				
			}
			else if(!dir.isDirectory())
			{
				String errmsg = "指定したパスはディレクトリではありません:" + dirPath;
				JSYwebLog.println(JSYwebLog.ERROR, getClass(), null, "BPCON0I002", new String[]{errmsg}, null);
				return false;
			}
			else if(!dir.canWrite())
			{
				String errmsg = "指定したパスに書き込み権限がありません:" + dirPath;
				JSYwebLog.println(JSYwebLog.ERROR, getClass(), null, "BPCON0I002", new String[]{errmsg}, null);
				return false;
			}
			
			// ファイル作成
			fstream = new FileOutputStream(new File(tmpFilename));
			stream = new BufferedOutputStream(fstream);
			stream.write(downloadData);
			
		} 
		catch (Exception e) 
		{
			JSYwebLog.println(JSYwebLog.ERROR, getClass(), null, "BPCON0I002", new String[]{e.getMessage()}, null);
			return false;
		}
		finally
		{
			try
			{
				if (null != stream)
				{
					stream.close();
				}
				if (null != fstream)
				{
					fstream.close();
				}
			}
			catch (IOException e)
			{
				;// 何もしない
			}
		}
		
		return true;
	}
	
	/**
	 * 共有フォームBeanのIPアドレス項目にクライアントのIPアドレスを設定します。
	 */
	private void setIPAddressToCommonInfoBean() 
	{
		// 共有フォームBean取得
		X31SDataBeanAccess bean = getCommonInfoBean();
		// IPアドレスを設定
		bean.sendMessageString("端末ＩＰアドレス", X31CWebConst.DATABEAN_SET_VALUE, super.getClientIPAddress());
	}
	
	/**
	 * 業務規制定義ファイルから対象サービスの業務規制を判定します。
	 * @param svcId サービスID
	 * @return 業務規制中サービスかの判定 (true:業務規制中ではない、false:業務規制中)
	 */
	public boolean chkWksijService(String svcId)
	{
//2013/03/27 電文蓄積再開時のサービス呼出し区分の変更対応 fst)yanagihara start
		// バックヤード/API/モバイルも電文蓄積の対象とする。
		// フロントおよび量販のみチェックを行う
//		String targetSystem = JCMAPLConstMgr.getString("TARGET_SYSTEM");
//		if(targetSystem.equals("FRONT") || targetSystem.equals("RYOHAN"))
//		{
//2013/03/27 電文蓄積再開時のサービス呼出し区分の変更対応 fst)yanagihara end
			// セッションより業務規制一覧情報の検索結果格納用マップを取得する。
			HashMap<String,  Object> lstMap = (HashMap<String, Object>)this.getSessionObject(JCCBusinessControl.KEY_SESSION);
			if(null == lstMap)
			{
				return true;
			}
			
			HashMap<String,  Object> sessionMap = (HashMap<String, Object>)lstMap.get(true);
			
			try
			{
				// 業務規制コードを取得
				JCCWorkRestrictionCache.setPath(JCCWorkRestrictionCache.FUNC_MODE_ONLINE);
				// 画面ID.サービスID
				String kiseiCd = JCCWorkRestrictionCache.getValue(JCCWorkRestrictionCache.FUNC_MODE_ONLINE, getGamenId() + "." + svcId);
				if(null == kiseiCd || 0 == kiseiCd.length())
				{
					return true;
				}
				// ","で分割する。
				String[] keySplit = kiseiCd.split(JCCWorkRestrictionCache.VAL_DELIMITERS);
				
				for(int i = 0; i < keySplit.length; i++)
				{
					// 業務規制一覧情報より業務規制コードの情報(マップ)を取得する
					if (!sessionMap.containsKey(keySplit[i]))
					{
						continue;
					}
					HashMap<String, String> recMap = (HashMap<String, String>)sessionMap.get(keySplit[i]);
					
					// 業務規制コードの規制フラグを取得する。
					String kiseiFlg = recMap.get(JCCBusinessControl.KEY_KISEI_FLG);
					if (null == kiseiFlg || "".equals(kiseiFlg.trim()))
					{
						continue;
					}
					// 規制フラグ = 1(規制中)の場合
					if ("1".equals(kiseiFlg))
					{
						// 規制中（false）を返却
						return false;
					}
				}
			}
			catch (Throwable e)
			{
				throw new JCCFrameworkException("規制定義ファイルキャッシュ情報の取得に失敗しました。", e);
			}
//2013/03/27 電文蓄積再開時のサービス呼出し区分の変更対応 fst)yanagihara start
//		}
//2013/03/27 電文蓄積再開時のサービス呼出し区分の変更対応 fst)yanagihara end
		return true;
	}
	
	/**
	 * 対象サービスを業務規制時更新電文テーブルへ格納します。
	 * @param svcId サービスID
	 * @param paramMap パラメータマップ
	 * @param inputMap 入力データマップ
	 * @param outputMap 出力データマップ
	 * @return X31CMessageResult 返却メッセージ情報
	 */
	public X31CMessageResult wksijInvokeService(String svcId, Map paramMap, Map inputMap, Map outputMap)
	{
		HashMap<String, String> usecaseMap = new HashMap<String, String>();
		HashMap<String, String> wksijUpdParamMap = new HashMap<String, String>();
		HashMap<String, Object> wksijUpdInputMap = new HashMap<String, Object>();
		XMLEncoder paramEnco = null;
		XMLEncoder inputEnco = null;

		try
		{
			// ユースケースID格納
			usecaseMap.put(X31CWebConst.TELEGRAM_INFO_USECASE_ID, "CCSV0009");
			// 機能コード設定
			wksijUpdParamMap.put("func_code", "1");
			// サービスID
			wksijUpdParamMap.put("svc_id", svcId);
			// パラメータマップ
			ByteArrayOutputStream paramBaos = new ByteArrayOutputStream();
			paramEnco = new XMLEncoder(paramBaos);
			paramEnco.writeObject(paramMap);
			paramEnco.close();
			wksijUpdParamMap.put("param_map", paramBaos.toString("UTF-8"));
			// 入力データマップ
			ByteArrayOutputStream inputBaos = new ByteArrayOutputStream();
			inputEnco = new XMLEncoder(inputBaos);
			inputEnco.writeObject(inputMap);
			inputEnco.close();
			wksijUpdParamMap.put("input_data_map", inputBaos.toString("UTF-8"));
			
			wksijUpdInputMap.put("CCSV000901SC", wksijUpdParamMap);
			return super.invokeService(usecaseMap, wksijUpdInputMap, outputMap);
			
		}
		catch(UnsupportedEncodingException e)
		{
			throw new JCCFrameworkException("業務規制時更新電文登録処理に失敗しました。");
		}
		finally
		{
			if(paramEnco != null)
			{
				paramEnco.close();
			}
			if(inputEnco != null)
			{
				inputEnco.close();
			}
		}
	}
	// 2016/02/24 ANK-2680-00-00 ADD START
	/**
	 * アクセスログ出力サービスIF呼び出し処理です。
	 * 
	 * @param fileName 実ファイル名
	 * @return 
	 */
	private void accessLogInvokeService(String fileName)
	{

		String fileKey = fileName;
		
		JCCWebCommon.getScreenInfo(this);
		// パラメータ作成
		X31SDataBeanAccess bean = super.getServiceFormBean();
		
		X31SDataBeanAccess[] paramBean = {bean};
		// ユースケースID格納用マップを生成。
		HashMap paramMap = new HashMap();
		HashMap inputMap = new HashMap();
		HashMap outputMap = new HashMap();
		
		// 画面IDとButtonIDを取得
		String gamenId = super.getGamenId();
		String actinId = super.getCurrentID().getComponentID();
		gamenId = gamenId + "." +  actinId;
				
		CCSV0008_CCSV0008OPDBMapper mapper = new CCSV0008_CCSV0008OPDBMapper();
		inputMap = mapper.setCCSV000801SC(paramBean, outputMap, "1", fileKey, gamenId);

		// アクセスログプロパティファイルに画面IDが無い場合
		if(inputMap == null)
		{
			return;
		}
		paramMap.put(X31CWebConst.TELEGRAM_INFO_USECASE_ID, "CCSV0008");
		
		// アクセスログ出力サービス呼び出し
		X31CMessageResult msgResult = super.invokeService(paramMap, inputMap, outputMap);
		if(msgResult != null)
		{
			throw new JCCWebServiceException(msgResult);
		}

		// 下りマッピング
		mapper.getCCSV000801SC(paramBean, outputMap) ;
		
		return;
	}
	// 2016/02/24 ANK-2680-00-00 ADD END
}