core/lib/Thelia/ImportExport/Export/AbstractExport.php line 141

  1. <?php
  3. /*
  4.  * This file is part of the Thelia package.
  5.  * http://www.thelia.net
  6.  *
  7.  * (c) OpenStudio <info@thelia.net>
  8.  *
  9.  * For the full copyright and license information, please view the LICENSE
  10.  * file that was distributed with this source code.
  11.  */
  13. namespace Thelia\ImportExport\Export;
  15. use Propel\Runtime\ActiveQuery\ModelCriteria;
  16. use Propel\Runtime\Map\TableMap;
  17. use Thelia\Core\Translation\Translator;
  18. use Thelia\Model\Lang;
  20. /**
  21.  * Class AbstractExport.
  22.  *
  23.  * @deprecated since 2.4, please use a specific AbstractExport (like JsonFileAbstractExport).
  24.  *
  25.  * @author Jérôme Billiras <jbilliras@openstudio.fr>
  26.  */
  27. abstract class AbstractExport implements \Iterator
  28. {
  29.     /**
  30.      * @var string Default file name
  31.      */
  32.     public const FILE_NAME = 'export';
  34.     /**
  35.      * @var bool Export images with data
  36.      */
  37.     public const EXPORT_IMAGE = false;
  39.     /**
  40.      * @var bool Export documents with data
  41.      */
  42.     public const EXPORT_DOCUMENT = false;
  44.     /**
  45.      * @var bool Use range date
  46.      */
  47.     public const USE_RANGE_DATE = false;
  49.     /**
  50.      * @var \SplFileObject|\Propel\Runtime\Util\PropelModelPager Data to export
  51.      */
  52.     private $data;
  54.     /**
  55.      * @var bool True if data is array, false otherwise
  56.      */
  57.     private $dataIsArray;
  59.     /**
  60.      *  @var bool True if data is a path to a JSON file, false otherwise
  61.      */
  62.     private $dataIsJSONFile;
  64.     /**
  65.      * @var \Thelia\Model\Lang A language model
  66.      */
  67.     protected $language;
  69.     /**
  70.      * @var array|null List of fields in order in which they must be exported and there alias name
  71.      */
  72.     protected $orderAndAliases;
  74.     /**
  75.      * @var array|null Keep untranslated
  76.      */
  77.     private $originalOrderAndAliases;
  79.     /**
  80.      * @var bool Whether to export images or not
  81.      */
  82.     protected $exportImages = false;
  84.     /**
  85.      * @var array Images paths list
  86.      */
  87.     protected $imagesPaths = [];
  89.     /**
  90.      * @var bool Whether to export documents or not
  91.      */
  92.     protected $exportDocuments = false;
  94.     /**
  95.      * @var array Documents paths list
  96.      */
  97.     protected $documentsPaths = [];
  99.     /**
  100.      * @var array|null Export date range
  101.      */
  102.     protected $rangeDate;
  104.     /**
  105.      * @throws \Exception
  106.      *
  107.      * @return array|false|mixed|string
  108.      */
  109.     public function current()
  110.     {
  111.         if ($this->dataIsJSONFile) {
  112.             /** @var resource $file */
  113.             $result = json_decode($this->data->current(), true);
  115.             if ($result !== null) {
  116.                 return $result;
  117.             }
  119.             return [];
  120.         }
  122.         if ($this->dataIsArray) {
  123.             return current($this->data);
  124.         }
  126.         $data = $this->data->getIterator()->current()->toArray(TableMap::TYPE_COLNAME, true, [], true);
  128.         foreach ($this->data->getQuery()->getWith() as $withKey => $with) {
  129.             $data = array_merge($data, $data[$withKey]);
  130.             unset($data[$withKey]);
  131.         }
  133.         return $data;
  134.     }
  136.     /**
  137.      * @throws \Exception
  138.      *
  139.      * @return bool|float|int|string|null
  140.      */
  141.     public function key()
  142.     {
  143.         if ($this->dataIsJSONFile) {
  144.             return $this->data->key();
  145.         }
  147.         if ($this->dataIsArray) {
  148.             return key($this->data);
  149.         }
  151.         if ($this->data->getIterator()->key() !== null) {
  152.             return $this->data->getIterator()->key() + ($this->data->getPage() - 1) * 1000;
  153.         }
  155.         return null;
  156.     }
  158.     /**
  159.      * @throws \Exception
  160.      */
  161.     public function next(): void
  162.     {
  163.         if ($this->dataIsJSONFile) {
  164.             $this->data->next();
  165.         } elseif ($this->dataIsArray) {
  166.             next($this->data);
  167.         } else {
  168.             $this->data->getIterator()->next();
  169.             if (!$this->valid() && !$this->data->isLastPage()) {
  170.                 $this->data = $this->data->getQuery()->paginate($this->data->getNextPage(), 1000);
  171.                 $this->data->getIterator()->rewind();
  172.             }
  173.         }
  174.     }
  176.     /**
  177.      * @throws \Exception
  178.      */
  179.     public function rewind(): void
  180.     {
  181.         // Since it's first method call on traversable, we get raw data here
  182.         // but we do not permit to go back
  184.         if ($this->data === null) {
  185.             $data = $this->getData();
  187.             // Check if $data is a path to a json file
  188.             if (\is_string($data)
  189.                 && '.json' === substr($data, -5)
  190.                 && file_exists($data)
  191.             ) {
  192.                 $this->data = new \SplFileObject($data, 'r');
  193.                 $this->data->setFlags(\SplFileObject::READ_AHEAD);
  194.                 $this->dataIsJSONFile = true;
  196.                 $this->data->rewind();
  198.                 return;
  199.             }
  201.             if (\is_array($data)) {
  202.                 $this->data = $data;
  203.                 $this->dataIsArray = true;
  204.                 reset($this->data);
  206.                 return;
  207.             }
  209.             if ($data instanceof ModelCriteria) {
  210.                 $this->data = $data->setFormatter(ModelCriteria::FORMAT_ON_DEMAND)->keepQuery(false)->paginate(1, 1000);
  211.                 $this->data->getIterator()->rewind();
  213.                 return;
  214.             }
  216.             throw new \DomainException(
  217.                 'Data must an array, an instance of \\Propel\\Runtime\\ActiveQuery\\ModelCriteria or a JSON file ending with.json'
  218.             );
  219.         }
  221.         throw new \LogicException('Export data can\'t be rewinded');
  222.     }
  224.     /**
  225.      * @throws \Exception
  226.      */
  227.     public function valid(): bool
  228.     {
  229.         if ($this->dataIsJSONFile) {
  230.             return $this->data->valid();
  231.         }
  233.         if ($this->dataIsArray) {
  234.             return key($this->data) !== null;
  235.         }
  237.         return $this->data->getIterator()->valid();
  238.     }
  240.     /**
  241.      * Get language.
  242.      *
  243.      * @return \Thelia\Model\Lang A language model
  244.      */
  245.     public function getLang()
  246.     {
  247.         return $this->language;
  248.     }
  250.     /**
  251.      * Set language.
  252.      *
  253.      * @param \Thelia\Model\Lang|null $language A language model
  254.      *
  255.      * @return $this Return $this, allow chaining
  256.      */
  257.     public function setLang(Lang $language = null)
  258.     {
  259.         $this->language = $language;
  261.         if ($this->originalOrderAndAliases === null) {
  262.             $this->originalOrderAndAliases = $this->orderAndAliases;
  263.         }
  265.         if ($this->language !== null && $this->orderAndAliases !== null) {
  266.             $previousLocale = Translator::getInstance()->getLocale();
  268.             Translator::getInstance()->setLocale($this->language->getLocale());
  269.             foreach ($this->orderAndAliases as &$alias) {
  270.                 $alias = Translator::getInstance()->trans($alias);
  271.             }
  273.             Translator::getInstance()->setLocale($previousLocale);
  274.         }
  276.         return $this;
  277.     }
  279.     /**
  280.      * Check if export is empty.
  281.      *
  282.      * @return bool true if export is empty, else false
  283.      */
  284.     public function isEmpty()
  285.     {
  286.         return empty($this->data);
  287.     }
  289.     /**
  290.      * Whether images has to be exported as data.
  291.      *
  292.      * @return bool
  293.      */
  294.     public function hasImages()
  295.     {
  296.         return static::EXPORT_IMAGE;
  297.     }
  299.     /**
  300.      * Get export images.
  301.      *
  302.      * @return bool Whether to export images or not
  303.      */
  304.     public function isExportImages()
  305.     {
  306.         return $this->exportImages;
  307.     }
  309.     /**
  310.      * Set export images.
  311.      *
  312.      * @param bool $exportImages Whether to export images or not
  313.      *
  314.      * @return $this Return $this, allow chaining
  315.      */
  316.     public function setExportImages($exportImages)
  317.     {
  318.         $this->exportImages = $exportImages;
  320.         return $this;
  321.     }
  323.     /**
  324.      * Get images paths.
  325.      *
  326.      * @return array|null Images paths list
  327.      */
  328.     public function getImagesPaths()
  329.     {
  330.         return $this->imagesPaths;
  331.     }
  333.     /**
  334.      * Set images paths.
  335.      *
  336.      * @param array $imagesPaths Images paths list
  337.      *
  338.      * @return $this Return $this, allow chaining
  339.      */
  340.     public function setImagesPaths(array $imagesPaths)
  341.     {
  342.         $this->imagesPaths = $imagesPaths;
  344.         return $this;
  345.     }
  347.     /**
  348.      * Whether documents has to be exported as data.
  349.      *
  350.      * @return bool
  351.      */
  352.     public function hasDocuments()
  353.     {
  354.         return static::EXPORT_DOCUMENT;
  355.     }
  357.     /**
  358.      * Get export documents.
  359.      *
  360.      * @return bool Whether to export documents or not
  361.      */
  362.     public function isExportDocuments()
  363.     {
  364.         return $this->exportDocuments;
  365.     }
  367.     /**
  368.      * Set export documents.
  369.      *
  370.      * @param bool $exportDocuments Whether to export documents or not
  371.      *
  372.      * @return $this Return $this, allow chaining
  373.      */
  374.     public function setExportDocuments($exportDocuments)
  375.     {
  376.         $this->exportDocuments = $exportDocuments;
  378.         return $this;
  379.     }
  381.     /**
  382.      * Get documents paths.
  383.      *
  384.      * @return array|null Documents paths list
  385.      */
  386.     public function getDocumentsPaths()
  387.     {
  388.         return $this->documentsPaths;
  389.     }
  391.     /**
  392.      * Set documents paths.
  393.      *
  394.      * @param array $documentsPaths Documents paths list
  395.      *
  396.      * @return $this Return $this, allow chaining
  397.      */
  398.     public function setDocumentsPaths(array $documentsPaths)
  399.     {
  400.         $this->documentsPaths = $documentsPaths;
  402.         return $this;
  403.     }
  405.     /**
  406.      * Get range date.
  407.      *
  408.      * @return array|null Array with date range
  409.      */
  410.     public function getRangeDate()
  411.     {
  412.         return $this->rangeDate;
  413.     }
  415.     /**
  416.      * Set range date.
  417.      *
  418.      * @param array|null $rangeDate Array with date range
  419.      *
  420.      * @return $this Return $this, allow chaining
  421.      */
  422.     public function setRangeDate(array $rangeDate = null)
  423.     {
  424.         $this->rangeDate = $rangeDate;
  426.         return $this;
  427.     }
  429.     /**
  430.      * Whether export bounded with date.
  431.      *
  432.      * @return bool
  433.      */
  434.     public function useRangeDate()
  435.     {
  436.         return static::USE_RANGE_DATE;
  437.     }
  439.     /**
  440.      * Get file name.
  441.      *
  442.      * @return string Export file name
  443.      */
  444.     public function getFileName()
  445.     {
  446.         return static::FILE_NAME;
  447.     }
  449.     /**
  450.      * Apply order and aliases on data.
  451.      *
  452.      * @param array $data Raw data
  453.      *
  454.      * @return array Ordered and aliased data
  455.      */
  456.     public function applyOrderAndAliases(array $data)
  457.     {
  458.         if ($this->orderAndAliases === null) {
  459.             return $data;
  460.         }
  462.         $processedData = [];
  464.         foreach ($this->orderAndAliases as $key => $value) {
  465.             if (\is_int($key)) {
  466.                 $fieldName = $value;
  467.                 $fieldAlias = $value;
  468.             } else {
  469.                 $fieldName = $key;
  470.                 $fieldAlias = $value;
  471.             }
  473.             if ($this->dataIsJSONFile) {
  474.                 $fieldName = substr($fieldName, strripos($fieldName, '.'));
  475.                 $fieldName = str_replace('.', '', $fieldName);
  476.                 $fieldName = strtolower($fieldName);
  477.             }
  479.             $processedData[$fieldAlias] = null;
  480.             if (\array_key_exists($fieldName, $data)) {
  481.                 $processedData[$fieldAlias] = $data[$fieldName];
  482.             }
  483.         }
  485.         return $processedData;
  486.     }
  488.     /**
  489.      * Process data before serialization.
  490.      *
  491.      * @param array $data Data before serialization
  492.      *
  493.      * @return array Processed data before serialization
  494.      */
  495.     public function beforeSerialize(array $data)
  496.     {
  497.         foreach ($data as $idx => &$value) {
  498.             if ($value instanceof \DateTime) {
  499.                 $value = $value->format('Y-m-d H:i:s');
  500.             }
  501.         }
  503.         return $data;
  504.     }
  506.     /**
  507.      * Process data after serialization.
  508.      *
  509.      * @param string $data Data after serialization
  510.      *
  511.      * @return string Processed after before serialization
  512.      */
  513.     public function afterSerialize($data)
  514.     {
  515.         return $data;
  516.     }
  518.     /**
  519.      * Get data to export.
  520.      *
  521.      * @return string|array|\Propel\Runtime\ActiveQuery\ModelCriteria Data to export
  522.      */
  523.     abstract protected function getData();
  524. }