Examples with XSSFSingleXmlCell org.apache.poi.xssf.usermodel.helpers.XSSFSingleXmlCell used on opensource projects

Example 1 with XSSFSingleXmlCell

use of org.apache.poi.xssf.usermodel.helpers.XSSFSingleXmlCell in project poi by apache.

the class XSSFMap method getRelatedSingleXMLCell.

/**
     * @return the list of Single Xml Cells that provide a map rule to this mapping.
     */
public List<XSSFSingleXmlCell> getRelatedSingleXMLCell() {
    List<XSSFSingleXmlCell> relatedSimpleXmlCells = new ArrayList<XSSFSingleXmlCell>();
    int sheetNumber = mapInfo.getWorkbook().getNumberOfSheets();
    for (int i = 0; i < sheetNumber; i++) {
        XSSFSheet sheet = mapInfo.getWorkbook().getSheetAt(i);
        for (POIXMLDocumentPart p : sheet.getRelations()) {
            if (p instanceof SingleXmlCells) {
                SingleXmlCells singleXMLCells = (SingleXmlCells) p;
                for (XSSFSingleXmlCell cell : singleXMLCells.getAllSimpleXmlCell()) {
                    if (cell.getMapId() == ctMap.getID()) {
                        relatedSimpleXmlCells.add(cell);
                    }
                }
            }
        }
    }
    return relatedSimpleXmlCells;
}

Example 2 with XSSFSingleXmlCell

use of org.apache.poi.xssf.usermodel.helpers.XSSFSingleXmlCell in project poi by apache.

the class XSSFImportFromXML method importFromXML.

/**
     * Imports an XML into the XLSX using the Custom XML mapping defined
     *
     * @param xmlInputString the XML to import
     * @throws SAXException if error occurs during XML parsing
     * @throws XPathExpressionException if error occurs during XML navigation
     * @throws ParserConfigurationException if there are problems with XML parser configuration
     * @throws IOException  if there are problems reading the input string
     */
public void importFromXML(String xmlInputString) throws SAXException, XPathExpressionException, IOException {
    DocumentBuilder builder = DocumentHelper.newDocumentBuilder();
    Document doc = builder.parse(new InputSource(new StringReader(xmlInputString.trim())));
    List<XSSFSingleXmlCell> singleXmlCells = _map.getRelatedSingleXMLCell();
    List<XSSFTable> tables = _map.getRelatedTables();
    XPathFactory xpathFactory = XPathFactory.newInstance();
    XPath xpath = xpathFactory.newXPath();
    // Setting namespace context to XPath
    // Assuming that the namespace prefix in the mapping xpath is the
    // same as the one used in the document
    xpath.setNamespaceContext(new DefaultNamespaceContext(doc));
    for (XSSFSingleXmlCell singleXmlCell : singleXmlCells) {
        STXmlDataType.Enum xmlDataType = singleXmlCell.getXmlDataType();
        String xpathString = singleXmlCell.getXpath();
        Node result = (Node) xpath.evaluate(xpathString, doc, XPathConstants.NODE);
        // result can be null if value is optional (xsd:minOccurs=0), see bugzilla 55864
        if (result != null) {
            String textContent = result.getTextContent();
            logger.log(POILogger.DEBUG, "Extracting with xpath " + xpathString + " : value is '" + textContent + "'");
            XSSFCell cell = singleXmlCell.getReferencedCell();
            logger.log(POILogger.DEBUG, "Setting '" + textContent + "' to cell " + cell.getColumnIndex() + "-" + cell.getRowIndex() + " in sheet " + cell.getSheet().getSheetName());
            setCellValue(textContent, cell, xmlDataType);
        }
    }
    for (XSSFTable table : tables) {
        String commonXPath = table.getCommonXpath();
        NodeList result = (NodeList) xpath.evaluate(commonXPath, doc, XPathConstants.NODESET);
        // the first row contains the table header
        int rowOffset = table.getStartCellReference().getRow() + 1;
        int columnOffset = table.getStartCellReference().getCol() - 1;
        for (int i = 0; i < result.getLength(); i++) {
            // TODO: implement support for denormalized XMLs (see
            // OpenOffice part 4: chapter 3.5.1.7)
            Node singleNode = result.item(i).cloneNode(true);
            for (XSSFXmlColumnPr xmlColumnPr : table.getXmlColumnPrs()) {
                int localColumnId = (int) xmlColumnPr.getId();
                int rowId = rowOffset + i;
                int columnId = columnOffset + localColumnId;
                String localXPath = xmlColumnPr.getLocalXPath();
                localXPath = localXPath.substring(localXPath.substring(1).indexOf('/') + 2);
                // TODO: convert the data to the cell format
                String value = (String) xpath.evaluate(localXPath, singleNode, XPathConstants.STRING);
                logger.log(POILogger.DEBUG, "Extracting with xpath " + localXPath + " : value is '" + value + "'");
                XSSFRow row = table.getXSSFSheet().getRow(rowId);
                if (row == null) {
                    row = table.getXSSFSheet().createRow(rowId);
                }
                XSSFCell cell = row.getCell(columnId);
                if (cell == null) {
                    cell = row.createCell(columnId);
                }
                logger.log(POILogger.DEBUG, "Setting '" + value + "' to cell " + cell.getColumnIndex() + "-" + cell.getRowIndex() + " in sheet " + table.getXSSFSheet().getSheetName());
                setCellValue(value, cell, xmlColumnPr.getXmlDataType());
            }
        }
    }
}

Example 3 with XSSFSingleXmlCell

use of org.apache.poi.xssf.usermodel.helpers.XSSFSingleXmlCell in project poi by apache.

the class XSSFExportToXml method exportToXML.

/**
     * Exports the data in an XML stream
     *
     * @param os OutputStream in which will contain the output XML
     * @param encoding the output charset encoding
     * @param validate if true, validates the XML against the XML Schema
     * @throws SAXException If validating the document fails
     * @throws TransformerException If transforming the document fails
     */
public void exportToXML(OutputStream os, String encoding, boolean validate) throws SAXException, TransformerException {
    List<XSSFSingleXmlCell> singleXMLCells = map.getRelatedSingleXMLCell();
    List<XSSFTable> tables = map.getRelatedTables();
    String rootElement = map.getCtMap().getRootElement();
    Document doc = DocumentHelper.createDocument();
    final Element root;
    if (isNamespaceDeclared()) {
        root = doc.createElementNS(getNamespace(), rootElement);
    } else {
        root = doc.createElementNS("", rootElement);
    }
    doc.appendChild(root);
    List<String> xpaths = new Vector<String>();
    Map<String, XSSFSingleXmlCell> singleXmlCellsMappings = new HashMap<String, XSSFSingleXmlCell>();
    Map<String, XSSFTable> tableMappings = new HashMap<String, XSSFTable>();
    for (XSSFSingleXmlCell simpleXmlCell : singleXMLCells) {
        xpaths.add(simpleXmlCell.getXpath());
        singleXmlCellsMappings.put(simpleXmlCell.getXpath(), simpleXmlCell);
    }
    for (XSSFTable table : tables) {
        String commonXPath = table.getCommonXpath();
        xpaths.add(commonXPath);
        tableMappings.put(commonXPath, table);
    }
    Collections.sort(xpaths, this);
    for (String xpath : xpaths) {
        XSSFSingleXmlCell simpleXmlCell = singleXmlCellsMappings.get(xpath);
        XSSFTable table = tableMappings.get(xpath);
        if (!xpath.matches(".*\\[.*")) {
            // Exports elements and attributes mapped with simpleXmlCell
            if (simpleXmlCell != null) {
                XSSFCell cell = simpleXmlCell.getReferencedCell();
                if (cell != null) {
                    Node currentNode = getNodeByXPath(xpath, doc.getFirstChild(), doc, false);
                    mapCellOnNode(cell, currentNode);
                    //remove nodes which are empty in order to keep the output xml valid
                    if ("".equals(currentNode.getTextContent()) && currentNode.getParentNode() != null) {
                        currentNode.getParentNode().removeChild(currentNode);
                    }
                }
            }
            // Exports elements and attributes mapped with tables
            if (table != null) {
                List<XSSFXmlColumnPr> tableColumns = table.getXmlColumnPrs();
                XSSFSheet sheet = table.getXSSFSheet();
                int startRow = table.getStartCellReference().getRow();
                // In mappings created with Microsoft Excel the first row contains the table header and must be skipped
                startRow += 1;
                int endRow = table.getEndCellReference().getRow();
                for (int i = startRow; i <= endRow; i++) {
                    XSSFRow row = sheet.getRow(i);
                    Node tableRootNode = getNodeByXPath(table.getCommonXpath(), doc.getFirstChild(), doc, true);
                    short startColumnIndex = table.getStartCellReference().getCol();
                    for (int j = startColumnIndex; j <= table.getEndCellReference().getCol(); j++) {
                        XSSFCell cell = row.getCell(j);
                        if (cell != null) {
                            XSSFXmlColumnPr pointer = tableColumns.get(j - startColumnIndex);
                            String localXPath = pointer.getLocalXPath();
                            Node currentNode = getNodeByXPath(localXPath, tableRootNode, doc, false);
                            mapCellOnNode(cell, currentNode);
                        }
                    }
                }
            }
        }
    /*else {
                // TODO:  implement filtering management in xpath
            }*/
    }
    boolean isValid = true;
    if (validate) {
        isValid = isValid(doc);
    }
    if (isValid) {
        /////////////////
        //Output the XML
        //set up a transformer
        TransformerFactory transfac = TransformerFactory.newInstance();
        Transformer trans = transfac.newTransformer();
        trans.setOutputProperty(OutputKeys.OMIT_XML_DECLARATION, "yes");
        trans.setOutputProperty(OutputKeys.INDENT, "yes");
        trans.setOutputProperty(OutputKeys.ENCODING, encoding);
        //create string from xml tree
        StreamResult result = new StreamResult(os);
        DOMSource source = new DOMSource(doc);
        trans.transform(source, result);
    }
}