/**
* @see Command
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$output->writeln('');
$output->writeln(sprintf('<info>Generation of Crud Rest Controller for "%s" Document in "%s" bundle.</info>', $input->getOption('document'), $input->getOption('bundle')));
$output->writeln('');
$document = $input->getOption('document');
$bundle = $input->getOption('bundle');
$bundle = Validators::validateBundleName($bundle);
try {
$bundle = $this->getContainer()->get('kernel')->getBundle($bundle);
} catch (\Exception $e) {
$output->writeln(sprintf('<bg=red>Bundle "%s" does not exist.</>', $bundle));
}
// Get document metadata
$dm = $this->getContainer()->get('doctrine_mongodb.odm.document_manager');
$class_metadata = $dm->getClassMetadata($document);
$generator = $this->getGenerator($this->getContainer()->get('kernel')->getBundle('RedkingCoreRestBundle'));
if ($input->getOption('no-controller') === false) {
$generator->generate($bundle, $class_metadata);
$output->writeln('Generating the CRUD code: <info>OK</info>');
}
if ($input->getOption('no-service') === false) {
$generator->generateServices($bundle, $class_metadata);
$output->writeln('Generating the services: <info>OK</info>');
}
if ($input->getOption('no-test') === false) {
$generator->generateTests($bundle, $class_metadata);
$output->writeln('Generating the functional test: <info>OK</info>');
}
if ($input->getOption('no-route') === false) {
$generator->generateRouting($bundle, $class_metadata);
$output->writeln('Add routing: <info>OK</info>');
}
}
public function execute(InputInterface $input, OutputInterface $output)
{
$questionHelper = $this->getQuestionHelper();
if ($input->isInteractive() && !$input->getOption('no-summary')) {
$question = new Question($questionHelper->getQuestion('Do you confirm generation', 'yes', '?'), true);
if (!$questionHelper->ask($input, $output, $question)) {
$output->writeln('<error>Command aborted</error>');
return 1;
}
}
if (null === $input->getOption('controller')) {
throw new \RuntimeException('The controller option must be provided.');
}
list($bundle) = $this->parseShortcutNotation($input->getOption('controller'));
if (is_string($bundle)) {
$bundle = Validators::validateBundleName($bundle);
try {
$this->getContainer()->get('kernel')->getBundle($bundle);
} catch (\Exception $e) {
$output->writeln(sprintf('<bg=red>Bundle "%s" does not exist.</>', $bundle));
}
}
/** @var TemplateInterface $generator */
$generator = $this->getGenerator();
$questionHelper->writeSection($output, 'Controller generation');
$errors = array();
$runner = $questionHelper->getRunner($output, $errors);
$runner($generator->generate($input->getOption('controller')));
if (!$input->getOption('no-summary')) {
$questionHelper->writeGeneratorSummary($output, $generator->getErrors());
}
}
/**
* {@inheritdoc}
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$namespace = $input->getOption('namespace');
$bundleName = strtr($namespace, array('\\' => ''));
$bundleName = Validators::validateBundleName($bundleName);
$bundle = new Bundle($namespace, $bundleName, getcwd() . '/src', 'yml', true);
/**
* @var UnitedBundleGenerator $generator
*/
$generator = $this->getGenerator();
$output->writeln(sprintf('> Generating a united admin bundle skeleton into <info>%s</info> <comment>OK!</comment>', $this->makePathRelative($bundle->getTargetDirectory())));
// Write section
$questionHelper = $this->getQuestionHelper();
$questionHelper->writeSection($output, 'Bundle generation');
// generate the bundle
$generator->generateBundle($bundle);
// After generation we need to perform some app updates
$errors = array();
$runner = $questionHelper->getRunner($output, $errors);
// register the bundle in the Kernel class
$runner($this->updateKernel($output, $this->getContainer()->get('kernel'), $bundle));
// routing importing
$runner($this->updateRouting($output, $bundle));
// print summary
$questionHelper->writeGeneratorSummary($output, $errors);
}
/**
* Executes the command.
*
* @param InputInterface $input An InputInterface instance
* @param OutputInterface $output An OutputInterface instance
*
* @throws \RuntimeException
* @return void
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$questionHelper = $this->getQuestionHelper();
if ($input->isInteractive()) {
$confirmationQuestion = new ConfirmationQuestion($questionHelper->getQuestion('Do you confirm generation', 'yes', '?'), true);
if (!$questionHelper->ask($input, $output, $confirmationQuestion)) {
$output->writeln('<error>Command aborted</error>');
return 1;
}
}
GeneratorUtils::ensureOptionsProvided($input, array('namespace', 'dir'));
$namespace = Validators::validateBundleNamespace($input->getOption('namespace'));
if (!($bundle = $input->getOption('bundle-name'))) {
$bundle = strtr($namespace, array('\\' => ''));
}
$bundle = Validators::validateBundleName($bundle);
$dir = $this::validateTargetDir($input->getOption('dir'), $bundle, $namespace);
$format = 'yml';
$questionHelper->writeSection($output, 'Bundle generation');
if (!$this->getContainer()->get('filesystem')->isAbsolutePath($dir)) {
$dir = getcwd() . '/' . $dir;
}
$generator = $this->getGenerator($this->getApplication()->getKernel()->getBundle("KunstmaanGeneratorBundle"));
$generator->generate($namespace, $bundle, $dir, $format);
$output->writeln('Generating the bundle code: <info>OK</info>');
$errors = array();
$runner = $questionHelper->getRunner($output, $errors);
// check that the namespace is already autoloaded
$runner($this->checkAutoloader($output, $namespace, $bundle));
// register the bundle in the Kernel class
$runner($this->updateKernel($questionHelper, $input, $output, $this->getContainer()->get('kernel'), $namespace, $bundle));
// routing
$runner($this->updateRouting($questionHelper, $input, $output, $bundle, $format));
$questionHelper->writeGeneratorSummary($output, $errors);
}
public function execute(InputInterface $input, OutputInterface $output)
{
$questionHelper = $this->getQuestionHelper();
if ($input->isInteractive()) {
$question = new Question($questionHelper->getQuestion('Do you confirm generation', 'yes', '?'), true);
if (!$questionHelper->ask($input, $output, $question)) {
$output->writeln('<error>Command aborted</error>');
return 1;
}
}
if (null === $input->getOption('controller')) {
throw new \RuntimeException('The controller option must be provided.');
}
list($bundle, $controller) = $this->parseShortcutNotation($input->getOption('controller'));
if (is_string($bundle)) {
$bundle = Validators::validateBundleName($bundle);
try {
$bundle = $this->getContainer()->get('kernel')->getBundle($bundle);
} catch (\Exception $e) {
$output->writeln(sprintf('<bg=red>Bundle "%s" does not exist.</>', $bundle));
}
}
$questionHelper->writeSection($output, 'Controller generation');
$generator = $this->getGenerator($bundle);
$generator->generate($bundle, $controller, $input->getOption('route-format'), $input->getOption('template-format'), $this->parseActions($input->getOption('actions')));
$output->writeln('Generating the bundle code: <info>OK</info>');
$questionHelper->writeGeneratorSummary($output, array());
}
/**
* {@inheritdoc}
*/
protected function interact(InputInterface $input, OutputInterface $output)
{
// Start question helper
$questionHelper = $this->getQuestionHelper();
$questionHelper->writeSection($output, 'Welcome to the united CRUD generator!');
// get entity
$entity = $input->getOption('entity');
$question = new Question($questionHelper->getQuestion('Entity', $entity), $entity);
$question->setValidator(function ($answer) {
return Validators::validateEntityName($answer);
});
$complete = new EntitiesAutoCompleter($this->getContainer()->get('doctrine')->getManager());
$completeEntities = $complete->getSuggestions();
$question->setAutocompleterValues($completeEntities);
$entity = $questionHelper->ask($input, $output, $question);
$input->setOption('entity', $entity);
// get bundle
$destinationBundle = $input->getOption('bundle');
$question = new Question($questionHelper->getQuestion('Destination bundle', $destinationBundle), $destinationBundle);
$question->setValidator(function ($answer) {
return Validators::validateBundleName($answer);
});
$question->setAutocompleterValues($this->getBundleSuggestions());
$destinationBundle = $questionHelper->ask($input, $output, $question);
$input->setOption('bundle', $destinationBundle);
}
/**
* @see Command
*
* @throws \InvalidArgumentException When namespace doesn't end with Bundle
* @throws \RuntimeException When bundle can't be executed
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$dialog = $this->getDialogHelper();
// @codeCoverageIgnoreStart
if ($input->isInteractive()) {
if (!$dialog->askConfirmation($output, $dialog->getQuestion('Do you confirm generation', 'yes', '?'), true)) {
$output->writeln('<error>Command aborted</error>');
return 1;
}
}
// @codeCoverageIgnoreEnd
foreach (array('namespace', 'dir') as $option) {
if (null === $input->getOption($option)) {
// @codeCoverageIgnoreStart
throw new \RuntimeException(sprintf('The "%s" option must be provided.', $option));
// @codeCoverageIgnoreEnd
}
}
$namespace = Validators::validateBundleNamespace($input->getOption('namespace'));
if (!($bundle = $input->getOption('bundle-name'))) {
$bundle = strtr($namespace, array('\\' => ''));
}
if ($input->getOption('no-strict') == false) {
$this->checkStrictNamespace($namespace);
}
$bundle = Validators::validateBundleName($bundle);
$dir = Validators::validateTargetDir($input->getOption('dir'), $bundle, $namespace);
$format = Validators::validateFormat($input->getOption('format'));
$structure = $input->getOption('structure');
$dialog->writeSection($output, 'Bundle generation');
// @codeCoverageIgnoreStart
if (!$this->getContainer()->get('filesystem')->isAbsolutePath($dir)) {
$dir = getcwd() . '/' . $dir;
}
// @codeCoverageIgnoreEnd
$generator = $this->getGenerator();
$generator->generateExt($namespace, $bundle, $dir, $format, $structure, $this->getGeneratorExtraOptions($input));
$output->writeln('Generating the bundle code: <info>OK</info>');
$errors = array();
$runner = $dialog->getRunner($output, $errors);
// check that the namespace is already autoloaded
$runner($this->checkAutoloader($output, $namespace, $bundle, $dir));
// register the bundle in the Kernel class
if ($this->updateKernel) {
$runner($this->updateKernel($dialog, $input, $output, $this->getContainer()->get('kernel'), $namespace, $bundle));
}
$dialog->writeGeneratorSummary($output, $errors);
}
public function execute(InputInterface $input, OutputInterface $output)
{
$questionHelper = $this->getQuestionHelper();
if ($input->isInteractive() && !$input->getOption('no-summary')) {
$question = new Question($questionHelper->getQuestion('Do you confirm generation', 'yes', '?'), true);
if (!$questionHelper->ask($input, $output, $question)) {
$output->writeln('<error>Command aborted</error>');
return 1;
}
}
if (null === $input->getOption('entity')) {
throw new \RuntimeException('The entity option must be provided.');
}
list($bundle) = $this->parseShortcutNotation($input->getOption('entity'));
if (is_string($bundle)) {
$bundle = Validators::validateBundleName($bundle);
try {
$this->getContainer()->get('kernel')->getBundle($bundle);
} catch (\Exception $e) {
$output->writeln(sprintf('<bg=red>Bundle "%s" does not exist.</bg>', $bundle));
}
}
/** @var TemplateInterface $generator */
$generator = $this->getGenerator();
if ($input->getOption('no-backend')) {
$generator->setConfiguration('backend_crud', false);
}
if ($input->getOption('actions')) {
$generator->setConfiguration('actions', explode(',', $input->getOption('actions')));
}
$questionHelper->writeSection($output, 'CRUD generation');
$errors = array();
$runner = $questionHelper->getRunner($output, $errors);
if (!$input->getOption('no-backend')) {
$generator->setConfiguration('backend_bundle', $input->getOption('backend'));
}
$runner($generator->generate($input->getOption('entity'), $output));
if (!$input->getOption('no-backend')) {
$questionHelper->writeSection($output, "Don't forget to run sylius:rbac:initialize command");
}
if (!$input->getOption('no-summary')) {
$questionHelper->writeGeneratorSummary($output, $generator->getErrors());
}
}
/**
* @see Command
*
* @throws \InvalidArgumentException When namespace doesn't end with Bundle
* @throws \RuntimeException When bundle can't be executed
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$helper = $this->getQuestionHelper();
$question = new ConfirmationQuestion('Do you confirm generation?', true);
if ($input->isInteractive()) {
if (!$helper->ask($input, $output, $question)) {
$output->writeln('<error>Command aborted</error>');
return 1;
}
}
foreach (array('namespace', 'short-name') as $option) {
if (null === $input->getOption($option)) {
throw new \RuntimeException(sprintf('The "%s" option must be provided.', $option));
}
}
$namespace = Validators::validateBundleNamespace($input->getOption('namespace'));
$bundle = strtr($namespace, array('\\' => ''));
$bundle = Validators::validateBundleName($bundle);
$dir = realpath(__DIR__ . '/../../../../../../');
if (null !== $input->getOption('dir')) {
$dir = $input->getOption('dir');
}
$dir = Validators::validateTargetDir($dir, $bundle, $namespace);
if (!$this->getContainer()->get('filesystem')->isAbsolutePath($dir)) {
$dir = getcwd() . '/' . $dir;
}
$format = 'yml';
$format = Validators::validateFormat($format);
$helper->writeSection($output, 'Bundle generation');
/** @var ComponentGenerator $generator */
$generator = $this->getGenerator();
$generator->generate($namespace, $bundle, $dir, $format);
$output->writeln('Generating the bundle code: <info>OK</info>');
$errors = array();
$runner = $helper->getRunner($output, $errors);
//update parameters.yml file in vendor
$shortName = $input->getOption('short-name');
$runner($this->updateParameters($output, $shortName, $dir, $namespace, $bundle));
$helper->writeGeneratorSummary($output, $errors);
}
/**
* @see Command
*
* @throws \InvalidArgumentException When namespace doesn't end with Bundle
* @throws \RuntimeException When bundle can't be executed
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$dialog = $this->getDialogHelper();
if ($input->isInteractive()) {
if (!$dialog->askConfirmation($output, $dialog->getQuestion('Do you confirm generation', 'yes', '?'), true)) {
$output->writeln('<error>Command aborted</error>');
return 1;
}
}
foreach (array('namespace', 'dir') as $option) {
if (null === $input->getOption($option)) {
throw new \RuntimeException(sprintf('The "%s" option must be provided.', $option));
}
}
$namespace = Validators::validateBundleNamespace($input->getOption('namespace'));
if (!($bundle = $input->getOption('bundle-name'))) {
$bundle = strtr($namespace, array('\\' => ''));
}
$bundle = Validators::validateBundleName($bundle);
$format = Validators::validateFormat($input->getOption('format'));
$dir = $input->getOption('dir') . '/';
$structure = $input->getOption('structure');
$dialog->writeSection($output, 'Bundle generation');
if (!$this->getContainer()->get('filesystem')->isAbsolutePath($dir)) {
$dir = getcwd() . '/' . $dir;
}
$generator = $this->getGenerator();
$generator->setGenerator($input->getOption('generator'));
$generator->setPrefix($input->getOption('prefix'));
$generator->generate($namespace, $bundle, $dir, $format, $structure);
$output->writeln('Generating the bundle code: <info>OK</info>');
$errors = array();
$runner = $dialog->getRunner($output, $errors);
// routing
$runner($this->updateRouting($dialog, $input, $output, $bundle, $format));
$dialog->writeGeneratorSummary($output, $errors);
}
protected function interact(InputInterface $input, OutputInterface $output)
{
$questionHelper = $this->getQuestionHelper();
$questionHelper->writeSection($output, 'Welcome to the Symfony2 bundle generator');
// namespace
$namespace = null;
try {
// validate the namespace option (if any) but don't require the vendor namespace
$namespace = $input->getOption('namespace') ? Validators::validateBundleNamespace($input->getOption('namespace'), false) : null;
} catch (\Exception $error) {
$output->writeln($questionHelper->getHelperSet()->get('formatter')->formatBlock($error->getMessage(), 'error'));
}
if (null === $namespace) {
$output->writeln(array('', 'Your application code must be written in <comment>bundles</comment>. This command helps', 'you generate them easily.', '', 'Each bundle is hosted under a namespace (like <comment>Acme/Bundle/BlogBundle</comment>).', 'The namespace should begin with a "vendor" name like your company name, your', 'project name, or your client name, followed by one or more optional category', 'sub-namespaces, and it should end with the bundle name itself', '(which must have <comment>Bundle</comment> as a suffix).', '', 'See http://symfony.com/doc/current/cookbook/bundles/best_practices.html#index-1 for more', 'details on bundle naming conventions.', '', 'Use <comment>/</comment> instead of <comment>\\ </comment> for the namespace delimiter to avoid any problem.', ''));
$acceptedNamespace = false;
while (!$acceptedNamespace) {
$question = new Question($questionHelper->getQuestion('Bundle namespace', $input->getOption('namespace')), $input->getOption('namespace'));
$question->setValidator(function ($answer) {
return Validators::validateBundleNamespace($answer, false);
});
$namespace = $questionHelper->ask($input, $output, $question);
// mark as accepted, unless they want to try again below
$acceptedNamespace = true;
// see if there is a vendor namespace. If not, this could be accidental
if (false === strpos($namespace, '\\')) {
// language is (almost) duplicated in Validators
$msg = array();
$msg[] = '';
$msg[] = sprintf('The namespace sometimes contain a vendor namespace (e.g. <info>VendorName/BlogBundle</info> instead of simply <info>%s</info>).', $namespace, $namespace);
$msg[] = 'If you\'ve *did* type a vendor namespace, try using a forward slash <info>/</info> (<info>Acme/BlogBundle</info>)?';
$msg[] = '';
$output->writeln($msg);
$question = new ConfirmationQuestion($questionHelper->getQuestion(sprintf('Keep <comment>%s</comment> as the bundle namespace (choose no to try again)?', $namespace), 'yes'), true);
$acceptedNamespace = $questionHelper->ask($input, $output, $question);
}
}
$input->setOption('namespace', $namespace);
}
// bundle name
$bundle = null;
try {
$bundle = $input->getOption('bundle-name') ? Validators::validateBundleName($input->getOption('bundle-name')) : null;
} catch (\Exception $error) {
$output->writeln($questionHelper->getHelperSet()->get('formatter')->formatBlock($error->getMessage(), 'error'));
}
if (null === $bundle) {
$bundle = strtr($namespace, array('\\Bundle\\' => '', '\\' => ''));
$output->writeln(array('', 'In your code, a bundle is often referenced by its name. It can be the', 'concatenation of all namespace parts but it\'s really up to you to come', 'up with a unique name (a good practice is to start with the vendor name).', 'Based on the namespace, we suggest <comment>' . $bundle . '</comment>.', ''));
$question = new Question($questionHelper->getQuestion('Bundle name', $bundle), $bundle);
$question->setValidator(array('Sensio\\Bundle\\GeneratorBundle\\Command\\Validators', 'validateBundleName'));
$bundle = $questionHelper->ask($input, $output, $question);
$input->setOption('bundle-name', $bundle);
}
// target dir
$dir = null;
try {
$dir = $input->getOption('dir') ? Validators::validateTargetDir($input->getOption('dir'), $bundle, $namespace) : null;
} catch (\Exception $error) {
$output->writeln($questionHelper->getHelperSet()->get('formatter')->formatBlock($error->getMessage(), 'error'));
}
if (null === $dir) {
$dir = dirname($this->getContainer()->getParameter('kernel.root_dir')) . '/src';
$output->writeln(array('', 'The bundle can be generated anywhere. The suggested default directory uses', 'the standard conventions.', ''));
$question = new Question($questionHelper->getQuestion('Target directory', $dir), $dir);
$question->setValidator(function ($dir) use($bundle, $namespace) {
return Validators::validateTargetDir($dir, $bundle, $namespace);
});
$dir = $questionHelper->ask($input, $output, $question);
$input->setOption('dir', $dir);
}
// format
$format = null;
try {
$format = $input->getOption('format') ? Validators::validateFormat($input->getOption('format')) : null;
} catch (\Exception $error) {
$output->writeln($questionHelper->getHelperSet()->get('formatter')->formatBlock($error->getMessage(), 'error'));
}
if (null === $format) {
$output->writeln(array('', 'Determine the format to use for the generated configuration.', ''));
$question = new Question($questionHelper->getQuestion('Configuration format (yml, xml, php, or annotation)', $input->getOption('format')), $input->getOption('format'));
$question->setValidator(array('Sensio\\Bundle\\GeneratorBundle\\Command\\Validators', 'validateFormat'));
$format = $questionHelper->ask($input, $output, $question);
$input->setOption('format', $format);
}
// optional files to generate
$output->writeln(array('', 'To help you get started faster, the command can generate some', 'code snippets for you.', ''));
$structure = $input->getOption('structure');
$question = new ConfirmationQuestion($questionHelper->getQuestion('Do you want to generate the whole directory structure', 'no', '?'), false);
if (!$structure && $questionHelper->ask($input, $output, $question)) {
$structure = true;
}
$input->setOption('structure', $structure);
// summary
$output->writeln(array('', $this->getHelper('formatter')->formatBlock('Summary before generation', 'bg=blue;fg=white', true), '', sprintf("You are going to generate a \"<info>%s\\%s</info>\" bundle\nin \"<info>%s</info>\" using the \"<info>%s</info>\" format.", $namespace, $bundle, $dir, $format), ''));
}
/**
* Gets type based on input params.
*
* @return array('bundleName','entityName')
*/
protected function getGenerationParams()
{
if ($this->input->getOption('entity')) {
$this->type = 'entity';
$this->output->writeln(array('You choose <info>entity</info> option for generation.', 'Each <info>entity</info> is hosted under a namespace (like <comment>AcmeBlogBundle:Article</comment>).'));
$entityName = null;
$entityName = $this->questionHelper->ask($this->input, $this->output, $this->questionHelper->getQuestion('Please, set <comment>entity namespace</comment>', $entityName));
$entityName = Validators::validateEntityName($entityName);
$entityNameArray = explode(':', $entityName);
$bundleName = $entityNameArray[0];
} else {
if ($this->input->getOption('project')) {
$this->type = 'project';
$this->output->writeln('You choose <info>project</info> option for generation.');
} else {
$this->type = "bundle";
if ($this->input->isInteractive()) {
$this->output->writeln(array('You choose <info>bundle</info> option for generation.', 'Each bundle is hosted under a namespace (like <comment>Acme/Bundle/BlogBundle</comment>).', 'Please write namespace of your bundle to generate fixture data.'));
$namespace = null;
//DialogHelper has not support anymore
$question = new Question($this->questionHelper->getQuestion('Please, set <comment>bundle namespace</comment>', $namespace), $namespace);
$namespace = $this->questionHelper->ask($this->input, $this->output, $question);
$namespace = Validators::validateBundleNamespace($namespace);
$bundleName = strtr($namespace, array('\\' => ''));
}
}
}
$overrideFiles = null;
//changed askconfirmation() into doAsk()
$questionFiles = new Question($this->questionHelper->getQuestion('Override existing backup files', $namespace), $namespace);
$overrideFiles = $this->questionHelper->doAsk($this->output, $questionFiles, true);
return array('bundleName' => !empty($bundleName) ? Validators::validateBundleName($bundleName) : null, 'entityName' => !empty($entityName) ? $entityName : null, 'overrideFiles' => !empty($overrideFiles) ? $overrideFiles : null);
}
/**
* @see Command
*
* @throws \InvalidArgumentException When namespace doesn't end with Bundle
* @throws \RuntimeException When bundle can't be executed
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$questionHelper = $this->getQuestionHelper();
if ($input->isInteractive()) {
$question = new ConfirmationQuestion('Do you confirm generation?', true);
if (!$questionHelper->ask($input, $output, $question)) {
$output->writeln('<error>Command aborted</error>');
return 1;
}
}
foreach (array('namespace', 'dir') as $option) {
if (null === $input->getOption($option)) {
throw new \RuntimeException(sprintf('The "%s" option must be provided.', $option));
}
}
$namespace = Validators::validateBundleNamespace($input->getOption('namespace'));
if (!($bundle = $input->getOption('bundle-name'))) {
$bundle = strtr($namespace, array('\\' => ''));
}
$bundle = Validators::validateBundleName($bundle);
$dir = Validators::validateTargetDir($input->getOption('dir'), $bundle, $namespace);
$format = Validators::validateFormat($input->getOption('format'));
$structure = $input->getOption('structure');
$questionHelper->writeSection($output, 'Bundle generation');
if (!$this->getContainer()->get('filesystem')->isAbsolutePath($dir)) {
$dir = getcwd() . '/' . $dir;
}
$generatorName = $input->getOption('generator');
$modelName = $input->getOption('model-name');
$generator = $this->createGenerator();
$generator->setGenerator($generatorName);
$generator->setPrefix($input->getOption('prefix'));
$generator->generate($namespace, $bundle, $dir, $format, $structure, $generatorName, $modelName);
$output->writeln('Generating the bundle code: <info>OK</info>');
$errors = array();
$runner = $questionHelper->getRunner($output, $errors);
// check that the namespace is already autoloaded
$runner($this->checkAutoloader($output, $namespace, $bundle, $dir));
// register the bundle in the Kernel class
$runner($this->updateKernel($questionHelper, $input, $output, $this->getContainer()->get('kernel'), $namespace, $bundle));
// routing
$runner($this->updateRouting($questionHelper, $input, $output, $bundle, $format));
$questionHelper->writeGeneratorSummary($output, $errors);
}
/**
* Creates the Bundle object based on the user's (non-interactive) input.
*
* @param InputInterface $input
*
* @return Bundle
*/
protected function createBundleObject(InputInterface $input)
{
foreach (array('namespace', 'dir') as $option) {
if (null === $input->getOption($option)) {
throw new \RuntimeException(sprintf('The "%s" option must be provided.', $option));
}
}
$shared = $input->getOption('shared');
$namespace = Validators::validateBundleNamespace($input->getOption('namespace'), $shared);
if (!($bundleName = $input->getOption('bundle-name'))) {
$bundleName = strtr($namespace, array('\\' => ''));
}
$bundleName = Validators::validateBundleName($bundleName);
$dir = $input->getOption('dir');
if (null === $input->getOption('format')) {
$input->setOption('format', 'annotation');
}
$format = Validators::validateFormat($input->getOption('format'));
// an assumption that the kernel root dir is in a directory (like app/)
$projectRootDirectory = $this->getContainer()->getParameter('kernel.root_dir') . '/..';
if (!$this->getContainer()->get('filesystem')->isAbsolutePath($dir)) {
$dir = $projectRootDirectory . '/' . $dir;
}
// add trailing / if necessary
$dir = '/' === substr($dir, -1, 1) ? $dir : $dir . '/';
$bundle = new Bundle($namespace, $bundleName, $dir, $format, $shared);
// not shared - put the tests in the root
if (!$shared) {
$testsDir = $projectRootDirectory . '/tests/' . $bundleName;
$bundle->setTestsDirectory($testsDir);
}
return $bundle;
}
/**
* Validate bundle
*
* @param $bundle
*
* @return AbstractResourceBundle
*/
private function validateBundle($bundle)
{
Validators::validateBundleName($bundle);
try {
$bundle = $this->getContainer()->get('kernel')->getBundle($bundle);
} catch (\Exception $e) {
throw new \RuntimeException('Cannot patch "%s", bundle not found.', $bundle);
}
if (!$bundle instanceof AbstractResourceBundle) {
throw new \RuntimeException('You need to implement AbstractResourceBundle for "%s"', $bundle->getName());
}
return $bundle;
}
protected function createGenerator()
{
$generator = new RestControllerGenerator($this->getContainer()->get('filesystem'));
list($bundle, $entity) = $this->parseShortcutNotation($this->input->getOption('entity'));
$generator->setEntityName($entity);
if (is_string($bundle)) {
$bundle = Validators::validateBundleName($bundle);
try {
$bundle = $this->getContainer()->get('kernel')->getBundle($bundle);
} catch (\Exception $e) {
$this->output->writeln(sprintf('<bg=red>Bundle "%s" does not exists.</>', $bundle));
}
}
/** @todo Check entity is a valid entity */
if ($this->input->getOption("mongo")) {
$generator->setMongo(true);
}
/** @todo Check entity is a valid entity */
if ($this->input->getOption("phpcr")) {
$generator->setPhpcr(true);
}
$generator->setEntityBundle($bundle);
return $generator;
}
/**
* Creates the Bundle object based on the user's (non-interactive) input.
*
* @param InputInterface $input
*
* @return Bundle
*/
protected function createBundleObject(InputInterface $input)
{
foreach (array('namespace', 'dir') as $option) {
if (null === $input->getOption($option)) {
throw new \RuntimeException(sprintf('The "%s" option must be provided.', $option));
}
}
$shared = $input->getOption('shared');
$namespace = Validators::validateBundleNamespace($input->getOption('namespace'), $shared);
if (!($bundleName = $input->getOption('bundle-name'))) {
$bundleName = strtr($namespace, array('\\' => ''));
}
$bundleName = Validators::validateBundleName($bundleName);
$dir = $input->getOption('dir');
if (null === $input->getOption('format')) {
$input->setOption('format', 'annotation');
}
$format = Validators::validateFormat($input->getOption('format'));
if (!$this->getContainer()->get('filesystem')->isAbsolutePath($dir)) {
$dir = getcwd() . '/' . $dir;
}
// add trailing / if necessary
$dir = '/' === substr($dir, -1, 1) ? $dir : $dir . '/';
return new Bundle($namespace, $bundleName, $dir, $format, $shared);
}
protected function execute(InputInterface $input, OutputInterface $output)
{
$name = $input->getArgument('name');
try {
$useCase = self::USE_CASE_BUNDLE;
$bundle = $this->getApplication()->getKernel()->getBundle($input->getArgument('name'));
} catch (\InvalidArgumentException $e) {
$useCase = self::USE_CASE_CONTROLLER;
}
if ($useCase === self::USE_CASE_CONTROLLER) {
list($bundle, $name) = $this->parseShortcutNotation($input->getArgument('name'));
$output->writeln(sprintf('Generating security for controller "<info>%s</info>"', $bundle . ":" . $name));
if (is_string($bundle)) {
$bundle = Validators::validateBundleName($bundle);
try {
$bundle = $this->getContainer()->get('kernel')->getBundle($bundle);
} catch (\Exception $e) {
$output->writeln(sprintf('<bg=red>Bundle "%s" does not exist.</>', $bundle));
}
}
$bundleDirectory = $bundle->getPath();
$controllerPath = $this->getControllerPath($bundleDirectory, $name);
$copyControllerPath = $this->getCopyControllerPath($bundleDirectory, $name);
if (file_exists($controllerPath) === false) {
throw new \RuntimeException(sprintf('Controller "%s" does not exists', $name));
}
if (file_exists($copyControllerPath) === true) {
throw new \RuntimeException(sprintf('Copy of controller "%s" exist. Remove this from the backup.', $name));
}
$creator = new PermissionCreator($controllerPath);
$buckupDirectory = $this->createBackupDirectory($bundleDirectory);
$this->createCopy($controllerPath, $copyControllerPath);
@($annotatedSource = $creator->annotate());
$result = file_put_contents($controllerPath, $annotatedSource);
if ($result === false) {
$this->throwIOException();
}
$output->writeln("Files were modified");
return 0;
} else {
$output->writeln(sprintf('Generating security for bundle "<info>%s</info>"', $bundle->getName()));
$bundleDirectory = $bundle->getPath();
if ($this->backupExists($bundleDirectory) == true) {
throw new \RuntimeException(sprintf('Backup exists!'));
}
$buckupDirectory = $this->createBackupDirectory($bundleDirectory);
$controllerDirectory = $this->getControllerDirectory($bundleDirectory);
foreach (new \DirectoryIterator($controllerDirectory) as $item) {
$fileInfo = $item->getFileInfo();
if ($fileInfo->isFile() == true) {
$copyControllerPath = $buckupDirectory . DIRECTORY_SEPARATOR . $fileInfo->getFilename();
$this->createCopy($fileInfo->getRealPath(), $copyControllerPath);
$creator = new PermissionCreator($fileInfo->getRealPath());
@($annotatedSource = $creator->annotate());
$result = file_put_contents($fileInfo->getRealPath(), $annotatedSource);
if ($result === false) {
$this->throwIOException();
}
}
}
$output->writeln("Files were modified");
return 0;
}
}
protected function interact(InputInterface $input, OutputInterface $output)
{
$questionHelper = $this->getQuestionHelper();
$questionHelper->writeSection($output, 'Welcome to the eZ FieldType generator');
// target bundle
$targetBundle = null;
try {
// validate the namespace option (if any) but don't require the vendor namespace
$targetBundle = $input->getOption('target-bundle') ? Validators::validateBundleName($input->getOption('target-bundle'), false) : null;
} catch (\Exception $error) {
$output->writeln($questionHelper->getHelperSet()->get('formatter')->formatBlock($error->getMessage(), 'error'));
}
if ($targetBundle === null) {
$output->writeln(array('', 'Your FieldType must be created in a <comment>bundle</comment>. ', '', 'If you don\'t have a bundle for it, please create one using <comment>generate:bundle</comment> first'));
$acceptedTargetBundle = false;
while (!$acceptedTargetBundle) {
$question = new Question($questionHelper->getQuestion('Target bundle name', $input->getOption('target-bundle')), $input->getOption('target-bundle'));
$question->setValidator(function ($answer) {
return Validators::validateBundleName($answer);
});
$targetBundle = $questionHelper->ask($input, $output, $question);
// mark as accepted, unless they want to try again below
$acceptedTargetBundle = true;
}
$input->setOption('target-bundle', $targetBundle);
}
$input->setOption('target-bundle-dir', $this->getContainer()->get('kernel')->locateResource("@" . $input->getOption('target-bundle')));
// FieldType name
$fieldTypeName = null;
try {
// @todo validate me
$fieldTypeName = $input->getOption('fieldtype-name');
} catch (\Exception $error) {
}
if (null === $fieldTypeName) {
$output->writeln(array('', 'A FieldType requires a unique identifier.', 'Identifiers can contain alphanumeric characters as well as underscores', ''));
$question = new Question($questionHelper->getQuestion('FieldType name', $fieldTypeName), $fieldTypeName);
// @todo validate me // $question->setValidator();
$fieldTypeName = $questionHelper->ask($input, $output, $question);
$fieldTypeRegistry = $this->getContainer()->get('ezpublish.persistence.field_type_registry');
$fieldTypeExists = true;
try {
$fieldTypeRegistry->getFieldType($fieldTypeName);
} catch (\Exception $e) {
$fieldTypeExists = false;
}
if ($fieldTypeExists === true) {
throw new InvalidArgumentException("A fieldtype {$fieldTypeName} already exists");
}
$input->setOption('fieldtype-name', $fieldTypeName);
}
// summary
$output->writeln(array('', $this->getHelper('formatter')->formatBlock('Summary before generation', 'bg=blue;fg=white', true), '', sprintf("You are going to generate a \"<info>%s</info>\" FieldType in the \"<info>%s</info>\" bundle.", $fieldTypeName, $targetBundle), ''));
}
/**
* Take arguments and options defined in $this->interact() and generate a new Widget.
*
* @param InputInterface $input
* @param OutputInterface $output
*
* @see Command
*
* @throws \InvalidArgumentException When namespace doesn't end with Bundle
* @throws \RuntimeException When bundle can't be executed
*
* @return int|null
*/
protected function execute(InputInterface $input, OutputInterface $output)
{
$questionHelper = $this->getQuestionHelper();
if ($input->isInteractive()) {
$question = new ConfirmationQuestion($questionHelper->getQuestion('Do you confirm generation', 'yes', '?'), true);
if (!$questionHelper->ask($input, $output, $question)) {
$output->writeln('<error>Command aborted</error>');
return 1;
}
}
foreach (['namespace', 'dir'] as $option) {
if (null === $input->getOption($option)) {
throw new \RuntimeException(sprintf('The "%s" option must be provided.', $option));
}
}
$namespace = Validators::validateBundleNamespace($input->getOption('namespace'));
if (!($bundle = $input->getOption('bundle-name'))) {
$bundle = strtr($namespace, ['\\' => '']);
}
$orgname = $input->getOption('orgname');
if (null === $input->getOption('orgname')) {
$orgname = $input->setOption('orgname', 'friendsofvictoire');
}
$parent = $input->getOption('parent');
if (null === $input->getOption('parent')) {
$parent = $input->setOption('parent', null);
}
$packagistParentName = $input->getOption('packagist-parent-name');
if (null === $input->getOption('packagist-parent-name')) {
$packagistParentName = $input->setOption('packagist-parent-name', null);
}
$bundle = Validators::validateBundleName($bundle);
$dir = Validators::validateTargetDir($input->getOption('dir'), $bundle, $namespace);
if (null === $input->getOption('format')) {
$input->setOption('format', 'annotation');
}
$format = Validators::validateFormat($input->getOption('format'));
$structure = $input->getOption('structure');
$contentResolver = $input->getOption('content-resolver');
$questionHelper->writeSection($output, 'Bundle generation');
if (!$this->getContainer()->get('filesystem')->isAbsolutePath($dir)) {
$dir = getcwd() . '/' . $dir;
}
$fields = $this->parseFields($input->getOption('fields'));
$parentContentResolver = $this->getContainer()->has('victoire_core.widget_' . strtolower($parent) . '_content_resolver');
$generator = $this->getGenerator();
$generator->generate($namespace, $bundle, $dir, $format, $structure, $fields, $parent, $packagistParentName, $contentResolver, $parentContentResolver, $orgname);
$output->writeln('Generating the bundle code: <info>OK</info>');
$errors = [];
$runner = $questionHelper->getRunner($output, $errors);
// check that the namespace is already autoloaded
$runner($this->checkAutoloader($output, $namespace, $bundle, $dir));
// register the bundle in the Kernel class
$runner($this->updateKernel($questionHelper, $input, $output, $this->getContainer()->get('kernel'), $namespace, $bundle));
$questionHelper->writeGeneratorSummary($output, $errors);
}
/**
* @see Command
*/
protected function interact(InputInterface $input, OutputInterface $output)
{
$this->input = $input;
$this->output = $output;
$questionHelper = $this->getQuestionHelper();
$questionHelper->writeSection($output, 'Welcome to the Sylius resource generator');
// namespace
$output->writeln(array('', 'This command helps you generate Sylius resource.', '', 'First, you need to give the entity name you want to generate.', 'You must use the shortcut notation like <comment>AcmeBlogBundle:Post</comment>.', ''));
$bundleNames = $this->getContainer()->get('kernel')->getBundles();
$bundleList = array();
foreach ($bundleNames as $bundle) {
if ($bundle instanceof AbstractResourceBundle) {
$bundleList[] = $bundle->getName();
}
}
while (true) {
$question = new Question($questionHelper->getQuestion('The Entity shortcut name', $input->getOption('resource')), $input->getOption('resource'));
$question->setValidator(array('Sensio\\Bundle\\GeneratorBundle\\Command\\Validators', 'validateEntityName'));
$question->setAutocompleterValues($bundleList);
$resource = $questionHelper->ask($input, $output, $question);
$resource = Validators::validateEntityName($resource);
list($bundle, $entity) = $this->parseShortcutNotation($resource);
$bundle = Validators::validateBundleName($bundle);
try {
$this->getContainer()->get('kernel')->getBundle($bundle);
} catch (\Exception $e) {
$output->writeln(sprintf('<bg=red>Bundle "%s" does not exist.</>', $bundle));
continue;
}
if (in_array($entity, Validators::getReservedWords())) {
$output->writeln(sprintf('<bg=red> "%s" is a reserved word</>.', $entity));
continue;
}
break;
}
$input->setOption('resource', $resource);
$dialog = $this->getHelper('dialog');
if ($dialog->askConfirmation($output, '<question>Would you add form? (y/N)</question>')) {
$this->commands[] = array('avoo:generate:form', '--entity' => $resource, '--no-summary' => true);
if ($dialog->askConfirmation($output, '<question>Would you add controller? (y/N)</question>')) {
$this->commands[] = array('avoo:generate:controller', '--controller' => $resource, '--no-summary' => true);
if ($dialog->askConfirmation($output, '<question>Would you add CRUD? (y/N)</question>')) {
$backend = $dialog->askConfirmation($output, '<question>With backend? (y/N)</question>');
$crud = array();
if (!$backend) {
$crud['--no-backend'] = true;
} else {
while (true) {
$question = new Question($questionHelper->getQuestion('Backend bundle', null));
$question->setValidator(array('Sensio\\Bundle\\GeneratorBundle\\Command\\Validators', 'validateBundleName'));
$question->setAutocompleterValues($bundleList);
$backendBundle = $questionHelper->ask($input, $output, $question);
try {
$this->getContainer()->get('kernel')->getBundle($backendBundle);
break;
} catch (\Exception $e) {
$output->writeln(sprintf('<bg=red>Bundle "%s" does not exist.</>', $backendBundle));
$input->setOption('no-summary', null);
continue;
}
}
$crud['--backend'] = $backendBundle;
}
$this->commands[] = array_merge(array('avoo:generate:crud', '--entity' => $resource, '--no-summary' => true), $crud);
}
}
$this->commands[] = array('cache:clear', '--no-warmup' => true);
}
}
