Sindbad~EG File Manager
<?php
/*
* This file is part of the Symfony MakerBundle package.
*
* (c) Fabien Potencier <fabien@symfony.com>
*
* For the full copyright and license information, please view the LICENSE
* file that was distributed with this source code.
*/
namespace Symfony\Bundle\MakerBundle\Maker;
use Doctrine\Bundle\DoctrineBundle\DoctrineBundle;
use Doctrine\Common\Annotations\Annotation;
use Doctrine\ORM\EntityManagerInterface;
use Doctrine\ORM\Mapping\Column;
use Symfony\Bridge\Doctrine\Validator\Constraints\UniqueEntity;
use Symfony\Bridge\Twig\Mime\TemplatedEmail;
use Symfony\Bundle\MakerBundle\ConsoleStyle;
use Symfony\Bundle\MakerBundle\DependencyBuilder;
use Symfony\Bundle\MakerBundle\Doctrine\DoctrineHelper;
use Symfony\Bundle\MakerBundle\Exception\RuntimeCommandException;
use Symfony\Bundle\MakerBundle\FileManager;
use Symfony\Bundle\MakerBundle\Generator;
use Symfony\Bundle\MakerBundle\InputConfiguration;
use Symfony\Bundle\MakerBundle\Renderer\FormTypeRenderer;
use Symfony\Bundle\MakerBundle\Security\InteractiveSecurityHelper;
use Symfony\Bundle\MakerBundle\Str;
use Symfony\Bundle\MakerBundle\Util\ClassDetails;
use Symfony\Bundle\MakerBundle\Util\ClassNameDetails;
use Symfony\Bundle\MakerBundle\Util\ClassSourceManipulator;
use Symfony\Bundle\MakerBundle\Util\TemplateComponentGenerator;
use Symfony\Bundle\MakerBundle\Util\YamlSourceManipulator;
use Symfony\Bundle\MakerBundle\Validator;
use Symfony\Bundle\SecurityBundle\SecurityBundle;
use Symfony\Bundle\TwigBundle\TwigBundle;
use Symfony\Component\Console\Command\Command;
use Symfony\Component\Console\Input\InputInterface;
use Symfony\Component\Form\AbstractType;
use Symfony\Component\Form\Extension\Core\Type\CheckboxType;
use Symfony\Component\Form\Extension\Core\Type\PasswordType;
use Symfony\Component\HttpFoundation\Request;
use Symfony\Component\HttpFoundation\Response;
use Symfony\Component\Mailer\MailerInterface;
use Symfony\Component\Mime\Address;
use Symfony\Component\PasswordHasher\Hasher\UserPasswordHasherInterface;
use Symfony\Component\Routing\Annotation\Route;
use Symfony\Component\Routing\RouterInterface;
use Symfony\Component\Security\Core\Encoder\UserPasswordEncoderInterface;
use Symfony\Component\Security\Guard\GuardAuthenticatorHandler;
use Symfony\Component\Security\Http\Authentication\UserAuthenticatorInterface;
use Symfony\Component\Translation\Translator;
use Symfony\Component\Validator\Validation;
use Symfony\Contracts\Translation\TranslatorInterface;
use SymfonyCasts\Bundle\VerifyEmail\Exception\VerifyEmailExceptionInterface;
use SymfonyCasts\Bundle\VerifyEmail\Model\VerifyEmailSignatureComponents;
use SymfonyCasts\Bundle\VerifyEmail\SymfonyCastsVerifyEmailBundle;
/**
* @author Ryan Weaver <ryan@symfonycasts.com>
* @author Jesse Rushlow <jr@rushlow.dev>
*
* @internal
*/
final class MakeRegistrationForm extends AbstractMaker
{
private $fileManager;
private $formTypeRenderer;
private $router;
private $doctrineHelper;
private $userClass;
private $usernameField;
private $passwordField;
private $willVerifyEmail = false;
private $verifyEmailAnonymously = false;
private $idGetter;
private $emailGetter;
private $fromEmailAddress;
private $fromEmailName;
private $autoLoginAuthenticator;
private $firewallName;
private $redirectRouteName;
private $addUniqueEntityConstraint;
private $useNewAuthenticatorSystem = false;
public function __construct(FileManager $fileManager, FormTypeRenderer $formTypeRenderer, RouterInterface $router, DoctrineHelper $doctrineHelper)
{
$this->fileManager = $fileManager;
$this->formTypeRenderer = $formTypeRenderer;
$this->router = $router;
$this->doctrineHelper = $doctrineHelper;
}
public static function getCommandName(): string
{
return 'make:registration-form';
}
public static function getCommandDescription(): string
{
return 'Creates a new registration form system';
}
public function configureCommand(Command $command, InputConfiguration $inputConf): void
{
$command
->setHelp(file_get_contents(__DIR__.'/../Resources/help/MakeRegistrationForm.txt'))
;
}
public function interact(InputInterface $input, ConsoleStyle $io, Command $command): void
{
$interactiveSecurityHelper = new InteractiveSecurityHelper();
if (!$this->fileManager->fileExists($path = 'config/packages/security.yaml')) {
throw new RuntimeCommandException('The file "config/packages/security.yaml" does not exist. This command needs that file to accurately build your registration form.');
}
$manipulator = new YamlSourceManipulator($this->fileManager->getFileContents($path));
$securityData = $manipulator->getData();
$providersData = $securityData['security']['providers'] ?? [];
// Determine if we should use new security features introduced in Symfony 5.2
if ($securityData['security']['enable_authenticator_manager'] ?? false) {
$this->useNewAuthenticatorSystem = true;
}
$this->userClass = $interactiveSecurityHelper->guessUserClass(
$io,
$providersData,
'Enter the User class that you want to create during registration (e.g. <fg=yellow>App\\Entity\\User</>)'
);
$io->text(sprintf('Creating a registration form for <info>%s</info>', $this->userClass));
$this->usernameField = $interactiveSecurityHelper->guessUserNameField($io, $this->userClass, $providersData);
$this->passwordField = $interactiveSecurityHelper->guessPasswordField($io, $this->userClass);
// see if it makes sense to add the UniqueEntity constraint
$userClassDetails = new ClassDetails($this->userClass);
$addAnnotation = false;
if (!$userClassDetails->doesDocBlockContainAnnotation('@UniqueEntity')) {
$addAnnotation = $io->confirm(sprintf('Do you want to add a <comment>@UniqueEntity</comment> validation annotation on your <comment>%s</comment> class to make sure duplicate accounts aren\'t created?', Str::getShortClassName($this->userClass)));
}
$this->addUniqueEntityConstraint = $addAnnotation;
$this->willVerifyEmail = $io->confirm('Do you want to send an email to verify the user\'s email address after registration?', true);
if ($this->willVerifyEmail) {
$this->checkComponentsExist($io);
$emailText[] = 'By default, users are required to be authenticated when they click the verification link that is emailed to them.';
$emailText[] = 'This prevents the user from registering on their laptop, then clicking the link on their phone, without';
$emailText[] = 'having to log in. To allow multi device email verification, we can embed a user id in the verification link.';
$io->text($emailText);
$io->newLine();
$this->verifyEmailAnonymously = $io->confirm('Would you like to include the user id in the verification link to allow anonymous email verification?', false);
$this->idGetter = $interactiveSecurityHelper->guessIdGetter($io, $this->userClass);
$this->emailGetter = $interactiveSecurityHelper->guessEmailGetter($io, $this->userClass, 'email');
$this->fromEmailAddress = $io->ask(
'What email address will be used to send registration confirmations? e.g. mailer@your-domain.com',
null,
[Validator::class, 'validateEmailAddress']
);
$this->fromEmailName = $io->ask(
'What "name" should be associated with that email address? e.g. "Acme Mail Bot"',
null,
[Validator::class, 'notBlank']
);
}
if ($io->confirm('Do you want to automatically authenticate the user after registration?')) {
$this->interactAuthenticatorQuestions(
$input,
$io,
$interactiveSecurityHelper,
$securityData,
$command
);
}
if (!$this->autoLoginAuthenticator) {
$routeNames = array_keys($this->router->getRouteCollection()->all());
$this->redirectRouteName = $io->choice('What route should the user be redirected to after registration?', $routeNames);
}
}
private function interactAuthenticatorQuestions(InputInterface $input, ConsoleStyle $io, InteractiveSecurityHelper $interactiveSecurityHelper, array $securityData, Command $command): void
{
$firewallsData = $securityData['security']['firewalls'] ?? [];
$firewallName = $interactiveSecurityHelper->guessFirewallName(
$io,
$securityData,
'Which firewall key in security.yaml holds the authenticator you want to use for logging in?'
);
if (!isset($firewallsData[$firewallName])) {
$io->note('No firewalls found - skipping authentication after registration. You might want to configure your security before running this command.');
return;
}
$this->firewallName = $firewallName;
// get list of guard authenticators
$authenticatorClasses = $interactiveSecurityHelper->getAuthenticatorClasses($firewallsData[$firewallName]);
if (empty($authenticatorClasses)) {
$io->note('No Guard authenticators found - so your user won\'t be automatically authenticated after registering.');
} else {
$this->autoLoginAuthenticator =
1 === \count($authenticatorClasses) ? $authenticatorClasses[0] : $io->choice(
'Which authenticator\'s onAuthenticationSuccess() should be used after logging in?',
$authenticatorClasses
);
}
}
public function generate(InputInterface $input, ConsoleStyle $io, Generator $generator): void
{
$userClassNameDetails = $generator->createClassNameDetails(
'\\'.$this->userClass,
'Entity\\'
);
$userDoctrineDetails = $this->doctrineHelper->createDoctrineDetails($userClassNameDetails->getFullName());
$userRepoVars = [
'repository_full_class_name' => 'Doctrine\ORM\EntityManagerInterface',
'repository_class_name' => 'EntityManagerInterface',
'repository_var' => '$manager',
];
$userRepository = $userDoctrineDetails->getRepositoryClass();
if (null !== $userRepository) {
$userRepoClassDetails = $generator->createClassNameDetails('\\'.$userRepository, 'Repository\\', 'Repository');
$userRepoVars = [
'repository_full_class_name' => $userRepoClassDetails->getFullName(),
'repository_class_name' => $userRepoClassDetails->getShortName(),
'repository_var' => sprintf('$%s', lcfirst($userRepoClassDetails->getShortName())),
];
}
$verifyEmailServiceClassNameDetails = $generator->createClassNameDetails(
'EmailVerifier',
'Security\\'
);
if ($this->willVerifyEmail) {
$generator->generateClass(
$verifyEmailServiceClassNameDetails->getFullName(),
'verifyEmail/EmailVerifier.tpl.php',
array_merge([
'id_getter' => $this->idGetter,
'email_getter' => $this->emailGetter,
'verify_email_anonymously' => $this->verifyEmailAnonymously,
],
$userRepoVars
)
);
$generator->generateTemplate(
'registration/confirmation_email.html.twig',
'registration/twig_email.tpl.php'
);
}
// 1) Generate the form class
$usernameField = $this->usernameField;
$formClassDetails = $this->generateFormClass(
$userClassNameDetails,
$generator,
$usernameField
);
// 2) Generate the controller
$controllerClassNameDetails = $generator->createClassNameDetails(
'RegistrationController',
'Controller\\'
);
/*
* @legacy Conditional can be removed when MakerBundle no longer
* supports Symfony < 5.2
*/
$passwordHasher = UserPasswordEncoderInterface::class;
if (interface_exists(UserPasswordHasherInterface::class)) {
$passwordHasher = UserPasswordHasherInterface::class;
}
$useStatements = [
Generator::getControllerBaseClass()->getFullName(),
$formClassDetails->getFullName(),
$userClassNameDetails->getFullName(),
Request::class,
Response::class,
Route::class,
$passwordHasher,
EntityManagerInterface::class,
];
if ($this->willVerifyEmail) {
$useStatements[] = $verifyEmailServiceClassNameDetails->getFullName();
$useStatements[] = TemplatedEmail::class;
$useStatements[] = Address::class;
$useStatements[] = VerifyEmailExceptionInterface::class;
if ($this->verifyEmailAnonymously) {
$useStatements[] = $userRepoVars['repository_full_class_name'];
}
}
if ($this->autoLoginAuthenticator) {
$useStatements[] = $this->autoLoginAuthenticator;
if ($this->useNewAuthenticatorSystem) {
$useStatements[] = UserAuthenticatorInterface::class;
} else {
$useStatements[] = GuardAuthenticatorHandler::class;
}
}
if ($isTranslatorAvailable = class_exists(Translator::class)) {
$useStatements[] = TranslatorInterface::class;
}
$generator->generateController(
$controllerClassNameDetails->getFullName(),
'registration/RegistrationController.tpl.php',
array_merge([
'use_statements' => TemplateComponentGenerator::generateUseStatements($useStatements),
'route_path' => '/register',
'route_name' => 'app_register',
'form_class_name' => $formClassDetails->getShortName(),
'user_class_name' => $userClassNameDetails->getShortName(),
'password_field' => $this->passwordField,
'will_verify_email' => $this->willVerifyEmail,
'email_verifier_class_details' => $verifyEmailServiceClassNameDetails,
'verify_email_anonymously' => $this->verifyEmailAnonymously,
'from_email' => $this->fromEmailAddress,
'from_email_name' => $this->fromEmailName,
'email_getter' => $this->emailGetter,
'authenticator_class_name' => $this->autoLoginAuthenticator ? Str::getShortClassName($this->autoLoginAuthenticator) : null,
'authenticator_full_class_name' => $this->autoLoginAuthenticator,
'use_new_authenticator_system' => $this->useNewAuthenticatorSystem,
'firewall_name' => $this->firewallName,
'redirect_route_name' => $this->redirectRouteName,
'password_hasher_class_details' => ($passwordClassDetails = $generator->createClassNameDetails($passwordHasher, '\\')),
'password_hasher_variable_name' => str_replace('Interface', '', sprintf('$%s', lcfirst($passwordClassDetails->getShortName()))), // @legacy see passwordHasher conditional above
'use_password_hasher' => UserPasswordHasherInterface::class === $passwordHasher, // @legacy see passwordHasher conditional above
'translator_available' => $isTranslatorAvailable,
],
$userRepoVars
)
);
// 3) Generate the template
$generator->generateTemplate(
'registration/register.html.twig',
'registration/twig_template.tpl.php',
[
'username_field' => $usernameField,
'will_verify_email' => $this->willVerifyEmail,
]
);
// 4) Update the User class if necessary
if ($this->addUniqueEntityConstraint) {
$classDetails = new ClassDetails($this->userClass);
$userManipulator = new ClassSourceManipulator(
file_get_contents($classDetails->getPath())
);
$userManipulator->setIo($io);
if ($this->doctrineHelper->isDoctrineSupportingAttributes()) {
$userManipulator->addAttributeToClass(
UniqueEntity::class,
['fields' => [$usernameField], 'message' => sprintf('There is already an account with this %s', $usernameField)]
);
} else {
$userManipulator->addAnnotationToClass(
UniqueEntity::class,
[
'fields' => [$usernameField],
'message' => sprintf('There is already an account with this %s', $usernameField),
]
);
}
$this->fileManager->dumpFile($classDetails->getPath(), $userManipulator->getSourceCode());
}
if ($this->willVerifyEmail) {
$classDetails = new ClassDetails($this->userClass);
$userManipulator = new ClassSourceManipulator(
file_get_contents($classDetails->getPath()),
false,
$this->doctrineHelper->isClassAnnotated($this->userClass),
true,
$this->doctrineHelper->doesClassUsesAttributes($this->userClass)
);
$userManipulator->setIo($io);
$userManipulator->addProperty(
'isVerified',
['@ORM\Column(type="boolean")'],
false,
[$userManipulator->buildAttributeNode(Column::class, ['type' => 'boolean'], 'ORM')]
);
$userManipulator->addAccessorMethod('isVerified', 'isVerified', 'bool', false);
$userManipulator->addSetter('isVerified', 'bool', false);
$this->fileManager->dumpFile($classDetails->getPath(), $userManipulator->getSourceCode());
}
$generator->writeChanges();
$this->writeSuccessMessage($io);
$this->successMessage($io, $this->willVerifyEmail, $userClassNameDetails->getShortName());
}
private function successMessage(ConsoleStyle $io, bool $emailVerification, string $userClass): void
{
$closing[] = 'Next:';
if (!$emailVerification) {
$closing[] = 'Make any changes you need to the form, controller & template.';
} else {
$index = 1;
if ($missingPackagesMessage = $this->getMissingComponentsComposerMessage()) {
$closing[] = '1) Install some missing packages:';
$closing[] = sprintf(' <fg=green>%s</>', $missingPackagesMessage);
++$index;
}
$closing[] = sprintf('%d) In <fg=yellow>RegistrationController::verifyUserEmail()</>:', $index++);
$closing[] = ' * Customize the last <fg=yellow>redirectToRoute()</> after a successful email verification.';
$closing[] = ' * Make sure you\'re rendering <fg=yellow>success</> flash messages or change the <fg=yellow>$this->addFlash()</> line.';
$closing[] = sprintf('%d) Review and customize the form, controller, and templates as needed.', $index++);
$closing[] = sprintf('%d) Run <fg=yellow>"php bin/console make:migration"</> to generate a migration for the newly added <fg=yellow>%s::isVerified</> property.', $index++, $userClass);
}
$io->text($closing);
$io->newLine();
$io->text('Then open your browser, go to "/register" and enjoy your new form!');
$io->newLine();
}
private function checkComponentsExist(ConsoleStyle $io): void
{
$message = $this->getMissingComponentsComposerMessage();
if ($message) {
$io->warning([
'We\'re missing some important components. Don\'t forget to install these after you\'re finished.',
$message,
]);
}
}
private function getMissingComponentsComposerMessage(): ?string
{
$missing = false;
$composerMessage = 'composer require';
// verify-email-bundle 1.1.1 includes support for translations and a fix for the bad expiration time bug.
// we need to check that if the bundle is installed, it is version 1.1.1 or greater
if (class_exists(SymfonyCastsVerifyEmailBundle::class)) {
$reflectedComponents = new \ReflectionClass(VerifyEmailSignatureComponents::class);
if (!$reflectedComponents->hasMethod('getExpirationMessageKey')) {
throw new RuntimeCommandException('Please upgrade symfonycasts/verify-email-bundle to version 1.1.1 or greater.');
}
} else {
$missing = true;
$composerMessage = sprintf('%s symfonycasts/verify-email-bundle', $composerMessage);
}
if (!interface_exists(MailerInterface::class)) {
$missing = true;
$composerMessage = sprintf('%s symfony/mailer', $composerMessage);
}
if (!$missing) {
return null;
}
return $composerMessage;
}
public function configureDependencies(DependencyBuilder $dependencies): void
{
$dependencies->addClassDependency(
Annotation::class,
'doctrine/annotations'
);
$dependencies->addClassDependency(
AbstractType::class,
'form'
);
$dependencies->addClassDependency(
Validation::class,
'validator'
);
$dependencies->addClassDependency(
TwigBundle::class,
'twig-bundle'
);
$dependencies->addClassDependency(
DoctrineBundle::class,
'orm'
);
$dependencies->addClassDependency(
SecurityBundle::class,
'security'
);
}
private function generateFormClass(ClassNameDetails $userClassDetails, Generator $generator, string $usernameField): ClassNameDetails
{
$formClassDetails = $generator->createClassNameDetails(
'RegistrationFormType',
'Form\\'
);
$formFields = [
$usernameField => null,
'agreeTerms' => [
'type' => CheckboxType::class,
'options_code' => <<<EOF
'mapped' => false,
'constraints' => [
new IsTrue([
'message' => 'You should agree to our terms.',
]),
],
EOF
],
'plainPassword' => [
'type' => PasswordType::class,
'options_code' => <<<EOF
// instead of being set onto the object directly,
// this is read and encoded in the controller
'mapped' => false,
'attr' => ['autocomplete' => 'new-password'],
'constraints' => [
new NotBlank([
'message' => 'Please enter a password',
]),
new Length([
'min' => 6,
'minMessage' => 'Your password should be at least {{ limit }} characters',
// max length allowed by Symfony for security reasons
'max' => 4096,
]),
],
EOF
],
];
$this->formTypeRenderer->render(
$formClassDetails,
$formFields,
$userClassDetails,
[
'Symfony\Component\Validator\Constraints\IsTrue',
'Symfony\Component\Validator\Constraints\Length',
'Symfony\Component\Validator\Constraints\NotBlank',
]
);
return $formClassDetails;
}
}
Sindbad File Manager Version 1.0, Coded By Sindbad EG ~ The Terrorists