//////////////////////////////////////////////////////////////////////////
// Copyright 2001-2011 Aspose Pty Ltd. All Rights Reserved.
//
// This file is part of Aspose.Words. The source code in this file
// is only intended as a supplement to the documentation, and is provided
// "as is", without warranty of any kind, either expressed or implied.
//////////////////////////////////////////////////////////////////////////
package com.aspose.words.demos;

import com.aspose.words.DataRelation;
import com.aspose.words.DataSet;
import com.aspose.words.DataTable;
import com.aspose.words.Document;

import javax.faces.el.ValueBinding;
import java.sql.ResultSet;

/**
 * Creates an invoice with order header, details and summary. Shows how to mail merge hierarchical data from
 * multiple tables, format date and numeric fields and use nested merge regions to grow portions of the document.
 */
public class SalesInvoiceDemo extends Demo
{
    public SalesInvoiceDemo()
    {
    }

    public Document execute() throws Exception
    {
        // Open the template document
        Document doc = new Document(getPathToTemplateDoc());

        // *** Mail Merge Regions
        //
        // This document uses mail merge regions and nested merge regions. For more information please
        // see the documentation under Mail Merge.

        // *** Parent-Child Data on the Report
        //
        // Note that documents such as invoice might contain data with master-child relationships,
        // for example Order and OrderDetails. The easiest and most natural way to build such a report
        // is to use nested merge regions. These can be easily set up from a variety of data sources and
        // merged in one line of code.
        //
        // This demo is designed to produce multiple invoices each with content from a data source with multiple
        // parent-child relationships. Each invoice is generated on a different page.

        // *** Date and Number Formatting in Merge Fields
        //
        // You can either format your data in the query or specify formatting flags in the merge fields
        // in the document.
        //
        // Merge fields with date or number formatting flags look like this:
        // MERGEFIELD  OrderDate \@ "dd-MMM-yyyy"
        // MERGEFIELD  UnitPrice \# "$#,##0.00"
        //
        // You can switch display of field codes on/off in MS Word using Alt+F9 to see which
        // fields in this demo use formatting flags.

        // Empty paragraphs can appear between some tables within regions. This setting removes these paragraphs automatically during mail merge.
        doc.getMailMerge().setRemoveEmptyParagraphs(true);

        // Perform a single mail merge operation which populates the document with data from the data source.
        doc.getMailMerge().executeWithRegions(getOrdersData());

        return doc;
    }

     private DataSet getOrdersData() throws Exception
    {
        // Note that mail merging using DataSet or DataTable classes is like working with disconnected data. All data needed for the mail merge
        // operation must be loaded into memory and must be scrollable. Either the ResultSets objects must be scrollable and open
        // for the duration of mail merge or the data can be loaded in a CachedRowSet.
        DataSet dataSet = new DataSet();

        // Add the data from the database into appropriate tables.  The names of the table are required to match to the names in
        // regions in template document.
        DataTable orders = new DataTable(executeQuery("SELECT TOP 3 * FROM AsposeWordOrders"), "Orders");
        dataSet.getTables().add(orders);

        DataTable orderDetails = new DataTable(executeQuery("SELECT * FROM AsposeWordOrderDetails"), "OrderDetails");
        dataSet.getTables().add(orderDetails);

        DataTable orderTotals = new DataTable(executeQuery("SELECT * FROM AsposeWordOrderTotals"), "OrderTotals");
        dataSet.getTables().add(orderTotals);

        // In order for nested mail merge to work, the mail merge engine must know the relation between parent and child tables.
        // Add a DataRelation to specify relations between these tables.
        dataSet.getRelations().add(new DataRelation(
                "OrderToOrderDetails",
                "Orders",
                "OrderDetails",
                new String[]{"OrderID"},
                new String[]{"OrderID"}));

        dataSet.getRelations().add(new DataRelation(
                "OrderToOrderTotals",
                "Orders",
                "OrderTotals",
                new String[]{"OrderID"},
                new String[]{"OrderID"}));

        return dataSet;
    }

    public String executeDemo() {

         // Java-added rethrow in order to avoid changing this method's signature.
         try
         {
             init("SalesInvoiceDemo");

             // Get the output format selected by user.
             String formatType = request.getParameter("format");
             ValueBinding theBean = context.getApplication().createValueBinding("#{mycontext.outputtype}");
             if (null!=theBean)
             {
                 formatType = (String)theBean.getValue(context);
             }

             boolean openNewWindow = request.getParameter("openNewWindow") != null;
             theBean = context.getApplication().createValueBinding("#{mycontext.opennewwindow}");
             if (null!=theBean)
             {
                 openNewWindow = (Boolean)theBean.getValue(context);
             }

             Document doc = execute();

             if (null!=doc) {
                 // Once we have a document, we can save it to a file, stream or send to the client browser.
                 // We just send the document to the browser in this case.
                 sendToBrowser(doc, mDemoName, formatType, openNewWindow);
             }
         }
         catch (Exception e)
         {
             throw new RuntimeException(e);
         }

         return "";
     }


    private ResultSet getTestOrder() throws Exception
    {
        return executeQuery(
            "SELECT * FROM AsposeWordOrders WHERE OrderId = " + TestOrderId);
    }

    private ResultSet getTestOrderDetails() throws Exception
    {
        return executeQuery(
            "SELECT * FROM AsposeWordOrderDetails WHERE OrderId = " + TestOrderId + " ORDER BY ProductID" );
    }

    private ResultSet getTestOrderTotals() throws Exception
    {
        return executeQuery(
            "SELECT * FROM AsposeWordOrderTotals WHERE OrderId = " + TestOrderId);
    }

    private final int TestOrderId = 10444;

}

//////////////////////////////////////////////////////////////////////////
// Copyright 2001-2011 Aspose Pty Ltd. All Rights Reserved.
//
// This file is part of Aspose.Words. The source code in this file
// is only intended as a supplement to the documentation, and is provided
// "as is", without warranty of any kind, either expressed or implied.
//////////////////////////////////////////////////////////////////////////
package com.aspose.words.demos;

import java.io.Serializable;

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

import javax.faces.application.FacesMessage;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.validator.ValidatorException;
import javax.faces.event.ActionEvent;

import javax.servlet.*;
import javax.servlet.http.*;

public class AsposeContext implements Serializable
{
    private String _outputType = "DOC";
    public String getOutputtype() {
        return _outputType;
    }
    public void setOutputtype(String v) {
        _outputType = v;
        if("DOC".equals(_outputType))
        {
            _mimeType = "application/msword";
        }
        else if("DOCX".equals(_outputType))
        {
            _mimeType = "application/vnd.openxmlformats-officedocument.wordprocessingml.document";
        }
        else if("HTML".equals(_outputType))
        {
            _mimeType = "text/html";
        }
        else if("TXT".equals(_outputType))
        {
            _mimeType = "text/plain";
        }
        else if("ODT".equals(_outputType))
        {
            _mimeType = "application/vnd.oasis.opendocument.text";
        }
        else if("PDF".equals(_outputType))
        {
            _mimeType = "application/pdf";
        }else
        {
            _mimeType = "application/msword";
        }
    }

    private String _mimeType = "application/msword";
    public String getMimetype() {
        return _mimeType;
    }

    private Boolean _openNew = false;
    public Boolean getOpennewwindow() {
        return _openNew;
    }
    public void setOpennewwindow(Boolean v) {
        _openNew = v;
    }

    // Default Constructor
    public AsposeContext() {
    }
}

//////////////////////////////////////////////////////////////////////////
// Copyright 2001-2011 Aspose Pty Ltd. All Rights Reserved.
//
// This file is part of Aspose.Words. The source code in this file
// is only intended as a supplement to the documentation, and is provided
// "as is", without warranty of any kind, either expressed or implied.
//////////////////////////////////////////////////////////////////////////
package com.aspose.words.demos;

import com.aspose.words.*;

import java.io.*;
import java.net.URI;
import java.net.URL;
import java.sql.*;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.faces.context.FacesContext;

///////////////////////
import java.text.SimpleDateFormat;
import com.icesoft.faces.context.ByteArrayResource;
import com.icesoft.faces.context.Resource;

import java.util.ArrayList;
import java.util.Date;
import java.util.Locale;
import java.lang.reflect.*;

/**
 * Base class for Aspose.Words.Demos classes that execute specific demos.
 */
public abstract class Demo
{
    /**
     * Called before launching any concrete demo-classes.
     * We need application path so we can find the database and template documents.
     */
    private void initDemo() throws Exception
    {
        // Calculate common project dirs and files used by all demos.
        mProjectDir = getProjectDir();
        File baseDir = mProjectDir.getParentFile();
        mDocumentsDir = new File(baseDir, "Documents");
        mGeneratedDir = new File(mProjectDir, "generated");
        mDatabaseDir = new File(baseDir, "Database");
        mDatabase = new File(mDatabaseDir, "Northwind.mdb");
        mResultSetCollection = new ArrayList();

        // Check all paths exist.
        checkExistense();

        // Clear all files from the output directory.
        if (mGeneratedDir.exists())
        {
            File[] files = mGeneratedDir.listFiles();
            for (int i = 0; i < files.length; i++)
                files[i].delete();
        }
        else
        {
            mGeneratedDir.mkdir();
        }

        // Create a connection to the database.
        createConnection();

        // Construct paths to where images are saved during HTML export.
        mHtmlImagesDir = new File(request.getSession().getServletContext().getRealPath("../"), "aspose.words\\Documents");
        mHtmlImageAliasPath = new URI(request.getScheme(), null, request.getServerName(), SERVER_PORT, "/aspose.words/Documents/", null, null);

        // Ensure that the folder used to store images when exporting to HTML exists.
        if(!mHtmlImagesDir.exists())
        {
           // Use mkdirs to create any necessary parent directories as well.
           mHtmlImagesDir.mkdirs();
        }

        // Check through the images folder for any files that are old and are to be removed.
        for(File file : mHtmlImagesDir.listFiles())
        {
            // Find the extension of the file name if it has one.
            String ext = null;
            String s = file.getName();
            int i = s.lastIndexOf('.');

            if (i > 0 &&  i < s.length() - 1) {
                ext = s.substring(i+1).toLowerCase();
            }

            // Only check if the file is to be removed if it is an PNG image file.
            if(ext != null && ext.equals("png"))
            {
                // The time and date the file was modified.
                Date fileDate = new Date(file.lastModified());
                // The current time and date.
                Date currentDate = new Date();

                // Get milliseconds of each time and subtract them.
                long diff = currentDate.getTime() - fileDate.getTime();
                // Calculate the difference in hours.
                int hoursDiff = (int)(diff / (1000 * 60 * 60));

                // If this png file is more than a day old then it can be removed.
                if(hoursDiff > 24)
                   file.delete();
            }
        }

        initLicense(new com.aspose.words.License());
        initLicense(new com.aspose.cells.License());
        initLicense(new com.aspose.barcode.License());

        isInitialized = true;
    }

    /**
     * Calculates the root dir of the demo project.
     *
     * The demo project dir is "demos/Aspose.Words.Demos".
     * It is proposed that compiled classes will be placed by compiler into "classes" subdir
     * of the project dir, so Demo.class (this) will be placed into
     * "demos/Aspose.Words.Demos/classes/com/aspose/words/demos/Demo.class".
     */
    private static File getProjectDir()
    {
        URL url = Demo.class.getResource("Demo.class");

        String path = new File(url.getPath()).getAbsolutePath();
        String subPath = "\\classes\\com\\aspose\\words\\demos\\Demo.class";

        return new File(path.substring(0, path.length() - subPath.length()));
    }

    /**
     * Note: The wrong project path will generally result in the wrong path to dependent directories and the
     * generated files.
     */
    private static void checkExistense()
    {
        if (!mProjectDir.exists())
            throw new IllegalArgumentException("Can't find the Project dir: " + mProjectDir.getAbsolutePath());

        if (!mDocumentsDir.exists())
            throw new IllegalArgumentException("Can't find the template documents dir: " + mDocumentsDir.getAbsolutePath());

        if (!mDatabaseDir.exists())
            throw new IllegalArgumentException("Can't find the database dir: " + mDatabaseDir.getAbsolutePath());

        if (!mDatabase.exists())
            throw new IllegalArgumentException("Can't find the database file: " + mDatabase.getAbsolutePath());
    }


    /**
     * Utility function that creates a database statement
     */
    public static Statement createStatement() throws Exception
    {
        return mConnection.createStatement(ResultSet.TYPE_SCROLL_INSENSITIVE, ResultSet.CONCUR_READ_ONLY);
    }

    /**
     * Cleans up and closes all ResultSets and Statements used. Then closes the connection to the database.
     */
    public static void closeResources() throws Exception
    {
        // Iterate through each ResultSet used by the demos. Close the result set and
        // parent statement.
        for(ResultSet rs : (Iterable<ResultSet>) mResultSetCollection)
        {
            if(rs != null)
            {
                Statement statement = rs.getStatement();

                rs.close();

                if(statement != null)
                    statement.close();
            }
        }

        mConnection.close();
    }

    /**
     * Called by concrete demo-class. Calculates paths to files used solely by this concrete demo.
     */
    protected void init(String demoName) throws Exception
    {
        context = FacesContext.getCurrentInstance();
        request = (HttpServletRequest) context.getExternalContext().getRequest();
        response = (HttpServletResponse) context.getExternalContext().getResponse();

        if(!isInitialized)
            initDemo();

        // Calculate files used solely by this concrete demo.
        mDemoName = demoName;
        File docTemplate = new File(mDocumentsDir, mDemoName + ".doc");
        File docxTemplate = new File(mDocumentsDir, mDemoName + ".docx");

        // Check to see if a DOC or DOCX template is used else throw an exception if no template
        // could be found.
        if (docTemplate.exists())
            mTemplate = docTemplate;
        else if (docxTemplate.exists())
            mTemplate = docxTemplate;
        else
            throw new IllegalArgumentException("Can't find the template document file for demo: " + demoName);
    }

    /**
     * Utility function that creates a connection to the Database.
     */
    public static void createConnection() throws Exception
    {
        //  Load a DB driver that is used by the demos
        Class.forName("sun.jdbc.odbc.JdbcOdbcDriver");
        // Compose connection string.
        String connectionString = "jdbc:odbc:DRIVER={Microsoft Access Driver (*.mdb)};" +
                                  "DBQ=" + mDatabase + ";UID=Admin";
        // DSN-less DB connection.
        mConnection = DriverManager.getConnection(connectionString);
    }

    /**
     * Executes the demo and returns a generated document. Implement in the derived classes.
     */
    public abstract Document execute() throws Exception;

    /**
     * Executes a query to the demo database using a new statement and returns the result in a ResultSet.
     */
    protected ResultSet executeQuery(String query) throws Exception
    {
        ResultSet rs = createStatement().executeQuery(query);
        // Add this resultset to be closed later.
        mResultSetCollection.add(rs);
        return rs;
    }

    //JAVA-added
    /**
     * Returns an demo name.
     */
    String getDemoName()
    {
        return mDemoName;
    }

    //JAVA-added
    /**
     * Returns a full path where the document generated by this demo should be stored.
     */
    String getPathToGeneratedDoc()
    {
        return new File(mGeneratedDir, mDemoName + ".doc").getAbsolutePath();
    }

    //JAVA-added
    /**
     * Returns a full path where the document generated by this demo should be stored.
     */
    String getPathToGeneratedHtml()
    {
        return new File(mGeneratedDir, mDemoName + ".html").getAbsolutePath();
    }

    //JAVA-added
    /**
     * Returns a full path where the document generated by this demo should be stored.
     */
    String getPathToGeneratedDocx()
    {
        return new File(mGeneratedDir, mDemoName + ".docx").getAbsolutePath();
    }

    //JAVA-added
    /**
     * Returns a full path where the document generated by this demo should be stored.
     */
    String getPathToGeneratedTxt()
    {
        return new File(mGeneratedDir, mDemoName + ".txt").getAbsolutePath();
    }

    //JAVA-added
    /**
     * Returns a root dir of this Aspose.Words release.
     * (the dir where unzipped downloaded Aspose.Words distributive).
     * Probably in that dir will be placed license file.
     *
     * Note: Can be called only after the demo initialization (initDemo() method).
     */
    static File getRootDistributiveDir()
    {
        assert mProjectDir != null;
        return mProjectDir.getParentFile().getParentFile();
    }

    String getPathToTemplateDoc()
    {
        return mTemplate.getAbsolutePath();
    }

    /**
     * Gets the path to the image to be inserted into the document
     */
    protected String getImagePath(){
         return mDocumentsDir + "\\Aspose.Words.gif";
    }

    /**
     * Project dir. Something like: 'Aspose.Words.Java installation path'\\demos\\Aspose.Words.Demos
     */
    protected static File mProjectDir;
    /**
     * Directory for template documents used by the demos: demos\\Documents.
     */
    protected static File mDocumentsDir;
    /**
     * Directory for documents generated by the demos: demos\\generated.
     */
    protected static File mGeneratedDir;
    /**
     * Directory for the Database used by the demos: demos\\Database.
     */
    protected static File mDatabaseDir;
    /**
     * This directory is used to store images generated in HTML format when documents are exported in
     * HTML format. Images are saved externally and they must be saved to a folder.
     * e.g C:\TomCat6.0\webapps\aspose.words\images\
     */
    protected static File mHtmlImagesDir;
    /**
     *Path used for the IMG tag in generated HTML which links to the external images stored in the folder above.
     * e.g http://localhost:80/aspose.words/Images/
     */
    protected static URI mHtmlImageAliasPath;
    /**
     * Define this explicitly as some server setups may return the wrong port.
     */
    protected static final int SERVER_PORT = 8081;
    /**
     * Database file used by the demos: demos\\Database\\Northwind.mdb.
     */
    protected static File mDatabase;
    /**
     * Stores a connection to the database.
     */
    protected static Connection mConnection;
    /**
     * Stores if the base variables used by all demos have been populated.
     */
    protected static boolean isInitialized = false;
    /**
     * Stores a list of ResultSet objects used in the demos. These are released when the demos have finished.
     */
    protected static ArrayList mResultSetCollection;
    /**
     * The name of this demo. Template document and all generated documents use this name.
     */
    protected String mDemoName;
    /**
     * Template document file used by the concrete demo.
     */
    protected File mTemplate;

    /**
     * Sends the document to the client's browser.
     */
    protected void sendToBrowser(Document doc, String demoName, String formatType, boolean openNewWindow)
            throws Exception
    {
        String fileName = demoName + "." + formatType;
        ByteArrayOutputStream out = new ByteArrayOutputStream();

        int saveFormat = FileFormatUtil.extensionToSaveFormat(formatType);

        if(saveFormat == SaveFormat.HTML || saveFormat == SaveFormat.MHTML || saveFormat == SaveFormat.EPUB)
        {
            // Set options used during export to HTML based formats.
            HtmlSaveOptions htmlOptions = new HtmlSaveOptions(saveFormat);
            htmlOptions.setExportHeadersFootersMode(ExportHeadersFootersMode.NONE);
            htmlOptions.setExportXhtmlTransitional(true);
            // This option improves how tables are displayed when exporting to EPUB format.
            htmlOptions.setTableWidthOutputMode(HtmlElementSizeOutputMode.NONE);
            // These two below are only needed for .html format to set where images are saved to and how to construct
            // the URI to the saved location.
            htmlOptions.setImagesFolder(mHtmlImagesDir.getAbsolutePath());
            htmlOptions.setImagesFolderAlias(mHtmlImageAliasPath.toString());

            doc.save(out, htmlOptions);
        }
        else
        {
           doc.save(out, saveFormat);
        }

        setResponse(fileName, out);
    }

    protected FacesContext context;
    protected HttpServletRequest request;
    protected HttpServletResponse response;

    //////////////////////////////////////////////////////////
    protected final String FILE_NAME = "result.doc";

    public Resource getGeneratedfile() {
        byte[] res = getResult();
        if (null==res || res.length<1) {
            return null;
        }
        return new ByteArrayResource(res);
    }

    private String fileName = FILE_NAME;
    public String getFilename() {
        return fileName;
    }

    private String respType = "application/msword";
    public String getResptype() {
        return respType;
    }
    public void setResptype(String v) {
        respType = v;
    }

    public void setFilename(String v) {

        SimpleDateFormat formatter = new SimpleDateFormat ("yyyy-MMM-dd_hh_mm_ss-", Locale.US);
        String curDate = formatter.format(new Date());

        this.fileName = curDate + v;

    }

    public  byte[] getResult()
    {
        return resp;
    }

    protected void setResponse(String fName, ByteArrayOutputStream out) throws IOException {
        setFilename(fName);
        resp = out.toByteArray();
        out.close();
    }
    protected byte[] resp;

    /**
     *
     * Initializes license (if demo license is available).
     * you may insert your licensing code here that would use obj's
     * setLicense based on InputStream rather than passing it on
     * to 3rd-party class.
     *
     */
    public static void initLicense(Object obj) {
        try {

            Class myclass = Class.forName("com.aspose.demos.Common");
            if (null==myclass) {
                System.out.println("initLicense not found");
                return ;
            }

            // Use reflection to list methods and invoke them
            Method[] methods = myclass.getMethods();
            Object object = myclass.newInstance();

            Class partypes[] = new Class[1];
            partypes[0] = Object.class;

            Method meth = myclass.getMethod("initLicense", partypes);
            if (null!=meth) {
                    Object arglist[] = new Object[1];
                    arglist[0] = obj;

                    meth.invoke(object, arglist);
            }
        } catch (ClassNotFoundException cnfe) {
            // Ignore
        } catch (Exception ex) {
            ex.printStackTrace();
        }
    }
}

<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd">
<html xmlns="http://www.w3.org/1999/xhtml"
      xmlns:ice="http://www.icesoft.com/icefaces/component"
      xmlns:ui="http://java.sun.com/jsf/facelets"
      xmlns:h="http://java.sun.com/jsf/html"
      xmlns:f="http://java.sun.com/jsf/core"
      xmlns:c="http://java.sun.com/jstl/core"
      xmlns:jsf="http://www.aspose.com/jsf"
      >

<ui:composition template="/WEB-INF/includes/templates/page-template.xhtml">
                        
    <ui:define name="pageTitle">
        Sales Invoice - Aspose.Words Demos
    </ui:define>

    <ui:define name="page-content">
        <ui:decorate template="/WEB-INF/includes/templates/tabbed_container.xhtml">
            <ui:define name="example">


                <p class="componentDescriptionTxt">Welcome to the <STRONG> Aspose.Words for Java</STRONG> Featured Demos!</p>
                <p class="componentDescriptionTxt">
                                        This demo shows one of the ways you can generate a sales invoice with a header, order details and a summary with Aspose.Words. In this demo you will 
                                        learn how to mail merge data from multiple tables, format date and numeric fields and use merge regions to grow portions of the document.
                </p>
                <P class="componentDescriptionTxt"><STRONG>Important</STRONG>: To produce Word documents, the machine to
                    run Aspose.Words for Java does not need to have Microsoft Word and Windows installed.
                    However, to view the contents of Word documents produced by demos, the machine to view
                    them needs at least Microsoft Word Viewer installed. Microsoft Word Viewer can be
                    <A href="http://www.microsoft.com/downloads/en/details.aspx?FamilyID=3657ce88-7cfa-457a-9aec-f4f827f20cac&amp;displaylang=en">
                    downloaded</A> for free.</P>
                <P class="componentDescriptionTxt">In all of these examples no OLE automation is used, all work is
                    performed by Aspose.Words for Java without Microsoft Word installed on the web server.</P>

                    <ui:include src="/WEB-INF/includes//templates/selectformat.xhtml" />

                <h:commandButton id="generate" action="#{salesinv.executeDemo}" value="Generate" /> 

                <ice:outputResource id="outResource"
                    mimeType="application/msword"
                    resource="#{salesinv.generatedfile}"
                    fileName="#{salesinv.filename}"
                    shared="false" />
            </ui:define>
        </ui:decorate>
    </ui:define>
        </ui:composition>
</html>