EOD; /** @var bool Whether inline or shared strings should be used */ protected $shouldUseInlineStrings; /** @var RowManager Manages rows */ private $rowManager; /** @var StyleManager Manages styles */ private $styleManager; /** @var StyleMerger Helper to merge styles together */ private $styleMerger; /** @var SharedStringsManager Helper to write shared strings */ private $sharedStringsManager; /** @var XLSXEscaper Strings escaper */ private $stringsEscaper; /** @var StringHelper String helper */ private $stringHelper; /** @var InternalEntityFactory Factory to create entities */ private $entityFactory; /** * WorksheetManager constructor. * * @param OptionsManagerInterface $optionsManager * @param RowManager $rowManager * @param StyleManager $styleManager * @param StyleMerger $styleMerger * @param SharedStringsManager $sharedStringsManager * @param XLSXEscaper $stringsEscaper * @param StringHelper $stringHelper * @param InternalEntityFactory $entityFactory */ public function __construct( OptionsManagerInterface $optionsManager, RowManager $rowManager, StyleManager $styleManager, StyleMerger $styleMerger, SharedStringsManager $sharedStringsManager, XLSXEscaper $stringsEscaper, StringHelper $stringHelper, InternalEntityFactory $entityFactory ) { $this->shouldUseInlineStrings = $optionsManager->getOption(Options::SHOULD_USE_INLINE_STRINGS); $this->rowManager = $rowManager; $this->styleManager = $styleManager; $this->styleMerger = $styleMerger; $this->sharedStringsManager = $sharedStringsManager; $this->stringsEscaper = $stringsEscaper; $this->stringHelper = $stringHelper; $this->entityFactory = $entityFactory; } /** * @return SharedStringsManager */ public function getSharedStringsManager() { return $this->sharedStringsManager; } /** * {@inheritdoc} */ public function startSheet(Worksheet $worksheet) { $sheetFilePointer = \fopen($worksheet->getFilePath(), 'w'); $this->throwIfSheetFilePointerIsNotAvailable($sheetFilePointer); $worksheet->setFilePointer($sheetFilePointer); \fwrite($sheetFilePointer, self::SHEET_XML_FILE_HEADER); \fwrite($sheetFilePointer, ''); } /** * Checks if the sheet has been sucessfully created. Throws an exception if not. * * @param bool|resource $sheetFilePointer Pointer to the sheet data file or FALSE if unable to open the file * @throws IOException If the sheet data file cannot be opened for writing * @return void */ private function throwIfSheetFilePointerIsNotAvailable($sheetFilePointer) { if (!$sheetFilePointer) { throw new IOException('Unable to open sheet for writing.'); } } /** * {@inheritdoc} */ public function addRow(Worksheet $worksheet, Row $row) { if (!$this->rowManager->isEmpty($row)) { $this->addNonEmptyRow($worksheet, $row); } $worksheet->setLastWrittenRowIndex($worksheet->getLastWrittenRowIndex() + 1); } /** * Adds non empty row to the worksheet. * * @param Worksheet $worksheet The worksheet to add the row to * @param Row $row The row to be written * @throws IOException If the data cannot be written * @throws InvalidArgumentException If a cell value's type is not supported * @return void */ private function addNonEmptyRow(Worksheet $worksheet, Row $row) { $rowStyle = $row->getStyle(); $rowIndexOneBased = $worksheet->getLastWrittenRowIndex() + 1; $numCells = $row->getNumCells(); $rowXML = ''; foreach ($row->getCells() as $columnIndexZeroBased => $cell) { $registeredStyle = $this->applyStyleAndRegister($cell, $rowStyle); $cellStyle = $registeredStyle->getStyle(); if ($registeredStyle->isMatchingRowStyle()) { $rowStyle = $cellStyle; // Replace actual rowStyle (possibly with null id) by registered style (with id) } $rowXML .= $this->getCellXML($rowIndexOneBased, $columnIndexZeroBased, $cell, $cellStyle->getId()); } $rowXML .= ''; $wasWriteSuccessful = \fwrite($worksheet->getFilePointer(), $rowXML); if ($wasWriteSuccessful === false) { throw new IOException("Unable to write data in {$worksheet->getFilePath()}"); } } /** * Applies styles to the given style, merging the cell's style with its row's style * * @param Cell $cell * @param Style $rowStyle * * @throws InvalidArgumentException If the given value cannot be processed * @return RegisteredStyle */ private function applyStyleAndRegister(Cell $cell, Style $rowStyle) : RegisteredStyle { $isMatchingRowStyle = false; if ($cell->getStyle()->isEmpty()) { $cell->setStyle($rowStyle); $possiblyUpdatedStyle = $this->styleManager->applyExtraStylesIfNeeded($cell); if ($possiblyUpdatedStyle->isUpdated()) { $registeredStyle = $this->styleManager->registerStyle($possiblyUpdatedStyle->getStyle()); } else { $registeredStyle = $this->styleManager->registerStyle($rowStyle); $isMatchingRowStyle = true; } } else { $mergedCellAndRowStyle = $this->styleMerger->merge($cell->getStyle(), $rowStyle); $cell->setStyle($mergedCellAndRowStyle); $possiblyUpdatedStyle = $this->styleManager->applyExtraStylesIfNeeded($cell); if ($possiblyUpdatedStyle->isUpdated()) { $newCellStyle = $possiblyUpdatedStyle->getStyle(); } else { $newCellStyle = $mergedCellAndRowStyle; } $registeredStyle = $this->styleManager->registerStyle($newCellStyle); } return new RegisteredStyle($registeredStyle, $isMatchingRowStyle); } /** * Builds and returns xml for a single cell. * * @param int $rowIndexOneBased * @param int $columnIndexZeroBased * @param Cell $cell * @param int $styleId * * @throws InvalidArgumentException If the given value cannot be processed * @return string */ private function getCellXML($rowIndexOneBased, $columnIndexZeroBased, Cell $cell, $styleId) { $columnLetters = CellHelper::getColumnLettersFromColumnIndex($columnIndexZeroBased); $cellXML = 'isString()) { $cellXML .= $this->getCellXMLFragmentForNonEmptyString($cell->getValue()); } elseif ($cell->isBoolean()) { $cellXML .= ' t="b">' . (int) ($cell->getValue()) . ''; } elseif ($cell->isNumeric()) { $cellXML .= '>' . $this->stringHelper->formatNumericValue($cell->getValue()) . ''; } elseif ($cell->isError() && is_string($cell->getValueEvenIfError())) { // only writes the error value if it's a string $cellXML .= ' t="e">' . $cell->getValueEvenIfError() . ''; } elseif ($cell->isEmpty()) { if ($this->styleManager->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($cell->getValue())); } return $cellXML; } /** * Returns the XML fragment for a cell containing a non empty string * * @param string $cellValue The cell value * @throws InvalidArgumentException If the string exceeds the maximum number of characters allowed per cell * @return string The XML fragment representing the cell */ private 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">' . $this->stringsEscaper->escape($cellValue) . ''; } else { $sharedStringId = $this->sharedStringsManager->writeString($cellValue); $cellXMLFragment = ' t="s">' . $sharedStringId . ''; } return $cellXMLFragment; } /** * {@inheritdoc} */ public function close(Worksheet $worksheet) { $worksheetFilePointer = $worksheet->getFilePointer(); if (!\is_resource($worksheetFilePointer)) { return; } \fwrite($worksheetFilePointer, ''); \fwrite($worksheetFilePointer, ''); \fclose($worksheetFilePointer); } }