PHP Controller::callAction方法代码示例

 /**
  * @param string $method
  * @param array  $routingParameters
  * @return \Illuminate\View\View|mixed
  */
 public function callAction($method, $routingParameters)
 {
     $objects = [];
     $this->setupLayout();
     try {
         $methodParams = $this->detectParameters($method);
     } catch (ReflectionException $ex) {
         return parent::callAction($method, $routingParameters);
     }
     foreach ($routingParameters as $rpKey => $rpValue) {
         if (is_object($rpValue)) {
             $objects[get_class($rpValue)] = $rpValue;
             unset($routingParameters[$rpKey]);
         }
     }
     $parameters = array_merge($this->matchClasses($methodParams, $objects), $routingParameters);
     $response = call_user_func_array(array($this, $method), $parameters);
     // If no response is returned from the controller action and a layout is being
     // used we will assume we want to just return the layout view as any nested
     // views were probably bound on this view during this controller actions.
     if (is_null($response) && !is_null($this->layout)) {
         $response = $this->layout;
     }
     return $response;
 }

 /**
  * Execute an action on the controller.
  *
  * And is fired pre and post events on controller
  *
  * @param  string $method
  * @param  array $parameters
  * @return \Symfony\Component\HttpFoundation\Response
  */
 public function callAction($method, $parameters)
 {
     $this->beforeCallAction($method);
     $this->response = parent::callAction($method, $parameters);
     $this->afterCallAction($method);
     return $this->response;
 }

 /**
  * Calls controller action.
  *
  * @param string $method
  * @param array $parameters
  * @return mixed
  */
 public function callAction($method, array $parameters = [])
 {
     $isAjax = app()->make('request')->ajax();
     $method = $this->checkAjaxMethod($method, $isAjax);
     $parameters = $this->checkParametersResolving($method, $parameters);
     return parent::callAction($method, $parameters);
 }

 /**
  * Execute an action on the controller.
  *
  * @param  string  $method
  * @param  array   $parameters
  * @return \Symfony\Component\HttpFoundation\Response
  */
 public function callAction($method, $parameters)
 {
     $result = parent::callAction($method, $parameters);
     if (app('ajax.helper')->isFrameworkAjax()) {
         $result = $this->prepareAjaxActionResponse($result);
     }
     return $result;
 }

 /**
  * @param string $method
  * @param array $parameters
  * @return \Illuminate\Contracts\View\View
  */
 public function callAction($method, $parameters)
 {
     $altResponseContent = parent::callAction($method, $parameters);
     if (is_null($altResponseContent)) {
         $this->layoutData = array_merge(['system_menu' => AdminMenu::getSystemMenu(), 'sections_menu' => Auth::admin() ? AdminMenu::getSectionsMenu() : '', 'coaster_routes' => Routes::jsonRoutes()], $this->layoutData);
     }
     event(new LoadResponse($this->layout, $this->layoutData, $altResponseContent, $this->responseCode));
     if (is_a($altResponseContent, \Symfony\Component\HttpFoundation\Response::class)) {
         return $altResponseContent;
     } else {
         $responseContent = is_null($altResponseContent) ? View::make($this->layout, $this->layoutData) : $altResponseContent;
     }
     return Response::make($responseContent, $this->responseCode);
 }

 /**
  * Return the content.
  *
  * @param string $method
  * @param array  $parameters
  *
  * @return mixed
  */
 public function callAction($method, $parameters)
 {
     /*
      * First, we need to get the actual response contents through the
      * parent function.
      */
     $response = parent::callAction($method, $parameters);
     /*
      * Secondly we need to instantiate all classes so we don't have
      * to do this over and over again during various calls.
      */
     $this->setClasses();
     /*
      * Then we set the formatter to the one that matches the content
      * type the user wants to have the data returned in.
      */
     $this->setFormatter();
     /*
      * And finally we return the response.
      */
     return $this->formatter->response($response, $this->statusCode);
 }

 /**
  * Call the given controller instance method.
  *
  * @param  \Illuminate\Routing\Controller  $instance
  * @param  \Illuminate\Routing\Route  $route
  * @param  string  $method
  * @return mixed
  */
 protected function call($instance, $route, $method)
 {
     $parameters = $route->parametersWithoutNulls();
     return $instance->callAction($method, $parameters);
 }

 /**
  * Execute an action on the controller.
  *
  * @param string $method
  * @param array  $parameters
  *
  * @return array
  */
 public function callAction($method, $parameters)
 {
     $this->responseArray['type'] = Response::TYPE_CONTENT;
     $this->responseArray['method'] = Request::method();
     $this->responseArray['code'] = Response::NO_ERROR;
     if (isset($this->requiredFields[$method]) and is_array($this->requiredFields[$method])) {
         $this->validateParameters($this->requiredFields[$method]);
     }
     $response = parent::callAction($method, $parameters);
     if ($response instanceof RedirectResponse) {
         $this->responseArray['type'] = Response::TYPE_REDIRECT;
         $this->responseArray['targetUrl'] = $response->getTargetUrl();
         $this->responseArray['code'] = $response->getStatusCode();
     } else {
         if ($response instanceof View) {
             return new JsonResponse($response->render());
         } else {
             if ($response instanceof JsonResponse) {
                 return $response;
             }
         }
     }
     return (new Response(config('app.debug')))->createResponse($this->responseArray);
 }

 /**
  * Execute an action on the controller.
  *
  * @param string $method
  * @param array  $parameters
  * @return \Illuminate\Http\Response
  */
 public function callAction($method, $parameters)
 {
     $rMethod = new ReflectionMethod($this, $method);
     $resolver = new MethodArgumentResolver($this->container);
     return Controller::callAction($method, $resolver->resolve($rMethod, $parameters));
 }

 /**
  * Execute an action on the controller.
  *
  * @param string $method
  * @param array  $parameters
  *
  * @return \Symfony\Component\HttpFoundation\Response
  */
 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;
 }