OdfUtils.java

  1. package org.jbehave.core.io.odf;

  2. import static org.apache.commons.lang3.StringUtils.join;
  3. import static org.odftoolkit.simple.common.TextExtractor.newOdfTextExtractor;

  4. import java.io.InputStream;
  5. import java.util.ArrayList;
  6. import java.util.Collection;
  7. import java.util.List;

  8. import org.odftoolkit.odfdom.dom.element.table.TableTableElement;
  9. import org.odftoolkit.odfdom.dom.element.text.TextParagraphElementBase;
  10. import org.odftoolkit.simple.Document;
  11. import org.odftoolkit.simple.TextDocument;
  12. import org.odftoolkit.simple.table.Cell;
  13. import org.odftoolkit.simple.table.Row;
  14. import org.odftoolkit.simple.table.Table;
  15. import org.w3c.dom.Node;
  16. import org.w3c.dom.NodeList;

  17. public class OdfUtils {

  18.     public static TextDocument loadOdt(InputStream resourceAsStream) {
  19.         try {
  20.             return TextDocument.loadDocument(resourceAsStream);
  21.         } catch (Exception cause) {
  22.             throw new OdfDocumentLoadingFailed(resourceAsStream, cause);
  23.         }
  24.     }

  25.     public static String parseOdt(TextDocument document) {
  26.         List<String> lines = new ArrayList<>();

  27.         try {
  28.             NodeList list = document.getContentRoot().getChildNodes();
  29.             for (int i = 0; i < list.getLength(); i++) {
  30.                 Node item = list.item(i);
  31.                 if (isTextNode(item)) {
  32.                     lines.add(parseTextNode(item));
  33.                 } else if (isTableNode(item)) {
  34.                     lines.addAll(parseTable(item));
  35.                 }
  36.             }
  37.         } catch (Exception e) {
  38.             throw new OdfDocumentParsingFailed(document, e);
  39.         }

  40.         return join(lines, System.getProperty("line.separator"));
  41.     }

  42.     private static Collection<String> parseTable(Node item) {
  43.         ArrayList<String> lines = new ArrayList<>();
  44.         Table table = Table.getInstance((TableTableElement) item);
  45.         for (Row row : table.getRowList()) {
  46.             lines.add(parseTableRow(row));
  47.         }
  48.         return lines;
  49.     }

  50.     private static String parseTableRow(Row row) {
  51.         String line = "|";
  52.         for (int i = 0; i < row.getCellCount(); i++) {
  53.             Cell cell = row.getCellByIndex(i);
  54.             line += cell.getDisplayText() + "|";
  55.         }
  56.         return line;
  57.     }

  58.     private static boolean isTableNode(Node item) {
  59.         return item instanceof TableTableElement;
  60.     }

  61.     private static String parseTextNode(Node item) {
  62.         TextParagraphElementBase textItem = (TextParagraphElementBase) item;
  63.         return newOdfTextExtractor(textItem).getText();
  64.     }

  65.     private static boolean isTextNode(Node item) {
  66.         return item instanceof TextParagraphElementBase;
  67.     }

  68.     @SuppressWarnings("serial")
  69.     public static class OdfDocumentLoadingFailed extends RuntimeException {

  70.         public OdfDocumentLoadingFailed(InputStream stream, Throwable cause) {
  71.             super("Failed to load ODF document from stream " + stream, cause);
  72.         }

  73.     }

  74.     @SuppressWarnings("serial")
  75.     public static class OdfDocumentParsingFailed extends RuntimeException {

  76.         public OdfDocumentParsingFailed(Document document, Throwable cause) {
  77.             super("Failed to parse ODF document " + document, cause);
  78.         }

  79.     }

  80. }