core/lib/Thelia/Action/File.php line 38

  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 Symfony\Component\EventDispatcher\EventDispatcherInterface;
  16. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  17. use Symfony\Component\HttpFoundation\File\UploadedFile;
  18. use Thelia\Core\Event\File\FileCreateOrUpdateEvent;
  19. use Thelia\Core\Event\Product\ProductCloneEvent;
  20. use Thelia\Core\Event\TheliaEvents;
  21. use Thelia\Core\Translation\Translator;
  22. use Thelia\Log\Tlog;
  23. use Thelia\Model\ProductDocument;
  24. use Thelia\Model\ProductDocumentI18n;
  25. use Thelia\Model\ProductDocumentI18nQuery;
  26. use Thelia\Model\ProductDocumentQuery;
  27. use Thelia\Model\ProductImage;
  28. use Thelia\Model\ProductImageI18nQuery;
  29. use Thelia\Model\ProductImageQuery;
  31. /**
  32.  * Class File.
  33.  *
  34.  * @author Etienne Perriere <eperriere@openstudio.fr>
  35.  */
  36. class File extends BaseAction implements EventSubscriberInterface
  37. {
  38.     public function cloneFile(ProductCloneEvent $event, $eventName, EventDispatcherInterface $dispatcher): void
  39.     {
  40.         $originalProductId = $event->getOriginalProduct()->getId();
  41.         $clonedProduct = $event->getClonedProduct();
  43.         foreach ($event->getTypes() as $type) {
  44.             if (!\in_array($type, ['images', 'documents'])) {
  45.                 throw new \Exception(Translator::getInstance()->trans('Cloning files of type %type is not allowed.', ['%type' => $type], 'core'));
  46.             }
  48.             $originalProductFiles = [];
  50.             switch ($type) {
  51.                 case 'images':
  52.                     $originalProductFiles = ProductImageQuery::create()
  53.                         ->findByProductId($originalProductId);
  54.                     break;
  55.                 case 'documents':
  56.                     $originalProductFiles = ProductDocumentQuery::create()
  57.                         ->findByProductId($originalProductId);
  58.                     break;
  59.             }
  61.             // Set clone's files
  62.             /** @var ProductDocument|ProductImage $originalProductFile */
  63.             foreach ($originalProductFiles as $originalProductFile) {
  64.                 $srcPath = $originalProductFile->getUploadDir().DS.$originalProductFile->getFile();
  66.                 if (file_exists($srcPath)) {
  67.                     $ext = pathinfo($srcPath, \PATHINFO_EXTENSION);
  69.                     $clonedProductFile = [];
  70.                     $fileName = '';
  71.                     switch ($type) {
  72.                         case 'images':
  73.                             $fileName = $clonedProduct->getRef().'.'.$ext;
  74.                             $clonedProductFile = new ProductImage();
  75.                             break;
  76.                         case 'documents':
  77.                             $fileName = pathinfo($originalProductFile->getFile(), \PATHINFO_FILENAME).'-'.$clonedProduct->getRef().'.'.$ext;
  78.                             $clonedProductFile = new ProductDocument();
  79.                             break;
  80.                     }
  82.                     // Copy a temporary file of the source file as it will be deleted by IMAGE_SAVE or DOCUMENT_SAVE event
  83.                     $srcTmp = $srcPath.'.tmp';
  84.                     copy($srcPath, $srcTmp);
  86.                     // Get file mimeType
  87.                     $finfo = new \finfo();
  88.                     $fileMimeType = $finfo->file($srcPath, \FILEINFO_MIME_TYPE);
  90.                     // Get file event's parameters
  91.                     $clonedProductFile
  92.                         ->setProductId($clonedProduct->getId())
  93.                         ->setVisible($originalProductFile->getVisible())
  94.                         ->setPosition($originalProductFile->getPosition())
  95.                         ->setLocale($clonedProduct->getLocale())
  96.                         ->setTitle($clonedProduct->getTitle());
  98.                     $clonedProductCopiedFile = new UploadedFile($srcPath, $fileName, $fileMimeType);
  100.                     // Create and dispatch event
  101.                     $clonedProductCreateFileEvent = new FileCreateOrUpdateEvent($clonedProduct->getId());
  102.                     $clonedProductCreateFileEvent
  103.                         ->setModel($clonedProductFile)
  104.                         ->setUploadedFile($clonedProductCopiedFile)
  105.                         ->setParentName($clonedProduct->getTitle());
  107.                     $originalProductFileI18ns = [];
  109.                     switch ($type) {
  110.                         case 'images':
  111.                             $dispatcher->dispatch($clonedProductCreateFileEvent, TheliaEvents::IMAGE_SAVE);
  113.                             // Get original product image I18n
  114.                             $originalProductFileI18ns = ProductImageI18nQuery::create()
  115.                                 ->findById($originalProductFile->getId());
  116.                             break;
  117.                         case 'documents':
  118.                             $dispatcher->dispatch($clonedProductCreateFileEvent, TheliaEvents::DOCUMENT_SAVE);
  120.                             // Get original product document I18n
  121.                             $originalProductFileI18ns = ProductDocumentI18nQuery::create()
  122.                                 ->findById($originalProductFile->getId());
  123.                             break;
  124.                     }
  126.                     // Set temporary source file as original one
  127.                     rename($srcTmp, $srcPath);
  129.                     // Clone file's I18n
  130.                     $this->cloneFileI18n($originalProductFileI18ns, $clonedProductFile, $type, $event, $dispatcher);
  131.                 } else {
  132.                     Tlog::getInstance()->addWarning("Failed to find media file $srcPath");
  133.                 }
  134.             }
  135.         }
  136.     }
  138.     public function cloneFileI18n($originalProductFileI18ns, $clonedProductFile, $type, ProductCloneEvent $event, EventDispatcherInterface $dispatcher): void
  139.     {
  140.         // Set clone files I18n
  141.         /** @var ProductDocumentI18n $originalProductFileI18n */
  142.         foreach ($originalProductFileI18ns as $originalProductFileI18n) {
  143.             // Update file with current I18n info. Update or create I18n according to existing or absent Locale in DB
  144.             $clonedProductFile
  145.                 ->setLocale($originalProductFileI18n->getLocale())
  146.                 ->setTitle($originalProductFileI18n->getTitle())
  147.                 ->setDescription($originalProductFileI18n->getDescription())
  148.                 ->setChapo($originalProductFileI18n->getChapo())
  149.                 ->setPostscriptum($originalProductFileI18n->getPostscriptum());
  151.             // Create and dispatch event
  152.             $clonedProductUpdateFileEvent = new FileCreateOrUpdateEvent($event->getClonedProduct()->getId());
  153.             $clonedProductUpdateFileEvent->setModel($clonedProductFile);
  155.             switch ($type) {
  156.                 case 'images':
  157.                     $dispatcher->dispatch($clonedProductUpdateFileEvent, TheliaEvents::IMAGE_UPDATE);
  158.                     break;
  159.                 case 'documents':
  160.                     $dispatcher->dispatch($clonedProductUpdateFileEvent, TheliaEvents::DOCUMENT_UPDATE);
  161.                     break;
  162.             }
  163.         }
  164.     }
  166.     /**
  167.      * {@inheritdoc}
  168.      */
  169.     public static function getSubscribedEvents()
  170.     {
  171.         return [
  172.             TheliaEvents::FILE_CLONE => ['cloneFile', 128],
  173.         ];
  174.     }
  175. }