Execute the job.

@return bool
198790
public function handle()
    {
        return $this->dbTransaction(function () {
            $lastAction = $this->block->restore();

            event('block.restored', [$this->block]);

            return $lastAction;
        });
    }
508295
public function handle()
    {
        $input = $this->getCommandInput();
        $file = $this->getFilename($input->file);

        if ($this->isFileExists($file) && !$this->option('force')) {
            $this->error('The resource-file already exists! To override the existing file, use --force option to append.');

            return false;
        }

        if (empty($input->fieldNames) && empty($input->relations) && empty($input->indexes)) {
            $this->noResourcesProvided();

            return false;
        }

        if (Config::autoManageResourceMapper()) {
            $mapper = new ResourceMapper($this);
            $mapper->append($input->modelName, $input->file);
        }

        $fields = FieldTransformer::fromString($this->option('fields'), 'generic', $input->translationFor);
        $relations = $this->getRelations($input->relations);
        $indexes = $this->getIndexes($input->indexes);

        $resource = new Resource($fields, $relations, $indexes);
		

        $this->createFile($file, Helpers::prettifyJson($resource->toArray()))
            ->info('The "' . basename($file) . '" file was crafted successfully!');
    }
1370276
public function handle(){
        $name = $this->argument('name') ? $this->argument('name') : false;
        if (false === $name) {
            $confirm = 'Your all backup files will be remove, do you accept?[yes|no]';
        } else {
            $confirm = sprintf('Your %s backup file will be remove, do you accept?[yes|no]', $name);
        }
        if ($this->confirm($confirm, true)) {
            $return = BackupLoader::forget($name);
            foreach ($return as $key => $response) {
                if (true === $response) {
                    $this->info(sprintf('%s backup successfully removed', $key));
                } else {
                    $this->error(sprintf('something went wrong while your %s backup file remove', $key));
                }
            }
        }
    }
178289
public function handle()
    {
        //change connection if provide
        if ($this->option('c')) {
            $this->schema->setConnection($this->option('c'));
            $this->schema->switchWrapper();
            if ($this->schema->connection !== 'mysql') {
                $this->warn('Monitoring in currently supporting for mysql and updating.');
                return false;
            }
        }
        $timeInterval = 2;
        if (null !== $this->option('i') & is_integer($this->option('i'))) {
            $timeInterval = $this->option('i');
        }
        for ($i = 1; ; $i++) {
            $this->info("Fetching ($i):");
            $this->table($this->headers, $this->schema->databaseWrapper->showDatabaseStatus($timeInterval));
            $this->line('');
        }
    }
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;
        }

    }
869499
public function execute()
    {
        $curdir = getcwd();
        chdir($this->workingdir);

        $phpcsfixer = $this->phpci->findBinary('php-cs-fixer');

        $cmd = $phpcsfixer . ' fix . %s %s %s';
        $success = $this->phpci->executeCommand($cmd, $this->verbose, $this->diff, $this->level);

        chdir($curdir);

        return $success;
    }
1145953
public function execute()
    {
        $this->result_set = new \FreeFW\Model\ResultSet();
        switch ($this->type) {
            case self::QUERY_SELECT:
                $model            = \FreeFW\DI\DI::get($this->main_model);
                $this->result_set = $this->strategy->select($model, $this->conditions);
                return true;
                break;
            case self::QUERY_DELETE:
                $model = \FreeFW\DI\DI::get($this->main_model);
                return $this->strategy->delete($model, $this->conditions);
                break;
            default:
                var_dump('error query execute');
                die;
        }
        return false;
    }
675387
public function execute()
    {
        $this->phpci->quiet = true;
        $this->phpci->logExecOutput(false);

        foreach ($this->directories as $dir) {
            $this->lintDirectory($dir);
        }

        $this->phpci->quiet = false;
        $this->phpci->logExecOutput(true);

        $errors = 0;
        $warnings = 0;

        foreach ($this->failedPaths as $path) {
            if ($path['type'] == 'error') {
                $errors++;
            } else {
                $warnings++;
            }
        }

        $this->build->storeMeta('phptallint-warnings', $warnings);
        $this->build->storeMeta('phptallint-errors', $errors);
        $this->build->storeMeta('phptallint-data', $this->failedPaths);

        $success = true;

        if ($this->allowed_warnings != -1 && $warnings > $this->allowed_warnings) {
            $success = false;
        }

        if ($this->allowed_errors != -1 && $errors > $this->allowed_errors) {
            $success = false;
        }

        return $success;
    }
33552
public function handle()
    {
        $experiment = $this->argument('experiment', false);
        $list = $this->option('list', false);

        if ($list == true) {
            $this->prettyPrint($this->listReports());

            return true;
        }

        if (!empty($experiment)) {
            $this->prettyPrint($this->printReport($experiment));
        } else {
            $reports = $this->listReports();
            $info = [];
            foreach ($reports as $report) {
                $info[$report->experiment] = $this->printReport($report->experiment);
            }
            $this->prettyPrint($info);
        }
    }
487615
public function handle()
    {
        if (count($jobs = $this->getFailedJobs()) === 0) {
            return $this->info('No failed jobs!');
        }

        $this->displayFailedJobs($jobs);
    }
211839
public function handle()
	{
		$days = (int)$this->option( 'days' );

		if ( $days < 0 )
		{
			$this->writeError( "days option cannot be negative" );

			return self::ERROR;
		}

		$success = $this->manager->deleteBackupFiles( $this->lang_folder_path , $days , $this->option( 'dry-run' ) );

		return ( $success === true ) ? self::SUCCESS : self::ERROR;
	}
939009
public function execute()
    {
        $this->phpci->quiet = true;
        $success = true;

        $php = $this->phpci->findBinary('php');

        foreach ($this->directories as $dir) {
            if (!$this->lintDirectory($php, $dir)) {
                $success = false;
            }
        }

        $this->phpci->quiet = false;

        return $success;
    }
51869
public function handle()
    {
        foreach ($this->loaders as $loader) {
            if ($language = call_user_func($loader)) {
                if (in_array($language, $this->supportedLanguages)) {
                    return $language;
                }

                $special = strpos($language, '-') !== false;
                if ($special && $this->allowFallback &&
                    in_array(substr($language, 0, 2), $this->supportedLanguages)) {
                    return substr($language, 0, 2);
                }

                if ( ! $special && $this->allowAdvance) {
                    foreach ($this->supportedLanguages as $supportedLanguage) {
                        if ($language === substr($supportedLanguage, 0, 2)) {
                            return $supportedLanguage;
                        }
                    }
                }
            }
        }

        return false;
    }
1052906
public function handle()
    {
        if (!auth()->user()) {
            return false;
        }
        publish('search', 'scripts.resources');

        $search           = Input::get('search');
        $string           = serialize([
            'protection_string' => config('antares/search::protection_string'),
            'app_key'           => env('APP_KEY'),
            'time'              => time()]);
        $protectionString = Crypt::encrypt($string);
        $this->app->make('antares.widget')
                ->make('placeholder.global_search')
                ->add('search')
                ->value(view('antares/search::admin.partials._search', compact('search', 'protectionString')));
    }
274449
public function handle()
    {
        if (! $this->confirmToProceed()) {
            return;
        }

        $driver = $this->getDriver();
        $database = $this->option('database');
        $id = $this->option('id');
        $pretend = $this->option('pretend', false);

        $this->prepareDatabase($driver, $database, $id);

        $migrator = $this->tenant->driver($driver);

        $this->setupMigrationOutput($migrator);

        $migrator->run($database, $id, $pretend);
    }
585530
public function handle()
    {
        $debug = !config('loggin.debug');

        $log = config('loggin.log');
        //
        $script = Loggin::set($debug, $log);

        $this->show(file_put_contents(root().'config/loggin.php', $script, 0), $debug);

        return true;
    }
234506
public function execute()
    {
        if (!$this->tryAndProcessRules()) {
            return false;
        }

        $phpmdBinaryPath = $this->phpci->findBinary('phpmd');

        $this->executePhpMd($phpmdBinaryPath);

        $errorCount = $this->processReport(trim($this->phpci->getLastOutput()));
        $this->build->storeMeta('phpmd-warnings', $errorCount);

        return $this->wasLastExecSuccessful($errorCount);
    }