/*
このファイルの中身は、NTT オープンソースライセンス　バージョン 1.0（「本
契約」という）の適用を受けます。
本契約を遵守しない限り、このファイルを使用してはなりません。
本契約のコピーは、次のＵＲＬから入手できます。
【配布サイトのURL】 http://www.oss.ecl.ntt.co.jp/lms/

本契約に基づき頒布されるソフトウェアは、現状のまま、明示又は黙示のあらゆ
る種類の保証なしで、頒布されます。本契約に基づく権利及び制限を律する特定
の文言については、本契約を参照してください。

「オリジナルコード」は、 NTT Cyber Space Laboratories Code です。 
「オリジナルコード」の「初期開発者」は、日本電信電話株式会社です。  
日本電信電話株式会社により創作された部分は、Copyright (C) 2004 
日本電信電話株式会社 です。
全ての権利が留保されます。 
「コントリビュータ」：_____________________________________ 


The contents of this file are subject to the NTT Opensource License
Version 1.0 (the License); you may not use this file except in
compliance with the License. You may obtain a copy of the License at
【配布サイトのURL】 http://www.oss.ecl.ntt.co.jp/lms/

Software distributed under the License is distributed on an AS IS
basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
License for the specific language governing rights and limitations
under the License.

The Original Code is NTT Cyber Space Laboratories Code .

The Initial Developer of the Original Code is NIPPON TELEGRAPH AND 
TELEPHONE CORPORATION.
Portions created by the NIPPON TELEGRAPH AND TELEPHONE CORPORATION 
are Copyright (C) 2004 NIPPON TELEGRAPH AND TELEPHONE CORPORATION. 
All Rights Reserved.

Contributor(s) ______________________________________.
*/

//
//	LO 共通クライアント部品
//			変更履歴
//				2004.01.08	新規作成	二條智文
//				2004.09.24	M0004	A.Shimoma
//
package jp.co.ntt.lms.lo;

import java.rmi.RemoteException;
import java.rmi.registry.LocateRegistry;
import java.rmi.registry.Registry;
import java.util.Hashtable;
import java.util.Vector;

import jp.co.ntt.lms.xmo.Environment;
import jp.co.ntt.lms.xmo.MenuData;
import jp.co.ntt.lms.xmo.MessageData;
import jp.co.ntt.lms.xmo.Lo.MaterialData;
import jp.co.ntt.lms.xmo.util.DebugLog;

/**
 * すべてのLoTopのクライアント部品の親クラスになります。<BR>
 * 各LoTopに関連したクライアント部品を作成する場合はこのクラスを継承
 * してください。
 * @author T.Nijou
 * @version 0.0.0.1 2004/01/08
 */
public class LoTopClient
	implements LoPropertyDef
{

	/**
	 * リモートオブジェクトをキャッシュします
	 */
	private static final Hashtable mhtbLoTop = new Hashtable();

	/**
	 * RMIレジストリ登録名称プレフィックス
	 */
	public static final String LO_PRE = "LoTop";

	/**
	 * LO種別を保持します
	 */
	private String mstrLoType = "";

	/**
	 * クラス名を保持します
	 */
	private String mstrClassName = "";

	/**
	 * サーバ名を保持します
	 */
	private String mstrServerName = "";

	/**
	 * パラメータを保持します
	 */
	private Hashtable mhtbParam = new Hashtable();

	/**
	 * リモートオブジェクトを保持します
	 */
	private LoTop mobjLoTop;

	/**
	 * メニューリスト結果を設定します
	 */
	private MenuData[] mobjMenuList;

	/**
	 * 教材リスト結果を設定します
	 */
	private MaterialData[] mobjMaterialList;

	/**
	 * 学習開始結果を設定します
	 */
	private LearnData mobjLearnData;

	/**
	 * 学習開始エラーページを設定します
	 */
	private String mstrLearnErrorURL = "/view/lo/Com/Err.vm";

	/**
	 * 学習終了結果を設定します
	 */
	private Object mobjEndLearn;

	/**
	 * 共通ログ取得結果を設定します
	 */
	private LoLogSessionRecord[] mobjLoLogSessionRecord;

	/**
	 * 共通ログ取得結果を保持します
	 */
	private String[][] mobjLoLogResult;

	/**
	 * 特殊ログ取得結果を設定します
	 */
	private Object mobjIndividualLog;

	/**
	 * 個別ログ取得結果を設定します
	 */
	private String[][] mobjIndividualLogResult;
	/**
	 * 個別ログ(CSV)取得結果を設定します
	 */
	private String[][] mobjIndividualLogCSVResult;

	/**
	 * Lo共通情報を保持します
	 */
	private LoComData[] mobjLoComData;

	/**
	 * 実行結果を設定します
	 */
	private Object mobjExecute;

	/**
	 * 教材構造を設定します
	 */
	private Object mobjMaterialNode;

	/**
	 * 教材構造ファイル内容を設定します
	 */
	private String mstrMaterialFile;


	/**
	 * メッセージデータオブジェクトを保持します
	 */
	private MessageData mobjMessageData;

	/**
	 * ステータス伝播レコードを保持します
	 */
	private PropagateRelationRecord[] mobjPropagateRelationRecord;


	/**
	 * RMI通信リトライ回数
	 */
	private static final int RMI_RETRY_COUNT = 10;

	/**
	 * RMI通信リトライ待機時間
	 */
	private static final int RMI_RETRY_WAIT = 1000;

	/**
	 * コンストラクタです。<BR>
	 * 取得したいRMIオブジェクトの登録名を指定してください。
	 * @param strServerName LOサーバ名
	 * @param strLoType LO種別
	 */
	public LoTopClient( String strServerName, String strLoType ) throws Exception {
		// プライベート変数にクラス名を設定(LOTOP + Lo種別)
		mstrClassName = LO_PRE + strLoType;
		synchronized( this.getClass() ){
			// キャッシュから指定されたクラス名のリモートオブジェクトを取り出します
			LoTop objLoTop = (LoTop)mhtbLoTop.get( mstrClassName );
			// キャッシュに存在しない場合は作成する
			if( objLoTop == null ) {
				objLoTop = getLoTop( strServerName, mstrClassName );
			}
			mobjLoTop = objLoTop;
		}
		// サーバ名称を設定
		mstrServerName = strServerName;
		// LO種別を設定
		mstrLoType = strLoType;
		// LO種別をHashtableに格納
		mhtbParam.put( LO_TYPE, strLoType );
	}

	/**
	 * LoTop取得メソッド
	 */
	private LoTop getLoTop( String strServerName, String strClassName )
		throws Exception
	{
		LoTop objLoTop = null;
		try{
			Environment objEnvironment = new Environment();
			int intLoPort = new Integer( objEnvironment.getLoRegistryPort() ).intValue();
			Registry registry = LocateRegistry.getRegistry( strServerName, intLoPort );
			for( int i=0; i<RMI_RETRY_COUNT; i++ ){
				try{
					objLoTop = (LoTop)registry.lookup( "//" + strServerName + "/" + strClassName );
					break;
				}catch( Exception ex ){
					// リトライ回数終了時
					if( i == RMI_RETRY_COUNT -1 ) {
						// 例外をスローする
						throw ex;
					}
					try{
						Thread.sleep(RMI_RETRY_WAIT);
					}
					catch(InterruptedException ex2){
					}
				}
			}
			mhtbLoTop.put( strClassName, objLoTop );
		}catch(Exception e){
			// ログ出力
			DebugLog.write( this.getClass(), e, DebugLog.HIGHT );
			throw e;
		}
		return objLoTop;
	}

	/**
	 * 基本LoTopメソッドの起動を行います。<BR>
	 * LoTopのメニューリストを取得します
	 * @return boolean メニュー取得成否
	 */
	public boolean getMenuList()
	{
		boolean boolRet = false;
		Vector vecRet   = new Vector();
		vecRet          = getMenuList(mhtbParam);
		int intSize     = vecRet.size();
		if(intSize > 0)
		{
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				boolRet = true;
				if(intSize > 1)
				{
					// 配列の２番目は必ずメニューリストデータ
					mobjMenuList = (MenuData[])vecRet.get(1);
					//MenuDataの配列をセットする
					setMobjMenuList(mobjMenuList);
				}
			}
		}
		return boolRet;
	}

	/**
	 * 基本LoTopメソッドの起動を行います。<BR>
	 * LoTopのメニューリストを取得します
	 * @return Vector メッセージデータとメニューリスト
	 */
	private Vector getMenuList(Hashtable htbParam)
	{
		Vector vecRet = new Vector();
		try
		{
			vecRet = mobjLoTop.getMenuList(htbParam);
		}
		catch(RemoteException ce)
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecRet = mobjLoTop.getMenuList(htbParam);
			}
			catch( RemoteException re ) {
				// リトライ
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecRet = mobjLoTop.getMenuList(htbParam);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}
		return vecRet;
	}

	/**
	 * 基本LoTopメソッドの起動を行います。<BR>
	 * LoTopの教材リストを取得します
	 * @return boolean 教材リスト取得の成否
	 */
	public boolean getMaterialList()
	{
		boolean boolRet = false;
		Vector vecRet   = new Vector();
		vecRet          = getMaterialList(mhtbParam);
		int intSize     = vecRet.size();
		if(intSize > 0)
		{
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				boolRet = true;
				if(intSize > 1)
				{
					// 配列の２番目は必ずメニューリストデータ
					mobjMaterialList = (MaterialData[])vecRet.get(1);
				}
			}
		}
		return boolRet;
	}

	/**
	 * 基本LoTopメソッドの起動を行います。<BR>
	 * LoTopの教材リストを取得します
	 * @return Vector メッセージデータと教材リスト
	 */
	private Vector getMaterialList( Hashtable htbParam )
	{
		Vector vecList = new Vector();
		try
		{
			vecList = mobjLoTop.getMaterialList(htbParam);
		}
		catch(RemoteException ce)
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecList = mobjLoTop.getMaterialList(htbParam);
			}
			catch( RemoteException re ) {
				// リトライ
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecList = mobjLoTop.getMaterialList(htbParam);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}
		return vecList;
	}

	/**
	 * LOのセットアップ処理を行います
	 * @param strSetupStatus セットアップ処理区分
	 * <PRE>
	 *      SETUP_INSERT   登録処理
	 *      SETUP_UPDATE   更新処理
	 *      SETUP_DELETE   削除処理
	 *      SETUP_ADDUSER  ユーザ登録処理
	 *      SETUP_DELUSER  ユーザ削除処理
	 * </PRE>
	 * @return boolean 結果
	 */
	public boolean setUp( String strSetupStatus, Hashtable htbParam ) {
		boolean boolRet = false;
		Vector vecRet = new Vector();

		mhtbParam = htbParam;
		// パラメータに処理区分を格納
		setValue( SETUP_STATUS, strSetupStatus );
		vecRet          = setUp();
		int intSize     = vecRet.size();
		if(intSize > 0)
		{
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				boolRet = true;
				if(intSize > 1)
				{
					// 配列の２番目は必ずメニューリストデータ
					mobjMaterialList = (MaterialData[])vecRet.get(1);
				}
			}
		}
		return boolRet;
	}

	/**
	 * LOセットアップ処理<BR>
	 * @return Vector 結果
	 */
	private Vector setUp()
	{
		Vector vecList = new Vector();
		try
		{
			vecList = mobjLoTop.setUp(mhtbParam);
		}
		catch(RemoteException ce)
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecList = mobjLoTop.setUp(mhtbParam);
			}
			catch( RemoteException re ) {
				// リトライ
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecList = mobjLoTop.setUp(mhtbParam);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}

		return vecList;
	}

	/**
	 * 基本LoTopメソッドの起動を行います。<BR>
	 * 学習開始可能かどうかチェックします。<BR>
	 * 学習開始可能ならば学習開始URLを設定し、<BR>
	 * trueを返します。
	 * @param strUserID ユーザID
	 * @param strPassword パスワード
	 * @param strLoID LOID
	 * @param strReturnURL 戻りURL
	 * @return boolean 学習開始成否
	 */
	public boolean startLearn(
							  String strUserID,
							  String strPassword,
							  String strLoID,
							  String strReturnURL,
							  String strRealLOID,
							  String strXCServerNo,
							  String strCookieXCSNo
							  ) throws Exception
	{
		// メンバ変数設定
		setUserID( strUserID );
		setPassword( strPassword );
		setLoID( strRealLOID );
		setReturnURL( strReturnURL );
		setPropagateLOID( strLoID );
		// 学習対象LOIDの設定
		setTargetLOID( strLoID );
		setXCServerNo( strXCServerNo );
		setCookieXCSNo( strCookieXCSNo );
		// 戻り値初期化
		boolean boolRet = false;
		// 学習開始データ取得
		Vector vecRet   = startLearn(mhtbParam);

		// メッセージデータと学習開始データ設定
		if(vecRet.size() > 0)
		{
			// エラー判定メッセージデータ取得
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				boolRet = true;
				if(vecRet.size() > 1)
				{
					// 学習開始URL設定
					mobjLearnData = (LearnData)vecRet.get(1);
				}
			}
		}
		return boolRet;
	}

	/**
	 * 基本LoTopメソッドの起動を行います。<BR>
	 * LoTopの学習開始メソッドを呼びます。<BR>
	 * @return Vector メッセージデータと学習開始結果
	 */
	private Vector startLearn( Hashtable htbParam )
	{
		Vector vecList = new Vector();
		try
		{
			vecList = mobjLoTop.startLearn(htbParam);
		}
		catch( RemoteException ce )
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecList = mobjLoTop.startLearn(htbParam);
			}
			catch( RemoteException re ) {
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecList = mobjLoTop.startLearn(htbParam);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}
		return vecList;
	}

	/**
	 * 基本LoTopメソッドの起動を行います。<BR>
	 * 学習終了可能かどうかチェックします。<BR>
	 * 学習終了可能ならば結果を設定し、<BR>
	 * trueを返します。
	 * @return boolean 学習終了成否
	 */
	public boolean endLearn()
		throws Exception
	{
		// 戻り値初期化
		boolean boolRet = false;
		// 学習終了データ取得
		Vector vecRet   = endLearn( mhtbParam );

		// メッセージデータと学習開始URL設定
		if(vecRet.size() > 0)
		{
			// エラー判定メッセージデータ取得
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				boolRet = true;
				if(vecRet.size() > 1)
				{
					mobjEndLearn = vecRet.get(1);
				}
			}
		}
		return boolRet;
	}

	/**
	 * 基本LoTopメソッドの起動を行います。<BR>
	 * LoTopの学習終了メソッドを呼びます
	 * @return Vector メッセージデータとNULL
	 */
	public Vector endLearn( Hashtable htbParam )
	{
		Vector vecList = new Vector();
		try
		{
			vecList = mobjLoTop.endLearn(htbParam);
		}
		catch( RemoteException ce )
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecList = mobjLoTop.endLearn(htbParam);
			}
			catch( RemoteException re ) {
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecList = mobjLoTop.endLearn(htbParam);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}
		return vecList;
	}

	/**
	 * 共通ログ取得用の検索条件を追加します。<BR>
	 * SQL定義ファイル内の'?'文字を追加した順番で置換します。<BR>
	 * 設定する側は呼び出すSQLにあわせて、条件を追加する順番を決めてください。
	 * @param strCondition 検索条件
	 */
	public void addLoLogCondition( String strCondition ) {
		// ハッシュからVectorを取り出す。
		Vector vecLogCondition = (Vector)mhtbParam.get( LOG_CONDITION );

		if( vecLogCondition == null ) {
			// 条件Vectorがnullの場合は新規に作成
			vecLogCondition = new Vector();
			// ハッシュパラメータに追加する
			mhtbParam.put( LOG_CONDITION, vecLogCondition );
		}

		// 条件Vectorに検索条件を設定する
		vecLogCondition.add( strCondition );
	}

	/**
	 * 共通ログの取得を行います。
	 * @param strQueryID 実行するSQLのIDを指定します
	 * @return boolean 共通ログの取得の成否
	 */
	public boolean getLoLog( String strQueryID ) {
		boolean boolRet = false;
		Vector vecRet   = new Vector();
		try {
			// ユーザID情報を格納
			if( strQueryID != null ) {
				mhtbParam.put( QUERY_ID, strQueryID );
			}
			vecRet = mobjLoTop.getLoLog(mhtbParam);
		}
		catch( RemoteException ce )
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecRet = mobjLoTop.getLoLog(mhtbParam);
			}
			catch( RemoteException re ) {
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecRet = mobjLoTop.getLoLog(mhtbParam);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}

		int intSize     = vecRet.size();
		if(intSize > 0)
		{
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				boolRet = true;
				if(intSize > 1)
				{
					// 配列の２番目は必ずログリストデータ
					mobjLoLogResult = (String[][])vecRet.get(1);
				}
			}
		}
		return boolRet;
	}


	/**
	 * PROPAGATERELATIONレコードの取得を行います。
	 * @param strRelatedID 完結要件に使用されているLOID
	 * @return boolean レコード取得の成否
	 */
	public boolean getPropagateRelation( String strRelatedID ) {
		boolean boolRet = false;
		Vector vecRet   = new Vector();
		try {
			// RELATEDID情報を格納
			if( strRelatedID != null ) {
				mhtbParam.put( RELATEDID, strRelatedID );
			}
			vecRet = mobjLoTop.getPropagateRelation(mhtbParam);
		}
		catch( RemoteException ce )
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecRet = mobjLoTop.getPropagateRelation(mhtbParam);
			}
			catch( RemoteException re ) {
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecRet = mobjLoTop.getPropagateRelation(mhtbParam);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}

		int intSize     = vecRet.size();
		if(intSize > 0)
		{
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				boolRet = true;
				if(intSize > 1)
				{
					// 配列の２番目は必ずレコードデータ
					mobjPropagateRelationRecord = (PropagateRelationRecord[])vecRet.get(1);
				}
			}
		}
		return boolRet;
	}


	/**
	 * LO情報をコピーします
	 * @param vecParam リスト構造のパラメータ
	 * @return boolean コピー結果
	 */
	public boolean doCopy( Vector vecParam ) {
		boolean boolRet = false;
		Vector vecRet   = new Vector();
		try {
			// パラメータを格納
			if( vecParam != null ) {
				mhtbParam.put( COPY_PARAM, vecParam );
			}
			vecRet = mobjLoTop.doCopy(mhtbParam);
		}
		catch( RemoteException ce )
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecRet = mobjLoTop.doCopy(mhtbParam);
			}
			catch( RemoteException re ) {
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecRet = mobjLoTop.doCopy(mhtbParam);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}

		int intSize     = vecRet.size();
		if(intSize > 0)
		{
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				boolRet = true;
			}
		}
		return boolRet;
	}

	/**
	 * 個別ログの取得を行います。
	 * @param strQueryID 実行するSQLのIDを指定します
	 * @return boolean 個別ログの取得の成否
	 */
	public boolean getIndividualLog( String strQueryID ) {
		boolean boolRet = false;
		Vector vecRet   = new Vector();
		try {
			// ユーザID情報を格納
			if( strQueryID != null ) {
				mhtbParam.put( QUERY_ID, strQueryID );
			}
			vecRet = mobjLoTop.getIndividualLog(mhtbParam);
		}
		catch( RemoteException ce )
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecRet = mobjLoTop.getIndividualLog(mhtbParam);
			}
			catch( RemoteException re ) {
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecRet = mobjLoTop.getIndividualLog(mhtbParam);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}

		int intSize     = vecRet.size();
		if(intSize > 0)
		{
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				boolRet = true;
				if(intSize > 1)
				{
					// 配列の２番目は必ずログリストデータ
					Vector vecResultData = (Vector)vecRet.get(1);
					mobjIndividualLogResult = (String[][])vecResultData.get(0);
				}
			}
		}
		return boolRet;
	}

// 20040924 M0004 ADD start NTTR(N)

	/**
	 * 個別ログの取得を行います。
	 * @param strQueryID		実行するSQLのIDを指定します
	 * @param strUserID 		取得するユーザIDのリストを指定します
	 * @param strUID 			取得するUIDのリストを指定します
	 * @param inGroupColumn		クエリーのIN句($USER_LIST$)で用いるカラム名
	 * @param inUIDColumn		クエリーのIN句($UID_LIST$)で用いるカラム名
	 * @return boolean 個別ログの取得の成否
	 */
	public boolean getIndividualLogCSV(
		String strQueryID,
		String[] strUserID,
		String[] strUID,
		String inGroupColumn,
		String inUIDColumn ) {

		boolean boolRet = false;
		Vector vecRet = new Vector();
		try {
			// ユーザID情報を格納
			if ( strQueryID != null ) {
				mhtbParam.put( QUERY_ID, strQueryID );
				mhtbParam.put( IN_COLUMN_USER_LIST, inGroupColumn );
				mhtbParam.put( IN_COLUMN_UID_LIST, inUIDColumn );
			}
			mhtbParam.put( USERID_LIST, strUserID );
			mhtbParam.put( UID_LIST, strUID );
			vecRet = mobjLoTop.getIndividualLogCSV( mhtbParam );
		} catch ( RemoteException ce ) {
			try {
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecRet = mobjLoTop.getIndividualLogCSV( mhtbParam );
			} catch ( RemoteException re ) {
				for ( int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecRet = mobjLoTop.getIndividualLogCSV( mhtbParam );
						break;
					} catch ( RemoteException re2 ) {
						// リトライ回数が終わった場合
						if ( i == RMI_RETRY_COUNT - 1 ) {
							re2.printStackTrace();
						}
						try {
							Thread.sleep( RMI_RETRY_WAIT );
						} catch ( InterruptedException ie ) {
						}
					}
				}
			} catch ( Exception e ) {
				e.printStackTrace();
			}
		}
		int intSize = vecRet.size();
		if ( intSize > 0 ) {
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = ( MessageData ) vecRet.get( 0 );
			if ( mobjMessageData == null ) {
				// 正常終了
				boolRet = true;
				if ( intSize > 1 ) {
					// 配列の２番目は必ずログリストデータ
					Vector vecResultData = ( Vector ) vecRet.get( 1 );
					mobjIndividualLogCSVResult = ( String[][] ) vecResultData.get( 0 );
				}
			}
		}
		return boolRet;
	}

// 20040924 M0004 ADD end

	/**
	 * 個別ログの取得を行います。
	 * @param strQueryID	実行するSQLのIDを指定します
	 * @param strUserID 	取得するユーザIDのリストを指定します
	 * @param strUID 		取得するUIDのリストを指定します
	 * @return boolean 個別ログの取得の成否
	 */
	public boolean getIndividualLogCSV( String strQueryID, String[] strUserID, String[] strUID ) {

		boolean boolRet = false;
		Vector vecRet   = new Vector();
		try {
			// ユーザID情報を格納
			if( strQueryID != null ) {
				mhtbParam.put( QUERY_ID, strQueryID );
			}
			mhtbParam.put( USERID_LIST, strUserID );
			mhtbParam.put( UID_LIST, strUID );
			vecRet = mobjLoTop.getIndividualLogCSV(mhtbParam);
		}
		catch( RemoteException ce )
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecRet = mobjLoTop.getIndividualLogCSV(mhtbParam);
			}
			catch( RemoteException re ) {
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecRet = mobjLoTop.getIndividualLogCSV(mhtbParam);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}

		int intSize     = vecRet.size();
		if(intSize > 0)
		{
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				boolRet = true;
				if(intSize > 1)
				{
					// 配列の２番目は必ずログリストデータ
					Vector vecResultData = (Vector)vecRet.get(1);
					mobjIndividualLogCSVResult = (String[][])vecResultData.get(0);
				}
			}
		}
		return boolRet;
	}

	/**
	 * 個別ログの取得を行います
	 * @param strUserID ユーザID
	 * @param strLoID LOID
	 * @return boolean 個別ログ取得の成否
	 */
	public boolean getIndividualLog( String strUserID, String strLoID )
	{
		Vector vecRet   = new Vector();

		String[] strUserIDList = null;
		String[] strLoIDList = null;
		if( strUserID != null ) {
			strUserIDList = new String[1];
			strUserIDList[0] = strUserID;
		}
		if( strLoID != null  ) {
			strLoIDList = new String[1];
			strLoIDList[0] = strLoID;
		}
		return getIndividualLog( strUserIDList, strLoIDList );
	}

	/**
	 * 個別ログの取得を行います
	 * @param strUserID ユーザIDリスト
	 * @param strLoID LOIDリスト
	 * @return Vector メッセージデータと個別ログ
	 */
	public boolean getIndividualLog( String[] strUserID, String[] strLoID )
	{
		boolean boolRet = false;
		Vector vecRet   = new Vector();
		try
		{
			// ユーザID情報を格納
			if( strUserID != null )
			{
				mhtbParam.put( USER_LIST, strUserID );
			}
			// LOID情報を格納
			if( strLoID != null )
			{
				mhtbParam.put( LOID_LIST, strLoID );
			}
			vecRet = mobjLoTop.getIndividualLog(mhtbParam);
		}
		catch( RemoteException ce )
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecRet = mobjLoTop.getIndividualLog(mhtbParam);
			}
			catch( RemoteException re ) {
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecRet = mobjLoTop.getIndividualLog(mhtbParam);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}

		int intSize     = vecRet.size();
		if(intSize > 0)
		{
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				boolRet = true;
				if(intSize > 1)
				{
					// 配列の２番目は必ずログリストデータ
					mobjIndividualLog = vecRet.get(1);
				}
			}
		}
		return boolRet;
	}

	/**
	 * 個別ログの削除を行います
	 * @param strUserID ユーザID
	 * @param strLoID LOID
	 * @return boolean 個別ログ取得の成否
	 */
	public boolean deleteIndividualLog( String strUserID, String strLoID )
	{
		boolean boolRet = false;
		Vector vecRet   = new Vector();
		try
		{
			// ユーザID情報を格納
			if( strUserID != null )
			{
				mhtbParam.put( USER, strUserID );
			}
			// LOID情報を格納
			if( strLoID != null )
			{
				mhtbParam.put( LOID, strLoID );
			}
			vecRet = mobjLoTop.deleteIndividualLog(mhtbParam);
		}
		catch( RemoteException ce )
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecRet = mobjLoTop.deleteIndividualLog(mhtbParam);
			}
			catch( RemoteException re ) {
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecRet = mobjLoTop.deleteIndividualLog(mhtbParam);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}

		int intSize     = vecRet.size();
		if(intSize > 0)
		{
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				boolRet = true;
			}
		}
		return boolRet;
	}

	/**
	 * 個別ログの更新を行います
	 * 
	 * @param loID LOID
	 * @param condition 検索条件
	 * @return boolean 個別ログ取得の成否
	 */
	public boolean changeTypeUpdateIndividualLog( String loID, String condition ) {
		boolean boolRet = false;
		Vector vecRet = new Vector();
		try {
			// LOID情報を格納
			if ( loID != null ) {
				mhtbParam.put( LOID, loID );
			}
			// 検索条件を格納
			if ( condition != null ) {
				mhtbParam.put( CONDITION_KEY, condition );
			}
			vecRet = mobjLoTop.changeTypeUpdateIndividualLog( mhtbParam );
		} catch ( RemoteException ce ) {
			try {
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecRet = mobjLoTop.deleteIndividualLog( mhtbParam );
			} catch ( RemoteException re ) {
				for ( int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecRet = mobjLoTop.deleteIndividualLog( mhtbParam );
						break;
					} catch ( RemoteException re2 ) {

						// リトライ回数が終わった場合
						if ( i == RMI_RETRY_COUNT - 1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						} catch ( InterruptedException ie ) {
						}
					}
				}
			} catch ( Exception e ) {
				e.printStackTrace();
			}
		}

		int intSize = vecRet.size();
		if ( intSize > 0 ) {
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = ( MessageData ) vecRet.get( 0 );
			if ( mobjMessageData == null ) {
				// 正常終了
				boolRet = true;
			}
		}
		return boolRet;
	}

	/**
	 * 共通ログの検索結果を取得します
	 */
	public String[][] getLoLogResult() {
		return mobjLoLogResult;
	}

	/**
	 * 教材IDを元にLOの詳細情報を取得します
	 * @return boolean 実行の成否
	 */
	public boolean getData( String strLoID ) {
		setLoID( strLoID );
		return getData( mhtbParam );
	}

	/**
	 * LO詳細情報取得処理
	 */
	private boolean getData(Hashtable htbParam) {
		boolean boolRet = false;
		Vector vecRet = new Vector();
		try
		{
			vecRet = mobjLoTop.getData(mhtbParam);
		}
		catch( RemoteException ce )
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecRet = mobjLoTop.getData(mhtbParam);
			}
			catch( RemoteException re ) {
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecRet = mobjLoTop.getData(mhtbParam);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}

		int intSize     = vecRet.size();
		if(intSize > 0)
		{
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				boolRet = true;
				if(intSize > 1)
				{
					// 配列の２番目は必ずログリストデータ
					mobjLoComData = (LoComData[])vecRet.get(1);
				}
			}
		}
		return boolRet;
	}

	/**
	 * LO詳細情報取得レコード数を返します
	 */
	public int getDataLength() {
		if( mobjLoComData != null ) {
			return mobjLoComData.length;
		}
		else {
			return 0;
		}
	}

	/**
	 * インデックスを指定して、詳細情報を取得します
	 */
	public LoComData getDataInfo( int index ) {
		if( mobjLoComData == null ) {
			return null;
		}
		else {
			return mobjLoComData[index];
		}
	}

	/**
	 * パラメーターを設定します
	 * @param strMehodName 起動するメソッド名
	 * @return boolean 実行の成否
	 */
	public boolean execute( String strMethodName )
	{
		boolean boolRet = false;

		boolRet = execute(strMethodName, mhtbParam);

		return boolRet;
	}

	/**
	 * 各Loに登録されているメソッドを起動します
	 * @param strMehodName 起動するメソッド名
	 * @param objParams 起動するメソッドのパラメータ
	 * @return boolean 実行の成否
	 */
	public boolean execute( String strMethodName, Hashtable objParams )
	{
		boolean boolRet = false;
		Vector vecRet   = new Vector();
		try
		{
			vecRet = mobjLoTop.execute(strMethodName, objParams);
		}
		catch( RemoteException ce )
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecRet = mobjLoTop.execute(strMethodName, objParams);
			}
			catch( RemoteException re ) {
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecRet = mobjLoTop.execute(strMethodName, objParams);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}

		int intSize     = vecRet.size();
		if(intSize > 0)
		{
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				if(intSize > 1)
				{
					mobjExecute  = vecRet.get(1);
				}
				boolRet      = true;
			}
		}
		return boolRet;
	}

	/**
	 * 教材構造取得
	 * @param
	 * @param objParams 起動するメソッドのパラメータ
	 * @return boolean 実行の成否
	 */
	public boolean getMaterialStruct(Hashtable objParams)
	{
		boolean boolRet = false;
		Vector vecRet   = new Vector();
		try
		{
			vecRet = mobjLoTop.getMaterialStruct(objParams);
		}
		catch( RemoteException ce )
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecRet = mobjLoTop.getMaterialStruct(objParams);
			}
			catch( RemoteException re ) {
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecRet = mobjLoTop.getMaterialStruct(objParams);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}

		int intSize     = vecRet.size();
		if(intSize > 0)
		{
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				if(intSize > 1)
				{
					mobjMaterialNode  = vecRet.get(1);
				}
				boolRet      = true;
			}
		}
		return boolRet;
	}

	/**
	 * 教材構造ファイル内容取得
	 * @param
	 * @param objParams 起動するメソッドのパラメータ
	 * @return boolean 実行の成否
	 */
	public boolean getMaterialStructFile(Hashtable objParams)
	{
		boolean boolRet = false;
		Vector vecRet   = new Vector();
		try
		{
			vecRet = mobjLoTop.getMaterialStructFile(objParams);
		}
		catch( RemoteException ce )
		{
			try
			{
				// 再取得
				mobjLoTop = getLoTop( mstrServerName, mstrClassName );
				vecRet = mobjLoTop.getMaterialStructFile(objParams);
			}
			catch( RemoteException re ) {
				for(int i = 0; i < RMI_RETRY_COUNT; i++ ) {
					try {
						vecRet = mobjLoTop.getMaterialStructFile(objParams);
						break;
					}
					catch(RemoteException re2) {

						// リトライ回数が終わった場合
						if( i == RMI_RETRY_COUNT -1 ) {
							re2.printStackTrace();
						}

						try {
							Thread.sleep( RMI_RETRY_WAIT );
						}
						catch( InterruptedException ie ) {}
					}
				}
			}
			catch( Exception e )
			{
				e.printStackTrace();
			}
		}

		int intSize     = vecRet.size();
		if(intSize > 0)
		{
			// 配列の１番目は必ずメッセージデータ
			mobjMessageData = (MessageData)vecRet.get(0);
			if(mobjMessageData == null)
			{
				// 正常終了
				if(intSize > 1)
				{
					mstrMaterialFile  = (String)vecRet.get(1);
				}
				boolRet = true;
			}
		}
		return boolRet;
	}


	/**
	 * パラメータの設定をクリアします
	 */
	public void clear() {
		mhtbParam = new Hashtable();
	}

	/**
	 * 教材IDを指定します
	 */
	public void setMaterialID( String strMaterialID ) {
		if( strMaterialID != null ) {
			mhtbParam.put( MATLID, strMaterialID );
		}
	}

	/**
	 * ユーザIDを設定します
	 */
	public void setUserID( String strUserID ) {
		if( strUserID != null ) {
			mhtbParam.put( USER, strUserID );
		}
	}

	/**
	 * ユーザパスワードを設定します
	 */
	public void setPassword( String strPassword ) {
		if( strPassword != null ) {
			mhtbParam.put( PASSWD, strPassword );
		}
	}

	/**
	 * ログ取得時のターゲットとなるIDを指定します
	 */
	public void setTargetID( String strTargetID ) {
		if( strTargetID != null ) {
			mhtbParam.put( TARGET_ID, strTargetID );
		}
	}

	/**
	 * ユーザタイプを設定します
	 */
	public void setUserType( String strUserType ) {
		if( strUserType != null ) {
			mhtbParam.put( USER_TYPE, strUserType );
		}
	}

	/**
	 * 戻りURLを設定します
	 */
	public void setReturnURL( String strReturnURL ) {
		if( strReturnURL != null ) {
			mhtbParam.put( RETURN_URL, strReturnURL );
		}
	}

	/**
	 * 教材の実アドレスを設定します
	 */
	public void setMaterialURL( String strMaterialURL ) {
		if( strMaterialURL != null ) {
			mhtbParam.put( MATERIAL_URL, strMaterialURL );
		}
	}

	/**
	 * Lo種別を設定します
	 */
	public void setLoType( String strLoType ) {
		if( strLoType != null ) {
			mhtbParam.put( LO_TYPE, strLoType );
		}
	}

	/**
	 * LoIDを設定します
	 */
	public void setLoID( String strLoID ) {
		if( strLoID != null ) {
			mhtbParam.put( LOID, strLoID );
		}
	}
	/**
	 * 学習対象LoIDを設定します
	 */
	public void setTargetLOID( String strTargetLoID ) {
		if( strTargetLoID != null ) {
			mhtbParam.put( TARGETLOID, strTargetLoID );
		}
	}
	/**
	 * RealLoIDを設定します
	 */
	public void setRealLoID( String strRealLoID ) {
		if( strRealLoID != null ) {
			mhtbParam.put( REAL_LOID, strRealLoID );
		}
	}

	/**
	 * 章IDを設定します
	 */
	public void setAuID( String strAuID ) {
		if( strAuID != null ) {
			mhtbParam.put( AUID, strAuID );
		}
	}

	/**
	 * 学習開始メニューURLを設定します
	 */
	public void setLearnURL( String strLearnURL ) {
		if( strLearnURL != null ) {
			mhtbParam.put( LEARN_URL, strLearnURL );
		}
	}

	/**
	 * パラメータに任意のキーで値を設定します
	 * @param strKey キー
	 * @param strValue 値
	 */
	public void setValue( String strKey, String strValue ) {
		if( strKey == null || strValue == null ) {
			return;
		}

		mhtbParam.put( strKey, strValue );
	}

	/**
	 * 学習開始データを取得します
	 * @return LearnData 学習開始データ
	 */
	public LearnData getLearnData()
	{
		return mobjLearnData;
	}

	/**
	 * 学習開始エラーURLを取得します
	 */
	public String getLearnErrorURL()
	{
		return mstrLearnErrorURL;
	}

	/**
	 * メニューリストの指定メニューデータ取得
	 *
	 * @param int インデックス
	 * @return MenuData メニューデータオブジェクト
	 */
	public MenuData getMenuData(int intIndex)
	{
		return mobjMenuList[intIndex];
	}

	/**
	 * メニューリスト長取得
	 *
	 * @return int メニューリスト長
	 */
	public int getMenuListSize()
	{
		if(mobjMenuList == null)
		{
			return 0;
		}
		return mobjMenuList.length;
	}

	/**
	 * 教材リストの指定教材データ取得
	 *
	 * @param int インデックス
	 * @return MenuData 教材データオブジェクト
	 */
	public MaterialData getMaterialData(int intIndex)
	{
		return mobjMaterialList[intIndex];
	}

	/**
	 * 教材リスト長取得
	 *
	 * @return int 教材リスト長
	 */
	public int getMaterialSize()
	{
		if(mobjMaterialList == null)
		{
			return 0;
		}
		return mobjMaterialList.length;
	}

	/**
	 * 学習終了結果取得
	 *
	 * @return Object 学習終了結果
	 */
	public Object getEndLearn()
	{
		return mobjEndLearn;
	}

	/**
	 * 共通ログリストの指定共通ログデータ取得
	 *
	 * @param int インデックス
	 * @return LoLogSessionRecord 共通ログデータオブジェクト
	 */
	public LoLogSessionRecord getLoLogSessionRecord(int intIndex)
	{
		return mobjLoLogSessionRecord[intIndex];
	}

	/**
	 * 共通ログリスト長取得
	 *
	 * @return int 共通ログリスト長
	 */
	public int getLoLogSessionRecordSize()
	{
		if(mobjLoLogSessionRecord == null)
		{
			return 0;
		}
		return mobjLoLogSessionRecord.length;
	}

	/**
	 * 個別ログ取得
	 *
	 * @return Object 個別ログ
	 */
	public Object getIndividualLog()
	{
		return mobjIndividualLog;
	}

	/**
	 * 個別ログ検索結果取得
	 *
	 * @return String[][] 個別ログ
	 */
	public String[][] getIndividualLogResult()
	{
		return mobjIndividualLogResult;
	}
	/**
	 * 個別ログ(CSV)検索結果取得
	 *
	 * @return String[][] 個別ログ
	 */
	public String[][] getIndividualLogCSVResult()
	{
		return mobjIndividualLogCSVResult;
	}

	/**
	 * 実行結果取得
	 *
	 * @return Object 実行結果
	 */
	public Object getExecute()
	{
		return mobjExecute;
	}

	/**
	 * 教材構造取得
	 *
	 * @return Object 実行結果
	 */
	public Object getMaterialStruct()
	{
		return mobjMaterialNode;
	}

	/**
	 * メッセージデータオブジェクトを取得します
	 * @return MessageData メッセージデータオブジェクト
	 */
	public MessageData getMessageData() {
		return mobjMessageData;
	}

	/**
	 * 教材構造ファイル内容取得
	 *
	 * @return String ファイル内容
	 */
	public String getMaterialFile()
	{
		return mstrMaterialFile;
	}

	/**
	 * パラメータを設定します
	 * @param htbParam パラメータ
	 */
	public void setParam( Hashtable htbParam ) {
		mhtbParam = htbParam;
	}

	/**
	 * ステータス伝播レコードを返却します。
	 *
	 * @return PropagateRelationRecord 実行結果
	 */
	public PropagateRelationRecord[] getPropageteRecords()
	{
		return mobjPropagateRelationRecord;
	}

	/**
	 * ステータス伝播用LOIDを設定します
	 */
	public void setPropagateLOID( String strPropagateLOID ) {
		if( strPropagateLOID != null ) {
			mhtbParam.put( PROPAGATE_LOID, strPropagateLOID );
		}
	}
	/**
	 * MenuDataの配列を取得する
	 * @return MenuDataの配列
	 */
	public MenuData[] getMobjMenuList() {
		return mobjMenuList;
	}

	/**
	 * MenuDataの配列を返却する
	 * @param MenuDataの配列
	 */
	public void setMobjMenuList(MenuData[] mobjMenuList) {
		this.mobjMenuList = mobjMenuList;
	}

	/**
	 * サーバー情報を設定します
	 */
	public void setXCServerNo( String strServerNo ) {
		if( strServerNo == null || strServerNo.equals("")) {
			strServerNo = "NULL";
		}
		mhtbParam.put( XC_SERVER_NO, strServerNo );
	}

	/**
	 * サーバー情報を設定します２
	 */
	public void setCookieXCSNo( String strCookieServerNo ) {
		if( strCookieServerNo == null || strCookieServerNo.equals("")) {
			strCookieServerNo = "NULL";
		}
		mhtbParam.put( XC_COOKIE_SERVER_NO, strCookieServerNo );
	}
}

