/*************************************************************************
*
* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
*
* Copyright 2000, 2010 Oracle and/or its affiliates.
*
* OpenOffice.org - a multi-platform office productivity suite
*
* This file is part of OpenOffice.org.
*
* OpenOffice.org is free software: you can redistribute it and/or modify
* it under the terms of the GNU Lesser General Public License version 3
* only, as published by the Free Software Foundation.
*
* OpenOffice.org is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Lesser General Public License version 3 for more details
* (a copy is included in the LICENSE file that accompanied this code).
*
* You should have received a copy of the GNU Lesser General Public License
* version 3 along with OpenOffice.org. If not, see
* <http://www.openoffice.org/license.html>
* for a copy of the LGPLv3 License.
*
************************************************************************/
package com.sun.star.wizards.web;
import java.io.File;
import java.io.FileOutputStream;
import java.io.IOException;
import java.util.Hashtable;
import java.util.Iterator;
import java.util.Map;
import javax.xml.transform.Templates;
import javax.xml.transform.Transformer;
import javax.xml.transform.dom.DOMSource;
import javax.xml.transform.stream.StreamResult;
import org.w3c.dom.Document;
import com.sun.star.lang.XMultiServiceFactory;
import com.sun.star.wizards.common.ConfigSet;
import com.sun.star.wizards.common.FileAccess;
import com.sun.star.wizards.common.UCB;
import com.sun.star.wizards.ui.event.Task;
import com.sun.star.wizards.web.data.CGContent;
import com.sun.star.wizards.web.data.CGDocument;
import com.sun.star.wizards.web.data.CGExporter;
import com.sun.star.wizards.web.data.CGLayout;
import com.sun.star.wizards.web.data.CGPublish;
import com.sun.star.wizards.web.data.CGSettings;
import com.sun.star.wizards.web.export.Exporter;
/**
* @author rpiterman
* This class is used to process a CGSession object
* and generate a site. </br>
* it does the following: <br/>
* 1. create a temporary directory.<br/>
* 2. export documents to the temporary directory.<br/>
* 3. generate the TOC page, includes copying images from the
* web wizard work directory and other layout files.<br/>
* 4. publish, or copy, from the temporary directory to
* different destinations.<br/>
* 5. delete the temporary directory.<br/>
* <br/>
* to follow up the status/errors it uses a TaskListener object,
* and an ErrorHandler. <br/>
* in practice, the TaskListener is the status dialog,
* and the Errorhandler does the interaction with the user,
* if something goes wrong.<br/>
* Note that this class takes it in count that
* the given session object is prepared for it -
* all preparations are done in WWD_Events.finishWizard methods.
* <br/>
* <br/>
*
* note on error handling: <br/>
* on "catch" clauses I tries to decide whether the
* exception is fatal or not. For fatal exception an error message
* is displayed (or rather: the errorHandler is being called...)
* and a false is returned.
* In less-fatal errors, the errorHandler "should decide" which means,
* the user is given the option to "OK" or to "Cancel" and depending
* on that interaction I cary on.
*/
public class Process implements WebWizardConst, ProcessErrors
{
private static final int TASKS_PER_DOC = 5;
private static final int TASKS_PER_XSL = 2;
private static final int TASKS_PER_PUBLISH = 2;
private static final int TASKS_IN_PREPARE = 1;
private static final int TASKS_IN_EXPORT = 2;
private static final int TASKS_IN_GENERATE = 2;
private static final int TASKS_IN_PUBLISH = 2;
private static final int TASKS_IN_FINISHUP = 1;
private CGSettings settings;
private XMultiServiceFactory xmsf;
private ErrorHandler errorHandler;
private String tempDir;
private FileAccess fileAccess;
private UCB ucb;
public Task myTask;
/**
* This is a cache for exporters, so I do not need to
* instanciate the same exporter more than once.
*/
private Map exporters = new Hashtable(3);
private boolean result;
public Process(
CGSettings settings,
XMultiServiceFactory xmsf,
ErrorHandler er)
throws Exception
{
this.xmsf = xmsf;
this.settings = settings;
fileAccess = new FileAccess(xmsf);
errorHandler = er;
ucb = new UCB(xmsf);
int taskSteps = getTaskSteps();
myTask = new Task(TASK, TASK_PREPARE, taskSteps);
}
/**
* @return to how many destinations should the
* generated site be published.
*/
private int countPublish()
{
int count = 0;
ConfigSet publishers = settings.cp_DefaultSession.cp_Publishing;
for (int i = 0; i < publishers.getSize(); i++)
{
if (((CGPublish) publishers.getElementAt(i)).cp_Publish)
{
count++;
}
}
return count;
}
/**
* @return the number of task steps that this
* session should have
*/
private int getTaskSteps()
{
int docs = settings.cp_DefaultSession.cp_Content.cp_Documents.getSize();
int xsl = 0;
try
{
xsl = settings.cp_DefaultSession.getLayout().getTemplates(xmsf).size();
}
catch (Exception ex)
{
}
int publish = countPublish();
int taskSteps =
TASKS_IN_PREPARE +
TASKS_IN_EXPORT + docs * TASKS_PER_DOC +
TASKS_IN_GENERATE + xsl * TASKS_PER_XSL +
TASKS_IN_PUBLISH + publish * TASKS_PER_PUBLISH +
TASKS_IN_FINISHUP;
return taskSteps;
}
/**
* does the job
*/
public void runProcess()
{
myTask.start();
try
{
try
{
/*
* I use here '&&' so if one of the
* methods returns false, the next
* will not be called.
*/
result = createTempDir(myTask) && export(myTask) && generate(tempDir, myTask) && publish(tempDir, myTask);
}
finally
{
//cleanup must be called.
result = result & cleanup(myTask);
}
}
catch (Exception ex)
{
result = false;
}
if (!result)
{
myTask.fail(); //this is a bug protection.
}
while (myTask.getStatus() < myTask.getMax())
{
myTask.advance(true);
}
}
/**
* creates a temporary directory.
* @param task
* @return true should continue
*/
private boolean createTempDir(Task task)
{
tempDir = fileAccess.createNewDir(getSOTempDir(xmsf), "wwiztemp");
if (tempDir == null)
{
error(null, null, ERROR_MKDIR, ErrorHandler.ERROR_PROCESS_FATAL);
return false;
}
else
{
task.advance(true);
return true;
}
}
/**
* @param xmsf
* @return the staroffice /openoffice temporary directory
*/
static String getSOTempDir(XMultiServiceFactory xmsf)
{
try
{
String s = FileAccess.getOfficePath(xmsf, "Temp", "", "");
return s;
}
catch (Exception e)
{
}
return null;
}
// CLEANUP
/**
* delete the temporary directory
* @return true should continue
*/
private boolean cleanup(Task task)
{
task.setSubtaskName(TASK_FINISH);
boolean b = fileAccess.delete(tempDir);
if (!b)
{
error(null, null, ERROR_CLEANUP, ErrorHandler.ERROR_WARNING);
}
task.advance(b);
return b;
}
// /**
// * deletes the given directory
// * @param dir the directory to delete
// * @return true if should continue
// */
// private boolean cleanup(String dir) {
//
// boolean success = true;
//
// if (dir != null && fileAccess.exists(dir,false)) {
//
// String[] files = fileAccess.listFiles(dir,true);
//
// for (int i = 0; i < files.length; i++) {
// if (fileAccess.isDirectory(files[i]))
// success = success && cleanup(files[i]);
// else
// success = success && fileAccess.delete(files[i]);
//
// }
// }
// return success && fileAccess.delete(dir);
// }
/**
* This method is used to copy style files to a target
* Directory: css and background.
* Note that this method is static since it is
* also used when displaying a "preview"
*/
public static void copyMedia(UCB copy, CGSettings settings, String targetDir, Task task) throws Exception
{
//1. .css
String sourceDir = FileAccess.connectURLs(settings.workPath, "styles");
String filename = settings.cp_DefaultSession.getStyle().cp_CssHref;
copy.copy(sourceDir, filename, targetDir, "style.css");
task.advance(true);
//2. background image
String background = settings.cp_DefaultSession.cp_Design.cp_BackgroundImage;
if (background != null && !background.equals(""))
{
sourceDir = FileAccess.getParentDir(background);
filename = background.substring(sourceDir.length());
copy.copy(sourceDir, filename, targetDir + "/images", "background.gif");
}
task.advance(true);
}
/**
* Copy "static" files (which are always the same,
* thus not user-input-dependant) to a target directory.
* Note that this method is static since it is
* also used when displaying a "preview"
* @param copy
* @param settings
* @param targetDir
* @throws Exception
*/
public static void copyStaticImages(UCB copy, CGSettings settings, String targetDir)
throws Exception
{
copy.copy(FileAccess.connectURLs(settings.workPath, "images"), targetDir + "/images");
}
/**
* publish the given directory.
* @param dir the source directory to publish from
* @param task task tracking.
* @return true if should continue
*/
private boolean publish(String dir, Task task)
{
task.setSubtaskName(TASK_PUBLISH_PREPARE);
ConfigSet set = settings.cp_DefaultSession.cp_Publishing;
try
{
copyMedia(ucb, settings, dir, task);
copyStaticImages(ucb, settings, dir);
task.advance(true);
}
catch (Exception ex)
{
//error in copying media
error(ex, "", ERROR_PUBLISH_MEDIA, ErrorHandler.ERROR_PROCESS_FATAL);
return false;
}
boolean result = true;
for (int i = 0; i < set.getSize(); i++)
{
CGPublish p = (CGPublish) set.getElementAt(i);
if (p.cp_Publish)
{
String key = (String) set.getKey(p);
task.setSubtaskName(key);
if (key.equals(ZIP_PUBLISHER))
{
fileAccess.delete(p.cp_URL);
}
if (!publish(dir, p, ucb, task))
{
return false;
}
}
}
return result;
}
/**
* publish the given directory to the
* given target CGPublish.
* @param dir the dir to copy from
* @param publish the object that specifies the target
* @param copy ucb encapsulation
* @param task task tracking
* @return true if should continue
*/
private boolean publish(String dir, CGPublish publish, UCB copy, Task task)
{
try
{
//copy.deleteDirContent(publish.url);
task.advance(true);
copy.copy(dir, publish.url);
task.advance(true);
return true;
}
catch (Exception e)
{
task.advance(false);
return error(e, publish, ERROR_PUBLISH, ErrorHandler.ERROR_NORMAL_IGNORE);
}
}
//GENERATING METHODS
/**
* Generates the TOC pages for the current session.
* @param targetDir generating to this directory.
*/
public boolean generate(String targetDir, Task task)
{
boolean result = false;
task.setSubtaskName(TASK_GENERATE_PREPARE);
CGLayout layout = settings.cp_DefaultSession.getLayout();
try
{
/*
* here I create the DOM of the TOC to pass to the XSL
*/
Document doc = (Document) settings.cp_DefaultSession.createDOM();
generate(xmsf, layout, doc, fileAccess, targetDir, task);
}
catch (Exception ex)
{
error(ex, "", ERROR_GENERATE_XSLT, ErrorHandler.ERROR_PROCESS_FATAL);
return false;
}
/* copy files which are not xsl from layout directory to
* website root.
*/
try
{
task.setSubtaskName(TASK_GENERATE_COPY);
copyLayoutFiles(ucb, fileAccess, settings, layout, targetDir);
task.advance(true);
result = true;
}
catch (Exception ex)
{
task.advance(false);
return error(ex, null, ERROR_GENERATE_COPY, ErrorHandler.ERROR_NORMAL_ABORT);
}
return result;
}
/**
* copies layout files which are not .xsl files
* to the target directory.
* @param ucb UCB encapsulatzion object
* @param fileAccess filaAccess encapsulation object
* @param settings web wizard settings
* @param layout the layout object
* @param targetDir the target directory to copy to
* @throws Exception
*/
public static void copyLayoutFiles(UCB ucb, FileAccess fileAccess, CGSettings settings, CGLayout layout, String targetDir)
throws Exception
{
String filesPath = fileAccess.getURL(
FileAccess.connectURLs(settings.workPath, "layouts/"), layout.cp_FSName);
ucb.copy(filesPath, targetDir, new ExtensionVerifier("xsl"));
}
/**
* generates the TOC page for the given layout.
* This method might generate more than one file, depending
* on how many .xsl files are in the
* directory specifies by the given layout object.
* @param xmsf
* @param layout specifies the layout to use.
* @param doc the DOM representation of the web wizard session
* @param fileAccess encapsulation of FileAccess
* @param targetPath target directory
* @param task
* @throws Exception
*/
public static void generate(
XMultiServiceFactory xmsf,
CGLayout layout,
Document doc,
FileAccess fileAccess,
String targetPath,
Task task)
throws Exception
{
/*
* a map that contains xsl templates. the keys are the xsl file names.
*/
Map templates = layout.getTemplates(xmsf);
task.advance(true, TASK_GENERATE_XSL);
/*
* each template generates a page.
*/
for (Iterator i = templates.keySet().iterator(); i.hasNext();)
{
String key = "";
key = (String) i.next();
Transformer transformer = ((Templates) templates.get(key)).newTransformer();
doc.normalize();
task.advance(true);
/*
* The target file name is like the xsl template filename
* without the .xsl extension.
*/
String fn = fileAccess.getPath(targetPath, key.substring(0, key.length() - 4));
File f = new File(fn);
FileOutputStream oStream = new FileOutputStream(f);
// Due to a problem occuring when using Xalan-Java 2.6.0 and
// Java 1.5.0, wrap f in a FileOutputStream here (otherwise, the
// StreamResult's getSystemId would return a "file:/..." URL while
// the Xalan code expects a "file:///..." URL):
transformer.transform(
new DOMSource(doc), new StreamResult(oStream));
oStream.close();
task.advance(true);
}
}
/**
* I broke the export method to two methods
* in a time where a tree with more than one contents was planned.
* I left it that way, because it may be used in the future.
* @param task
* @return
*/
private boolean export(Task task)
{
return export(settings.cp_DefaultSession.cp_Content, tempDir, task);
}
/**
* This method could actually, with light modification, use recursion.
* In the present situation, where we only use a "flat" list of
* documents, instead of the original plan to use a tree,
* the recursion is not implemented.
* @param content the content ( directory-like, contains documents)
* @param dir (target directory for exporting this content.
* @param task
* @return true if should continue
*/
private boolean export(CGContent content, String dir, Task task)
{
int toPerform = 1;
String contentDir = dir;
try
{
task.setSubtaskName(TASK_EXPORT_PREPARE);
/* 1. create a content directory.
* each content (at the moment there is only one :-( )
* is created in its own directory.
* faileure here is fatal.
*/
contentDir = fileAccess.createNewDir(dir, content.cp_Name);
if (contentDir == null || contentDir.equals(""))
{
throw new IOException("Directory " + dir + " could not be created.");
}
content.dirName = FileAccess.getFilename(contentDir);
task.advance(true, TASK_EXPORT_DOCUMENTS);
toPerform--;
/*2. export all documents and sub contents.
* (at the moment, only documents, no subcontents)
*/
Object item = null;
for (int i = 0; i < content.cp_Documents.getSize(); i++)
{
try
{
item = content.cp_Documents.getElementAt(i);
/*
* In present this is always the case.
* may be in the future, when
* a tree is used, it will be abit different.
*/
if (item instanceof CGDocument)
{
if (!export((CGDocument) item, contentDir, task))
{
return false;
}
}
else /*
* we never get here since we
* did not implement sub-contents.
*/ if (!export((CGContent) item, contentDir, task))
{
return false;
}
}
catch (SecurityException sx)
{
// nonfatal
if (!error(sx, item, ERROR_EXPORT_SECURITY, ErrorHandler.ERROR_NORMAL_IGNORE))
{
return false;
}
result = false;
}
}
}
catch (IOException iox)
{
//nonfatal
return error(iox, content, ERROR_EXPORT_IO, ErrorHandler.ERROR_NORMAL_IGNORE);
}
catch (SecurityException se)
{
//nonfatal
return error(se, content, ERROR_EXPORT_SECURITY, ErrorHandler.ERROR_NORMAL_IGNORE);
}
failTask(task, toPerform);
return true;
}
/**
* exports a single document
* @param doc the document to export
* @param dir the target directory
* @param task task tracking
* @return true if should continue
*/
private boolean export(CGDocument doc, String dir, Task task)
{
//first I check if the document was already validated...
if (!doc.valid)
{
try
{
doc.validate(xmsf, null);
}
catch (Exception ex)
{
//fatal
error(ex, doc, ERROR_DOC_VALIDATE, ErrorHandler.ERROR_PROCESS_FATAL);
return false;
}
//get the exporter specified for this document
}
CGExporter exporter = (CGExporter) settings.cp_Exporters.getElement(doc.cp_Exporter);
try
{
/*
* here I calculate the destination filename.
* I take the original filename (docFilename), substract the extension, (docExt) -> (fn)
* and find an available filename which starts with
* this filename, but with the new extension. (destExt)
*/
String docFilename = FileAccess.getFilename(doc.cp_URL);
String docExt = FileAccess.getExtension(docFilename);
String fn = doc.localFilename.substring(0, doc.localFilename.length() - docExt.length() - 1); //filename without extension
/*
* the copyExporter does not change
* the extension of the target...
*/
String destExt = (exporter.cp_Extension.equals("")
? FileAccess.getExtension(docFilename)
: exporter.cp_Extension);
/* if this filter needs to export to its own directory...
* this is the case in, for example, impress html export
*/
if (exporter.cp_OwnDirectory)
{ //+++
dir = fileAccess.createNewDir(dir, fn);
doc.dirName = FileAccess.getFilename(dir);
}
/*
* if two files with the same name
* need to be exported ? So here
* i get a new filename, so I do not
* overwrite files...
*/
String file = fileAccess.getNewFile(dir, fn, destExt);
/* set filename with extension.
* this will be used by the exporter,
* and to generate the TOC.
*/
doc.urlFilename = FileAccess.getFilename(file);
task.advance(true);
try
{
//export
getExporter(exporter).export(doc, file, xmsf, task);
task.advance(true);
}
/*
* getExporter(..) throws
* IllegalAccessException, InstantiationException, ClassNotFoundException
* export() throws Exception
*/
catch (Exception ex)
{
//nonfatal
if (!error(ex, doc, ERROR_EXPORT, ErrorHandler.ERROR_NORMAL_IGNORE))
{
return false;
}
}
}
catch (Exception ex)
{
//nonfatal
if (!error(ex, doc, ERROR_EXPORT_MKDIR, ErrorHandler.ERROR_NORMAL_ABORT))
{
return false;
}
}
return true;
}
/**
* submit an error.
* @param ex the exception
* @param arg1 error argument
* @param arg2 error argument 2
* @param errType error type
* @return the interaction result
*/
private boolean error(Exception ex, Object arg1, int arg2, int errType)
{
result = false;
return errorHandler.error(ex, arg1, arg2, errType);
}
/**
* advances the given task in the given count of steps,
* marked as failed.
* @param task the task to advance
* @param count the number of steps to advance
*/
private void failTask(Task task, int count)
{
while (count-- > 0)
{
task.advance(false);
}
}
/**
* creates an instance of the exporter class
* as specified by the
* exporter object.
* @param export specifies the exporter to be created
* @return the Exporter instance
* @throws ClassNotFoundException
* @throws IllegalAccessException
* @throws InstantiationException
*/
private Exporter createExporter(CGExporter export)
throws ClassNotFoundException,
IllegalAccessException,
InstantiationException
{
Exporter e = (Exporter) Class.forName(export.cp_ExporterClass).newInstance();
e.init(export);
return e;
}
/**
* searches the an exporter for the given CGExporter object
* in the cache.
* If its not there, creates it, stores it in the cache and
* returns it.
* @param export specifies the needed exporter.
* @return an Exporter instance
* @throws ClassNotFoundException thrown when using Class.forName(string)
* @throws IllegalAccessException thrown when using Class.forName(string)
* @throws InstantiationException thrown when using Class.forName(string)
*/
private Exporter getExporter(CGExporter export)
throws ClassNotFoundException,
IllegalAccessException,
InstantiationException
{
Exporter exp = (Exporter) exporters.get(export);
if (exp == null)
{
exp = createExporter(export);
exporters.put(export, exp);
}
return exp;
}
/**
* @return tru if everything went smooth, false
* if error(s) accured.
*/
public boolean getResult()
{
return (myTask.getFailed() == 0) && result;
}
}