vendor/artgris/filemanager-bundle/Controller/ManagerController.php line 276

  1. <?php
  3. namespace Artgris\Bundle\FileManagerBundle\Controller;
  5. use Artgris\Bundle\FileManagerBundle\Event\FileManagerEvents;
  6. use Artgris\Bundle\FileManagerBundle\Helpers\File;
  7. use Artgris\Bundle\FileManagerBundle\Helpers\FileManager;
  8. use Artgris\Bundle\FileManagerBundle\Helpers\FileManagerUploadHandler;
  9. use Artgris\Bundle\FileManagerBundle\Service\FilemanagerService;
  10. use Artgris\Bundle\FileManagerBundle\Service\FileTypeService;
  11. use Artgris\Bundle\FileManagerBundle\Twig\OrderExtension;
  12. use Symfony\Bundle\FrameworkBundle\Controller\AbstractController;
  13. use Symfony\Component\EventDispatcher\EventDispatcherInterface;
  14. use Symfony\Component\EventDispatcher\GenericEvent;
  15. use Symfony\Component\Filesystem\Exception\IOException;
  16. use Symfony\Component\Filesystem\Exception\IOExceptionInterface;
  17. use Symfony\Component\Filesystem\Filesystem;
  18. use Symfony\Component\Finder\Finder;
  19. use Symfony\Component\Finder\SplFileInfo;
  20. use Symfony\Component\Form\Extension\Core\Type\FormType;
  21. use Symfony\Component\Form\Extension\Core\Type\HiddenType;
  22. use Symfony\Component\Form\Extension\Core\Type\SubmitType;
  23. use Symfony\Component\Form\Extension\Core\Type\TextType;
  24. use Symfony\Component\Form\Form;
  25. use Symfony\Component\Form\FormFactoryInterface;
  26. use Symfony\Component\Form\FormInterface;
  27. use Symfony\Component\HttpFoundation\BinaryFileResponse;
  28. use Symfony\Component\HttpFoundation\JsonResponse;
  29. use Symfony\Component\HttpFoundation\RedirectResponse;
  30. use Symfony\Component\HttpFoundation\Request;
  31. use Symfony\Component\HttpFoundation\Response;
  32. use Symfony\Component\Routing\Annotation\Route;
  33. use Symfony\Component\Routing\RouterInterface;
  34. use Symfony\Component\Validator\Constraints\NotBlank;
  35. use Symfony\Contracts\Translation\TranslatorInterface;
  36. use Exception;
  38. /**
  39.  * @author Arthur Gribet <a.gribet@gmail.com>
  40.  */
  41. class ManagerController extends AbstractController {
  43.     private FileManager $fileManager;
  45.     /**
  46.      * ManagerController constructor.
  47.      */
  48.     public function __construct(private FilemanagerService $filemanagerService, private EventDispatcherInterface $dispatcher, private TranslatorInterface $translator, private RouterInterface $router, private FormFactoryInterface $formFactory) {
  49.     }
  51.     #[Route('/', name: 'file_manager')]
  52.     public function indexAction(Request $request, FileTypeService $fileTypeService): JsonResponse|Response {
  53.         $queryParameters = $request->query->all();
  54.         $isJson = $request->get('json');
  55.         if ($isJson) {
  56.             unset($queryParameters['json']);
  57.         }
  58.         $fileManager = $this->newFileManager($queryParameters);
  60.         // Folder search
  61.         $directoriesArbo = $this->retrieveSubDirectories($fileManager, $fileManager->getDirName(), \DIRECTORY_SEPARATOR, $fileManager->getBaseName());
  63.         // File search
  64.         $finderFiles = new Finder();
  65.         $finderFiles->in($fileManager->getCurrentPath())->depth(0);
  66.         $regex = $fileManager->getRegex();
  68.         $orderBy = $fileManager->getQueryParameter('orderby');
  69.         $orderDESC = OrderExtension::DESC === $fileManager->getQueryParameter('order');
  70.         if (!$orderBy) {
  71.             $finderFiles->sortByType();
  72.         }
  74.         switch ($orderBy) {
  75.             case 'name':
  76.                 $finderFiles->sort(function (SplFileInfo $a, SplFileInfo $b) {
  77.                     return strcmp(mb_strtolower($b->getFilename()), mb_strtolower($a->getFilename()));
  78.                 });
  79.                 break;
  80.             case 'date':
  81.                 $finderFiles->sortByModifiedTime();
  82.                 break;
  83.             case 'size':
  84.                 $finderFiles->sort(function (\SplFileInfo $a, \SplFileInfo $b) {
  85.                     return $a->getSize() - $b->getSize();
  86.                 });
  87.                 break;
  88.         }
  90.         if ($fileManager->getTree()) {
  91.             $finderFiles->files()->name($regex)->filter(function (SplFileInfo $file) {
  92.                 return $file->isReadable();
  93.             });
  94.         } else {
  95.             $finderFiles->filter(function (SplFileInfo $file) use ($regex) {
  96.                 if ('file' === $file->getType()) {
  97.                     if (preg_match($regex, $file->getFilename())) {
  98.                         return $file->isReadable();
  99.                     }
  101.                     return false;
  102.                 }
  104.                 return $file->isReadable();
  105.             });
  106.         }
  108.         $this->dispatch(FileManagerEvents::POST_FILE_FILTER_CONFIGURATION, ['finder' => $finderFiles]);
  110.         $formDelete = $this->createDeleteForm()->createView();
  111.         $fileArray = [];
  112.         foreach ($finderFiles as $file) {
  113.             $fileArray[] = new File($file, $this->translator, $fileTypeService, $fileManager);
  114.         }
  116.         if ('dimension' === $orderBy) {
  117.             usort($fileArray, function (File $a, File $b) {
  118.                 $aDimension = $a->getDimension();
  119.                 $bDimension = $b->getDimension();
  120.                 if ($aDimension && !$bDimension) {
  121.                     return 1;
  122.                 }
  124.                 if (!$aDimension && $bDimension) {
  125.                     return -1;
  126.                 }
  128.                 if (!$aDimension && !$bDimension) {
  129.                     return 0;
  130.                 }
  132.                 return ($aDimension[0] * $aDimension[1]) - ($bDimension[0] * $bDimension[1]);
  133.             });
  134.         }
  136.         if ($orderDESC) {
  137.             $fileArray = array_reverse($fileArray);
  138.         }
  140.         $parameters = [
  141.             'fileManager' => $fileManager,
  142.             'fileArray' => $fileArray,
  143.             'formDelete' => $formDelete,
  144.         ];
  145.         if ($isJson) {
  146.             $fileList = $this->renderView('@ArtgrisFileManager/views/_manager_view.html.twig', $parameters);
  148.             return new JsonResponse(['data' => $fileList, 'badge' => $finderFiles->count(), 'treeData' => $directoriesArbo]);
  149.         }
  150.         $parameters['treeData'] = json_encode($directoriesArbo);
  152.         $form = $this->formFactory->createNamedBuilder('rename', FormType::class)
  153.             ->add('name', TextType::class, [
  154.                 'constraints' => [
  155.                     new NotBlank(),
  156.                 ],
  157.                 'label' => false,
  158.                 'data' => $this->translator->trans('input.default'),
  159.             ])
  160.             ->add('send', SubmitType::class, [
  161.                 'attr' => [
  162.                     'class' => 'btn btn-primary',
  163.                 ],
  164.                 'label' => $this->translator->trans('button.save'),
  165.             ])
  166.             ->getForm();
  168.         /* @var Form $form */
  169.         $form->handleRequest($request);
  170.         /** @var Form $formRename */
  171.         $formRename = $this->createRenameForm();
  173.         if ($form->isSubmitted() && $form->isValid()) {
  174.             $data = $form->getData();
  175.             $fs = new Filesystem();
  176.             $directory = $directorytmp = $fileManager->getCurrentPath().\DIRECTORY_SEPARATOR.$data['name'];
  177.             $i = 1;
  179.             while ($fs->exists($directorytmp)) {
  180.                 $directorytmp = "{$directory} ({$i})";
  181.                 ++$i;
  182.             }
  183.             $directory = $directorytmp;
  185.             try {
  186.                 $fs->mkdir($directory);
  187.                 $this->addFlash('success', $this->translator->trans('folder.add.success'));
  188.             } catch (IOExceptionInterface $e) {
  189.                 $this->addFlash('danger', $this->translator->trans('folder.add.danger', ['%message%' => $data['name']]));
  190.             }
  192.             return $this->redirectToRoute('file_manager', $fileManager->getQueryParameters());
  193.         }
  194.         $parameters['form'] = $form->createView();
  195.         $parameters['formRename'] = $formRename->createView();
  197.         return $this->render('@ArtgrisFileManager/manager.html.twig', $parameters);
  198.     }
  200.     #[Route("/rename/{fileName}", name: 'file_manager_rename')]
  201.     public function renameFileAction(Request $request, string $fileName): RedirectResponse {
  202.         $queryParameters = $request->query->all();
  203.         $formRename = $this->createRenameForm();
  204.         /* @var Form $formRename */
  205.         $formRename->handleRequest($request);
  206.         if ($formRename->isSubmitted() && $formRename->isValid()) {
  207.             $data = $formRename->getData();
  208.             $extension = $data['extension'] ? '.'.$data['extension'] : '';
  209.             $newfileName = $data['name'].$extension;
  210.             if ($newfileName !== $fileName && isset($data['name'])) {
  211.                 $fileManager = $this->newFileManager($queryParameters);
  212.                 $newfilePath = $fileManager->getCurrentPath().\DIRECTORY_SEPARATOR.$newfileName;
  213.                 $oldfilePath = realpath($fileManager->getCurrentPath().\DIRECTORY_SEPARATOR.$fileName);
  214.                 if (0 !== mb_strpos($newfilePath, $fileManager->getCurrentPath())) {
  215.                     $this->addFlash('danger', $this->translator->trans('file.renamed.unauthorized'));
  216.                 } else {
  217.                     $fs = new Filesystem();
  218.                     try {
  219.                         $this->dispatch(FileManagerEvents::RENAME_FILE, ['oldFile'=> $oldfilePath,'newFile'=> $newfilePath]);
  220.                         $fs->rename($oldfilePath, $newfilePath);
  221.                         $this->addFlash('success', $this->translator->trans('file.renamed.success'));
  222.                         //File has been renamed successfully
  223.                     } catch (IOException $exception) {
  224.                         $this->addFlash('danger', $this->translator->trans('file.renamed.danger'));
  225.                     } catch (Exception $exception) {
  226.                         $this->addFlash('danger', $exception->getMessage() );
  227.                     }
  228.                 }
  229.             } else {
  230.                 $this->addFlash('warning', $this->translator->trans('file.renamed.nochanged'));
  231.             }
  232.         }
  234.         return $this->redirectToRoute('file_manager', $queryParameters);
  235.     }
  237.     #[Route("/upload/", name: 'file_manager_upload')]
  238.     public function uploadFileAction(Request $request): JsonResponse|Response {
  239.         $fileManager = $this->newFileManager($request->query->all());
  241.         $options = [
  242.             'upload_dir' => $fileManager->getCurrentPath().\DIRECTORY_SEPARATOR,
  243.             'upload_url' => implode('/', array_map('rawurlencode', explode('/', $fileManager->getImagePath()))),
  244.             'accept_file_types' => $fileManager->getRegex(),
  245.             'print_response' => false,
  246.             'override' => false,
  247.             'image_versions' => array(
  248.                 '' => array(
  249.                     'auto_orient' => true
  250.                 ),
  251.             ),
  252.         ];
  253.         if (isset($fileManager->getConfiguration()['upload'])) {
  254.             $options = $fileManager->getConfiguration()['upload'] + $options;
  255.         }
  257.         $this->dispatch(FileManagerEvents::PRE_UPDATE, ['options' => &$options]);
  258.         $uploadHandler = new FileManagerUploadHandler($options);
  259.         $response = $uploadHandler->get_response();
  261.         foreach ($response['files'] as $file) {
  262.             if (isset($file->error)) {
  263.                 $file->error = $this->translator->trans($file->error);
  264.             } else {
  265.                 if (!$fileManager->getImagePath()) {
  266.                     $file->url = $this->generateUrl('file_manager_file', array_merge($fileManager->getQueryParameters(), ['fileName' => $file->url]));
  267.                 }
  268.             }
  269.         }
  270.         $this->dispatch(FileManagerEvents::POST_UPDATE, ['response' => &$response]);
  272.         return new JsonResponse($response);
  273.     }
  275.     #[Route("/file/{fileName}", name: 'file_manager_file')]
  276.     public function binaryFileResponseAction(Request $request, string $fileName): BinaryFileResponse {
  277.         $fileManager = $this->newFileManager($request->query->all());
  279.         $file = $fileManager->getCurrentPath().\DIRECTORY_SEPARATOR.urldecode($fileName);
  280.         $this->dispatch(FileManagerEvents::FILE_ACCESS, ['path' => $file]);
  282.         return new BinaryFileResponse($file);
  283.     }
  285.     #[Route("/delete/", name: 'file_manager_delete')]
  286.     public function deleteAction(Request $request): RedirectResponse {
  287.         $form = $this->createDeleteForm();
  288.         $form->handleRequest($request);
  289.         $queryParameters = $request->query->all();
  290.         if ($form->isSubmitted() && $form->isValid()) {
  291.             // remove file
  292.             $fileManager = $this->newFileManager($queryParameters);
  293.             $fs = new Filesystem();
  294.             if (isset($queryParameters['delete'])) {
  295.                 $is_delete = false;
  296.                 foreach ($queryParameters['delete'] as $fileName) {
  297.                     $filePath = realpath($fileManager->getCurrentPath().\DIRECTORY_SEPARATOR.$fileName);
  298.                     if (0 !== mb_strpos($filePath, $fileManager->getCurrentPath())) {
  299.                         $this->addFlash('danger', 'file.deleted.danger');
  300.                     } else {
  301.                          try {
  302.                             $this->dispatch(FileManagerEvents::PRE_DELETE_FILE);
  303.                             $fs->remove($filePath);
  304.                             $is_delete = true;
  305.                             $this->dispatch(FileManagerEvents::POST_DELETE_FILE);
  306.                         } catch (IOException $exception) {
  307.                             $this->addFlash('danger', 'file.deleted.unauthorized');
  308.                         } catch (Exception $exception) {
  309.                             $this->addFlash('danger', $exception->getMessage() );
  310.                         }
  311.                     }
  312.                 }
  313.                 if ($is_delete) {
  314.                     $this->addFlash('success', 'file.deleted.success');
  315.                 }
  316.                 unset($queryParameters['delete']);
  317.             } else {
  318.                 
  319.                 try {
  320.                     $this->dispatch(FileManagerEvents::PRE_DELETE_FOLDER);
  321.                     $fs->remove($fileManager->getCurrentPath());
  322.                     $this->addFlash('success', 'folder.deleted.success');
  323.                 } catch (IOException $exception) {
  324.                     $this->addFlash('danger', 'folder.deleted.unauthorized');
  325.                 } catch (Exception $exception) {
  326.                     $this->addFlash('danger', $exception->getMessage() );
  327.                 }
  329.                 $this->dispatch(FileManagerEvents::POST_DELETE_FOLDER);
  330.                 $queryParameters['route'] = \dirname($fileManager->getCurrentRoute());
  331.                 if ($queryParameters['route'] == '/') {
  332.                     unset($queryParameters['route']);
  333.                 }
  335.                 return $this->redirectToRoute('file_manager', $queryParameters);
  336.             }
  337.         }
  339.         return $this->redirectToRoute('file_manager', $queryParameters);
  340.     }
  342.     private function createDeleteForm(): FormInterface|Form {
  343.         return $this->formFactory->createNamedBuilder('delete_f')
  344.             ->add('DELETE', SubmitType::class, [
  345.                 'translation_domain' => 'messages',
  346.                 'attr' => [
  347.                     'class' => 'btn btn-danger',
  348.                 ],
  349.                 'label' => 'button.delete.action',
  350.             ])
  351.             ->getForm();
  352.     }
  354.     private function createRenameForm(): FormInterface|Form {
  355.         return $this->formFactory->createNamedBuilder('rename_f')
  356.             ->add('name', TextType::class, [
  357.                 'constraints' => [
  358.                     new NotBlank(),
  359.                 ],
  360.                 'label' => false,
  361.             ])->add('extension', HiddenType::class)
  362.             ->add('send', SubmitType::class, [
  363.                 'attr' => [
  364.                     'class' => 'btn btn-primary',
  365.                 ],
  366.                 'label' => 'button.rename.action',
  367.             ])
  368.             ->getForm();
  369.     }
  371.     private function retrieveSubDirectories(FileManager $fileManager, string $path, ?string $parent = \DIRECTORY_SEPARATOR, ?string $baseFolderName = null): ?array {
  372.         $directories = new Finder();
  373.         $directories->in($path)->ignoreUnreadableDirs()->directories()->depth(0)->sortByType()->filter(function (SplFileInfo $file) {
  374.             return $file->isReadable();
  375.         });
  377.         $this->dispatch(FileManagerEvents::POST_DIRECTORY_FILTER_CONFIGURATION, ['finder' => $directories]);
  379.         if ($baseFolderName) {
  380.             $directories->name($baseFolderName);
  381.         }
  382.         $directoriesList = null;
  384.         foreach ($directories as $directory) {
  385.             /** @var SplFileInfo $directory */
  386.             $directoryFileName = $directory->getFilename();
  387.             $fileName = $baseFolderName ? '' : $parent.$directoryFileName;
  389.             $queryParameters = $fileManager->getQueryParameters();
  390.             $queryParameters['route'] = $fileName;
  391.             $queryParametersRoute = $queryParameters;
  392.             unset($queryParametersRoute['route']);
  394.             $fileSpan = '';
  395.             if (true === $fileManager->getConfiguration()['show_file_count']) {
  396.                 $filesNumber = $this->retrieveFilesNumber($directory->getPathname(), $fileManager->getRegex());
  397.                 $fileSpan = $filesNumber > 0 ? " <span class='label label-default'>{$filesNumber}</span>" : '';
  398.             }
  400.             if ($fileName === '' && isset($fileManager->getConfiguration()['root_name'])) {
  401.                 $directoryFileName = $fileManager->getConfiguration()['root_name'];
  402.             }
  404.             $directoriesList[] = [
  405.                 'text' => $directoryFileName.$fileSpan,
  406.                 'icon' => 'far fa-folder-open',
  407.                 'children' => $this->retrieveSubDirectories($fileManager, $directory->getPathname(), $fileName.\DIRECTORY_SEPARATOR),
  408.                 'a_attr' => [
  409.                     'href' => $fileName ? $this->generateUrl('file_manager', $queryParameters) : $this->generateUrl('file_manager', $queryParametersRoute),
  410.                 ],
  411.                 'state' => [
  412.                     'selected' => $fileManager->getCurrentRoute() === $fileName,
  413.                     'opened' => true,
  414.                 ],
  415.             ];
  416.         }
  418.         return $directoriesList;
  419.     }
  421.     /**
  422.      * Tree Iterator.
  423.      */
  424.     private function retrieveFilesNumber(string $path,string $regex): int {
  425.         $files = new Finder();
  426.         $files->in($path)->files()->depth(0)->name($regex);
  427.         $this->dispatch(FileManagerEvents::POST_FILE_FILTER_CONFIGURATION, ['finder' => $files]);
  429.         return iterator_count($files);
  430.     }
  432.     private function newFileManager(array $queryParameters): FileManager {
  433.         if (!isset($queryParameters['conf'])) {
  434.             throw new \RuntimeException('Please define a conf parameter in your route');
  435.         }
  436.         $webDir = $this->getParameter('artgris_file_manager')['web_dir'];
  437.         $this->fileManager = new FileManager($queryParameters, $this->filemanagerService->getBasePath($queryParameters), $this->router, $this->dispatcher, $webDir);
  439.         return $this->fileManager;
  440.     }
  442.     protected function dispatch(string $eventName, array $arguments = []) {
  443.         $arguments = array_replace([
  444.             'filemanager' => $this->fileManager,
  445.         ], $arguments);
  447.         $subject = $arguments['filemanager'];
  448.         $event = new GenericEvent($subject, $arguments);
  449.         $this->dispatcher->dispatch($event, $eventName);
  450.     }
  451. }