vendor/contao-community-alliance/contao-clipboard-bundle/src/Xml/Base.php line 82

Open in your IDE?
  1. <?php
  2. /**
  3.  * This file is part of contao-community-alliance/contao-clipboard-bundle.
  4.  *
  5.  * (c) 2013 MEN AT WORK.
  6.  * (c) 2021 The CCA team.
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  *
  11.  * This project is provided in good faith and hope to be usable by anyone.
  12.  *
  13.  * @package    Clipboard
  14.  * @author     Ingolf Steinhardt <info@e-spin.de>
  15.  * @copyright  2013 MEN AT WORK.
  16.  * @copyright  2021 The CCA team.
  17.  * @license    https://spdx.org/licenses/LGPL-3.0-or-later.html LGPL-3.0-or-later
  18.  * @filesource
  19.  */
  20. namespace ContaoCommunityAlliance\ClipboardBundle\Xml;
  21. use Contao\File;
  22. use Contao\Folder;
  23. /**
  24.  * Class ClipboardXml
  25.  */
  26. class Base
  27. {
  28.     /**
  29.      * @var \Contao\BackendUser|\Contao\User
  30.      */
  31.     private $backendUser;
  32.     /**
  33.      * Contains some helper functions
  34.      *
  35.      * @var object
  36.      */
  37.     protected $helper;
  38.     /**
  39.      * Contains all function to write xml
  40.      *
  41.      * @var Writer
  42.      */
  43.     protected $xmlWriter;
  44.     /**
  45.      * Contains all functions to read xml
  46.      *
  47.      * @var Reader
  48.      */
  49.     protected $xmlReader;
  50.     /**
  51.      * Contains all file operations
  52.      *
  53.      * @var \Files
  54.      */
  55.     protected $files;
  56.     /**
  57.      * Variables
  58.      */
  59.     protected $_arrClipboardElements;
  60.     /**
  61.      * Base constructor.
  62.      *
  63.      * @param \ContaoCommunityAlliance\ClipboardBundle\Xml\Reader          $xmlReader
  64.      *
  65.      * @param \ContaoCommunityAlliance\ClipboardBundle\Xml\Writer          $xmlWriter
  66.      *
  67.      * @param \ContaoCommunityAlliance\ClipboardBundle\Helper\Base         $clipboardHelper
  68.      *
  69.      * @param \ContaoCommunityAlliance\ClipboardBundle\Helper\ContaoBridge $contaoBindings
  70.      */
  71.     public function __construct($xmlReader$xmlWriter$clipboardHelper$contaoBindings)
  72.     {
  73.         $this->backendUser $contaoBindings->getBackendUser();
  74.         $this->files       $contaoBindings->getFiles();
  75.         $this->xmlReader   $xmlReader;
  76.         $this->xmlWriter   $xmlWriter;
  77.         $this->helper      $clipboardHelper;
  78.         $this->_createClipboardFromFiles();
  79.     }
  80.     /**
  81.      * Set the current favorite to the given position in action with the id
  82.      *
  83.      * @param string  $strPastePos
  84.      * @param integer $intId
  85.      */
  86.     public function read($strPastePos$intId)
  87.     {
  88.         $this->xmlReader->readXml($this->getFavorite(), $strPastePos$intId);
  89.     }
  90.     /**
  91.      * Unfavor all clipboard elements and write given array to xml file
  92.      *
  93.      * @param array $arrSet
  94.      */
  95.     public function write($arrSet)
  96.     {
  97.         $objFile $this->getFavorite();
  98.         $this->unFavorAll();
  99.         $arrSet['filename'] = $this->_getFileName($arrSet);
  100.         $arrSet['path']     = $this->getPath();
  101.         if (!$this->xmlWriter->writeXml($arrSet$this->_arrClipboardElements)) {
  102.             $objFile->setFavorite(true);
  103.         }
  104.     }
  105.     /**
  106.      * Delete xml file
  107.      *
  108.      * @param string $strHash
  109.      */
  110.     public function deleteFile($strHash)
  111.     {
  112.         if (is_object($this->_arrClipboardElements[$strHash])) {
  113.             $objFile $this->_arrClipboardElements[$strHash];
  114.             if ($this->fileExists($objFile->getFileName())) {
  115.                 $this->files->delete($this->getPath() . '/' $objFile->getFileName());
  116.             }
  117.         }
  118.     }
  119.     /**
  120.      * Edit all given titles
  121.      *
  122.      * @param array $arrTitles
  123.      */
  124.     public function editTitle($arrTitles)
  125.     {
  126.         foreach ($arrTitles as $hash => $strTitle) {
  127.             if (isset($this->_arrClipboardElements[$hash])) {
  128.                 $this->_arrClipboardElements[$hash]->setTitle($strTitle);
  129.             }
  130.         }
  131.     }
  132.     /**
  133.      * Check if the given file exists and return boolean
  134.      *
  135.      * @param string $strFileName
  136.      *
  137.      * @return boolean
  138.      */
  139.     protected function fileExists($strFileName)
  140.     {
  141.         if (file_exists(TL_ROOT '/' $this->getPath() . '/' $strFileName)) {
  142.             return true;
  143.         }
  144.         return false;
  145.     }
  146.     /**
  147.      * Return if clipboard has elements or not
  148.      *
  149.      * @return boolean
  150.      */
  151.     public function hasElements()
  152.     {
  153.         return is_array($this->_arrClipboardElements) && count($this->_arrClipboardElements) > 0;
  154.     }
  155.     /**
  156.      * Return if clipboard has favorite elements
  157.      *
  158.      * return boolean
  159.      */
  160.     public function hasFavorite()
  161.     {
  162.         if (is_object($this->getFavorite())) {
  163.             return true;
  164.         }
  165.         return false;
  166.     }
  167.     /**
  168.      * Get favorite
  169.      *
  170.      * @return Element
  171.      */
  172.     public function getFavorite()
  173.     {
  174.         $arrFavorits = [];
  175.         if ($this->hasElements()) {
  176.             foreach ($this->_arrClipboardElements as $objFile) {
  177.                 if ($objFile->getFavorite()) {
  178.                     $arrFavorits[] = $objFile;
  179.                 }
  180.             }
  181.             if (count($arrFavorits) == 1) {
  182.                 return $arrFavorits[0];
  183.             } else {
  184.                 $objFileNewest reset($this->_arrClipboardElements);
  185.                 foreach ($this->_arrClipboardElements as $objFile) {
  186.                     if ($objFileNewest->getTimeStemp() < $objFile->getTimeStemp()) {
  187.                         $objFileNewest $objFile;
  188.                     }
  189.                 }
  190.                 $this->unFavorAll();
  191.                 $objFileNewest->setFavorite(true);
  192.                 return $objFileNewest;
  193.             }
  194.         }
  195.         return false;
  196.     }
  197.     /**
  198.      * Set given file hast to favorite and unfavor all other
  199.      *
  200.      * @param type $hash
  201.      */
  202.     public function setFavor($hash)
  203.     {
  204.         $this->unFavorAll();
  205.         $this->_arrClipboardElements[$hash]->setFavorite(true);
  206.     }
  207.     /**
  208.      * Unfavor all clipboard elements
  209.      */
  210.     public function unFavorAll()
  211.     {
  212.         if ($this->hasElements()) {
  213.             foreach ($this->_arrClipboardElements as $objFile) {
  214.                 $objFile->setFavorite(false);
  215.             }
  216.         }
  217.     }
  218.     /**
  219.      * Get all clipboard elements
  220.      *
  221.      * @return array
  222.      */
  223.     public function getElements()
  224.     {
  225.         return $this->_arrClipboardElements;
  226.     }
  227.     /**
  228.      * Fill the clipboard from files
  229.      *
  230.      * @throws \Exception
  231.      */
  232.     protected function _createClipboardFromFiles()
  233.     {
  234.         $arrFiles scan(TL_ROOT '/' $this->getPath());
  235.         if (is_array($arrFiles) && count($arrFiles) > 0) {
  236.             foreach ($arrFiles as $strFileName) {
  237.                 $arrFile $this->helper->getArrFromFileName($this->getPath() . '/' $strFileName);
  238.                 if ($arrFile[0] != $this->helper->getPageType()) {
  239.                     continue;
  240.                 }
  241.                 if ($this->fileExists($strFileName)) {
  242.                     $objFile = new Element($strFileName$this->getPath());
  243.                     $objFile->setHelper($this->helper);
  244.                     $objFile->setXmlReader($this->xmlReader);
  245.                     $objFile->setXmlWriter($this->xmlWriter);
  246.                     $this->_arrClipboardElements[$objFile->getHash()] = $objFile;
  247.                 }
  248.             }
  249.         }
  250.     }
  251.     /**
  252.      * Return path to clipboard files for current user
  253.      *
  254.      * @return string
  255.      * @throws \Exception
  256.      */
  257.     public function getPath()
  258.     {
  259.         $objUserFolder = new Folder($GLOBALS['TL_CONFIG']['uploadPath'] . '/clipboard/' $this->backendUser->username);
  260.         $this->_protect($objUserFolder->value);
  261.         return $objUserFolder->value;
  262.     }
  263.     /**
  264.      * Protect the folder by adding an .htaccess file
  265.      *
  266.      * @throws \Exception
  267.      */
  268.     protected function _protect($strFolder)
  269.     {
  270.         if (!file_exists(TL_ROOT '/' $strFolder '/.htaccess')) {
  271.             $objFile = new File($strFolder '/.htaccess');
  272.             $objFile->write("order deny,allow\ndeny from all");
  273.             $objFile->close();
  274.         }
  275.     }
  276.     /**
  277.      * Get new filename
  278.      *
  279.      * @param array $arrSet
  280.      *
  281.      * @return string
  282.      */
  283.     protected function _getFileName($arrSet)
  284.     {
  285.         $arrFileName = [
  286.             $this->helper->getPageType(),
  287.             time(),
  288.             'F',
  289.             (($arrSet['childs']) ? 'C' 'NC'),
  290.             (($arrSet['grouped']) ? 'G' 'NG'),
  291.             standardize($arrSet['title'])
  292.         ];
  293.         return implode(','$arrFileName) . '.xml';
  294.     }
  295. }