src/EventSubscriber/EasyAdminSubscriber.php line 57

  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__."/../IlaveU/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__."/../IlaveU/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.             
  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 || $entity->getStartingAt() || $entity->getEndingAt()){
  267.                 $queryBuilder = $this->doctrine->getManager()->createQueryBuilder();
  269.                 
  270.                 $queryBuilder
  271.                     ->select('e')
  272.                     ->from($entityNameSpace, 'e')
  273.                     //->join('e.relatedEntity', 'r')
  274.                     // ->andWhere('JSON_CONTAINS(e.metaData, :metadataAPE) = 1  OR JSON_CONTAINS(e.metaData, :metadataNAF) = 1')
  275.                     // ->setParameter("metadataAPE",'{"key": "CodeAPE"}')
  276.                     // ->setParameter("metadataNAF",'{"key": "CodeNAF"}')
  277.                     ;
  280.                     
  282.                 foreach($entity->getFindBy() as $key => $value){
  283.                     $queryBuilder   
  284.                     ->andWhere('e.'.$key.' '.$value);
  285.                 }
  286.                 if($entity->getStartingAt()){
  287.                     $queryBuilder->andWhere('e.createdAt >= :startingAt')->setParameter('startingAt', $entity->getStartingAt());
  288.                 }
  289.                 if($entity->getEndingAt()){
  290.                     $queryBuilder->andWhere('e.createdAt <= :endingAt')->setParameter('endingAt', $entity->getEndingAt());
  291.                 }
  292.                 
  293.                 if(count($entity->getOrderBy())>0){
  294.                     foreach($entity->getOrderBy() as $key => $value){
  295.                         if(gettype($key)=="integer"){
  296.                             $queryBuilder->orderBy("e.".$value);
  297.                         }else{
  298.                             $queryBuilder->orderBy("e.".$key,$value);
  299.                         }
  300.                         
  301.                     }
  302.                     
  303.                 }
  304.                 //$queryBuilder->setMaxResults(500);
  305.                 
  306.                 $entityFetchAll = $queryBuilder->getQuery()->getResult();
  309.                 
  311.                 
  313.                 
  314.                 
  315.                 
  316.                 
  317.                     
  318.             }else{
  319.                 $queryBuilder = $this->doctrine->getManager()->createQueryBuilder();
  321.                 
  322.                     $queryBuilder
  323.                         ->select('e')
  324.                         ->from($entityNameSpace, 'e');
  325.                         //->join('e.relatedEntity', 'r')
  326.                         //$queryBuilder->setMaxResults(500);
  327.                     $entityFetchAll = $queryBuilder->getQuery()->getResult();
  328.             }
  330.             
  331.             
  333.             
  335.             $arrayToExport = [];
  337.             $correctedFieldsName =[];
  338.             foreach($fields as $field){
  339.                 if($field == "getMetaData"){
  340.                     continue;
  341.                 }
  342.                 
  343.                 $name = $this->getAbsoluteNameMethod($field);
  344.                 $correctedFieldsName[]= $this->translatorInterface->trans($name,[],"ilaveu-admin");
  345.             }
  348.             foreach($entity->getMetaDataFields() as $singleField){
  349.                 $correctedFieldsName[]= $this->translatorInterface->trans($singleField,[],"ilaveu-admin");
  350.             }
  352.             
  353.             
  354.             
  356.             $arrayToExport[]=$correctedFieldsName;
  358.             
  360.             foreach($entityFetchAll as $singleEntityInstance){
  362.                 
  363.                 $singleRow =[];
  364.                 $singleMetaDataValue = [];
  365.                 foreach($fields as $singleField){
  367.                     $value=null;
  368.                     $valueSub=null;
  369.                     $valueParent=null;
  370.                     
  372.                     
  375.                    
  376.                     
  377.                     
  380.                         if(method_exists($singleEntityInstance,$singleField)){
  381.                             
  382.                             
  383.                             
  384.                             $value = $singleEntityInstance->{$singleField}();
  388.                             
  389.                                 if($value instanceof Collection){
  390.                                     $value = implode("\n", $value->toArray());
  391.                                     //dd($value);
  392.                                 }elseif(is_array($value)){
  393.                                     
  395.                                     if($singleField == "getMetaData"){
  396.                                         
  398.                                         
  399.                                         foreach($entity->getMetaDataFields() as $singleField){
  400.                                             $singleMetaDataValue[] = $this->getMetaDataValue($value,$singleField);
  401.                                             continue;
  402.                                         }
  403.                                         continue;
  404.                                     
  406.                                     foreach($value as $k=>$v){
  409.                                         if(in_array($k,$entity->getMetaDataFields())){
  410.                                                 
  411.                                                 $singleMetaDataValue[]=$v["value"];
  412.                                                 
  413.                                         }else
  414.                                         dd("None");
  417.                                             
  418.                                             
  419.                                             
  420.                                             
  421.                                         }
  423.                                         
  425.                                         continue;
  426.                                     }
  427.                                     
  428.                                     
  429.                                     $value = $this->implode_multidimensional($value,"\n");
  430.                                     
  431.                                 }elseif(gettype($value) == "string"){
  432.                                     $value = $this->translatorInterface->trans($value);
  433.                                 }
  434.                             
  435.     
  436.                         }elseif(method_exists($entityRepository,$singleField)){
  437.                             $value = $entityRepository->{$singleField}($singleEntityInstance->getId());
  438.                             
  439.                         
  440.                             if(is_array($value)){
  442.                                 
  444.                                 // find the index of the value 'orange'
  445.                                 $field = $this->getAbsoluteNameMethod($singleField);
  446.                                
  449.                                 $translatedField = $this->translatorInterface->trans($field);
  450.                                 $index = array_search($translatedField, $arrayToExport[0]);
  452.                                 // if the value exists in the array, remove it
  453.                                 if ($index !== false) {
  454.                                     unset($arrayToExport[0][$index]);
  455.                                 }
  457.                                 // re-index the array
  458.                                 //$arrayToExport = array_values($arrayToExport[0]);
  460.                                // dd($value);
  461.                                 
  462.                                 foreach($value as $singleData){
  464.                                     $translatedKey = $this->translatorInterface->trans($singleData["key"]);
  466.                                     if(!in_array($translatedKey,$arrayToExport[0])){
  469.                                         
  471.                                         $arrayToExport[0][] = $this->translatorInterface->trans($translatedKey);
  472.                                     }
  473.                                     
  474.                                     $singleRow[]=$singleData["value"];
  475.                                 }
  476.                                 
  477.                                 continue;
  478.                             }else{
  479.                                 $value = $this->translatorInterface->trans($value);
  480.                             }
  481.                         }
  482.                         $singleRow[]=$value;
  483.                     
  484.                     
  486.                 }
  487.                 
  488.                 
  489.                 
  490.                 
  491.                 foreach($singleMetaDataValue  as $singleMetaDataVal){
  492.                     //dd($singleMetaDataVal);
  493.                     if(is_array($singleMetaDataVal)){
  494.                         
  495.                         $singleRow[] = $this->implode_multidimensional($singleMetaDataVal,", ");
  496.                         continue;
  497.                     }
  499.                     $singleRow[] = $singleMetaDataVal;
  500.                 }
  501.                 $arrayToExport[]=$singleRow;
  502.                 //dd($arrayToExport);
  503.             }
  505.             //dd($arrayToExport);
  506.             
  507.             
  508.             
  509.             
  510.             $mySpreadsheet = new \PhpOffice\PhpSpreadsheet\Spreadsheet();
  511.             $mySpreadsheet->removeSheetByIndex(0);
  513.             $worksheet1 = new \PhpOffice\PhpSpreadsheet\Worksheet\Worksheet($mySpreadsheet, "List Produits");
  514.             $mySpreadsheet->addSheet($worksheet1, 0);
  515.             $worksheet1->fromArray($arrayToExport,null,"A1");
  516.             // Set the auto filter to cover all the data
  517.             $lastColumn = $worksheet1->getHighestColumn();
  518.             $lastRow = $worksheet1->getHighestDataRow();
  519.             $range = "A1:$lastColumn$lastRow";
  520.             $worksheet1->setAutoFilter($range);
  522.             foreach ($worksheet1->getColumnIterator() as $column)
  523.                 {
  524.                     $worksheet1->getColumnDimension($column->getColumnIndex())->setAutoSize(true);
  525.                     
  526.                     
  527.                 }
  528.                 foreach ($worksheet1->getRowIterator() as $row) {
  529.                     foreach ($row->getCellIterator() as $cell) {
  530.                         $cell->getStyle()->getAlignment()->setVertical(\PhpOffice\PhpSpreadsheet\Style\Alignment::VERTICAL_TOP);
  531.                     }
  532.                 }
  534.                 $writer = new \PhpOffice\PhpSpreadsheet\Writer\Xlsx($mySpreadsheet);
  537.                 
  538.                 $parts = explode("\\", $entityNameSpace);
  539.                 $nameOfFile = end($parts);
  540.                 $nameOfFile = strtolower($nameOfFile)."-".$entity->getCreatedAt()->format("Y-m-d-H-i");
  541.                 //echo $lastWord; // output: CategoryProduct
  543.                 $settings = $this->doctrine->getManager()->getRepository(Settings::class)->findOneBy(["code"=>"main"]);
  544.                 $assetFolderName = $settings->getAssetFolderName();
  545.                 $assetFolderName = strtolower($assetFolderName);
  547.                 $writer->save("uploads/".$assetFolderName."/exports/".$nameOfFile.".xlsx");
  549.                 
  550.                 $entity->setGeneratedFilePath("uploads/".$assetFolderName."/exports/".$nameOfFile.".xlsx");
  551.                 $entity->setEntityNameSpace($entityNameSpace);
  552.         
  553.             
  554.         }
  556.                 if ($entity instanceof User) {
  557.                     
  558.                    $entity->setPassword(
  559.                    $this->passwordEncoder->hashPassword(
  560.                             $entity,
  561.                             $entity->getPassword()
  562.                 ));
  563.                 
  564.             
  565.             
  566.             
  567.                 
  568.         }
  569.     }
  572.     public function beforeUpdated(BeforeEntityUpdatedEvent $event)
  573.     {
  574.         $entity = $event->getEntityInstance();
  576.         
  577.         if($entity instanceof Settings){
  579.             $filesystem = new Filesystem();
  580.             $pathFrontBundle = __DIR__."/../IlaveU/FrontBundle";
  581.             $themePath = $pathFrontBundle."/Themes";
  582.             if($entity->getFrontTheme()){
  583.                 $entity->setAssetFolderName($entity->getFrontTheme()->getName());
  584.                 if(!$filesystem->exists(__DIR__."/../../public/themes/".strtolower($entity->getFrontTheme()->getName()))){
  585.                     $filesystem->symlink($themePath."/".$entity->getFrontTheme()->getName()."/assets", __DIR__."/../../public/themes/".strtolower($entity->getFrontTheme()->getName()));
  587.                 }
  588.                
  589.             }
  590.             
  593.             
  594.             $path = __DIR__."/../../public/uploads/".$entity->getAssetFolderName();
  595.             if(!$filesystem->exists($path) )
  596.             {
  597.                 $filesystem->mkdir($path,0777);
  598.                 $filesystem->mkdir($path."/pages",0777);
  599.                 $filesystem->mkdir($path."/shop",0777);
  600.                 
  601.             }
  603.             
  604.             $pathFrontBundleRoutes = __DIR__."/../IlaveU/FrontBundle/Resources/config/routes.yaml";
  605.             if($filesystem->exists($pathFrontBundleRoutes)){
  606.                 $configArray = Yaml::parseFile($pathFrontBundleRoutes);
  608.                 $configArray["controllers"]["resource"] = "../../Themes/".ucfirst($entity->getAssetFolderName())."/Controller";
  609.                 
  611.                 $yamlConfig = Yaml::dump($configArray);
  613.                 file_put_contents($pathFrontBundleRoutes, $yamlConfig);
  614.             }
  615.             
  617.         }
  621.       
  623.    
  624.      
  625.     }
  627.     public function beforeDelete(BeforeEntityDeletedEvent $event){
  629.         $entity = $event->getEntityInstance();
  632.         if($entity instanceof FrontTheme){
  634.             //$entity->getSettings()->setFrontTheme(null);
  635.             $filesystem = new Filesystem();
  637.             //dd(__DIR__."/../../");
  638.             $pathFrontBundle = __DIR__."/../IlaveU/FrontBundle";
  640.             
  641.             $themePath = $pathFrontBundle."/Themes";
  642.             if($filesystem->exists($themePath."/".ucfirst($entity->getName()) ) ){
  643.             
  644.             $this->zipDirectory($themePath."/".ucfirst($entity->getName()),__DIR__."/../../public/archive-themes/".strtolower($entity->getName()).".zip" );
  647.             
  648.             $filesystem->remove($themePath."/".ucfirst($entity->getName()));
  649.             
  651.                 
  652.                 
  653.             
  654.                
  655.             }
  656.             
  657.             //$filesystem->remove($pathFrontBundle."/Resources/public/assets/".strtolower($entity->getName()));
  660.             $settings = $this->doctrine->getManager()->getRepository(Settings::class)->findOneBy(["code"=>"main"]);
  661.             $currentTheme = $settings->getAssetFolderName();
  662.             $entity->removeSetting($settings);
  664.             $settings->setAssetFolderName("Default");
  666.             $this->doctrine->getManager()->persist($settings);
  669.             if(strtolower($entity->getName()) == strtolower($currentTheme) ){
  670.                 $pathFrontBundleRoutes = __DIR__."/../IlaveU/FrontBundle/Resources/config/routes.yaml";
  671.                 if($filesystem->exists($pathFrontBundleRoutes)){
  672.                     $configArray = Yaml::parseFile($pathFrontBundleRoutes);
  673.     
  674.                     $configArray["controllers"]["resource"] = "../../Themes/Default/Controller";
  675.                     
  676.     
  677.                     $yamlConfig = Yaml::dump($configArray);
  678.     
  679.                     file_put_contents($pathFrontBundleRoutes, $yamlConfig);
  680.                 }
  681.             }
  682.             
  683.         }
  684.        
  686.     }
  690.     public function  exportFile($records) {
  691.         $heading = false;
  692.             if(!empty($records))
  693.               foreach($records as $row) {
  694.                 if(!$heading) {
  695.                   // display field/column names as a first row
  696.                   echo implode("\t", array_keys($row)) . "\n";
  697.                   $heading = true;
  698.                 }
  699.                 echo implode("\t", array_values($row)) . "\n";
  700.             }
  701.         
  703.     }
  706.     public static function zipDirectory($directory, $zipName)
  707. {
  708.     // Get real path for our folder
  709. $rootPath = realpath($directory);
  711. // Initialize archive object
  712. $zip = new ZipArchive();
  713. $zip->open($zipName, ZipArchive::CREATE | ZipArchive::OVERWRITE);
  715. // Initialize empty "delete list"
  716. $filesToDelete = array();
  718. // Create recursive directory iterator
  719. /** @var SplFileInfo[] $files */
  720. $files = new RecursiveIteratorIterator(
  721.     new RecursiveDirectoryIterator($rootPath),
  722.     RecursiveIteratorIterator::LEAVES_ONLY
  723. );
  725. foreach ($files as $name => $file)
  726. {
  727.     // Skip directories (they would be added automatically)
  728.     if (!$file->isDir())
  729.     {
  730.         // Get real and relative path for current file
  731.         $filePath = $file->getRealPath();
  732.         $relativePath = substr($filePath, strlen($rootPath) + 1);
  734.         // Add current file to archive
  735.         $zip->addFile($filePath, $relativePath);
  737.         // Add current file to "delete list"
  738.         // delete it later cause ZipArchive create archive only after calling close function and ZipArchive lock files until archive created)
  739.         if ($file->getFilename() != 'important.txt')
  740.         {
  741.             $filesToDelete[] = $filePath;
  742.         }
  743.     }
  744. }
  746. // Zip archive will be created only after closing object
  747. $zip->close();
  748. return $zip;
  749. }
  753. function getAbsoluteNameMethod($input) {
  754.     // Remove the "get" prefix from the input string
  755.   $input = preg_replace('/^get/', '', $input);
  756.   
  757.   // Replace all capital letters with a space followed by the letter
  758.   $output = preg_replace('/([A-Z])/', ' $1', $input);
  759.   
  760.   // Remove any leading or trailing spaces
  761.   $output = trim($output);
  762.   
  763.   // Convert the first character to uppercase
  764.   $output = ucfirst($output);
  765.   
  766.   // Return the final result
  767.   return $output;
  768.   }
  771.   public function getAllRepositoryMethods($repository)
  772. {
  773.     $reflectionClass = new ReflectionClass(get_class($repository));
  774.     $methods = $reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC);
  776.     $findMethods = [];
  777.     foreach ($methods as $method) {
  778.         $methodName = $method->getName();
  779.         if (strpos($methodName, 'export') === 0) {
  780.             $findMethods[] = $methodName;
  781.         }
  782.     }
  784.     return $findMethods;
  785. }
  790. function is_multidimensional(array $array) {
  791.     foreach ($array as $element) {
  792.         if (is_array($element)) {
  793.             return true;
  794.         }
  795.     }
  796.     return false;
  797. }
  799. function implode_multidimensional(array $array, $glue = ', ') {
  800.     $result = [];
  801.     
  802.     foreach ($array as $key => $element) {
  803.         if (is_array($element)) {
  804.             $element = $this->implode_multidimensional($element, $glue);
  805.         }
  807.         //$result[] = "{$key}:{$element}";
  808.         if(!in_array("{$element}",$result)){
  809.             $result[] = "{$element}";
  810.         }
  811.         
  813.         
  814.     }
  815.     
  816.     return implode($glue, $result);
  817. }
  820. public function getMetaDataValue($jsonData, $searchKey)
  821.     {
  823.         
  824.         $dataArray = (array)$jsonData;
  826.         
  827.         
  828.         foreach ($dataArray as $item) {
  829.             if (isset($item['key']) && $item['key'] === $searchKey) {
  830.                 return $item['value'];
  831.             }
  832.         }
  834.         return null;
  835.     }
  837. }