screenflowxml.java.svn-base

一个timesheet程序,用来统计开发人员的度量衡web在线程序.用于软件行业

package com.nsi.control.web.util;

import java.io.IOException;
import java.io.InputStream;
import java.net.MalformedURLException;
import java.util.HashMap;
import java.util.Map;

import javax.xml.parsers.DocumentBuilderFactory;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;
import org.w3c.dom.Document;
import org.w3c.dom.Element;
import org.w3c.dom.Node;
import org.w3c.dom.NodeList;
import org.xml.sax.InputSource;
import org.xml.sax.SAXException;
import org.xml.sax.SAXParseException;

import com.nsi.constants.AppConstants;
import com.nsi.control.web.Parameter;
import com.nsi.control.web.Screen;
import com.nsi.control.web.URLMapping;

/**
 * @author Chris Ye, created on Oct 23, 2008
 *
 * ScreenFlowXml
 */
public final class ScreenFlowXml
{
	private static Log log = LogFactory.getLog(ScreenFlowXml.class);
	private ScreenFlowXml()
	{
	}
	private static class ScreenFlowXmlHolder
	{
		static final ScreenFlowXml screenFlowXml = new ScreenFlowXml();
	}
	/**
	 * @return an instance of ScreenFlowXml
	 */
	public static ScreenFlowXml getInstance()
	{
		return ScreenFlowXmlHolder.screenFlowXml;
	}
	public String getTagValue(Element root, String tagName)
	{
		String returnString = AppConstants.EMPTY_STRING;
		NodeList list = root.getElementsByTagName(tagName);
		int size = list.getLength();
		for (int i = 0; i < size; i++)
		{
			Node node = list.item(i);
			if(node != null)
			{
				Node child = node.getFirstChild();
				if(child != null && child.getNodeValue() != null) return child.getNodeValue();
			}
		}
		return returnString;
	}
	public String getSubTagValue(Node node, String subTagName)
	{
		String returnString = AppConstants.EMPTY_STRING;
		if(node != null)
		{
			NodeList children = node.getChildNodes();
			int length = children.getLength();
			for (int i = 0; i < length; i++)
			{
				Node child = children.item(i);
				if(child != null && child.getNodeName() != null && child.getNodeName().equals(subTagName))
				{
					Node grandChild = child.getFirstChild();
					if(grandChild.getNodeValue() != null) return grandChild.getNodeValue();
				}
			}
		}
		return returnString;
	}
	public String getSubTagValue(Element root, String tagName, String subTagName)
	{
		String returnString = AppConstants.EMPTY_STRING;
		NodeList list = root.getElementsByTagName(tagName);
		int size = list.getLength();
		for (int i = 0; i < size; i++)
		{
			Node node = list.item(i);
			if(node != null)
			{
				returnString = getSubTagValue( node, subTagName );
			}
		}
		return returnString;
	}
	public Map<String,URLMapping> getRequestMappings(Element root)
	{
		Map<String,URLMapping> urlMappings = new HashMap<String,URLMapping>();
		NodeList list = root.getElementsByTagName("url-mapping");
		int size = list.getLength();
		for (int i = 0; i < size; i++)
		{
			Node node = list.item(i);
			if(node != null)
			{
				String url = AppConstants.EMPTY_STRING;
				String screen = null;
				String useRequestHandlerString = null;
				String useFlowHandlerString = null;
				String flowHandler = null;
				String requestHandler = null;
				Map<String,String> resultMappings = null;
				boolean useFlowHandler = false;
				boolean useRequestHandler = false;
				if(node instanceof Element)
				{
					Element element = (Element)node;
					url = element.getAttribute("url");
					screen = element.getAttribute("screen");
					useRequestHandlerString = element.getAttribute("useRequestHandler");
					useFlowHandlerString = element.getAttribute("useFlowHandler");
				}
				if(useRequestHandlerString != null && useRequestHandlerString.equalsIgnoreCase("true")) useRequestHandler = true;
				if(useRequestHandler) requestHandler = getSubTagValue(node, "request-handler-class");
				if(useFlowHandlerString != null && useFlowHandlerString.equalsIgnoreCase("true")) useFlowHandler = true;
				if(useFlowHandler && (node instanceof Element))
				{
					Element element = (Element)node;
					NodeList children = element.getElementsByTagName("flow-handler");
					Node flowHandlerNode = null;
					if(children.getLength() >= 1) flowHandlerNode = children.item(0);
					if(children.getLength() > 1) log.error("Non fatal error: There can be only one <flow-handler> definition in a <url-mapping>");
					if(flowHandlerNode != null && (flowHandlerNode instanceof Element))
					{
						Element flowElement = (Element)flowHandlerNode;
						flowHandler = flowElement.getAttribute("class");
						NodeList results = flowElement.getElementsByTagName("handler-result");
						int length = results.getLength();
						if(length > 0) resultMappings = new HashMap<String,String>();
						for (int j = 0; j < length; j++)
						{
							Node resultNode = results.item(j);
							if(resultNode instanceof Element)
							{
								Element resultElement = (Element)resultNode;
								String key = resultElement.getAttribute("result");
								String value = resultElement.getAttribute("screen");
								if(!resultMappings.containsKey(key)) resultMappings.put(key, value);
								else log.error("*** Non Fatal errror: Screen " + url + " <" + "flow-handler" + "> key " + "\"" + key + "\" defined more than one time");
							}
						}

					}
				}
				URLMapping mapping = new URLMapping(url, screen, useRequestHandler, useFlowHandler, requestHandler, flowHandler, resultMappings);
				if(!urlMappings.containsKey(url)) urlMappings.put(url, mapping);
				else log.error("*** Non Fatal errror: Screen " + url + " defined more than once in screen definitions file");
			}
		}
		return urlMappings;
	}
	public Map<String,String> getScreenDefinitions(Element root)
	{
		Map<String,String> screensDefs = new HashMap<String,String>();
		NodeList list = root.getElementsByTagName("screen-definition");
		int size = list.getLength();
		for (int i = 0; i < size; i++)
		{
			Node node = list.item(i);
			if(node != null)
			{
				String language = null;
				String url = null;
				if(node instanceof Element)
				{
					language = ((Element)node).getAttribute("language");
					url = ((Element)node).getAttribute("url");
				}
				if(language != null && url != null && !screensDefs.containsKey(language)) screensDefs.put(language, url);
				else log.error("*** Non Fatal errror: ScreenDefinitions for language " + language + " defined more than once in screen definitions file");
			}
		}
		return screensDefs;
	}
	public Map<String, Screen> getScreens(Element root)
	{
		Map<String, Screen> screens = new HashMap<String, Screen>();
		NodeList list = root.getElementsByTagName("screen");
		for (int i = 0; i < list.getLength(); i++)
		{
			Node node = list.item(i);
			if(node != null)
			{
				String screenName = getSubTagValue(node, "screen-name");
				Map<String, Parameter> parameters = getParameters(node);
				Screen screen = new Screen(screenName, parameters);
				if(!screens.containsKey(screenName)) screens.put(screenName, screen);
				else log.error("*** Non Fatal errror: Screen " + screenName + " defined more than once in screen definitions file");
			}
		}

		return screens;
	}
	public Map<String, String> getTemplates(Element root)
	{
		Map<String, String> templates = new HashMap<String, String>();
		String templateName = getTagValue(root, "/main.jsp");
		templates.put("/main.jsp", templateName);
		return templates;
	}
	public Element loadDocument(InputStream input)
	{
		Document doc = null;
		Element root = null;
		try
		{
			InputSource xmlInp = new InputSource(input);
			doc = DocumentBuilderFactory.newInstance().newDocumentBuilder().parse(xmlInp);
			root = doc.getDocumentElement();
			root.normalize();
		}
		catch(SAXParseException err)
		{
			log.error("loadDocument() --  ** Parsing error, line " + err.getLineNumber() + ", uri " + err.getSystemId());
			log.error("loadDocument() caught error: ",err );
		}
		catch(SAXException saxex)
		{
			log.error("loadDocument() caught SAXException: ", saxex );
		}
		catch(MalformedURLException mfx)
		{
			log.error("loadDocument() caught MalformedURLException: ", mfx );
		}
		catch(IOException ioex)
		{
			log.error("loadDocument() caught IOException: ", ioex );
		}
		catch(Exception ex)
		{
			log.error("loadDocument() caught Exception: ", ex );
		}
		return root;
	}
	public Map<String,URLMapping> loadRequestMappings()
	{
		InputStream input = ScreenFlowXml.class.getClassLoader().getResourceAsStream(AppConstants.REQUESTMAPPINGFILE);
		Element root = loadDocument(input);
		return getRequestMappings(root);
	}
	public Map<String,String> loadScreenDefinitionMappings()
	{
		InputStream input = ScreenFlowXml.class.getClassLoader().getResourceAsStream(AppConstants.SCREENDEFFILE);
		Element root = loadDocument(input);
		return getScreenDefinitions(root);
	}
	public Map<String, Screen> loadScreenDefinitions()
	{
		InputStream input = ScreenFlowXml.class.getClassLoader().getResourceAsStream(AppConstants.SCREENDEFFILE);
		Element root = loadDocument(input);
		return getScreens(root);
	}
	public Map<String, String> loadScreenTemplates()
	{
		InputStream input = ScreenFlowXml.class.getClassLoader().getResourceAsStream(AppConstants.SCREENDEFFILE);
		Element root = loadDocument(input);
		return getTemplates(root);
	}
	private Map<String, Parameter> getParameters(Node node)
	{
		Map<String, Parameter> params = new HashMap<String, Parameter>();
		if(node != null)
		{
			NodeList children = node.getChildNodes();
			int size = children.getLength();
			for (int i = 0; i < size; i++)
			{
				Node child = children.item(i);
				if(child != null && child.getNodeName() != null && child.getNodeName().equals("parameter") && (child instanceof Element))
				{
					Element childElement = (Element)child;
					String key = childElement.getAttribute("key");
					String value = childElement.getAttribute("value");
					String directString = childElement.getAttribute("direct");
					boolean direct = false;
					if(directString != null && directString.equalsIgnoreCase("true")) direct = true;
					if(!params.containsKey(key)) params.put(key, new Parameter(key, value, direct));
					else log.error("*** Non Fatal errror: Parameter " + key + " is defined more than once");
				}
			}
		}
		return params;
	}
}