/*
このファイルの中身は、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) ______________________________________.
*/

//
// 画面振分定義ＸＭＬ対応クラス
//
//
//	変更履歴
//	2004/01/08 新規作成	T.Nishiki
//
package jp.co.ntt.lms.xms.framework;

import java.io.InputStream;
import java.util.HashMap;
import java.util.Map;

import javax.xml.parsers.DocumentBuilder;
import javax.xml.parsers.DocumentBuilderFactory;

import jp.co.ntt.lms.xmo.util.DebugLog;
import jp.co.ntt.lms.xms.common.util.StringUtil;
import jp.co.ntt.lms.xms.common.util.XmlUtil;

import org.w3c.dom.Document;
import org.w3c.dom.Node;

/**
 * 画面振分定義ＸＭＬ対応クラス。<br>
 * @author T.Nishiki
 */
class XmsScreenXMLPerser {

	/**
	 *  画面XML定義ファイルのパス。
	 */
	private static final String SCREEN_XMLFILE_PATH;

	/**
	 *  <screen>ノードのstatus属性。
	 */
	private static final String NODE_SCREEN_ATTR_STATUS;

	/**
	 *  <screen>ノードのclass属性。
	 */
	private static final String NODE_SCREEN_ATTR_CLASS;

	/**
	 *  <screen>ノードのjsp属性。
	 */
	private static final String NODE_SCREEN_ATTR_JSP;

	/**
	 *  <screen>ノードのforward属性。
	 */
	private static final String NODE_SCREEN_ATTR_FORWARD;

	/**
	 *  <action>ノードのパス。
	 */
	private static final String PATH_NODE_ACTION;

	/**
	 *  <common><property>ノードのパス。
	 */
	private static final String PATH_NODE_COMMON_PROPERTY;

	/**
	 *  <common><error>ノードのパス。
	 */
	private static final String PATH_NODE_COMMON_ERROR;

	/**
	 *  <action>ノードのname属性。
	 */
	private static final String NODE_ACTION_ATTR_NAME;

	/**
	 *  <common><property>ノードのname属性。
	 */
	private static final String NODE_COMMON_PROPERTY_ATTR_NAME;
	/**
	 *  <common><property>ノードのvalue属性。
	 */
	private static final String NODE_COMMON_PROPERTY_ATTR_VALUE;
	/**
	 *  プロパティ名称：JSPルート。
	 */
	private static final String NODE_COMMON_PROPERTY_JSPROOT;
	/**
	 *  プロパティ名称：ファイル出力先。
	 */
	private static final String NODE_COMMON_PROPERTY_OUTPUT;

	/**
	 * warning属性名称。
	 */
	private static final String ATTR_WARNING;

	/**
	 * system属性名称。
	 */
	private static final String ATTR_SYSTEM;

	/**
	 * inner属性名称。
	 */
	private static final String ATTR_INNER;

	/**
	 * throwable属性名称。
	 */
	private static final String ATTR_THROWABLE;

	/**
	 * <error>ノード名称。
	 */
	private static final String NODE_NAME_ERROR;

	/**
	 * <screen>ノード名称。
	 */
	private static final String NODE_NAME_SCREEN;

	/**
	 * 画面XML定義情報Document。
	 */
	private static Document DOCUMENT;

	/**
	 * 画面XML定義共通プロパティ・マップ。
	 */
	private static Map COMMON_PROPERTIES;

	/**
	 * ファイル出力先。
	 */
	private static String OUTPUT_DIR;

	/**
	 * JSPのルートディレクトリ。
	 */
	private static String JSPROOT_DIR;

	/**
	 * XmsWarningException発生時のデフォルトフォワード先JSP。
	 */
	private static String JSP_WARNING;

	/**
	 * XmsSystemException発生時のデフォルトフォワード先JSP。
	 */
	private static String JSP_SYSTEM;

	/**
	 * XmsInnerException発生時のデフォルトフォワード先JSP。
	 */
	private static String JSP_INNER;

	/**
	 * Throwable発生時のデフォルトフォワード先JSP。
	 */
	private static String JSP_THROWAOBLE;

	/**
	 * スタティック・イニシャライザ。
	 */
	static {
		DebugLog.write(
			XmsScreenXMLPerser.class,
			"HEAD XmsScreenControl.static-initilizer",
			DebugLog.ROW);
		SCREEN_XMLFILE_PATH = "/conf/xms/XmsScreenDefine.xml";
		NODE_SCREEN_ATTR_STATUS = "status";
		NODE_SCREEN_ATTR_CLASS = "class";
		NODE_SCREEN_ATTR_JSP = "jsp";
		NODE_SCREEN_ATTR_FORWARD = "forward";

		PATH_NODE_ACTION = "root/action";
		PATH_NODE_COMMON_PROPERTY = "root/common/property";
		PATH_NODE_COMMON_ERROR = "root/common/error";

		NODE_NAME_ERROR = "error";
		NODE_NAME_SCREEN = "screen";
		NODE_ACTION_ATTR_NAME = "name";
		NODE_COMMON_PROPERTY_ATTR_NAME = "name";
		NODE_COMMON_PROPERTY_ATTR_VALUE = "value";
		NODE_COMMON_PROPERTY_JSPROOT = "jsproot";
		NODE_COMMON_PROPERTY_OUTPUT = "output";

		ATTR_WARNING = "warning";
		ATTR_SYSTEM = "system";
		ATTR_INNER = "inner";
		ATTR_THROWABLE = "throwable";

		DebugLog.write(
			XmsScreenXMLPerser.class,
			"TAIL XmsScreenControl.static-initilizer",
			DebugLog.ROW);
	}

	/**
	 * 画面情報取得用アクションクラス名を取得する。<br>
	 * 指定したアクションID、更新系業務の結果文字列の組み合わせで、
	 * 画面振分定義ファイルから、アクションクラス名を取得し、戻す。
	 * @param actionId アクションID。
	 * @param businessStatus 更新系業務の結果文字列。
	 * @return 指定した組み合わせに設定されたクラス名を返却。
	 *
	 * @throws XmsException 処理中に例外が発生した場合。
	 */
	static String getScreenActionName(String actionId, String businessStatus)
		throws XmsException {
		String actionName = null;
		Node screenNode = null;
		try {
			// <screen>ノード取得。
			screenNode = getScreenNode(actionId, businessStatus);
			// <screen>ノードから、class属性を取得
			actionName =
				XmlUtil.getAttributeValue(screenNode, NODE_SCREEN_ATTR_CLASS);
		}
		catch (XmsException e) {
			throw e;
		}
		catch (Exception e) {
			throw new XmsSystemException(e);
		}
		return actionName;
	}

	/**
	 * フォワードするＵＲＩを取得する。<br>
	 * 指定したアクションID、更新系業務の結果文字列ならびに出力指定の
	 * 組み合わせに基づき、画面振分定義ファイルから、
	 * フォワード先となるＪＳＰ名またはフォワード用ＵＲＩを取得し、戻す。<br>
	 * ＪＳＰを取得するか、フォワード用ＵＲＩを取得するかの判断は以下の通りとする。
	 * 引数で指定された出力指定が{@link XmsResponse#JSP}または
	 * {@link XmsResponse#JSP_CSV}ならば、
	 * アクションID、更新系業務の結果文字列から取得できる&lt;screen&gt;要素の
	 * jsp属性を取得する。jsp属性がない場合は、forward属性を取得する。
	 * 引数で指定された出力指定が{@link XmsResponse#FORWARD}ならば、
	 * &lt;screen&gt;要素のforward属性を取得する。
	 * JSP名を取得した場合、別途、JSPルートを取得・連結し、JSPのURIとして戻す。
	 * @param actionId アクションID。
	 * @param businessStatus 更新系業務の結果文字列。
	 * @param type 出力指定。
	 * @return 指定した組み合わせに設定されたフォワード先ＵＲＩ。
	 * @throws XmsException 処理中に例外が発生した場合。
	 * @see XmsResponse#JSP
	 * @see XmsResponse#JSP_CSV
	 * @see XmsResponse#FORWARD
	 */
	static String getUriToForward(
		String actionId,
		String businessStatus,
		int type)
		throws XmsException {
		String uri = null;
		try {
			// <screen>ノード取得。
			Node screenNode = getScreenNode(actionId, businessStatus);
			if (type == XmsResponse.JSP || type == XmsResponse.JSP_CSV) {
				// <screen>ノードから、jsp属性を取得
				String jspName = XmlUtil.getAttributeValue(
						screenNode, NODE_SCREEN_ATTR_JSP);
				// JSP属性を取得できた場合はJSPルートを取得して、連結。
				if (jspName != null) {
					// ＪＳＰルート
					String jspRoot = getJspRootDirectory();
					// ＪＳＰのＵＲＩ
					uri = jspRoot + jspName;
				}
				// jsp属性がない場合はforward属性を取得
				else {
					uri = XmlUtil.getAttributeValue(
							screenNode, NODE_SCREEN_ATTR_FORWARD);
				}
			}
			// フォワード指定の場合、foward属性を取得
			else if (type == XmsResponse.FORWARD) {
				uri = XmlUtil.getAttributeValue(
						screenNode, NODE_SCREEN_ATTR_FORWARD);
			}
		}
		catch (XmsException e) {
			throw e;
		}
		catch (Exception e) {
			throw new XmsSystemException(e);
		}
		return uri;
	}

	/**
	 * XmsWariningExceptionが発生したときにフォワードするＪＳＰのパスを取得する。<br>
	 * 画面振分定義ファイルから、指定したアクションIDに対応する&lt;action&gt;要素を取得する。
	 * その子要素&lt;error&gt;を取得し、warining属性の値を取得する。
	 * その属性値とルートディレクトリを連結し、戻す。
	 * &lt;error&gt;要素やwarining属性が存在しない場合は、
	 * 共通要素として定義してあるＪＳＰのパスを戻す。
	 * @param actionId アクションID。
	 * @return 指定したアクションIDに対応するXmsWarningException用のＪＳＰのパス。
	 *
	 * @throws XmsException 処理中に例外が発生した場合。
	 * @see XmsWarningException
	 */
	static String getWarningExceptiontJspPath(String actionId)
		throws XmsException {

		String jspPath = null;
		try {
			// <error>要素のwarning属性を取得する。
			jspPath = getExceptionJspPath(actionId, ATTR_WARNING, JSP_WARNING);
		}
		catch (XmsException e) {
			throw e;
		}
		catch (Exception e) {
			throw new XmsSystemException(e);
		}
		return jspPath;
	}

	/**
	 * XmsSystemExceptionが発生したときにフォワードするＪＳＰのパスを取得する。<br>
	 * 画面振分定義ファイルから、指定したアクションIDに対応する&lt;action&gt;要素を取得する。
	 * その子要素&lt;error&gt;を取得し、system属性の値を取得する。
	 * その属性値とルートディレクトリを連結し、戻す。
	 * &lt;error&gt;要素やsystem属性が存在しない場合は、
	 * 共通要素として定義してあるＪＳＰのパスを戻す。
	 * @param actionId アクションID。
	 * @return 指定したアクションIDに対応するXmsWarningException用のＪＳＰのパス。
	 *
	 * @throws XmsException 処理中に例外が発生した場合。
	 * @see XmsSystemException
	 */
	static String getSystemExceptiontJspPath(String actionId)
		throws XmsException {

		String jspPath = null;
		try {
			// <error>要素のsystem属性を取得する。
			jspPath = getExceptionJspPath(actionId, ATTR_SYSTEM, JSP_SYSTEM);
		}
		catch (XmsException e) {
			throw e;
		}
		catch (Exception e) {
			throw new XmsSystemException(e);
		}
		return jspPath;
	}

	/**
	 * XmsInnerExceptionが発生したときにフォワードするＪＳＰのパスを取得する。<br>
	 * 画面振分定義ファイルから、指定したアクションIDに対応する
	 * &lt;action&gt;要素を取得する。
	 * その子要素&lt;error&gt;を取得し、inner属性の値を取得する。
	 * その属性値とルートディレクトリを連結し、戻す。
	 * &lt;error&gt;要素やinner属性が存在しない場合は、
	 * 共通要素として定義してあるＪＳＰのパスを戻す。
	 * @param actionId アクションID。
	 * @return 指定したアクションIDに対応するXmsWarningException用のＪＳＰのパス。
	 *
	 * @throws XmsException 処理中に例外が発生した場合。
	 * @see XmsInnerException
	 */
	static String getInnerExceptiontJspPath(String actionId)
		throws XmsException {

		String jspPath = null;
		try {
			// <error>要素のinner属性を取得する。
			jspPath = getExceptionJspPath(actionId, ATTR_INNER, JSP_INNER);
		}
		catch (XmsException e) {
			throw e;
		}
		catch (Exception e) {
			throw new XmsSystemException(e);
		}
		return jspPath;
	}

	/**
	 * Throwableが発生したときにフォワードするＪＳＰのパスを取得する。<br>
	 * &lt;error&gt;要素やthrowable属性が存在しない場合は、
	 * 共通要素として定義してあるＪＳＰのパスを戻す。
	 * @return Throwable用のＪＳＰのパス。
	 *
	 * @throws XmsException 処理中に例外が発生した場合。
	 * @see XmsInnerException
	 */
	static String getThrowableJspPath() throws XmsException {

		String jspPath = null;
		String jspRoot = null;
		try {
			jspRoot = getJspRootDirectory();
			jspPath = jspRoot + JSP_THROWAOBLE;
		}
		catch (Exception e) {
			throw new XmsSystemException(e);
		}
		return jspPath;
	}

	/**
	 * 例外が発生したときにフォワードするＪＳＰのパスを取得する。<br>
	 * 画面振分定義ファイルから、指定したアクションIDに対応する&lt;action&gt;要素を取得する。
	 * その子要素&lt;error&gt;を取得し、指定した属性の値を取得する。
	 * その属性値とルートディレクトリを連結し、戻す。
	 * &lt;error&gt;要素やwarining属性が存在しない場合は、
	 * デフォルト値と指定したＪＳＰ名を利用し、ルートディレクトリを連結し、戻す。
	 * @param actionId アクションID。
	 * @param errorAttrName 取得する属性名称。
	 * @param defaultJsp 指定した属性を取得できなかったときに利用するJSP名。
	 * @return 指定したアクションIDに対応するXmsWarningException用のＪＳＰのパス。
	 *
	 * @throws XmsException 処理中に例外が発生した場合。
	 * @see #ATTR_INNER
	 * @see #ATTR_SYSTEM
	 * @see #ATTR_WARNING
	 */
	private static String getExceptionJspPath(
		String actionId,
		String errorAttrName,
		String defaultJsp)
		throws XmsException {

		Node errorNode = null;
		String jspPath = null;
		String jspFile = null;
		try {
			// <error>ノード取得
			errorNode = getErrorNode(actionId);
			if (errorNode != null) {
				// <error>ノードがある場合、warning属性を取得。
				jspFile = XmlUtil.getAttributeValue(errorNode, errorAttrName);
			}
			// error属性がない場合やwarning属性がない場合、
			// 共通のJSPを利用する。
			if (StringUtil.isNullString(jspFile) == true) {
				jspFile = defaultJsp;
			}
			// ルートディレクトリと合わせて戻す。
			jspPath = getJspRootDirectory() + jspFile;
		}
		catch (XmsException e) {
			throw e;
		}
		catch (Exception e) {
			throw new XmsSystemException(e);
		}
		return jspPath;
	}

	/**
	 * 結果データファイルの出力先ディレクトリを戻す。<br>
	 * @return 結果データファイルの出力先ディレクトリ。
	 * @throws XmsException 出力先ディレクトリの取得に失敗した場合。
	 */
	static synchronized String getOutputDirectory() throws XmsException {
		if (OUTPUT_DIR == null) {
			initializeDocument();
			initializeCommons();
		}
		return OUTPUT_DIR;
	}

	/**
	 * ＪＳＰファイルのルートディレクトリを戻す。<br>
	 * @return ＪＳＰファイルのルートディレクトリ。
	 */
	private static String getJspRootDirectory() {
		return JSPROOT_DIR;
	}

	/**
	 * 指定されたアクションIDに対応する&lt;error&gt;ノードを戻す。<br>
	 * 画面振分定義ファイルから、指定したアクションIDに
	 * 対応する&lt;action&gt;要素を取得する。
	 * その子要素&lt;error&gt;を取得できた場合は、その要素を表すノードを戻す。
	 * 取得できない場合はnullを戻す。
	 *
	 * @param actionId アクションID。
	 * @return アクションIDに対応すっる&lt;error&gt;ノード。
	 * @throws XmsException
	 * 	        指定したアクションIDに対応する&lt;action&gt;要素が存在しない場合。
	 *          その他、処理中に例外が発生した場合。
	 */
	private static Node getErrorNode(String actionId) throws XmsException {
		Node actionNode = null;
		Node errorNode = null;
		try {
			// アクションIDに一致する<action>ノードを取得
			actionNode = getActionNode(actionId);
			if (actionNode == null) {
				throw new XmsSystemException("actionNode == null");
			}
			// <error>ノード取得
			errorNode = XmlUtil.selectNode(actionNode, NODE_NAME_ERROR);
		}
		catch (XmsException e) {
			throw e;
		}
		catch (Exception e) {
			throw new XmsSystemException(e);
		}
		return errorNode;
	}

	/**
	 * 指定したＩＤと結果に対応する&lt;screen&gt;ノードを取得する。<br>
	 * 指定したアクションID、更新系業務の結果文字列の組み合わせで、
	 * 画面振分定義ファイルから、アクションクラス名を取得し、戻す。
	 * @param actionId アクションID。
	 * @param businessStatus 更新系業務の結果文字列。
	 * @return 指定した組み合わせに設定された&lt;screen&gt;ノード。
	 *
	 * @throws XmsException
	 *          処理中に例外が発生した場合。
	 *          対応する&lt;screen&gt;ノードが存在しない場合。
	 *          またはその親の&lt;action&gt;ノードが存在しない場合。
	 */
	private static Node getScreenNode(String actionId, String businessStatus)
		throws XmsException {

		Node actionNode = null;
		Node[] screenNodes = null;
		Node screenNode = null;
		try {
			// アクションIDに一致する<action>ノードを取得
			actionNode = getActionNode(actionId);
			if (actionNode == null) {
				throw new XmsSystemException("actionNode == null");
			}
			// <action>ノード配下の<screen>ノード・リストを取得。
			// status属性が一致する<screen>ノードを取得。
			screenNodes = XmlUtil.selectNodes(actionNode, NODE_NAME_SCREEN);
			screenNode =
				XmlUtil.searchNodeByAttribute(
					screenNodes, NODE_SCREEN_ATTR_STATUS, businessStatus);
			if (screenNode == null) {
				throw new XmsSystemException(
					"screenNode[status=\"" + businessStatus + "\"] not found");
			}
		}
		catch (XmsException e) {
			throw e;
		}
		catch (Exception e) {
			throw new XmsSystemException(e);
		}
		return screenNode;
	}

	/**
	 * 指定したアクションIDに合致する&lt;action&gt;ノードを戻す。<br>
	 * @param actionId 検索キーとなるアクションID。
	 * @return 指定したアクションIDに合致する&lt;action&gt;ノードがあれば、
	 *          そのノード、なければnullを戻す。
	 * @throws XmsException 処理中に例外が発生した場合。
	 */
	private static Node getActionNode(String actionId) throws XmsException {
		// <action>ノードの集合
		Node[] actionNodes = null;
		// このメソッドの戻り値。
		Node returnNode = null;

		try {
			// <action>ノードを取得
			actionNodes = XmlUtil.selectNodes(getDocument(), PATH_NODE_ACTION);
			// NAME属性値が指定したアクションIDと一致するノードを選択
			returnNode = XmlUtil.searchNodeByAttribute(
					actionNodes, NODE_ACTION_ATTR_NAME, actionId);

		}
		catch (XmsException e) {
			throw e;
		}
		catch (Exception e) {
			throw new XmsSystemException(e);
		}
		return returnNode;
	}

	/**
	 * ＤＯＭデータの初期化。<br>
	 * @throws XmsException 処理中に例外が発生した場合。
	 */
	private static synchronized void initializeDocument()
			throws XmsException {
		DebugLog.write( XmsScreenXMLPerser.class,
			"HEAD initializeDocument()", DebugLog.ROW);
		// 変換用ビルダ・ファクトリ
		DocumentBuilderFactory dbf = null;
		// 変換用ビルダ
		DocumentBuilder db = null;
		// 定義ファイルの入力ストリーム
		InputStream in = null;
		// 例外発生フラグ（tryブロック内）
		boolean exceptionFlag = true;

		try {
			dbf = DocumentBuilderFactory.newInstance();
			// XMLファイル内の空白を排除します
			dbf.setIgnoringElementContentWhitespace(true);
			// XMLファイル内のコメントを無視します
			dbf.setIgnoringComments(true);

			db = dbf.newDocumentBuilder();
			in = (XmsScreenXMLPerser.class).getResourceAsStream(
					SCREEN_XMLFILE_PATH);
			// ファイルからDOMに変換
			DOCUMENT = db.parse(in);
			DebugLog.write(XmsScreenXMLPerser.class,
					"DOCUMENT==null:" + (DOCUMENT == null), DebugLog.HIGHT);

			// tryブロック内で例外が発生していない
			exceptionFlag = false;
		}
		catch (Exception e) {
			DebugLog.write(XmsScreenXMLPerser.class, e, DebugLog.HIGHT);
			throw new XmsSystemException(e);
		}
		finally {
			// InputStreamのクローズ
			try {
				if (in != null) {
					in.close();
				}
			}
			catch (Exception e) {
				DebugLog.write(XmsScreenXMLPerser.class, e, DebugLog.HIGHT);
				// tryブロック内で例外が発生していない場合、スロー
				if (exceptionFlag == false) {
					throw new XmsSystemException(e);
				}
			}
			finally {
				in = null;
				DebugLog.write( XmsScreenXMLPerser.class,
					"TAIL initializeDocument()", DebugLog.ROW);
			}
		}
	}

	/**
	 * 共通プロパティを定義ファイルより取得する。<br>
	 * @throws XmsException 処理中に例外が発生した場合。
	 */
	private static synchronized void initializeCommons()
			throws XmsException {
		DebugLog.write( XmsScreenXMLPerser.class,
			"HEAD initializeCommons()", DebugLog.ROW);
		try {
			////////////////////////////////////////////////////////////////////
			// プロパティ取得
			// -----------------------------------------------------------------
			// <var>ノードを取得
			Node[] varNodes = null;
			String varName = null;
			String varValue = null;
			COMMON_PROPERTIES = new HashMap();
			varNodes =
				XmlUtil.selectNodes(getDocument(), PATH_NODE_COMMON_PROPERTY);
			for (int i = 0; i < varNodes.length; i++) {
				varName =
					XmlUtil.getAttributeValue(
						varNodes[i],
						NODE_COMMON_PROPERTY_ATTR_NAME);
				varValue =
					XmlUtil.getAttributeValue(
						varNodes[i],
						NODE_COMMON_PROPERTY_ATTR_VALUE);
				DebugLog.write( XmsScreenXMLPerser.class,
					"varName=[" + varName + "]", DebugLog.ROW);
				DebugLog.write( XmsScreenXMLPerser.class,
					"varValue=[" + varValue + "]", DebugLog.ROW);

				if ((varName != null) && (varValue != null)) {
					COMMON_PROPERTIES.put(varName, varValue);
				}
			}

			// 結果データファイル出力先
			OUTPUT_DIR =
				(String)COMMON_PROPERTIES.get(NODE_COMMON_PROPERTY_OUTPUT);
			if (StringUtil.isNullString(OUTPUT_DIR) == true) {
				throw new XmsSystemException(
					NODE_COMMON_PROPERTY_OUTPUT + " is not found.");
			}
			// ＪＳＰファイルルートパス
			JSPROOT_DIR =
				(String)COMMON_PROPERTIES.get(NODE_COMMON_PROPERTY_JSPROOT);
			if (StringUtil.isNullString(JSPROOT_DIR) == true) {
				throw new XmsSystemException(
					NODE_COMMON_PROPERTY_JSPROOT + " is not found.");
			}
			////////////////////////////////////////////////////////////////////
			// 例外／エラー発生時の遷移先取得
			// -----------------------------------------------------------------
			// <error>ノードを取得
			Node errorNode = null;
			String jspWarning = null;
			String jspSystem = null;
			String jspInner = null;
			String jspThrowable = null;
			errorNode =
				XmlUtil.selectNode(getDocument(), PATH_NODE_COMMON_ERROR);

			// throwable発生時の遷移先
			jspThrowable = XmlUtil.getAttributeValue(errorNode, ATTR_THROWABLE);
			if (StringUtil.isNullString(jspThrowable) == true) {
				throw new XmsSystemException(
					ATTR_THROWABLE + " is not found.");
			}
			JSP_THROWAOBLE = jspThrowable;

			// XmsWarningException発生時の遷移先
			jspWarning = XmlUtil.getAttributeValue(errorNode, ATTR_WARNING);
			if (StringUtil.isNullString(jspWarning) == true) {
				JSP_WARNING = jspThrowable;
			}
			else {
				JSP_WARNING = jspWarning;
			}
			// XmsSystemException発生時の遷移先
			jspSystem = XmlUtil.getAttributeValue(errorNode, ATTR_SYSTEM);
			if (StringUtil.isNullString(jspSystem) == true) {
				JSP_SYSTEM = jspThrowable;
			}
			else {
				JSP_SYSTEM = jspSystem;
			}
			// XmsInnerException発生時の遷移先
			jspInner = XmlUtil.getAttributeValue(errorNode, ATTR_INNER);
			if (StringUtil.isNullString(jspInner) == true) {
				JSP_INNER = jspThrowable;
			}
			else {
				JSP_INNER = jspInner;
			}
		}
		catch (XmsException e) {
			DebugLog.write(XmsScreenXMLPerser.class, e, DebugLog.HIGHT);
			throw e;
		}
		catch (Exception e) {
			DebugLog.write(XmsScreenXMLPerser.class, e, DebugLog.HIGHT);
			throw new XmsSystemException(e);
		}
		finally {
			DebugLog.write( XmsScreenXMLPerser.class,
				"TAIL initializeCommons()", DebugLog.ROW);
		}
	}
	/**
	 * 画面振分定義ＸＭＬ−ＤＯＭを返却する。<br>
	 * @return Document 画面振分定義ＸＭＬ。
	 * @throws XmsException 処理中に例外が発生した場合。
	 */
	private static synchronized Document getDocument()
			throws XmsException {
		if (DOCUMENT == null) {
			initializeDocument();
			initializeCommons();
		}
		return DOCUMENT;
	}
}
