Execute the command.

@return void
198027
public function handle() {
        // Create a new command instance
        $newUpdateCommand = new UpdateBaseCommand;


        // get the field list array
        $field_list = $this->getFieldList();

        // add the field_list itself to new command instance
        $newUpdateCommand->field_list = $field_list;

        // add crud_action to the new command instance
        $newUpdateCommand->crud_action = Input::get('crud_action');

        // add fields with their associated data to the new command instance
        foreach( $field_list as $field )
        {
            if ( ($field['name'] == "featured_image_upload") && (Input::file($field['name'])) ) {
                $newUpdateCommand->{$field['name']} = Input::file($field['name'])->getClientOriginalName();
            } else {
                $newUpdateCommand->{$field['name']} = Input::get($field['name']);
            }
        }

        // Get the namespace and class name of the Form Processor class
        $namespace_formprocessor        = $this->getNamespaceFormprocessor();
        $classname_formprocessor_update = $this->getClassnameFormprocessorUpdate();

        // Inject a new instance of the container in order to inject the relevant model.
        $this->app   = new Container;

        // bind the Form Processor class to the IoC (that is, inject the Form Processor class into the IoC)
        $this->$classname_formprocessor_update = $this->app->make( $namespace_formprocessor."\\".$classname_formprocessor_update );


        // Now onto the Form Processor, aka "The Command Handler"
        return $this->$classname_formprocessor_update->quarterback($newUpdateCommand);
    }
224900
public function handle()
    {
        $requestLogger = app(ResponseLogger::class);
        $requestLogger->log($this->request, $this->response);
    }
718141
public function fire()
    {
        $path = $this->argument('path');
        $properties = $this->option('properties');
        $base = $this->option('base');

        // Parse the command input.
        $commandInput = $this->parser->parse($path, $properties);
        $handlerInput = $this->parser->parse($path.'Handler', $properties);

        // Actually create the files with the correct boilerplate.
        $this->generator->make(
            $commandInput,
            __DIR__.'/stubs/command.stub',
            "{$base}/{$path}.php"
        );

        $this->generator->make(
            $handlerInput,
            __DIR__.'/stubs/handler.stub',
            "{$base}/{$path}Handler.php"
        );

        $this->info('All done! Your two classes have now been generated.');
    }
360404
public function handle()
    {
        $id = $this->argument('id');
        $rule = $this->argument('rule');

        if( $id && $rule ) {
            $this->generateThumbByRule($id, $rule);
        } else {
            if( $id ) {
                $this->generateGlobalThumb($id);
            } else {

                if( $this->confirm('Are you sure you want to generate thumbs for all resources?') ) {
                    $list = HCResources::all()->pluck('id');

                    foreach ( $list as $id )
                        $this->generateGlobalThumb($id);
                }
            }
        }
    }
630812
public function handle()
    {
        try {
            $role = App::make(config('commands.role'));

            $role::create([
                'name' => $this->ask('Name?')
            ]);
            $this->info('Role created');
        } catch (\Exception $exception) {
            $this->error($exception->getMessage());
        }
    }
279248
public function handle()
    {
        User::create([
            'name' => $this->ask('Name?'),
            'email' => $this->ask('Email address?'),
            'password' => bcrypt($this->secret('Password?'))
        ]);
        
        $this->info('User saved');
    }
987183
public function handle()
    {
        $connection = $this->getConnection();
        $schema = $this->getSchema($connection);
        $table = $this->getTable();

        // Check whether we just need to generate one table
        if ($table) {
            $this->models->on($connection)->create($schema, $table);
            $this->info("Check out your models for $table");
        }

        // Otherwise map the whole database
        else {
            $this->models->on($connection)->map($schema);
            $this->info("Check out your models for $schema");
        }
    }
236846
public function handle()
    {
        $this->basePath = $this->getMigrationPath();
        $migrations = $this->migrator->getMigrationFiles($this->basePath);
        $count = count($migrations);

        if ($count == 0) {
            $this->comment('No migrations to move');

            return;
        }

        foreach ($migrations as $migration_name => $migration_path) {
            $datePath = $this->migrator->getDateFolderStructure($migration_name);
            // Move the migration into base migration folder
            $this->files->move($this->basePath.'/'.$datePath.$migration_name.'.php', $this->basePath.'/'.$migration_name.'.php');
        }

        $this->info('Migrations disorganised successfully ('.$count.' migrations moved)');
        $this->cleanup();
    }
1188441
public function handle()
    {
        $id = $this->argument('id');

        if ($id === null) {
            $this->table(
                ['ID', 'Email'],
                User::all(['id', 'email'])->toArray()
            );
            $id = $this->ask('ID?');
        }

        User::where('id', $id)->update([
            'password' => bcrypt($this->secret('New password?'))
        ]);

        $this->info('User was updated');
    }
1201275
public function handle()
    {
        $this->abortCommandExecution();

        $this->info("Checking if token is valid...");

        $this->url = $this->checkTokenURL();

        if ($this->checkToken($this->token)) {
            $this->info('Token is valid!');
        } else {
            $this->error('Token not valid!');
        }
    }
150941
public function handle()
    {
        $name = $this->parseName($this->getNameInput());

        $path = $this->getPath($name);

        if ($this->alreadyExists($this->getNameInput())) {
            $this->error($this->type . " \"{$name}\" already exists!");

            return;
        }

        if (! $this->checkOptions()) {
            return;
        }

        $this->makeDirectory($path);

        $this->files->put($path, $this->buildClass($name));

        $this->info($this->type . " \"{$name}\" created successfully.");

        // If also needs a new model file
        if ($model = $this->option('create')) {
            $this->call('make:model', ['name' => $model]);
        }
    }
484267
public function handle()
    {
        $boolData = $this->option('data');
        $this->call('migrate', [
            '--force' => true
        ]);
        $this->call('db:seed');
        $seedListsClass = [
            'CommonConfig', 'CommonRole', 'ManageMenu', 'CommonRoleUri'
        ];
        if($seedListsClass) {
            foreach ($seedListsClass as $class) {
                $this->call('db:seed', [
                    '--class' => $class . 'TableSeeder'
                ]);
            }
        }
        //Set up test data in the database
        if (!empty($boolData))
        {
            $seedListClass = [
                //'Article'
            ];
            if($seedListClass) {
                foreach ($seedListClass as $class) {
                    $this->call('db:seed', [
                        '--class' => $class . 'TableSeeder'
                    ]);
                }
            }
        }
    }
788981
public function handle()
    {
        $sql = $this->option('command');
        $connection = $this->databaseManager->connection($this->option('connection'));
        $rows = $this->castArray($connection->select($sql, [], true));
        $headers = array_keys(Arr::get($rows, 0, []));
        $this->table($headers, $rows);
    }
493538
public function handle()
    {
        app('fgenerator')->run(
            $this->argument('group'),
            $this->argument('module'),
            $this->argument('model'),
            $this->argument('type'),
            $this->option('mode'),
            $this->option('output')
        );
    }
635419
public function handle()
    {
        if ($this->shouldBeFailed()) {
            return;
        }

        $database = $this->config['database'] ?? null;
        $migrator = $this->resolveMigrator();

        if (! $this->shouldBeDelayed()) {
            $migrator->runReset($this->model, $database);

            $this->delete();
        }
    }
627085
public function handle()
    {
        $this->line(static::$logo);
        $this->line(Admin::getLongVersion());

        $this->comment('');
        $this->comment('Available commands:');

        $this->listAdminCommands();
    }
177515
public function handle()
    {

        if (! $this->preflighted()) return;

        $killmails = $this->retrieve([
            'character_id' => $this->getCharacterId(),
        ]);

        if ($killmails->isCachedLoad()) return;

        collect($killmails)->each(function ($killmail) {

            CharacterKillmail::firstOrCreate([
                'character_id'  => $this->getCharacterId(),
                'killmail_id'   => $killmail->killmail_id,
            ], [
                'killmail_hash' => $killmail->killmail_hash,
            ]);
        });
    }