Execute the console command.

@param  \Illuminate\Contracts\Cache\Repository  $cache
@param  \Nuwave\Lighthouse\GraphQL  $graphQL
@return void
504215
public function handle(Repository $cache, GraphQL $graphQL): void
    {
        // Clear the cache so this always validates the current schema
        $cache->forget(config('lighthouse.cache.key'));

        $graphQL->prepSchema()->assertValid();

        $this->info('The defined schema is valid.');
    }
827565
public function fire()
	{
		$compiledPath = $this->laravel->getCachedCompilePath();
		$servicesPath = $this->laravel->getCachedServicesPath();

		if (file_exists($compiledPath))
		{
			@unlink($compiledPath);
		}

		if (file_exists($servicesPath))
		{
			@unlink($servicesPath);
		}
	}
495135
public function handle()
    {
        $this->cache->store($this->argument('store'))->forget(
            $this->argument('key')
        );

        $this->info('The ['.$this->argument('key').'] key has been removed from the cache.');
    }
1141135
public function fire()
    {
        $queue = $this->input->getOption('queue');
        $config_file = require(__DIR__.'../../config/queue.php');
        $conf = new Config($config_file);
        if($message = Queue::instance($conf)->get($queue)){
            Queue::instance($conf)->run($message);
            Queue::instance($conf)->ack($message);
        }
    }
1150082
public function setCache($cache)
    {
        $this->cache = $cache;
        if ($this->isBool($cache) && $cache === false) {
            $this->cache = $cache;
        } else {
            if (is_object($cache)) {
                if ($this->isInstanceOf($cache, CacheStorage::class)) {
                    $this->cache = $cache;
                } else {
                    throw new RouterException('$cache must either be a boolean or instance of ' . CacheStorage::class . '.');
                }
            } else {
                $this->cache = $this->cache($cache);
            }
        }
    }
644875
public function fire()
    {
        $this->prepare();

        if ($this->repositoryUrl == null || strlen($this->repositoryUrl) <= 0) {
            $this->error('Invalid wikiclone.repository or wikiclone.repository_type config value.');
            return;
        }

        $this->cloneRepository();

        if ($this->option('delete')) {
            $this->deleteDocumentation($this->option('delete'));
        }

        if (!$this->tags) {
            $this->info('Getting documentation from default branch...');

            $this->deleteDocumentation();
            $this->parse();
        } else {
            if ($this->option('force')) {
                $this->info('Forcibly deleted all files');
                foreach ($this->disk->files() as $file) {
                    $this->disk->delete($file);
                }
                foreach ($this->disk->directories() as $directory) {
                    $this->disk->deleteDirectory($directory);
                }
            }


            $refs = $this->repository->getReferences();

            /** @var Branch $branch */
            foreach ($refs->getBranches() as $branch) {
                $localName = $branch->getName();
                if ($branch->isRemote()) {
                    $localName = substr($localName, strlen('origin/'));
                    if ($refs->hasBranch($localName)) {
                        continue;
                    }
                }
                if (!Page::isValidTagName($localName) ||
                    !$this->isInWhitelist('branches', $localName)
                ) {
                    continue;
                }

                $this->info("Getting documentation from '{$localName}' branch...");

                $this->deleteDocumentation($localName);

                // Checkout
                if ($branch->isLocal()) {
                    $this->repository->getWorkingCopy()
                        ->checkout($branch);
                } else {
                    $this->repository->getWorkingCopy()
                        ->checkout($branch, $localName);
                }


                // Parse
                $this->parse($localName . '/');
            }

            /** @var Tag $tag */
            foreach ($refs->getTags() as $tag) {
                if (!Page::isValidTagName($tag->getName()) ||
                    Page::tagExists($tag->getName()) ||
                    !$this->isInWhitelist('tags', $tag->getName())
                ) {
                    continue;
                }

                $this->info("Getting documentation from '{$tag->getName()}' tag...");

                $this->deleteDocumentation($tag->getName());

                // Checkout
                $this->repository->getWorkingCopy()
                    ->checkout($tag);

                // Parse
                $this->parse($tag->getName() . '/');
            }
        }

        $this->deleteRepository();
    }
703837
public function fire()
    {
        $this->resolveTenantRoutes($this->argument('domain'));

        $this->files->delete($this->laravel->getCachedRoutesPath());

        $this->info('Tenant route cache cleared!');
    }
1078545
public function execute(\Amp\Artax\Request $request, \ArtaxServiceBuilder\Operation $operation) {
        $originalRequest = clone $request;
        $cachingHeaders = $this->responseCache->getCachingHeaders($request);
        $request->setAllHeaders($cachingHeaders);
        $promise = $this->client->request($request);
        $response = \Amp\wait($promise, $this->reactor);

        if ($response) {
            $operation->setResponse($response);
            $operation->setOriginalResponse($response);
        }

        if ($operation->shouldResponseBeCached($response)) {
            $this->responseCache->storeResponse($originalRequest, $response);
        }

        if ($operation->shouldUseCachedResponse($response)) {
            $cachedResponse = $this->responseCache->getResponse($originalRequest);
            if ($cachedResponse) {
                $response = $cachedResponse;
                $operation->setResponse($response);
            }
            //@TODO This code should only be reached if the cache entry was deleted
            //so throw an exception? Or just leave the 304 to error?
        }

        $exception = $operation->translateResponseToException($response);

        if ($exception) {
            throw $exception;
        }

        return $response;
    }
961328
public function handle()
    {
        $this->repository->setSource($this->determineConnection());

        $this->repository->createRepository();

        $this->info('CMS migration table created successfully.');
    }
487289
public function handle()
    {
        $this->repository->setSource($this->input->getOption('database'));

        $this->repository->createRepository();

        $this->info('Migration table created successfully.');
    }
743226
public function fire()
    {
        if (!$this->cacheEnabled) {
            $this->info('The translation cache is disabled.');
        } else {
            $this->cacheRepository->flushAll();
            $this->info('Translation cache cleared.');
        }
    }
1146400
public function fire()
    {

        $this->line('');
        $this->info( "Tables: flows, nodes, node_role, node_user, resourceflow, resourcenode, resourcelog" );
        $message = "An migration that creates 'flows', 'nodes', 'node_role', 'node_user', 'resourceflow', 'resourcenode', 'resourcelog'".
            " tables will be created in app/database/migrations directory ";

        $this->comment( $message );
        $this->line('');

        if ( $this->confirm("Proceed with the migration creation? [Yes|no]") )
        {
            $this->line('');

            $this->info( "Creating migration..." );
            if( $this->createMigration() )
            {
                $this->info( "Migration successfully created!" );
            }
            else{
                $this->error(
                    "Coudn't create migration.\n Check the write permissions".
                    " within the app/database/migrations directory."
                );
            }

            $this->line('');

        }
    }
1368389
public function handle(Connection $connection, WebsiteRepository $repository)
    {
        $this->connection = $connection;

        $repository->query()->chunk(50, function ($websites) {
            foreach ($websites as $website) {
                if ($this->tenantDatabaseExists($website)) {
                    $this->info("Database `{$website->uuid}` exists. Skipping.");
                } else {
                    $this->info("Recreating database `{$website->uuid}`.");
                    $this->emitEvent(new Events\Created($website));
                }
            }
        });
    }
438450
public function fire()
	{
		if (! $this->migrator->repositoryExists()) {
			return $this->error('No migrations found.');
		}

		$this->migrator->setConnection($this->input->getOption('database'));

		if (! is_null($path = $this->input->getOption('path'))) {
			$path = $this->laravel->basePath().'/'.$path;
		} else {
			$path = $this->getMigrationPath();
		}

		$ran = $this->migrator->getRepository()->getRan();

		$migrations = [];

		foreach ($this->getAllMigrationFiles($path) as $migration) {
			$migrations[] = in_array($migration, $ran) ? ['<info>Y</info>', $migration] : ['<fg=red>N</fg=red>', $migration];
		}

		if (count($migrations) > 0) {
			$this->table(['Ran?', 'Migration'], $migrations);
		} else {
			$this->error('No migrations found');
		}
	}
1052384
public function fire()
    {
        chdir(base_path());

        $phpCsFixerBinnaryPath = base_path('vendor/bin/php-cs-fixer');

        $commandParams = [];

        $commandParams[] = '--path-mode="'.$this->option('path-mode').'"';

        if (!is_null($this->option('allow-risky'))) {
            $commandParams[] = '--allow-risky="'.$this->option('allow-risky').'"';
        }

        if (!is_null($this->option('config'))) {
            $commandParams[] = '--config="'.base_path($this->option('config')).'"';
        } elseif (file_exists(base_path('.php_cs'))) {
            $commandParams[] = '--config="'.base_path('.php_cs').'"';
        } else {
            $commandParams[] = '--config="'.__DIR__.'/../../Config/.php_cs"';
        }

        if ($this->option('dry-run')) {
            $commandParams[] = '--dry-run';
        }

        if (!is_null($this->option('rules'))) {
            $commandParams[] = '--rules="'.$this->option('rules').'"';
        }

        if (!is_null($this->option('using-cache'))) {
            $commandParams[] = '--using-cache="'.$this->option('using-cache').'"';
        }

        if (!is_null($this->option('cache-file'))) {
            $commandParams[] = '--cache-file="'.$this->option('cache-file').'"';
        }

        if ($this->option('diff')) {
            $commandParams[] = '--diff';
        }

        if (!is_null($this->option('format'))) {
            $commandParams[] = '--format="'.$this->option('format').'"';
        }

        if ($this->option('stop-on-violation')) {
            $commandParams[] = '--stop-on-violation';
        }

        if (!is_null($this->option('show-progress'))) {
            $commandParams[] = '--show-progress="'.$this->option('show-progress').'"';
        }

        if ($this->option('quiet')) {
            $commandParams[] = '--quiet';
        }

        if ($this->option('verbose')) {
            $commandParams[] = '--verbose';
        }

        if ($this->option('ansi')) {
            $commandParams[] = '--ansi';
        }

        if ($this->option('no-ansi')) {
            $commandParams[] = '--no-ansi';
        }

        if ($this->option('no-interaction')) {
            $commandParams[] = '--no-interaction';
        }

        if (!empty($this->argument('path'))) {
            $paths = [];
            foreach ($this->argument('path') as $path) {
                $paths[] = '"'.base_path($path).'"';
            }
            $commandParams[] = implode(' ', $paths);
        }

        $paramString = (empty($commandParams)) ? '' : ' '.implode(' ', $commandParams);

        passthru($phpCsFixerBinnaryPath.' fix'.$paramString);
    }
317996
public function fire()
    {
        // Remove the files from the cache directory
        $this->removeFiles($this->buildFileList(config('assetprocessor.cache.directory')));

        // Remove the files from the external directory
        $this->removeFiles($this->buildFileList(config('assetprocessor.cache.external')));
        
    }
606574
public function handle()
    {
        parent::handle();
        if ($this->option('all')) {
            $this->call('make:repository:contract', [
                'name' => $this->argument('name')
            ]);
            $this->call('make:repository:decorator', [
                'name' => $this->argument('name')
            ]);
        }
    }