first commit

modules/x13import/tools/Spout/Writer/AbstractMultiSheetsWriter.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace Box\Spout\Writer;
+
+use Box\Spout\Writer\Exception\WriterNotOpenedException;
+
+/**
+ * Class AbstractMultiSheetsWriter
+ *
+ * @package Box\Spout\Writer
+ * @abstract
+ */
+abstract class AbstractMultiSheetsWriter extends AbstractWriter
+{
+    /** @var bool Whether new sheets should be automatically created when the max rows limit per sheet is reached */
+    protected $shouldCreateNewSheetsAutomatically = true;
+
+    /**
+     * @return Common\Internal\WorkbookInterface The workbook representing the file to be written
+     */
+    abstract protected function getWorkbook();
+
+    /**
+     * Sets whether new sheets should be automatically created when the max rows limit per sheet is reached.
+     * This must be set before opening the writer.
+     *
+     * @api
+     * @param bool $shouldCreateNewSheetsAutomatically Whether new sheets should be automatically created when the max rows limit per sheet is reached
+     * @return AbstractMultiSheetsWriter
+     * @throws \Box\Spout\Writer\Exception\WriterAlreadyOpenedException If the writer was already opened
+     */
+    public function setShouldCreateNewSheetsAutomatically($shouldCreateNewSheetsAutomatically)
+    {
+        $this->throwIfWriterAlreadyOpened('Writer must be configured before opening it.');
+
+        $this->shouldCreateNewSheetsAutomatically = $shouldCreateNewSheetsAutomatically;
+        return $this;
+    }
+
+    /**
+     * Returns all the workbook's sheets
+     *
+     * @api
+     * @return Common\Sheet[] All the workbook's sheets
+     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If the writer has not been opened yet
+     */
+    public function getSheets()
+    {
+        $this->throwIfBookIsNotAvailable();
+
+        $externalSheets = [];
+        $worksheets = $this->getWorkbook()->getWorksheets();
+
+        /** @var Common\Internal\WorksheetInterface $worksheet */
+        foreach ($worksheets as $worksheet) {
+            $externalSheets[] = $worksheet->getExternalSheet();
+        }
+
+        return $externalSheets;
+    }
+
+    /**
+     * Creates a new sheet and make it the current sheet. The data will now be written to this sheet.
+     *
+     * @api
+     * @return Common\Sheet The created sheet
+     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If the writer has not been opened yet
+     */
+    public function addNewSheetAndMakeItCurrent()
+    {
+        $this->throwIfBookIsNotAvailable();
+        $worksheet = $this->getWorkbook()->addNewSheetAndMakeItCurrent();
+
+        return $worksheet->getExternalSheet();
+    }
+
+    /**
+     * Returns the current sheet
+     *
+     * @api
+     * @return Common\Sheet The current sheet
+     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If the writer has not been opened yet
+     */
+    public function getCurrentSheet()
+    {
+        $this->throwIfBookIsNotAvailable();
+        return $this->getWorkbook()->getCurrentWorksheet()->getExternalSheet();
+    }
+
+    /**
+     * Sets the given sheet as the current one. New data will be written to this sheet.
+     * The writing will resume where it stopped (i.e. data won't be truncated).
+     *
+     * @api
+     * @param Common\Sheet $sheet The sheet to set as current
+     * @return void
+     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If the writer has not been opened yet
+     * @throws \Box\Spout\Writer\Exception\SheetNotFoundException If the given sheet does not exist in the workbook
+     */
+    public function setCurrentSheet($sheet)
+    {
+        $this->throwIfBookIsNotAvailable();
+        $this->getWorkbook()->setCurrentSheet($sheet);
+    }
+
+    /**
+     * Checks if the book has been created. Throws an exception if not created yet.
+     *
+     * @return void
+     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If the book is not created yet
+     */
+    protected function throwIfBookIsNotAvailable()
+    {
+        if (!$this->getWorkbook()) {
+            throw new WriterNotOpenedException('The writer must be opened before performing this action.');
+        }
+    }
+}
+

modules/x13import/tools/Spout/Writer/AbstractWriter.php

@@ -0,0 +1,384 @@
+<?php
+
+namespace Box\Spout\Writer;
+
+use Box\Spout\Common\Exception\IOException;
+use Box\Spout\Common\Exception\InvalidArgumentException;
+use Box\Spout\Common\Exception\SpoutException;
+use Box\Spout\Common\Helper\FileSystemHelper;
+use Box\Spout\Writer\Exception\WriterAlreadyOpenedException;
+use Box\Spout\Writer\Exception\WriterNotOpenedException;
+use Box\Spout\Writer\Style\StyleBuilder;
+
+/**
+ * Class AbstractWriter
+ *
+ * @package Box\Spout\Writer
+ * @abstract
+ */
+abstract class AbstractWriter implements WriterInterface
+{
+    /** @var string Path to the output file */
+    protected $outputFilePath;
+
+    /** @var resource Pointer to the file/stream we will write to */
+    protected $filePointer;
+
+    /** @var bool Indicates whether the writer has been opened or not */
+    protected $isWriterOpened = false;
+
+    /** @var \Box\Spout\Common\Helper\GlobalFunctionsHelper Helper to work with global functions */
+    protected $globalFunctionsHelper;
+
+    /** @var Style\Style Style to be applied to the next written row(s) */
+    protected $rowStyle;
+
+    /** @var Style\Style Default row style. Each writer can have its own default style */
+    protected $defaultRowStyle;
+
+    /** @var string Content-Type value for the header - to be defined by child class */
+    protected static $headerContentType;
+
+    /**
+     * Opens the streamer and makes it ready to accept data.
+     *
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If the writer cannot be opened
+     */
+    abstract protected function openWriter();
+
+    /**
+     * Adds data to the currently openned writer.
+     *
+     * @param  array $dataRow Array containing data to be streamed.
+     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
+     * @param Style\Style $style Style to be applied to the written row
+     * @return void
+     */
+    abstract protected function addRowToWriter(array $dataRow, $style);
+
+    /**
+     * Closes the streamer, preventing any additional writing.
+     *
+     * @return void
+     */
+    abstract protected function closeWriter();
+
+    /**
+     *
+     */
+    public function __construct()
+    {
+        $this->defaultRowStyle = $this->getDefaultRowStyle();
+        $this->resetRowStyleToDefault();
+    }
+
+    /**
+     * Sets the default styles for all rows added with "addRow".
+     * Overriding the default style instead of using "addRowWithStyle" improves performance by 20%.
+     * @see https://github.com/box/spout/issues/272
+     *
+     * @param Style\Style $defaultStyle
+     * @return AbstractWriter
+     */
+    public function setDefaultRowStyle($defaultStyle)
+    {
+        $this->defaultRowStyle = $defaultStyle;
+        $this->resetRowStyleToDefault();
+        return $this;
+    }
+
+    /**
+     * @param \Box\Spout\Common\Helper\GlobalFunctionsHelper $globalFunctionsHelper
+     * @return AbstractWriter
+     */
+    public function setGlobalFunctionsHelper($globalFunctionsHelper)
+    {
+        $this->globalFunctionsHelper = $globalFunctionsHelper;
+        return $this;
+    }
+
+    /**
+     * Inits the writer and opens it to accept data.
+     * By using this method, the data will be written to a file.
+     *
+     * @api
+     * @param  string $outputFilePath Path of the output file that will contain the data
+     * @return AbstractWriter
+     * @throws \Box\Spout\Common\Exception\IOException If the writer cannot be opened or if the given path is not writable
+     */
+    public function openToFile($outputFilePath)
+    {
+        $this->outputFilePath = $outputFilePath;
+
+        $this->filePointer = $this->globalFunctionsHelper->fopen($this->outputFilePath, 'wb+');
+        $this->throwIfFilePointerIsNotAvailable();
+
+        $this->openWriter();
+        $this->isWriterOpened = true;
+
+        return $this;
+    }
+
+    /**
+     * Inits the writer and opens it to accept data.
+     * By using this method, the data will be outputted directly to the browser.
+     *
+     * @codeCoverageIgnore
+     *
+     * @api
+     * @param  string $outputFileName Name of the output file that will contain the data. If a path is passed in, only the file name will be kept
+     * @return AbstractWriter
+     * @throws \Box\Spout\Common\Exception\IOException If the writer cannot be opened
+     */
+    public function openToBrowser($outputFileName)
+    {
+        $this->outputFilePath = $this->globalFunctionsHelper->basename($outputFileName);
+
+        $this->filePointer = $this->globalFunctionsHelper->fopen('php://output', 'w');
+        $this->throwIfFilePointerIsNotAvailable();
+
+        // Clear any previous output (otherwise the generated file will be corrupted)
+        // @see https://github.com/box/spout/issues/241
+        $this->globalFunctionsHelper->ob_end_clean();
+
+        // Set headers
+        $this->globalFunctionsHelper->header('Content-Type: ' . static::$headerContentType);
+        $this->globalFunctionsHelper->header('Content-Disposition: attachment; filename="' . $this->outputFilePath . '"');
+
+        /*
+         * When forcing the download of a file over SSL,IE8 and lower browsers fail
+         * if the Cache-Control and Pragma headers are not set.
+         *
+         * @see http://support.microsoft.com/KB/323308
+         * @see https://github.com/liuggio/ExcelBundle/issues/45
+         */
+        $this->globalFunctionsHelper->header('Cache-Control: max-age=0');
+        $this->globalFunctionsHelper->header('Pragma: public');
+
+        $this->openWriter();
+        $this->isWriterOpened = true;
+
+        return $this;
+    }
+
+    /**
+     * Checks if the pointer to the file/stream to write to is available.
+     * Will throw an exception if not available.
+     *
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If the pointer is not available
+     */
+    protected function throwIfFilePointerIsNotAvailable()
+    {
+        if (!$this->filePointer) {
+            throw new IOException('File pointer has not be opened');
+        }
+    }
+
+    /**
+     * Checks if the writer has already been opened, since some actions must be done before it gets opened.
+     * Throws an exception if already opened.
+     *
+     * @param string $message Error message
+     * @return void
+     * @throws \Box\Spout\Writer\Exception\WriterAlreadyOpenedException If the writer was already opened and must not be.
+     */
+    protected function throwIfWriterAlreadyOpened($message)
+    {
+        if ($this->isWriterOpened) {
+            throw new WriterAlreadyOpenedException($message);
+        }
+    }
+
+    /**
+     * Write given data to the output. New data will be appended to end of stream.
+     *
+     * @param  array $dataRow Array containing data to be streamed.
+     *                        If empty, no data is added (i.e. not even as a blank row)
+     *                        Example: $dataRow = ['data1', 1234, null, '', 'data5', false];
+     * @api
+     * @return AbstractWriter
+     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If this function is called before opening the writer
+     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
+     * @throws \Box\Spout\Common\Exception\SpoutException If anything else goes wrong while writing data
+     */
+    public function addRow(array $dataRow)
+    {
+        if ($this->isWriterOpened) {
+            // empty $dataRow should not add an empty line
+            if (!empty($dataRow)) {
+                try {
+                    $this->addRowToWriter($dataRow, $this->rowStyle);
+                } catch (SpoutException $e) {
+                    // if an exception occurs while writing data,
+                    // close the writer and remove all files created so far.
+                    $this->closeAndAttemptToCleanupAllFiles();
+
+                    // re-throw the exception to alert developers of the error
+                    throw $e;
+                }
+            }
+        } else {
+            throw new WriterNotOpenedException('The writer needs to be opened before adding row.');
+        }
+
+        return $this;
+    }
+
+    /**
+     * Write given data to the output and apply the given style.
+     * @see addRow
+     *
+     * @api
+     * @param array $dataRow Array of array containing data to be streamed.
+     * @param Style\Style $style Style to be applied to the row.
+     * @return AbstractWriter
+     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If the input param is not valid
+     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If this function is called before opening the writer
+     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
+     */
+    public function addRowWithStyle(array $dataRow, $style)
+    {
+        if (!$style instanceof Style\Style) {
+            throw new InvalidArgumentException('The "$style" argument must be a Style instance and cannot be NULL.');
+        }
+
+        $this->setRowStyle($style);
+        $this->addRow($dataRow);
+        $this->resetRowStyleToDefault();
+
+        return $this;
+    }
+
+    /**
+     * Write given data to the output. New data will be appended to end of stream.
+     *
+     * @api
+     * @param  array $dataRows Array of array containing data to be streamed.
+     *                         If a row is empty, it won't be added (i.e. not even as a blank row)
+     *                         Example: $dataRows = [
+     *                             ['data11', 12, , '', 'data13'],
+     *                             ['data21', 'data22', null, false],
+     *                         ];
+     * @return AbstractWriter
+     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If the input param is not valid
+     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If this function is called before opening the writer
+     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
+     */
+    public function addRows(array $dataRows)
+    {
+        if (!empty($dataRows)) {
+            $firstRow = reset($dataRows);
+            if (!is_array($firstRow)) {
+                throw new InvalidArgumentException('The input should be an array of arrays');
+            }
+
+            foreach ($dataRows as $dataRow) {
+                $this->addRow($dataRow);
+            }
+        }
+
+        return $this;
+    }
+
+    /**
+     * Write given data to the output and apply the given style.
+     * @see addRows
+     *
+     * @api
+     * @param array $dataRows Array of array containing data to be streamed.
+     * @param Style\Style $style Style to be applied to the rows.
+     * @return AbstractWriter
+     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If the input param is not valid
+     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If this function is called before opening the writer
+     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
+     */
+    public function addRowsWithStyle(array $dataRows, $style)
+    {
+        if (!$style instanceof Style\Style) {
+            throw new InvalidArgumentException('The "$style" argument must be a Style instance and cannot be NULL.');
+        }
+
+        $this->setRowStyle($style);
+        $this->addRows($dataRows);
+        $this->resetRowStyleToDefault();
+
+        return $this;
+    }
+
+    /**
+     * Returns the default style to be applied to rows.
+     * Can be overriden by children to have a custom style.
+     *
+     * @return Style\Style
+     */
+    protected function getDefaultRowStyle()
+    {
+        return (new StyleBuilder())->build();
+    }
+
+    /**
+     * Sets the style to be applied to the next written rows
+     * until it is changed or reset.
+     *
+     * @param Style\Style $style
+     * @return void
+     */
+    private function setRowStyle($style)
+    {
+        // Merge given style with the default one to inherit custom properties
+        $this->rowStyle = $style->mergeWith($this->defaultRowStyle);
+    }
+
+    /**
+     * Resets the style to be applied to the next written rows.
+     *
+     * @return void
+     */
+    private function resetRowStyleToDefault()
+    {
+        $this->rowStyle = $this->defaultRowStyle;
+    }
+
+    /**
+     * Closes the writer. This will close the streamer as well, preventing new data
+     * to be written to the file.
+     *
+     * @api
+     * @return void
+     */
+    public function close()
+    {
+        if (!$this->isWriterOpened) {
+            return;
+        }
+
+        $this->closeWriter();
+
+        if (is_resource($this->filePointer)) {
+            $this->globalFunctionsHelper->fclose($this->filePointer);
+        }
+
+        $this->isWriterOpened = false;
+    }
+
+    /**
+     * Closes the writer and attempts to cleanup all files that were
+     * created during the writing process (temp files & final file).
+     *
+     * @return void
+     */
+    private function closeAndAttemptToCleanupAllFiles()
+    {
+        // close the writer, which should remove all temp files
+        $this->close();
+
+        // remove output file if it was created
+        if ($this->globalFunctionsHelper->file_exists($this->outputFilePath)) {
+            $outputFolderPath = dirname($this->outputFilePath);
+            $fileSystemHelper = new FileSystemHelper($outputFolderPath);
+            $fileSystemHelper->deleteFile($this->outputFilePath);
+        }
+    }
+}

modules/x13import/tools/Spout/Writer/CSV/Writer.php

@@ -0,0 +1,118 @@
+<?php
+
+namespace Box\Spout\Writer\CSV;
+
+use Box\Spout\Writer\AbstractWriter;
+use Box\Spout\Common\Exception\IOException;
+use Box\Spout\Common\Helper\EncodingHelper;
+
+/**
+ * Class Writer
+ * This class provides support to write data to CSV files
+ *
+ * @package Box\Spout\Writer\CSV
+ */
+class Writer extends AbstractWriter
+{
+    /** Number of rows to write before flushing */
+    const FLUSH_THRESHOLD = 500;
+
+    /** @var string Content-Type value for the header */
+    protected static $headerContentType = 'text/csv; charset=UTF-8';
+
+    /** @var string Defines the character used to delimit fields (one character only) */
+    protected $fieldDelimiter = ',';
+
+    /** @var string Defines the character used to enclose fields (one character only) */
+    protected $fieldEnclosure = '"';
+
+    /** @var int */
+    protected $lastWrittenRowIndex = 0;
+
+    /** @var bool */
+    protected $shouldAddBOM = true;
+
+    /**
+     * Sets the field delimiter for the CSV
+     *
+     * @api
+     * @param string $fieldDelimiter Character that delimits fields
+     * @return Writer
+     */
+    public function setFieldDelimiter($fieldDelimiter)
+    {
+        $this->fieldDelimiter = $fieldDelimiter;
+        return $this;
+    }
+
+    /**
+     * Sets the field enclosure for the CSV
+     *
+     * @api
+     * @param string $fieldEnclosure Character that enclose fields
+     * @return Writer
+     */
+    public function setFieldEnclosure($fieldEnclosure)
+    {
+        $this->fieldEnclosure = $fieldEnclosure;
+        return $this;
+    }
+
+    /**
+     * Set if a BOM has to be added to the file
+     *
+     * @param bool $shouldAddBOM
+     * @return Writer
+     */
+    public function setShouldAddBOM($shouldAddBOM)
+    {
+        $this->shouldAddBOM = (bool) $shouldAddBOM;
+        return $this;
+    }
+
+    /**
+     * Opens the CSV streamer and makes it ready to accept data.
+     *
+     * @return void
+     */
+    protected function openWriter()
+    {
+        if ($this->shouldAddBOM) {
+            // Adds UTF-8 BOM for Unicode compatibility
+            $this->globalFunctionsHelper->fputs($this->filePointer, EncodingHelper::BOM_UTF8);
+        }
+    }
+
+    /**
+     * Adds data to the currently opened writer.
+     *
+     * @param  array $dataRow Array containing data to be written.
+     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
+     * @param \Box\Spout\Writer\Style\Style $style Ignored here since CSV does not support styling.
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
+     */
+    protected function addRowToWriter(array $dataRow, $style)
+    {
+        $wasWriteSuccessful = $this->globalFunctionsHelper->fputcsv($this->filePointer, $dataRow, $this->fieldDelimiter, $this->fieldEnclosure);
+        if ($wasWriteSuccessful === false) {
+            throw new IOException('Unable to write data');
+        }
+
+        $this->lastWrittenRowIndex++;
+        if ($this->lastWrittenRowIndex % self::FLUSH_THRESHOLD === 0) {
+            $this->globalFunctionsHelper->fflush($this->filePointer);
+        }
+    }
+
+    /**
+     * Closes the CSV streamer, preventing any additional writing.
+     * If set, sets the headers and redirects output to the browser.
+     *
+     * @return void
+     */
+    protected function closeWriter()
+    {
+        $this->lastWrittenRowIndex = 0;
+    }
+}

modules/x13import/tools/Spout/Writer/Common/Helper/AbstractStyleHelper.php

@@ -0,0 +1,138 @@
+<?php
+
+namespace Box\Spout\Writer\Common\Helper;
+
+/**
+ * Class AbstractStyleHelper
+ * This class provides helper functions to manage styles
+ *
+ * @package Box\Spout\Writer\Common\Helper
+ */
+abstract class AbstractStyleHelper
+{
+    /** @var array [SERIALIZED_STYLE] => [STYLE_ID] mapping table, keeping track of the registered styles */
+    protected $serializedStyleToStyleIdMappingTable = [];
+
+    /** @var array [STYLE_ID] => [STYLE] mapping table, keeping track of the registered styles */
+    protected $styleIdToStyleMappingTable = [];
+
+    /**
+     * @param \Box\Spout\Writer\Style\Style $defaultStyle
+     */
+    public function __construct($defaultStyle)
+    {
+        // This ensures that the default style is the first one to be registered
+        $this->registerStyle($defaultStyle);
+    }
+
+    /**
+     * Registers the given style as a used style.
+     * Duplicate styles won't be registered more than once.
+     *
+     * @param \Box\Spout\Writer\Style\Style $style The style to be registered
+     * @return \Box\Spout\Writer\Style\Style The registered style, updated with an internal ID.
+     */
+    public function registerStyle($style)
+    {
+        $serializedStyle = $style->serialize();
+
+        if (!$this->hasStyleAlreadyBeenRegistered($style)) {
+            $nextStyleId = count($this->serializedStyleToStyleIdMappingTable);
+            $style->setId($nextStyleId);
+
+            $this->serializedStyleToStyleIdMappingTable[$serializedStyle] = $nextStyleId;
+            $this->styleIdToStyleMappingTable[$nextStyleId] = $style;
+        }
+
+        return $this->getStyleFromSerializedStyle($serializedStyle);
+    }
+
+    /**
+     * Returns whether the given style has already been registered.
+     *
+     * @param \Box\Spout\Writer\Style\Style $style
+     * @return bool
+     */
+    protected function hasStyleAlreadyBeenRegistered($style)
+    {
+        $serializedStyle = $style->serialize();
+
+        // Using isset here because it is way faster than array_key_exists...
+        return isset($this->serializedStyleToStyleIdMappingTable[$serializedStyle]);
+    }
+
+    /**
+     * Returns the registered style associated to the given serialization.
+     *
+     * @param string $serializedStyle The serialized style from which the actual style should be fetched from
+     * @return \Box\Spout\Writer\Style\Style
+     */
+    protected function getStyleFromSerializedStyle($serializedStyle)
+    {
+        $styleId = $this->serializedStyleToStyleIdMappingTable[$serializedStyle];
+        return $this->styleIdToStyleMappingTable[$styleId];
+    }
+
+    /**
+     * @return \Box\Spout\Writer\Style\Style[] List of registered styles
+     */
+    protected function getRegisteredStyles()
+    {
+        return array_values($this->styleIdToStyleMappingTable);
+    }
+
+    /**
+     * Returns the default style
+     *
+     * @return \Box\Spout\Writer\Style\Style Default style
+     */
+    protected function getDefaultStyle()
+    {
+        // By construction, the default style has ID 0
+        return $this->styleIdToStyleMappingTable[0];
+    }
+
+    /**
+     * Apply additional styles if the given row needs it.
+     * Typically, set "wrap text" if a cell contains a new line.
+     *
+     * @param \Box\Spout\Writer\Style\Style $style The original style
+     * @param array $dataRow The row the style will be applied to
+     * @return \Box\Spout\Writer\Style\Style The updated style
+     */
+    public function applyExtraStylesIfNeeded($style, $dataRow)
+    {
+        $updatedStyle = $this->applyWrapTextIfCellContainsNewLine($style, $dataRow);
+        return $updatedStyle;
+    }
+
+    /**
+     * Set the "wrap text" option if a cell of the given row contains a new line.
+     *
+     * @NOTE: There is a bug on the Mac version of Excel (2011 and below) where new lines
+     *        are ignored even when the "wrap text" option is set. This only occurs with
+     *        inline strings (shared strings do work fine).
+     *        A workaround would be to encode "\n" as "_x000D_" but it does not work
+     *        on the Windows version of Excel...
+     *
+     * @param \Box\Spout\Writer\Style\Style $style The original style
+     * @param array $dataRow The row the style will be applied to
+     * @return \Box\Spout\Writer\Style\Style The eventually updated style
+     */
+    protected function applyWrapTextIfCellContainsNewLine($style, $dataRow)
+    {
+        // if the "wrap text" option is already set, no-op
+        if ($style->hasSetWrapText()) {
+            return $style;
+        }
+
+        foreach ($dataRow as $cell) {
+            if (is_string($cell) && strpos($cell, "\n") !== false) {
+                $style->setShouldWrapText();
+                break;
+            }
+        }
+
+        return $style;
+    }
+}

modules/x13import/tools/Spout/Writer/Common/Helper/CellHelper.php

@@ -0,0 +1,91 @@
+<?php
+
+namespace Box\Spout\Writer\Common\Helper;
+
+/**
+ * Class CellHelper
+ * This class provides helper functions when working with cells
+ *
+ * @package Box\Spout\Writer\Common\Helper
+ */
+class CellHelper
+{
+    /** @var array Cache containing the mapping column index => cell index */
+    private static $columnIndexToCellIndexCache = [];
+
+    /**
+     * Returns the cell index (base 26) associated to the base 10 column index.
+     * Excel uses A to Z letters for column indexing, where A is the 1st column,
+     * Z is the 26th and AA is the 27th.
+     * The mapping is zero based, so that 0 maps to A, B maps to 1, Z to 25 and AA to 26.
+     *
+     * @param int $columnIndex The Excel column index (0, 42, ...)
+     * @return string The associated cell index ('A', 'BC', ...)
+     */
+    public static function getCellIndexFromColumnIndex($columnIndex)
+    {
+        $originalColumnIndex = $columnIndex;
+
+        // Using isset here because it is way faster than array_key_exists...
+        if (!isset(self::$columnIndexToCellIndexCache[$originalColumnIndex])) {
+            $cellIndex = '';
+            $capitalAAsciiValue = ord('A');
+
+            do {
+                $modulus = $columnIndex % 26;
+                $cellIndex = chr($capitalAAsciiValue + $modulus) . $cellIndex;
+
+                // substracting 1 because it's zero-based
+                $columnIndex = intval($columnIndex / 26) - 1;
+
+            } while ($columnIndex >= 0);
+
+            self::$columnIndexToCellIndexCache[$originalColumnIndex] = $cellIndex;
+        }
+
+        return self::$columnIndexToCellIndexCache[$originalColumnIndex];
+    }
+
+    /**
+     * @param $value
+     * @return bool Whether the given value is considered "empty"
+     */
+    public static function isEmpty($value)
+    {
+        return ($value === null || $value === '');
+    }
+
+    /**
+     * @param $value
+     * @return bool Whether the given value is a non empty string
+     */
+    public static function isNonEmptyString($value)
+    {
+        return (gettype($value) === 'string' && $value !== '');
+    }
+
+    /**
+     * Returns whether the given value is numeric.
+     * A numeric value is from type "integer" or "double" ("float" is not returned by gettype).
+     *
+     * @param $value
+     * @return bool Whether the given value is numeric
+     */
+    public static function isNumeric($value)
+    {
+        $valueType = gettype($value);
+        return ($valueType === 'integer' || $valueType === 'double');
+    }
+
+    /**
+     * Returns whether the given value is boolean.
+     * "true"/"false" and 0/1 are not booleans.
+     *
+     * @param $value
+     * @return bool Whether the given value is boolean
+     */
+    public static function isBoolean($value)
+    {
+        return gettype($value) === 'boolean';
+    }
+}

modules/x13import/tools/Spout/Writer/Common/Helper/ZipHelper.php

@@ -0,0 +1,217 @@
+<?php
+
+namespace Box\Spout\Writer\Common\Helper;
+
+/**
+ * Class ZipHelper
+ * This class provides helper functions to create zip files
+ *
+ * @package Box\Spout\Writer\Common\Helper
+ */
+class ZipHelper
+{
+    const ZIP_EXTENSION = '.zip';
+
+    /** Controls what to do when trying to add an existing file */
+    const EXISTING_FILES_SKIP = 'skip';
+    const EXISTING_FILES_OVERWRITE = 'overwrite';
+
+    /** @var string Path of the folder where the zip file will be created */
+    protected $tmpFolderPath;
+
+    /** @var \ZipArchive The ZipArchive instance */
+    protected $zip;
+
+    /**
+     * @param string $tmpFolderPath Path of the temp folder where the zip file will be created
+     */
+    public function __construct($tmpFolderPath)
+    {
+        $this->tmpFolderPath = $tmpFolderPath;
+    }
+
+    /**
+     * Returns the already created ZipArchive instance or
+     * creates one if none exists.
+     *
+     * @return \ZipArchive
+     */
+    protected function createOrGetZip()
+    {
+        if (!isset($this->zip)) {
+            $this->zip = new \ZipArchive();
+            $zipFilePath = $this->getZipFilePath();
+
+            $this->zip->open($zipFilePath, \ZipArchive::CREATE|\ZipArchive::OVERWRITE);
+        }
+
+        return $this->zip;
+    }
+
+    /**
+     * @return string Path where the zip file of the given folder will be created
+     */
+    public function getZipFilePath()
+    {
+        return $this->tmpFolderPath . self::ZIP_EXTENSION;
+    }
+
+    /**
+     * Adds the given file, located under the given root folder to the archive.
+     * The file will be compressed.
+     *
+     * Example of use:
+     *   addFileToArchive('/tmp/xlsx/foo', 'bar/baz.xml');
+     *   => will add the file located at '/tmp/xlsx/foo/bar/baz.xml' in the archive, but only as 'bar/baz.xml'
+     *
+     * @param string $rootFolderPath Path of the root folder that will be ignored in the archive tree.
+     * @param string $localFilePath Path of the file to be added, under the root folder
+     * @param string|void $existingFileMode Controls what to do when trying to add an existing file
+     * @return void
+     */
+    public function addFileToArchive($rootFolderPath, $localFilePath, $existingFileMode = self::EXISTING_FILES_OVERWRITE)
+    {
+        $this->addFileToArchiveWithCompressionMethod(
+            $rootFolderPath,
+            $localFilePath,
+            $existingFileMode,
+            \ZipArchive::CM_DEFAULT
+        );
+    }
+
+    /**
+     * Adds the given file, located under the given root folder to the archive.
+     * The file will NOT be compressed.
+     *
+     * Example of use:
+     *   addUncompressedFileToArchive('/tmp/xlsx/foo', 'bar/baz.xml');
+     *   => will add the file located at '/tmp/xlsx/foo/bar/baz.xml' in the archive, but only as 'bar/baz.xml'
+     *
+     * @param string $rootFolderPath Path of the root folder that will be ignored in the archive tree.
+     * @param string $localFilePath Path of the file to be added, under the root folder
+     * @param string|void $existingFileMode Controls what to do when trying to add an existing file
+     * @return void
+     */
+    public function addUncompressedFileToArchive($rootFolderPath, $localFilePath, $existingFileMode = self::EXISTING_FILES_OVERWRITE)
+    {
+        $this->addFileToArchiveWithCompressionMethod(
+            $rootFolderPath,
+            $localFilePath,
+            $existingFileMode,
+            \ZipArchive::CM_STORE
+        );
+    }
+
+    /**
+     * Adds the given file, located under the given root folder to the archive.
+     * The file will NOT be compressed.
+     *
+     * Example of use:
+     *   addUncompressedFileToArchive('/tmp/xlsx/foo', 'bar/baz.xml');
+     *   => will add the file located at '/tmp/xlsx/foo/bar/baz.xml' in the archive, but only as 'bar/baz.xml'
+     *
+     * @param string $rootFolderPath Path of the root folder that will be ignored in the archive tree.
+     * @param string $localFilePath Path of the file to be added, under the root folder
+     * @param string $existingFileMode Controls what to do when trying to add an existing file
+     * @param int $compressionMethod The compression method
+     * @return void
+     */
+    protected function addFileToArchiveWithCompressionMethod($rootFolderPath, $localFilePath, $existingFileMode, $compressionMethod)
+    {
+        $zip = $this->createOrGetZip();
+
+        if (!$this->shouldSkipFile($zip, $localFilePath, $existingFileMode)) {
+            $normalizedFullFilePath = $this->getNormalizedRealPath($rootFolderPath . '/' . $localFilePath);
+            $zip->addFile($normalizedFullFilePath, $localFilePath);
+
+            if (self::canChooseCompressionMethod()) {
+                $zip->setCompressionName($localFilePath, $compressionMethod);
+            }
+        }
+    }
+
+    /**
+     * @return bool Whether it is possible to choose the desired compression method to be used
+     */
+    public static function canChooseCompressionMethod()
+    {
+        // setCompressionName() is a PHP7+ method...
+        return (method_exists(new \ZipArchive(), 'setCompressionName'));
+    }
+
+    /**
+     * @param string $folderPath Path to the folder to be zipped
+     * @param string|void $existingFileMode Controls what to do when trying to add an existing file
+     * @return void
+     */
+    public function addFolderToArchive($folderPath, $existingFileMode = self::EXISTING_FILES_OVERWRITE)
+    {
+        $zip = $this->createOrGetZip();
+
+        $folderRealPath = $this->getNormalizedRealPath($folderPath) . '/';
+        $itemIterator = new \RecursiveIteratorIterator(new \RecursiveDirectoryIterator($folderPath, \RecursiveDirectoryIterator::SKIP_DOTS), \RecursiveIteratorIterator::SELF_FIRST);
+
+        foreach ($itemIterator as $itemInfo) {
+            $itemRealPath = $this->getNormalizedRealPath($itemInfo->getPathname());
+            $itemLocalPath = str_replace($folderRealPath, '', $itemRealPath);
+
+            if ($itemInfo->isFile() && !$this->shouldSkipFile($zip, $itemLocalPath, $existingFileMode)) {
+                $zip->addFile($itemRealPath, $itemLocalPath);
+            }
+        }
+    }
+
+    /**
+     * @param \ZipArchive $zip
+     * @param string $itemLocalPath
+     * @param string $existingFileMode
+     * @return bool Whether the file should be added to the archive or skipped
+     */
+    protected function shouldSkipFile($zip, $itemLocalPath, $existingFileMode)
+    {
+        // Skip files if:
+        //   - EXISTING_FILES_SKIP mode chosen
+        //   - File already exists in the archive
+        return ($existingFileMode === self::EXISTING_FILES_SKIP && $zip->locateName($itemLocalPath) !== false);
+    }
+
+    /**
+     * Returns canonicalized absolute pathname, containing only forward slashes.
+     *
+     * @param string $path Path to normalize
+     * @return string Normalized and canonicalized path
+     */
+    protected function getNormalizedRealPath($path)
+    {
+        $realPath = realpath($path);
+        return str_replace(DIRECTORY_SEPARATOR, '/', $realPath);
+    }
+
+    /**
+     * Closes the archive and copies it into the given stream
+     *
+     * @param resource $streamPointer Pointer to the stream to copy the zip
+     * @return void
+     */
+    public function closeArchiveAndCopyToStream($streamPointer)
+    {
+        $zip = $this->createOrGetZip();
+        $zip->close();
+        unset($this->zip);
+
+        $this->copyZipToStream($streamPointer);
+    }
+
+    /**
+     * Streams the contents of the zip file into the given stream
+     *
+     * @param resource $pointer Pointer to the stream to copy the zip
+     * @return void
+     */
+    protected function copyZipToStream($pointer)
+    {
+        $zipFilePointer = fopen($this->getZipFilePath(), 'r');
+        stream_copy_to_stream($zipFilePointer, $pointer);
+        fclose($zipFilePointer);
+    }
+}

modules/x13import/tools/Spout/Writer/Common/Internal/AbstractWorkbook.php

@@ -0,0 +1,192 @@
+<?php
+
+namespace Box\Spout\Writer\Common\Internal;
+
+use Box\Spout\Writer\Exception\SheetNotFoundException;
+
+/**
+ * Class Workbook
+ * Represents a workbook within a spreadsheet file.
+ * It provides the functions to work with worksheets.
+ *
+ * @package Box\Spout\Writer\Common
+ */
+abstract class AbstractWorkbook implements WorkbookInterface
+{
+    /** @var bool Whether new sheets should be automatically created when the max rows limit per sheet is reached */
+    protected $shouldCreateNewSheetsAutomatically;
+
+    /** @var string Timestamp based unique ID identifying the workbook */
+    protected $internalId;
+
+    /** @var WorksheetInterface[] Array containing the workbook's sheets */
+    protected $worksheets = [];
+
+    /** @var WorksheetInterface The worksheet where data will be written to */
+    protected $currentWorksheet;
+
+    /**
+     * @param bool $shouldCreateNewSheetsAutomatically
+     * @param \Box\Spout\Writer\Style\Style $defaultRowStyle
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create at least one of the base folders
+     */
+    public function __construct($shouldCreateNewSheetsAutomatically, $defaultRowStyle)
+    {
+        $this->shouldCreateNewSheetsAutomatically = $shouldCreateNewSheetsAutomatically;
+        $this->internalId = uniqid();
+    }
+
+    /**
+     * @return \Box\Spout\Writer\Common\Helper\AbstractStyleHelper The specific style helper
+     */
+    abstract protected function getStyleHelper();
+
+    /**
+     * @return int Maximum number of rows/columns a sheet can contain
+     */
+    abstract protected function getMaxRowsPerWorksheet();
+
+    /**
+     * Creates a new sheet in the workbook. The current sheet remains unchanged.
+     *
+     * @return WorksheetInterface The created sheet
+     * @throws \Box\Spout\Common\Exception\IOException If unable to open the sheet for writing
+     */
+    abstract public function addNewSheet();
+
+    /**
+     * Creates a new sheet in the workbook and make it the current sheet.
+     * The writing will resume where it stopped (i.e. data won't be truncated).
+     *
+     * @return WorksheetInterface The created sheet
+     * @throws \Box\Spout\Common\Exception\IOException If unable to open the sheet for writing
+     */
+    public function addNewSheetAndMakeItCurrent()
+    {
+        $worksheet = $this->addNewSheet();
+        $this->setCurrentWorksheet($worksheet);
+
+        return $worksheet;
+    }
+
+    /**
+     * @return WorksheetInterface[] All the workbook's sheets
+     */
+    public function getWorksheets()
+    {
+        return $this->worksheets;
+    }
+
+    /**
+     * Returns the current sheet
+     *
+     * @return WorksheetInterface The current sheet
+     */
+    public function getCurrentWorksheet()
+    {
+        return $this->currentWorksheet;
+    }
+
+    /**
+     * Sets the given sheet as the current one. New data will be written to this sheet.
+     * The writing will resume where it stopped (i.e. data won't be truncated).
+     *
+     * @param \Box\Spout\Writer\Common\Sheet $sheet The "external" sheet to set as current
+     * @return void
+     * @throws \Box\Spout\Writer\Exception\SheetNotFoundException If the given sheet does not exist in the workbook
+     */
+    public function setCurrentSheet($sheet)
+    {
+        $worksheet = $this->getWorksheetFromExternalSheet($sheet);
+        if ($worksheet !== null) {
+            $this->currentWorksheet = $worksheet;
+        } else {
+            throw new SheetNotFoundException('The given sheet does not exist in the workbook.');
+        }
+    }
+
+    /**
+     * @param WorksheetInterface $worksheet
+     * @return void
+     */
+    protected function setCurrentWorksheet($worksheet)
+    {
+        $this->currentWorksheet = $worksheet;
+    }
+
+    /**
+     * Returns the worksheet associated to the given external sheet.
+     *
+     * @param \Box\Spout\Writer\Common\Sheet $sheet
+     * @return WorksheetInterface|null The worksheet associated to the given external sheet or null if not found.
+     */
+    protected function getWorksheetFromExternalSheet($sheet)
+    {
+        $worksheetFound = null;
+
+        foreach ($this->worksheets as $worksheet) {
+            if ($worksheet->getExternalSheet() === $sheet) {
+                $worksheetFound = $worksheet;
+                break;
+            }
+        }
+
+        return $worksheetFound;
+    }
+
+    /**
+     * Adds data to the current sheet.
+     * If shouldCreateNewSheetsAutomatically option is set to true, it will handle pagination
+     * with the creation of new worksheets if one worksheet has reached its maximum capicity.
+     *
+     * @param array $dataRow Array containing data to be written. Cannot be empty.
+     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
+     * @param \Box\Spout\Writer\Style\Style $style Style to be applied to the row.
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If trying to create a new sheet and unable to open the sheet for writing
+     * @throws \Box\Spout\Writer\Exception\WriterException If unable to write data
+     */
+    public function addRowToCurrentWorksheet($dataRow, $style)
+    {
+        $currentWorksheet = $this->getCurrentWorksheet();
+        $hasReachedMaxRows = $this->hasCurrentWorkseetReachedMaxRows();
+        $styleHelper = $this->getStyleHelper();
+
+        // if we reached the maximum number of rows for the current sheet...
+        if ($hasReachedMaxRows) {
+            // ... continue writing in a new sheet if option set
+            if ($this->shouldCreateNewSheetsAutomatically) {
+                $currentWorksheet = $this->addNewSheetAndMakeItCurrent();
+
+                $updatedStyle = $styleHelper->applyExtraStylesIfNeeded($style, $dataRow);
+                $registeredStyle = $styleHelper->registerStyle($updatedStyle);
+                $currentWorksheet->addRow($dataRow, $registeredStyle);
+            } else {
+                // otherwise, do nothing as the data won't be read anyways
+            }
+        } else {
+            $updatedStyle = $styleHelper->applyExtraStylesIfNeeded($style, $dataRow);
+            $registeredStyle = $styleHelper->registerStyle($updatedStyle);
+            $currentWorksheet->addRow($dataRow, $registeredStyle);
+        }
+    }
+
+    /**
+     * @return bool Whether the current worksheet has reached the maximum number of rows per sheet.
+     */
+    protected function hasCurrentWorkseetReachedMaxRows()
+    {
+        $currentWorksheet = $this->getCurrentWorksheet();
+        return ($currentWorksheet->getLastWrittenRowIndex() >= $this->getMaxRowsPerWorksheet());
+    }
+
+    /**
+     * Closes the workbook and all its associated sheets.
+     * All the necessary files are written to disk and zipped together to create the ODS file.
+     * All the temporary files are then deleted.
+     *
+     * @param resource $finalFilePointer Pointer to the ODS that will be created
+     * @return void
+     */
+    abstract public function close($finalFilePointer);
+}

modules/x13import/tools/Spout/Writer/Common/Internal/WorkbookInterface.php

@@ -0,0 +1,74 @@
+<?php
+
+namespace Box\Spout\Writer\Common\Internal;
+
+/**
+ * Interface WorkbookInterface
+ *
+ * @package Box\Spout\Writer\Common\Internal
+ */
+interface WorkbookInterface
+{
+    /**
+     * Creates a new sheet in the workbook. The current sheet remains unchanged.
+     *
+     * @return WorksheetInterface The created sheet
+     * @throws \Box\Spout\Common\Exception\IOException If unable to open the sheet for writing
+     */
+    public function addNewSheet();
+
+    /**
+     * Creates a new sheet in the workbook and make it the current sheet.
+     * The writing will resume where it stopped (i.e. data won't be truncated).
+     *
+     * @return WorksheetInterface The created sheet
+     * @throws \Box\Spout\Common\Exception\IOException If unable to open the sheet for writing
+     */
+    public function addNewSheetAndMakeItCurrent();
+
+    /**
+     * @return WorksheetInterface[] All the workbook's sheets
+     */
+    public function getWorksheets();
+
+    /**
+     * Returns the current sheet
+     *
+     * @return WorksheetInterface The current sheet
+     */
+    public function getCurrentWorksheet();
+
+    /**
+     * Sets the given sheet as the current one. New data will be written to this sheet.
+     * The writing will resume where it stopped (i.e. data won't be truncated).
+     *
+     * @param \Box\Spout\Writer\Common\Sheet $sheet The "external" sheet to set as current
+     * @return void
+     * @throws \Box\Spout\Writer\Exception\SheetNotFoundException If the given sheet does not exist in the workbook
+     */
+    public function setCurrentSheet($sheet);
+
+    /**
+     * Adds data to the current sheet.
+     * If shouldCreateNewSheetsAutomatically option is set to true, it will handle pagination
+     * with the creation of new worksheets if one worksheet has reached its maximum capicity.
+     *
+     * @param array $dataRow Array containing data to be written.
+     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
+     * @param \Box\Spout\Writer\Style\Style $style Style to be applied to the row.
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If trying to create a new sheet and unable to open the sheet for writing
+     * @throws \Box\Spout\Writer\Exception\WriterException If unable to write data
+     */
+    public function addRowToCurrentWorksheet($dataRow, $style);
+
+    /**
+     * Closes the workbook and all its associated sheets.
+     * All the necessary files are written to disk and zipped together to create the ODS file.
+     * All the temporary files are then deleted.
+     *
+     * @param resource $finalFilePointer Pointer to the ODS that will be created
+     * @return void
+     */
+    public function close($finalFilePointer);
+}

modules/x13import/tools/Spout/Writer/Common/Internal/WorksheetInterface.php

@@ -0,0 +1,40 @@
+<?php
+
+namespace Box\Spout\Writer\Common\Internal;
+
+/**
+ * Interface WorksheetInterface
+ *
+ * @package Box\Spout\Writer\Common\Internal
+ */
+interface WorksheetInterface
+{
+    /**
+     * @return \Box\Spout\Writer\Common\Sheet The "external" sheet
+     */
+    public function getExternalSheet();
+
+    /**
+     * @return int The index of the last written row
+     */
+    public function getLastWrittenRowIndex();
+
+    /**
+     * Adds data to the worksheet.
+     *
+     * @param array $dataRow Array containing data to be written.
+     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
+     * @param \Box\Spout\Writer\Style\Style $style Style to be applied to the row. NULL means use default style.
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If the data cannot be written
+     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If a cell value's type is not supported
+     */
+    public function addRow($dataRow, $style);
+
+    /**
+     * Closes the worksheet
+     *
+     * @return void
+     */
+    public function close();
+}

modules/x13import/tools/Spout/Writer/Common/Sheet.php

@@ -0,0 +1,183 @@
+<?php
+
+namespace Box\Spout\Writer\Common;
+
+use Box\Spout\Common\Helper\StringHelper;
+use Box\Spout\Writer\Exception\InvalidSheetNameException;
+
+/**
+ * Class Sheet
+ * External representation of a worksheet
+ *
+ * @package Box\Spout\Writer\Common
+ */
+class Sheet
+{
+    const DEFAULT_SHEET_NAME_PREFIX = 'Sheet';
+
+    /** Sheet name should not exceed 31 characters */
+    const MAX_LENGTH_SHEET_NAME = 31;
+
+    /** @var array Invalid characters that cannot be contained in the sheet name */
+    private static $INVALID_CHARACTERS_IN_SHEET_NAME = ['\\', '/', '?', '*', ':', '[', ']'];
+
+    /** @var array Associative array [WORKBOOK_ID] => [[SHEET_INDEX] => [SHEET_NAME]] keeping track of sheets' name to enforce uniqueness per workbook */
+    protected static $SHEETS_NAME_USED = [];
+
+    /** @var int Index of the sheet, based on order in the workbook (zero-based) */
+    protected $index;
+
+    /** @var string ID of the sheet's associated workbook. Used to restrict sheet name uniqueness enforcement to a single workbook */
+    protected $associatedWorkbookId;
+
+    /** @var string Name of the sheet */
+    protected $name;
+
+    /** @var \Box\Spout\Common\Helper\StringHelper */
+    protected $stringHelper;
+
+    /**
+     * @param int $sheetIndex Index of the sheet, based on order in the workbook (zero-based)
+     * @param string $associatedWorkbookId ID of the sheet's associated workbook
+     */
+    public function __construct($sheetIndex, $associatedWorkbookId)
+    {
+        $this->index = $sheetIndex;
+        $this->associatedWorkbookId = $associatedWorkbookId;
+        if (!isset(self::$SHEETS_NAME_USED[$associatedWorkbookId])) {
+            self::$SHEETS_NAME_USED[$associatedWorkbookId] = [];
+        }
+
+        $this->stringHelper = new StringHelper();
+        $this->setName(self::DEFAULT_SHEET_NAME_PREFIX . ($sheetIndex + 1));
+    }
+
+    /**
+     * @api
+     * @return int Index of the sheet, based on order in the workbook (zero-based)
+     */
+    public function getIndex()
+    {
+        return $this->index;
+    }
+
+    /**
+     * @api
+     * @return string Name of the sheet
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * Sets the name of the sheet. Note that Excel has some restrictions on the name:
+     *  - it should not be blank
+     *  - it should not exceed 31 characters
+     *  - it should not contain these characters: \ / ? * : [ or ]
+     *  - it should be unique
+     *
+     * @api
+     * @param string $name Name of the sheet
+     * @return Sheet
+     * @throws \Box\Spout\Writer\Exception\InvalidSheetNameException If the sheet's name is invalid.
+     */
+    public function setName($name)
+    {
+        $this->throwIfNameIsInvalid($name);
+
+        $this->name = $name;
+        self::$SHEETS_NAME_USED[$this->associatedWorkbookId][$this->index] = $name;
+
+        return $this;
+    }
+
+    /**
+     * Throws an exception if the given sheet's name is not valid.
+     * @see Sheet::setName for validity rules.
+     *
+     * @param string $name
+     * @return void
+     * @throws \Box\Spout\Writer\Exception\InvalidSheetNameException If the sheet's name is invalid.
+     */
+    protected function throwIfNameIsInvalid($name)
+    {
+        if (!is_string($name)) {
+            $actualType = gettype($name);
+            $errorMessage = "The sheet's name is invalid. It must be a string ($actualType given).";
+            throw new InvalidSheetNameException($errorMessage);
+        }
+
+        $failedRequirements = [];
+        $nameLength = $this->stringHelper->getStringLength($name);
+
+        if (!$this->isNameUnique($name)) {
+            $failedRequirements[] = 'It should be unique';
+        } else {
+            if ($nameLength === 0) {
+                $failedRequirements[] = 'It should not be blank';
+            } else {
+                if ($nameLength > self::MAX_LENGTH_SHEET_NAME) {
+                    $failedRequirements[] = 'It should not exceed 31 characters';
+                }
+
+                if ($this->doesContainInvalidCharacters($name)) {
+                    $failedRequirements[] = 'It should not contain these characters: \\ / ? * : [ or ]';
+                }
+
+                if ($this->doesStartOrEndWithSingleQuote($name)) {
+                    $failedRequirements[] = 'It should not start or end with a single quote';
+                }
+            }
+        }
+
+        if (count($failedRequirements) !== 0) {
+            $errorMessage = "The sheet's name (\"$name\") is invalid. It did not respect these rules:\n - ";
+            $errorMessage .= implode("\n - ", $failedRequirements);
+            throw new InvalidSheetNameException($errorMessage);
+        }
+    }
+
+    /**
+     * Returns whether the given name contains at least one invalid character.
+     * @see Sheet::$INVALID_CHARACTERS_IN_SHEET_NAME for the full list.
+     *
+     * @param string $name
+     * @return bool TRUE if the name contains invalid characters, FALSE otherwise.
+     */
+    protected function doesContainInvalidCharacters($name)
+    {
+        return (str_replace(self::$INVALID_CHARACTERS_IN_SHEET_NAME, '', $name) !== $name);
+    }
+
+    /**
+     * Returns whether the given name starts or ends with a single quote
+     *
+     * @param string $name
+     * @return bool TRUE if the name starts or ends with a single quote, FALSE otherwise.
+     */
+    protected function doesStartOrEndWithSingleQuote($name)
+    {
+        $startsWithSingleQuote = ($this->stringHelper->getCharFirstOccurrencePosition('\'', $name) === 0);
+        $endsWithSingleQuote = ($this->stringHelper->getCharLastOccurrencePosition('\'', $name) === ($this->stringHelper->getStringLength($name) - 1));
+
+        return ($startsWithSingleQuote || $endsWithSingleQuote);
+    }
+
+    /**
+     * Returns whether the given name is unique.
+     *
+     * @param string $name
+     * @return bool TRUE if the name is unique, FALSE otherwise.
+     */
+    protected function isNameUnique($name)
+    {
+        foreach (self::$SHEETS_NAME_USED[$this->associatedWorkbookId] as $sheetIndex => $sheetName) {
+            if ($sheetIndex !== $this->index && $sheetName === $name) {
+                return false;
+            }
+        }
+
+        return true;
+    }
+}

modules/x13import/tools/Spout/Writer/Exception/Border/InvalidNameException.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Box\Spout\Writer\Exception\Border;
+
+use Box\Spout\Writer\Exception\WriterException;
+use Box\Spout\Writer\Style\BorderPart;
+
+class InvalidNameException extends WriterException
+{
+    public function __construct($name)
+    {
+        $msg = '%s is not a valid name identifier for a border. Valid identifiers are: %s.';
+
+        parent::__construct(sprintf($msg, $name, implode(',', BorderPart::getAllowedNames())));
+    }
+}

modules/x13import/tools/Spout/Writer/Exception/Border/InvalidStyleException.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Box\Spout\Writer\Exception\Border;
+
+use Box\Spout\Writer\Exception\WriterException;
+use Box\Spout\Writer\Style\BorderPart;
+
+class InvalidStyleException extends WriterException
+{
+    public function __construct($name)
+    {
+        $msg = '%s is not a valid style identifier for a border. Valid identifiers are: %s.';
+
+        parent::__construct(sprintf($msg, $name, implode(',', BorderPart::getAllowedStyles())));
+    }
+}

modules/x13import/tools/Spout/Writer/Exception/Border/InvalidWidthException.php

@@ -0,0 +1,16 @@
+<?php
+
+namespace Box\Spout\Writer\Exception\Border;
+
+use Box\Spout\Writer\Exception\WriterException;
+use Box\Spout\Writer\Style\BorderPart;
+
+class InvalidWidthException extends WriterException
+{
+    public function __construct($name)
+    {
+        $msg = '%s is not a valid width identifier for a border. Valid identifiers are: %s.';
+
+        parent::__construct(sprintf($msg, $name, implode(',', BorderPart::getAllowedWidths())));
+    }
+}

modules/x13import/tools/Spout/Writer/Exception/InvalidColorException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Box\Spout\Writer\Exception;
+
+/**
+ * Class InvalidColorException
+ *
+ * @api
+ * @package Box\Spout\Writer\Exception
+ */
+class InvalidColorException extends WriterException
+{
+}

modules/x13import/tools/Spout/Writer/Exception/InvalidSheetNameException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Box\Spout\Writer\Exception;
+
+/**
+ * Class InvalidSheetNameException
+ *
+ * @api
+ * @package Box\Spout\Writer\Exception
+ */
+class InvalidSheetNameException extends WriterException
+{
+}

modules/x13import/tools/Spout/Writer/Exception/SheetNotFoundException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Box\Spout\Writer\Exception;
+
+/**
+ * Class SheetNotFoundException
+ *
+ * @api
+ * @package Box\Spout\Writer\Exception
+ */
+class SheetNotFoundException extends WriterException
+{
+}

modules/x13import/tools/Spout/Writer/Exception/WriterAlreadyOpenedException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Box\Spout\Writer\Exception;
+
+/**
+ * Class WriterAlreadyOpenedException
+ *
+ * @api
+ * @package Box\Spout\Writer\Exception
+ */
+class WriterAlreadyOpenedException extends WriterException
+{
+}

modules/x13import/tools/Spout/Writer/Exception/WriterException.php

@@ -0,0 +1,15 @@
+<?php
+
+namespace Box\Spout\Writer\Exception;
+
+use Box\Spout\Common\Exception\SpoutException;
+
+/**
+ * Class WriterException
+ *
+ * @package Box\Spout\Writer\Exception
+ * @abstract
+ */
+abstract class WriterException extends SpoutException
+{
+}

modules/x13import/tools/Spout/Writer/Exception/WriterNotOpenedException.php

@@ -0,0 +1,13 @@
+<?php
+
+namespace Box\Spout\Writer\Exception;
+
+/**
+ * Class WriterNotOpenedException
+ *
+ * @api
+ * @package Box\Spout\Writer\Exception
+ */
+class WriterNotOpenedException extends WriterException
+{
+}

modules/x13import/tools/Spout/Writer/ODS/Helper/BorderHelper.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Box\Spout\Writer\ODS\Helper;
+
+use Box\Spout\Writer\Style\BorderPart;
+use Box\Spout\Writer\Style\Border;
+
+/**
+ * Class BorderHelper
+ *
+ * The fo:border, fo:border-top, fo:border-bottom, fo:border-left and fo:border-right attributes
+ * specify border properties
+ * http://docs.oasis-open.org/office/v1.2/os/OpenDocument-v1.2-os-part1.html#__RefHeading__1419780_253892949
+ *
+ * Example table-cell-properties
+ *
+ * <style:table-cell-properties
+ * fo:border-bottom="0.74pt solid #ffc000" style:diagonal-bl-tr="none"
+ * style:diagonal-tl-br="none" fo:border-left="none" fo:border-right="none"
+ * style:rotation-align="none" fo:border-top="none"/>
+ */
+class BorderHelper
+{
+    /**
+     * Width mappings
+     *
+     * @var array
+     */
+    protected static $widthMap = [
+        Border::WIDTH_THIN => '0.75pt',
+        Border::WIDTH_MEDIUM => '1.75pt',
+        Border::WIDTH_THICK => '2.5pt',
+    ];
+
+    /**
+     * Style mapping
+     *
+     * @var array
+     */
+    protected static $styleMap = [
+        Border::STYLE_SOLID => 'solid',
+        Border::STYLE_DASHED => 'dashed',
+        Border::STYLE_DOTTED => 'dotted',
+        Border::STYLE_DOUBLE => 'double',
+    ];
+
+    /**
+     * @param BorderPart $borderPart
+     * @return string
+     */
+    public static function serializeBorderPart(BorderPart $borderPart)
+    {
+        $definition = 'fo:border-%s="%s"';
+
+        if ($borderPart->getStyle() === Border::STYLE_NONE) {
+            $borderPartDefinition = sprintf($definition, $borderPart->getName(), 'none');
+        } else {
+            $attributes = [
+                self::$widthMap[$borderPart->getWidth()],
+                self::$styleMap[$borderPart->getStyle()],
+                '#' . $borderPart->getColor(),
+            ];
+            $borderPartDefinition = sprintf($definition, $borderPart->getName(), implode(' ', $attributes));
+        }
+
+        return $borderPartDefinition;
+    }
+}

modules/x13import/tools/Spout/Writer/ODS/Helper/FileSystemHelper.php

@@ -0,0 +1,279 @@
+<?php
+
+namespace Box\Spout\Writer\ODS\Helper;
+
+use Box\Spout\Writer\Common\Helper\ZipHelper;
+use Box\Spout\Writer\ODS\Internal\Worksheet;
+
+/**
+ * Class FileSystemHelper
+ * This class provides helper functions to help with the file system operations
+ * like files/folders creation & deletion for ODS files
+ *
+ * @package Box\Spout\Writer\ODS\Helper
+ */
+class FileSystemHelper extends \Box\Spout\Common\Helper\FileSystemHelper
+{
+    const APP_NAME = 'Spout';
+    const MIMETYPE = 'application/vnd.oasis.opendocument.spreadsheet';
+
+    const META_INF_FOLDER_NAME = 'META-INF';
+    const SHEETS_CONTENT_TEMP_FOLDER_NAME = 'worksheets-temp';
+
+    const MANIFEST_XML_FILE_NAME = 'manifest.xml';
+    const CONTENT_XML_FILE_NAME = 'content.xml';
+    const META_XML_FILE_NAME = 'meta.xml';
+    const MIMETYPE_FILE_NAME = 'mimetype';
+    const STYLES_XML_FILE_NAME = 'styles.xml';
+
+    /** @var string Path to the root folder inside the temp folder where the files to create the ODS will be stored */
+    protected $rootFolder;
+
+    /** @var string Path to the "META-INF" folder inside the root folder */
+    protected $metaInfFolder;
+
+    /** @var string Path to the temp folder, inside the root folder, where specific sheets content will be written to */
+    protected $sheetsContentTempFolder;
+
+    /**
+     * @return string
+     */
+    public function getRootFolder()
+    {
+        return $this->rootFolder;
+    }
+
+    /**
+     * @return string
+     */
+    public function getSheetsContentTempFolder()
+    {
+        return $this->sheetsContentTempFolder;
+    }
+
+    /**
+     * Creates all the folders needed to create a ODS file, as well as the files that won't change.
+     *
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create at least one of the base folders
+     */
+    public function createBaseFilesAndFolders()
+    {
+        $this
+            ->createRootFolder()
+            ->createMetaInfoFolderAndFile()
+            ->createSheetsContentTempFolder()
+            ->createMetaFile()
+            ->createMimetypeFile();
+    }
+
+    /**
+     * Creates the folder that will be used as root
+     *
+     * @return FileSystemHelper
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the folder
+     */
+    protected function createRootFolder()
+    {
+        $this->rootFolder = $this->createFolder($this->baseFolderRealPath, uniqid('ods'));
+        return $this;
+    }
+
+    /**
+     * Creates the "META-INF" folder under the root folder as well as the "manifest.xml" file in it
+     *
+     * @return FileSystemHelper
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the folder or the "manifest.xml" file
+     */
+    protected function createMetaInfoFolderAndFile()
+    {
+        $this->metaInfFolder = $this->createFolder($this->rootFolder, self::META_INF_FOLDER_NAME);
+
+        $this->createManifestFile();
+
+        return $this;
+    }
+
+    /**
+     * Creates the "manifest.xml" file under the "META-INF" folder (under root)
+     *
+     * @return FileSystemHelper
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the file
+     */
+    protected function createManifestFile()
+    {
+        $manifestXmlFileContents = <<<EOD
+<?xml version="1.0" encoding="UTF-8"?>
+<manifest:manifest xmlns:manifest="urn:oasis:names:tc:opendocument:xmlns:manifest:1.0" manifest:version="1.2">
+    <manifest:file-entry manifest:full-path="/" manifest:media-type="application/vnd.oasis.opendocument.spreadsheet"/>
+    <manifest:file-entry manifest:full-path="styles.xml" manifest:media-type="text/xml"/>
+    <manifest:file-entry manifest:full-path="content.xml" manifest:media-type="text/xml"/>
+    <manifest:file-entry manifest:full-path="meta.xml" manifest:media-type="text/xml"/>
+</manifest:manifest>
+EOD;
+
+        $this->createFileWithContents($this->metaInfFolder, self::MANIFEST_XML_FILE_NAME, $manifestXmlFileContents);
+
+        return $this;
+    }
+
+    /**
+     * Creates the temp folder where specific sheets content will be written to.
+     * This folder is not part of the final ODS file and is only used to be able to jump between sheets.
+     *
+     * @return FileSystemHelper
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the folder
+     */
+    protected function createSheetsContentTempFolder()
+    {
+        $this->sheetsContentTempFolder = $this->createFolder($this->rootFolder, self::SHEETS_CONTENT_TEMP_FOLDER_NAME);
+        return $this;
+    }
+
+    /**
+     * Creates the "meta.xml" file under the root folder
+     *
+     * @return FileSystemHelper
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the file
+     */
+    protected function createMetaFile()
+    {
+        $appName = self::APP_NAME;
+        $createdDate = (new \DateTime())->format(\DateTime::W3C);
+
+        $metaXmlFileContents = <<<EOD
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<office:document-meta office:version="1.2" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:meta="urn:oasis:names:tc:opendocument:xmlns:meta:1.0" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:xlink="http://www.w3.org/1999/xlink">
+    <office:meta>
+        <dc:creator>$appName</dc:creator>
+        <meta:creation-date>$createdDate</meta:creation-date>
+        <dc:date>$createdDate</dc:date>
+    </office:meta>
+</office:document-meta>
+EOD;
+
+        $this->createFileWithContents($this->rootFolder, self::META_XML_FILE_NAME, $metaXmlFileContents);
+
+        return $this;
+    }
+
+    /**
+     * Creates the "mimetype" file under the root folder
+     *
+     * @return FileSystemHelper
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the file
+     */
+    protected function createMimetypeFile()
+    {
+        $this->createFileWithContents($this->rootFolder, self::MIMETYPE_FILE_NAME, self::MIMETYPE);
+        return $this;
+    }
+
+    /**
+     * Creates the "content.xml" file under the root folder
+     *
+     * @param Worksheet[] $worksheets
+     * @param StyleHelper $styleHelper
+     * @return FileSystemHelper
+     */
+    public function createContentFile($worksheets, $styleHelper)
+    {
+        $contentXmlFileContents = <<<EOD
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<office:document-content office:version="1.2" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:calcext="urn:org:documentfoundation:names:experimental:calc:xmlns:calcext:1.0" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:msoxl="http://schemas.microsoft.com/office/excel/formula" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:xlink="http://www.w3.org/1999/xlink">
+EOD;
+
+        $contentXmlFileContents .= $styleHelper->getContentXmlFontFaceSectionContent();
+        $contentXmlFileContents .= $styleHelper->getContentXmlAutomaticStylesSectionContent(count($worksheets));
+
+        $contentXmlFileContents .= '<office:body><office:spreadsheet>';
+
+        $this->createFileWithContents($this->rootFolder, self::CONTENT_XML_FILE_NAME, $contentXmlFileContents);
+
+        // Append sheets content to "content.xml"
+        $contentXmlFilePath = $this->rootFolder . '/' . self::CONTENT_XML_FILE_NAME;
+        $contentXmlHandle = fopen($contentXmlFilePath, 'a');
+
+        foreach ($worksheets as $worksheet) {
+            // write the "<table:table>" node, with the final sheet's name
+            fwrite($contentXmlHandle, $worksheet->getTableElementStartAsString());
+
+            $worksheetFilePath = $worksheet->getWorksheetFilePath();
+            $this->copyFileContentsToTarget($worksheetFilePath, $contentXmlHandle);
+
+            fwrite($contentXmlHandle, '</table:table>');
+        }
+
+        $contentXmlFileContents = '</office:spreadsheet></office:body></office:document-content>';
+
+        fwrite($contentXmlHandle, $contentXmlFileContents);
+        fclose($contentXmlHandle);
+
+        return $this;
+    }
+
+    /**
+     * Streams the content of the file at the given path into the target resource.
+     * Depending on which mode the target resource was created with, it will truncate then copy
+     * or append the content to the target file.
+     *
+     * @param string $sourceFilePath Path of the file whose content will be copied
+     * @param resource $targetResource Target resource that will receive the content
+     * @return void
+     */
+    protected function copyFileContentsToTarget($sourceFilePath, $targetResource)
+    {
+        $sourceHandle = fopen($sourceFilePath, 'r');
+        stream_copy_to_stream($sourceHandle, $targetResource);
+        fclose($sourceHandle);
+    }
+
+    /**
+     * Deletes the temporary folder where sheets content was stored.
+     *
+     * @return FileSystemHelper
+     */
+    public function deleteWorksheetTempFolder()
+    {
+        $this->deleteFolderRecursively($this->sheetsContentTempFolder);
+        return $this;
+    }
+
+
+    /**
+     * Creates the "styles.xml" file under the root folder
+     *
+     * @param StyleHelper $styleHelper
+     * @param int $numWorksheets Number of created worksheets
+     * @return FileSystemHelper
+     */
+    public function createStylesFile($styleHelper, $numWorksheets)
+    {
+        $stylesXmlFileContents = $styleHelper->getStylesXMLFileContent($numWorksheets);
+        $this->createFileWithContents($this->rootFolder, self::STYLES_XML_FILE_NAME, $stylesXmlFileContents);
+
+        return $this;
+    }
+
+    /**
+     * Zips the root folder and streams the contents of the zip into the given stream
+     *
+     * @param resource $streamPointer Pointer to the stream to copy the zip
+     * @return void
+     */
+    public function zipRootFolderAndCopyToStream($streamPointer)
+    {
+        $zipHelper = new ZipHelper($this->rootFolder);
+
+        // In order to have the file's mime type detected properly, files need to be added
+        // to the zip file in a particular order.
+        // @see http://www.jejik.com/articles/2010/03/how_to_correctly_create_odf_documents_using_zip/
+        $zipHelper->addUncompressedFileToArchive($this->rootFolder, self::MIMETYPE_FILE_NAME);
+
+        $zipHelper->addFolderToArchive($this->rootFolder, ZipHelper::EXISTING_FILES_SKIP);
+        $zipHelper->closeArchiveAndCopyToStream($streamPointer);
+
+        // once the zip is copied, remove it
+        $this->deleteFile($zipHelper->getZipFilePath());
+    }
+}

modules/x13import/tools/Spout/Writer/ODS/Helper/StyleHelper.php

@@ -0,0 +1,356 @@
+<?php
+
+namespace Box\Spout\Writer\ODS\Helper;
+
+use Box\Spout\Writer\Common\Helper\AbstractStyleHelper;
+use Box\Spout\Writer\Style\BorderPart;
+
+/**
+ * Class StyleHelper
+ * This class provides helper functions to manage styles
+ *
+ * @package Box\Spout\Writer\ODS\Helper
+ */
+class StyleHelper extends AbstractStyleHelper
+{
+    /** @var string[] [FONT_NAME] => [] Map whose keys contain all the fonts used */
+    protected $usedFontsSet = [];
+
+    /**
+     * Registers the given style as a used style.
+     * Duplicate styles won't be registered more than once.
+     *
+     * @param \Box\Spout\Writer\Style\Style $style The style to be registered
+     * @return \Box\Spout\Writer\Style\Style The registered style, updated with an internal ID.
+     */
+    public function registerStyle($style)
+    {
+        $this->usedFontsSet[$style->getFontName()] = true;
+        return parent::registerStyle($style);
+    }
+
+    /**
+     * @return string[] List of used fonts name
+     */
+    protected function getUsedFonts()
+    {
+        return array_keys($this->usedFontsSet);
+    }
+
+    /**
+     * Returns the content of the "styles.xml" file, given a list of styles.
+     *
+     * @param int $numWorksheets Number of worksheets created
+     * @return string
+     */
+    public function getStylesXMLFileContent($numWorksheets)
+    {
+        $content = <<<EOD
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<office:document-styles office:version="1.2" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:draw="urn:oasis:names:tc:opendocument:xmlns:drawing:1.0" xmlns:fo="urn:oasis:names:tc:opendocument:xmlns:xsl-fo-compatible:1.0" xmlns:msoxl="http://schemas.microsoft.com/office/excel/formula" xmlns:number="urn:oasis:names:tc:opendocument:xmlns:datastyle:1.0" xmlns:office="urn:oasis:names:tc:opendocument:xmlns:office:1.0" xmlns:style="urn:oasis:names:tc:opendocument:xmlns:style:1.0" xmlns:svg="urn:oasis:names:tc:opendocument:xmlns:svg-compatible:1.0" xmlns:table="urn:oasis:names:tc:opendocument:xmlns:table:1.0" xmlns:text="urn:oasis:names:tc:opendocument:xmlns:text:1.0" xmlns:xlink="http://www.w3.org/1999/xlink">
+EOD;
+
+        $content .= $this->getFontFaceSectionContent();
+        $content .= $this->getStylesSectionContent();
+        $content .= $this->getAutomaticStylesSectionContent($numWorksheets);
+        $content .= $this->getMasterStylesSectionContent($numWorksheets);
+
+        $content .= <<<EOD
+</office:document-styles>
+EOD;
+
+        return $content;
+    }
+
+    /**
+     * Returns the content of the "<office:font-face-decls>" section, inside "styles.xml" file.
+     *
+     * @return string
+     */
+    protected function getFontFaceSectionContent()
+    {
+        $content = '<office:font-face-decls>';
+        foreach ($this->getUsedFonts() as $fontName) {
+            $content .= '<style:font-face style:name="' . $fontName . '" svg:font-family="' . $fontName . '"/>';
+        }
+        $content .= '</office:font-face-decls>';
+
+        return $content;
+    }
+
+    /**
+     * Returns the content of the "<office:styles>" section, inside "styles.xml" file.
+     *
+     * @return string
+     */
+    protected function getStylesSectionContent()
+    {
+        $defaultStyle = $this->getDefaultStyle();
+
+        return <<<EOD
+<office:styles>
+    <number:number-style style:name="N0">
+        <number:number number:min-integer-digits="1"/>
+    </number:number-style>
+    <style:style style:data-style-name="N0" style:family="table-cell" style:name="Default">
+        <style:table-cell-properties fo:background-color="transparent" style:vertical-align="automatic"/>
+        <style:text-properties fo:color="#{$defaultStyle->getFontColor()}"
+                               fo:font-size="{$defaultStyle->getFontSize()}pt" style:font-size-asian="{$defaultStyle->getFontSize()}pt" style:font-size-complex="{$defaultStyle->getFontSize()}pt"
+                               style:font-name="{$defaultStyle->getFontName()}" style:font-name-asian="{$defaultStyle->getFontName()}" style:font-name-complex="{$defaultStyle->getFontName()}"/>
+    </style:style>
+</office:styles>
+EOD;
+    }
+
+    /**
+     * Returns the content of the "<office:automatic-styles>" section, inside "styles.xml" file.
+     *
+     * @param int $numWorksheets Number of worksheets created
+     * @return string
+     */
+    protected function getAutomaticStylesSectionContent($numWorksheets)
+    {
+        $content = '<office:automatic-styles>';
+
+        for ($i = 1; $i <= $numWorksheets; $i++) {
+            $content .= <<<EOD
+<style:page-layout style:name="pm$i">
+    <style:page-layout-properties style:first-page-number="continue" style:print="objects charts drawings" style:table-centering="none"/>
+    <style:header-style/>
+    <style:footer-style/>
+</style:page-layout>
+EOD;
+        }
+
+        $content .= '</office:automatic-styles>';
+
+        return $content;
+    }
+
+    /**
+     * Returns the content of the "<office:master-styles>" section, inside "styles.xml" file.
+     *
+     * @param int $numWorksheets Number of worksheets created
+     * @return string
+     */
+    protected function getMasterStylesSectionContent($numWorksheets)
+    {
+        $content = '<office:master-styles>';
+
+        for ($i = 1; $i <= $numWorksheets; $i++) {
+            $content .= <<<EOD
+<style:master-page style:name="mp$i" style:page-layout-name="pm$i">
+    <style:header/>
+    <style:header-left style:display="false"/>
+    <style:footer/>
+    <style:footer-left style:display="false"/>
+</style:master-page>
+EOD;
+        }
+
+        $content .= '</office:master-styles>';
+
+        return $content;
+    }
+
+
+    /**
+     * Returns the contents of the "<office:font-face-decls>" section, inside "content.xml" file.
+     *
+     * @return string
+     */
+    public function getContentXmlFontFaceSectionContent()
+    {
+        $content = '<office:font-face-decls>';
+        foreach ($this->getUsedFonts() as $fontName) {
+            $content .= '<style:font-face style:name="' . $fontName . '" svg:font-family="' . $fontName . '"/>';
+        }
+        $content .= '</office:font-face-decls>';
+
+        return $content;
+    }
+
+    /**
+     * Returns the contents of the "<office:automatic-styles>" section, inside "content.xml" file.
+     *
+     * @param int $numWorksheets Number of worksheets created
+     * @return string
+     */
+    public function getContentXmlAutomaticStylesSectionContent($numWorksheets)
+    {
+        $content = '<office:automatic-styles>';
+
+        foreach ($this->getRegisteredStyles() as $style) {
+            $content .= $this->getStyleSectionContent($style);
+        }
+
+        $content .= <<<EOD
+<style:style style:family="table-column" style:name="co1">
+    <style:table-column-properties fo:break-before="auto"/>
+</style:style>
+<style:style style:family="table-row" style:name="ro1">
+    <style:table-row-properties fo:break-before="auto" style:row-height="15pt" style:use-optimal-row-height="true"/>
+</style:style>
+EOD;
+
+        for ($i = 1; $i <= $numWorksheets; $i++) {
+            $content .= <<<EOD
+<style:style style:family="table" style:master-page-name="mp$i" style:name="ta$i">
+    <style:table-properties style:writing-mode="lr-tb" table:display="true"/>
+</style:style>
+EOD;
+        }
+
+        $content .= '</office:automatic-styles>';
+
+        return $content;
+    }
+
+    /**
+     * Returns the contents of the "<style:style>" section, inside "<office:automatic-styles>" section
+     *
+     * @param \Box\Spout\Writer\Style\Style $style
+     * @return string
+     */
+    protected function getStyleSectionContent($style)
+    {
+        $styleIndex = $style->getId() + 1; // 1-based
+
+        $content = '<style:style style:data-style-name="N0" style:family="table-cell" style:name="ce' . $styleIndex . '" style:parent-style-name="Default">';
+
+        $content .= $this->getTextPropertiesSectionContent($style);
+        $content .= $this->getTableCellPropertiesSectionContent($style);
+
+        $content .= '</style:style>';
+
+        return $content;
+    }
+
+    /**
+     * Returns the contents of the "<style:text-properties>" section, inside "<style:style>" section
+     *
+     * @param \Box\Spout\Writer\Style\Style $style
+     * @return string
+     */
+    private function getTextPropertiesSectionContent($style)
+    {
+        $content = '';
+
+        if ($style->shouldApplyFont()) {
+            $content .= $this->getFontSectionContent($style);
+        }
+
+        return $content;
+    }
+
+    /**
+     * Returns the contents of the "<style:text-properties>" section, inside "<style:style>" section
+     *
+     * @param \Box\Spout\Writer\Style\Style $style
+     * @return string
+     */
+    private function getFontSectionContent($style)
+    {
+        $defaultStyle = $this->getDefaultStyle();
+
+        $content = '<style:text-properties';
+
+        $fontColor = $style->getFontColor();
+        if ($fontColor !== $defaultStyle->getFontColor()) {
+            $content .= ' fo:color="#' . $fontColor . '"';
+        }
+
+        $fontName = $style->getFontName();
+        if ($fontName !== $defaultStyle->getFontName()) {
+            $content .= ' style:font-name="' . $fontName . '" style:font-name-asian="' . $fontName . '" style:font-name-complex="' . $fontName . '"';
+        }
+
+        $fontSize = $style->getFontSize();
+        if ($fontSize !== $defaultStyle->getFontSize()) {
+            $content .= ' fo:font-size="' . $fontSize . 'pt" style:font-size-asian="' . $fontSize . 'pt" style:font-size-complex="' . $fontSize . 'pt"';
+        }
+
+        if ($style->isFontBold()) {
+            $content .= ' fo:font-weight="bold" style:font-weight-asian="bold" style:font-weight-complex="bold"';
+        }
+        if ($style->isFontItalic()) {
+            $content .= ' fo:font-style="italic" style:font-style-asian="italic" style:font-style-complex="italic"';
+        }
+        if ($style->isFontUnderline()) {
+            $content .= ' style:text-underline-style="solid" style:text-underline-type="single"';
+        }
+        if ($style->isFontStrikethrough()) {
+            $content .= ' style:text-line-through-style="solid"';
+        }
+
+        $content .= '/>';
+
+        return $content;
+    }
+
+    /**
+     * Returns the contents of the "<style:table-cell-properties>" section, inside "<style:style>" section
+     *
+     * @param \Box\Spout\Writer\Style\Style $style
+     * @return string
+     */
+    private function getTableCellPropertiesSectionContent($style)
+    {
+        $content = '';
+
+        if ($style->shouldWrapText()) {
+            $content .= $this->getWrapTextXMLContent();
+        }
+
+        if ($style->shouldApplyBorder()) {
+            $content .= $this->getBorderXMLContent($style);
+        }
+
+        if ($style->shouldApplyBackgroundColor()) {
+            $content .= $this->getBackgroundColorXMLContent($style);
+        }
+
+        return $content;
+    }
+
+    /**
+     * Returns the contents of the wrap text definition for the "<style:table-cell-properties>" section
+     *
+     * @return string
+     */
+    private function getWrapTextXMLContent()
+    {
+        return '<style:table-cell-properties fo:wrap-option="wrap" style:vertical-align="automatic"/>';
+    }
+
+    /**
+     * Returns the contents of the borders definition for the "<style:table-cell-properties>" section
+     *
+     * @param \Box\Spout\Writer\Style\Style $style
+     * @return string
+     */
+    private function getBorderXMLContent($style)
+    {
+        $borderProperty = '<style:table-cell-properties %s />';
+
+        $borders = array_map(function (BorderPart $borderPart) {
+            return BorderHelper::serializeBorderPart($borderPart);
+        }, $style->getBorder()->getParts());
+
+        return sprintf($borderProperty, implode(' ', $borders));
+    }
+
+    /**
+     * Returns the contents of the background color definition for the "<style:table-cell-properties>" section
+     *
+     * @param \Box\Spout\Writer\Style\Style $style
+     * @return string
+     */
+    private function getBackgroundColorXMLContent($style)
+    {
+        return sprintf(
+            '<style:table-cell-properties fo:background-color="#%s"/>',
+            $style->getBackgroundColor()
+        );
+    }
+}

modules/x13import/tools/Spout/Writer/ODS/Internal/Workbook.php

@@ -0,0 +1,119 @@
+<?php
+
+namespace Box\Spout\Writer\ODS\Internal;
+
+use Box\Spout\Writer\Common\Internal\AbstractWorkbook;
+use Box\Spout\Writer\ODS\Helper\FileSystemHelper;
+use Box\Spout\Writer\ODS\Helper\StyleHelper;
+use Box\Spout\Writer\Common\Sheet;
+
+/**
+ * Class Workbook
+ * Represents a workbook within a ODS file.
+ * It provides the functions to work with worksheets.
+ *
+ * @package Box\Spout\Writer\ODS\Internal
+ */
+class Workbook extends AbstractWorkbook
+{
+    /**
+     * Maximum number of rows a ODS sheet can contain
+     * @see https://ask.libreoffice.org/en/question/8631/upper-limit-to-number-of-rows-in-calc/
+     */
+    protected static $maxRowsPerWorksheet = 1048576;
+
+    /** @var \Box\Spout\Writer\ODS\Helper\FileSystemHelper Helper to perform file system operations */
+    protected $fileSystemHelper;
+
+    /** @var \Box\Spout\Writer\ODS\Helper\StyleHelper Helper to apply styles */
+    protected $styleHelper;
+
+    /**
+     * @param string $tempFolder
+     * @param bool $shouldCreateNewSheetsAutomatically
+     * @param \Box\Spout\Writer\Style\Style $defaultRowStyle
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create at least one of the base folders
+     */
+    public function __construct($tempFolder, $shouldCreateNewSheetsAutomatically, $defaultRowStyle)
+    {
+        parent::__construct($shouldCreateNewSheetsAutomatically, $defaultRowStyle);
+
+        $this->fileSystemHelper = new FileSystemHelper($tempFolder);
+        $this->fileSystemHelper->createBaseFilesAndFolders();
+
+        $this->styleHelper = new StyleHelper($defaultRowStyle);
+    }
+
+    /**
+     * @return \Box\Spout\Writer\ODS\Helper\StyleHelper Helper to apply styles to ODS files
+     */
+    protected function getStyleHelper()
+    {
+        return $this->styleHelper;
+    }
+
+    /**
+     * @return int Maximum number of rows/columns a sheet can contain
+     */
+    protected function getMaxRowsPerWorksheet()
+    {
+        return self::$maxRowsPerWorksheet;
+    }
+
+    /**
+     * Creates a new sheet in the workbook. The current sheet remains unchanged.
+     *
+     * @return Worksheet The created sheet
+     * @throws \Box\Spout\Common\Exception\IOException If unable to open the sheet for writing
+     */
+    public function addNewSheet()
+    {
+        $newSheetIndex = count($this->worksheets);
+        $sheet = new Sheet($newSheetIndex, $this->internalId);
+
+        $sheetsContentTempFolder = $this->fileSystemHelper->getSheetsContentTempFolder();
+        $worksheet = new Worksheet($sheet, $sheetsContentTempFolder);
+        $this->worksheets[] = $worksheet;
+
+        return $worksheet;
+    }
+
+    /**
+     * Closes the workbook and all its associated sheets.
+     * All the necessary files are written to disk and zipped together to create the ODS file.
+     * All the temporary files are then deleted.
+     *
+     * @param resource $finalFilePointer Pointer to the ODS that will be created
+     * @return void
+     */
+    public function close($finalFilePointer)
+    {
+        /** @var Worksheet[] $worksheets */
+        $worksheets = $this->worksheets;
+        $numWorksheets = count($worksheets);
+
+        foreach ($worksheets as $worksheet) {
+            $worksheet->close();
+        }
+
+        // Finish creating all the necessary files before zipping everything together
+        $this->fileSystemHelper
+            ->createContentFile($worksheets, $this->styleHelper)
+            ->deleteWorksheetTempFolder()
+            ->createStylesFile($this->styleHelper, $numWorksheets)
+            ->zipRootFolderAndCopyToStream($finalFilePointer);
+
+        $this->cleanupTempFolder();
+    }
+
+    /**
+     * Deletes the root folder created in the temp folder and all its contents.
+     *
+     * @return void
+     */
+    protected function cleanupTempFolder()
+    {
+        $xlsxRootFolder = $this->fileSystemHelper->getRootFolder();
+        $this->fileSystemHelper->deleteFolderRecursively($xlsxRootFolder);
+    }
+}

modules/x13import/tools/Spout/Writer/ODS/Internal/Worksheet.php

@@ -0,0 +1,233 @@
+<?php
+
+namespace Box\Spout\Writer\ODS\Internal;
+
+use Box\Spout\Common\Exception\InvalidArgumentException;
+use Box\Spout\Common\Exception\IOException;
+use Box\Spout\Common\Helper\StringHelper;
+use Box\Spout\Writer\Common\Helper\CellHelper;
+use Box\Spout\Writer\Common\Internal\WorksheetInterface;
+
+/**
+ * Class Worksheet
+ * Represents a worksheet within a ODS file. The difference with the Sheet object is
+ * that this class provides an interface to write data
+ *
+ * @package Box\Spout\Writer\ODS\Internal
+ */
+class Worksheet implements WorksheetInterface
+{
+    /** @var \Box\Spout\Writer\Common\Sheet The "external" sheet */
+    protected $externalSheet;
+
+    /** @var string Path to the XML file that will contain the sheet data */
+    protected $worksheetFilePath;
+
+    /** @var \Box\Spout\Common\Escaper\ODS Strings escaper */
+    protected $stringsEscaper;
+
+    /** @var \Box\Spout\Common\Helper\StringHelper To help with string manipulation */
+    protected $stringHelper;
+
+    /** @var Resource Pointer to the temporary sheet data file (e.g. worksheets-temp/sheet1.xml) */
+    protected $sheetFilePointer;
+
+    /** @var int Maximum number of columns among all the written rows */
+    protected $maxNumColumns = 1;
+
+    /** @var int Index of the last written row */
+    protected $lastWrittenRowIndex = 0;
+
+    /**
+     * @param \Box\Spout\Writer\Common\Sheet $externalSheet The associated "external" sheet
+     * @param string $worksheetFilesFolder Temporary folder where the files to create the ODS will be stored
+     * @throws \Box\Spout\Common\Exception\IOException If the sheet data file cannot be opened for writing
+     */
+    public function __construct($externalSheet, $worksheetFilesFolder)
+    {
+        $this->externalSheet = $externalSheet;
+        /** @noinspection PhpUnnecessaryFullyQualifiedNameInspection */
+        $this->stringsEscaper = \Box\Spout\Common\Escaper\ODS::getInstance();
+        $this->worksheetFilePath = $worksheetFilesFolder . '/sheet' . $externalSheet->getIndex() . '.xml';
+
+        $this->stringHelper = new StringHelper();
+
+        $this->startSheet();
+    }
+
+    /**
+     * Prepares the worksheet to accept data
+     * The XML file does not contain the "<table:table>" node as it contains the sheet's name
+     * which may change during the execution of the program. It will be added at the end.
+     *
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If the sheet data file cannot be opened for writing
+     */
+    protected function startSheet()
+    {
+        $this->sheetFilePointer = fopen($this->worksheetFilePath, 'w');
+        $this->throwIfSheetFilePointerIsNotAvailable();
+    }
+
+    /**
+     * Checks if the book has been created. Throws an exception if not created yet.
+     *
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If the sheet data file cannot be opened for writing
+     */
+    protected function throwIfSheetFilePointerIsNotAvailable()
+    {
+        if (!$this->sheetFilePointer) {
+            throw new IOException('Unable to open sheet for writing.');
+        }
+    }
+
+    /**
+     * @return string Path to the temporary sheet content XML file
+     */
+    public function getWorksheetFilePath()
+    {
+        return $this->worksheetFilePath;
+    }
+
+    /**
+     * Returns the table XML root node as string.
+     *
+     * @return string <table> node as string
+     */
+    public function getTableElementStartAsString()
+    {
+        $escapedSheetName = $this->stringsEscaper->escape($this->externalSheet->getName());
+        $tableStyleName = 'ta' . ($this->externalSheet->getIndex() + 1);
+
+        $tableElement  = '<table:table table:style-name="' . $tableStyleName . '" table:name="' . $escapedSheetName . '">';
+        $tableElement .= '<table:table-column table:default-cell-style-name="ce1" table:style-name="co1" table:number-columns-repeated="' . $this->maxNumColumns . '"/>';
+
+        return $tableElement;
+    }
+
+    /**
+     * @return \Box\Spout\Writer\Common\Sheet The "external" sheet
+     */
+    public function getExternalSheet()
+    {
+        return $this->externalSheet;
+    }
+
+    /**
+     * @return int The index of the last written row
+     */
+    public function getLastWrittenRowIndex()
+    {
+        return $this->lastWrittenRowIndex;
+    }
+
+    /**
+     * Adds data to the worksheet.
+     *
+     * @param array $dataRow Array containing data to be written. Cannot be empty.
+     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
+     * @param \Box\Spout\Writer\Style\Style $style Style to be applied to the row. NULL means use default style.
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If the data cannot be written
+     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If a cell value's type is not supported
+     */
+    public function addRow($dataRow, $style)
+    {
+        // $dataRow can be an associative array. We need to transform
+        // it into a regular array, as we'll use the numeric indexes.
+        $dataRowWithNumericIndexes = array_values($dataRow);
+
+        $styleIndex = ($style->getId() + 1); // 1-based
+        $cellsCount = count($dataRow);
+        $this->maxNumColumns = max($this->maxNumColumns, $cellsCount);
+
+        $data = '<table:table-row table:style-name="ro1">';
+
+        $currentCellIndex = 0;
+        $nextCellIndex = 1;
+
+        for ($i = 0; $i < $cellsCount; $i++) {
+            $currentCellValue = $dataRowWithNumericIndexes[$currentCellIndex];
+
+            // Using isset here because it is way faster than array_key_exists...
+            if (!isset($dataRowWithNumericIndexes[$nextCellIndex]) ||
+                $currentCellValue !== $dataRowWithNumericIndexes[$nextCellIndex]) {
+
+                $numTimesValueRepeated = ($nextCellIndex - $currentCellIndex);
+                $data .= $this->getCellXML($currentCellValue, $styleIndex, $numTimesValueRepeated);
+
+                $currentCellIndex = $nextCellIndex;
+            }
+
+            $nextCellIndex++;
+        }
+
+        $data .= '</table:table-row>';
+
+        $wasWriteSuccessful = fwrite($this->sheetFilePointer, $data);
+        if ($wasWriteSuccessful === false) {
+            throw new IOException("Unable to write data in {$this->worksheetFilePath}");
+        }
+
+        // only update the count if the write worked
+        $this->lastWrittenRowIndex++;
+    }
+
+    /**
+     * Returns the cell XML content, given its value.
+     *
+     * @param mixed $cellValue The value to be written
+     * @param int $styleIndex Index of the used style
+     * @param int $numTimesValueRepeated Number of times the value is consecutively repeated
+     * @return string The cell XML content
+     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If a cell value's type is not supported
+     */
+    protected function getCellXML($cellValue, $styleIndex, $numTimesValueRepeated)
+    {
+        $data = '<table:table-cell table:style-name="ce' . $styleIndex . '"';
+
+        if ($numTimesValueRepeated !== 1) {
+            $data .= ' table:number-columns-repeated="' . $numTimesValueRepeated . '"';
+        }
+
+        if (CellHelper::isNonEmptyString($cellValue)) {
+            $data .= ' office:value-type="string" calcext:value-type="string">';
+
+            $cellValueLines = explode("\n", $cellValue);
+            foreach ($cellValueLines as $cellValueLine) {
+                $data .= '<text:p>' . $this->stringsEscaper->escape($cellValueLine) . '</text:p>';
+            }
+
+            $data .= '</table:table-cell>';
+        } else if (CellHelper::isBoolean($cellValue)) {
+            $data .= ' office:value-type="boolean" calcext:value-type="boolean" office:boolean-value="' . $cellValue . '">';
+            $data .= '<text:p>' . $cellValue . '</text:p>';
+            $data .= '</table:table-cell>';
+        } else if (CellHelper::isNumeric($cellValue)) {
+            $data .= ' office:value-type="float" calcext:value-type="float" office:value="' . $cellValue . '">';
+            $data .= '<text:p>' . $cellValue . '</text:p>';
+            $data .= '</table:table-cell>';
+        } else if (empty($cellValue)) {
+            $data .= '/>';
+        } else {
+            throw new InvalidArgumentException('Trying to add a value with an unsupported type: ' . gettype($cellValue));
+        }
+
+        return $data;
+    }
+
+    /**
+     * Closes the worksheet
+     *
+     * @return void
+     */
+    public function close()
+    {
+        if (!is_resource($this->sheetFilePointer)) {
+            return;
+        }
+
+        fclose($this->sheetFilePointer);
+    }
+}

modules/x13import/tools/Spout/Writer/ODS/Writer.php

@@ -0,0 +1,93 @@
+<?php
+
+namespace Box\Spout\Writer\ODS;
+
+use Box\Spout\Writer\AbstractMultiSheetsWriter;
+use Box\Spout\Writer\Common;
+use Box\Spout\Writer\ODS\Internal\Workbook;
+
+/**
+ * Class Writer
+ * This class provides base support to write data to ODS files
+ *
+ * @package Box\Spout\Writer\ODS
+ */
+class Writer extends AbstractMultiSheetsWriter
+{
+    /** @var string Content-Type value for the header */
+    protected static $headerContentType = 'application/vnd.oasis.opendocument.spreadsheet';
+
+    /** @var string Temporary folder where the files to create the ODS will be stored */
+    protected $tempFolder;
+
+    /** @var Internal\Workbook The workbook for the ODS file */
+    protected $book;
+
+    /**
+     * Sets a custom temporary folder for creating intermediate files/folders.
+     * This must be set before opening the writer.
+     *
+     * @api
+     * @param string $tempFolder Temporary folder where the files to create the ODS will be stored
+     * @return Writer
+     * @throws \Box\Spout\Writer\Exception\WriterAlreadyOpenedException If the writer was already opened
+     */
+    public function setTempFolder($tempFolder)
+    {
+        $this->throwIfWriterAlreadyOpened('Writer must be configured before opening it.');
+
+        $this->tempFolder = $tempFolder;
+        return $this;
+    }
+
+    /**
+     * Configures the write and sets the current sheet pointer to a new sheet.
+     *
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If unable to open the file for writing
+     */
+    protected function openWriter()
+    {
+        $tempFolder = ($this->tempFolder) ? : sys_get_temp_dir();
+        $this->book = new Workbook($tempFolder, $this->shouldCreateNewSheetsAutomatically, $this->defaultRowStyle);
+        $this->book->addNewSheetAndMakeItCurrent();
+    }
+
+    /**
+     * @return Internal\Workbook The workbook representing the file to be written
+     */
+    protected function getWorkbook()
+    {
+        return $this->book;
+    }
+
+    /**
+     * Adds data to the currently opened writer.
+     * If shouldCreateNewSheetsAutomatically option is set to true, it will handle pagination
+     * with the creation of new worksheets if one worksheet has reached its maximum capicity.
+     *
+     * @param array $dataRow Array containing data to be written.
+     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
+     * @param \Box\Spout\Writer\Style\Style $style Style to be applied to the row.
+     * @return void
+     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If the book is not created yet
+     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
+     */
+    protected function addRowToWriter(array $dataRow, $style)
+    {
+        $this->throwIfBookIsNotAvailable();
+        $this->book->addRowToCurrentWorksheet($dataRow, $style);
+    }
+
+    /**
+     * Closes the writer, preventing any additional writing.
+     *
+     * @return void
+     */
+    protected function closeWriter()
+    {
+        if ($this->book) {
+            $this->book->close($this->filePointer);
+        }
+    }
+}

modules/x13import/tools/Spout/Writer/Style/Border.php

@@ -0,0 +1,85 @@
+<?php
+
+namespace Box\Spout\Writer\Style;
+
+/**
+ * Class Border
+ */
+class Border
+{
+    const LEFT = 'left';
+    const RIGHT = 'right';
+    const TOP = 'top';
+    const BOTTOM = 'bottom';
+
+    const STYLE_NONE = 'none';
+    const STYLE_SOLID = 'solid';
+    const STYLE_DASHED = 'dashed';
+    const STYLE_DOTTED = 'dotted';
+    const STYLE_DOUBLE = 'double';
+
+    const WIDTH_THIN = 'thin';
+    const WIDTH_MEDIUM = 'medium';
+    const WIDTH_THICK = 'thick';
+
+    /**
+     * @var array A list of BorderPart objects for this border.
+     */
+    protected $parts = [];
+
+    /**
+     * @param array|void $borderParts
+     */
+    public function __construct(array $borderParts = [])
+    {
+        $this->setParts($borderParts);
+    }
+
+    /**
+     * @param $name The name of the border part
+     * @return null|BorderPart
+     */
+    public function getPart($name)
+    {
+        return $this->hasPart($name) ? $this->parts[$name] : null;
+    }
+
+    /**
+     * @param $name The name of the border part
+     * @return bool
+     */
+    public function hasPart($name)
+    {
+        return isset($this->parts[$name]);
+    }
+
+    /**
+     * @return array
+     */
+    public function getParts()
+    {
+        return $this->parts;
+    }
+
+    /**
+     * Set BorderParts
+     * @param array $parts
+     */
+    public function setParts($parts)
+    {
+        unset($this->parts);
+        foreach ($parts as $part) {
+            $this->addPart($part);
+        }
+    }
+
+    /**
+     * @param BorderPart $borderPart
+     * @return self
+     */
+    public function addPart(BorderPart $borderPart)
+    {
+        $this->parts[$borderPart->getName()] = $borderPart;
+        return $this;
+    }
+}

modules/x13import/tools/Spout/Writer/Style/BorderBuilder.php

@@ -0,0 +1,75 @@
+<?php
+
+namespace Box\Spout\Writer\Style;
+
+/**
+ * Class BorderBuilder
+ */
+class BorderBuilder
+{
+    /**
+     * @var Border
+     */
+    protected $border;
+
+    public function __construct()
+    {
+        $this->border = new Border();
+    }
+
+    /**
+     * @param string|void $color Border A RGB color code
+     * @param string|void $width Border width @see BorderPart::allowedWidths
+     * @param string|void $style Border style @see BorderPart::allowedStyles
+     * @return BorderBuilder
+     */
+    public function setBorderTop($color = Color::BLACK, $width = Border::WIDTH_MEDIUM, $style = Border::STYLE_SOLID)
+    {
+        $this->border->addPart(new BorderPart(Border::TOP, $color, $width, $style));
+        return $this;
+    }
+
+    /**
+     * @param string|void $color Border A RGB color code
+     * @param string|void $width Border width @see BorderPart::allowedWidths
+     * @param string|void $style Border style @see BorderPart::allowedStyles
+     * @return BorderBuilder
+     */
+    public function setBorderRight($color = Color::BLACK, $width = Border::WIDTH_MEDIUM, $style = Border::STYLE_SOLID)
+    {
+        $this->border->addPart(new BorderPart(Border::RIGHT, $color, $width, $style));
+        return $this;
+    }
+
+    /**
+     * @param string|void $color Border A RGB color code
+     * @param string|void $width Border width @see BorderPart::allowedWidths
+     * @param string|void $style Border style @see BorderPart::allowedStyles
+     * @return BorderBuilder
+     */
+    public function setBorderBottom($color = Color::BLACK, $width = Border::WIDTH_MEDIUM, $style = Border::STYLE_SOLID)
+    {
+        $this->border->addPart(new BorderPart(Border::BOTTOM, $color, $width, $style));
+        return $this;
+    }
+
+    /**
+     * @param string|void $color Border A RGB color code
+     * @param string|void $width Border width @see BorderPart::allowedWidths
+     * @param string|void $style Border style @see BorderPart::allowedStyles
+     * @return BorderBuilder
+     */
+    public function setBorderLeft($color = Color::BLACK, $width = Border::WIDTH_MEDIUM, $style = Border::STYLE_SOLID)
+    {
+        $this->border->addPart(new BorderPart(Border::LEFT, $color, $width, $style));
+        return $this;
+    }
+
+    /**
+     * @return Border
+     */
+    public function build()
+    {
+        return $this->border;
+    }
+}

modules/x13import/tools/Spout/Writer/Style/BorderPart.php

@@ -0,0 +1,184 @@
+<?php
+
+namespace Box\Spout\Writer\Style;
+
+use Box\Spout\Writer\Exception\Border\InvalidNameException;
+use Box\Spout\Writer\Exception\Border\InvalidStyleException;
+use Box\Spout\Writer\Exception\Border\InvalidWidthException;
+
+/**
+ * Class BorderPart
+ */
+class BorderPart
+{
+    /**
+     * @var string The style of this border part.
+     */
+    protected $style;
+
+    /**
+     * @var string The name of this border part.
+     */
+    protected $name;
+
+    /**
+     * @var string The color of this border part.
+     */
+    protected $color;
+
+    /**
+     * @var string The width of this border part.
+     */
+    protected $width;
+
+    /**
+     * @var array Allowed style constants for parts.
+     */
+    protected static $allowedStyles = [
+        'none',
+        'solid',
+        'dashed',
+        'dotted',
+        'double'
+    ];
+
+    /**
+     * @var array Allowed names constants for border parts.
+     */
+    protected static $allowedNames = [
+        'left',
+        'right',
+        'top',
+        'bottom',
+    ];
+
+    /**
+     * @var array Allowed width constants for border parts.
+     */
+    protected static $allowedWidths = [
+        'thin',
+        'medium',
+        'thick',
+    ];
+
+    /**
+     * @param string $name @see  BorderPart::$allowedNames
+     * @param string $color A RGB color code
+     * @param string $width @see BorderPart::$allowedWidths
+     * @param string $style @see BorderPart::$allowedStyles
+     * @throws InvalidNameException
+     * @throws InvalidStyleException
+     * @throws InvalidWidthException
+     */
+    public function __construct($name, $color = Color::BLACK, $width = Border::WIDTH_MEDIUM, $style = Border::STYLE_SOLID)
+    {
+        $this->setName($name);
+        $this->setColor($color);
+        $this->setWidth($width);
+        $this->setStyle($style);
+    }
+
+    /**
+     * @return string
+     */
+    public function getName()
+    {
+        return $this->name;
+    }
+
+    /**
+     * @param string $name The name of the border part @see BorderPart::$allowedNames
+     * @throws InvalidNameException
+     * @return void
+     */
+    public function setName($name)
+    {
+        if (!in_array($name, self::$allowedNames)) {
+            throw new InvalidNameException($name);
+        }
+        $this->name = $name;
+    }
+
+    /**
+     * @return string
+     */
+    public function getStyle()
+    {
+        return $this->style;
+    }
+
+    /**
+     * @param string $style The style of the border part @see BorderPart::$allowedStyles
+     * @throws InvalidStyleException
+     * @return void
+     */
+    public function setStyle($style)
+    {
+        if (!in_array($style, self::$allowedStyles)) {
+            throw new InvalidStyleException($style);
+        }
+        $this->style = $style;
+    }
+
+    /**
+     * @return string
+     */
+    public function getColor()
+    {
+        return $this->color;
+    }
+
+    /**
+     * @param string $color The color of the border part @see Color::rgb()
+     * @return void
+     */
+    public function setColor($color)
+    {
+        $this->color = $color;
+    }
+
+    /**
+     * @return string
+     */
+    public function getWidth()
+    {
+        return $this->width;
+    }
+
+    /**
+     * @param string $width The width of the border part @see BorderPart::$allowedWidths
+     * @throws InvalidWidthException
+     * @return void
+     */
+    public function setWidth($width)
+    {
+        if (!in_array($width, self::$allowedWidths)) {
+            throw new InvalidWidthException($width);
+        }
+        $this->width = $width;
+    }
+
+    /**
+     * @return array
+     */
+    public static function getAllowedStyles()
+    {
+        return self::$allowedStyles;
+    }
+
+    /**
+     * @return array
+     */
+    public static function getAllowedNames()
+    {
+        return self::$allowedNames;
+    }
+
+    /**
+     * @return array
+     */
+    public static function getAllowedWidths()
+    {
+        return self::$allowedWidths;
+    }
+}

modules/x13import/tools/Spout/Writer/Style/Color.php

@@ -0,0 +1,87 @@
+<?php
+
+namespace Box\Spout\Writer\Style;
+
+use Box\Spout\Writer\Exception\InvalidColorException;
+
+/**
+ * Class Color
+ * This class provides constants and functions to work with colors
+ *
+ * @package Box\Spout\Writer\Style
+ */
+class Color
+{
+    /** Standard colors - based on Office Online */
+    const BLACK = '000000';
+    const WHITE = 'FFFFFF';
+    const RED = 'FF0000';
+    const DARK_RED = 'C00000';
+    const ORANGE = 'FFC000';
+    const YELLOW = 'FFFF00';
+    const LIGHT_GREEN = '92D040';
+    const GREEN = '00B050';
+    const LIGHT_BLUE = '00B0E0';
+    const BLUE = '0070C0';
+    const DARK_BLUE = '002060';
+    const PURPLE = '7030A0';
+
+    /**
+     * Returns an RGB color from R, G and B values
+     *
+     * @api
+     * @param int $red Red component, 0 - 255
+     * @param int $green Green component, 0 - 255
+     * @param int $blue Blue component, 0 - 255
+     * @return string RGB color
+     */
+    public static function rgb($red, $green, $blue)
+    {
+        self::throwIfInvalidColorComponentValue($red);
+        self::throwIfInvalidColorComponentValue($green);
+        self::throwIfInvalidColorComponentValue($blue);
+
+        return strtoupper(
+            self::convertColorComponentToHex($red) .
+            self::convertColorComponentToHex($green) .
+            self::convertColorComponentToHex($blue)
+        );
+    }
+
+    /**
+     * Throws an exception is the color component value is outside of bounds (0 - 255)
+     *
+     * @param int $colorComponent
+     * @return void
+     * @throws \Box\Spout\Writer\Exception\InvalidColorException
+     */
+    protected static function throwIfInvalidColorComponentValue($colorComponent)
+    {
+        if (!is_int($colorComponent) || $colorComponent < 0 || $colorComponent > 255) {
+            throw new InvalidColorException("The RGB components must be between 0 and 255. Received: $colorComponent");
+        }
+    }
+
+    /**
+     * Converts the color component to its corresponding hexadecimal value
+     *
+     * @param int $colorComponent Color component, 0 - 255
+     * @return string Corresponding hexadecimal value, with a leading 0 if needed. E.g "0f", "2d"
+     */
+    protected static function convertColorComponentToHex($colorComponent)
+    {
+        return str_pad(dechex($colorComponent), 2, '0', STR_PAD_LEFT);
+    }
+
+    /**
+     * Returns the ARGB color of the given RGB color,
+     * assuming that alpha value is always 1.
+     *
+     * @param string $rgbColor RGB color like "FF08B2"
+     * @return string ARGB color
+     */
+    public static function toARGB($rgbColor)
+    {
+        return 'FF' . $rgbColor;
+    }
+}

modules/x13import/tools/Spout/Writer/Style/Style.php

@@ -0,0 +1,426 @@
+<?php
+
+namespace Box\Spout\Writer\Style;
+
+/**
+ * Class Style
+ * Represents a style to be applied to a cell
+ *
+ * @package Box\Spout\Writer\Style
+ */
+class Style
+{
+    /** Default font values */
+    const DEFAULT_FONT_SIZE = 11;
+    const DEFAULT_FONT_COLOR = Color::BLACK;
+    const DEFAULT_FONT_NAME = 'Arial';
+
+    /** @var int|null Style ID */
+    protected $id = null;
+
+    /** @var bool Whether the font should be bold */
+    protected $fontBold = false;
+    /** @var bool Whether the bold property was set */
+    protected $hasSetFontBold = false;
+
+    /** @var bool Whether the font should be italic */
+    protected $fontItalic = false;
+    /** @var bool Whether the italic property was set */
+    protected $hasSetFontItalic = false;
+
+    /** @var bool Whether the font should be underlined */
+    protected $fontUnderline = false;
+    /** @var bool Whether the underline property was set */
+    protected $hasSetFontUnderline = false;
+
+    /** @var bool Whether the font should be struck through */
+    protected $fontStrikethrough = false;
+    /** @var bool Whether the strikethrough property was set */
+    protected $hasSetFontStrikethrough = false;
+
+    /** @var int Font size */
+    protected $fontSize = self::DEFAULT_FONT_SIZE;
+    /** @var bool Whether the font size property was set */
+    protected $hasSetFontSize = false;
+
+    /** @var string Font color */
+    protected $fontColor = self::DEFAULT_FONT_COLOR;
+    /** @var bool Whether the font color property was set */
+    protected $hasSetFontColor = false;
+
+    /** @var string Font name */
+    protected $fontName = self::DEFAULT_FONT_NAME;
+    /** @var bool Whether the font name property was set */
+    protected $hasSetFontName = false;
+
+    /** @var bool Whether specific font properties should be applied */
+    protected $shouldApplyFont = false;
+
+    /** @var bool Whether the text should wrap in the cell (useful for long or multi-lines text) */
+    protected $shouldWrapText = false;
+    /** @var bool Whether the wrap text property was set */
+    protected $hasSetWrapText = false;
+
+    /**
+     * @var Border
+     */
+    protected $border = null;
+
+    /**
+     * @var bool Whether border properties should be applied
+     */
+    protected $shouldApplyBorder = false;
+
+    /** @var string Background color */
+    protected $backgroundColor = null;
+
+    /** @var bool */
+    protected $hasSetBackgroundColor = false;
+
+
+    /**
+     * @return int|null
+     */
+    public function getId()
+    {
+        return $this->id;
+    }
+
+    /**
+     * @param int $id
+     * @return Style
+     */
+    public function setId($id)
+    {
+        $this->id = $id;
+        return $this;
+    }
+
+    /**
+     * @return Border
+     */
+    public function getBorder()
+    {
+        return $this->border;
+    }
+
+    /**
+     * @param Border $border
+     * @return Style
+     */
+    public function setBorder(Border $border)
+    {
+        $this->shouldApplyBorder = true;
+        $this->border = $border;
+        return $this;
+    }
+
+    /**
+     * @return bool
+     */
+    public function shouldApplyBorder()
+    {
+        return $this->shouldApplyBorder;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isFontBold()
+    {
+        return $this->fontBold;
+    }
+
+    /**
+     * @return Style
+     */
+    public function setFontBold()
+    {
+        $this->fontBold = true;
+        $this->hasSetFontBold = true;
+        $this->shouldApplyFont = true;
+        return $this;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isFontItalic()
+    {
+        return $this->fontItalic;
+    }
+
+    /**
+     * @return Style
+     */
+    public function setFontItalic()
+    {
+        $this->fontItalic = true;
+        $this->hasSetFontItalic = true;
+        $this->shouldApplyFont = true;
+        return $this;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isFontUnderline()
+    {
+        return $this->fontUnderline;
+    }
+
+    /**
+     * @return Style
+     */
+    public function setFontUnderline()
+    {
+        $this->fontUnderline = true;
+        $this->hasSetFontUnderline = true;
+        $this->shouldApplyFont = true;
+        return $this;
+    }
+
+    /**
+     * @return bool
+     */
+    public function isFontStrikethrough()
+    {
+        return $this->fontStrikethrough;
+    }
+
+    /**
+     * @return Style
+     */
+    public function setFontStrikethrough()
+    {
+        $this->fontStrikethrough = true;
+        $this->hasSetFontStrikethrough = true;
+        $this->shouldApplyFont = true;
+        return $this;
+    }
+
+    /**
+     * @return int
+     */
+    public function getFontSize()
+    {
+        return $this->fontSize;
+    }
+
+    /**
+     * @param int $fontSize Font size, in pixels
+     * @return Style
+     */
+    public function setFontSize($fontSize)
+    {
+        $this->fontSize = $fontSize;
+        $this->hasSetFontSize = true;
+        $this->shouldApplyFont = true;
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getFontColor()
+    {
+        return $this->fontColor;
+    }
+
+    /**
+     * Sets the font color.
+     *
+     * @param string $fontColor ARGB color (@see Color)
+     * @return Style
+     */
+    public function setFontColor($fontColor)
+    {
+        $this->fontColor = $fontColor;
+        $this->hasSetFontColor = true;
+        $this->shouldApplyFont = true;
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getFontName()
+    {
+        return $this->fontName;
+    }
+
+    /**
+     * @param string $fontName Name of the font to use
+     * @return Style
+     */
+    public function setFontName($fontName)
+    {
+        $this->fontName = $fontName;
+        $this->hasSetFontName = true;
+        $this->shouldApplyFont = true;
+        return $this;
+    }
+
+    /**
+     * @return bool
+     */
+    public function shouldWrapText()
+    {
+        return $this->shouldWrapText;
+    }
+
+    /**
+     * @param bool|void $shouldWrap Should the text be wrapped
+     * @return Style
+     */
+    public function setShouldWrapText($shouldWrap = true)
+    {
+        $this->shouldWrapText = $shouldWrap;
+        $this->hasSetWrapText = true;
+        return $this;
+    }
+
+    /**
+     * @return bool
+     */
+    public function hasSetWrapText()
+    {
+        return $this->hasSetWrapText;
+    }
+
+    /**
+     * @return bool Whether specific font properties should be applied
+     */
+    public function shouldApplyFont()
+    {
+        return $this->shouldApplyFont;
+    }
+
+    /**
+     * Sets the background color
+     * @param string $color ARGB color (@see Color)
+     * @return Style
+     */
+    public function setBackgroundColor($color)
+    {
+        $this->hasSetBackgroundColor = true;
+        $this->backgroundColor = $color;
+        return $this;
+    }
+
+    /**
+     * @return string
+     */
+    public function getBackgroundColor()
+    {
+        return $this->backgroundColor;
+    }
+
+    /**
+     *
+     * @return bool Whether the background color should be applied
+     */
+    public function shouldApplyBackgroundColor()
+    {
+        return $this->hasSetBackgroundColor;
+    }
+
+    /**
+     * Serializes the style for future comparison with other styles.
+     * The ID is excluded from the comparison, as we only care about
+     * actual style properties.
+     *
+     * @return string The serialized style
+     */
+    public function serialize()
+    {
+        // In order to be able to properly compare style, set static ID value
+        $currentId = $this->id;
+        $this->setId(0);
+
+        $serializedStyle = serialize($this);
+
+        $this->setId($currentId);
+
+        return $serializedStyle;
+    }
+
+    /**
+     * Merges the current style with the given style, using the given style as a base. This means that:
+     *   - if current style and base style both have property A set, use current style property's value
+     *   - if current style has property A set but base style does not, use current style property's value
+     *   - if base style has property A set but current style does not, use base style property's value
+     *
+     * @NOTE: This function returns a new style.
+     *
+     * @param Style $baseStyle
+     * @return Style New style corresponding to the merge of the 2 styles
+     */
+    public function mergeWith($baseStyle)
+    {
+        $mergedStyle = clone $this;
+
+        $this->mergeFontStyles($mergedStyle, $baseStyle);
+        $this->mergeOtherFontProperties($mergedStyle, $baseStyle);
+        $this->mergeCellProperties($mergedStyle, $baseStyle);
+
+        return $mergedStyle;
+    }
+
+    /**
+     * @param Style $styleToUpdate (passed as reference)
+     * @param Style $baseStyle
+     * @return void
+     */
+    private function mergeFontStyles($styleToUpdate, $baseStyle)
+    {
+        if (!$this->hasSetFontBold && $baseStyle->isFontBold()) {
+            $styleToUpdate->setFontBold();
+        }
+        if (!$this->hasSetFontItalic && $baseStyle->isFontItalic()) {
+            $styleToUpdate->setFontItalic();
+        }
+        if (!$this->hasSetFontUnderline && $baseStyle->isFontUnderline()) {
+            $styleToUpdate->setFontUnderline();
+        }
+        if (!$this->hasSetFontStrikethrough && $baseStyle->isFontStrikethrough()) {
+            $styleToUpdate->setFontStrikethrough();
+        }
+    }
+
+    /**
+     * @param Style $styleToUpdate Style to update (passed as reference)
+     * @param Style $baseStyle
+     * @return void
+     */
+    private function mergeOtherFontProperties($styleToUpdate, $baseStyle)
+    {
+        if (!$this->hasSetFontSize && $baseStyle->getFontSize() !== self::DEFAULT_FONT_SIZE) {
+            $styleToUpdate->setFontSize($baseStyle->getFontSize());
+        }
+        if (!$this->hasSetFontColor && $baseStyle->getFontColor() !== self::DEFAULT_FONT_COLOR) {
+            $styleToUpdate->setFontColor($baseStyle->getFontColor());
+        }
+        if (!$this->hasSetFontName && $baseStyle->getFontName() !== self::DEFAULT_FONT_NAME) {
+            $styleToUpdate->setFontName($baseStyle->getFontName());
+        }
+    }
+
+    /**
+     * @param Style $styleToUpdate Style to update (passed as reference)
+     * @param Style $baseStyle
+     * @return void
+     */
+    private function mergeCellProperties($styleToUpdate, $baseStyle)
+    {
+        if (!$this->hasSetWrapText && $baseStyle->shouldWrapText()) {
+            $styleToUpdate->setShouldWrapText();
+        }
+        if (!$this->getBorder() && $baseStyle->shouldApplyBorder()) {
+            $styleToUpdate->setBorder($baseStyle->getBorder());
+        }
+        if (!$this->hasSetBackgroundColor && $baseStyle->shouldApplyBackgroundColor()) {
+            $styleToUpdate->setBackgroundColor($baseStyle->getBackgroundColor());
+        }
+    }
+}

modules/x13import/tools/Spout/Writer/Style/StyleBuilder.php

@@ -0,0 +1,159 @@
+<?php
+
+namespace Box\Spout\Writer\Style;
+
+/**
+ * Class StyleBuilder
+ * Builder to create new styles
+ *
+ * @package Box\Spout\Writer\Style
+ */
+class StyleBuilder
+{
+    /** @var Style Style to be created */
+    protected $style;
+
+    /**
+     *
+     */
+    public function __construct()
+    {
+        $this->style = new Style();
+    }
+
+    /**
+     * Makes the font bold.
+     *
+     * @api
+     * @return StyleBuilder
+     */
+    public function setFontBold()
+    {
+        $this->style->setFontBold();
+        return $this;
+    }
+
+    /**
+     * Makes the font italic.
+     *
+     * @api
+     * @return StyleBuilder
+     */
+    public function setFontItalic()
+    {
+        $this->style->setFontItalic();
+        return $this;
+    }
+
+    /**
+     * Makes the font underlined.
+     *
+     * @api
+     * @return StyleBuilder
+     */
+    public function setFontUnderline()
+    {
+        $this->style->setFontUnderline();
+        return $this;
+    }
+
+    /**
+     * Makes the font struck through.
+     *
+     * @api
+     * @return StyleBuilder
+     */
+    public function setFontStrikethrough()
+    {
+        $this->style->setFontStrikethrough();
+        return $this;
+    }
+
+    /**
+     * Sets the font size.
+     *
+     * @api
+     * @param int $fontSize Font size, in pixels
+     * @return StyleBuilder
+     */
+    public function setFontSize($fontSize)
+    {
+        $this->style->setFontSize($fontSize);
+        return $this;
+    }
+
+    /**
+     * Sets the font color.
+     *
+     * @api
+     * @param string $fontColor ARGB color (@see Color)
+     * @return StyleBuilder
+     */
+    public function setFontColor($fontColor)
+    {
+        $this->style->setFontColor($fontColor);
+        return $this;
+    }
+
+    /**
+     * Sets the font name.
+     *
+     * @api
+     * @param string $fontName Name of the font to use
+     * @return StyleBuilder
+     */
+    public function setFontName($fontName)
+    {
+        $this->style->setFontName($fontName);
+        return $this;
+    }
+
+    /**
+     * Makes the text wrap in the cell if requested
+     *
+     * @api
+     * @param bool $shouldWrap Should the text be wrapped
+     * @return StyleBuilder
+     */
+    public function setShouldWrapText($shouldWrap = true)
+    {
+        $this->style->setShouldWrapText($shouldWrap);
+        return $this;
+    }
+
+    /**
+     * Set a border
+     *
+     * @param Border $border
+     * @return $this
+     */
+    public function setBorder(Border $border)
+    {
+        $this->style->setBorder($border);
+        return $this;
+    }
+
+    /**
+     *  Sets a background color
+     *
+     * @api
+     * @param string $color ARGB color (@see Color)
+     * @return StyleBuilder
+     */
+    public function setBackgroundColor($color)
+    {
+        $this->style->setBackgroundColor($color);
+        return $this;
+    }
+
+    /**
+     * Returns the configured style. The style is cached and can be reused.
+     *
+     * @api
+     * @return Style
+     */
+    public function build()
+    {
+        return $this->style;
+    }
+}

modules/x13import/tools/Spout/Writer/WriterFactory.php

@@ -0,0 +1,48 @@
+<?php
+
+namespace Box\Spout\Writer;
+
+use Box\Spout\Common\Exception\UnsupportedTypeException;
+use Box\Spout\Common\Helper\GlobalFunctionsHelper;
+use Box\Spout\Common\Type;
+
+/**
+ * Class WriterFactory
+ * This factory is used to create writers, based on the type of the file to be read.
+ * It supports CSV, XLSX and ODS formats.
+ *
+ * @package Box\Spout\Writer
+ */
+class WriterFactory
+{
+    /**
+     * This creates an instance of the appropriate writer, given the type of the file to be read
+     *
+     * @api
+     * @param  string $writerType Type of the writer to instantiate
+     * @return WriterInterface
+     * @throws \Box\Spout\Common\Exception\UnsupportedTypeException
+     */
+    public static function create($writerType)
+    {
+        $writer = null;
+
+        switch ($writerType) {
+            case Type::CSV:
+                $writer = new CSV\Writer();
+                break;
+            case Type::XLSX:
+                $writer = new XLSX\Writer();
+                break;
+            case Type::ODS:
+                $writer = new ODS\Writer();
+                break;
+            default:
+                throw new UnsupportedTypeException('No writers supporting the given type: ' . $writerType);
+        }
+
+        $writer->setGlobalFunctionsHelper(new GlobalFunctionsHelper());
+
+        return $writer;
+    }
+}

modules/x13import/tools/Spout/Writer/WriterInterface.php

@@ -0,0 +1,91 @@
+<?php
+
+namespace Box\Spout\Writer;
+
+/**
+ * Interface WriterInterface
+ *
+ * @package Box\Spout\Writer
+ */
+interface WriterInterface
+{
+    /**
+     * Inits the writer and opens it to accept data.
+     * By using this method, the data will be written to a file.
+     *
+     * @param  string $outputFilePath Path of the output file that will contain the data
+     * @return WriterInterface
+     * @throws \Box\Spout\Common\Exception\IOException If the writer cannot be opened or if the given path is not writable
+     */
+    public function openToFile($outputFilePath);
+
+    /**
+     * Inits the writer and opens it to accept data.
+     * By using this method, the data will be outputted directly to the browser.
+     *
+     * @param  string $outputFileName Name of the output file that will contain the data. If a path is passed in, only the file name will be kept
+     * @return WriterInterface
+     * @throws \Box\Spout\Common\Exception\IOException If the writer cannot be opened
+     */
+    public function openToBrowser($outputFileName);
+
+    /**
+     * Write given data to the output. New data will be appended to end of stream.
+     *
+     * @param  array $dataRow Array containing data to be streamed.
+     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
+     * @return WriterInterface
+     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If the writer has not been opened yet
+     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
+     */
+    public function addRow(array $dataRow);
+
+    /**
+     * Write given data to the output and apply the given style.
+     * @see addRow
+     *
+     * @param array $dataRow Array of array containing data to be streamed.
+     * @param Style\Style $style Style to be applied to the row.
+     * @return WriterInterface
+     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If the input param is not valid
+     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If this function is called before opening the writer
+     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
+     */
+    public function addRowWithStyle(array $dataRow, $style);
+
+    /**
+     * Write given data to the output. New data will be appended to end of stream.
+     *
+     * @param  array $dataRows Array of array containing data to be streamed.
+     *          Example $dataRow = [
+     *              ['data11', 12, , '', 'data13'],
+     *              ['data21', 'data22', null],
+     *          ];
+     * @return WriterInterface
+     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If the input param is not valid
+     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If the writer has not been opened yet
+     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
+     */
+    public function addRows(array $dataRows);
+
+    /**
+     * Write given data to the output and apply the given style.
+     * @see addRows
+     *
+     * @param array $dataRows Array of array containing data to be streamed.
+     * @param Style\Style $style Style to be applied to the rows.
+     * @return WriterInterface
+     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If the input param is not valid
+     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If this function is called before opening the writer
+     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
+     */
+    public function addRowsWithStyle(array $dataRows, $style);
+
+    /**
+     * Closes the writer. This will close the streamer as well, preventing new data
+     * to be written to the file.
+     *
+     * @return void
+     */
+    public function close();
+}

modules/x13import/tools/Spout/Writer/XLSX/Helper/BorderHelper.php

@@ -0,0 +1,68 @@
+<?php
+
+namespace Box\Spout\Writer\XLSX\Helper;
+
+use Box\Spout\Writer\Style\Border;
+use Box\Spout\Writer\Style\BorderPart;
+
+class BorderHelper
+{
+    public static $xlsxStyleMap = [
+        Border::STYLE_SOLID => [
+            Border::WIDTH_THIN => 'thin',
+            Border::WIDTH_MEDIUM => 'medium',
+            Border::WIDTH_THICK => 'thick'
+        ],
+        Border::STYLE_DOTTED => [
+            Border::WIDTH_THIN => 'dotted',
+            Border::WIDTH_MEDIUM => 'dotted',
+            Border::WIDTH_THICK => 'dotted',
+        ],
+        Border::STYLE_DASHED => [
+            Border::WIDTH_THIN => 'dashed',
+            Border::WIDTH_MEDIUM => 'mediumDashed',
+            Border::WIDTH_THICK => 'mediumDashed',
+        ],
+        Border::STYLE_DOUBLE => [
+            Border::WIDTH_THIN => 'double',
+            Border::WIDTH_MEDIUM => 'double',
+            Border::WIDTH_THICK => 'double',
+        ],
+        Border::STYLE_NONE => [
+            Border::WIDTH_THIN => 'none',
+            Border::WIDTH_MEDIUM => 'none',
+            Border::WIDTH_THICK => 'none',
+        ],
+    ];
+
+    /**
+     * @param BorderPart $borderPart
+     * @return string
+     */
+    public static function serializeBorderPart(BorderPart $borderPart)
+    {
+        $borderStyle = self::getBorderStyle($borderPart);
+
+        $colorEl = $borderPart->getColor() ? sprintf('<color rgb="%s"/>', $borderPart->getColor()) : '';
+        $partEl = sprintf(
+            '<%s style="%s">%s</%s>',
+            $borderPart->getName(),
+            $borderStyle,
+            $colorEl,
+            $borderPart->getName()
+        );
+
+        return $partEl . PHP_EOL;
+    }
+
+    /**
+     * Get the style definition from the style map
+     *
+     * @param BorderPart $borderPart
+     * @return string
+     */
+    protected static function getBorderStyle(BorderPart $borderPart)
+    {
+        return self::$xlsxStyleMap[$borderPart->getStyle()][$borderPart->getWidth()];
+    }
+}

modules/x13import/tools/Spout/Writer/XLSX/Helper/FileSystemHelper.php

@@ -0,0 +1,371 @@
+<?php
+
+namespace Box\Spout\Writer\XLSX\Helper;
+
+use Box\Spout\Writer\Common\Helper\ZipHelper;
+use Box\Spout\Writer\XLSX\Internal\Worksheet;
+
+/**
+ * Class FileSystemHelper
+ * This class provides helper functions to help with the file system operations
+ * like files/folders creation & deletion for XLSX files
+ *
+ * @package Box\Spout\Writer\XLSX\Helper
+ */
+class FileSystemHelper extends \Box\Spout\Common\Helper\FileSystemHelper
+{
+    const APP_NAME = 'Spout';
+
+    const RELS_FOLDER_NAME = '_rels';
+    const DOC_PROPS_FOLDER_NAME = 'docProps';
+    const XL_FOLDER_NAME = 'xl';
+    const WORKSHEETS_FOLDER_NAME = 'worksheets';
+
+    const RELS_FILE_NAME = '.rels';
+    const APP_XML_FILE_NAME = 'app.xml';
+    const CORE_XML_FILE_NAME = 'core.xml';
+    const CONTENT_TYPES_XML_FILE_NAME = '[Content_Types].xml';
+    const WORKBOOK_XML_FILE_NAME = 'workbook.xml';
+    const WORKBOOK_RELS_XML_FILE_NAME = 'workbook.xml.rels';
+    const STYLES_XML_FILE_NAME = 'styles.xml';
+
+    /** @var string Path to the root folder inside the temp folder where the files to create the XLSX will be stored */
+    protected $rootFolder;
+
+    /** @var string Path to the "_rels" folder inside the root folder */
+    protected $relsFolder;
+
+    /** @var string Path to the "docProps" folder inside the root folder */
+    protected $docPropsFolder;
+
+    /** @var string Path to the "xl" folder inside the root folder */
+    protected $xlFolder;
+
+    /** @var string Path to the "_rels" folder inside the "xl" folder */
+    protected $xlRelsFolder;
+
+    /** @var string Path to the "worksheets" folder inside the "xl" folder */
+    protected $xlWorksheetsFolder;
+
+    /**
+     * @return string
+     */
+    public function getRootFolder()
+    {
+        return $this->rootFolder;
+    }
+
+    /**
+     * @return string
+     */
+    public function getXlFolder()
+    {
+        return $this->xlFolder;
+    }
+
+    /**
+     * @return string
+     */
+    public function getXlWorksheetsFolder()
+    {
+        return $this->xlWorksheetsFolder;
+    }
+
+    /**
+     * Creates all the folders needed to create a XLSX file, as well as the files that won't change.
+     *
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create at least one of the base folders
+     */
+    public function createBaseFilesAndFolders()
+    {
+        $this
+            ->createRootFolder()
+            ->createRelsFolderAndFile()
+            ->createDocPropsFolderAndFiles()
+            ->createXlFolderAndSubFolders();
+    }
+
+    /**
+     * Creates the folder that will be used as root
+     *
+     * @return FileSystemHelper
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the folder
+     */
+    protected function createRootFolder()
+    {
+        $this->rootFolder = $this->createFolder($this->baseFolderRealPath, uniqid('xlsx', true));
+        return $this;
+    }
+
+    /**
+     * Creates the "_rels" folder under the root folder as well as the ".rels" file in it
+     *
+     * @return FileSystemHelper
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the folder or the ".rels" file
+     */
+    protected function createRelsFolderAndFile()
+    {
+        $this->relsFolder = $this->createFolder($this->rootFolder, self::RELS_FOLDER_NAME);
+
+        $this->createRelsFile();
+
+        return $this;
+    }
+
+    /**
+     * Creates the ".rels" file under the "_rels" folder (under root)
+     *
+     * @return FileSystemHelper
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the file
+     */
+    protected function createRelsFile()
+    {
+        $relsFileContents = <<<EOD
+<?xml version="1.0" encoding="UTF-8"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+    <Relationship Id="rIdWorkbook" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/officeDocument" Target="xl/workbook.xml"/>
+    <Relationship Id="rIdCore" Type="http://schemas.openxmlformats.org/officedocument/2006/relationships/metadata/core-properties" Target="docProps/core.xml"/>
+    <Relationship Id="rIdApp" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/extended-properties" Target="docProps/app.xml"/>
+</Relationships>
+EOD;
+
+        $this->createFileWithContents($this->relsFolder, self::RELS_FILE_NAME, $relsFileContents);
+
+        return $this;
+    }
+
+    /**
+     * Creates the "docProps" folder under the root folder as well as the "app.xml" and "core.xml" files in it
+     *
+     * @return FileSystemHelper
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the folder or one of the files
+     */
+    protected function createDocPropsFolderAndFiles()
+    {
+        $this->docPropsFolder = $this->createFolder($this->rootFolder, self::DOC_PROPS_FOLDER_NAME);
+
+        $this->createAppXmlFile();
+        $this->createCoreXmlFile();
+
+        return $this;
+    }
+
+    /**
+     * Creates the "app.xml" file under the "docProps" folder
+     *
+     * @return FileSystemHelper
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the file
+     */
+    protected function createAppXmlFile()
+    {
+        $appName = self::APP_NAME;
+        $appXmlFileContents = <<<EOD
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Properties xmlns="http://schemas.openxmlformats.org/officeDocument/2006/extended-properties">
+    <Application>$appName</Application>
+    <TotalTime>0</TotalTime>
+</Properties>
+EOD;
+
+        $this->createFileWithContents($this->docPropsFolder, self::APP_XML_FILE_NAME, $appXmlFileContents);
+
+        return $this;
+    }
+
+    /**
+     * Creates the "core.xml" file under the "docProps" folder
+     *
+     * @return FileSystemHelper
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the file
+     */
+    protected function createCoreXmlFile()
+    {
+        $createdDate = (new \DateTime())->format(\DateTime::W3C);
+        $coreXmlFileContents = <<<EOD
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<cp:coreProperties xmlns:cp="http://schemas.openxmlformats.org/package/2006/metadata/core-properties" xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:dcmitype="http://purl.org/dc/dcmitype/" xmlns:dcterms="http://purl.org/dc/terms/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance">
+    <dcterms:created xsi:type="dcterms:W3CDTF">$createdDate</dcterms:created>
+    <dcterms:modified xsi:type="dcterms:W3CDTF">$createdDate</dcterms:modified>
+    <cp:revision>0</cp:revision>
+</cp:coreProperties>
+EOD;
+
+        $this->createFileWithContents($this->docPropsFolder, self::CORE_XML_FILE_NAME, $coreXmlFileContents);
+
+        return $this;
+    }
+
+    /**
+     * Creates the "xl" folder under the root folder as well as its subfolders
+     *
+     * @return FileSystemHelper
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create at least one of the folders
+     */
+    protected function createXlFolderAndSubFolders()
+    {
+        $this->xlFolder = $this->createFolder($this->rootFolder, self::XL_FOLDER_NAME);
+        $this->createXlRelsFolder();
+        $this->createXlWorksheetsFolder();
+
+        return $this;
+    }
+
+    /**
+     * Creates the "_rels" folder under the "xl" folder
+     *
+     * @return FileSystemHelper
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the folder
+     */
+    protected function createXlRelsFolder()
+    {
+        $this->xlRelsFolder = $this->createFolder($this->xlFolder, self::RELS_FOLDER_NAME);
+        return $this;
+    }
+
+    /**
+     * Creates the "worksheets" folder under the "xl" folder
+     *
+     * @return FileSystemHelper
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create the folder
+     */
+    protected function createXlWorksheetsFolder()
+    {
+        $this->xlWorksheetsFolder = $this->createFolder($this->xlFolder, self::WORKSHEETS_FOLDER_NAME);
+        return $this;
+    }
+
+    /**
+     * Creates the "[Content_Types].xml" file under the root folder
+     *
+     * @param Worksheet[] $worksheets
+     * @return FileSystemHelper
+     */
+    public function createContentTypesFile($worksheets)
+    {
+        $contentTypesXmlFileContents = <<<EOD
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+    <Default ContentType="application/xml" Extension="xml"/>
+    <Default ContentType="application/vnd.openxmlformats-package.relationships+xml" Extension="rels"/>
+    <Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sheet.main+xml" PartName="/xl/workbook.xml"/>
+EOD;
+
+    /** @var Worksheet $worksheet */
+    foreach ($worksheets as $worksheet) {
+        $contentTypesXmlFileContents .= '<Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.worksheet+xml" PartName="/xl/worksheets/sheet' . $worksheet->getId() . '.xml"/>';
+    }
+
+    $contentTypesXmlFileContents .= <<<EOD
+    <Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.styles+xml" PartName="/xl/styles.xml"/>
+    <Override ContentType="application/vnd.openxmlformats-officedocument.spreadsheetml.sharedStrings+xml" PartName="/xl/sharedStrings.xml"/>
+    <Override ContentType="application/vnd.openxmlformats-package.core-properties+xml" PartName="/docProps/core.xml"/>
+    <Override ContentType="application/vnd.openxmlformats-officedocument.extended-properties+xml" PartName="/docProps/app.xml"/>
+</Types>
+EOD;
+
+        $this->createFileWithContents($this->rootFolder, self::CONTENT_TYPES_XML_FILE_NAME, $contentTypesXmlFileContents);
+
+        return $this;
+    }
+
+    /**
+     * Creates the "workbook.xml" file under the "xl" folder
+     *
+     * @param Worksheet[] $worksheets
+     * @return FileSystemHelper
+     */
+    public function createWorkbookFile($worksheets)
+    {
+        $workbookXmlFileContents = <<<EOD
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<workbook xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+    <sheets>
+EOD;
+
+        /** @noinspection PhpUnnecessaryFullyQualifiedNameInspection */
+        $escaper = \Box\Spout\Common\Escaper\XLSX::getInstance();
+
+        /** @var Worksheet $worksheet */
+        foreach ($worksheets as $worksheet) {
+            $worksheetName = $worksheet->getExternalSheet()->getName();
+            $worksheetId = $worksheet->getId();
+            $workbookXmlFileContents .= '<sheet name="' . $escaper->escape($worksheetName) . '" sheetId="' . $worksheetId . '" r:id="rIdSheet' . $worksheetId . '"/>';
+        }
+
+        $workbookXmlFileContents .= <<<EOD
+    </sheets>
+</workbook>
+EOD;
+
+        $this->createFileWithContents($this->xlFolder, self::WORKBOOK_XML_FILE_NAME, $workbookXmlFileContents);
+
+        return $this;
+    }
+
+    /**
+     * Creates the "workbook.xml.res" file under the "xl/_res" folder
+     *
+     * @param Worksheet[] $worksheets
+     * @return FileSystemHelper
+     */
+    public function createWorkbookRelsFile($worksheets)
+    {
+        $workbookRelsXmlFileContents = <<<EOD
+<?xml version="1.0" encoding="UTF-8"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+    <Relationship Id="rIdStyles" Target="styles.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/styles"/>
+    <Relationship Id="rIdSharedStrings" Target="sharedStrings.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/sharedStrings"/>
+EOD;
+
+        /** @var Worksheet $worksheet */
+        foreach ($worksheets as $worksheet) {
+            $worksheetId = $worksheet->getId();
+            $workbookRelsXmlFileContents .= '<Relationship Id="rIdSheet' . $worksheetId . '" Target="worksheets/sheet' . $worksheetId . '.xml" Type="http://schemas.openxmlformats.org/officeDocument/2006/relationships/worksheet"/>';
+        }
+
+        $workbookRelsXmlFileContents .= '</Relationships>';
+
+        $this->createFileWithContents($this->xlRelsFolder, self::WORKBOOK_RELS_XML_FILE_NAME, $workbookRelsXmlFileContents);
+
+        return $this;
+    }
+
+    /**
+     * Creates the "styles.xml" file under the "xl" folder
+     *
+     * @param StyleHelper $styleHelper
+     * @return FileSystemHelper
+     */
+    public function createStylesFile($styleHelper)
+    {
+        $stylesXmlFileContents = $styleHelper->getStylesXMLFileContent();
+        $this->createFileWithContents($this->xlFolder, self::STYLES_XML_FILE_NAME, $stylesXmlFileContents);
+
+        return $this;
+    }
+
+    /**
+     * Zips the root folder and streams the contents of the zip into the given stream
+     *
+     * @param resource $streamPointer Pointer to the stream to copy the zip
+     * @return void
+     */
+    public function zipRootFolderAndCopyToStream($streamPointer)
+    {
+        $zipHelper = new ZipHelper($this->rootFolder);
+
+        // In order to have the file's mime type detected properly, files need to be added
+        // to the zip file in a particular order.
+        // "[Content_Types].xml" then at least 2 files located in "xl" folder should be zipped first.
+        $zipHelper->addFileToArchive($this->rootFolder, self::CONTENT_TYPES_XML_FILE_NAME);
+        $zipHelper->addFileToArchive($this->rootFolder, self::XL_FOLDER_NAME . '/' . self::WORKBOOK_XML_FILE_NAME);
+        $zipHelper->addFileToArchive($this->rootFolder, self::XL_FOLDER_NAME . '/' . self::STYLES_XML_FILE_NAME);
+
+        $zipHelper->addFolderToArchive($this->rootFolder, ZipHelper::EXISTING_FILES_SKIP);
+        $zipHelper->closeArchiveAndCopyToStream($streamPointer);
+
+        // once the zip is copied, remove it
+        $this->deleteFile($zipHelper->getZipFilePath());
+    }
+}

modules/x13import/tools/Spout/Writer/XLSX/Helper/SharedStringsHelper.php

@@ -0,0 +1,107 @@
+<?php
+
+namespace Box\Spout\Writer\XLSX\Helper;
+
+use Box\Spout\Common\Exception\IOException;
+
+/**
+ * Class SharedStringsHelper
+ * This class provides helper functions to write shared strings
+ *
+ * @package Box\Spout\Writer\XLSX\Helper
+ */
+class SharedStringsHelper
+{
+    const SHARED_STRINGS_FILE_NAME = 'sharedStrings.xml';
+
+    const SHARED_STRINGS_XML_FILE_FIRST_PART_HEADER = <<<EOD
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<sst xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main"
+EOD;
+
+    /**
+     * This number must be really big so that the no generated file will have more strings than that.
+     * If the strings number goes above, characters will be overwritten in an unwanted way and will corrupt the file.
+     */
+    const DEFAULT_STRINGS_COUNT_PART = 'count="9999999999999" uniqueCount="9999999999999"';
+
+    /** @var resource Pointer to the sharedStrings.xml file */
+    protected $sharedStringsFilePointer;
+
+    /** @var int Number of shared strings already written */
+    protected $numSharedStrings = 0;
+
+    /** @var \Box\Spout\Common\Escaper\XLSX Strings escaper */
+    protected $stringsEscaper;
+
+    /**
+     * @param string $xlFolder Path to the "xl" folder
+     */
+    public function __construct($xlFolder)
+    {
+        $sharedStringsFilePath = $xlFolder . '/' . self::SHARED_STRINGS_FILE_NAME;
+        $this->sharedStringsFilePointer = fopen($sharedStringsFilePath, 'w');
+
+        $this->throwIfSharedStringsFilePointerIsNotAvailable();
+
+        // the headers is split into different parts so that we can fseek and put in the correct count and uniqueCount later
+        $header = self::SHARED_STRINGS_XML_FILE_FIRST_PART_HEADER . ' ' . self::DEFAULT_STRINGS_COUNT_PART . '>';
+        fwrite($this->sharedStringsFilePointer, $header);
+
+        /** @noinspection PhpUnnecessaryFullyQualifiedNameInspection */
+        $this->stringsEscaper = \Box\Spout\Common\Escaper\XLSX::getInstance();
+    }
+
+    /**
+     * Checks if the book has been created. Throws an exception if not created yet.
+     *
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If the sheet data file cannot be opened for writing
+     */
+    protected function throwIfSharedStringsFilePointerIsNotAvailable()
+    {
+        if (!$this->sharedStringsFilePointer) {
+            throw new IOException('Unable to open shared strings file for writing.');
+        }
+    }
+
+    /**
+     * Writes the given string into the sharedStrings.xml file.
+     * Starting and ending whitespaces are preserved.
+     *
+     * @param string $string
+     * @return int ID of the written shared string
+     */
+    public function writeString($string)
+    {
+        fwrite($this->sharedStringsFilePointer, '<si><t xml:space="preserve">' . $this->stringsEscaper->escape($string) . '</t></si>');
+        $this->numSharedStrings++;
+
+        // Shared string ID is zero-based
+        return ($this->numSharedStrings - 1);
+    }
+
+    /**
+     * Finishes writing the data in the sharedStrings.xml file and closes the file.
+     *
+     * @return void
+     */
+    public function close()
+    {
+        if (!is_resource($this->sharedStringsFilePointer)) {
+            return;
+        }
+
+        fwrite($this->sharedStringsFilePointer, '</sst>');
+
+        // Replace the default strings count with the actual number of shared strings in the file header
+        $firstPartHeaderLength = strlen(self::SHARED_STRINGS_XML_FILE_FIRST_PART_HEADER);
+        $defaultStringsCountPartLength = strlen(self::DEFAULT_STRINGS_COUNT_PART);
+
+        // Adding 1 to take into account the space between the last xml attribute and "count"
+        fseek($this->sharedStringsFilePointer, $firstPartHeaderLength + 1);
+        fwrite($this->sharedStringsFilePointer, sprintf("%-{$defaultStringsCountPartLength}s", 'count="' . $this->numSharedStrings . '" uniqueCount="' . $this->numSharedStrings . '"'));
+
+        fclose($this->sharedStringsFilePointer);
+    }
+}

modules/x13import/tools/Spout/Writer/XLSX/Helper/StyleHelper.php

@@ -0,0 +1,344 @@
+<?php
+
+namespace Box\Spout\Writer\XLSX\Helper;
+
+use Box\Spout\Writer\Common\Helper\AbstractStyleHelper;
+use Box\Spout\Writer\Style\Color;
+use Box\Spout\Writer\Style\Style;
+
+/**
+ * Class StyleHelper
+ * This class provides helper functions to manage styles
+ *
+ * @package Box\Spout\Writer\XLSX\Helper
+ */
+class StyleHelper extends AbstractStyleHelper
+{
+    /**
+     * @var array
+     */
+    protected $registeredFills = [];
+
+    /**
+     * @var array [STYLE_ID] => [FILL_ID] maps a style to a fill declaration
+     */
+    protected $styleIdToFillMappingTable = [];
+
+    /**
+     * Excel preserves two default fills with index 0 and 1
+     * Since Excel is the dominant vendor - we play along here
+     *
+     * @var int The fill index counter for custom fills.
+     */
+    protected $fillIndex = 2;
+
+    /**
+     * @var array
+     */
+    protected $registeredBorders = [];
+
+    /**
+     * @var array [STYLE_ID] => [BORDER_ID] maps a style to a border declaration
+     */
+    protected $styleIdToBorderMappingTable = [];
+
+    /**
+     * XLSX specific operations on the registered styles
+     *
+     * @param \Box\Spout\Writer\Style\Style $style
+     * @return \Box\Spout\Writer\Style\Style
+     */
+    public function registerStyle($style)
+    {
+        $registeredStyle = parent::registerStyle($style);
+        $this->registerFill($registeredStyle);
+        $this->registerBorder($registeredStyle);
+        return $registeredStyle;
+    }
+
+    /**
+     * Register a fill definition
+     *
+     * @param \Box\Spout\Writer\Style\Style $style
+     */
+    protected function registerFill($style)
+    {
+        $styleId = $style->getId();
+
+        // Currently - only solid backgrounds are supported
+        // so $backgroundColor is a scalar value (RGB Color)
+        $backgroundColor = $style->getBackgroundColor();
+
+        if ($backgroundColor) {
+            $isBackgroundColorRegistered = isset($this->registeredFills[$backgroundColor]);
+
+            // We need to track the already registered background definitions
+            if ($isBackgroundColorRegistered) {
+                $registeredStyleId = $this->registeredFills[$backgroundColor];
+                $registeredFillId = $this->styleIdToFillMappingTable[$registeredStyleId];
+                $this->styleIdToFillMappingTable[$styleId] = $registeredFillId;
+            } else {
+                $this->registeredFills[$backgroundColor] = $styleId;
+                $this->styleIdToFillMappingTable[$styleId] = $this->fillIndex++;
+            }
+
+        } else {
+            // The fillId maps a style to a fill declaration
+            // When there is no background color definition - we default to 0
+            $this->styleIdToFillMappingTable[$styleId] = 0;
+        }
+    }
+
+    /**
+     * Register a border definition
+     *
+     * @param \Box\Spout\Writer\Style\Style $style
+     */
+    protected function registerBorder($style)
+    {
+        $styleId = $style->getId();
+
+        if ($style->shouldApplyBorder()) {
+            $border = $style->getBorder();
+            $serializedBorder = serialize($border);
+
+            $isBorderAlreadyRegistered = isset($this->registeredBorders[$serializedBorder]);
+
+            if ($isBorderAlreadyRegistered) {
+                $registeredStyleId = $this->registeredBorders[$serializedBorder];
+                $registeredBorderId = $this->styleIdToBorderMappingTable[$registeredStyleId];
+                $this->styleIdToBorderMappingTable[$styleId] = $registeredBorderId;
+            } else {
+                $this->registeredBorders[$serializedBorder] = $styleId;
+                $this->styleIdToBorderMappingTable[$styleId] = count($this->registeredBorders);
+            }
+
+        } else {
+            // If no border should be applied - the mapping is the default border: 0
+            $this->styleIdToBorderMappingTable[$styleId] = 0;
+        }
+    }
+
+
+    /**
+     * For empty cells, we can specify a style or not. If no style are specified,
+     * then the software default will be applied. But sometimes, it may be useful
+     * to override this default style, for instance if the cell should have a
+     * background color different than the default one or some borders
+     * (fonts property don't really matter here).
+     *
+     * @param int $styleId
+     * @return bool Whether the cell should define a custom style
+     */
+    public function shouldApplyStyleOnEmptyCell($styleId)
+    {
+        $hasStyleCustomFill = (isset($this->styleIdToFillMappingTable[$styleId]) && $this->styleIdToFillMappingTable[$styleId] !== 0);
+        $hasStyleCustomBorders = (isset($this->styleIdToBorderMappingTable[$styleId]) && $this->styleIdToBorderMappingTable[$styleId] !== 0);
+
+        return ($hasStyleCustomFill || $hasStyleCustomBorders);
+    }
+
+
+    /**
+     * Returns the content of the "styles.xml" file, given a list of styles.
+     *
+     * @return string
+     */
+    public function getStylesXMLFileContent()
+    {
+        $content = <<<EOD
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<styleSheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main">
+EOD;
+
+        $content .= $this->getFontsSectionContent();
+        $content .= $this->getFillsSectionContent();
+        $content .= $this->getBordersSectionContent();
+        $content .= $this->getCellStyleXfsSectionContent();
+        $content .= $this->getCellXfsSectionContent();
+        $content .= $this->getCellStylesSectionContent();
+
+        $content .= <<<EOD
+</styleSheet>
+EOD;
+
+        return $content;
+    }
+
+    /**
+     * Returns the content of the "<fonts>" section.
+     *
+     * @return string
+     */
+    protected function getFontsSectionContent()
+    {
+        $content = '<fonts count="' . count($this->styleIdToStyleMappingTable) . '">';
+
+        /** @var \Box\Spout\Writer\Style\Style $style */
+        foreach ($this->getRegisteredStyles() as $style) {
+            $content .= '<font>';
+
+            $content .= '<sz val="' . $style->getFontSize() . '"/>';
+            $content .= '<color rgb="' . Color::toARGB($style->getFontColor()) . '"/>';
+            $content .= '<name val="' . $style->getFontName() . '"/>';
+
+            if ($style->isFontBold()) {
+                $content .= '<b/>';
+            }
+            if ($style->isFontItalic()) {
+                $content .= '<i/>';
+            }
+            if ($style->isFontUnderline()) {
+                $content .= '<u/>';
+            }
+            if ($style->isFontStrikethrough()) {
+                $content .= '<strike/>';
+            }
+
+            $content .= '</font>';
+        }
+
+        $content .= '</fonts>';
+
+        return $content;
+    }
+
+    /**
+     * Returns the content of the "<fills>" section.
+     *
+     * @return string
+     */
+    protected function getFillsSectionContent()
+    {
+        // Excel reserves two default fills
+        $fillsCount = count($this->registeredFills) + 2;
+        $content = sprintf('<fills count="%d">', $fillsCount);
+
+        $content .= '<fill><patternFill patternType="none"/></fill>';
+        $content .= '<fill><patternFill patternType="gray125"/></fill>';
+
+        // The other fills are actually registered by setting a background color
+        foreach ($this->registeredFills as $styleId) {
+            /** @var Style $style */
+            $style = $this->styleIdToStyleMappingTable[$styleId];
+
+            $backgroundColor = $style->getBackgroundColor();
+            $content .= sprintf(
+                '<fill><patternFill patternType="solid"><fgColor rgb="%s"/></patternFill></fill>',
+                $backgroundColor
+            );
+        }
+
+        $content .= '</fills>';
+
+        return $content;
+    }
+
+    /**
+     * Returns the content of the "<borders>" section.
+     *
+     * @return string
+     */
+    protected function getBordersSectionContent()
+    {
+
+        // There is one default border with index 0
+        $borderCount = count($this->registeredBorders) + 1;
+
+        $content = '<borders count="' . $borderCount . '">';
+
+        // Default border starting at index 0
+        $content .= '<border><left/><right/><top/><bottom/></border>';
+
+        foreach ($this->registeredBorders as $styleId) {
+            /** @var \Box\Spout\Writer\Style\Style $style */
+            $style = $this->styleIdToStyleMappingTable[$styleId];
+            $border = $style->getBorder();
+            $content .= '<border>';
+
+            // @link https://github.com/box/spout/issues/271
+            $sortOrder = ['left', 'right', 'top', 'bottom'];
+
+            foreach ($sortOrder as $partName) {
+                if ($border->hasPart($partName)) {
+                    /** @var $part \Box\Spout\Writer\Style\BorderPart */
+                    $part = $border->getPart($partName);
+                    $content .= BorderHelper::serializeBorderPart($part);
+                }
+
+            }
+
+            $content .= '</border>';
+        }
+
+        $content .= '</borders>';
+
+        return $content;
+    }
+
+    /**
+     * Returns the content of the "<cellStyleXfs>" section.
+     *
+     * @return string
+     */
+    protected function getCellStyleXfsSectionContent()
+    {
+        return <<<EOD
+<cellStyleXfs count="1">
+    <xf borderId="0" fillId="0" fontId="0" numFmtId="0"/>
+</cellStyleXfs>
+EOD;
+    }
+
+    /**
+     * Returns the content of the "<cellXfs>" section.
+     *
+     * @return string
+     */
+    protected function getCellXfsSectionContent()
+    {
+        $registeredStyles = $this->getRegisteredStyles();
+
+        $content = '<cellXfs count="' . count($registeredStyles) . '">';
+
+        foreach ($registeredStyles as $style) {
+            $styleId = $style->getId();
+            $fillId = $this->styleIdToFillMappingTable[$styleId];
+            $borderId = $this->styleIdToBorderMappingTable[$styleId];
+
+            $content .= '<xf numFmtId="0" fontId="' . $styleId . '" fillId="' . $fillId . '" borderId="' . $borderId . '" xfId="0"';
+
+            if ($style->shouldApplyFont()) {
+                $content .= ' applyFont="1"';
+            }
+
+            $content .= sprintf(' applyBorder="%d"', $style->shouldApplyBorder() ? 1 : 0);
+
+            if ($style->shouldWrapText()) {
+                $content .= ' applyAlignment="1">';
+                $content .= '<alignment wrapText="1"/>';
+                $content .= '</xf>';
+            } else {
+                $content .= '/>';
+            }
+        }
+
+        $content .= '</cellXfs>';
+
+        return $content;
+    }
+
+    /**
+     * Returns the content of the "<cellStyles>" section.
+     *
+     * @return string
+     */
+    protected function getCellStylesSectionContent()
+    {
+        return <<<EOD
+<cellStyles count="1">
+    <cellStyle builtinId="0" name="Normal" xfId="0"/>
+</cellStyles>
+EOD;
+    }
+}

modules/x13import/tools/Spout/Writer/XLSX/Internal/Workbook.php

@@ -0,0 +1,135 @@
+<?php
+
+namespace Box\Spout\Writer\XLSX\Internal;
+
+use Box\Spout\Writer\Common\Internal\AbstractWorkbook;
+use Box\Spout\Writer\XLSX\Helper\FileSystemHelper;
+use Box\Spout\Writer\XLSX\Helper\SharedStringsHelper;
+use Box\Spout\Writer\XLSX\Helper\StyleHelper;
+use Box\Spout\Writer\Common\Sheet;
+
+/**
+ * Class Workbook
+ * Represents a workbook within a XLSX file.
+ * It provides the functions to work with worksheets.
+ *
+ * @package Box\Spout\Writer\XLSX\Internal
+ */
+class Workbook extends AbstractWorkbook
+{
+    /**
+     * Maximum number of rows a XLSX sheet can contain
+     * @see http://office.microsoft.com/en-us/excel-help/excel-specifications-and-limits-HP010073849.aspx
+     */
+    protected static $maxRowsPerWorksheet = 1048576;
+
+    /** @var bool Whether inline or shared strings should be used */
+    protected $shouldUseInlineStrings;
+
+    /** @var \Box\Spout\Writer\XLSX\Helper\FileSystemHelper Helper to perform file system operations */
+    protected $fileSystemHelper;
+
+    /** @var \Box\Spout\Writer\XLSX\Helper\SharedStringsHelper Helper to write shared strings */
+    protected $sharedStringsHelper;
+
+    /** @var \Box\Spout\Writer\XLSX\Helper\StyleHelper Helper to apply styles */
+    protected $styleHelper;
+
+    /**
+     * @param string $tempFolder
+     * @param bool $shouldUseInlineStrings
+     * @param bool $shouldCreateNewSheetsAutomatically
+     * @param \Box\Spout\Writer\Style\Style $defaultRowStyle
+     * @throws \Box\Spout\Common\Exception\IOException If unable to create at least one of the base folders
+     */
+    public function __construct($tempFolder, $shouldUseInlineStrings, $shouldCreateNewSheetsAutomatically, $defaultRowStyle)
+    {
+        parent::__construct($shouldCreateNewSheetsAutomatically, $defaultRowStyle);
+
+        $this->shouldUseInlineStrings = $shouldUseInlineStrings;
+
+        $this->fileSystemHelper = new FileSystemHelper($tempFolder);
+        $this->fileSystemHelper->createBaseFilesAndFolders();
+
+        $this->styleHelper = new StyleHelper($defaultRowStyle);
+
+        // This helper will be shared by all sheets
+        $xlFolder = $this->fileSystemHelper->getXlFolder();
+        $this->sharedStringsHelper = new SharedStringsHelper($xlFolder);
+    }
+
+    /**
+     * @return \Box\Spout\Writer\XLSX\Helper\StyleHelper Helper to apply styles to XLSX files
+     */
+    protected function getStyleHelper()
+    {
+        return $this->styleHelper;
+    }
+
+    /**
+     * @return int Maximum number of rows/columns a sheet can contain
+     */
+    protected function getMaxRowsPerWorksheet()
+    {
+        return self::$maxRowsPerWorksheet;
+    }
+
+    /**
+     * Creates a new sheet in the workbook. The current sheet remains unchanged.
+     *
+     * @return Worksheet The created sheet
+     * @throws \Box\Spout\Common\Exception\IOException If unable to open the sheet for writing
+     */
+    public function addNewSheet()
+    {
+        $newSheetIndex = count($this->worksheets);
+        $sheet = new Sheet($newSheetIndex, $this->internalId);
+
+        $worksheetFilesFolder = $this->fileSystemHelper->getXlWorksheetsFolder();
+        $worksheet = new Worksheet($sheet, $worksheetFilesFolder, $this->sharedStringsHelper, $this->styleHelper, $this->shouldUseInlineStrings);
+        $this->worksheets[] = $worksheet;
+
+        return $worksheet;
+    }
+
+    /**
+     * Closes the workbook and all its associated sheets.
+     * All the necessary files are written to disk and zipped together to create the XLSX file.
+     * All the temporary files are then deleted.
+     *
+     * @param resource $finalFilePointer Pointer to the XLSX that will be created
+     * @return void
+     */
+    public function close($finalFilePointer)
+    {
+        /** @var Worksheet[] $worksheets */
+        $worksheets = $this->worksheets;
+
+        foreach ($worksheets as $worksheet) {
+            $worksheet->close();
+        }
+
+        $this->sharedStringsHelper->close();
+
+        // Finish creating all the necessary files before zipping everything together
+        $this->fileSystemHelper
+            ->createContentTypesFile($worksheets)
+            ->createWorkbookFile($worksheets)
+            ->createWorkbookRelsFile($worksheets)
+            ->createStylesFile($this->styleHelper)
+            ->zipRootFolderAndCopyToStream($finalFilePointer);
+
+        $this->cleanupTempFolder();
+    }
+
+    /**
+     * Deletes the root folder created in the temp folder and all its contents.
+     *
+     * @return void
+     */
+    protected function cleanupTempFolder()
+    {
+        $xlsxRootFolder = $this->fileSystemHelper->getRootFolder();
+        $this->fileSystemHelper->deleteFolderRecursively($xlsxRootFolder);
+    }
+}

modules/x13import/tools/Spout/Writer/XLSX/Internal/Worksheet.php

@@ -0,0 +1,275 @@
+<?php
+
+namespace Box\Spout\Writer\XLSX\Internal;
+
+use Box\Spout\Common\Exception\InvalidArgumentException;
+use Box\Spout\Common\Exception\IOException;
+use Box\Spout\Common\Helper\StringHelper;
+use Box\Spout\Writer\Common\Helper\CellHelper;
+use Box\Spout\Writer\Common\Internal\WorksheetInterface;
+
+/**
+ * Class Worksheet
+ * Represents a worksheet within a XLSX file. The difference with the Sheet object is
+ * that this class provides an interface to write data
+ *
+ * @package Box\Spout\Writer\XLSX\Internal
+ */
+class Worksheet implements WorksheetInterface
+{
+    /**
+     * Maximum number of characters a cell can contain
+     * @see https://support.office.com/en-us/article/Excel-specifications-and-limits-16c69c74-3d6a-4aaf-ba35-e6eb276e8eaa [Excel 2007]
+     * @see https://support.office.com/en-us/article/Excel-specifications-and-limits-1672b34d-7043-467e-8e27-269d656771c3 [Excel 2010]
+     * @see https://support.office.com/en-us/article/Excel-specifications-and-limits-ca36e2dc-1f09-4620-b726-67c00b05040f [Excel 2013/2016]
+     */
+    const MAX_CHARACTERS_PER_CELL = 32767;
+
+    const SHEET_XML_FILE_HEADER = <<<EOD
+<?xml version="1.0" encoding="UTF-8" standalone="yes"?>
+<worksheet xmlns="http://schemas.openxmlformats.org/spreadsheetml/2006/main" xmlns:r="http://schemas.openxmlformats.org/officeDocument/2006/relationships">
+EOD;
+
+    /** @var \Box\Spout\Writer\Common\Sheet The "external" sheet */
+    protected $externalSheet;
+
+    /** @var string Path to the XML file that will contain the sheet data */
+    protected $worksheetFilePath;
+
+    /** @var \Box\Spout\Writer\XLSX\Helper\SharedStringsHelper Helper to write shared strings */
+    protected $sharedStringsHelper;
+
+    /** @var \Box\Spout\Writer\XLSX\Helper\StyleHelper Helper to work with styles */
+    protected $styleHelper;
+
+    /** @var bool Whether inline or shared strings should be used */
+    protected $shouldUseInlineStrings;
+
+    /** @var \Box\Spout\Common\Escaper\XLSX Strings escaper */
+    protected $stringsEscaper;
+
+    /** @var \Box\Spout\Common\Helper\StringHelper String helper */
+    protected $stringHelper;
+
+    /** @var Resource Pointer to the sheet data file (e.g. xl/worksheets/sheet1.xml) */
+    protected $sheetFilePointer;
+
+    /** @var int Index of the last written row */
+    protected $lastWrittenRowIndex = 0;
+
+    /**
+     * @param \Box\Spout\Writer\Common\Sheet $externalSheet The associated "external" sheet
+     * @param string $worksheetFilesFolder Temporary folder where the files to create the XLSX will be stored
+     * @param \Box\Spout\Writer\XLSX\Helper\SharedStringsHelper $sharedStringsHelper Helper for shared strings
+     * @param \Box\Spout\Writer\XLSX\Helper\StyleHelper Helper to work with styles
+     * @param bool $shouldUseInlineStrings Whether inline or shared strings should be used
+     * @throws \Box\Spout\Common\Exception\IOException If the sheet data file cannot be opened for writing
+     */
+    public function __construct($externalSheet, $worksheetFilesFolder, $sharedStringsHelper, $styleHelper, $shouldUseInlineStrings)
+    {
+        $this->externalSheet = $externalSheet;
+        $this->sharedStringsHelper = $sharedStringsHelper;
+        $this->styleHelper = $styleHelper;
+        $this->shouldUseInlineStrings = $shouldUseInlineStrings;
+
+        /** @noinspection PhpUnnecessaryFullyQualifiedNameInspection */
+        $this->stringsEscaper = \Box\Spout\Common\Escaper\XLSX::getInstance();
+        $this->stringHelper = new StringHelper();
+
+        $this->worksheetFilePath = $worksheetFilesFolder . '/' . strtolower($this->externalSheet->getName()) . '.xml';
+        $this->startSheet();
+    }
+
+    /**
+     * Prepares the worksheet to accept data
+     *
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If the sheet data file cannot be opened for writing
+     */
+    protected function startSheet()
+    {
+        $this->sheetFilePointer = fopen($this->worksheetFilePath, 'w');
+        $this->throwIfSheetFilePointerIsNotAvailable();
+
+        fwrite($this->sheetFilePointer, self::SHEET_XML_FILE_HEADER);
+        fwrite($this->sheetFilePointer, '<sheetData>');
+    }
+
+    /**
+     * Checks if the book has been created. Throws an exception if not created yet.
+     *
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If the sheet data file cannot be opened for writing
+     */
+    protected function throwIfSheetFilePointerIsNotAvailable()
+    {
+        if (!$this->sheetFilePointer) {
+            throw new IOException('Unable to open sheet for writing.');
+        }
+    }
+
+    /**
+     * @return \Box\Spout\Writer\Common\Sheet The "external" sheet
+     */
+    public function getExternalSheet()
+    {
+        return $this->externalSheet;
+    }
+
+    /**
+     * @return int The index of the last written row
+     */
+    public function getLastWrittenRowIndex()
+    {
+        return $this->lastWrittenRowIndex;
+    }
+
+    /**
+     * @return int The ID of the worksheet
+     */
+    public function getId()
+    {
+        // sheet index is zero-based, while ID is 1-based
+        return $this->externalSheet->getIndex() + 1;
+    }
+
+    /**
+     * Adds data to the worksheet.
+     *
+     * @param array $dataRow Array containing data to be written. Cannot be empty.
+     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
+     * @param \Box\Spout\Writer\Style\Style $style Style to be applied to the row. NULL means use default style.
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If the data cannot be written
+     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If a cell value's type is not supported
+     */
+    public function addRow($dataRow, $style)
+    {
+        if (!$this->isEmptyRow($dataRow)) {
+            $this->addNonEmptyRow($dataRow, $style);
+        }
+
+        $this->lastWrittenRowIndex++;
+    }
+
+    /**
+     * Returns whether the given row is empty
+     *
+     * @param array $dataRow Array containing data to be written. Cannot be empty.
+     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
+     * @return bool Whether the given row is empty
+     */
+    protected function isEmptyRow($dataRow)
+    {
+        $numCells = count($dataRow);
+        // using "reset()" instead of "$dataRow[0]" because $dataRow can be an associative array
+        return ($numCells === 1 && CellHelper::isEmpty(reset($dataRow)));
+    }
+
+    /**
+     * Adds non empty row to the worksheet.
+     *
+     * @param array $dataRow Array containing data to be written. Cannot be empty.
+     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
+     * @param \Box\Spout\Writer\Style\Style $style Style to be applied to the row. NULL means use default style.
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If the data cannot be written
+     * @throws \Box\Spout\Common\Exception\InvalidArgumentException If a cell value's type is not supported
+     */
+    protected function addNonEmptyRow($dataRow, $style)
+    {
+        $cellNumber = 0;
+        $rowIndex = $this->lastWrittenRowIndex + 1;
+        $numCells = count($dataRow);
+
+        $rowXML = '<row r="' . $rowIndex . '" spans="1:' . $numCells . '">';
+
+        foreach($dataRow as $cellValue) {
+            $rowXML .= $this->getCellXML($rowIndex, $cellNumber, $cellValue, $style->getId());
+            $cellNumber++;
+        }
+
+        $rowXML .= '</row>';
+
+        $wasWriteSuccessful = fwrite($this->sheetFilePointer, $rowXML);
+        if ($wasWriteSuccessful === false) {
+            throw new IOException("Unable to write data in {$this->worksheetFilePath}");
+        }
+    }
+
+    /**
+     * Build and return xml for a single cell.
+     *
+     * @param int $rowIndex
+     * @param int $cellNumber
+     * @param mixed $cellValue
+     * @param int $styleId
+     * @return string
+     * @throws InvalidArgumentException If the given value cannot be processed
+     */
+    protected function getCellXML($rowIndex, $cellNumber, $cellValue, $styleId)
+    {
+        $columnIndex = CellHelper::getCellIndexFromColumnIndex($cellNumber);
+        $cellXML = '<c r="' . $columnIndex . $rowIndex . '"';
+        $cellXML .= ' s="' . $styleId . '"';
+
+        if (CellHelper::isNonEmptyString($cellValue)) {
+            $cellXML .= $this->getCellXMLFragmentForNonEmptyString($cellValue);
+        } else if (CellHelper::isBoolean($cellValue)) {
+            $cellXML .= ' t="b"><v>' . intval($cellValue) . '</v></c>';
+        } else if (CellHelper::isNumeric($cellValue)) {
+            $cellXML .= '><v>' . $cellValue . '</v></c>';
+        } else if (empty($cellValue)) {
+            if ($this->styleHelper->shouldApplyStyleOnEmptyCell($styleId)) {
+                $cellXML .= '/>';
+            } else {
+                // don't write empty cells that do no need styling
+                // NOTE: not appending to $cellXML is the right behavior!!
+                $cellXML = '';
+            }
+        } else {
+            throw new InvalidArgumentException('Trying to add a value with an unsupported type: ' . gettype($cellValue));
+        }
+
+        return $cellXML;
+    }
+
+    /**
+     * Returns the XML fragment for a cell containing a non empty string
+     *
+     * @param string $cellValue The cell value
+     * @return string The XML fragment representing the cell
+     * @throws InvalidArgumentException If the string exceeds the maximum number of characters allowed per cell
+     */
+    protected function getCellXMLFragmentForNonEmptyString($cellValue)
+    {
+        if ($this->stringHelper->getStringLength($cellValue) > self::MAX_CHARACTERS_PER_CELL) {
+            throw new InvalidArgumentException('Trying to add a value that exceeds the maximum number of characters allowed in a cell (32,767)');
+        }
+
+        if ($this->shouldUseInlineStrings) {
+            $cellXMLFragment = ' t="inlineStr"><is><t>' . $this->stringsEscaper->escape($cellValue) . '</t></is></c>';
+        } else {
+            $sharedStringId = $this->sharedStringsHelper->writeString($cellValue);
+            $cellXMLFragment = ' t="s"><v>' . $sharedStringId . '</v></c>';
+        }
+
+        return $cellXMLFragment;
+    }
+
+    /**
+     * Closes the worksheet
+     *
+     * @return void
+     */
+    public function close()
+    {
+        if (!is_resource($this->sheetFilePointer)) {
+            return;
+        }
+
+        fwrite($this->sheetFilePointer, '</sheetData>');
+        fwrite($this->sheetFilePointer, '</worksheet>');
+        fclose($this->sheetFilePointer);
+    }
+}

modules/x13import/tools/Spout/Writer/XLSX/Writer.php

@@ -0,0 +1,132 @@
+<?php
+
+namespace Box\Spout\Writer\XLSX;
+
+use Box\Spout\Writer\AbstractMultiSheetsWriter;
+use Box\Spout\Writer\Style\StyleBuilder;
+use Box\Spout\Writer\XLSX\Internal\Workbook;
+
+/**
+ * Class Writer
+ * This class provides base support to write data to XLSX files
+ *
+ * @package Box\Spout\Writer\XLSX
+ */
+class Writer extends AbstractMultiSheetsWriter
+{
+    /** Default style font values */
+    const DEFAULT_FONT_SIZE = 12;
+    const DEFAULT_FONT_NAME = 'Calibri';
+
+    /** @var string Content-Type value for the header */
+    protected static $headerContentType = 'application/vnd.openxmlformats-officedocument.spreadsheetml.sheet';
+
+    /** @var string Temporary folder where the files to create the XLSX will be stored */
+    protected $tempFolder;
+
+    /** @var bool Whether inline or shared strings should be used - inline string is more memory efficient */
+    protected $shouldUseInlineStrings = true;
+
+    /** @var Internal\Workbook The workbook for the XLSX file */
+    protected $book;
+
+    /**
+     * Sets a custom temporary folder for creating intermediate files/folders.
+     * This must be set before opening the writer.
+     *
+     * @api
+     * @param string $tempFolder Temporary folder where the files to create the XLSX will be stored
+     * @return Writer
+     * @throws \Box\Spout\Writer\Exception\WriterAlreadyOpenedException If the writer was already opened
+     */
+    public function setTempFolder($tempFolder)
+    {
+        $this->throwIfWriterAlreadyOpened('Writer must be configured before opening it.');
+
+        $this->tempFolder = $tempFolder;
+        return $this;
+    }
+
+    /**
+     * Use inline string to be more memory efficient. If set to false, it will use shared strings.
+     * This must be set before opening the writer.
+     *
+     * @api
+     * @param bool $shouldUseInlineStrings Whether inline or shared strings should be used
+     * @return Writer
+     * @throws \Box\Spout\Writer\Exception\WriterAlreadyOpenedException If the writer was already opened
+     */
+    public function setShouldUseInlineStrings($shouldUseInlineStrings)
+    {
+        $this->throwIfWriterAlreadyOpened('Writer must be configured before opening it.');
+
+        $this->shouldUseInlineStrings = $shouldUseInlineStrings;
+        return $this;
+    }
+
+    /**
+     * Configures the write and sets the current sheet pointer to a new sheet.
+     *
+     * @return void
+     * @throws \Box\Spout\Common\Exception\IOException If unable to open the file for writing
+     */
+    protected function openWriter()
+    {
+        if (!$this->book) {
+            $tempFolder = ($this->tempFolder) ? : sys_get_temp_dir();
+            $this->book = new Workbook($tempFolder, $this->shouldUseInlineStrings, $this->shouldCreateNewSheetsAutomatically, $this->defaultRowStyle);
+            $this->book->addNewSheetAndMakeItCurrent();
+        }
+    }
+
+    /**
+     * @return Internal\Workbook The workbook representing the file to be written
+     */
+    protected function getWorkbook()
+    {
+        return $this->book;
+    }
+
+    /**
+     * Adds data to the currently opened writer.
+     * If shouldCreateNewSheetsAutomatically option is set to true, it will handle pagination
+     * with the creation of new worksheets if one worksheet has reached its maximum capicity.
+     *
+     * @param array $dataRow Array containing data to be written.
+     *          Example $dataRow = ['data1', 1234, null, '', 'data5'];
+     * @param \Box\Spout\Writer\Style\Style $style Style to be applied to the row.
+     * @return void
+     * @throws \Box\Spout\Writer\Exception\WriterNotOpenedException If the book is not created yet
+     * @throws \Box\Spout\Common\Exception\IOException If unable to write data
+     */
+    protected function addRowToWriter(array $dataRow, $style)
+    {
+        $this->throwIfBookIsNotAvailable();
+        $this->book->addRowToCurrentWorksheet($dataRow, $style);
+    }
+
+    /**
+     * Returns the default style to be applied to rows.
+     *
+     * @return \Box\Spout\Writer\Style\Style
+     */
+    protected function getDefaultRowStyle()
+    {
+        return (new StyleBuilder())
+            ->setFontSize(self::DEFAULT_FONT_SIZE)
+            ->setFontName(self::DEFAULT_FONT_NAME)
+            ->build();
+    }
+
+    /**
+     * Closes the writer, preventing any additional writing.
+     *
+     * @return void
+     */
+    protected function closeWriter()
+    {
+        if ($this->book) {
+            $this->book->close($this->filePointer);
+        }
+    }
+}