Execute the console command.

@return mixed
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'
                    ]);
                }
            }
        }
    }
1094188
public function handle()
	{
		$this->mcustom($this->__directives);
		$this->mextend($this->__directory, $this->__extension);
		$this->mif();
		$this->mforeach();
		$this->mfor();
		$this->mswitch();
		$this->mwhile();
		$this->mecho();
		$this->msection();
		$this->mcode();
		$this->mcomment();
		return $this->__cached;
	}
576974
public function handle()
    {
        // Retrieve attributes
        $attributes = config('commands.user_attributes');

        // Retrieve sensitive fields
        $sensitive_attributes = config('commands.user_attributes_sensitive');

        // Ask questions and prepare data
        foreach ($attributes as $attribute => $question) {
            if (is_null($attribute) || $attribute === 0) {
                $attribute = $question;
            }

            // Check if sensitive field
            if (in_array($attribute, $sensitive_attributes)) {
                $attributes[$attribute] = Hash::make($this->secret($question));
                continue;
            }

            $attributes[$attribute] = $this->ask($question);
        }

        // Create new user
        try {
            $user = App::make(config('commands.user'));
            $user::create($attributes);
            $this->info('User created');
        } catch (\Exception $exception) {
            $this->error($exception->getMessage());
        }
    }
1008835
public function handle()
    {
        if (is_null($this->argument('name'))) {
            $this->installFromFile();

            return;
        }

        $this->install(
            $this->argument('name'),
            $this->argument('version'),
            $this->option('type'),
            $this->option('tree')
        );
    }
681188
public function handle()
	{
		if ($this->files->isDirectory($this->getPath(null))){
			return $this->error('Theme "'.$this->getTheme().'" is already exists.');
		}

		$this->makeDirs([
						'assets/css',
						'assets/js',
						'assets/img',
						'layouts',
						'partials/sections',
						'views',
						'widgets',
						]);

		$this->makeFiles([
						'layout.blade.php'	=> 'layouts/',
						'header.blade.php'	=> 'partials/',
						'footer.blade.php'	=> 'partials/',
						'main.blade.php'	=> 'partials/sections/',
						'index.blade.php'	=> 'views/',
						'style.css'			=> 'assets/css/',
						'script.js'			=> 'assets/js/',
						'theme.json'		=> '',
						'gulpfile.js'		=> '',
						'config.php'		=> ''
						]);

		$this->info('Theme "'.$this->getTheme().'" has been created.');
	}
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();
    }
110632
public function handle()
    {
    	if ($this->confirm('Do you want to install it?', false)) {
            Artisan::call('vendor:publish',['--tag' => 'admin_migrations']);
	    	Artisan::call('vendor:publish',['--tag' => 'admin_seeds']);
	    	Artisan::call('vendor:publish',['--tag' => 'admin_public']);
	    	Artisan::call('vendor:publish',['--tag' => 'admin_views']);
	    	exec('composer dump-autoload');
	    	Artisan::call('migrate');
	    	Artisan::call('db:seed',['--class' => 'UsersTableSeeder']);

	    	$this->displayOutput();
        }
    	

    }
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).");
    }
1274894
public function handle()
    {
        $this->abortCommandExecution();
        $file = $this->argument('file');
        $this->runScp(base_path($file), $this->domain, null, true);
    }
1328179
public function handle()
    {
        $group = $this->argument('group');
        $json = $this->option('json');

        if (is_null($group) && !$json) {
            $this->warn('You must either specify a group argument or export as --json');

            return;
        }

        if (!is_null($group) && $json) {
            $this->warn('You cannot use both group argument and --json option at the same time');

            return;
        }

        $this->manager->exportTranslations($group, $json);

        if (!is_null($group)) {
            $this->info('Done writing language files for '.(($group == '*') ? 'ALL groups' : $group.' group'));
        } elseif ($json) {
            $this->info('Done writing JSON language files for translation strings');
        }
    }
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');
    }
737945
public function handle()
    {

        // Ask what command
        $command = $this->choice('What command are you running?', $this->availableCommands->toArray());

        if (!$this->availableCommands->has($command)) {
            $this->info('The specified command does not exist.');
            return;
        }

        $method = 'make' . ucfirst($command);
        call_user_func([$this, $method]);

        $this->call('make:'. $command, $this->options);
    }
494568
public function handle()
	{
		if( ( $code = $this->argument( 'email' ) ) === null ) {
			$code = $this->ask( 'E-Mail' );
		}

		if( ( $password = $this->option( 'password' ) ) === null ) {
			$password = $this->secret( 'Password' );
		}

		$context = $this->getLaravel()->make( 'Aimeos\Shop\Base\Context' )->get( false, 'command' );
		$context->setEditor( 'aimeos:account' );

		$localeManager = \Aimeos\MShop::create( $context, 'locale' );
		$localeItem = $localeManager->bootstrap( $this->argument( 'site' ), '', '', false );
		$context->setLocale( $localeItem );

		$this->addGroups( $context, $this->createCustomerItem( $context, $code, $password ) );
	}
1215208
public function handle()
    {
        $translation = $this->dbTransaction(function () {
            $translation = new FileTranslation();
            $translation->fill([
                'title'         => $this->title,
                'language_code' => $this->language->code,
                'description'   => $this->attributes['description']
            ]);
            $translation->author()->associate($this->author);

            $this->file->removeExistingTranslation($translation->language_code);
            $this->file->translations()->save($translation);

            event('file.translation.created', [$translation]);
            return $translation;
        });
        return $translation;
    }
966864
public function handle()
    {
        $target = $this->argument('target');
        $options = [
            'compress' => $this->option('compress'),
            'json' => $this->option('json'),
            'no-lib' => $this->option('no-lib'),
            'source' => $this->option('source'),
        ];

        if ($this->generator->generate($target, $options)) {
            $this->info("Created: {$target}");

            return;
        }

        $this->error("Could not create: {$target}");
    }
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");
    }
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");
        }
    }