Executes the given method defined by the given ActionsManager

@param string $method
@param array $actionManagers
@return array An array that contains the post actions and the not execution action
481394
protected function doExecuteActions($method, array $actionManagers)
    {
        $actions = array('post' => array(), 'notExecuted' => array());
        $this->executeFailedActions($method);
        if (0 !== count($actionManagers)){
            $actions = $this->execute($method, $actionManagers);
            if(!empty($actions['notExecuted'])) $this->writeFailedActions('.' . $method, $actions['notExecuted']);
        }

        return $actions;
    }
1141285
protected function _requireMethod($method, $actions = [])
    {
        if (isset($actions[0]) && is_array($actions[0])) {
            $actions = $actions[0];
        }
        $this->setConfig('require' . $method, empty($actions) ? ['*'] : $actions);
    }
429601
public function setHeader($action, $method = 'POST', array $attributes = array())
    {
        $this->setAction($action);
        $this->setMethod($method);
        $this->setAttributes($attributes);

        return $this;
    }
80476
protected function invoke($method, array $params = [])
    {
        $qualifiedClassName = get_class($this);

        if (false !== $pos = strrpos($qualifiedClassName, '\\')) {
            $methodRef = substr($qualifiedClassName, $pos + 1) . ':' . $method;
        } else {
            $methodRef = $qualifiedClassName . ':' . $method;
        }

        $invoker = $this->user->getInvoker();

        return $invoker(function () use ($methodRef, $method, $params) {
            $this->dispatcher->dispatch(
                Events::BEFORE_REQUEST,
                new PreCallEvent($methodRef, $params, $this->user)
            );

            try {
                $response = $this->__soapCall($method, $params);
            } catch (\Exception $ex) {
                if ($ex instanceof \SoapFault) {
                    if (strtolower($ex->faultcode) === 'http') {
                        $ex = new NetworkException($ex->getMessage(), 0, $ex);
                    } else {
                        $ex = $this->handleFault($ex, $methodRef, $params);
                    }
                }

                $this->dispatcher->dispatch(
                    Events::FAIL_REQUEST,
                    new FailCallEvent($methodRef, $params, $this->user, $this, $ex, $this->fetchUtits())
                );

                throw $ex;
            }

            $this->dispatcher->dispatch(
                Events::AFTER_REQUEST,
                new PostCallEvent($methodRef, $params, $this->user, $this, $response, $this->fetchUtits())
            );

            return $response;
        });
    }
262299
protected function execute($method, $resource, array $data = [])
    {
        if (! $this->branch) {
            $this->setBranch(1);
        }

        $request = new Request($this->domusClient->getHandler());
        $dataResource = $request->execute($method, $this->domusClient->makeUrl($resource), array_merge($data, [
            'headers' => [
                'X-Session-ID' => $this->domusClient->getToken()
            ]
        ]));

        return $dataResource;
    }
683533
protected function executeAction($index, $action)
    {
        list($key, $name, $args) = $action;

        $executedCount = $this->preExecuteAction($key, $index, $args);
        call_user_func_array([$this->rawLayoutBuilder, $name], $args);
        $executedCount++;
        $executedCount += $this->postExecuteAction($key, $index, $args);

        return $executedCount;
    }
1090065
public function invoke($method, $parameters)
    {
        /* @var Aop $aop */
        $aop = \bean(Aop::class);

        return $aop->execute($this->target, $method, $parameters);
    }
770772
protected function showHelpByMethodAnnotations(string $method, string $action = '', array $aliases = []): int
    {
        $ref  = new \ReflectionClass($this);
        $name = $this->input->getCommand();

        $this->logf(
            Console::VERB_CRAZY,
            'display help info for the method=%s, action=%s, class=%s',
            $method, $action, static::class
        );

        if (!$ref->hasMethod($method)) {
            $this->write("The command [<info>$name</info>] don't exist in the group: " . static::getName());
            return 0;
        }

        // is a console controller command
        if ($action && !$ref->getMethod($method)->isPublic()) {
            $this->write("The command [<info>$name</info>] don't allow access in the class.");
            return 0;
        }

        $doc     = $ref->getMethod($method)->getDocComment();
        $tags    = PhpDoc::getTags($this->parseCommentsVars($doc));
        $isAlone = $ref->isSubclassOf(CommandInterface::class);
        $help    = [];

        if ($aliases) {
            $realName         = $action ?: self::getName();
            $help['Command:'] = \sprintf('%s(alias: <info>%s</info>)', $realName, \implode(',', $aliases));
        }

        foreach (\array_keys(self::$annotationTags) as $tag) {
            if (empty($tags[$tag]) || !\is_string($tags[$tag])) {
                // for alone command
                if ($tag === 'description' && $isAlone) {
                    $help['Description:'] = self::getDescription();
                    continue;
                }

                if ($tag === 'usage') {
                    $help['Usage:'] = $this->commentsVars['fullCommand'] . ' [--options ...] [arguments ...]';
                }

                continue;
            }

            // $msg = trim($tags[$tag]);
            $msg = $tags[$tag];
            $tag = \ucfirst($tag);

            // for alone command
            if (!$msg && $tag === 'description' && $isAlone) {
                $msg = self::getDescription();
            } else {
                $msg = \preg_replace('#(\n)#', '$1 ', $msg);
            }

            $help[$tag . ':'] = $msg;
        }

        if (isset($help['Description:'])) {
            $description = $help['Description:'] ?: 'No description message for the command';
            $this->write(\ucfirst($description) . \PHP_EOL);
            unset($help['Description:']);
        }

        $help['Group Options:']  = null;
        $help['Global Options:'] = FormatUtil::alignOptions(Application::getGlobalOptions());

        $this->beforeRenderCommandHelp($help);

        $this->output->mList($help, [
            'sepChar'     => '  ',
            'lastNewline' => 0,
        ]);

        return 0;
    }
81281
protected function executeStrategiesMethod($method)
    {
        $this->onStrategies(function (AbstractStrategy $strategy) use ($method) {
            return $strategy->$method();
        });

        return $this->passed();
    }
1065577
public function evaluate($method, $arguments = array())
    {
        $callable = $this->mapper->getCallable($method);
        $arguments = $this->mapper->getArguments($callable, $arguments);

        return $this->execute($callable, $arguments);
    }
1078031
protected function runActionMethod($action, $vars = array()) {
		return call_user_func_array(
		    array($this, $action),
            $this->getActionArguments($action, $vars)
        );
	}
970151
public function call($method, Array $params = [])
    {
        $rawResult = parent::call($method, $params);

        switch ($method) {
            case 'GetCarBrandAndModel':
                $result = $rawResult->GetCarBrandAndModelReturn->MakeModelBean;
            break;

            case 'GetCarBrand':
                $result = $rawResult->GetCarBrandReturn->x_car_brand->string;
        }

        return $result;
    }
843951
public function runController($controller, $method, Array $params) {
    $transactional = $controller instanceof \Psc\CMS\Controller\TransactionalController;
    
    try {
      try {
        $this->logf('running Controller: %s::%s(%s)', Code::getClass($controller), $method, implode(', ',array_map(function ($param) { return Code::varInfo($param); }, $params)));
        $cb = new Callback($controller, $method);
        $controllerResponse = $cb->call($params);
        
        $this->log('Converting Controller Response');
        $this->setResponseFromControllerResponse($controllerResponse);
        $this->log('Response Format: '.($this->response->getFormat() ?: 'null'));
        $this->log('successful run');
        
        $this->log('überprüfe ResponseMetadataController');
        if ($controller instanceof \Psc\CMS\Controller\ResponseMetadataController && ($meta = $controller->getResponseMetadata()) != NULL) {
          $this->response->setMetadata($meta);
          $this->log('Metadaten übertragen');
        }
        
      /* PDO Exceptions */
      } catch (\PDOException  $e) {
        throw \Psc\Doctrine\Exception::convertPDOException($e);
      }

    } catch (\Exception $e) {
      if ($transactional && $controller->hasActiveTransaction())
        $controller->rollbackTransaction();
      
      $this->handleException($e);
    }
  }
215706
protected function parseAction(string $action, string $method): string
    {
        if ('post' === $method) {
            return $this->getSlug().'_'.$action;
        }

        return $action;
    }
979779
public function handle(string $method, array $arguments)
    {
        $upMethod = strtoupper($method);
        $context  = array_shift($arguments);

        if (in_array($upMethod, self::$asynCommand)) {
            $sql = '';
            if ($upMethod == 'GO') {
                if (!empty($arguments[1])) {
                    $sql = trim($arguments[1]);
                } else {
                    $sql = $this->getDBQueryBuilder($context)->getStatement(false);
                }
            }

            if (!empty($sql) && empty($arguments[0]) && !empty($this->slaves)) {
                if (stripos($sql, 'SELECT') === 0 || stripos($sql, 'SHOW') === 0) {
                    $rand     = array_rand($this->slaves);
                    $poolName = $this->slaves[$rand];
                } else {
                    $poolName = $this->master;
                }
            } else {
                $poolName = $this->master;
            }

            $pool = getInstance()->getAsynPool($poolName);
            if ($pool == null) {
                throw new Exception("mysql pool $poolName not register!");
            }
            $this->getDBQueryBuilder($context)->mysqlPool = $pool;
            if (method_exists($this->getDBQueryBuilder(), $method)) {
                return $this->getDBQueryBuilder($context)->{$method}(...$arguments);
            } else {
                array_push($arguments, $context);
                return $this->getDBQueryBuilder($context)->mysqlPool->{$method}(...$arguments);
            }
        }

        $this->getDBQueryBuilder($context)->{$method}(...$arguments);

        return $this->__wrapper;
    }
652182
public function method($method)
    {
        if (!$this->isString($method) && !$this->isStringObject($method)) {
            throw new EventManagerException(EventManagerException::MSG_INVALID_ARG, [
                    '$method',
                    'string|StringObject'
                ]
            );
        }
        $this->method = StdObjectWrapper::toString($method);

        return $this;
    }
629329
public function callAction($method, $parameters)
    {
        $response = $parentResponse = null;

        try {
            $response = $parentResponse = parent::callAction($method, $parameters);
        } catch (\Exception $e) {
            $notFoundExceptions = array(
                'Illuminate\\Database\\Eloquent\\ModelNotFoundException',
                'Symfony\\Component\\HttpKernel\\Exception\\NotFoundHttpException',
            );
            $errorExceptions = array(
                'Subbly\\Api\\Service\\Exception',
            );

            if (in_array(get_class($e), $notFoundExceptions)) {
                return $this->jsonNotFoundResponse($e->getMessage());
            } elseif (in_array(get_class($e), $errorExceptions)) {
                return $this->jsonErrorResponse($e->getMessage());
            } elseif ($e instanceof \Subbly\Model\Exception\UnvalidModelException) {
                return $this->jsonErrorResponse($e->firstErrorMessage());
            }

            $response = $this->jsonErrorResponse('Fatal error!');
        }

        if (App::environment('local', 'testing')) {
            return $parentResponse ?: parent::callAction($method, $parameters);
        }

        return $response;
    }