src/EventSubscriber/EasyAdminSubscriber.php line 473

  1. <?php
  2. # src/EventSubscriber/EasyAdminSubscriber.php
  3. namespace App\EventSubscriber;
  5. use App\Entity\ExportExcel;
  6. use App\Entity\FrontTheme;
  7. use App\Entity\Settings;
  8. use App\Entity\User;
  9. use Doctrine\Common\Collections\ArrayCollection;
  10. use Doctrine\Common\Collections\Collection;
  11. use Doctrine\Persistence\ManagerRegistry;
  12. use EasyCorp\Bundle\EasyAdminBundle\Event\BeforeEntityDeletedEvent;
  13. use EasyCorp\Bundle\EasyAdminBundle\Event\BeforeEntityPersistedEvent;
  14. use EasyCorp\Bundle\EasyAdminBundle\Event\BeforeEntityUpdatedEvent;
  15. use RecursiveDirectoryIterator;
  16. use RecursiveIteratorIterator;
  17. use ReflectionClass;
  18. use ReflectionMethod;
  19. use Symfony\Component\EventDispatcher\EventSubscriberInterface;
  20. use Symfony\Component\Security\Core\Security;
  21. use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
  22. use Symfony\Component\Filesystem\Exception\IOExceptionInterface;
  23. use Symfony\Component\Filesystem\Filesystem;
  24. use Symfony\Component\Filesystem\Path;
  25. use Symfony\Component\Finder\Finder;
  26. use Symfony\Component\HttpFoundation\File\Exception\FileException;
  27. use Symfony\Component\Yaml\Yaml;
  28. use ZipArchive;
  29. use Symfony\Contracts\Translation\TranslatorInterface;
  31. class EasyAdminSubscriber implements EventSubscriberInterface
  32. {
  33.  
  35.     
  37.     public function __construct(
  38.         private readonly Security $security,
  39.         private readonly UserPasswordHasherInterface $passwordEncoder,
  40.         private readonly ManagerRegistry $doctrine,
  41.         private readonly TranslatorInterface $translatorInterface
  42.         
  43.         )
  44. {
  45.         
  46.     }
  48.     public static function getSubscribedEvents()
  49.     {
  50.         return [
  51.             BeforeEntityPersistedEvent::class => ['beforePersist'],
  52.             BeforeEntityUpdatedEvent::class => ['beforeUpdated'],
  53.             BeforeEntityDeletedEvent::class => ['beforeDelete']
  54.         ];
  55.     }
  57.     public function beforePersist(BeforeEntityPersistedEvent $event)
  58.     {
  59.         $entity = $event->getEntityInstance();
  65.         if($entity instanceof FrontTheme){
  67.             
  69.             $filesystem = new Filesystem();
  70.             $finder = new Finder();
  72.             
  73.             $path = __DIR__."/../../public/uploads/".$entity->getName();
  74.             if(!$filesystem->exists($path) )
  75.             {
  76.                 $filesystem->mkdir($path,0777);
  77.                 $filesystem->mkdir($path."/pages",0777);
  78.                 $filesystem->mkdir($path."/shop",0777);
  79.                 
  80.             }
  82.             $pathFrontBundle = __DIR__."/../Flexy/FrontBundle";
  84.             
  85.             $themePath = $pathFrontBundle."/Themes";
  87.             $filesystem->mirror($themePath."/Default",$themePath."/".ucfirst($entity->getName()));
  88.             //$filesystem->mkdir(__DIR__."/../../public/themes/".strtolower($entity->getName()),0777);
  89.             $filesystem->symlink($themePath."/".$entity->getName()."/assets", __DIR__."/../../public/themes/".strtolower($entity->getName()));
  90.             
  91.             
  92.             
  96.             //Step 1 : Copy Controllers
  97.             $finder->in($themePath."/".ucfirst($entity->getName())."/Controller");
  98.             $finder->files()->contains("Default");
  100.             
  102.             foreach ($finder as $file) {
  103.                 
  104.                 $file_contents = file_get_contents($file->getPathname());
  105.                 $file_contents = str_replace("Default\Controller", ucfirst($entity->getName())."\Controller", $file_contents);
  106.                 $file_contents = str_replace("Default\Form", ucfirst($entity->getName())."\Form", $file_contents);
  107.                 
  108.                 file_put_contents($file->getPathname(), $file_contents);
  109.             }
  110.             
  111.             
  112.             
  114.             //Step 2 : Copy Forms
  115.             
  117.             $finder->in($themePath."/".ucfirst($entity->getName())."/Form");
  118.             $finder->files()->contains("Default");
  120.             //dd($finder->hasResults());
  122.             foreach ($finder as $file) {
  123.                 
  124.                 $file_contents = file_get_contents($file->getPathname());
  125.                 $file_contents = str_replace("Default\Form", ucfirst($entity->getName())."\Form", $file_contents);
  126.                 file_put_contents($file->getPathname(), $file_contents);
  127.             }
  130.             //Step 3 : Copy assets
  131.             
  133.             //$assetsPath = $pathFrontBundle."/Resources/public/assets";
  134.             //$filesystem->mirror($assetsPath."/default",$assetsPath."/".strtolower($entity->getName())); 
  135.                       
  137.             //Step 4 : Copy Templates
  138.             
  140.             $finder->in($themePath."/".ucfirst($entity->getName())."/templates");
  142.             
  143.             $finder->files()->contains("default");
  145.             //dd($finder->hasResults());
  147.             foreach ($finder as $file) {
  148.                 
  149.                 $file_contents = file_get_contents($file->getPathname());
  150.                 $file_contents = str_replace("default/", strtolower($entity->getName())."/", $file_contents);
  151.                 file_put_contents($file->getPathname(), $file_contents);
  152.             }
  153.             
  154.             
  156.         }
  159.         if($entity instanceof Settings){
  161.             if($entity->getFrontTheme()){
  162.                 $entity->setAssetFolderName(strtolower($entity->getFrontTheme()->getName()));
  163.             }
  164.             
  166.             $filesystem = new Filesystem();
  169.             
  170.             $path = __DIR__."/../../public/uploads/".$entity->getAssetFolderName();
  171.             if(!$filesystem->exists($path) )
  172.             {
  173.                 $filesystem->mkdir($path,0777);
  174.                 $filesystem->mkdir($path."/pages",0777);
  175.                 $filesystem->mkdir($path."/shop",0777);
  176.                 
  177.             }
  179.             $pathFrontBundleRoutes = __DIR__."/../Flexy/FrontBundle/Resources/config/routes.yaml";
  180.             if($filesystem->exists($pathFrontBundleRoutes)){
  181.                 $configArray = Yaml::parseFile($pathFrontBundleRoutes);
  183.                 $configArray["controllers"]["resource"] = "../../Controller/".ucfirst($entity->getAssetFolderName());
  184.                 
  186.                 $yamlConfig = Yaml::dump($configArray);
  188.                 file_put_contents($pathFrontBundleRoutes, $yamlConfig);
  189.             }
  192.             
  193.             
  194.         } 
  195.     
  196.         
  197.         if ($entity instanceof ExportExcel) {
  199.             $entityNameSpace = $entity->getEntityNameSpace();
  201.             
  203.             $directFields = $this->doctrine->getManager()->getClassMetadata($entityNameSpace)->getColumnNames();
  204.             $associationFields = $this->doctrine->getManager()->getClassMetadata($entityNameSpace)->getAssociationMappings();
  206.             
  207.             
  208.             $entityRepository = $this->doctrine->getRepository($entityNameSpace);
  210.             $repositoryMethods = $this->getAllRepositoryMethods($entityRepository);
  212.             
  214.             $reflectionClass = $this->doctrine->getManager()->getClassMetadata($entityNameSpace)->reflClass->getMethods();// All methods detailled
  217.             
  218.             //-------------
  220.             //dd($reflectionClass[0]->name);
  221.             $fields = [];
  222.             $translatedFields = [];
  223.             foreach($reflectionClass as $singleRefClass){
  225.                 if(count($entity->getFields()) > 0 ){
  227.                     if($entity->isExcludeFields()){
  228.                         if(in_array($singleRefClass->name,$entity->getFields())){
  229.                             continue;
  230.                         }
  231.                     }else{
  232.                         if(!in_array($singleRefClass->name,$entity->getFields())){
  233.                             continue;
  234.                         }
  235.                     }
  236.                     
  238.                 }
  240.                 if (substr($singleRefClass->name, 0, 3) === "get") {
  241.                     $fields[]=$singleRefClass->name;
  242.                 } else {
  243.                     continue;
  244.                 }
  245.             }
  247.             foreach($repositoryMethods as $singleMethod){
  248.                     $fields[]=$singleMethod;
  249.             }
  252.             
  254.             //dd($fields);
  256.             //$selectedFieldsToExport = ["name","categoryProduct","subCategoryProduct","price"];
  258.             $selectedFieldsToExport = [];
  260.             $selectedFieldsToExport = array_merge($selectedFieldsToExport,$fields);
  261.             //$selectedFieldsToExport = array_merge($selectedFieldsToExport,$reflectionClass);
  264.             
  266.             if(count($entity->getFindBy())>0){
  267.                 $queryBuilder = $this->doctrine->getManager()->createQueryBuilder();
  269.                 
  270.                 $queryBuilder
  271.                     ->select('e')
  272.                     ->from($entityNameSpace, 'e');
  273.                     //->join('e.relatedEntity', 'r')
  275.                 foreach($entity->getFindBy() as $key => $value){
  276.                     $queryBuilder   
  277.                     ->where('e.'.$key.' '.$value);
  278.                 }
  279.                 if(count($entity->getOrderBy())>0){
  280.                     foreach($entity->getOrderBy() as $key => $value){
  281.                         if(gettype($key)=="integer"){
  282.                             $queryBuilder->orderBy("e.".$value);
  283.                         }else{
  284.                             $queryBuilder->orderBy("e.".$key,$value);
  285.                         }
  286.                         
  287.                     }
  288.                     
  289.                 }
  290.                 
  291.                 $entityFetchAll = $queryBuilder->getQuery()->getResult();
  292.                 
  293.                 
  294.                     
  295.             }else{
  296.                 $entityFetchAll = $this->doctrine->getManager()->getRepository($entityNameSpace)->findAll();
  297.             }
  299.             
  300.             
  302.             
  304.             $arrayToExport = [];
  305.             //$arrayToExport[]=$selectedFieldsToExport;
  307.             $correctedFieldsName =[];
  308.             foreach($fields as $field){
  309.                 $name = $this->getAbsoluteNameMethod($field);
  310.                 $correctedFieldsName[]= $this->translatorInterface->trans($name);
  311.             }
  312.             
  313.             
  315.             $arrayToExport[]=$correctedFieldsName;
  317.             foreach($entityFetchAll as $singleEntityInstance){
  319.                 
  320.                 $singleRow =[];
  321.                 foreach($fields as $singleField){
  323.                     $value=null;
  324.                     $valueSub=null;
  325.                     $valueParent=null;
  327.                     
  330.                    
  331.                     
  332.                     
  335.                         if(method_exists($singleEntityInstance,$singleField)){
  336.                             
  337.                             
  338.                             
  339.                             $value = $singleEntityInstance->{$singleField}();
  343.                             
  344.                                 if($value instanceof Collection){
  345.                                     $value = implode("\n", $value->toArray());
  346.                                     //dd($value);
  347.                                 }elseif(is_array($value)){
  348.                                     $value = implode("\n", $value);
  349.                                     //dd($value);
  350.                                 }elseif(gettype($value) == "string"){
  351.                                     $value = $this->translatorInterface->trans($value);
  352.                                 }
  353.                             
  354.     
  355.                         }elseif(method_exists($entityRepository,$singleField)){
  356.                             $value = $entityRepository->{$singleField}($singleEntityInstance->getId());
  357.                             
  358.                         
  359.                             if(is_array($value)){
  361.                                 
  363.                                 // find the index of the value 'orange'
  364.                                 $field = $this->getAbsoluteNameMethod($singleField);
  365.                                 $translatedField = $this->translatorInterface->trans($field);
  366.                                 $index = array_search($translatedField, $arrayToExport[0]);
  368.                                 // if the value exists in the array, remove it
  369.                                 if ($index !== false) {
  370.                                     unset($arrayToExport[0][$index]);
  371.                                 }
  373.                                 // re-index the array
  374.                                 //$arrayToExport = array_values($arrayToExport[0]);
  376.                                // dd($value);
  377.                                 
  378.                                 foreach($value as $singleData){
  380.                                     $translatedKey = $this->translatorInterface->trans($singleData["key"]);
  382.                                     if(!in_array($translatedKey,$arrayToExport[0])){
  385.                                         
  387.                                         $arrayToExport[0][] = $this->translatorInterface->trans($translatedKey);
  388.                                     }
  389.                                     
  390.                                     $singleRow[]=$singleData["value"];
  391.                                 }
  392.                                 
  393.                                 continue;
  394.                             }else{
  395.                                 $value = $this->translatorInterface->trans($value);
  396.                             }
  397.                         }
  398.                         $singleRow[]=$value;
  399.                     
  400.                     
  402.                 }
  403.                 $arrayToExport[]=$singleRow;
  404.             }
  406.             
  407.             
  408.             
  409.             
  410.             
  411.             $mySpreadsheet = new \PhpOffice\PhpSpreadsheet\Spreadsheet();
  412.             $mySpreadsheet->removeSheetByIndex(0);
  414.             $worksheet1 = new \PhpOffice\PhpSpreadsheet\Worksheet\Worksheet($mySpreadsheet, "List Produits");
  415.             $mySpreadsheet->addSheet($worksheet1, 0);
  416.             $worksheet1->fromArray($arrayToExport,null,"A1");
  417.             // Set the auto filter to cover all the data
  418.             $lastColumn = $worksheet1->getHighestColumn();
  419.             $lastRow = $worksheet1->getHighestDataRow();
  420.             $range = "A1:$lastColumn$lastRow";
  421.             $worksheet1->setAutoFilter($range);
  423.             foreach ($worksheet1->getColumnIterator() as $column)
  424.                 {
  425.                     $worksheet1->getColumnDimension($column->getColumnIndex())->setAutoSize(true);
  426.                     
  427.                     
  428.                 }
  429.                 foreach ($worksheet1->getRowIterator() as $row) {
  430.                     foreach ($row->getCellIterator() as $cell) {
  431.                         $cell->getStyle()->getAlignment()->setVertical(\PhpOffice\PhpSpreadsheet\Style\Alignment::VERTICAL_TOP);
  432.                     }
  433.                 }
  435.                 $writer = new \PhpOffice\PhpSpreadsheet\Writer\Xlsx($mySpreadsheet);
  438.                 
  439.                 $parts = explode("\\", $entityNameSpace);
  440.                 $nameOfFile = end($parts);
  441.                 $nameOfFile = strtolower($nameOfFile)."-".$entity->getCreatedAt()->format("Y-m-d-H-i");
  442.                 //echo $lastWord; // output: CategoryProduct
  444.                 $settings = $this->doctrine->getManager()->getRepository(Settings::class)->findOneBy(["code"=>"main"]);
  445.                 $assetFolderName = $settings->getAssetFolderName();
  446.                 $assetFolderName = strtolower($assetFolderName);
  448.                 $writer->save("uploads/".$assetFolderName."/exports/".$nameOfFile.".xlsx");
  450.                 
  451.                 $entity->setGeneratedFilePath("uploads/".$assetFolderName."/exports/".$nameOfFile.".xlsx");
  452.                 $entity->setEntityNameSpace($entityNameSpace);
  453.         
  454.             
  455.         }
  457.                 if ($entity instanceof User) {
  458.                     
  459.                    $entity->setPassword(
  460.                    $this->passwordEncoder->hashPassword(
  461.                             $entity,
  462.                             $entity->getPassword()
  463.                 ));
  464.                 
  465.             
  466.             
  467.             
  468.                 
  469.         }
  470.     }
  473.     public function beforeUpdated(BeforeEntityUpdatedEvent $event)
  474.     {
  475.         $entity = $event->getEntityInstance();
  477.         
  478.         if($entity instanceof Settings){
  480.             $filesystem = new Filesystem();
  481.             $pathFrontBundle = __DIR__."/../Flexy/FrontBundle";
  482.             $themePath = $pathFrontBundle."/Themes";
  483.             if($entity->getFrontTheme()){
  484.                 $entity->setAssetFolderName($entity->getFrontTheme()->getName());
  485.                 if(!$filesystem->exists(__DIR__."/../../public/themes/".strtolower($entity->getFrontTheme()->getName()))){
  486.                     $filesystem->symlink($themePath."/".$entity->getFrontTheme()->getName()."/assets", __DIR__."/../../public/themes/".strtolower($entity->getFrontTheme()->getName()));
  488.                 }
  489.                
  490.             }
  491.             
  494.             
  495.             $path = __DIR__."/../../public/uploads/".$entity->getAssetFolderName();
  496.             if(!$filesystem->exists($path) )
  497.             {
  498.                 $filesystem->mkdir($path,0777);
  499.                 $filesystem->mkdir($path."/pages",0777);
  500.                 $filesystem->mkdir($path."/shop",0777);
  501.                 
  502.             }
  504.             
  505.             $pathFrontBundleRoutes = __DIR__."/../Flexy/FrontBundle/Resources/config/routes.yaml";
  506.             if($filesystem->exists($pathFrontBundleRoutes)){
  507.                 $configArray = Yaml::parseFile($pathFrontBundleRoutes);
  509.                 $configArray["controllers"]["resource"] = "../../Themes/".ucfirst($entity->getAssetFolderName())."/Controller";
  510.                 
  512.                 $yamlConfig = Yaml::dump($configArray);
  514.                 file_put_contents($pathFrontBundleRoutes, $yamlConfig);
  515.             }
  516.             
  518.         }
  522.       
  524.    
  525.      
  526.     }
  528.     public function beforeDelete(BeforeEntityDeletedEvent $event){
  530.         $entity = $event->getEntityInstance();
  533.         if($entity instanceof FrontTheme){
  535.             //$entity->getSettings()->setFrontTheme(null);
  536.             $filesystem = new Filesystem();
  538.             //dd(__DIR__."/../../");
  539.             $pathFrontBundle = __DIR__."/../Flexy/FrontBundle";
  541.             
  542.             $themePath = $pathFrontBundle."/Themes";
  543.             if($filesystem->exists($themePath."/".ucfirst($entity->getName()) ) ){
  544.             
  545.             $this->zipDirectory($themePath."/".ucfirst($entity->getName()),__DIR__."/../../public/archive-themes/".strtolower($entity->getName()).".zip" );
  548.             
  549.             $filesystem->remove($themePath."/".ucfirst($entity->getName()));
  550.             
  552.                 
  553.                 
  554.             
  555.                
  556.             }
  557.             
  558.             //$filesystem->remove($pathFrontBundle."/Resources/public/assets/".strtolower($entity->getName()));
  561.             $settings = $this->doctrine->getManager()->getRepository(Settings::class)->findOneBy(["code"=>"main"]);
  562.             $currentTheme = $settings->getAssetFolderName();
  563.             $entity->removeSetting($settings);
  565.             $settings->setAssetFolderName("Default");
  567.             $this->doctrine->getManager()->persist($settings);
  570.             if(strtolower($entity->getName()) == strtolower($currentTheme) ){
  571.                 $pathFrontBundleRoutes = __DIR__."/../Flexy/FrontBundle/Resources/config/routes.yaml";
  572.                 if($filesystem->exists($pathFrontBundleRoutes)){
  573.                     $configArray = Yaml::parseFile($pathFrontBundleRoutes);
  574.     
  575.                     $configArray["controllers"]["resource"] = "../../Themes/Default/Controller";
  576.                     
  577.     
  578.                     $yamlConfig = Yaml::dump($configArray);
  579.     
  580.                     file_put_contents($pathFrontBundleRoutes, $yamlConfig);
  581.                 }
  582.             }
  583.             
  584.         }
  585.        
  587.     }
  591.     public function  exportFile($records) {
  592.         $heading = false;
  593.             if(!empty($records))
  594.               foreach($records as $row) {
  595.                 if(!$heading) {
  596.                   // display field/column names as a first row
  597.                   echo implode("\t", array_keys($row)) . "\n";
  598.                   $heading = true;
  599.                 }
  600.                 echo implode("\t", array_values($row)) . "\n";
  601.             }
  602.         
  604.     }
  607.     public static function zipDirectory($directory, $zipName)
  608. {
  609.     // Get real path for our folder
  610. $rootPath = realpath($directory);
  612. // Initialize archive object
  613. $zip = new ZipArchive();
  614. $zip->open($zipName, ZipArchive::CREATE | ZipArchive::OVERWRITE);
  616. // Initialize empty "delete list"
  617. $filesToDelete = array();
  619. // Create recursive directory iterator
  620. /** @var SplFileInfo[] $files */
  621. $files = new RecursiveIteratorIterator(
  622.     new RecursiveDirectoryIterator($rootPath),
  623.     RecursiveIteratorIterator::LEAVES_ONLY
  624. );
  626. foreach ($files as $name => $file)
  627. {
  628.     // Skip directories (they would be added automatically)
  629.     if (!$file->isDir())
  630.     {
  631.         // Get real and relative path for current file
  632.         $filePath = $file->getRealPath();
  633.         $relativePath = substr($filePath, strlen($rootPath) + 1);
  635.         // Add current file to archive
  636.         $zip->addFile($filePath, $relativePath);
  638.         // Add current file to "delete list"
  639.         // delete it later cause ZipArchive create archive only after calling close function and ZipArchive lock files until archive created)
  640.         if ($file->getFilename() != 'important.txt')
  641.         {
  642.             $filesToDelete[] = $filePath;
  643.         }
  644.     }
  645. }
  647. // Zip archive will be created only after closing object
  648. $zip->close();
  649. return $zip;
  650. }
  654. function getAbsoluteNameMethod($input) {
  655.     // Remove the "get" prefix from the input string
  656.   $input = preg_replace('/^get/', '', $input);
  657.   
  658.   // Replace all capital letters with a space followed by the letter
  659.   $output = preg_replace('/([A-Z])/', ' $1', $input);
  660.   
  661.   // Remove any leading or trailing spaces
  662.   $output = trim($output);
  663.   
  664.   // Convert the first character to uppercase
  665.   $output = ucfirst($output);
  666.   
  667.   // Return the final result
  668.   return $output;
  669.   }
  672.   public function getAllRepositoryMethods($repository)
  673. {
  674.     $reflectionClass = new ReflectionClass(get_class($repository));
  675.     $methods = $reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC);
  677.     $findMethods = [];
  678.     foreach ($methods as $method) {
  679.         $methodName = $method->getName();
  680.         if (strpos($methodName, 'export') === 0) {
  681.             $findMethods[] = $methodName;
  682.         }
  683.     }
  685.     return $findMethods;
  686. }
  688. }