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__."/../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.             
  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')
  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.                     ;
  279.                 foreach($entity->getFindBy() as $key => $value){
  280.                     $queryBuilder   
  281.                     ->andWhere('e.'.$key.' '.$value);
  282.                 }
  283.                 if(count($entity->getOrderBy())>0){
  284.                     foreach($entity->getOrderBy() as $key => $value){
  285.                         if(gettype($key)=="integer"){
  286.                             $queryBuilder->orderBy("e.".$value);
  287.                         }else{
  288.                             $queryBuilder->orderBy("e.".$key,$value);
  289.                         }
  290.                         
  291.                     }
  292.                     
  293.                 }
  294.                 //$queryBuilder->setMaxResults(500);
  295.                 
  296.                 $entityFetchAll = $queryBuilder->getQuery()->getResult();
  298.                 
  299.                 
  300.                 
  301.                 
  302.                     
  303.             }else{
  304.                 $queryBuilder = $this->doctrine->getManager()->createQueryBuilder();
  306.                 
  307.                     $queryBuilder
  308.                         ->select('e')
  309.                         ->from($entityNameSpace, 'e');
  310.                         //->join('e.relatedEntity', 'r')
  311.                         $queryBuilder->setMaxResults(500);
  312.                     $entityFetchAll = $queryBuilder->getQuery()->getResult();
  313.             }
  315.             
  316.             
  318.             
  320.             $arrayToExport = [];
  322.             $correctedFieldsName =[];
  323.             foreach($fields as $field){
  324.                 if($field == "getMetaData"){
  325.                     continue;
  326.                 }
  327.                 
  328.                 $name = $this->getAbsoluteNameMethod($field);
  329.                 $correctedFieldsName[]= $this->translatorInterface->trans($name,[],"admin");
  330.             }
  333.             foreach($entity->getMetaDataFields() as $singleField){
  334.                 $correctedFieldsName[]= $this->translatorInterface->trans($singleField,[],"admin");
  335.             }
  337.             
  338.             
  339.             
  341.             $arrayToExport[]=$correctedFieldsName;
  343.             
  345.             foreach($entityFetchAll as $singleEntityInstance){
  347.                 
  348.                 $singleRow =[];
  349.                 $singleMetaDataValue = [];
  350.                 foreach($fields as $singleField){
  352.                     $value=null;
  353.                     $valueSub=null;
  354.                     $valueParent=null;
  355.                     
  357.                     
  360.                    
  361.                     
  362.                     
  365.                         if(method_exists($singleEntityInstance,$singleField)){
  366.                             
  367.                             
  368.                             
  369.                             $value = $singleEntityInstance->{$singleField}();
  373.                             
  374.                                 if($value instanceof Collection){
  375.                                     $value = implode("\n", $value->toArray());
  376.                                     //dd($value);
  377.                                 }elseif(is_array($value)){
  378.                                     
  380.                                     if($singleField == "getMetaData"){
  381.                                         
  383.                                         
  384.                                         foreach($entity->getMetaDataFields() as $singleField){
  385.                                             $singleMetaDataValue[] = $this->getMetaDataValue($value,$singleField);
  386.                                             continue;
  387.                                         }
  388.                                         continue;
  389.                                     
  391.                                     foreach($value as $k=>$v){
  394.                                         if(in_array($k,$entity->getMetaDataFields())){
  395.                                                 dd($k);
  396.                                                 $singleMetaDataValue[]=$v["value"];
  397.                                                 
  398.                                         }else
  399.                                         dd("None");
  402.                                             
  403.                                             
  404.                                             
  405.                                             
  406.                                         }
  408.                                         
  410.                                         continue;
  411.                                     }
  412.                                     
  413.                                     
  414.                                     $value = $this->implode_multidimensional($value,"\n");
  415.                                     
  416.                                 }elseif(gettype($value) == "string"){
  417.                                     $value = $this->translatorInterface->trans($value);
  418.                                 }
  419.                             
  420.     
  421.                         }elseif(method_exists($entityRepository,$singleField)){
  422.                             $value = $entityRepository->{$singleField}($singleEntityInstance->getId());
  423.                             
  424.                         
  425.                             if(is_array($value)){
  427.                                 
  429.                                 // find the index of the value 'orange'
  430.                                 $field = $this->getAbsoluteNameMethod($singleField);
  431.                                
  434.                                 $translatedField = $this->translatorInterface->trans($field);
  435.                                 $index = array_search($translatedField, $arrayToExport[0]);
  437.                                 // if the value exists in the array, remove it
  438.                                 if ($index !== false) {
  439.                                     unset($arrayToExport[0][$index]);
  440.                                 }
  442.                                 // re-index the array
  443.                                 //$arrayToExport = array_values($arrayToExport[0]);
  445.                                // dd($value);
  446.                                 
  447.                                 foreach($value as $singleData){
  449.                                     $translatedKey = $this->translatorInterface->trans($singleData["key"]);
  451.                                     if(!in_array($translatedKey,$arrayToExport[0])){
  454.                                         
  456.                                         $arrayToExport[0][] = $this->translatorInterface->trans($translatedKey);
  457.                                     }
  458.                                     
  459.                                     $singleRow[]=$singleData["value"];
  460.                                 }
  461.                                 
  462.                                 continue;
  463.                             }else{
  464.                                 $value = $this->translatorInterface->trans($value);
  465.                             }
  466.                         }
  467.                         $singleRow[]=$value;
  468.                     
  469.                     
  471.                 }
  472.                 
  473.                 
  474.                 
  475.                 
  476.                 foreach($singleMetaDataValue  as $singleMetaDataVal){
  477.                     //dd($singleMetaDataVal);
  478.                     if(is_array($singleMetaDataVal)){
  479.                         
  480.                         $singleRow[] = $this->implode_multidimensional($singleMetaDataVal,", ");
  481.                         continue;
  482.                     }
  484.                     $singleRow[] = $singleMetaDataVal;
  485.                 }
  486.                 $arrayToExport[]=$singleRow;
  487.                 //dd($arrayToExport);
  488.             }
  490.             //dd($arrayToExport);
  491.             
  492.             
  493.             
  494.             
  495.             $mySpreadsheet = new \PhpOffice\PhpSpreadsheet\Spreadsheet();
  496.             $mySpreadsheet->removeSheetByIndex(0);
  498.             $worksheet1 = new \PhpOffice\PhpSpreadsheet\Worksheet\Worksheet($mySpreadsheet, "List Produits");
  499.             $mySpreadsheet->addSheet($worksheet1, 0);
  500.             $worksheet1->fromArray($arrayToExport,null,"A1");
  501.             // Set the auto filter to cover all the data
  502.             $lastColumn = $worksheet1->getHighestColumn();
  503.             $lastRow = $worksheet1->getHighestDataRow();
  504.             $range = "A1:$lastColumn$lastRow";
  505.             $worksheet1->setAutoFilter($range);
  507.             foreach ($worksheet1->getColumnIterator() as $column)
  508.                 {
  509.                     $worksheet1->getColumnDimension($column->getColumnIndex())->setAutoSize(true);
  510.                     
  511.                     
  512.                 }
  513.                 foreach ($worksheet1->getRowIterator() as $row) {
  514.                     foreach ($row->getCellIterator() as $cell) {
  515.                         $cell->getStyle()->getAlignment()->setVertical(\PhpOffice\PhpSpreadsheet\Style\Alignment::VERTICAL_TOP);
  516.                     }
  517.                 }
  519.                 $writer = new \PhpOffice\PhpSpreadsheet\Writer\Xlsx($mySpreadsheet);
  522.                 
  523.                 $parts = explode("\\", $entityNameSpace);
  524.                 $nameOfFile = end($parts);
  525.                 $nameOfFile = strtolower($nameOfFile)."-".$entity->getCreatedAt()->format("Y-m-d-H-i");
  526.                 //echo $lastWord; // output: CategoryProduct
  528.                 $settings = $this->doctrine->getManager()->getRepository(Settings::class)->findOneBy(["code"=>"main"]);
  529.                 $assetFolderName = $settings->getAssetFolderName();
  530.                 $assetFolderName = strtolower($assetFolderName);
  532.                 $writer->save("uploads/".$assetFolderName."/exports/".$nameOfFile.".xlsx");
  534.                 
  535.                 $entity->setGeneratedFilePath("uploads/".$assetFolderName."/exports/".$nameOfFile.".xlsx");
  536.                 $entity->setEntityNameSpace($entityNameSpace);
  537.         
  538.             
  539.         }
  541.                 if ($entity instanceof User) {
  542.                     
  543.                    $entity->setPassword(
  544.                    $this->passwordEncoder->hashPassword(
  545.                             $entity,
  546.                             $entity->getPassword()
  547.                 ));
  548.                 
  549.             
  550.             
  551.             
  552.                 
  553.         }
  554.     }
  557.     public function beforeUpdated(BeforeEntityUpdatedEvent $event)
  558.     {
  559.         $entity = $event->getEntityInstance();
  561.         
  562.         if($entity instanceof Settings){
  564.             $filesystem = new Filesystem();
  565.             $pathFrontBundle = __DIR__."/../Flexy/FrontBundle";
  566.             $themePath = $pathFrontBundle."/Themes";
  567.             if($entity->getFrontTheme()){
  568.                 $entity->setAssetFolderName($entity->getFrontTheme()->getName());
  569.                 if(!$filesystem->exists(__DIR__."/../../public/themes/".strtolower($entity->getFrontTheme()->getName()))){
  570.                     $filesystem->symlink($themePath."/".$entity->getFrontTheme()->getName()."/assets", __DIR__."/../../public/themes/".strtolower($entity->getFrontTheme()->getName()));
  572.                 }
  573.                
  574.             }
  575.             
  578.             
  579.             $path = __DIR__."/../../public/uploads/".$entity->getAssetFolderName();
  580.             if(!$filesystem->exists($path) )
  581.             {
  582.                 $filesystem->mkdir($path,0777);
  583.                 $filesystem->mkdir($path."/pages",0777);
  584.                 $filesystem->mkdir($path."/shop",0777);
  585.                 
  586.             }
  588.             
  589.             $pathFrontBundleRoutes = __DIR__."/../Flexy/FrontBundle/Resources/config/routes.yaml";
  590.             if($filesystem->exists($pathFrontBundleRoutes)){
  591.                 $configArray = Yaml::parseFile($pathFrontBundleRoutes);
  593.                 $configArray["controllers"]["resource"] = "../../Themes/".ucfirst($entity->getAssetFolderName())."/Controller";
  594.                 
  596.                 $yamlConfig = Yaml::dump($configArray);
  598.                 file_put_contents($pathFrontBundleRoutes, $yamlConfig);
  599.             }
  600.             
  602.         }
  606.       
  608.    
  609.      
  610.     }
  612.     public function beforeDelete(BeforeEntityDeletedEvent $event){
  614.         $entity = $event->getEntityInstance();
  617.         if($entity instanceof FrontTheme){
  619.             //$entity->getSettings()->setFrontTheme(null);
  620.             $filesystem = new Filesystem();
  622.             //dd(__DIR__."/../../");
  623.             $pathFrontBundle = __DIR__."/../Flexy/FrontBundle";
  625.             
  626.             $themePath = $pathFrontBundle."/Themes";
  627.             if($filesystem->exists($themePath."/".ucfirst($entity->getName()) ) ){
  628.             
  629.             $this->zipDirectory($themePath."/".ucfirst($entity->getName()),__DIR__."/../../public/archive-themes/".strtolower($entity->getName()).".zip" );
  632.             
  633.             $filesystem->remove($themePath."/".ucfirst($entity->getName()));
  634.             
  636.                 
  637.                 
  638.             
  639.                
  640.             }
  641.             
  642.             //$filesystem->remove($pathFrontBundle."/Resources/public/assets/".strtolower($entity->getName()));
  645.             $settings = $this->doctrine->getManager()->getRepository(Settings::class)->findOneBy(["code"=>"main"]);
  646.             $currentTheme = $settings->getAssetFolderName();
  647.             $entity->removeSetting($settings);
  649.             $settings->setAssetFolderName("Default");
  651.             $this->doctrine->getManager()->persist($settings);
  654.             if(strtolower($entity->getName()) == strtolower($currentTheme) ){
  655.                 $pathFrontBundleRoutes = __DIR__."/../Flexy/FrontBundle/Resources/config/routes.yaml";
  656.                 if($filesystem->exists($pathFrontBundleRoutes)){
  657.                     $configArray = Yaml::parseFile($pathFrontBundleRoutes);
  658.     
  659.                     $configArray["controllers"]["resource"] = "../../Themes/Default/Controller";
  660.                     
  661.     
  662.                     $yamlConfig = Yaml::dump($configArray);
  663.     
  664.                     file_put_contents($pathFrontBundleRoutes, $yamlConfig);
  665.                 }
  666.             }
  667.             
  668.         }
  669.        
  671.     }
  675.     public function  exportFile($records) {
  676.         $heading = false;
  677.             if(!empty($records))
  678.               foreach($records as $row) {
  679.                 if(!$heading) {
  680.                   // display field/column names as a first row
  681.                   echo implode("\t", array_keys($row)) . "\n";
  682.                   $heading = true;
  683.                 }
  684.                 echo implode("\t", array_values($row)) . "\n";
  685.             }
  686.         
  688.     }
  691.     public static function zipDirectory($directory, $zipName)
  692. {
  693.     // Get real path for our folder
  694. $rootPath = realpath($directory);
  696. // Initialize archive object
  697. $zip = new ZipArchive();
  698. $zip->open($zipName, ZipArchive::CREATE | ZipArchive::OVERWRITE);
  700. // Initialize empty "delete list"
  701. $filesToDelete = array();
  703. // Create recursive directory iterator
  704. /** @var SplFileInfo[] $files */
  705. $files = new RecursiveIteratorIterator(
  706.     new RecursiveDirectoryIterator($rootPath),
  707.     RecursiveIteratorIterator::LEAVES_ONLY
  708. );
  710. foreach ($files as $name => $file)
  711. {
  712.     // Skip directories (they would be added automatically)
  713.     if (!$file->isDir())
  714.     {
  715.         // Get real and relative path for current file
  716.         $filePath = $file->getRealPath();
  717.         $relativePath = substr($filePath, strlen($rootPath) + 1);
  719.         // Add current file to archive
  720.         $zip->addFile($filePath, $relativePath);
  722.         // Add current file to "delete list"
  723.         // delete it later cause ZipArchive create archive only after calling close function and ZipArchive lock files until archive created)
  724.         if ($file->getFilename() != 'important.txt')
  725.         {
  726.             $filesToDelete[] = $filePath;
  727.         }
  728.     }
  729. }
  731. // Zip archive will be created only after closing object
  732. $zip->close();
  733. return $zip;
  734. }
  738. function getAbsoluteNameMethod($input) {
  739.     // Remove the "get" prefix from the input string
  740.   $input = preg_replace('/^get/', '', $input);
  741.   
  742.   // Replace all capital letters with a space followed by the letter
  743.   $output = preg_replace('/([A-Z])/', ' $1', $input);
  744.   
  745.   // Remove any leading or trailing spaces
  746.   $output = trim($output);
  747.   
  748.   // Convert the first character to uppercase
  749.   $output = ucfirst($output);
  750.   
  751.   // Return the final result
  752.   return $output;
  753.   }
  756.   public function getAllRepositoryMethods($repository)
  757. {
  758.     $reflectionClass = new ReflectionClass(get_class($repository));
  759.     $methods = $reflectionClass->getMethods(ReflectionMethod::IS_PUBLIC);
  761.     $findMethods = [];
  762.     foreach ($methods as $method) {
  763.         $methodName = $method->getName();
  764.         if (strpos($methodName, 'export') === 0) {
  765.             $findMethods[] = $methodName;
  766.         }
  767.     }
  769.     return $findMethods;
  770. }
  775. function is_multidimensional(array $array) {
  776.     foreach ($array as $element) {
  777.         if (is_array($element)) {
  778.             return true;
  779.         }
  780.     }
  781.     return false;
  782. }
  784. function implode_multidimensional(array $array, $glue = ', ') {
  785.     $result = [];
  786.     
  787.     foreach ($array as $key => $element) {
  788.         if (is_array($element)) {
  789.             $element = $this->implode_multidimensional($element, $glue);
  790.         }
  792.         //$result[] = "{$key}:{$element}";
  793.         if(!in_array("{$element}",$result)){
  794.             $result[] = "{$element}";
  795.         }
  796.         
  798.         
  799.     }
  800.     
  801.     return implode($glue, $result);
  802. }
  805. public function getMetaDataValue($jsonData, $searchKey)
  806.     {
  808.         
  809.         $dataArray = (array)$jsonData;
  811.         
  812.         
  813.         foreach ($dataArray as $item) {
  814.             if (isset($item['key']) && $item['key'] === $searchKey) {
  815.                 return $item['value'];
  816.             }
  817.         }
  819.         return null;
  820.     }
  822. }