Primefaces dataExporter - inline PDF in new window without footer

Question

I'm trying to use Primefaces's dataExporter component. I have two problems with it (for now):

1. In column footers of datatable I have a p:commandButton. What happens to me is that when I export datatable with dataExporter to PDF I can see that it added column footers to PDF and wrote something like this: javax.faces.component.UIPanel@9e08b9 (it just called toString of UIComponent I suppose). Is there any way to instruct dataExporter to ignore column footers?

2. I want to try to somehow open new window with generated PDF and show that PDF inline on a new page. I don't wont to see Download file prompt. Is this possible?

Answer 1

After some time, and coding I finally succeeded to make this work. Primefaces doesn't have this functions included so I have to override default behavior little bit.

First I created custom PDFExporter to skip footer printing:

import java.io.ByteArrayOutputStream;
import java.io.IOException;

import javax.faces.context.ExternalContext;
import javax.faces.context.FacesContext;

import org.primefaces.component.datatable.DataTable;
import org.primefaces.component.export.PDFExporter;

import com.lowagie.text.DocumentException;
import com.lowagie.text.pdf.PdfPTable;

public class CustomPDFExporter extends PDFExporter {

    @Override
    protected void addColumnFacets(DataTable table, PdfPTable pdfTable,
            ColumnType columnType) {
        if (columnType == ColumnType.HEADER) {
            super.addColumnFacets(table, pdfTable, columnType);
        }
    }

    @Override
    protected void writePDFToResponse(ExternalContext externalContext,
            ByteArrayOutputStream baos, String fileName) throws IOException,
            DocumentException {

        FacesContext.getCurrentInstance().getExternalContext().getSessionMap()
                .put("reportBytes", baos.toByteArray());
        FacesContext.getCurrentInstance().getExternalContext().getSessionMap()
                .put("reportName", fileName);
    }

}

As you can see, report data is added in session.

Now DataExporter of Primefaces should be rewriten:

import java.io.IOException;

import javax.el.ELContext;
import javax.el.MethodExpression;
import javax.el.ValueExpression;
import javax.faces.FacesException;
import javax.faces.component.StateHolder;
import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.event.ActionEvent;
import javax.faces.event.ActionListener;
import javax.servlet.ServletContext;
import javax.servlet.http.HttpServletRequest;

import org.primefaces.component.datatable.DataTable;
import org.primefaces.component.export.CSVExporter;
import org.primefaces.component.export.Exporter;
import org.primefaces.component.export.ExporterType;
import org.primefaces.component.export.XMLExporter;
import org.primefaces.context.RequestContext;

import asw.iis.common.ui.beans.DatatableBackingBean;

public class CustomDataExporter implements ActionListener, StateHolder {

    private ValueExpression target;
    private ValueExpression type;
    private ValueExpression fileName;
    private ValueExpression encoding;
    private MethodExpression preProcessor;
    private MethodExpression postProcessor;
    private DatatableBackingBean<?> datatableBB;

    public CustomDataExporter() {}

    public CustomDataExporter(ValueExpression target, ValueExpression type, ValueExpression fileName, ValueExpression encoding,
            MethodExpression preProcessor, MethodExpression postProcessor, DatatableBackingBean<?> datatableBB) {
        this.target = target;
        this.type = type;
        this.fileName = fileName;
        this.encoding = encoding;
        this.preProcessor = preProcessor;
        this.postProcessor = postProcessor;
        this.datatableBB = datatableBB;
    }

    public void processAction(ActionEvent event) {
        FacesContext context = FacesContext.getCurrentInstance();
        try {
            datatableBB.stampaPreProcess();
            ELContext elContext = context.getELContext();

            String tableId = (String) target.getValue(elContext);
            String exportAs = (String) type.getValue(elContext);
            String outputFileName = (String) fileName.getValue(elContext);

            String encodingType = "UTF-8";
            if(encoding != null) {
                encodingType = (String) encoding.getValue(elContext);
            }

            try {
                Exporter exporter;
                ExporterType exporterType = ExporterType.valueOf(exportAs.toUpperCase());
                switch(exporterType) {
                case XLS:
                    exporter = new ExcelExporter();
                    break;

                case PDF:
                    exporter = new CustomPDFExporter();
                    break; 

                case CSV:
                    exporter = new CSVExporter();
                    break; 

                case XML:
                    exporter = new XMLExporter();
                    break;

                default:
                    exporter = new CustomPDFExporter();
                    break;
                }

                UIComponent component = event.getComponent().findComponent(tableId);
                if(component == null) {
                    throw new FacesException("Cannot find component \"" + tableId + "\" in view.");
                }

                if(!(component instanceof DataTable)) {
                    throw new FacesException("Unsupported datasource target:\"" + component.getClass().getName() + "\", exporter must target a PrimeFaces DataTable.");
                }

                DataTable table = (DataTable) component;
                exporter.export(context, table, outputFileName, false, false, encodingType, preProcessor, postProcessor);

                if ("pdf".equals(exportAs)) {
                    String path = ((ServletContext)(FacesContext.getCurrentInstance().getExternalContext().getContext())).getContextPath();
                    RequestContext.getCurrentInstance().execute("window.open('" + path + "/report.pdf', '_blank', 'dependent=yes, menubar=no, toolbar=no')");
                } else {
                    context.responseComplete();
                }
            } 
            catch (IOException e) {
                throw new FacesException(e);
            }
        }
        finally {
            ((HttpServletRequest) context.getExternalContext().getRequest()).removeAttribute("vrstaStampe");
            datatableBB.stampaPostProcess();
        }
    }

    public boolean isTransient() {
        return false;
    }

    public void setTransient(boolean value) {
    }

    public void restoreState(FacesContext context, Object state) {
        Object values[] = (Object[]) state;

        target = (ValueExpression) values[0];
        type = (ValueExpression) values[1];
        fileName = (ValueExpression) values[2];
        preProcessor = (MethodExpression) values[3];
        postProcessor = (MethodExpression) values[4];
        encoding = (ValueExpression) values[5];
        datatableBB = (DatatableBackingBean<?>) values[6];
    }

    public Object saveState(FacesContext context) {
        Object values[] = new Object[7];

        values[0] = target;
        values[1] = type;
        values[2] = fileName;
        values[3] = preProcessor;
        values[4] = postProcessor;
        values[5] = encoding;
        values[6] = datatableBB;

        return ((Object[]) values);
    }
}

Main job here is to instantiate CustomPDFExporter, and open new window in case when report type is PDF.

Now I wrote simple Servlet to handle this request and print report data:

import java.io.IOException;

import javax.servlet.ServletException;
import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet("/report.pdf")
public class PdfReportServlet extends HttpServlet {

    private static final long serialVersionUID = 1L;

    @Override
    protected void doGet(HttpServletRequest req, HttpServletResponse resp)
            throws ServletException, IOException {
        byte[] b = (byte[]) req.getSession().getAttribute("reportBytes");
        if (b == null) {
            b = new byte[0];
        }
        resp.setContentType("application/pdf");
        resp.setContentLength(b.length);
        resp.getOutputStream().write(b);
        req.getSession().removeAttribute("reportBytes");
    }
}

This will configure HTTP header, and print bytes of report to output stream. Also it removes report bytes from session.

Finally, as I handle this printing from dynamically created menu button I add this action listener in code:

MenuItem item = ...;
ELContext el = FacesContext.getCurrentInstance().getELContext();
ExpressionFactory ef = FacesContext.getCurrentInstance().getApplication().getExpressionFactory();
ValueExpression typeEL = ef.createValueExpression(el, "#{startBean.reportType}", String.class);
ValueExpression fileEL = ef.createValueExpression(el, datasource, String.class);
ValueExpression targetEL = ef.createValueExpression(el, ":" + datatableId + ":datatableForm:datatable", String.class);
ValueExpression encodingEL = ef.createValueExpression(el, "ISO-8859-2", String.class);
CustomDataExporter de = new CustomDataExporter(targetEL, typeEL, fileEL, encodingEL, null, null, this);
item.setAjax(true);
item.addActionListener(de);