ScheduleRunCommand
class ScheduleRunCommand extends Command (View source)
Traits
Properties
| protected Factory | $components | The console components factory.  | 
                from InteractsWithIO | 
| protected InputInterface | $input | The input interface implementation.  | 
                from InteractsWithIO | 
| protected OutputStyle | $output | The output interface implementation.  | 
                from InteractsWithIO | 
| protected int | $verbosity | The default verbosity of output commands.  | 
                from InteractsWithIO | 
| protected array | $verbosityMap | The mapping between human readable verbosity levels and Symfony's OutputInterface.  | 
                from InteractsWithIO | 
| protected Signals|null | $signals | The signal registrar instance.  | 
                from InteractsWithSignals | 
| static protected array | $macros | The registered string macros.  | 
                from Macroable | 
| protected Application | $laravel | The Laravel application instance.  | 
                from Command | 
| protected string | $signature | The name and signature of the console command.  | 
                |
| protected string | $name | The console command name.  | 
                from Command | 
| protected string | $description | The console command description.  | 
                |
| protected string | $help | The console command help text.  | 
                from Command | 
| $hidden | Indicates whether the command should be shown in the Artisan command list.  | 
                from Command | |
| protected bool | $isolated | Indicates whether only one instance of the command can run at any given time.  | 
                from Command | 
| protected int | $isolatedExitCode | The default exit code for isolated commands.  | 
                from Command | 
| protected array | $aliases | The console command name aliases.  | 
                from Command | 
| protected Schedule | $schedule | The schedule instance.  | 
                |
| protected Carbon | $startedAt | The 24 hour timestamp this scheduler command started running.  | 
                |
| protected bool | $eventsRan | Check if any events ran.  | 
                |
| protected Dispatcher | $dispatcher | The event dispatcher.  | 
                |
| protected ExceptionHandler | $handler | The exception handler.  | 
                |
| protected Repository | $cache | The cache store implementation.  | 
                |
| protected string | $phpBinary | The PHP binary used by the command.  | 
                
Methods
Resolve the console command instance for the given command.
Call another console command.
Call another console command without output.
Call another console command without output.
Run the given console command.
Create an input instance from the given arguments.
Prompt the user until the given validation callback passes.
Validate the given prompt value using the validator.
Get the validator instance that should be used to validate prompts.
Get the validation messages that should be used during prompt validation.
Get the validation attributes that should be used during prompt validation.
Get the value of a command argument.
Determine whether the option is defined in the command signature.
Get the value of a command option.
Confirm a question with the user.
Prompt the user for input.
Prompt the user for input with auto completion.
Prompt the user for input with auto completion.
Prompt the user for input but hide the answer from the console.
Give the user a single choice from an array of answers.
Format input to textual table.
Execute a given callback while advancing a progress bar.
Write a string as information output.
Write a string as standard output.
Write a string as comment output.
Write a string as question output.
Write a string as error output.
Write a string as warning output.
Write a string in an alert box.
Get the verbosity level in terms of Symfony's OutputInterface level.
Interact with the user before validating the input.
Prompt the user for any missing arguments.
Prompt for missing input arguments using the returned questions.
Perform actions after the user was prompted for missing arguments.
Whether the input contains any options that differ from the default values.
Mix another object into the class.
Dynamically handle calls to the class.
Dynamically handle calls to the class.
Create a new command instance.
Configure the console command using a fluent definition.
Execute the console command.
Get a command isolation mutex instance for the command.
Execute the console command.
Run the given repeating events.
Determine if the schedule run should be interrupted.
Ensure the interrupt signal is cleared.
Details
        
            abstract        protected        Command
    resolveCommand(Command|string $command)
        
    
    Resolve the console command instance for the given command.
        
                            int
    call(Command|string $command, array $arguments = [])
        
    
    Call another console command.
        
                            int
    callSilent(Command|string $command, array $arguments = [])
        
    
    Call another console command without output.
        
                            int
    callSilently(Command|string $command, array $arguments = [])
        
    
    Call another console command without output.
        
                    protected        int
    runCommand(Command|string $command, array $arguments, OutputInterface $output)
        
    
    Run the given console command.
        
                    protected        ArrayInput
    createInputFromArguments(array $arguments)
        
    
    Create an input instance from the given arguments.
        
                    protected        array
    context()
        
    
    Get all of the context passed to the command.
        
                    protected        void
    configurePrompts(InputInterface $input)
        
    
    Configure the prompt fallbacks.
        
                    protected        mixed
    promptUntilValid(Closure $prompt, bool|string $required, Closure|null $validate)
        
    
    Prompt the user until the given validation callback passes.
        
                    protected        ?string
    validatePrompt(mixed $value, mixed $rules)
        
    
    Validate the given prompt value using the validator.
        
                    protected        Validator
    getPromptValidatorInstance(mixed $field, mixed $value, mixed $rules, array $messages = [], array $attributes = [])
        
    
    Get the validator instance that should be used to validate prompts.
        
                    protected        array
    validationMessages()
        
    
    Get the validation messages that should be used during prompt validation.
        
                    protected        array
    validationAttributes()
        
    
    Get the validation attributes that should be used during prompt validation.
        
                    protected        void
    restorePrompts()
        
    
    Restore the prompts output.
        
                    protected        void
    specifyParameters()
        
    
    Specify the arguments and options on the command.
        
                    protected        array
    getArguments()
        
    
    Get the console command arguments.
        
                    protected        array
    getOptions()
        
    
    Get the console command options.
        
                            bool
    hasArgument(string|int $name)
        
    
    Determine if the given argument is present.
        
                            array|string|bool|null
    argument(string|null $key = null)
        
    
    Get the value of a command argument.
        
                            array
    arguments()
        
    
    Get all of the arguments passed to the command.
        
                            bool
    hasOption(string $name)
        
    
    Determine whether the option is defined in the command signature.
        
                            string|array|bool|null
    option(string|null $key = null)
        
    
    Get the value of a command option.
        
                            array
    options()
        
    
    Get all of the options passed to the command.
        
                            bool
    confirm(string $question, bool $default = false)
        
    
    Confirm a question with the user.
        
                            mixed
    ask(string $question, string|null $default = null)
        
    
    Prompt the user for input.
        
                            mixed
    anticipate(string $question, array|callable $choices, string|null $default = null)
        
    
    Prompt the user for input with auto completion.
        
                            mixed
    askWithCompletion(string $question, array|callable $choices, string|null $default = null)
        
    
    Prompt the user for input with auto completion.
        
                            mixed
    secret(string $question, bool $fallback = true)
        
    
    Prompt the user for input but hide the answer from the console.
        
                            string|array
    choice(string $question, array $choices, string|int|null $default = null, mixed $attempts = null, bool $multiple = false)
        
    
    Give the user a single choice from an array of answers.
        
                            void
    table(array $headers, Arrayable|array $rows, TableStyle|string $tableStyle = 'default', array $columnStyles = [])
        
    
    Format input to textual table.
        
                            mixed|void
    withProgressBar(iterable|int $totalSteps, Closure $callback)
        
    
    Execute a given callback while advancing a progress bar.
        
                            void
    info(string $string, int|string|null $verbosity = null)
        
    
    Write a string as information output.
        
                            void
    line(string $string, string|null $style = null, int|string|null $verbosity = null)
        
    
    Write a string as standard output.
        
                            void
    comment(string $string, int|string|null $verbosity = null)
        
    
    Write a string as comment output.
        
                            void
    question(string $string, int|string|null $verbosity = null)
        
    
    Write a string as question output.
        
                            void
    error(string $string, int|string|null $verbosity = null)
        
    
    Write a string as error output.
        
                            void
    warn(string $string, int|string|null $verbosity = null)
        
    
    Write a string as warning output.
        
                            void
    alert(string $string, int|string|null $verbosity = null)
        
    
    Write a string in an alert box.
        
                            $this
    newLine(int $count = 1)
        
    
    Write a blank line.
        
                            void
    setInput(InputInterface $input)
        
    
    Set the input interface implementation.
        
                            void
    setOutput(OutputStyle $output)
        
    
    Set the output interface implementation.
        
                    protected        void
    setVerbosity(string|int $level)
        
    
    Set the verbosity level.
        
                    protected        int
    parseVerbosity(string|int|null $level = null)
        
    
    Get the verbosity level in terms of Symfony's OutputInterface level.
        
                            OutputStyle
    getOutput()
        
    
    Get the output implementation.
        
                            Factory
    outputComponents()
        
    
    Get the output component factory implementation.
        
                            
    trap($signals, $callback)
        
    
    No description
        
                            void
    untrap()
        
    
    | internal | 
Untrap signal handlers set within the command's handler.
        
                    protected        void
    interact(InputInterface $input, OutputInterface $output)
        
    
    Interact with the user before validating the input.
        
                    protected        void
    promptForMissingArguments(InputInterface $input, OutputInterface $output)
        
    
    Prompt the user for any missing arguments.
        
                    protected        array
    promptForMissingArgumentsUsing()
        
    
    Prompt for missing input arguments using the returned questions.
        
                    protected        void
    afterPromptingForMissingArguments(InputInterface $input, OutputInterface $output)
        
    
    Perform actions after the user was prompted for missing arguments.
        
                    protected        bool
    didReceiveOptions(InputInterface $input)
        
    
    Whether the input contains any options that differ from the default values.
        
                static            void
    macro(string $name, object|callable $macro)
        
    
    Register a custom macro.
        
                static            void
    mixin(object $mixin, bool $replace = true)
        
    
    Mix another object into the class.
        
                static            bool
    hasMacro(string $name)
        
    
    Checks if macro is registered.
        
                static            void
    flushMacros()
        
    
    Flush the existing macros.
        
                static            mixed
    __callStatic(string $method, array $parameters)
        
    
    Dynamically handle calls to the class.
        
                            mixed
    __call(string $method, array $parameters)
        
    
    Dynamically handle calls to the class.
        
                            
    __construct()
        
    
    Create a new command instance.
        
                    protected        void
    configureUsingFluentDefinition()
        
    
    Configure the console command using a fluent definition.
        
                    protected        void
    configureIsolation()
        
    
    Configure the console command for isolation.
        
                            int
    run(InputInterface $input, OutputInterface $output)
        
    
    Run the console command.
        
                    protected        int
    execute(InputInterface $input, OutputInterface $output)
        
    
    Execute the console command.
        
                    protected        CommandMutex
    commandIsolationMutex()
        
    
    Get a command isolation mutex instance for the command.
        
                            never
    fail(Throwable|string|null $exception = null)
        
    
    Fail the command manually.
        
                            bool
    isHidden()
        
    
    {@inheritdoc}
        
                            Command
    setHidden(bool $hidden = true)
        
    
    {@inheritdoc}
        
                            Application
    getLaravel()
        
    
    Get the Laravel application instance.
        
                            void
    setLaravel(Container $laravel)
        
    
    Set the Laravel application instance.
        
                            void
    handle(Schedule $schedule, Dispatcher $dispatcher, Repository $cache, ExceptionHandler $handler)
        
    
    Execute the console command.
        
                    protected        void
    runSingleServerEvent(Event $event)
        
    
    Run the given single server event.
        
                    protected        void
    runEvent(Event $event)
        
    
    Run the given event.
        
                    protected        void
    repeatEvents(Event> $events)
        
    
    Run the given repeating events.
        
                    protected        bool
    shouldInterrupt()
        
    
    Determine if the schedule run should be interrupted.
        
                    protected        void
    clearInterruptSignal()
        
    
    Ensure the interrupt signal is cleared.