Пример #1
1
 /**
  * Implements convenient method of calling static methods from
  * controller's model.
  *
  * @return mixed
  */
 public function __call($method, $args)
 {
     if (preg_match('/^staticModel([a-zA-Z0-9]+)$/', $method, $m)) {
         $modelClass = $this->getModelClass();
         $modelMethod = lcfirst($m[1]);
         return call_user_func_array(array($modelClass, $modelMethod), $args);
     }
     return parent::__call($method, $args);
 }
 /**
  * Register the spamguard middleware on a controller.
  *
  * @param  Controller $controller
  * @param  array $actions
  * @param  array $elements
  * @return void
  */
 public function assign(Controller $controller, $actions = [], $elements = [])
 {
     $elements = $elements ?: Config::$elements;
     foreach ($elements as $middleware) {
         $controller->middleware($middleware, $actions);
     }
 }
Пример #3
0
 /**
  * Inject the controller dependencies into the controller instance.
  *
  * @param \Illuminate\Routing\Controller $instance
  *
  * @return void
  */
 protected function injectControllerDependencies($instance)
 {
     try {
         $instance->setDispatcher($this->container['api.dispatcher']);
         $instance->setAuthenticator($this->container['api.auth']);
         $instance->setResponseFactory($this->container['api.response']);
     } catch (BadMethodCallException $exception) {
         // This controller does not utilize the trait.
     }
 }
Пример #4
0
 /**
  * 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;
 }
Пример #5
0
 /**
  * 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);
 }
Пример #6
0
 /**
  * @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;
 }
Пример #7
0
 /**
  * Make a controller instance via the IoC container.
  *
  * @param  string  $controller
  * @return mixed
  */
 protected function makeController($controller)
 {
     if ($this->creator) {
         Controller::setRouter($this->router);
         return $this->creator->createController($controller, $this->getPage());
     }
     return parent::makeController($controller);
 }
Пример #8
0
 public function __call($method, $parameters)
 {
     if (starts_with($method, 'respond')) {
         $responseBuilder = new ResponseBuilder($this->format, ['only' => $this->only, 'modelName' => $this->getModelName(), 'includes' => $this->request->has('includes') ? $this->request->get('includes') : []]);
         return call_user_func_array([$responseBuilder, $method], $parameters);
     }
     return parent::__call($method, $parameters);
 }
Пример #9
0
 /**
  * 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;
 }
Пример #10
0
 public function edit($entity)
 {
     parent::edit($entity);
     $this->edit = \DataEdit::source(new \User());
     $this->edit->label('Edit User');
     $this->edit->link("rapyd-demo/filter", "Articles", "TR")->back();
     $this->edit->add('name', 'Name', 'text')->rule('required|min:5');
     $this->edit->add('username', 'userame', 'text')->rule('required|min:5');
     return $this->returnEditView();
 }
Пример #11
0
 /**
  * Get the middleware for the controller instance.
  *
  * @param  \Illuminate\Routing\Controller  $instance
  * @param  string  $method
  * @return array
  */
 protected function getMiddleware($instance, $method)
 {
     $results = new Collection();
     foreach ($instance->getMiddleware() as $name => $options) {
         if (!$this->methodExcludedByOptions($method, $options)) {
             $results[] = $this->router->resolveMiddlewareClassName($name);
         }
     }
     return $results->flatten()->all();
 }
Пример #12
0
 /**
  * Get an instance of the possible current controller
  * being executed for the current route.
  *
  * @return mixed
  */
 protected function getCurrentController()
 {
     $router = $this->app->make('router');
     $route = $router->currentRouteAction();
     if (($pos = strpos($route, '@')) !== false) {
         Controller::setFilterer($router);
         $controllerName = substr($route, 0, $pos);
         return $this->app[$controllerName];
     }
 }
 public function validateRequest($request, $rules)
 {
     $validator = $this->getValidationFactory()->make($request->all(), $rules);
     if ($validator->fails()) {
         $message = array();
         foreach ($validator->errors()->getMessages() as $field => $errorMsg) {
             $message[] = $errorMsg[0];
         }
         $message = implode('|', $message);
         throw new HttpResponseException(Response::json(ResponseManager::error($message)));
     }
     return parent::validateRequest($request, $rules);
 }
Пример #14
0
 /**
  * @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);
 }
Пример #15
0
 /**
  * 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);
 }
 /**
  * Get the middleware for the controller instance.
  *
  * @param  \Illuminate\Routing\Controller  $instance
  * @param  string  $method
  * @return array
  */
 protected function getMiddleware($instance, $method)
 {
     $middleware = $this->router->getMiddleware();
     $results = [];
     foreach ($instance->getMiddleware() as $name => $options) {
         if (!$this->methodExcludedByOptions($method, $options)) {
             $results[] = array_get($middleware, $name, $name);
         }
     }
     return $results;
 }
Пример #17
0
 /**
  * Make a controller instance via the IoC container.
  *
  * @param  string  $controller
  * @return mixed
  */
 protected function makeController($controller)
 {
     Controller::setRouter($this->router);
     return $this->container->make($controller);
 }
Пример #18
0
 /** @inheritdoc */
 public function pushRouteMiddleware(Controller $controller)
 {
     foreach ($this->routeMiddleware as $_middleware) {
         $controller->middleware($_middleware);
     }
     return $this;
 }
Пример #19
0
 /**
  * Make a controller instance via the IoC container.
  *
  * @param  string  $controller
  * @return mixed
  */
 protected function makeController($controller)
 {
     Controller::setFilterer($this->filterer);
     return $this->container->make($controller)->setContainer($this->container);
 }
Пример #20
0
 /**
  * Apply the applicable after filters to the route.
  *
  * @param  \Illuminate\Routing\Controller  $instance
  * @param  \Illuminate\Routing\Route  $route
  * @param  \Illuminate\Http\Request  $request
  * @param  string  $method
  * @return mixed
  */
 protected function assignAfter($instance, $route, $request, $method)
 {
     foreach ($instance->getAfterFilters() as $filter) {
         // If the filter applies, we will add it to the route, since it has already been
         // registered on the filterer by the controller, and will just let the normal
         // router take care of calling these filters so we do not duplicate logics.
         if ($this->filterApplies($filter, $request, $method)) {
             $route->after($this->getAssignableAfter($filter));
         }
     }
 }
Пример #21
0
 /**
  * Get the middlewares for the given controller instance and method.
  *
  * @param  \Illuminate\Routing\Controller  $controller
  * @param  string  $method
  * @return array
  */
 protected function getControllerMiddlewareFromInstance($controller, $method)
 {
     $middleware = $this->router->getMiddleware();
     $results = [];
     foreach ($controller->getMiddleware() as $name => $options) {
         if (!$this->methodExcludedByOptions($method, $options)) {
             $results[] = Arr::get($middleware, $name, $name);
         }
     }
     return $results;
 }
Пример #22
0
 /**
  * Revise the protected state of a controller method.
  *
  * @param \Dingo\Api\Routing\Route       $action
  * @param \Illuminate\Routing\Controller $controller
  * @param string                         $method
  *
  * @return void
  */
 protected function reviseProtection(Route $route, $controller, $method)
 {
     $properties = $controller->getProperties();
     if (isset($properties['*']['protected'])) {
         $route->setProtected($properties['*']['protected']);
     }
     if (isset($properties[$method]['protected'])) {
         $route->setProtected($properties[$method]['protected']);
     }
 }
Пример #23
0
 /**
  * Magically handle calls to the response builder.
  * 
  * @param  string  $method
  * @param  array  $parameters
  * @return mixed
  */
 public function __call($method, $parameters)
 {
     if (method_exists($this->response, $method)) {
         return call_user_func_array([$this->response, $method], $parameters);
     }
     return parent::__call($method, $parameters);
 }
Пример #24
0
 public function __construct()
 {
     parent::__construct();
 }
Пример #25
0
 /**
  * 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));
 }
Пример #27
0
 /**
  * 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;
 }