/**
  * Filters the Response.
  *
  * @param FilterResponseEvent $event    A FilterResponseEvent instance
  */
 public function onResponse(FilterResponseEvent $event)
 {
     // $response = $event->getResponse();
     // $headers  = $response->headers;
     // $headers->set('Content-Length', 11);
     // if (!$headers->has('Content-Length') && !$headers->has('Transfer-Encoding')) {
     //     $headers->set('Content-Length', strlen($response->getContent()));
     // }
     $request = $event->getRequest();
     $response = $event->getResponse();
     if ('HEAD' === $request->getMethod()) {
         // cf. RFC2616 14.13
         $length = $response->headers->get('Content-Length');
         $response->setContent('');
         if ($length) {
             $response->headers->set('Content-Length', $length);
         }
     }
     if ($response->getCharset() === null) {
         $response->setCharset($this->charset);
     }
     $annotations = $event->getAnnotations();
     // override headers from annotations
     if ($annotations instanceof ResponseAnnotation) {
         $annotatedHeaders = $annotations->getHeaders();
         foreach ($annotatedHeaders as $key => $value) {
             $response->headers->set($key, $value);
         }
     }
     // end annotated headers
     if ($response->headers->has('Content-Type')) {
         return;
     }
     $format = $request->getRequestFormat();
     if ($format !== null && ($mimeType = $request->getMimeType($format))) {
         $response->headers->set('Content-Type', $mimeType);
     }
 }
Example #2
0
 /**
  * handle the http user request
  *
  * @param \Alchemy\Application $app
  * @param \Alchemy\Component\Http\Request $request user http request
  * @return \Alchemy\Component\Http\JsonResponse|\Alchemy\Component\Http\Response
  */
 public function handle(Request $request, Application $app = null)
 {
     $this->request = $request;
     try {
         // init services providers
         /** @var \Alchemy\Service\ServiceProviderInterface $providers */
         $providers = $app->getServiceProviders();
         foreach ($providers as $provider) {
             $provider->init($app);
         }
         /*
          * "EVENT" KernelEvents::REQUEST using GetResponse Event
          *
          * This event can be used by an application to filter a request before
          * ever all kernel logic being executed, listeners for this event should
          * be registered outside framework logic (should be on application logic).
          */
         if ($this->dispatcher->hasListeners(KernelEvents::REQUEST)) {
             $event = new GetResponseEvent($this, $request, $app);
             $this->dispatcher->dispatch(KernelEvents::REQUEST, $event);
             if ($event->hasResponse()) {
                 //var_dump($event->getResponse()); die("ee");
                 $event = new FilterResponseEvent($this, $request, $event->getResponse());
                 $this->dispatcher->dispatch(KernelEvents::RESPONSE, $event);
                 return $event->getResponse();
             }
         }
         /*
          * try match the url request with a defined route.
          * it any route match the current url a ResourceNotFoundException
          * will be thrown.
          */
         $params = $this->mapper->match($request);
         $uriParams = $params["params"];
         // prepare request params.
         $params = $this->prepareRequestParams(array($params["mapped"], $request->query->all(), $request->request->all()));
         // add prepared params to request as attributes.
         $request->attributes->add($params);
         // resolve controller
         try {
             $controller = $this->resolver->getController($request);
         } catch (\Exception $exception) {
             /*
              * Detailed exception types are only for development environments
              * if the current is a non dev environment just overrides the current exception with
              * a ResourceNotFoundException exception
              */
             if ($this->config->get('env.type') !== 'dev') {
                 $exception = new ResourceNotFoundException($request->getPathInfo());
             }
             throw $exception;
         }
         if (!$controller) {
             throw new ResourceNotFoundException($request->getPathInfo());
         }
         // setting default annotations namespace
         $this->annotationReader->setDefaultNamespace('\\Alchemy\\Annotation\\');
         // seeting annotation reader target
         $this->annotationReader->setTarget($params['_controllerClass'], $params['_controllerMethod']);
         $arguments = $this->resolver->getArguments($app, $request, $controller);
         //"EVENT" FILTER_CONTROLLER
         if ($this->dispatcher->hasListeners(KernelEvents::FILTER_CONTROLLER)) {
             $event = new FilterControllerEvent($this, $controller, $request);
             $this->dispatcher->dispatch(KernelEvents::FILTER_CONTROLLER, $event);
             // getting controller; this can be the same or other filtered controller
             $controller = $event->getController();
         }
         //"EVENT" BEFORE_CONTROLLER
         if ($this->dispatcher->hasListeners(KernelEvents::BEFORE_CONTROLLER)) {
             $event = new ControllerEvent($this, $controller, $arguments, $request);
             $this->dispatcher->dispatch(KernelEvents::BEFORE_CONTROLLER, $event);
         }
         // Execute controller action
         $response = call_user_func_array($controller, $arguments);
         // check returned value by method is a array
         if (is_array($response)) {
             // set controller view data object
             foreach ($response as $key => $value) {
                 $controller[0]->view->{$key} = $value;
             }
         }
         // getting controller's data.
         $controllerData = (array) $controller[0]->view;
         if (!($response instanceof Response || $response instanceof JsonResponse)) {
             if ($this->annotationReader->getAnnotation('JsonResponse')) {
                 $controllerData = $response;
                 $response = new JsonResponse();
                 $response->setData($controllerData);
             } else {
                 $response = new Response();
             }
         }
         //"EVENT" AFTER_CONTROLLER
         if ($this->dispatcher->hasListeners(KernelEvents::AFTER_CONTROLLER)) {
             if (!isset($event) || !$event instanceof ControllerEvent) {
                 $event = new ControllerEvent($this, $controller, $arguments, $request);
             }
             $event->setResponse($response);
             $this->dispatcher->dispatch(KernelEvents::AFTER_CONTROLLER, $event);
         }
         // handling view
         $view = $this->handleView($params['_controllerClass'], $params['_controllerMethod'], $controllerData, $this->annotationReader->getAnnotation('View'));
         // handling meta ui
         if ($this->annotationReader->getAnnotation('ServeUi')) {
             $view = $this->handleMetaUi($controllerData, $this->annotationReader->getAnnotation('ServeUi'), $view, $request);
         }
         // if there is a view adapter instance, get its contents and set to response content
         if (!empty($view)) {
             foreach ($uriParams as $keyParam => $valParam) {
                 $view->assign($keyParam, $valParam);
             }
             //"EVENT" VIEW dispatch all KernelEvents::VIEW events
             if ($this->dispatcher->hasListeners(KernelEvents::VIEW)) {
                 $event = new ViewEvent($this, $view, $request, $this->annotationReader, $app);
                 $this->dispatcher->dispatch(KernelEvents::VIEW, $event);
                 $view = $event->getView();
             }
             $response->setContent($view->getOutput());
         }
     } catch (ResourceNotFoundException $e) {
         $exceptionHandler = new Exception\Handler();
         if ($request->isXmlHttpRequest()) {
             $response = new JsonResponse();
             $response->setData(array('success' => false, 'message' => $e->getMessage()));
         } else {
             $response = new Response($exceptionHandler->getOutput($e), 404);
         }
     } catch (\Exception $e) {
         //            echo $e->getMessage();
         //            echo "<br><pre>";
         //            echo $e->getTraceAsString();
         //            die;
         $exceptionHandler = new Exception\Handler();
         if ($request->isXmlHttpRequest()) {
             $response = new JsonResponse();
             $response->setData(array('success' => false, 'message' => $e->getMessage()));
         } else {
             $response = new Response($exceptionHandler->getOutput($e), 500);
         }
     }
     if ($this->annotationReader->hasTarget()) {
         $responseAnnotation = $this->annotationReader->getAnnotation('Response');
     } else {
         $responseAnnotation = null;
     }
     // dispatch a response event
     $this->dispatcher->dispatch(KernelEvents::RESPONSE, new FilterResponseEvent($this, $request, $response, $responseAnnotation));
     return $response;
 }