Execute the console command.

@return mixed
776176
public function fire() {
        $rows          = [];
        $real_progress = 0;
        $idx           = 0;
        $last          = null;
        $items         = [];
        foreach (\Route::getRoutes() as $r => $route) {
//            if (!\Larakit\Route\Route::isEnable($route->getName())) {
//                continue;
//            }
            /**
             * @var Route $route
             */
            $item    = [];
            $action  = $route->getActionName();
            $_action = explode('@', $action);
            $method  = Arr::get($_action, 1);
            $class   = Arr::get($_action, 0);
            //            if (($action != 'Closure') && (strpos($action, 'Larakit') === false))
            //                continue;
            if ('Closure' == $action) {
                $progress = 100;
            }
            else {
                if (is_callable(explode('@', $action))) {
                    $readiness = (int)\Larakit\Route\Route::_($route->getName(), 'readiness');
                    if (!$readiness) {
                        $readiness = 1;
                    }
                    $progress = $readiness;
                }
                else {
                    $progress = 0;
                }
            }
            $idx++;
            $real_progress += $progress;
            switch (true) {
                case $progress < 50:
                    $style = 'error';
                    break;
                case $progress < 100:
                    $style = 'question';
                    break;
                default:
                    $style = 'info';
                    break;
            }
            $item[] = $this->wrap($route->domain(), $style);
            $item[] = $this->wrap(implode('|', $route->getMethods()), $style);
            $item[] = $this->wrap($route->getUri(), $style);
            $item[] = $this->wrap($route->getName(), $style);
            if ('Closure' == $action) {
                $item[] = $this->wrap('\Closure', $style);
                $item[] = '';
            }
            else {
                $item[] = $this->wrap($class, $style);
                $item[] = $this->wrap($method, $style);
            }
            $item[] = $this->wrap($idx, $style, 3);
            $item[] = $this->wrap($progress . '%', $style, 9);
            $v      = mb_strpos($route->getName(), '::') ? explode('::', $route->getName()) : [];
            $vendor = Arr::get($v, 0, 'app');
            //            $item[]      = $vendor;

            if (($last != $vendor)) {
                if (!(is_null($last))) {
                    $rows[] = new TableSeparator();
                }
                $last = $vendor;
            }
            $items[$route->getName()] = $item;
        }

        $last = null;
        $rows = [];
        $idx = 0;
        foreach ($items as $route => $row) {
            $idx++;
            $v      = mb_strpos($route, '::') ? explode('::', $route) : [];
            $vendor = Arr::get($v, 0, 'app');
            if (($last != $vendor)) {
                if (!(is_null($last))) {
                    $rows[] = new TableSeparator();
                }
                $last = $vendor;
            }
            $rows[] = [$idx] + $row;
        }
        //        foreach($)
        $this->table(
            [
                'Domain',
                'Method',
                'URI',
                'RouteName',
                'Controller',
                'Action',
                '#',
                'Readiness',
            ],
            $rows
        );
        $progress_all  = count($rows) * 100;
        $real_progress = $real_progress / $progress_all * 100;
        $this->info('Общая готовность: ' . number_format($real_progress, 2) . '%');
        $this->info(
            '[' . str_pad(
                str_repeat('#', (int)$real_progress) . ($real_progress != 100 ? '>' : ''),
                100,
                '-',
                STR_PAD_RIGHT
            ) . ']'
        );
    }
268098
public function handle()
    {
        if (file_exists($publicPath = public_path('assets'))) {
            return $this->error('The "webroot/assets" directory already exists.');
        }

        $assetsPath = $this->container['config']->get('routing.assets.path', base_path('assets'));

        $this->container->make('files')->link(
            $assetsPath, $publicPath
        );

        $this->info('The [webroot/assets] directory has been linked.');
    }
1045253
public function handle()
    {

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

        while (true) {

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

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

            collect($bookmarks)->chunk(1000)->each(function ($chunk) {

                $records = $chunk->map(function ($bookmark, $key) {

                    $normalized_location = $this->find_nearest_celestial(
                        $bookmark->location_id,
                        $bookmark->position->x ?? 0.0,
                        $bookmark->position->y ?? 0.0,
                        $bookmark->position->z ?? 0.0);

                    return [
                        'character_id' => $this->getCharacterId(),
                        'bookmark_id'  => $bookmark->bookmark_id,
                        'creator_id'   => $bookmark->creator_id,
                        'folder_id'    => $bookmark->folder_id ?? null,
                        'created'      => carbon($bookmark->created),
                        'label'        => $bookmark->label,
                        'notes'        => $bookmark->notes,
                        'location_id'  => $bookmark->location_id,
                        'item_id'      => $bookmark->item->item_id ?? null,
                        'type_id'      => $bookmark->item->type_id ?? null,
                        'x'            => $bookmark->coordinates->x ?? null,
                        'y'            => $bookmark->coordinates->y ?? null,
                        'z'            => $bookmark->coordinates->z ?? null,
                        'map_id'       => $normalized_location['map_id'],
                        'map_name'     => $normalized_location['map_name'],
                        'created_at'   => carbon(),
                        'updated_at'   => carbon(),
                    ];
                });

                CharacterBookmark::upsert($records->toArray(), [
                    'character_id',
                    'bookmark_id',
                    'creator_id',
                    'folder_id',
                    'created',
                    'label',
                    'notes',
                    'location_id',
                    'item_id',
                    'type_id',
                    'x',
                    'y',
                    'z',
                    'map_id',
                    'map_name',
                    'updated_at',
                ]);
            });

            $this->known_bookmarks->push(collect($bookmarks)
                ->pluck('bookmark_id')->flatten()->all());

            if (! $this->nextPage($bookmarks->pages))
                break;
        }

        CharacterBookmark::where('character_id', $this->getCharacterId())
            ->whereNotIn('bookmark_id', $this->known_bookmarks->flatten()->all())
            ->delete();
    }
1230892
public function handle()
    {
        $this->laravel['events']->dispatch(
            'cache:clearing', [$this->argument('store'), $this->tags()]
        );

        $successful = $this->cache()->flush();

        $this->flushFacades();

        if (! $successful) {
            return $this->error('Failed to clear cache. Make sure you have the appropriate permissions.');
        }

        $this->laravel['events']->dispatch(
            'cache:cleared', [$this->argument('store'), $this->tags()]
        );

        $this->info('Application cache cleared!');
    }
1354288
public function handle()
    {
        $group = $this->input->getArgument('group');

        if (is_null($group)) {
            return $this->publish();
        }

        $groups = explode(',', $group);

        foreach($groups as $group) {
            $this->publish($group);
        }
    }
1286894
public function handle()
    {
        if (! $this->confirmToProceed()) {
            return;
        }

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

        if (! empty($slug)) {
            if (! $this->packages->exists($slug)) {
                return $this->error('Package does not exist.');
            }

            if ($this->packages->isEnabled($slug)) {
                $this->seed($slug);
            } else if ($this->option('force')) {
                $this->seed($slug);
            }

            return;
        }

        if ($this->option('force')) {
            $packages = $this->packages->all();
        } else {
            $packages = $this->packages->enabled();
        }

        foreach ($packages as $package) {
            $slug = $package['slug'];

            $this->seed($slug);
        }
    }
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');
    }
12692
public function handle()
    {
        $filesystem = new Filesystem;
        $filesystem->copyDirectory(
            __DIR__ . '/stubs/install',
            base_path()
        );
        $this->call('storage:link');

        if ($this->option('migrate')) {
            $this->call('migrate', ['--path' => str_replace(base_path(), '', __DIR__) . '/../../migrations']);
            $this->call('db:seed', ['--class' => \Kaiwh\Admin\Seeds\InitAdminSeeder::class]);
        }
    }
1118801
public function handle()
    {
        if (!$this->confirmToProceed()) {
            return;
        }

        $database = $this->connection->tenantName();

        $this->input->setOption('force', $force = true);
        $website_id = $this->option('website_id');
        $realpath = $this->option('realpath');
        $path = $this->input->getOption('path');
        $step = $this->input->getOption('step') ?? 0;

        if ($step > 0) {
            $this->call('tenancy:migrate:rollback', [
                '--database' => $database,
                '--realpath' => $realpath,
                '--website_id' => $website_id,
                '--path' => $path,
                '--step' => $step,
                '--force' => $force,
            ]);
        } else {
            $this->call('tenancy:migrate:reset', [
                '--database' => $database,
                '--realpath' => $realpath,
                '--website_id' => $website_id,
                '--path' => $path,
                '--force' => $force,
            ]);
        }

        $this->call('tenancy:migrate', [
            '--database' => $database,
            '--realpath' => $realpath,
            '--website_id' => $website_id,
            '--path' => $path,
            '--force' => $force,
        ]);

        if ($this->needsSeeding()) {
            $this->call('tenancy:db:seed', [
                '--database' => $database,
                '--class' => $this->option('seeder') ?? config('tenancy.db.tenant-seed-class') ?? 'DatabaseSeeder',
                '--force' => $force,
            ]);
        }
    }
766979
public function handle()
    {
        $name = $this->argument('name');
        $createMigration = $this->option('m');
        $createResourceController = $this->option('c');

        if (empty($name)) {
            return $this->error("You need to specify an object to create");
        }

        $newObject = ucfirst($name).'.php';
        $newContract = ucfirst($name).'Repository.php';
        $newConcrete = 'Eloquent'.ucfirst($name).'Repository.php';

        $this->createObjectFiles($name, $newObject, $newContract, $newConcrete);

        $this->makeBindings($newContract, $newConcrete);

        $this->makeMigration($createMigration);

        $this->makeResourceController($createResourceController);

        return $this->info('Your structure has been created');
    }
218521
public function handle()
    {

        $connectionName = ! empty($this->argument('connection')) && $this->argument('connection') != 'null'
            ? $this->argument('connection') : config('database.default');
        $connection = config('database.connections.' . $connectionName);

        if (empty($connection)) {
            $this->info('No connection details');
            return false;
        }

        if ($connection['driver'] != 'mysql') {
            return $this->notMysql();
        }

        $cmd = $this->makeCommand($connection, $connectionName);

        try {
            exec($cmd);
        } catch (\Exception $e) {
            $this->info('There was an error');
            $this->info('Message: ' . $e->getMessage());
            $this->info('Trace: ' . $e->getTraceAsString());
            return false;
        }

    }
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();
    }
1157806
public function handle()
    {
        $model = $this->argument('model');

        if ($this->manager->isModelExists($model)) {
            return $this->showDetail($this->manager->getModel($model));
        }

        $this->error("Model {$model} is not found");
    }
146494
public function handle()
    {
        $disk = $this->argument('disk');
        $directory = $this->option('directory') ?: '';
        $recursive = ! $this->option('non-recursive');
        $counter = 0;

        $records = Media::inDirectory($disk, $directory, $recursive)->get();

        foreach ($records as $media) {
            if (! $media->fileExists()) {
                $media->delete();
                ++$counter;
                $this->info("Pruned record for file {$media->getDiskPath()}", 'v');
            }
        }

        $this->info("Pruned {$counter} record(s).");
    }
378860
public function handle()
    {
        $rule = $this->option('rule');
        /**
         * @var Cdn $cdn
         */
        $cdn = app()->makeWith(Cdn::class, ['rule' => $rule]);
        $cdn->clearCdn($this->output);
    }
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);
    }
1185488
public function handle()
    {
        $this->events->fire('command.updating', $this);
        $this->events->fire('command.cacheconfig', $this);
        $this->events->fire('command.cacheroutes', $this);
        $this->events->fire('command.publishvendors', $this);
        $this->events->fire('command.runmigrations', $this);
        $this->events->fire('command.updatecache', $this);
        $this->events->fire('command.extrastuff', $this);
        $this->events->fire('command.updated', $this);
    }