Source of file MakeEntity.php

<?php

namespace TIC\MakeBundle\Maker;

use Symfony\Component\Console\Command\Command;

use Symfony\Component\Console\Input\InputInterface;

use Symfony\Component\Console\Input\InputArgument;

use Symfony\Component\Console\Input\InputOption;

use Doctrine\Common\Annotations\Annotation;

use Symfony\Bundle\MakerBundle\Maker\MakeEntity as OriginalMaker;

use Symfony\Bundle\MakerBundle\Util\ClassNameDetails;

use Symfony\Bundle\MakerBundle\Exception\RuntimeCommandException;

use Symfony\Bundle\MakerBundle\Doctrine\DoctrineHelper;

#use Symfony\Bundle\MakerBundle\Doctrine\EntityClassGenerator;

use TIC\MakeBundle\Doctrine\EntityClassGenerator;

/**

 *

 */

final class MakeEntity extends BaseMaker

{

	private $doctrineHelper;

	private $entityClassGenerator;

	private $originalEntityMaker;

	public function __construct(DoctrineHelper $doctrineHelper, EntityClassGenerator $entityClassGenerator, OriginalMaker $originalEntityMaker)

	{

		parent::__construct();

		$this->doctrineHelper       = $doctrineHelper;

		$this->entityClassGenerator = $entityClassGenerator;

		$this->originalEntityMaker  = $originalEntityMaker;

	}

	protected $dependencies = array(

		['class' => Annotation::class, 'value' => 'doctrine/annotations'],

	);

	/**

	 * Configure the command: set description, input arguments, options, etc.

	 */

	protected function ticConfigure(Command $command)

	{

		$command

			->addArgument('name',      InputArgument::OPTIONAL, "Nom, chemin ou classname de l'entité")

			->addOption('regenerate',  null, InputOption::VALUE_NONE, "Regénération des méthodes (e.g. getter/setter) des champs")

			->addOption('overwrite',   null, InputOption::VALUE_NONE, "Regénération des méthodes existantes (sinon seulement manquantes")

			->addOption('broadcast',    'b', InputOption::VALUE_NONE, "(inutilisé)")

			->addOption('api-resource', 'a', InputOption::VALUE_NONE, "(inutilisé)")

		;

	}

	/**

	 * Called after normal code generation: allows you to do anything.

	 */

	protected function ticGenerate(InputInterface $input)

	{

		$inputName = $this->fixClassName($input->getArgument('name'), true);

		$this->io->title("Construction de l'entité : '$inputName'");

		// détermination des variables à utiliser

		$variables = $this->getVariablesFromName($inputName, "Entity");

		$tableBase   = str_replace("\\", "", str_replace("\\Entity\\", "", $variables['item_class']));

		$variables['table_name'] = $this->doctrineHelper->getPotentialTableName($tableBase);

		$entityDetails = $this->generator->createClassNameDetails($inputName, "Entity\\");

		$repoDetails   = $this->generator->createClassNameDetails($entityDetails->getRelativeName(), "Repository\\", "Repository");

		// affichage des valeurs des variables

		$this->io->section("Paramètres utilisés :");

		$this->io->table(["Variable","Valeur"], self::hash2list($variables));

		// vérifications

		$classExists = $repoExists = false;

		try {

			$classExists = class_exists($variables['item_class']);

			$repoExists  = class_exists($repoDetails->getFullName());

		} catch (\ErrorException $e) {

		}

		if ($entityDetails->getFullName() !== $variables['item_class'])

			throw new RuntimeCommandException("Le namespace de l'entité ne correspond pas à ce qui est attendu : " . $entityDetails->getFullName());

		if ($classExists && !$this->doctrineHelper->isClassAnnotated($variables['item_class']))

			throw new RuntimeCommandException("L'entité doit utiliser les annotations pour son mapping ORM");

		if ($this->test) return;

		if (! $this->confirm("Lancer la construction ?")) return;

		// construction (ou chargement) Entity et Repository

		$newPaths = array();

		if (! $classExists) {

			$this->io->section("Construction de l'entité...");

			$entityPath = $this->entityClassGenerator->generateEntityClass($entityDetails, $variables['table_name']);

			$newPaths[] = $entityPath;

		} else $this->io->warning("Entité déjà existante");

		if (! $repoExists) {

			$this->io->section("Construction du repository...");

			$repoPath   = $this->entityClassGenerator->generateRepositoryClass($repoDetails, $entityDetails);

			$newPaths[] = $repoPath;

		}

		if (! empty($newPaths)) $this->generator->writeChanges();

		$this->io->listing( $newPaths );

		// appel au maker d'origine pour la suite...

		if ($classExists) $entityPath = (new \ReflectionClass($entityDetails->getFullName()))->getFileName();

		$input->setArgument('name', $variables['item_name']);

		$input->setOption('api-resource', false);

		$input->setOption('broadcast',    false);

		if (! $classExists) require($entityPath);

		self::indentFile($entityPath, true);

		$this->originalEntityMaker->generate($input, $this->io, $this->generator);

		self::indentFile($entityPath, false);

		return true;

	}

}