vendor/sonata-project/core-bundle/src/CoreBundle/Command/SonataDumpDoctrineMetaCommand.php line 29

Open in your IDE?
  1. <?php
  2. declare(strict_types=1);
  3. /*
  4.  * This file is part of the Sonata Project package.
  5.  *
  6.  * (c) Thomas Rabaix <thomas.rabaix@sonata-project.org>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  11. namespace Sonata\CoreBundle\Command;
  12. use Doctrine\ORM\Mapping\ClassMetadata;
  13. use Gaufrette\Adapter\Local as LocalAdapter;
  14. use Gaufrette\Filesystem;
  15. use Symfony\Bundle\FrameworkBundle\Command\ContainerAwareCommand;
  16. use Symfony\Component\Console\Input\InputInterface;
  17. use Symfony\Component\Console\Input\InputOption;
  18. use Symfony\Component\Console\Output\OutputInterface;
  19. /**
  20.  * Return useful data on the database schema.
  21.  *
  22.  * @deprecated since 3.12.0, to be removed in 4.0.
  23.  */
  24. class SonataDumpDoctrineMetaCommand extends ContainerAwareCommand
  25. {
  26.     /**
  27.      * @var array
  28.      */
  29.     protected $metadata;
  30.     protected function configure()
  31.     {
  32.         $this
  33.             ->setName('sonata:core:dump-doctrine-metadata')
  34.             ->setDefinition([
  35.                 new InputOption(
  36.                     'entity-name',
  37.                     'E',
  38.                     InputOption::VALUE_OPTIONAL,
  39.                     'If entity-name is set, dump will only contain the specified entity and all its extended classes.',
  40.                     null
  41.                 ),
  42.                 new InputOption(
  43.                     'regex',
  44.                     'r',
  45.                     InputOption::VALUE_OPTIONAL,
  46.                     'If regex is set, dump will only contain entities which name match the pattern.',
  47.                     null
  48.                 ),
  49.                 new InputOption(
  50.                     'filename',
  51.                     'f',
  52.                     InputOption::VALUE_OPTIONAL,
  53.                     'If filename is specified, result will be dumped into this file under json format.',
  54.                     null
  55.                 ),
  56.             ])
  57.             ->setDescription('Get information on the current Doctrine\'s schema')
  58.         ;
  59.     }
  60.     protected function initialize(InputInterface $inputOutputInterface $output)
  61.     {
  62.         @trigger_error(
  63.             'The '.__CLASS__.' class is deprecated since version 3.12.0 and will be removed in 4.0.',
  64.             E_USER_DEPRECATED
  65.         );
  66.         $output->writeln('Initialising Doctrine metadata.');
  67.         $manager $this->getContainer()->get('doctrine')->getManager();
  68.         $metadata $manager->getMetadataFactory()->getAllMetadata();
  69.         $allowedMeta $this->filterMetadata($metadata$input$output);
  70.         /** @var ClassMetadata $meta */
  71.         foreach ($allowedMeta as $meta) {
  72.             $this->metadata[$meta->getName()] = $this->normalizeDoctrineORMMeta($meta);
  73.         }
  74.     }
  75.     protected function execute(InputInterface $inputOutputInterface $output)
  76.     {
  77.         if (!$this->metadata) {
  78.             $output->writeln('<error>No meta was found</error>');
  79.             return 1;
  80.         }
  81.         $this->dumpMetadata($this->metadata$input$output);
  82.         return 0;
  83.     }
  84.     /**
  85.      * Display the list of entities handled by Doctrine and their fields.
  86.      */
  87.     private function dumpMetadata(array $metadataInputInterface $inputOutputInterface $output)
  88.     {
  89.         foreach ($metadata as $name => $meta) {
  90.             $output->writeln(sprintf('<info>%s</info>'$name));
  91.             foreach ($meta['fields'] as $fieldName => $columnName) {
  92.                 $output->writeln(sprintf('  <comment>></comment> %s <info>=></info> %s'$fieldName$columnName));
  93.             }
  94.         }
  95.         $output->writeln('---------------');
  96.         $output->writeln('----  END  ----');
  97.         $output->writeln('---------------');
  98.         $output->writeln('');
  99.         if ($input->getOption('filename')) {
  100.             $directory = \dirname($input->getOption('filename'));
  101.             $filename basename($input->getOption('filename'));
  102.             if (empty($directory) || '.' === $directory) {
  103.                 $directory getcwd();
  104.             }
  105.             $adapter = new LocalAdapter($directorytrue);
  106.             $fileSystem = new Filesystem($adapter);
  107.             $success $fileSystem->write($filenamejson_encode($metadata), true);
  108.             if ($success) {
  109.                 $output->writeLn(sprintf('<info>File %s/%s successfully created</info>'$directory$filename));
  110.             } else {
  111.                 $output->writeLn(sprintf('<error>File %s/%s could not be created</error>'$directory$filename));
  112.             }
  113.         }
  114.     }
  115.     /**
  116.      * @return array
  117.      */
  118.     private function filterMetadata(array $metadataInputInterface $inputOutputInterface $output)
  119.     {
  120.         $baseEntity $input->getOption('entity-name');
  121.         $regex $input->getOption('regex');
  122.         if ($baseEntity) {
  123.             $allowedMeta array_filter(
  124.                 $metadata,
  125.                 static function ($meta) use ($baseEntity) {
  126.                     /* @var \Doctrine\ORM\Mapping\ClassMetadata $meta */
  127.                     return $meta->rootEntityName === $baseEntity;
  128.                 }
  129.             );
  130.         } elseif ($regex) {
  131.             $allowedMeta array_filter(
  132.                 $metadata,
  133.                 static function ($meta) use ($regex) {
  134.                     /* @var \Doctrine\ORM\Mapping\ClassMetadata $meta */
  135.                     return preg_match($regex$meta->rootEntityName);
  136.                 }
  137.             );
  138.         } else {
  139.             $allowedMeta $metadata;
  140.         }
  141.         return $allowedMeta;
  142.     }
  143.     /**
  144.      * @return array
  145.      */
  146.     private function normalizeDoctrineORMMeta(ClassMetadata $meta)
  147.     {
  148.         $normalizedMeta = [];
  149.         $fieldMappings $meta->fieldMappings;
  150.         $normalizedMeta['table'] = $meta->table['name'];
  151.         foreach ($fieldMappings as $field) {
  152.             $normalizedMeta['fields'][$field['fieldName']] = $field['columnName'] ?? null;
  153.         }
  154.         return $normalizedMeta;
  155.     }
  156. }