Fire the hooks.

@return void
760625
public function fire() {
		$context = Context::guest();

		$this->cmb->set_context( $context );
		$this->object_type = $this->cmb->mb_object_type();

		if ( $this->cmb->prop( 'hookup' ) ) {
			$this->universal_hooks();
		}

		$this->once( 'admin_footer', [ __CLASS__, 'enqueue_scripts' ], 20 );
		$this->once( 'admin_enqueue_scripts', [ __CLASS__, 'enqueue_styles' ], 20 );
	}
1146421
public function fire()
	{
		$ids = $this->argument('id');

		if (count($ids) === 1 && $ids[0] === 'all') {
			$ids = Arr::pluck($this->laravel['queue.failer']->all(), 'id');
		}

		foreach ($ids as $id) {
			$this->retryJob($id);
		}
	}
299898
public function fire()
	{
		$this->call('config:clear');

		$config = $this->setRealSessionDriver(
			$this->getFreshConfiguration()
		);

		$this->files->put(
			$this->laravel->getCachedConfigPath(), '<?php return '.var_export($config, true).';'.PHP_EOL
		);

		$this->info('Configuration cached successfully!');
	}
736081
public function fire()
    {

        $file = __DIR__ . '/migrations/create_mf_logs_table.php';
        $migrationsPath = $this->getMigrationsPath();

        $this->files->copy(
                $file,
                $migrationsPath . "/" . $this->getNewFileName($file)
            );

        $this->info('Published migration. run "php artisan migrate" to create the logs table');
    }
1123009
public function fire()
	{
		if (file_exists($path = $this->laravel['path.storage'] . '/compiled.php'))
		{
			@unlink($path);
		}

		if (file_exists($path = $this->laravel['config']['app.manifest'] . '/services.json'))
		{
			@unlink($path);
		}
	}
331242
public function handle()
	{
        $themes = [];
        $empty = true;

        $path = $this->option('path');

        if ($this->files->exists($path)) {
            $scannedThemes = $this->files->directories($path);
            foreach ($scannedThemes as $key => $theme) {
                $themes[] = array($key+1, basename($theme));
            	$empty = false;
            }
        }
        
		$headers = ['#', 'Theme name'];

		if(!$empty){
			$this->table($headers, $themes);
		} else {
			$this->info("No themes installed");
		}
	}
368904
public function handle()
    {
        $slug = $this->argument('slug');
        $value = $this->argument('value');
        if($slug && $value) {
            if($slug == 'module') {
                HookModel::del('', $value);
            } else {
                HookModel::del($value);
            }
            $this->call('hook:cache');
            $this->info('Delete Success');
        }
    }
357553
public function fire()
    {
        // get classes
        $classes = $this->getClasses($this->config['models_namespace']);

        // build metadata
        $metadata = $this->scanner->scan($classes, $this->config['namespace_tablenames'], $this->config['morphclass_abbreviations']);

        // clean generated eloquent models
        $this->models->clean();

        // build schema
        $statements = $this->schema->drop($metadata);

        $this->info('Schema dropped successfully!');

        // output SQL queries
        if ($this->option('dump-sql')) {
            $this->outputQueries($statements);
        }
    }
241934
public function fire()
    {
        // It's possible for the developer to specify the tables to modify in this
        // schema operation. The developer may also specify if this table needs
        // to be freshly created so we can create the appropriate migrations.
        $inputAuthor = trim($this->ask('Name of author?'));
        $inputName = trim($this->ask('Name of module ?'));
        $migreateClass = trim($this->ask('Name of Migrate class?'));
        $table = trim($this->ask('Name of table'));
        $create =true;

        if (! $table && is_string($create)) {
            $table = $create;

            $create = true;
        }

        // Now we are ready to write the migration out to disk. Once we've written
        // the migration out, we will dump-autoload for the entire framework to
        // make sure that the migrations are registered by the class loaders.
        $this->writeMigrate($inputAuthor,$inputName,$migreateClass, $table, $create);

        $this->composer->dumpAutoloads();
    }
831769
public function fire()
    {
        $this->container['migration.repository']->setSource($this->input->getOption('database'));

        $this->container['migration.repository']->createRepository();

        $this->info('Migration table created successfully.');
    }
52586
public function fire()
    {
        if (!$this->confirmToProceed()) {
            return;
        }

        $this->output->writeln('<info>Seeding KodiCMS modules...</info>');
        $installer = new ModulesInstaller(ModulesLoader::getRegisteredModules());

        $installer->cleanOutputMessages();
        $installer->seedModules();

        foreach ($installer->getOutputMessages() as $message) {
            $this->output->writeln($message);
        }
    }
744991
public function fire()
    {
        $types   = NotificationTypes::all();
        $flatten = [];
        foreach ($types as $type) {
            $flatten[] = ['<info>' . $type->id . '</info>', '<fg=red>' . $type->name . '</fg=red>', '<info>' . $type->title . '</info>'];
        }

        if (count($flatten) > 0) {
            $this->table(['Id', 'Name', 'Title'], $flatten);
        } else {
            $this->error('No types found');
        }
    }
808954
public function fire()
	{
		$filter = $this->argument('filter');
		$verbose = $this->option('verbose');

		$aliasLoader = AliasLoader::getInstance();
		$first = true;

		foreach ($aliasLoader->getAliases() as $alias => $class) {

			// If a filter is given, only display aliases that start with that substring
			if ($filter && stripos($alias, $filter) !== 0)
				continue;

			// Put a blank line between each one
			if ($first)
				$first = false;
			else
				$this->line('');

			// Display the alias name
			$this->comment($alias);

			// Display the class that this alias maps to and all of its parents
			$type = 'alias  ';
			while ($class) {

				if ($verbose)
					$this->line("<info>$type ></info> $class");
				else
					$this->line("<info>-></info> $class");

				if ($this->isFacade($class))
				{
					if ($verbose)
					{
						if ($accessor = $this->getFacadeAccessor($class))
							$this->line("<info>facade  ></info> <comment>App::make('$accessor')</comment>");
						else
							$this->line("<info>facade  ></info> <comment>$class::getFacadeRoot()</comment>");
					}

					$type = 'resolve';
					$class = get_class($class::getFacadeRoot());
				}
				else
				{
					$type = 'parent ';
					$class = get_parent_class($class);
				}
			}
		}
	}
337319
public function fire()
    {
        $this->imageRefreshService->setOutput($this->output);

        $class = $this->argument('class');
        $attachments = $this->option('attachments') ?: '';

        $this->info('Refreshing uploaded images...');
        $this->imageRefreshService->refresh($class, $attachments);
        $this->info('Done!');
    }
265828
public function fire()
    {
        list($tableOne, $tableTwo) = $this->sortDesiredTables();

        $this->call('generate:migration', [
            'migrationName' => "create_{$tableOne}_{$tableTwo}_table",
            '--fields' => $this->getMigrationFields($tableOne, $tableTwo)
        ]);
    }
128458
public function fire()
    {
        if (!$this->confirm('This will remove your current "app" folder and composer.json file, do you want to proceed?')) {
            return;
        }

        // Delete previous directory
        $path = $this->paths->getUserlandPath();
        $this->files->deleteDir($path);

        // Export stubs
        $type = $this->choice('Which type of structure do you want?', ['classes', 'functions']);
        $namespace = $type === 'classes' ? $this->bootstrapper->getUserNamespace() : null;
        $this->igniter->exportStubs($type, $path, $namespace);

        $this->success('Stubs exported into "app" folder');
    }
284660
public function fire()
    {
        $this->info('Checking if database needs updating....');
        $clean = $this->option('clean');
        $sql = $this->tool->getUpdateSchemaSql($this->metadata->getAllMetadata(), $clean);
        if (empty($sql)) {
            $this->info('No updates found.');
            return;
        }
        if ($this->option('sql')) {
            $this->info('Outputting update query:');
            $this->info(implode(';' . PHP_EOL, $sql));
        } else {
            $this->info('Updating database schema....');
            $this->tool->updateSchema($this->metadata->getAllMetadata());
            $this->info('Schema has been updated!');
        }
    }