core/lib/Thelia/Action/BaseCachedFile.php line 279

  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\Action;
  15. use Propel\Runtime\Propel;
  16. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  17. use Thelia\Core\Event\CachedFileEvent;
  18. use Thelia\Core\Event\File\FileCreateOrUpdateEvent;
  19. use Thelia\Core\Event\File\FileDeleteEvent;
  20. use Thelia\Core\Event\File\FileToggleVisibilityEvent;
  21. use Thelia\Core\Event\UpdateFilePositionEvent;
  22. use Thelia\Exception\FileException;
  23. use Thelia\Files\FileManager;
  24. use Thelia\Model\ConfigQuery;
  25. use Thelia\Model\Map\ProductImageTableMap;
  26. use Thelia\Tools\URL;
  28. /**
  29.  * Cached file management actions. This class handles file caching in the web space.
  30.  *
  31.  * Basically, files are stored outside the web space (by default in local/media/<dirname>),
  32.  * and cached in the web space (by default in web/local/<dirname>).
  33.  *
  34.  * In the file cache directory, a subdirectory for files categories (eg. product, category, folder, etc.) is
  35.  * automatically created, and the cached file is created here. Plugin may use their own subdirectory as required.
  36.  *
  37.  * A copy (or symbolic link, by default) of the original file is created in the cache.
  38.  *
  39.  * @author Franck Allimant <franck@cqfdev.fr>
  40.  */
  41. abstract class BaseCachedFile extends BaseAction
  42. {
  43.     /**
  44.      * @var FileManager
  45.      */
  46.     protected $fileManager;
  48.     /** @var string|null */
  49.     protected $cdnBaseUrl;
  51.     public function __construct(FileManager $fileManager)
  52.     {
  53.         $this->fileManager = $fileManager;
  55.         $this->cdnBaseUrl = ConfigQuery::read('cdn.documents-base-url', null);
  56.     }
  58.     /**
  59.      * @return string root of the file cache directory in web space
  60.      */
  61.     abstract protected function getCacheDirFromWebRoot();
  63.     /**
  64.      * @param string $url the fully qualified CDN URL that will be used to create doucments URL
  65.      */
  66.     public function setCdnBaseUrl(string $url): void
  67.     {
  68.         $this->cdnBaseUrl = $url;
  69.     }
  71.     /**
  72.      * Clear the file cache. Is a subdirectory is specified, only this directory is cleared.
  73.      * If no directory is specified, the whole cache is cleared.
  74.      * Only files are deleted, directories will remain.
  75.      */
  76.     public function clearCache(CachedFileEvent $event): void
  77.     {
  78.         $path = $this->getCachePath($event->getCacheSubdirectory(), false);
  80.         $this->clearDirectory($path);
  81.     }
  83.     /**
  84.      * Recursively clears the specified directory.
  85.      *
  86.      * @param string $path the directory path
  87.      */
  88.     protected function clearDirectory(string $path): void
  89.     {
  90.         $iterator = new \DirectoryIterator($path);
  92.         /** @var \DirectoryIterator $fileinfo */
  93.         foreach ($iterator as $fileinfo) {
  94.             if ($fileinfo->isDot()) {
  95.                 continue;
  96.             }
  98.             if ($fileinfo->isFile() || $fileinfo->isLink()) {
  99.                 @unlink($fileinfo->getPathname());
  100.             } elseif ($fileinfo->isDir()) {
  101.                 $this->clearDirectory($fileinfo->getPathname());
  102.             }
  103.         }
  104.     }
  106.     /**
  107.      * Return the absolute URL to the cached file.
  108.      *
  109.      * @param string $subdir        the subdirectory related to cache base
  110.      * @param string $safe_filename the safe filename, as returned by getCacheFilePath()
  111.      *
  112.      * @return string the absolute URL to the cached file
  113.      */
  114.     protected function getCacheFileURL(string $subdir, string $safe_filename)
  115.     {
  116.         $path = $this->getCachePathFromWebRoot($subdir);
  118.         return URL::getInstance()->absoluteUrl(sprintf('%s/%s', $path, $safe_filename), null, URL::PATH_TO_FILE, $this->cdnBaseUrl);
  119.     }
  121.     /**
  122.      * Return the full path of the cached file.
  123.      *
  124.      * @param string      $subdir            the subdirectory related to cache base
  125.      * @param string      $filename          the filename
  126.      * @param bool        $forceOriginalFile if true, the original file path in the cache dir is returned
  127.      * @param string|null $hashed_options    a hash of transformation options, or null if no transformations have been applied
  128.      *
  129.      * @return string the cache directory path relative to Web Root
  130.      */
  131.     protected function getCacheFilePath(string $subdir, string $filename, bool $forceOriginalFile = false, string $hashed_options = null)
  132.     {
  133.         $path = $this->getCachePath($subdir);
  135.         $safe_filename = preg_replace("[^:alnum:\-\._]", '-', strtolower(basename($filename)));
  137.         // Keep original safe name if no tranformations are applied
  138.         if ($forceOriginalFile || $hashed_options == null) {
  139.             return sprintf('%s/%s', $path, $safe_filename);
  140.         }
  142.         return sprintf('%s/%s-%s', $path, $hashed_options, $safe_filename);
  143.     }
  145.     /**
  146.      * Return the cache directory path relative to Web Root.
  147.      *
  148.      * @param string|null $subdir the subdirectory related to cache base, or null to get the cache directory only
  149.      *
  150.      * @return string the cache directory path relative to Web Root
  151.      */
  152.     protected function getCachePathFromWebRoot(string $subdir = null)
  153.     {
  154.         $cache_dir_from_web_root = $this->getCacheDirFromWebRoot();
  156.         if ($subdir != null) {
  157.             $safe_subdir = basename($subdir);
  159.             $path = sprintf('%s/%s', $cache_dir_from_web_root, $safe_subdir);
  160.         } else {
  161.             $path = $cache_dir_from_web_root;
  162.         }
  164.         // Check if path is valid, e.g. in the cache dir
  165.         return $path;
  166.     }
  168.     /**
  169.      * Return the absolute cache directory path.
  170.      *
  171.      * @param string|null $subdir               the subdirectory related to cache base, or null to get the cache base directory
  172.      * @param bool        $create_if_not_exists create the directory if it is not found
  173.      *
  174.      * @throws \RuntimeException         if cache directory cannot be created
  175.      * @throws \InvalidArgumentException ii path is invalid, e.g. not in the cache dir
  176.      *
  177.      * @return string the absolute cache directory path
  178.      */
  179.     protected function getCachePath(string $subdir = null, bool $create_if_not_exists = true)
  180.     {
  181.         $cache_base = $this->getCachePathFromWebRoot($subdir);
  183.         $web_root = rtrim(THELIA_WEB_DIR, '/');
  185.         $path = sprintf('%s/%s', $web_root, $cache_base);
  187.         // Create directory (recursively) if it does not exists.
  188.         if ($create_if_not_exists && !is_dir($path)) {
  189.             if (!@mkdir($path, 0777, true)) {
  190.                 throw new \RuntimeException(sprintf('Failed to create %s file in cache directory', $path));
  191.             }
  192.         }
  194.         // Check if path is valid, e.g. in the cache dir
  195.         $cache_base = realpath(sprintf('%s/%s', $web_root, $this->getCachePathFromWebRoot()));
  197.         if (strpos(realpath($path), $cache_base) !== 0) {
  198.             throw new \InvalidArgumentException(sprintf('Invalid cache path %s, with subdirectory %s', $path, $subdir));
  199.         }
  201.         return $path;
  202.     }
  204.     /**
  205.      * Take care of saving a file in the database and file storage.
  206.      *
  207.      * @param FileCreateOrUpdateEvent $event Image event
  208.      *
  209.      * @throws \Thelia\Exception\FileException|\Exception
  210.      */
  211.     public function saveFile(FileCreateOrUpdateEvent $event): void
  212.     {
  213.         $model = $event->getModel();
  214.         $model->setFile(sprintf('tmp/%s', $event->getUploadedFile()->getFilename()));
  215.         $con = Propel::getWriteConnection(ProductImageTableMap::DATABASE_NAME);
  216.         $con->beginTransaction();
  218.         try {
  219.             $nbModifiedLines = $model->save($con);
  220.             $event->setModel($model);
  222.             if (!$nbModifiedLines) {
  223.                 throw new FileException(
  224.                     sprintf(
  225.                         'File "%s" (type %s) with parent id %s failed to be saved',
  226.                         $event->getParentName(),
  227.                         \get_class($model),
  228.                         $event->getParentId()
  229.                     )
  230.                 );
  231.             }
  233.             $newUploadedFile = $this->fileManager->copyUploadedFile($event->getModel(), $event->getUploadedFile());
  235.             $event->setUploadedFile($newUploadedFile);
  236.             $con->commit();
  237.         } catch (\Exception $e) {
  238.             $con->rollBack();
  240.             throw $e;
  241.         }
  242.     }
  244.     /**
  245.      * Take care of updating file in the database and file storage.
  246.      *
  247.      * @param FileCreateOrUpdateEvent $event Image event
  248.      *
  249.      * @throws \Thelia\Exception\FileException
  250.      */
  251.     public function updateFile(FileCreateOrUpdateEvent $event): void
  252.     {
  253.         // Copy and save file
  254.         if ($event->getUploadedFile()) {
  255.             // Remove old picture file from file storage
  256.             $url = $event->getModel()->getUploadDir().'/'.$event->getOldModel()->getFile();
  257.             unlink(str_replace('..', '', $url));
  259.             $newUploadedFile = $this->fileManager->copyUploadedFile($event->getModel(), $event->getUploadedFile());
  260.             $event->setUploadedFile($newUploadedFile);
  261.         }
  263.         // Update image modifications
  264.         $event->getModel()->save();
  266.         $event->setModel($event->getModel());
  267.     }
  269.     /**
  270.      * Deleting file in the database and in storage.
  271.      *
  272.      * @param FileDeleteEvent $event Image event
  273.      */
  274.     public function deleteFile(FileDeleteEvent $event): void
  275.     {
  276.         $this->fileManager->deleteFile($event->getFileToDelete());
  277.     }
  279.     public function updatePosition(UpdateFilePositionEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  280.     {
  281.         $this->genericUpdatePosition($event->getQuery(), $event, $dispatcher);
  282.     }
  284.     public function toggleVisibility(FileToggleVisibilityEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  285.     {
  286.         $this->genericToggleVisibility($event->getQuery(), $event, $dispatcher);
  287.     }
  288. }