vendor/symfony/maker-bundle/src/Maker/MakeUser.php line 234

  1. <?php
  3. /*
  4.  * This file is part of the Symfony MakerBundle package.
  5.  *
  6.  * (c) Fabien Potencier <fabien@symfony.com>
  7.  *
  8.  * For the full copyright and license information, please view the LICENSE
  9.  * file that was distributed with this source code.
  10.  */
  12. namespace Symfony\Bundle\MakerBundle\Maker;
  14. use Doctrine\Bundle\DoctrineBundle\DoctrineBundle;
  15. use Symfony\Bundle\MakerBundle\ConsoleStyle;
  16. use Symfony\Bundle\MakerBundle\DependencyBuilder;
  17. use Symfony\Bundle\MakerBundle\Doctrine\DoctrineHelper;
  18. use Symfony\Bundle\MakerBundle\Doctrine\EntityClassGenerator;
  19. use Symfony\Bundle\MakerBundle\Doctrine\ORMDependencyBuilder;
  20. use Symfony\Bundle\MakerBundle\Exception\RuntimeCommandException;
  21. use Symfony\Bundle\MakerBundle\FileManager;
  22. use Symfony\Bundle\MakerBundle\Generator;
  23. use Symfony\Bundle\MakerBundle\InputConfiguration;
  24. use Symfony\Bundle\MakerBundle\Security\SecurityConfigUpdater;
  25. use Symfony\Bundle\MakerBundle\Security\UserClassBuilder;
  26. use Symfony\Bundle\MakerBundle\Security\UserClassConfiguration;
  27. use Symfony\Bundle\MakerBundle\Util\ClassSourceManipulator;
  28. use Symfony\Bundle\MakerBundle\Util\UseStatementGenerator;
  29. use Symfony\Bundle\MakerBundle\Util\YamlManipulationFailedException;
  30. use Symfony\Bundle\MakerBundle\Validator;
  31. use Symfony\Bundle\SecurityBundle\SecurityBundle;
  32. use Symfony\Component\Console\Command\Command;
  33. use Symfony\Component\Console\Input\InputArgument;
  34. use Symfony\Component\Console\Input\InputInterface;
  35. use Symfony\Component\Console\Input\InputOption;
  36. use Symfony\Component\Security\Core\Exception\UnsupportedUserException;
  37. use Symfony\Component\Security\Core\Exception\UserNotFoundException;
  38. use Symfony\Component\Security\Core\User\PasswordAuthenticatedUserInterface;
  39. use Symfony\Component\Security\Core\User\PasswordUpgraderInterface;
  40. use Symfony\Component\Security\Core\User\UserInterface;
  41. use Symfony\Component\Security\Core\User\UserProviderInterface;
  42. use Symfony\Component\Yaml\Yaml;
  44. /**
  45.  * @author Ryan Weaver <weaverryan@gmail.com>
  46.  *
  47.  * @internal
  48.  */
  49. final class MakeUser extends AbstractMaker
  50. {
  51.     public function __construct(
  52.         private FileManager $fileManager,
  53.         private UserClassBuilder $userClassBuilder,
  54.         private SecurityConfigUpdater $configUpdater,
  55.         private EntityClassGenerator $entityClassGenerator,
  56.         private DoctrineHelper $doctrineHelper,
  57.     ) {
  58.     }
  60.     public static function getCommandName(): string
  61.     {
  62.         return 'make:user';
  63.     }
  65.     public static function getCommandDescription(): string
  66.     {
  67.         return 'Creates a new security user class';
  68.     }
  70.     public function configureCommand(Command $command, InputConfiguration $inputConfig): void
  71.     {
  72.         $command
  73.             ->addArgument('name', InputArgument::OPTIONAL, 'The name of the security user class (e.g. <fg=yellow>User</>)')
  74.             ->addOption('is-entity', null, InputOption::VALUE_NONE, 'Do you want to store user data in the database (via Doctrine)?')
  75.             ->addOption('identity-property-name', null, InputOption::VALUE_REQUIRED, 'Enter a property name that will be the unique "display" name for the user (e.g. <comment>email, username, uuid</comment>)')
  76.             ->addOption('with-password', null, InputOption::VALUE_NONE, 'Will this app be responsible for checking the password? Choose <comment>No</comment> if the password is actually checked by some other system (e.g. a single sign-on server)')
  77.             ->setHelp(file_get_contents(__DIR__.'/../Resources/help/MakeUser.txt'));
  79.         $inputConfig->setArgumentAsNonInteractive('name');
  80.     }
  82.     public function interact(InputInterface $input, ConsoleStyle $io, Command $command): void
  83.     {
  84.         if (null === $input->getArgument('name')) {
  85.             $name = $io->ask(
  86.                 $command->getDefinition()->getArgument('name')->getDescription(),
  87.                 'User'
  88.             );
  89.             $input->setArgument('name', $name);
  90.         }
  92.         $userIsEntity = $io->confirm(
  93.             'Do you want to store user data in the database (via Doctrine)?',
  94.             class_exists(DoctrineBundle::class)
  95.         );
  96.         if ($userIsEntity) {
  97.             $dependencies = new DependencyBuilder();
  98.             ORMDependencyBuilder::buildDependencies($dependencies);
  100.             $missingPackagesMessage = $dependencies->getMissingPackagesMessage(self::getCommandName(), 'Doctrine must be installed to store user data in the database');
  101.             if ($missingPackagesMessage) {
  102.                 throw new RuntimeCommandException($missingPackagesMessage);
  103.             }
  104.         }
  105.         $input->setOption('is-entity', $userIsEntity);
  107.         $identityFieldName = $io->ask('Enter a property name that will be the unique "display" name for the user (e.g. <comment>email, username, uuid</comment>)', 'email', [Validator::class, 'validatePropertyName']);
  108.         $input->setOption('identity-property-name', $identityFieldName);
  110.         $io->text('Will this app need to hash/check user passwords? Choose <comment>No</comment> if passwords are not needed or will be checked/hashed by some other system (e.g. a single sign-on server).');
  111.         $userWillHavePassword = $io->confirm('Does this app need to hash/check user passwords?');
  112.         $input->setOption('with-password', $userWillHavePassword);
  113.     }
  115.     public function generate(InputInterface $input, ConsoleStyle $io, Generator $generator): void
  116.     {
  117.         $userClassConfiguration = new UserClassConfiguration(
  118.             $input->getOption('is-entity'),
  119.             $input->getOption('identity-property-name'),
  120.             $input->getOption('with-password')
  121.         );
  123.         $userClassNameDetails = $generator->createClassNameDetails(
  124.             $input->getArgument('name'),
  125.             $userClassConfiguration->isEntity() ? 'Entity\\' : 'Security\\'
  126.         );
  128.         // A) Generate the User class
  129.         if ($userClassConfiguration->isEntity()) {
  130.             $classPath = $this->entityClassGenerator->generateEntityClass(
  131.                 $userClassNameDetails,
  132.                 false, // api resource
  133.                 $userClassConfiguration->hasPassword() // security user
  134.             );
  135.         } else {
  136.             $classPath = $generator->generateClass($userClassNameDetails->getFullName(), 'Class.tpl.php');
  137.         }
  138.         // need to write changes early so we can modify the contents below
  139.         $generator->writeChanges();
  141.         $entityUsesAttributes = ($isEntity = $userClassConfiguration->isEntity()) && $this->doctrineHelper->doesClassUsesAttributes($userClassNameDetails->getFullName());
  143.         if ($isEntity && !$entityUsesAttributes) {
  144.             throw new \RuntimeException('MakeUser only supports attribute mapping with doctrine entities.');
  145.         }
  147.         // B) Implement UserInterface
  148.         $manipulator = new ClassSourceManipulator(
  149.             sourceCode: $this->fileManager->getFileContents($classPath),
  150.             overwrite: true,
  151.             useAttributesForDoctrineMapping: $entityUsesAttributes
  152.         );
  154.         $manipulator->setIo($io);
  156.         $this->userClassBuilder->addUserInterfaceImplementation($manipulator, $userClassConfiguration);
  158.         $generator->dumpFile($classPath, $manipulator->getSourceCode());
  160.         // C) Generate a custom user provider, if necessary
  161.         if (!$userClassConfiguration->isEntity()) {
  162.             $userClassConfiguration->setUserProviderClass($generator->getRootNamespace().'\\Security\\UserProvider');
  164.             $useStatements = new UseStatementGenerator([
  165.                 UnsupportedUserException::class,
  166.                 UserNotFoundException::class,
  167.                 PasswordAuthenticatedUserInterface::class,
  168.                 PasswordUpgraderInterface::class,
  169.                 UserInterface::class,
  170.                 UserProviderInterface::class,
  171.             ]);
  173.             $customProviderPath = $generator->generateClass(
  174.                 $userClassConfiguration->getUserProviderClass(),
  175.                 'security/UserProvider.tpl.php',
  176.                 [
  177.                     'use_statements' => $useStatements,
  178.                     'user_short_name' => $userClassNameDetails->getShortName(),
  179.                 ]
  180.             );
  181.         }
  183.         // D) Update security.yaml
  184.         $securityYamlUpdated = false;
  185.         $path = 'config/packages/security.yaml';
  186.         if ($this->fileManager->fileExists($path)) {
  187.             try {
  188.                 $newYaml = $this->configUpdater->updateForUserClass(
  189.                     $this->fileManager->getFileContents($path),
  190.                     $userClassConfiguration,
  191.                     $userClassNameDetails->getFullName()
  192.                 );
  193.                 $generator->dumpFile($path, $newYaml);
  194.                 $securityYamlUpdated = true;
  195.             } catch (YamlManipulationFailedException) {
  196.             }
  197.         }
  199.         $generator->writeChanges();
  201.         $this->writeSuccessMessage($io);
  203.         $io->text('Next Steps:');
  204.         $nextSteps = [
  205.             sprintf('Review your new <info>%s</info> class.', $userClassNameDetails->getFullName()),
  206.         ];
  207.         if ($userClassConfiguration->isEntity()) {
  208.             $nextSteps[] = sprintf(
  209.                 'Use <comment>make:entity</comment> to add more fields to your <info>%s</info> entity and then run <comment>make:migration</comment>.',
  210.                 $userClassNameDetails->getShortName()
  211.             );
  212.         } else {
  213.             $nextSteps[] = sprintf(
  214.                 'Open <info>%s</info> to finish implementing your user provider.',
  215.                 $this->fileManager->relativizePath($customProviderPath)
  216.             );
  217.         }
  219.         if (!$securityYamlUpdated) {
  220.             $yamlExample = $this->configUpdater->updateForUserClass(
  221.                 'security: {}',
  222.                 $userClassConfiguration,
  223.                 $userClassNameDetails->getFullName()
  224.             );
  225.             $nextSteps[] = "Your <info>security.yaml</info> could not be updated automatically. You'll need to add the following config manually:\n\n".$yamlExample;
  226.         }
  228.         $nextSteps[] = 'Create a way to authenticate! See https://symfony.com/doc/current/security.html';
  230.         $nextSteps = array_map(static fn ($step) => sprintf('  - %s', $step), $nextSteps);
  231.         $io->text($nextSteps);
  232.     }
  234.     public function configureDependencies(DependencyBuilder $dependencies, InputInterface $input = null): void
  235.     {
  236.         // checking for SecurityBundle guarantees security.yaml is present
  237.         $dependencies->addClassDependency(
  238.             SecurityBundle::class,
  239.             'security'
  240.         );
  242.         // needed to update the YAML files
  243.         $dependencies->addClassDependency(
  244.             Yaml::class,
  245.             'yaml'
  246.         );
  248.         if (null !== $input && $input->getOption('is-entity')) {
  249.             ORMDependencyBuilder::buildDependencies($dependencies);
  250.         }
  251.     }
  252. }