alfresco-community-repo/source/java/org/alfresco/web/templating/TemplatingService.java

/*
 * Copyright (C) 2005 Alfresco, Inc.
 *
 * Licensed under the Mozilla Public License version 1.1 
 * with a permitted attribution clause. You may obtain a
 * copy of the License at
 *
 *   http://www.alfresco.org/legal/license.txt
 *
 * Unless required by applicable law or agreed to in writing,
 * software distributed under the License is distributed on an
 * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
 * either express or implied. See the License for the specific
 * language governing permissions and limitations under the
 * License.
 */
package org.alfresco.web.templating;

import java.io.*;
import java.util.*;

import javax.xml.parsers.*;

import javax.xml.transform.*;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.alfresco.web.templating.xforms.*;

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

import org.alfresco.service.cmr.repository.ContentReader;
import org.alfresco.service.cmr.repository.ContentService;
import org.alfresco.service.cmr.repository.NodeRef;
import org.alfresco.model.ContentModel;
import org.alfresco.util.TempFileProvider;
import org.alfresco.service.ServiceRegistry;
import org.alfresco.service.cmr.dictionary.DictionaryService;
import org.alfresco.service.cmr.repository.NodeService;
import org.alfresco.service.cmr.search.SearchService;
import org.alfresco.service.cmr.model.*;
import org.alfresco.service.namespace.NamespaceService;
import javax.faces.context.FacesContext;
import org.alfresco.web.app.Application;
import org.alfresco.web.bean.repository.Repository;

/**
 * Provides management of template types.
 */
public final class TemplatingService
    implements Serializable
{

    ////////////////////////////////////////////////////////////////////////////

    /**
     * Encapsulation of configuration file management.
     */
    private static class Configuration
    {
	
	/** indicates whether or not the configuration file has been loaded */
	public static boolean loaded = false;
	private static NodeRef configFileNodeRef = null;

	/**
	 * locate the configuration file.  currently it is stored as 
	 * <tt>templating_config.xml</tt> at the root of the data dictionary.
	 *
	 * @return the configuration file, which is currently all the
	 * <tt>TemplateTypes</tt> serialized using object serialization.
	 */
	private static NodeRef getConfigFile()
	{
	    if (configFileNodeRef == null)
	    {
		final TemplatingService ts = TemplatingService.INSTANCE;
		LOGGER.debug("loading config file");
		// get the template from the special Email Templates folder
		FacesContext fc = FacesContext.getCurrentInstance();
		String xpath = (Application.getRootPath(fc) + "/" + 
				Application.getGlossaryFolderName(fc));
		NodeRef rootNodeRef = ts.nodeService.getRootNode(Repository.getStoreRef());
		List<NodeRef> results = ts.searchService.selectNodes(rootNodeRef, xpath, null, ts.namespaceService, false);
		if (results.size() != 1)
		    throw new RuntimeException("expected one result for " + xpath);
		NodeRef dataDictionaryNodeRef =  results.get(0);
		LOGGER.debug("loaded data dictionary " + dataDictionaryNodeRef);
		try
		{
		    Configuration.configFileNodeRef = 
			ts.fileFolderService.create(dataDictionaryNodeRef,
						    "templating_configuration.xml",
						    ContentModel.TYPE_CONTENT).getNodeRef();
		}
		catch (FileExistsException fee)
		{
		    Configuration.configFileNodeRef = 
			ts.fileFolderService.searchSimple(dataDictionaryNodeRef, "templating_configuration.xml");
		}
		LOGGER.debug("loaded config file " + configFileNodeRef);
		assert Configuration.configFileNodeRef != null : "unable to load templating_configuration.xml";
	    }
	    return Configuration.configFileNodeRef;
	}

	/**
	 * Load the configuration file into the templating service.
	 */
	public static void load()
	    throws IOException
	{
	    final TemplatingService ts = TemplatingService.INSTANCE;
	    final NodeRef configFileNodeRef = getConfigFile();
	    FacesContext fc = FacesContext.getCurrentInstance();
	    final ContentReader contentReader = ts.contentService.getReader(configFileNodeRef, 
									    ContentModel.TYPE_CONTENT);
	    if (contentReader == null)
		LOGGER.debug("templating_config.xml is empty");
	    else
	    {
		LOGGER.debug("parsing templating_config.xml");
		final InputStream contentIn = contentReader.getContentInputStream();
		final ObjectInputStream in = new ObjectInputStream(contentIn);
		try
	        {
		    while (true)
		    {
			try
			{
			    final TemplateType tt = (TemplateType)in.readObject();
			    TemplatingService.INSTANCE.registerTemplateType(tt);
			}
			catch (EOFException eof)
			{
			    break;
			}
			
		    }
		    in.close();
		}
		catch (ClassNotFoundException cnfe)
		{
		    TemplatingService.LOGGER.error(cnfe);
		}
	    }
	    loaded = true;
	}
	
        /**
	 * Save the current state of the templating service to the configuration file.
	 */
	public static void save()
	    throws IOException
	{
	    final TemplatingService ts = TemplatingService.INSTANCE;
	    FacesContext fc = FacesContext.getCurrentInstance();
	    final NodeRef configFileNodeRef = getConfigFile();
	    final OutputStream contentOut = ts.contentService.getWriter(configFileNodeRef, ContentModel.TYPE_CONTENT, true).getContentOutputStream();
	    final ObjectOutputStream out = new ObjectOutputStream(contentOut);
	    for (TemplateType tt : TemplatingService.INSTANCE.getTemplateTypes())
	    {
		out.writeObject(tt);
	    }
	    out.close();
	}
    }

    ////////////////////////////////////////////////////////////////////////////

    /**
     * temporary location of the property on nodes that are xml files created
     * by templating.
     */
    public static final org.alfresco.service.namespace.QName TT_QNAME = 
	org.alfresco.service.namespace.QName.createQName(org.alfresco.service.namespace.NamespaceService.CONTENT_MODEL_1_0_URI, "tt");

    /**
     * temporary location of the property on nodes generated from xml assets.
     */
    public static final org.alfresco.service.namespace.QName TT_GENERATED_OUTPUT_QNAME = 
	org.alfresco.service.namespace.QName.createQName(org.alfresco.service.namespace.NamespaceService.CONTENT_MODEL_1_0_URI, "tt_generated_output");

    private static final Log LOGGER = LogFactory.getLog(TemplatingService.class);

    /** the single instance initialized using spring */
    private static TemplatingService INSTANCE;

    /** internal storage of template types, keyed by the template name */
    private HashMap<String, TemplateType> templateTypes = 
	new HashMap<String, TemplateType>();

    private final ContentService contentService;
    private final NodeService nodeService;
    private final FileFolderService fileFolderService;
    private final DictionaryService dictionaryService;
    private final NamespaceService namespaceService;
    private final SearchService searchService;

    /** instantiated using spring */
    public TemplatingService(final ContentService contentService,
			     final NodeService nodeService,
			     final FileFolderService fileFolderService,
			     final DictionaryService dictionaryService,
			     final NamespaceService namespaceService,
			     final SearchService searchService)
    {
	this.contentService = contentService;
	this.nodeService = nodeService;
	this.fileFolderService = fileFolderService;
	this.dictionaryService = dictionaryService;
	this.namespaceService = namespaceService;
	this.searchService = searchService;
	if (INSTANCE == null)
	    INSTANCE = this;
    }

    /** Provides the templating service instance, loads config if necessary */
    public static TemplatingService getInstance()
    {
	if (!Configuration.loaded)
	{
	    LOGGER.debug("loading configuration");
	    try
	    {
		Configuration.load();
	    }
	    catch (Throwable t)
	    {
		LOGGER.error(t);
		t.printStackTrace();
	    }
	}

	return TemplatingService.INSTANCE;
    }

    /** returns all registered template types */
    public Collection<TemplateType> getTemplateTypes()
    {
	return this.templateTypes.values();
    }

    /** return the template type by name or <tt>null</tt> if not found */
    public TemplateType getTemplateType(final String name)
    {
	return this.templateTypes.get(name);
    }

    /** registers a template type.  if one exists with the same name, it is replaced */
    public void registerTemplateType(final TemplateType tt)
    {
	this.templateTypes.put(tt.getName(), tt);
	try
	{
	    Configuration.save();
	}
	catch (IOException ioe)
	{
	    LOGGER.error(ioe);
	}
    }

    /** 
     * instantiate a template type.  for now this will always generate the
     * xforms implementation, but will at some point be configurable such that
     * the template type implementation can be configured for the system,
     * or specified in the gui.
     */
    public TemplateType newTemplateType(final String name,
					final NodeRef schemaNodeRef)
    {
	return new TemplateTypeImpl(name, schemaNodeRef);
    }

    /** utility function for creating a document */
    public Document newDocument()
    {
	try
	{
	    final DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
	    dbf.setNamespaceAware(true);
	    dbf.setValidating(false);
	    final DocumentBuilder db = dbf.newDocumentBuilder();
	    return db.newDocument();
	}
	catch (ParserConfigurationException pce)
	{
	assert false : pce;
	    LOGGER.error(pce);
	    return null;
	}
//	catch (SAXException saxe)
//	{
//	    LOGGER.error(saxe);
//	}
//	catch (IOException ioe)
//	{
//	    LOGGER.error(ioe);
//	}
    }

    /** utility function for serializing a node */
    public void writeXML(final Node n, final Writer output)
    {
	try 
	{
	    final TransformerFactory tf = TransformerFactory.newInstance();
	    final Transformer t = tf.newTransformer();
	    t.setOutputProperty(OutputKeys.INDENT, "yes");

	    if (LOGGER.isDebugEnabled())
	    {
		LOGGER.debug("writing out a document for " + 
			     (n instanceof Document
			      ? ((Document)n).getDocumentElement()
			      : n).getNodeName() + 
			     " to " + output);
		final StringWriter sw = new StringWriter();
		t.transform(new DOMSource(n), new StreamResult(sw));
		LOGGER.debug(sw.toString());
	    }
	    t.transform(new DOMSource(n), new StreamResult(output));
	}
	catch (TransformerException te)
        {
	    te.printStackTrace();
	    assert false : te.getMessage();
	}
    }

    /** utility function for serializing a node */
    public void writeXML(final Node n, final File output)
	throws IOException
    {
	this.writeXML(n, new FileWriter(output));
    }

    /** utility function for serializing a node */
    public String writeXMLToString(final Node n)
    {
	final StringWriter result = new StringWriter();
	this.writeXML(n, result);
	return result.toString();
    }

    /** utility function for parsing xml */
    public Document parseXML(final String source)
	throws ParserConfigurationException,
	SAXException,
	IOException
    {
	return this.parseXML(new ByteArrayInputStream(source.getBytes()));
    }

    /** utility function for parsing xml */
    public Document parseXML(final NodeRef nodeRef)
	throws ParserConfigurationException,
	SAXException,
	IOException
    {
	final ContentReader contentReader = 
	    this.contentService.getReader(nodeRef, ContentModel.TYPE_CONTENT);
	final InputStream in = contentReader.getContentInputStream();
	return this.parseXML(in);
    }

    /** utility function for parsing xml */
    public Document parseXML(final File source)
	throws ParserConfigurationException,
	SAXException,
	IOException
    {
	return this.parseXML(new FileInputStream(source));
    }

    /** utility function for parsing xml */
    public Document parseXML(final InputStream source)
	throws ParserConfigurationException,
	SAXException,
	IOException
    {
	final DocumentBuilderFactory dbf = DocumentBuilderFactory.newInstance();
	dbf.setNamespaceAware(true);
	dbf.setValidating(false);
	final DocumentBuilder db = dbf.newDocumentBuilder();
	final Document result = db.parse(source);
	source.close();
	return result;
    }
}