3 Replies Latest reply on Jun 10, 2014 6:31 AM by Michal Petrov

    richfaces 4 mediaOutput throwing PropertyNotFoundException

    Manish Prajapati Newbie

      Hi,

       

      I am using richfaces 4.3.6 Final along with JSF 2 and wildfly-8.1.0.CR1. In my application I am uploading image and showing that uploaded image into <rich:mediaOutput> but I am getting below exception while rendering <rich:mediaOutput> .Below is my xhtml and java code, please take a look at this and let me know If I am doing anything wrong.

       

      Any workaround or solution to fix it.

       

      Thanks in advance.

       

      upload.xhtml

       

      <ui:composition xmlns="http://www.w3.org/1999/xhtml"

          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:a4j="http://richfaces.org/a4j"

          xmlns:rich="http://richfaces.org/rich"

          xmlns:c="http://java.sun.com/jsp/jstl/core"

          xmlns:s="http://jboss.org/schema/seam/taglib"

          xmlns:cu="http://ext.test.com/cu/functions"

          xmlns:el="http://ext.test.com/el/functions">

       

          <h:form id="docupload" style="margin-left:5px; width: 100%;">

              <h:messages layout="horizontal" globalOnly="true" showDetail="false"

                  showSummary="true" />

       

              <c:choose>

                  <c:when test="#{featureConfig.OFLOWS_MOBILIZED_ENABLED().booleanValue() eq 'true' and themeResolver.canvasEnabled}">

                  <br/>

                      <span id="submitButton"> <s:link styleClass="button" view="/oconsole/appuploadhelper.seam"

                          ><span>Upload

                                  Documents</span>

                                      <s:conversationPropagation type="join"></s:conversationPropagation>

                                  </s:link>

                      </span>

                      <br/>

                      <br/>

                  </c:when>

                  <c:otherwise>

                      <rich:fileUpload  fileUploadListener="#{fileUploadBean.listener}"

                          maxFilesQuantity="#{fileUploadBean.uploadsAvailable}" id="upload"

                          immediateUpload="false"

                          acceptedTypes="jpg,gif,png,pdf,bmp,tif,tiff,jpeg"

                          allowFlash="#{featureConfig.ENABLE_FLASH_UPLOADS()}"

                          style="width:100%;"

                          disabled="#{appRequest.checkApplicationsStatus()}">

                          <a4j:ajax event="uploadcomplete" render="info" />

                      </rich:fileUpload>

                  </c:otherwise>

              </c:choose>

       

       

              <p>Once you've uploaded your documents, classify each one using

                  the categories below.</p>

       

              <rich:panel bodyClass="info" id="info">

                  <f:facet name="header">

                      <h:outputText value="Classify uploaded documents" />

                  </f:facet>

                  <h:outputText value="No files currently uploaded"

                      rendered="#{fileUploadBean.size==0}" />

                  <s:div id="docuploadTable" style="border:none;">

                      <c:forEach items="#{fileUploadBean.files}" var="file"

                          varStatus="row">

                          <s:div id="docRow#{row.index}" styleClass="documentRow">

                              <s:div id="docImageCol#{row.index}"

                                  styleClass="docUploadImageColumn">

                                  <a4j:mediaOutput id="docImage#{row.index}" element="img"

                                      mimeType="#{file.mime}" createContent="#{fileUploadBean.paint}"

                                      value="#{row.index}" style="max-width:200px;" cacheable="false">

                                      <f:param value="#{fileUploadBean.timeStamp}" name="time" />

                                      <s:conversationId value="#{conversation.id}" />

                                  </a4j:mediaOutput>

                              </s:div>

                              <s:div id="docCategoryCol#{row.index}"

                                  styleClass="docUploadCategoryColumn">

                                  <h:selectOneMenu id="docCategory#{row.index}" name="docCategory" value="">

                                      <el:setValueBinding var="selectionmap"

                                          valueBinding="#{fileUploadBean.documentCategory}" />

                                      <s:selectItems var="selection"

                                          value="#{selectionmap.entrySet()}" label="#{selection.value}"

                                          itemValue="#{selection.key}" hideNoSelectionLabel="true" />

                                  </h:selectOneMenu>

                              </s:div>

                          </s:div>

                          <br class="clearfloat" />

                          <br class="clearfloat" />

                      </c:forEach>

                  </s:div>

              </rich:panel>

       

              <br />

              <span id="uploadSaveBtn"> <a4j:commandLink id="saveLink"

                      onclick="replaceWithSpinner(this);"

                      action="#{fileUploadBean.saveSupportingDocuments()}"

                      styleClass="button" render="docupload">

                      <s:conversationPropagation type="join"></s:conversationPropagation>

                      <span>Save</span>

                  </a4j:commandLink>

              </span>

          </h:form>

      </ui:composition>

       

      DocUploadBean.java


      package com.test.seam.action.oweb;

       

      import static org.apache.commons.lang3.ArrayUtils.isEmpty;

      import static org.apache.commons.lang3.StringUtils.isEmpty;

       

      import java.awt.image.BufferedImage;

      import java.io.BufferedInputStream;

      import java.io.ByteArrayInputStream;

      import java.io.ByteArrayOutputStream;

      import java.io.IOException;

      import java.io.OutputStream;

      import java.io.Serializable;

      import java.util.ArrayList;

      import java.util.Collection;

      import java.util.Date;

      import java.util.HashMap;

      import java.util.Iterator;

      import java.util.List;

      import java.util.Map;

       

      import javax.el.ELContext;

      import javax.faces.application.FacesMessage;

      import javax.faces.component.UIComponent;

      import javax.faces.component.html.HtmlSelectOneMenu;

      import javax.faces.context.FacesContext;

      import javax.imageio.ImageIO;

       

      import org.apache.commons.lang3.StringUtils;

      import org.jboss.seam.Component;

      import org.jboss.seam.ScopeType;

      import org.jboss.seam.annotations.AutoCreate;

      import org.jboss.seam.annotations.Begin;

      import org.jboss.seam.annotations.Create;

      import org.jboss.seam.annotations.Destroy;

      import org.jboss.seam.annotations.End;

      import org.jboss.seam.annotations.Factory;

      import org.jboss.seam.annotations.In;

      import org.jboss.seam.annotations.Name;

      import org.jboss.seam.annotations.Scope;

      import org.jboss.seam.annotations.Synchronized;

      import org.jboss.seam.annotations.web.RequestParameter;

      import org.jboss.seam.contexts.Contexts;

      import org.jboss.seam.core.Conversation;

      import org.jboss.seam.log.Log;

      import org.jboss.seam.log.Logging;

      import org.jboss.seam.ui.component.html.HtmlDiv;

      import org.richfaces.event.FileUploadEvent;

      import org.richfaces.model.UploadedFile;

       

      import com.drew.imaging.ImageMetadataReader;

      import com.drew.metadata.Metadata;

      import com.drew.metadata.exif.ExifIFD0Directory;

      import com.drew.metadata.exif.ExifSubIFDDirectory;

      import com.lowagie.text.DocumentException;

      import com.lowagie.text.Image;

      import com.lowagie.text.PageSize;

      import com.lowagie.text.pdf.PdfContentByte;

      import com.lowagie.text.pdf.PdfCopyFields;

      import com.lowagie.text.pdf.PdfImportedPage;

      import com.lowagie.text.pdf.PdfReader;

      import com.lowagie.text.pdf.PdfWriter;

      import com.lowagie.text.pdf.RandomAccessFileOrArray;

      import com.lowagie.text.pdf.codec.TiffImage;

      import com.test.seam.entity.ApplicationRequest;

      import com.test.seam.entity.Customer;

      import com.test.seam.entity.Document;

      import com.test.seam.entity.DocumentImage;

      import com.test.seam.entity.InputField;

      import com.test.seam.entity.RawSupportingDocument;

      import com.test.seam.entity.SupportingDocument;

      import com.test.seam.entity.UserType;

      import com.test.seam.infrastructure.ELEvaluator;

      import com.test.seam.infrastructure.UserContext;

      import com.test.seam.session.oconsole.OConsoleDocUploadManagerBean;

      import com.test.seam.session.oconsole.ProductsInfo;

      import com.test.seam.session.oweb.DocUploadManager;

      import com.test.seam.session.oweb.DocUploadManagerBean;

      import com.test.seam.util.PDFToImageConvertor;

      import com.test.seam.web.util.PageScopeUtil;

       

       

      @Name(DocUploadBean.COMPONENT_NAME)

      @Scope(ScopeType.CONVERSATION)

      // TODO: change this to page scope and fix the interaction

      @Synchronized(timeout = 100000)

      @AutoCreate

      public class DocUploadBean implements Serializable {

       

          private static final int MAX_FILE_SIZE_IN_DATABASE = 5 * 1014 * 1024;

       

          public static final String COMPONENT_NAME = "fileUploadBean";

       

          /**

           *

           */

          private static final long serialVersionUID = 5339410002696528789L;

       

          // http://itextdocs.lowagie.com/tutorial/general/index.php - See Step 1, and

          // description of margin width

          private static final float ONE_INCH = 72.0f;

       

          private String customerLevelUpload;

       

          public String getCustomerLevelUpload() {

              return customerLevelUpload;

          }

       

          public void setCustomerLevelUpload(String customerLevelUpload) {

              this.customerLevelUpload = customerLevelUpload;

          }

       

          private static final float MAX_CONTENT_WIDTH = PageSize.LETTER.getWidth() - ONE_INCH; // 1 inch margin

          private static final float MAX_CONTENT_HEIGHT = PageSize.LETTER.getHeight() - ONE_INCH; // 1 inch margin

       

          private boolean decisionTableEnabled;

          // @In (create=true) DocUploadManager docUploadManager;

          private static Log log = Logging.getLog(DocUploadBean.class);

       

          @In

          UserContext userContext;

       

          @In(required=false, create=false)

          ApplicationRequest appRequest;

       

          @Create

          @Begin(join=true)

          public void create(){

              log.debug("Creating DocUploadBean in conversation: " +Conversation.instance().getId() );

          }

       

          @Destroy

          public void remove(){

              log.debug("Destroying DocUploadBean in conversation: " +Conversation.instance().getId() );

          }

       

       

          public static String className = DocUploadManagerBean.class.getName();

       

          // files holds atomic support docs.  each page in a multi page pdf is separated

          // into individual pdf doc that can be used as different supporting documents.

          // e.g. a multipage pdf has 1 page of passport img, 1 page of insurance id

          // This will get separated into 2 pdf docs and stored in files

          private ArrayList<DocumentAndCategory> files = new ArrayList<DocumentAndCategory>();

       

          // separate compound supporting documents into individual page of separate pdf docs

          // private List<DocumentAndCategory> atomicSupportingDocs;

       

       

          private int uploadsAvailable = 10;

          private boolean autoUpload = false;

          private boolean useFlash = false;

          //private SupportingDocumentCategory defaultCategory = SupportingDocumentCategory.BANK_STATEMENT;

          //private List<SupportingDocumentCategory> documentCategory;

       

          public int getSize() {

              if (getFiles().size() > 0) {

                  return getFiles().size();

              } else {

                  return 0;

              }

          }

       

          public DocUploadBean() {

       

          }

       

          public void paint(OutputStream stream, Object object) throws IOException {

              log.debug("DocUploadBean.paint()");

              log.debug("size: " + files.size());

              log.debug("index: " + object);

              stream.write(getFiles().get((Integer) object).getData());

          }

       

          public void listener(FileUploadEvent event) throws Exception {

              log.debug(className +".listener() is called to convert and store uploaded files.");

              PageScopeUtil pageScopeUtil = PageScopeUtil.instance();

              pageScopeUtil.setErrMsg(null);//clear if previous request had errors, note cannot use event scope for the uploader as the upload is its own request

              UploadedFile item = event.getUploadedFile();

              //By default this flag variable will be false. When user is on validate decision table

              //tab in console page that time, this flag variable will be true means it will  invoke code

              //related to validating decision table which is in else section of this condition.

              if(!decisionTableEnabled){

       

                  RawSupportingDocument rawDocument = createRawDocument(item);

                  saveRawDocument(rawDocument);

       

                  if (!isEmpty(rawDocument.getDocumentImage().getContent())) {

                      log.info("Processing uploaded file '#0'", rawDocument.getDocumentImage().getFileName());

                      try{

                          if (StringUtils.endsWithIgnoreCase(item.getName(), ".pdf")) {

                              log.debug("process uploaded pdf file");

                              preparePdf(rawDocument.getDocumentImage().getFileName(), rawDocument.getDocumentImage().getContent());

                          } else if (StringUtils.endsWithIgnoreCase(item.getName(), ".tif")

                                  || StringUtils.endsWithIgnoreCase(item.getName(), ".tiff")) {

                              log.debug("process uploaded tiff file");

                              prepareTiff(item.getName(), rawDocument.getDocumentImage().getContent());

                          } else {

                              log.debug("process uploaded file (jpg,gif,png,pdf,bmp)");

                              prepareImage(item.getName(), rawDocument.getDocumentImage().getContent());

                          }

                      } catch(PDFSecurityException pse){

                          String errMsg = "Your PDF document has security settings that prevented us from processing it.";

                          pageScopeUtil.setErrMsg(errMsg);

                          log.error(errMsg, pse);

                          return;

                      }catch(Throwable t){

                          String errMsg = "There is some problem with the uploaded file, we can't process it.";

                          pageScopeUtil.setErrMsg(errMsg);

                          log.error(t, t.getMessage());

                          return;

                      }

                  }

                  uploadsAvailable--;

              } else {

                  validateDecisionTable(item);

              }

          }

       

          private void prepareImage(String fileName, byte[] data) throws Exception {

              files.add(extractPageFromImage(data, fileName, null));

          }

       

          private DocumentAndCategory extractPageFromImage(final byte[] data, final String fileName, String documentCategory) throws Exception {

              // pdf wrapper around the image

              DocumentAndCategory pdfDoc = new DocumentAndCategory();

              pdfDoc.setName(fileName);

              pdfDoc.setDocumentCategory(documentCategory);

              byte[] pdfBytes = convertOtherToPDFDoc(data);

              pdfDoc.setPdfByte(pdfBytes);

       

              // the image

              pdfDoc.setData(data);

              pdfDoc.setLength(data.length);

              return pdfDoc;

          }

       

          private DocumentAndCategory extractPageFromImage(byte[] data, String fileName) throws Exception {

              return extractPageFromImage(data, fileName, null);

          }

       

          private void prepareTiff(String fileName, byte[] data) throws Exception {

              final List<DocumentAndCategory> docs = extractPagesFromTiff(data, fileName, null);

              for (DocumentAndCategory doc: docs) {

                  files.add(doc);

              }

          }

       

          private List<DocumentAndCategory> extractPagesFromTiff(final byte[] data,

                  String fileName, String documentCategory) throws Exception {

              // convert each page in the tiff into a separate pdf

              // note each tiff image can have multiple pages

              List<byte[]> pdfByteList = convertTiffToPDFDocs(data);

       

              final List<DocumentAndCategory> docs = new ArrayList<DocUploadBean.DocumentAndCategory>();

       

              // store each pdf in this.files list, also include the thumb nails

              for (int c = 0; c < pdfByteList.size(); c++) {

                  DocumentAndCategory pdfDoc = new DocumentAndCategory();

                  // store the pdf for each page

                  pdfDoc.setName(fileName);

                  pdfDoc.setDocumentCategory(documentCategory);

                  byte[] pdfBytes = pdfByteList.get(c);

                  pdfDoc.setPdfByte(pdfBytes);

       

                  // store the thumb nail image

                  List<byte[]> imageBytesList = convertPDFToImagePages(pdfBytes, true);

                  byte[] imageBytes = imageBytesList.get(0);

                  pdfDoc.setData(imageBytes);

                  pdfDoc.setLength(imageBytes.length);

                  docs.add(pdfDoc);

              }

              return docs;

          }

       

          private Collection<DocumentAndCategory> extractPagesFromTiff(byte[] data, String fileName) throws Exception {

              return extractPagesFromTiff(data, fileName, null);

          }

       

          private void preparePdf(String fileName, byte[] data) throws Exception {

              final List<DocumentAndCategory> docs = extractPagesFromPdf(data, fileName, null);

              for (DocumentAndCategory doc: docs) {

                  files.add(doc);

              }

          }

       

          private List<DocumentAndCategory> extractPagesFromPdf(final byte[] data, final String fileName, String documentCategory) throws Exception {

              // separate the pdf into separate pages, one page per doc

              List<byte[]> pdfByteList = separatePDFPages(data);

       

              // get the individual page image

              List<byte[]> imageBytesList = convertPDFToImagePages(data, true);

       

              final List<DocumentAndCategory> docs = new ArrayList<DocUploadBean.DocumentAndCategory>();

       

              // save each jpg image in the files object.  files object is later used to categorize each doc.

              for (int c = 0; c < imageBytesList.size(); c++) {

                  DocumentAndCategory pdfDoc = new DocumentAndCategory();

                  // store the pdf for each page

                  pdfDoc.setName(fileName);

                  pdfDoc.setDocumentCategory(documentCategory);

                  byte[] pdfBytes = pdfByteList.get(c);

                  pdfDoc.setPdfByte(pdfBytes);

       

                  // store the thumb nail image

                  byte[] imageBytes = imageBytesList.get(c);

                  pdfDoc.setData(imageBytes);

                  pdfDoc.setLength(imageBytes.length);

                  docs.add(pdfDoc);

              }

              return docs;

          }

       

          private List<DocumentAndCategory> extractPagesFromPdf(byte[] data, String fileName) throws Exception {

              return extractPagesFromPdf(data, fileName, null);

          }

       

          private void saveRawDocument(RawSupportingDocument rsd) {

              log.info("Saving File Name: #0, Content Type: #1", rsd.getDocumentImage().getFileName(), rsd.getDocumentImage().getMimeType());

              String componentName = "";

              if (userContext.getNamespace().getUserType() == UserType.OFFICER)

                  componentName = OConsoleDocUploadManagerBean.COMPONENT_NAME;

              else

                  componentName = DocUploadManagerBean.COMPONENT_NAME;

              DocUploadManager docUploadManager = (DocUploadManager) Component

                      .getInstance(componentName);

              docUploadManager.saveRaw(rsd);

          }

       

          private RawSupportingDocument createRawDocument(UploadedFile item) throws IOException {

              DocumentImage d = new DocumentImage();

              // TODO: item.isTempFile() -- alternate in RF4?

      //        if (item.isTempFile()) {

      //            if (item.getFile().length() < MAX_FILE_SIZE_IN_DATABASE) {

      //                log.info("Loading file '#0' (#1K) into DB", item.getName(), item.getFile().length() / 1024);

      //                FileInputStream fileInput = null;

      //                try {

      //                    fileInput = new FileInputStream(item.getFile());

      //                    d.setContent(IOUtils.toByteArray(fileInput));

      //                } finally {

      //                    IOUtils.closeQuietly(fileInput);

      //                }

      //                try {

      //                    item.getFile().delete();

      //                } catch (Exception e) {

      //                    log.warn("Can't remove uploaded file '#0'", e, item.getFile().getAbsolutePath());

      //                }

      //            } else {

      //                log.info("Uploaded file '#0' is to big (#1K), leaving it in the file system", item.getName(), item.getFile().length() / 1024);

      //                d.setFilePath(item.getFile().getAbsolutePath());

      //            }

      //        } else {

                  log.info("Loading file '#0' (#1K) into DB", item.getName(), item.getData().length / 1024);

                  d.setContent(item.getData());

      //        }

              d.setFileName(item.getName());

              d.setDescription(item.getName());

              d.setMimeType(item.getContentType());

              d.setLabel(item.getName());

       

              RawSupportingDocument rsd = new RawSupportingDocument();

              rsd.setDocumentImage(d);

              return rsd;

          }

       

          /**

           * Use by console to save uploaded supporting docs

           */

          public void saveSupportingDocuments() {

              try {

                  saveSupportingDocuments(OConsoleDocUploadManagerBean.COMPONENT_NAME);

                  FacesContext.getCurrentInstance().addMessage(

                          null,

                          new FacesMessage(FacesMessage.SEVERITY_INFO,

                                  "Supporting Documents are uploaded", null));

              } catch (Exception e) {

                  // TODO Auto-generated catch block

                  e.printStackTrace();

              }

          }

       

          /**

           * responsible for saving uploaded document from docupload.xhtml in app

           * It will append the new supporting doc to the existing set in the database

           *

           * @param componentName

           */

          public void saveSupportingDocuments(String componentName) {

              saveSupportingDocuments(componentName, true);

              clearUploadData();

          }

          /**

           * This method is responsible for saving the changes made on already

           * uploaded supporting documents on Re-categorization of supporting

           * documents page.

           *

           * It will not append.  Instead it will erase what is in db and than save

           *

           */

          public void saveRecategorizedSupportingDocuments() {

              saveSupportingDocuments(DocUploadManagerBean.COMPONENT_NAME, false);

       

          }

       

       

          /**

           * helper function to save supporting documents.

           *

           * @param componentName

           * @param isAppend

           */

          @End

          public void saveSupportingDocuments(String componentName, boolean isAppend) {

              try {

                  UIComponent dependenciesComp = FacesContext.getCurrentInstance().getViewRoot().findComponent("docupload:docuploadTable");

                  HtmlDiv html = (HtmlDiv) dependenciesComp;

                  // setup categorizedDocMap which maps category to each file in this.files (contains jpg image)

                  Map<String, List<DocumentAndCategory>> categorizedDocMap = new HashMap<String, List<DocumentAndCategory>>();

                  for (int i = 0; i < html.getChildren().size(); i++) {

                      DocumentAndCategory file = files.get(i);

       

                      // process those not mark for delete

                      if (file.getMarkForDelete()==false) {

                          HtmlDiv innerDiv = (HtmlDiv) html.getChildren().get(i);

                          HtmlSelectOneMenu selectMenu = (HtmlSelectOneMenu) innerDiv.getChildren().get(1).getChildren().get(0);

                          if(selectMenu != null && selectMenu.getValue() != null){

                              String category = selectMenu.getValue().toString();

                              if (categorizedDocMap.get(category) != null) {

                                  List<DocumentAndCategory> documentList = categorizedDocMap.get(category);

                                  documentList.add(file);

                              } else {

                                  List<DocumentAndCategory> documentList = new ArrayList<DocumentAndCategory>();

                                  documentList.add(file);

                                  categorizedDocMap.put(category, documentList);

                              }

                          }else{

                              log.warn("Uploaded supporting document was not categorized.");

                          }

                      }

                  }

       

                  // convert categorizedDocMap to pdf documents.

                  List<SupportingDocument> supportingDocList = mergePdfDocByCategory(categorizedDocMap);

       

                  // save the pdf docs

                  DocUploadManager docUploadManager = (DocUploadManager) Component.getInstance(componentName);

                  docUploadManager.save(supportingDocList, isAppend);

       

                  // clean up; scan backward and remove those in the files that have been deleted

                  for (int count = files.size(); count>0; count--) {

                      if (files.get(count-1).getMarkForDelete()==true) {

                          files.remove(count-1);

                      }

                  }

       

              } catch (Exception e) {

                  log.error(e);

              }

          }

       

          @Factory(value = "documentCategory")

          public Map<String, String> getDocumentCategory() {

              String componentName = "";

              if (userContext.getNamespace().getUserType() == UserType.OFFICER) componentName = OConsoleDocUploadManagerBean.COMPONENT_NAME;

              else componentName = DocUploadManagerBean.COMPONENT_NAME;

              DocUploadManager docUploadManager = (DocUploadManager)Component.getInstance(componentName);

              return docUploadManager.getSupportingDocumentCtgry();

          }

       

          /*@Factory(value = "documentCategory")

          public List<SupportingDocumentCategory> getDocumentCategory() {

              SupportingDocumentCategory[] sdcArray = SupportingDocumentCategory

                      .values();

              List<SupportingDocumentCategory> sdcList = new ArrayList<SupportingDocumentCategory>();

              for (int i = 0; i < sdcArray.length; i++) {

                  sdcList.add(sdcArray[i]);

              }

              return sdcList;

          }

       

          public SupportingDocumentCategory getDefaultCategory() {

              return defaultCategory;

          }

       

          public void setDefaultCategory(SupportingDocumentCategory defaultCategory) {

              this.defaultCategory = defaultCategory;

          }

       

          public void setDocumentCategory(

                  List<SupportingDocumentCategory> documentCategory) {

              this.documentCategory = documentCategory;

          }*/

       

          public String clearUploadData() {

              files.clear();

              setUploadsAvailable(10);

              return null;

          }

       

       

          /**

           * convert a multipage tiff into multiple pdf docs

           *

           * @param imageBytes

           * @return

           */

          public List<byte[]> convertTiffToPDFDocs(byte[] imageBytes) {

              // each item in the list is a byte array of a pdf document.  the pdf document holds the one image in the multi-page tiff

              List<byte[]> pdfByteList = new ArrayList<byte[]>();

       

              RandomAccessFileOrArray ra = new RandomAccessFileOrArray(imageBytes);

              int pages = TiffImage.getNumberOfPages(ra);

              for(int i = 1; i <= pages; i++){

                  // construct the pdf doc

                  com.lowagie.text.Document document = new com.lowagie.text.Document();

                  ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

                  try {

                      PdfWriter w = PdfWriter.getInstance(document, byteArrayOutputStream);

                  } catch (DocumentException e) {

                      log.error("failed to create PdfWriter: #0", e);

                      e.printStackTrace();

                  }

                  document.open();

                  // resize the tiff if necessary

                  Image tiff = TiffImage.getTiffImage(ra, i);

                  if (tiff == null)

                      break;

       

                  // scale and rotate if the img is too big

                  if (tiff.getHeight() > MAX_CONTENT_HEIGHT || tiff.getWidth() > MAX_CONTENT_WIDTH) {

                      // if image length is shorter than width by more than an inch

                      if ((tiff.getHeight() + ONE_INCH) < tiff.getWidth()) {

                          tiff.setRotationDegrees(-90);

                      }

                      tiff.scaleToFit(MAX_CONTENT_WIDTH, MAX_CONTENT_HEIGHT);

                  }

       

                  adjustRotation(imageBytes, tiff);

       

                  // add tiff to doc

                  try {

                      document.add(tiff);

                  } catch (DocumentException e) {

                      log.error("failed to add tiff to pdf doc: #0", e);

                      e.printStackTrace();

                  }

                  document.close();

                  pdfByteList.add(byteArrayOutputStream.toByteArray());

              }

       

              return pdfByteList;

          }

       

          /**

           * convert jpg,gif,png,pdf,bmp to pdf

           * @param imageBytes

           * @return

           * @throws Exception

           */

          public byte[] convertOtherToPDFDoc(byte[] imageBytes) throws Exception {

              com.lowagie.text.Document document = new com.lowagie.text.Document();

              ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();

              PdfWriter w = PdfWriter.getInstance(document, byteArrayOutputStream);

              // w.setFullCompression();

              // w.setCompressionLevel(9);

              document.open();

              Image jpg = Image.getInstance(imageBytes);

       

              if (jpg == null)

                  return null;

              if (jpg.getHeight() > MAX_CONTENT_HEIGHT || jpg.getWidth() > MAX_CONTENT_WIDTH)

                  jpg.scaleToFit(MAX_CONTENT_WIDTH, MAX_CONTENT_HEIGHT);

       

              adjustRotation(imageBytes, jpg);

              document.add(jpg);

              document.close();

              return byteArrayOutputStream.toByteArray();

          }

       

          /**

           * Fixes the rotation of the image if the initial orientation was not normal.

           * Requires the image has EXIF meta data and is of supported formatts, JPEG, TIFF, or GIF

           *

           * TODO - use apache Tika instead?

           *

           * Drew Metadata-extractor image library is used

           *     http://code.google.com/p/metadata-extractor/wiki/GettingStarted

           * reference to orientation codes:

           *     http://jpegclub.org/exif_orientation.html

           *

           * @param imageBytes - used by parse out the EXIF image meta data

           * @param iTextImg - used to rotate the image before embedding into a PDF

           */

          private void adjustRotation(byte[] imageBytes, Image iTextImg){

              if(imageBytes == null)

                  return;

       

              if(iTextImg == null)

                  return;

       

              BufferedInputStream bis= null;

              try {

                  bis = new BufferedInputStream(new ByteArrayInputStream(imageBytes));

                  boolean waitForBytes = false;

                  int exifOrientation = 1;//default to normal, which needs no rotation

       

                  Metadata metadata = ImageMetadataReader.readMetadata(bis, waitForBytes);

       

                  if(log.isTraceEnabled()){

                      //list image's taken date

                      ExifSubIFDDirectory directory = metadata.getDirectory(ExifSubIFDDirectory.class);

                      if(directory != null && directory.containsTag(ExifSubIFDDirectory.TAG_DATETIME_ORIGINAL)){

                          Date date = directory.getDate(ExifSubIFDDirectory.TAG_DATETIME_ORIGINAL);

                          log.trace("Image taken on: " + date);

                      }

                  }

       

                  //find tag orientation

                  final ExifIFD0Directory exifIFD0Directory = metadata.getDirectory(ExifIFD0Directory.class);

                  if(exifIFD0Directory != null && exifIFD0Directory.containsTag(ExifIFD0Directory.TAG_ORIENTATION)){

                      exifOrientation = exifIFD0Directory.getInt(ExifIFD0Directory.TAG_ORIENTATION);

                      log.debug("Image EXIF orientation: " + exifOrientation);

                  }else{

                       log.debug("Image did not have EXIF orientation meta tag specified, not adjusting rotation");

                       return;

                  }

       

                  //Note rotation will turn it to the left, counter clockwise

                  switch(exifOrientation){

                      case 1:

                          log.debug("EXIF orientation of 1, no adjustment rotation required.");

                          break;//normal

                      case 2:

                          log.debug("EXIF orientation of 2, no adjustment rotation required.");

                          break;//flip/mirror, consider unflipping

                      case 3:

                          iTextImg.setRotationDegrees(180);//upside down

                          log.info("Adjusted uploaded image rotation by 180 degrees to compensate for EXIF orientation of 3, upside down.");

                          break;

                      case 4:

                          iTextImg.setRotationDegrees(180);//upside down

                          log.info("Adjusted uploaded image rotation by 180 degrees to compensate for EXIF orientation of 4, upside down.");

                          break;

                      case 5:

                          iTextImg.setRotationDegrees(-90);//right side is up

                          log.info("Adjusted uploaded image rotation by -90 degrees to compensate for EXIF orientation of 5, right side is up.");

                          break;

                      case 6:

                          iTextImg.setRotationDegrees(-90);//left side is down

                          log.info("Adjusted uploaded image rotation by -90 degrees to compensate for EXIF orientation of 6, left side is down.");

                          break;

                      case 7:

                          iTextImg.setRotationDegrees(90);//right side is down

                          log.info("Adjusted uploaded image rotation by 90 degrees to compensate for EXIF orientation of 7, right side is down.");

                          break;

                      case 8:

                          iTextImg.setRotationDegrees(90);//left side is up

                          log.info("Adjusted uploaded image rotation by 90 degrees to compensate for EXIF orientation of 6, left side is up.");

                          break;

                  }

              }catch(Exception e) {

                  String errMsg = "Problem attempting to identify and rotate image based on EXIF metadata, error=" + e.getMessage();

                  log.error(errMsg, e);

              }finally{

                  if(bis != null){

                      try {

                          bis.close();

                      } catch (Exception ie) {

                          log.error("Error closing buffered input stream for docupload bean meta data read, error=" + ie.getMessage(), ie);

                      }

                  }

              }

          }

       

          /**

           * merge a list of documents into a single pdf document

           *

           * @param pages

           * @return

           * @throws DocumentException

           * @throws IOException

           */

          public byte[] mergeDocList(List<DocumentAndCategory> pages) throws DocumentException, IOException {

              if (pages != null && pages.size() > 0) {

       

                  List<PdfReader> readers = new ArrayList<PdfReader>();

                  Iterator<DocumentAndCategory> iteratorPDFs = pages.iterator();

       

                  // Create readers for each pdfs in the docList.

                  while (iteratorPDFs.hasNext()) {

                      DocumentAndCategory doc = iteratorPDFs.next();

                      PdfReader pdfReader = new PdfReader(doc.pdfData);

                      readers.add(pdfReader);

                  }

       

                  // create a pdf copy to hold the merged doc

                  ByteArrayOutputStream baos = new ByteArrayOutputStream();

                  PdfCopyFields copy = new PdfCopyFields(baos);

                  copy.open();

       

                  // iterate every pdf reader and append to the pdf copy

                  Iterator<PdfReader> iter = readers.iterator();

                  while (iter.hasNext()) {

                      PdfReader pdfReader = iter.next();

                      copy.addDocument(pdfReader);

                  }

                  copy.close();

                  return baos.toByteArray();

              }

              return null;

          }

       

          /**

           * each catagory can have multiple docs.  this function

           * converts all pdfs for each category into one category pdf.

           *

           * @param categorizedDocMap

           * @return

           * @throws Exception

           */

          public List<SupportingDocument> mergePdfDocByCategory(Map<String, List<DocumentAndCategory>> categorizedDocMap) throws Exception {

              List<SupportingDocument> pdfDocumentsList = new ArrayList<SupportingDocument>();

              // iterate every category

              Iterator<String> categoryIter = categorizedDocMap.keySet().iterator();

              while (categoryIter.hasNext()) {

                  String category = categoryIter.next();

                  List<DocumentAndCategory> documentList = categorizedDocMap.get(category);

                  SupportingDocument sDocument = createSupportingDoc(documentList, category);

                  pdfDocumentsList.add(sDocument);

              }

              return pdfDocumentsList;

          }

       

          private SupportingDocument createSupportingDoc(List<DocumentAndCategory> pages, String category) throws DocumentException, IOException {

              // merge all docs into 1 pdf

              byte pdfBytes[] = mergeDocList(pages);

       

              SupportingDocument sDocument = new SupportingDocument();

              DocumentImage docImage = new DocumentImage();

              docImage.setContent(pdfBytes);

              docImage.setFileName(category + ".pdf");

              docImage.setDescription(category + " Documents");

              docImage.setMimeType("application/pdf");

              sDocument.setDocumentImage(docImage);

              //sDocument.setDocumentCategory(SupportingDocumentCategory.valueOf(category));

              //sDocument.setDocumentCategory(appLookupManager.getApplicationLookupByName(EnumCtgry.DOCUMENT_CATEGORY, category));

              sDocument.setDocumentCategory(category);

              return sDocument;

          }

       

          /**

           * Separate a multipage pdf into individual pages with 1 pdf document each

           *

           * @param pdfBytes

           * @return

           */

          public List<byte[]> separatePDFPages(byte[] pdfBytes) throws Exception {

              List<byte[]> results = new ArrayList<byte[]>();

              try {

                  PdfReader srcPdf = new PdfReader(pdfBytes);

                  boolean encryptedPDF = srcPdf.isEncrypted();

                  if(encryptedPDF){

                      log.debug("PDF is encrypted");

                      //byte[] userPwd = srcPdf.computeUserPassword();

                      //srcPdf = new PdfReader(pdfBytes, userPwd);

                      //srcPdf = new PdfReader(pdfBytes, "test".getBytes());

                      //com.lowagie.tools.plugins.Decrypt;

                  }

                  int totalPages = srcPdf.getNumberOfPages();

       

                  // itext pdf start with page 1

                  for (int c=1; c<=totalPages; c++) {

                      // each page gets its own document

                      com.lowagie.text.Document document = new com.lowagie.text.Document();

       

                      // Create a writer for the outputstream for each page doc

                      ByteArrayOutputStream outputStream = new ByteArrayOutputStream();

                      PdfWriter writer = PdfWriter.getInstance(document, outputStream);

       

                      document.open();

                      PdfContentByte cb = writer.getDirectContent(); // Holds the PDF data

                      PdfImportedPage srcPage = null;

       

                      document.newPage();

                      //writer.setEncryption(1, 2, 2, PdfWriter.STANDARD_ENCRYPTION_128);

                      try{

                          srcPage = writer.getImportedPage(srcPdf, c);

                      }catch(Exception e){

                          if(e.getMessage().toLowerCase().contains("password") ||

                                  e.getMessage().toLowerCase().contains("security")){

                              throw new PDFSecurityException(e);

                          }else{

                              throw e;

                          }

                      }

                      cb.addTemplate(srcPage, 0, 0);

       

                      outputStream.flush();

                      document.close();

                      outputStream.close();

                      results.add(outputStream.toByteArray());

                  }

              } catch(PDFSecurityException pse){

                  throw pse;

              }catch (Exception e) {

                  log.error("separatePDFPages() failed to separate pdf document into individual pages.  " + e.getMessage());

                  e.printStackTrace();

              }

              return results;

          }

       

          /**

           * convert each page in the pdf to jpg images

           *

           * @param pdfBytes

           * @param allPages

           * @return

           * @throws Exception

           */

          public List<byte[]> convertPDFToImagePages(byte[] pdfBytes, boolean allPages)

                  throws Exception {

              List<byte[]> bytesList = new ArrayList<byte[]>();

              PDFToImageConvertor pdfToImage = (PDFToImageConvertor) Component.getInstance(PDFToImageConvertor.class);

              List<BufferedImage> bufferedImageList = pdfToImage.convertPDFToImage(pdfBytes, true, false);

              for (int i = 0; i < bufferedImageList.size(); i++) {

                  BufferedImage bufferedImage = bufferedImageList.get(i);

                  ByteArrayOutputStream baos = new ByteArrayOutputStream();

                  ImageIO.write(bufferedImage, "jpg", baos);

                  byte[] imageBytes = baos.toByteArray();

                  bytesList.add(imageBytes);

              }

              return bytesList;

          }

       

       

          /**

           * Call by docupload.page.xml (docupload.xhtml) to load supporting_document from database.

           * @throws Exception

           */

          // @Create

          public void loadFaxedDocuments() throws Exception {

              log.debug(" getFaxedDocuments() of " + className + " is called to retrieve faxed documents.");

       

              // load the pdf doc, one per category, from database

              DocUploadManager docUploadManager = (DocUploadManager) Component.getInstance(DocUploadManagerBean.class);

              loadSupportingDocuments(docUploadManager.getFaxedDocuments());

          }

          /**

           *  This method will be called from UI while entering into the validation decision table Tab.( productslist.xhtml)

           *  It will enable decisionTableEnabled instance variable so that listner method which is common for all other file uploads

           *  will execute code specific to validate decision table.

           */

          public void enableDecisionTableConfig(){

              log.info("Entered into enableDecisionTableConfig");

              decisionTableEnabled = true;

          }

          /**

           * This method is responsible for validating the uploaded xls file. It will be called from listener method

           * if decisionTableEnabled instance variable is true. Internally this method invokes ProductInfo.validateDecisionTable()

           * which has the actual logic of validating decision table and will return the msg accordingly.

           * @param item  item contains actual uploaded file data and metadata.

           */

          public void validateDecisionTable(UploadedFile item){

              log.info("Entered into validateDecisionTable, Validating decision table : "+item.getName());

              ProductsInfo productInfo = (ProductsInfo) Component.getInstance("productsInfo");

              PageScopeUtil pageScopeUtil = PageScopeUtil.instance();

              String errMsg = productInfo.validateDecisionTable(item.getData());

              pageScopeUtil.setErrMsg(errMsg);

          }

          /**

           * This method is responsible for loading the existing supporting

           * documents from db on recategorizedocs.xhtml

           *

           * @param componentName

           * @throws Exception

           */

       

          public void loadSupportingDocumets(String componentName) throws Exception {

              log.info("Load Supporting Documents called for component:" + componentName);

              DocUploadManager docUploadManager = (DocUploadManager) Component.getInstance(componentName);

       

              // get supporting docs from database

              loadSupportingDocuments(docUploadManager.getUploadedSupportingDocuments());

          }

       

          /**

           *

           * This helper function does the following

           * 1.  break each page in each supporting doc into separate pdf doc

           * 2.  create separate images (one per page) for each pdf doc for use as thumb nail

           *

           * All these in formation is stored in this.files list

           * @param supportingDocList

           * @throws Exception

           */

          void loadSupportingDocuments(List<SupportingDocument> supportingDocList) throws Exception {

              files.clear();

              // iterate through each supporting doc and create an image for every page in the doc

              if (supportingDocList != null) {

                  for (SupportingDocument sd : supportingDocList) {

                      // separate the pdf into individual pages.  each page is a pdf doc

                      List<byte[]> pdfByteList = separatePDFPages(sd.getDocumentImage().getContent());

       

                      // get image for each page in the pdf

                      List<byte[]> imageBytesList = convertPDFToImagePages(sd.getDocumentImage().getContent(), true);

       

                      // add every page to this.files list

                      for (int i = 0; i < imageBytesList.size(); i++) {

                          byte[] pdfBytes = pdfByteList.get(i);

                          byte[] imageBytes = imageBytesList.get(i);

       

                          DocumentAndCategory pdfDoc = new DocumentAndCategory();

                          //pdfDoc.setDocumentCategory(sd.getDocumentCategory());

                          if (sd.getDocumentCategory() != null) pdfDoc.setDocumentCategory(sd.getDocumentCategory());

                          pdfDoc.setName(sd.getDocumentImage().getFileName());

                          pdfDoc.setPdfByte(pdfBytes);

                          pdfDoc.setLength(imageBytes.length);

                          pdfDoc.setData(imageBytes);

                          files.add(pdfDoc);

                      }

                  }

              }

          }

       

          /**

           * This method is responsible for removing a supporting

           * documents from this.files.  Change is not saved until user click update button

           *

           * @param docId

           * @throws Exception

           */

          public void removeSupportingDocument(int index) throws Exception {

              files.remove(index);

          }

       

          public long getTimeStamp() {

              return System.currentTimeMillis();

          }

       

          public ArrayList<DocumentAndCategory> getFiles() {

              return files;

          }

       

          public void setFiles(ArrayList<DocumentAndCategory> files) {

              this.files = files;

          }

       

          /**

           * use by recategorizeddocs.xhtml

           *

           * @return

           */

          public List<DocumentAndCategory> getSupportingDocs() {

              return files;

          }

       

          public int getUploadsAvailable() {

              return uploadsAvailable;

          }

       

          public void setUploadsAvailable(int uploadsAvailable) {

              this.uploadsAvailable = uploadsAvailable;

          }

       

          public boolean getAutoUpload() {

              return autoUpload;

          }

       

          public void setAutoUpload(boolean autoUpload) {

              this.autoUpload = autoUpload;

          }

       

          public boolean getUseFlash() {

              return useFlash;

          }

       

          public void setUseFlash(boolean useFlash) {

              this.useFlash = useFlash;

          }

       

       

          public static class DocumentAndCategory extends Document {

       

              private byte[] pdfData = null;

              private boolean markForDelete = false;

       

              /*        private SupportingDocumentCategory documentCategory;

       

              public SupportingDocumentCategory getDocumentCategory() {

                  return documentCategory;

              }

       

              public void setDocumentCategory(SupportingDocumentCategory documentCategory) {

                  this.documentCategory = documentCategory;

              }*/

       

              private String documentCategory;

       

              public DocumentAndCategory(SupportingDocument document) {

                  setPdfByte(document.getDocumentImage().getContent());

                  setData(document.getDocumentImage().getContent());

                  setDocumentCategory(document.getDocumentCategory());

              }

       

              public DocumentAndCategory() {

              }

       

              public String getDocumentCategory(){

                  return documentCategory;

              }

       

              public void setDocumentCategory(String documentCategoryParam) {

                  this.documentCategory = documentCategoryParam;

              }

       

              public void setPdfByte(byte[] pdf) {

                  this.pdfData = pdf;

              }

       

              public void setMarkForDelete(boolean b) {

                  markForDelete = b;

              }

       

              public boolean getMarkForDelete() {

                  return markForDelete;

              }

       

          }

       

          public Boolean checkDocumentsSignedByCoapplicant() {

              DocUploadManager docUploadManager = (DocUploadManager) Component.getInstance(DocUploadManagerBean.COMPONENT_NAME);

              return docUploadManager.checkDocumentsSignedByCoapplicant();

          }

       

          @RequestParameter private String appReqId;

       

          public String getAppReqId() {

              return appReqId;

          }

       

          public void setAppReqId(String appReqId) {

              this.appReqId = appReqId;

          }

       

          public void propagateAppRequest(){

              if(appReqId != null){

                  //This upload operation is being associated with an application/appRequest

                  //put the id into session so other things can use it if needed

                  //ie for page navigation after upload (check on co-applicant or not)

                  Contexts.getSessionContext().set("appReqId", new Long(appReqId));

              }

       

              //to support primary to upload his own document from home this action is required

              //because of joint workflow streamline changes

              if(customerLevelUpload != null && customerLevelUpload.equals("1")){

                  Long appReqId = (Long) Contexts.getSessionContext().get("appReqId");

                  if(appReqId != null){

                      Contexts.getSessionContext().set("isPrimaryContinuingAsJoint"+appReqId, false);

                  }

       

              }

          }

       

          @SuppressWarnings("serial")

          public static class PDFSecurityException extends Exception{

              public PDFSecurityException(){

       

              }

       

              public PDFSecurityException(Exception e){

                  super(e);

              }

       

              public PDFSecurityException(Throwable t){

                  super(t);

              }

       

              public PDFSecurityException(String msg, Exception e){

                  super(msg, e);

              }

          }

       

          public void driversLicenseUploadListener(FileUploadEvent event) throws Exception {

              if (event.getComponent().getValueExpression("inputField") == null) {

                  throw new IllegalArgumentException("Can't find attribute: inputField");

              }

              final InputField inputField = (InputField)event.getComponent()

                      .getValueExpression("inputField")

                      .getValue(FacesContext.getCurrentInstance().getELContext());

       

              final Customer customer = (Customer)ELEvaluator.eval(inputField.getField().getEntity().getEffectivePath());

       

              customer.clearDriverLicenseRawDocuments();

       

              documentUploadListener(event);

          }

       

          public void documentUploadListener(FileUploadEvent event) throws Exception {

              PageScopeUtil pageScopeUtil = PageScopeUtil.instance();

              pageScopeUtil.setErrMsg(null);//clear if previous request had errors, note cannot use event scope for the uploader as the upload is its own request

       

              if (event.getComponent().getValueExpression("inputField") == null) {

                  throw new IllegalArgumentException("Can't find attribute: inputField");

              }

              ELContext elContext = FacesContext.getCurrentInstance().getELContext();

              final InputField inputField = (InputField)event.getComponent()

                      .getValueExpression("inputField")

                      .getValue(elContext);

       

              final Customer customer = (Customer)ELEvaluator.eval(inputField.getField().getEntity().getEffectivePath());

       

              final UploadedFile UploadedFile = event.getUploadedFile();

              final String documentCategory = inputField.getDocumentCategory();

       

              if (isEmpty(documentCategory)) {

                  throw new IllegalArgumentException("documentCategory is null, check field configuration: " +

                          inputField.getFieldGroup().getPage().getInputPageType() + ":" +

                          inputField.getFieldGroup().getName() + ":" +

                          inputField.getField().getName());

              }

       

              final RawSupportingDocument rawDocument = createRawDocument(UploadedFile);

              rawDocument.setClient(userContext.getClient());

              rawDocument.setCustomer(customer);

              rawDocument.setCategory(documentCategory);

              customer.addRawSupportingDocument(rawDocument);

       

              // re-create document from raw documents (including new raw)

              if (!isEmpty(rawDocument.getDocumentImage().getContent())) {

                  log.info("Processing file '#0' (#1K)",

                          rawDocument.getDocumentImage().getFileName(), rawDocument.getDocumentImage().getContent().length / 1024);

                  customer.removeDocumentsByCategory(documentCategory);

                  final List<RawSupportingDocument> rawDocuments = customer.getRawDocumentsByCategory(documentCategory);

                  final List<DocumentAndCategory> pages = extractPages(rawDocuments);

                  final SupportingDocument document = createSupportingDoc(pages, documentCategory);

                  customer.addSupportingDocument(document);

                  document.setCustomer(customer);

                  document.setClient(userContext.getClient());

              }

          }

       

          private List<DocumentAndCategory> extractPages(List<RawSupportingDocument> rawDocuments) throws Exception {

              List<DocumentAndCategory> docPages = new ArrayList<DocUploadBean.DocumentAndCategory>();

              for (final RawSupportingDocument raw: rawDocuments) {

                  final DocumentImage docImage = raw.getDocumentImage();

                  if (docImage.isPdf()) {

                      docPages.addAll(extractPagesFromPdf(docImage.getContent(), docImage.getFileName()));

                  } else if (docImage.isTiff()) {

                      docPages.addAll(extractPagesFromTiff(docImage.getContent(), docImage.getFileName()));

                  } else {

                      docPages.add(extractPageFromImage(docImage.getContent(), docImage.getFileName()));

                  }

              }

              return docPages;

          }

      }

       

       

      Thanks,

      Manish