Checks if the action should be processed by the component.

@return bool
762476
protected function _actionCheck()
    {
        $actions = $this->config('actions');
        if (is_bool($actions)) {
            return $actions;
        }
        if (is_string($actions)) {
            $actions = [$actions];
        }
        if(count(array_filter(array_keys($actions), 'is_string')) > 0){
            $_actions = [];
            foreach($actions as $key=>$value){
                if(is_string($key)){
                    $_actions[] = $key;
                } else {
                    $_actions[] = $value;
                }
            }
            $actions = $_actions;
        }
        return in_array($this->request->action, $actions);
    }
1337319
public function canViewTarget()
    {
        $action = $this->CurrentAction();
        if ($action) {
            return $action->canViewTarget($this->getTarget());
        }
        return true;
    }
747066
protected function validateAction()
    {
        $token = (isset($this->validationToken)) ? $this->validationToken : get_class($this);
        if (!$this->app->make('token')->validate($token)) {
            $this->error->add($this->app->make('token')->getErrorMessage());

            return false;
        }
        if (!$this->canAccess()) {
            return false;
        }

        return true;
    }
98907
public function shouldNotify()
    {
        if (!$this->notifyReleaseStages) {
            return true;
        }

        return in_array($this->getAppData()['releaseStage'], $this->notifyReleaseStages, true);
    }
464867
public function isSuccessful()
    {
        if ($this->getState() === static::STATE_NOT_RUNNING) {
            foreach ($this->items as $run) {
                if (!$run->isSuccessful()) {
                    return false;
                }
            }
            return true;
        }
        return false;
    }
878923
public function execute()
    {
        try {
            if ($action = $this->action) {
                return $action($this);
            } else {
                foreach ($this->parseSteps as $parseStep) {
                    if (is_string($parseStep)) {
                        $parseStep = [$this->controller, $parseStep];
                    }

                    if ($parseStep($this) === false) {
                        return false;
                    }
                }

                $queryStep = $this->queryStep;
                if (is_string($queryStep)) {
                    $queryStep = [$this->controller, $queryStep];
                }

                $result = $queryStep($this);

                foreach ($this->transformSteps as $transformStep) {
                    if (is_string($transformStep)) {
                        $transformStep = [$this->controller, $transformStep];
                    }

                    if ($transformStep($result, $this) === false) {
                        return false;
                    }
                }
            }
        // handle API exceptions
        } catch (Error\Base $ex) {
            if (method_exists($this->controller, 'handleError')) {
                $this->controller->handleError($ex, $this);
            }
        }

        return true;
    }
212313
public function canProcess()
    {
        if ($this->persisted()) {
            return false;
        }

        if (!$this->_subscriber) {
            return false;
        }

        if (!$this->validateEntity()) {
            return false;
        }

        if (!$this->_subscriber->persisted() && !$this->_subscriber->validateEntity()) {
            return false;
        }

        if (!isset($this->_package)) {
            return false;
        }

        if (!isset($this->_payment_method)) {
            return false;
        }

        return true;
    }
1166875
public function process ()
    {
        if ($this->isProcessed)
            return;
        $this->isProcessed = true;
        foreach ($this->getFields() as $field)
            /* @var $field Field */
            $field->preprocess();
        $this->isUserSubmitted = $this->getValue($this->getSubmitConfirmFieldName(), 'false') == 'true' || $this->forceSubmit;
        if ($this->isUserSubmitted) {
            foreach ($this->getFields() as $field)
                $field->restoreValue($this->method);

            $this->activateHandlers();

            if ($this->isValid()) {
                $this->submit();
            }
        }
    }
757453
public function run()
    {
        $event = $this->getMvcEvent();

        // Define callback used to determine whether or not to short-circuit
        $shortCircuit = function ($r) use ($event) {
            if ($r instanceof Response) {
                return true;
            }
            return false;
        };

        $events = $this->getEventManager();
        $result = $events->trigger(MvcEvent::EVENT_DISPATCH, $event, $shortCircuit);

        // Complete response
        $response = $result->last();
        if ($response instanceof Response) {
            $event->setTarget($this);
            $events->trigger(MvcEvent::EVENT_FINISH, $event);
        }

    }
676937
public function isPair()
    {
        return (!$this->isNull() && ($this->getBaseType() === BaseType::PAIR) || $this->getBaseType() === BaseType::DIRECTED_PAIR);
    }
1234482
public function process()
    {
        switch ($this->inputs['action']) {
            case 'login':
                $this->webLogin();
                break;
            case 'logout':
                $this->webLogout();
                exit($this->showWebLoginForm());
                break;
            case 'getContacts':
                $this->getContacts();
                break;
            case 'updateStatus':
                $this->updateStatus();
                break;
            case 'sendMessage':
                $this->sendMessage();
                break;
            case 'sendBroadcast':
                $this->sendBroadcast();
                break;
            default:
                if (isset($_SESSION['logged_in']) && $_SESSION['logged_in'] == true) {
                    exit($this->showWebForm());
                }
                exit($this->showWebLoginForm());
                break;
        }
    }
204899
protected function doExecute()
    {
        $args = $this->io->getArguments();

        if (!$this->console instanceof ScheduleConsoleInterface) {
            $this->out('Console Application should be ' . ScheduleConsoleInterface::class);

            return true;
        }

        $schedule = $this->console->make(Schedule::class);

        $this->console->schedule($schedule);

        foreach ($schedule->getDueEvents() as $event) {
            $event->execute();
        }

        return true;
    }
603904
public function isActive(): bool
    {
        if (is_callable($activeWhen = $this->activeWhen)) {
            return call_user_func($activeWhen);
        }

        if ($this->route) {
            return $this->hasActiveStateFromRoute();
        }

        return $this->hasActiveStateFromUrl();
    }
770326
function isCurrentAction( $actionName, $view = '' )
    {
        if ( $view == '' )
            $view = self::currentView();
        if ( $view == '' or $actionName == '' )
            return false;
        return $this->currentAction( $view ) == $actionName;
    }
1146019
protected function _isFilterRequest()
    {
        return (
            $this->controller !== null  &&
            $this->request !== null &&
            $this->action !== null &&
            $this->_filterEnabled
        );
    }
151384
public function runStepActions()
    {
        $step = $this->getCurrentStep();

        foreach ($step->getActions() as $action) {
            $action = $this->getAction($action);

            if (false == $action->run($this->getModel())) {

                return false;
            }
        }

        return true;
    }
162233
public function isAppropriate($components)
    {
        $components = array_values(array_filter(array_map('trim', $components), 'strlen'));
        $this->options = array();
        if (count($components) < 5) {
            return false;
        }

        if ($components[1] !== '--task' || $components[3] !== '--action') {
            return false;
        }
        $this->options['task'] = $components[2];
        $this->options['action'] = $components[4];

        try {
            // ensure we have this task registered
            $this->getServiceProvider()->get($this->options['task']);
        } catch (Exception $e) {
            return false;
        }

        return true;
    }