Execute the console command.

@param ConfigurationProvider  $provider
@param MigrationFileGenerator $generator
356050
public function handle(ConfigurationProvider $provider, MigrationFileGenerator $generator)
    {
        $configuration = $provider->getForConnection($this->option('connection'));

        $filename = $generator->generate(
            $configuration,
            $this->option('create'),
            $this->option('table')
        );

        $this->line(sprintf('<info>Created Migration:</info> %s', $filename));
    }
5296
protected function execute(Input\InputInterface $input, Output\OutputInterface $output)
    {
        $this->generatorService->process($input->getOption('force'));
        $output->writeln('Completed');
    }
157983
public function fire()
    {
        if (!$this->confirmToProceed()) {
            return;
        }

        $migrator = $this->container['migrator'];

        $migrator->setConnection($this->option('database'));

        // First, we'll make sure that the migration table actually exists before we
        // start trying to rollback and re-run all of the migrations. If it's not
        // present we'll just bail out with an info message for the developers.
        if (!$migrator->repositoryExists()) {
            return $this->comment('Migration table not found.');
        }

        $migrator->reset(
            $this->getMigrationPaths(),
            $this->option('pretend')
        );

        // Once the migrator has run we will grab the note output and send it out to
        // the console screen, since the migrator itself functions without having
        // any instances of the OutputInterface contract passed into the class.
        foreach ($migrator->getNotes() as $note) {
            $this->output->writeln($note);
        }
    }
702613
protected function execute(InputInterface $input, OutputInterface $output) {
		if (!file_exists(\Skeleton\Database\Migration\Config::$migration_directory)) {
			$output->writeln('<error>Config::$migration_directory is not set to a valid directory</error>');
			return 1;
		}

		$migration = \Skeleton\Database\Migration::get_by_version($input->getArgument('name'));

		try {
			$migration->up();
			$output->writeln(get_class($migration) . "\t" . ' <info>ok</info>');
		} catch (\Exception $e) {
			$output->writeln(get_class($migration) . "\t" . ' <error>' . $e->getMessage() . '</error>');
			$output->writeln('<comment>' . $e->getTraceAsString() . '</comment>');
			return 1;
		}

		return 0;
	}
1361140
public function handle(
        ResourceInterface $resource,
        RequestConfiguration $configuration,
        ObjectManager $manager
    ): void {
        try {
            $this->decoratedHandler->handle($resource, $configuration, $manager);
        } catch (OptimisticLockException $exception) {
            throw new RaceConditionException($exception);
        }
    }
1313565
public function purgeGenerator( ApiGenerator $generator ) {
		$this->api->postRequest(
			new SimpleRequest( 'purge', $generator->getParams() )
		);

		return true;
	}
1264748
public function handle(ConfigurationProvider $provider, Migrator $migrator)
    {
        if (!$this->confirmToProceed()) {
            return;
        }

        $configuration = $provider->getForConnection(
            $this->option('connection')
        );

        $version   = $this->argument('version');
        $direction = $this->option('down') ? 'down' : 'up';

        $version = $configuration->getVersion($version);

        if ($path = $this->option('write-sql')) {
            $migrator->executeToFile($version, $direction, $path);
        } else {
            $migrator->execute($version, $direction, $this->option('dry-run'), $this->option('query-time'));
        }

        foreach ($migrator->getNotes() as $note) {
            $this->line($note);
        }
    }
1157125
public function handle(Migrator $migrator)
    {
        if (!$this->confirmToProceed()) {
            return;
        }

        $migrator->makeLogTable();

        $installed_migrations = $migrator->installedMigrationsByDesc();

        foreach ($installed_migrations as $group => $migrations) {
            foreach ($migrations as $data) {
                $this->infoDowngrade($group, $data->version, $data->class);

                $migrator->doDowngrade($group, $data->version);
            }
        }
    }
1322065
public function handle(Migrator $migrator)
    {
        if (!$this->confirmToProceed()) {
            return;
        }

        $group = $this->argument('group');

        // check valid group
        if (!in_array($group, $migrator->migrationGroups())) {
            throw new UnexpectedValueException("Migation group '$group' is not defined.");
        }

        $version = $this->option('all') ? Migrator::VERSION_NULL : $migrator->migrationLatestVersion($group);

        $migrator->makeLogTable();

        $this->doRollback($migrator, $group, $version);
    }
188803
public function handle()
    {
        if (parent::handle() === false) {
            return;
        }

        $providerFileName = $this->getPath($this->qualifyClass($this->getNameInput()));
        $this->files->put(//Replace the
            $providerFileName,
            str_replace(
                'DummyProviderFolder',
                str_replace('/', '\\', $this->convention->providersFolder()),
                $this->files->get($providerFileName)
            )
        );

        $name         = $this->getNameInput();
        $manifestPath = str_replace(
                sprintf('%s/ModuleServiceProvider.php', $this->convention->providersFolder()),
                $this->convention->manifestFile(),
                $this->getPath($this->getFQCNComp($name)
            )
        );

        if (!$this->files->exists($manifestPath)) {
            $this->makeDirectory($manifestPath);

            $this->files->put($manifestPath, $this->buildManifest($name));
        }
    }
999597
protected function bootProvider(ServiceProvider $provider)
    {
        parent::bootProvider($provider);

        if (method_exists($provider, 'booted')) {
            Event::listen('antares.extension: booted', function() use($provider) {
                Event::fire(new LoadServiceProviders());
                $this->call([$provider, 'booted']);
            });
        }
    }
401728
protected function runConfig(array $config, Configuration $parent = null)
  {
    try
    {
      $config = $this->validateConfiguration($config);
      foreach ($config as $key => $settings)
      {
        $this->configuration[$key] = new Configuration($key);
        $this->configuration[$key]->setParent($parent);
        $this->setBaseConfiguration($settings, $key);
        $this->setBaseOptions($settings, $key);
        $this->{'set' . ucfirst($this->configuration[$key]->getType()) . 'Options'}($settings, $key);
        $this->createChildren($settings, $key);
        $this->setEventConfiguration($settings, $key);

        $this->dispatcher->dispatch(
          TransformerEvents::AFTER_CONFIGURATION,
          new ConfigurationEvent($this->configuration[$key])
        );
      }

      return $this->configuration;
    }
    catch (\Exception $e)
    {
      $this->dispatcher->dispatch(TransformerEvents::ON_EXCEPTION, new ExceptionEvent($e));
      throw new TransformerException($e->getMessage() . ' --- ' . $e->getFile() . ': ' . $e->getLine());
    }
  }
857220
public function fire()
    {
        $this->setCommandDeclaredType('Service Provider');
        $this->setCommandDeclaredNamespace('Providers\Bindings');
        $this->setCommandDeclaredClassSuffix('ServiceProvider');
        $this->setCommandDeclaredStubPath(__DIR__ . '/../Stubs/BindingsServiceProvider.stub');

        if (parent::fire() === false) {
            return;
        }

        $this->info($this->getCommandDeclaredType() . ' says the config generated code: "' . $this->commandResponseInfo() . '"');
    }
673443
public function handle()
    {
        $providers = $this->laravel->getProviders(EventServiceProvider::class);

        foreach ($providers as $provider) {
            foreach ($provider->listens() as $event => $listeners) {
                $this->makeEventAndListeners($event, $listeners);
            }
        }

        $this->info('Events and listeners generated successfully!');
    }
338802
public function Execute( $provider, $dataPool )
	{
		return call_user_func(
			$this->_binaryOper,
			$provider,
			$this->getAbstractNode(0)->Execute( $provider, $dataPool ),
			$this->getAbstractNode(1)->Execute( $provider, $dataPool )
		);
	}
213437
public function handle()
    {
        $this->call('key:generate');
        $this->call('storage:link');

        $this->call('vendor:publish', [
            '--provider' => BlogServiceProvider::class
        ]);
        /*$this->call('vendor:publish', [
            '--provider' => PermissionServiceProvider::class,
            '--tag' => 'migrations'
        ]);*/
        $this->call('migrate');

        $this->info('Attempting to set User model as parent to App\User');
        if (file_exists(app_path('User.php'))) {
            $str = file_get_contents(app_path('User.php'));

            if ($str !== false) {
                $str = str_replace('extends Authenticatable', "extends \Tanwencn\Blog\Database\Eloquent\User", $str);

                file_put_contents(app_path('User.php'), $str);
            }
        } else {
            $this->warn('Unable to locate "app/User.php".  Did you move this file?');
            $this->warn('You will need to update this manually.  Change "extends Authenticatable" to "extends \Tanwencn\Blog\Database\Eloquent\User" in your User model');
        }

        $this->call('blog:registerPermissions');
    }
236539
public function handle()
    {
        if (! $this->confirmToProceed()) {
            return;
        }

        $this->migrator->setConnection($this->option('database'));

        // Next, we will check to see if a path option has been defined. If it has
        // we will use the path relative to the root of this installation folder
        // so that migrations may be run for any path within the applications.
        $this->migrator->run($this->getMigrationPaths(), [
            'pretend' => $this->option('pretend'),
            'step' => $this->option('step'),
        ]);
        // Once the migrator has run we will grab the note output and send it out to
        // the console screen, since the migrator itself functions without having
        // any instances of the OutputInterface contract passed into the class.
        foreach ($this->migrator->getNotes() as $note) {
            $this->output->writeln($note);
        }
        // Finally, if the "seed" option has been given, we will re-run the database
        // seed task to re-populate the database, which is convenient when adding
        // a migration and a seed at the same time, as it is only this command.
        if ($this->option('seed')) {
            $this->call('db:seed', ['--force' => true]);
        }
    }