vendor/terminal42/contao-fineuploader/widgets/FineUploaderBase.php line 37

Open in your IDE?
  1. <?php
  3. /**
  4.  * fineuploader extension for Contao Open Source CMS
  5.  *
  6.  * @copyright  Copyright (c) 2008-2015, terminal42 gmbh
  7.  * @author     terminal42 gmbh <info@terminal42.ch>
  8.  * @license    http://opensource.org/licenses/lgpl-3.0.html LGPL
  9.  * @link       http://github.com/terminal42/contao-fineuploader
  10.  */
  12. /**
  13.  * Class FineUploaderBase
  14.  *
  15.  * Parent class for "fine uploader" widgets.
  16.  */
  17. abstract class FineUploaderBase extends \Widget
  18. {
  19.     /**
  20.      * Temporary upload path
  21.      * @var string
  22.      */
  23.     protected $strTemporaryPath = 'system/tmp';
  25.     /**
  26.      * Initialize the object
  27.      * @param array
  28.      */
  29.     public function __construct($arrAttributes=null)
  30.     {
  31.         $arrAttributes['decodeEntities'] = true;
  33.         parent::__construct($arrAttributes);
  35.         // Clean the chunks session when the widget is initialized
  36.         if (!\Environment::get('isAjaxRequest')) {
  37.             unset($_SESSION[$this->strName . '_FINEUPLOADER_CHUNKS']);
  38.         }
  39.     }
  41.     /**
  42.      * Add the labels and messages.
  43.      *
  44.      * @param null $arrAttributes
  45.      */
  46.     public function parse($arrAttributes = null)
  47.     {
  48.         // Messages (passed on to fineuploader JS)
  49.         $basicTextOptions = array(
  50.             'text'  => array(
  51.                 'formatProgress',
  52.                 'failUpload',
  53.                 'waitingForResponse',
  54.                 'paused',
  55.             ),
  56.             'messages'  => array(
  57.                 'typeError',
  58.                 'sizeError',
  59.                 'minSizeError',
  60.                 'emptyError',
  61.                 'noFilesError',
  62.                 'tooManyItemsError',
  63.                 'maxHeightImageError',
  64.                 'maxWidthImageError',
  65.                 'minHeightImageError',
  66.                 'minWidthImageError',
  67.                 'retryFailTooManyItems',
  68.                 'onLeave',
  69.                 'unsupportedBrowserIos8Safari',
  70.             ),
  71.             'retry' => array(
  72.                 'autoRetryNote',
  73.             ),
  74.             'deleteFile' => array(
  75.                 'confirmMessage',
  76.                 'deletingStatusText',
  77.                 'deletingFailedText',
  78.             ),
  79.             'paste' => array(
  80.                 'namePromptMessage',
  81.             )
  82.         );
  84.         $config = array();
  86.         foreach ($basicTextOptions as $category => $messages) {
  87.             foreach ($messages as $message) {
  88.                 // Only translate if available, otherwise fall back to default (EN)
  89.                 if (isset($GLOBALS['TL_LANG']['MSC']['fineuploader_trans'][$category][$message])) {
  90.                     $config[$category][$message] = $GLOBALS['TL_LANG']['MSC']['fineuploader_trans'][$category][$message];
  91.                 }
  92.             }
  93.         }
  95.         // BC (used to be a JSON string)
  96.         if (isset($this->arrConfiguration['uploaderConfig'])
  97.             && $this->arrConfiguration['uploaderConfig'] !== ''
  98.         ) {
  99.             $this->arrConfiguration['uploaderConfig'] = json_decode('{' . $this->arrConfiguration['uploaderConfig'] . '}', true);
  100.         }
  102.         // Merge with custom options
  103.         $this->config = json_encode(array_merge($config, (array) $this->arrConfiguration['uploaderConfig']));
  105.         // Labels (in HTML)
  106.         $labels = array(
  107.             'drop',
  108.             'upload',
  109.             'processing',
  110.             'cancel',
  111.             'retry',
  112.             'delete',
  113.             'close',
  114.             'yes',
  115.             'no',
  116.         );
  118.         $preparedLabels = array();
  120.         foreach ($labels as $label) {
  121.             $preparedLabels[$label] = $GLOBALS['TL_LANG']['MSC']['fineuploader_' . $label];
  122.         }
  124.         // Set the upload button label
  125.         if ($this->uploadButtonLabel) {
  126.             $preparedLabels['upload'] = $this->uploadButtonLabel;
  127.         }
  129.         $this->labels = $preparedLabels;
  131.         return parent::parse($arrAttributes);
  132.     }
  134.     /**
  135.      * Add the required attribute if mandatory
  136.      *
  137.      * @param string
  138.      * @param mixed
  139.      */
  140.     public function __set($strKey, $varValue)
  141.     {
  142.         switch ($strKey) {
  143.             case 'mandatory':
  144.                 if ($varValue) {
  145.                     $this->arrAttributes['required'] = 'required';
  146.                 } else {
  147.                     unset($this->arrAttributes['required']);
  148.                 }
  149.                 // DO NOT BREAK HERE
  150.         }
  152.         parent::__set($strKey, $varValue);
  153.     }
  155.     /**
  156.      * Validate the upload
  157.      * @return string
  158.      */
  159.     public function validateUpload()
  160.     {
  161.         \Message::reset();
  162.         $strTempName = $this->strName . '_fineuploader';
  163.         $objUploader = new \Haste\Util\FileUpload($this->strName);
  164.         $blnIsChunk = isset($_POST['qqpartindex']);
  166.         // Convert the $_FILES array to Contao format
  167.         if (!empty($_FILES[$strTempName])) {
  168.             $arrFile = array
  169.             (
  170.                 'name' => array($_FILES[$strTempName]['name']),
  171.                 'type' => array($_FILES[$strTempName]['type']),
  172.                 'tmp_name' => array($_FILES[$strTempName]['tmp_name']),
  173.                 'error' => array($_FILES[$strTempName]['error']),
  174.                 'size' => array($_FILES[$strTempName]['size']),
  175.             );
  177.             // Replace the comma character (#22)
  178.             $arrFile['name'] = str_replace(',', '_', $arrFile['name']);
  180.             // Set the UUID as the filename
  181.             if ($blnIsChunk) {
  182.                 $arrFile['name'][0] = \Input::post('qquuid') . '.chunk';
  183.             }
  185.             // Check if the file exists
  186.             if (file_exists(TL_ROOT . '/' . $this->strTemporaryPath . '/' . $arrFile['name'][0])) {
  187.                 $arrFile['name'][0] = $this->getFileName($arrFile['name'][0], $this->strTemporaryPath);
  188.             }
  190.             $_FILES[$this->strName] = $arrFile;
  191.             unset($_FILES[$strTempName]); // Unset the temporary file
  192.         }
  194.         $varInput = '';
  196.         // Add the "chunk" extension to upload types
  197.         if ($blnIsChunk) {
  198.             $extensions   = trimsplit(',', $GLOBALS['TL_CONFIG']['uploadTypes']);
  199.             $extensions[] = 'chunk';
  201.             $objUploader->setExtensions($extensions);
  202.         }
  204.         // Validate the minlength
  205.         if ($this->arrConfiguration['minlength'] > 0 && !$blnIsChunk) {
  206.             $objUploader->setMinFileSize($this->arrConfiguration['minlength']);
  207.         }
  209.         // Validate the maxlength
  210.         if ($this->arrConfiguration['maxlength'] > 0 || $blnIsChunk) {
  211.             $objUploader->setMaxFileSize($blnIsChunk ? $this->arrConfiguration['chunkSize'] : $this->arrConfiguration['maxlength']);
  212.         }
  214.         // Set the maximum width
  215.         if ($this->arrConfiguration['maxWidth']) {
  216.             $objUploader->setImageWidth($this->arrConfiguration['maxWidth']);
  217.         }
  219.         // Set the maximum height
  220.         if ($this->arrConfiguration['maxHeight']) {
  221.             $objUploader->setImageHeight($this->arrConfiguration['maxHeight']);
  222.         }
  224.         try {
  225.             $varInput = $objUploader->uploadTo($this->strTemporaryPath);
  227.             if ($objUploader->hasError()) {
  228.                 if (version_compare(VERSION, '4.2', '>=')) {
  229.                     $session = \System::getContainer()->get('session');
  231.                     foreach ($session->getFlashBag()->peek('contao.'.TL_MODE.'.error') as $strError) {
  232.                         $this->addError($strError);
  233.                     }
  234.                 } else {
  235.                     foreach ((array) $_SESSION['TL_ERROR'] as $strError) {
  236.                         $this->addError($strError);
  237.                     }
  238.                 }
  239.             }
  241.             \Message::reset();
  242.         } catch (\Exception $e) {
  243.             $this->addError($e->getMessage());
  244.         }
  246.         if (!is_array($varInput) || empty($varInput)) {
  247.             $this->addError($GLOBALS['TL_LANG']['MSC']['fineuploader_error']);
  248.         }
  250.         $varInput = $varInput[0];
  252.         // Store the chunk in the session for further merge
  253.         if ($blnIsChunk) {
  254.             $_SESSION[$this->strName . '_FINEUPLOADER_CHUNKS'][\Input::post('qqfilename')][] = $varInput;
  256.             // This is the last chunking request, merge the chunks and create the final file
  257.             if (\Input::post('qqpartindex') == \Input::post('qqtotalparts') - 1) {
  258.                 $strFileName = \Input::post('qqfilename');
  260.                 // Get the new file name
  261.                 if (file_exists(TL_ROOT . '/' . $this->strTemporaryPath . '/' . $strFileName)) {
  262.                     $strFileName = $this->getFileName($strFileName, $this->strTemporaryPath);
  263.                 }
  265.                 $objFile = new \File($this->strTemporaryPath . '/' . $strFileName);
  267.                 // Merge the chunks
  268.                 foreach ($_SESSION[$this->strName . '_FINEUPLOADER_CHUNKS'][\Input::post('qqfilename')] as $strChunk) {
  269.                     $objFile->append(file_get_contents(TL_ROOT . '/' . $strChunk), '');
  271.                     // Delete the file
  272.                     \Files::getInstance()->delete($strChunk);
  273.                 }
  275.                 $objFile->close();
  276.                 $varInput = $objFile->path;
  278.                 // Validate the minlength
  279.                 if ($this->arrConfiguration['minlength'] > 0 && $objFile->size < $this->arrConfiguration['minlength']) {
  280.                     $readableSize = \System::getReadableSize($this->arrConfiguration['minlength']);
  281.                     $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['minFileSize'], $readableSize));
  282.                     \System::log('File "'.$objFile->name.'" is smaller than the minimum file size of '.$readableSize, __METHOD__, TL_ERROR);
  283.                 }
  285.                 // Validate the maxlength
  286.                 if ($this->arrConfiguration['maxlength'] > 0 && $objFile->size > $this->arrConfiguration['maxlength']) {
  287.                     $readableSize = \System::getReadableSize($this->arrConfiguration['maxlength']);
  288.                     $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['maxFileSize'], $readableSize));
  289.                     \System::log('File "'.$objFile->name.'" exceeds the maximum file size of '.$readableSize, __METHOD__, TL_ERROR);
  290.                 }
  292.                 // Reset the chunk flag
  293.                 $blnIsChunk = false;
  295.                 // Unset the file session after merging the chunks
  296.                 unset($_SESSION[$this->strName . '_FINEUPLOADER_CHUNKS'][\Input::post('qqfilename')]);
  297.             }
  298.         }
  300.         // Validate and move the file immediately
  301.         if ($this->arrConfiguration['directUpload'] && !$blnIsChunk) {
  302.             $varInput = $this->validatorSingle($varInput, $this->getDestinationFolder());
  303.         }
  305.         return $varInput;
  306.     }
  308.     /**
  309.      * Return an array if the "multiple" attribute is set
  310.      * @param mixed
  311.      * @return mixed
  312.      */
  313.     protected function validator($varInput)
  314.     {
  315.         $varReturn = $this->blnIsMultiple ? array() : '';
  316.         $strDestination = $this->getDestinationFolder();
  318.         // Check if mandatory
  319.         if ($varInput == '' && $this->mandatory) {
  320.             $this->addError(sprintf($GLOBALS['TL_LANG']['ERR']['mandatory'], $this->strLabel));
  321.         }
  322.         // Single file
  323.         elseif (strpos($varInput, ',') === false) {
  324.             $varInput = $this->validatorSingle($varInput, $strDestination);
  325.             $varReturn = $this->blnIsMultiple ? array($varInput) : $varInput;
  326.         }
  327.         // Multiple files
  328.         else {
  329.             $arrValues = array_filter(explode(',', $varInput));
  331.             // Limit the number of uploads
  332.             if ($this->arrConfiguration['uploaderLimit'] > 0) {
  333.                 $arrValues = array_slice($arrValues, 0, $this->arrConfiguration['uploaderLimit']);
  334.             }
  336.             foreach ($arrValues as $k => $v) {
  337.                 $arrValues[$k] = $this->validatorSingle($v, $strDestination);
  338.             }
  340.             $varReturn = $this->blnIsMultiple ? $arrValues : $arrValues[0];
  341.         }
  343.         return $varReturn;
  344.     }
  346.     /**
  347.      * Get the destination folder
  348.      *
  349.      * @return mixed
  350.      */
  351.     protected function getDestinationFolder()
  352.     {
  353.         $destination = \Config::get('uploadPath');
  354.         $folder = null;
  356.         // Specify the target folder in the DCA (eval)
  357.         if (isset($this->arrConfiguration['uploadFolder'])) {
  358.             $folder = $this->arrConfiguration['uploadFolder'];
  359.         }
  361.         // Use the user's home directory
  362.         if ($this->arrConfiguration['useHomeDir'] && FE_USER_LOGGED_IN) {
  363.             $user = FrontendUser::getInstance();
  365.             if ($user->assignDir && $user->homeDir) {
  366.                 $folder = $user->homeDir;
  367.             }
  368.         }
  370.         if ($folder !== null && \Validator::isUuid($folder)) {
  371.             $folderModel = \FilesModel::findByUuid($folder);
  373.             if ($folderModel !== null) {
  374.                 $destination = $folderModel->path;
  375.             }
  376.         } else {
  377.             $destination = $folder;
  378.         }
  380.         return $destination;
  381.     }
  383.     /**
  384.      * Validate a single file.
  385.      *
  386.      * @param mixed
  387.      * @param string
  388.      * @return mixed
  389.      */
  390.     protected function validatorSingle($varFile, $strDestination)
  391.     {
  392.         // Move the temporary file
  393.         if (!\Validator::isStringUuid($varFile) && is_file(TL_ROOT . '/' . $varFile)) {
  394.             $varFile = $this->moveTemporaryFile($varFile, $strDestination);
  395.         }
  397.         // Convert uuid to binary format
  398.         if (\Validator::isStringUuid($varFile)) {
  399.             $varFile = \StringUtil::uuidToBin($varFile);
  400.         }
  402.         return $varFile;
  403.     }
  406.     /**
  407.      * Move the temporary file to its destination
  408.      * @param string
  409.      * @param string
  410.      * @return string
  411.      */
  412.     protected function moveTemporaryFile($strFile, $strDestination)
  413.     {
  414.         if (!is_file(TL_ROOT . '/' . $strFile)) {
  415.             return '';
  416.         }
  418.         // Do not store the file
  419.         if (!$this->arrConfiguration['storeFile']) {
  420.             return $strFile;
  421.         }
  423.         // The file is not temporary
  424.         if (stripos($strFile, $this->strTemporaryPath) === false) {
  425.             return $strFile;
  426.         }
  428.         $strNew = $strDestination . '/' . basename($strFile);
  430.         // Do not overwrite existing files
  431.         if ($this->arrConfiguration['doNotOverwrite']) {
  432.             $strNew = $strDestination . '/' . $this->getFileName(basename($strFile), $strDestination);
  433.         }
  435.         $blnRename = \Files::getInstance()->rename($strFile, $strNew);
  437.         \Files::getInstance()->chmod($strNew, \Config::get('defaultFileChmod'));
  439.         // Add the file to Dbafs
  440.         if ($this->arrConfiguration['addToDbafs'] && $blnRename) {
  441.             $objModel = \Dbafs::addResource($strNew);
  443.             if ($objModel !== null) {
  444.                 $strNew = $objModel->uuid;
  445.             }
  446.         }
  448.         return $strNew;
  449.     }
  452.     /**
  453.      * Get the new file name if it already exists in the folder
  454.      * @param string
  455.      * @param string
  456.      * @return string
  457.      */
  458.     protected function getFileName($strFile, $strFolder)
  459.     {
  460.         if (!file_exists(TL_ROOT . '/' . $strFolder . '/' . $strFile)) {
  461.             return $strFile;
  462.         }
  464.         $offset = 1;
  465.         $pathinfo = pathinfo($strFile);
  466.         $name = $pathinfo['filename'];
  468.         $arrAll = scan(TL_ROOT . '/' . $strFolder);
  469.         $arrFiles = preg_grep('/^' . preg_quote($name, '/') . '.*\.' . preg_quote($pathinfo['extension'], '/') . '/', $arrAll);
  471.         foreach ($arrFiles as $file) {
  472.             if (preg_match('/__[0-9]+\.' . preg_quote($pathinfo['extension'], '/') . '$/', $file)) {
  473.                 $file = str_replace('.' . $pathinfo['extension'], '', $file);
  474.                 $intValue = intval(substr($file, (strrpos($file, '_') + 1)));
  476.                 $offset = max($offset, $intValue);
  477.             }
  478.         }
  480.         return str_replace($name, $name . '__' . ++$offset, $strFile);
  481.     }
  484.     /**
  485.      * Generate a file item and return it as HTML string
  486.      * @param string
  487.      * @return string
  488.      */
  489.     protected function generateFileItem($strPath)
  490.     {
  491.         if (!is_file(TL_ROOT . '/' . $strPath)) {
  492.             return '';
  493.         }
  495.         $imageSize = $this->getImageSize();
  496.         $objFile = new \File($strPath, true);
  497.         $strInfo = $strPath . ' <span class="tl_gray">(' . \System::getReadableSize($objFile->size) . ($objFile->isGdImage ? ', ' . $objFile->width . 'x' . $objFile->height . ' px' : '') . ')</span>';
  498.         $allowedDownload = trimsplit(',', strtolower($GLOBALS['TL_CONFIG']['allowedDownload']));
  499.         $strReturn = '';
  501.         // Show files and folders
  502.         if (!$this->blnIsGallery && !$this->blnIsDownloads) {
  503.             if ($objFile->isGdImage) {
  504.                 $strReturn = \Image::getHtml(\Image::get($strPath, $imageSize[0], $imageSize[1], $imageSize[2]), '', 'class="gimage" title="' . specialchars($strInfo) . '"');
  505.             } else {
  506.                 $strReturn = \Image::getHtml($objFile->icon) . ' ' . $strInfo;
  507.             }
  508.         }
  510.         // Show a sortable list of files only
  511.         else {
  512.             if ($this->blnIsGallery) {
  513.                 // Only show images
  514.                 if ($objFile->isGdImage) {
  515.                     $strReturn = \Image::getHtml(\Image::get($strPath, $imageSize[0], $imageSize[1], $imageSize[2]), '', 'class="gimage" title="' . specialchars($strInfo) . '"');
  516.                 }
  517.             } else {
  518.                 // Only show allowed download types
  519.                 if (in_array($objFile->extension, $allowedDownload) && !preg_match('/^meta(_[a-z]{2})?\.txt$/', $objFile->basename)) {
  520.                     $strReturn = \Image::getHtml($objFile->icon) . ' ' . $strPath;
  521.                 }
  522.             }
  523.         }
  525.         return $strReturn;
  526.     }
  528.     /**
  529.      * Get the image size
  530.      *
  531.      * @return array
  532.      */
  533.     protected function getImageSize()
  534.     {
  535.         if (is_array($this->imageSize)) {
  536.             return $this->imageSize;
  537.         }
  539.         return [80, 60, 'center_center'];
  540.     }
  541. }