PHP Controller::viewBuilder方法代码示例

 protected function _getView($viewVars = [])
 {
     $Request = new Request();
     $Response = new Response();
     $Controller = new Controller($Request, $Response);
     $builder = $Controller->viewBuilder();
     $builder->className('JsonApi\\View\\JsonApiView');
     if ($viewVars) {
         $Controller->set($viewVars);
     }
     return $Controller->createView();
 }

 /**
  * AjaxComponent::_respondAsAjax()
  *
  * @return void
  */
 protected function _respondAsAjax()
 {
     $this->Controller->viewBuilder()->className($this->_config['viewClass']);
     // Set flash messages to the view
     if ($this->_config['flashKey']) {
         $message = $this->Controller->request->session()->consume($this->_config['flashKey']);
         $this->Controller->set('_message', $message);
     }
     // If _serialize is true, *all* viewVars will be serialized; no need to add _message.
     if (!empty($this->Controller->viewVars['_serialize']) && $this->Controller->viewVars['_serialize'] === true) {
         return;
     }
     $serializeKeys = ['_message'];
     if (!empty($this->Controller->viewVars['_serialize'])) {
         $serializeKeys = array_merge($serializeKeys, $this->Controller->viewVars['_serialize']);
     }
     $this->Controller->set('_serialize', $serializeKeys);
 }

 /**
  * Handles unauthenticated access attempt. First the `unauthenticated()` method
  * of the last authenticator in the chain will be called. The authenticator can
  * handle sending response or redirection as appropriate and return `true` to
  * indicate no further action is necessary. If authenticator returns null this
  * method redirects user to login action. If it's an AJAX request and config
  * `ajaxLogin` is specified that element is rendered else a 403 HTTP status code
  * is returned.
  *
  * @param \Cake\Controller\Controller $controller A reference to the controller object.
  * @return \Cake\Network\Response|null Null if current action is login action
  *   else response object returned by authenticate object or Controller::redirect().
  */
 protected function _unauthenticated(Controller $controller)
 {
     if (empty($this->_authenticateObjects)) {
         $this->constructAuthenticate();
     }
     $auth = end($this->_authenticateObjects);
     $result = $auth->unauthenticated($this->request, $this->response);
     if ($result !== null) {
         return $result;
     }
     if (!$this->storage()->redirectUrl()) {
         $this->storage()->redirectUrl($this->request->here(false));
     }
     if (!$controller->request->is('ajax')) {
         $this->flash($this->_config['authError']);
         $this->storage()->redirectUrl($controller->request->here(false));
         return $controller->redirect($this->_config['loginAction']);
     }
     if (!empty($this->_config['ajaxLogin'])) {
         $controller->viewBuilder()->templatePath('Element');
         $response = $controller->render($this->_config['ajaxLogin'], $this->RequestHandler->ajaxLayout);
         $response->statusCode(403);
         return $response;
     }
     $this->response->statusCode(403);
     return $this->response;
 }

 protected function _createSitemap($type)
 {
     $this->_type = $type;
     //$this->controller->autoRender = false;
     $this->controller->viewClass = 'Sitemap.SitemapXml';
     $this->controller->viewBuilder()->autoLayout(false);
     //@TODO Set response parameters from SitemapXml view
     $this->controller->response->type('application/xml');
     $this->controller->response->cache(mktime(0, 0, 0, date('m'), date('d'), date('Y')), $this->cache);
 }

 /**
  * SetupComponent::startup()
  *
  * - Sets the layout based on session value 'Setup.layout'.
  *
  * @param \Cake\Event\Event $event
  * @return void
  */
 public function startup(Event $event)
 {
     $layout = $this->request->session()->read('Setup.layout');
     if ($layout) {
         $this->Controller->viewBuilder()->layout($layout);
     }
 }

 /**
  * A safer way to render error messages, replaces all helpers, with basics
  * and doesn't call component methods.
  *
  * @param string $template The template to render.
  * @return \Cake\Network\Response A response object that can be sent.
  */
 protected function _outputMessageSafe($template)
 {
     $helpers = ['Form', 'Html'];
     $this->controller->helpers = $helpers;
     $builder = $this->controller->viewBuilder();
     $builder->helpers($helpers, false)->layoutPath('')->templatePath('Error');
     $view = $this->controller->createView();
     $this->controller->response->body($view->render($template, 'error'));
     $this->controller->response->type('html');
     return $this->controller->response;
 }

 /**
  * testRender method
  *
  * @return void
  */
 public function testRender()
 {
     Plugin::load('TestPlugin');
     $request = new Request('controller_posts/index');
     $request->params['action'] = 'index';
     $Controller = new Controller($request, new Response());
     $Controller->viewBuilder()->templatePath('Posts');
     $result = $Controller->render('index');
     $this->assertRegExp('/posts index/', (string) $result);
     $Controller->viewBuilder()->template('index');
     $result = $Controller->render();
     $this->assertRegExp('/posts index/', (string) $result);
     $result = $Controller->render('/Element/test_element');
     $this->assertRegExp('/this is the test element/', (string) $result);
 }

 /**
  * Sets either the view class if one exists or the layout and template path of the view.
  * The names of these are derived from the $type input parameter.
  *
  * ### Usage:
  *
  * Render the response as an 'ajax' response.
  *
  * ```
  * $this->RequestHandler->renderAs($this, 'ajax');
  * ```
  *
  * Render the response as an xml file and force the result as a file download.
  *
  * ```
  * $this->RequestHandler->renderAs($this, 'xml', ['attachment' => 'myfile.xml'];
  * ```
  *
  * @param Controller $controller A reference to a controller object
  * @param string $type Type of response to send (e.g: 'ajax')
  * @param array $options Array of options to use
  * @return void
  * @see RequestHandlerComponent::respondAs()
  */
 public function renderAs(Controller $controller, $type, array $options = [])
 {
     $defaults = ['charset' => 'UTF-8'];
     $viewClassMap = $this->config('viewClassMap');
     if (Configure::read('App.encoding') !== null) {
         $defaults['charset'] = Configure::read('App.encoding');
     }
     $options += $defaults;
     $builder = $controller->viewBuilder();
     if (array_key_exists($type, $viewClassMap)) {
         $view = $viewClassMap[$type];
     } else {
         $view = Inflector::classify($type);
     }
     $viewClass = null;
     if ($builder->className() === null) {
         $viewClass = App::className($view, 'View', 'View');
     }
     if ($viewClass) {
         $controller->viewClass = $viewClass;
         $builder->className($viewClass);
     } else {
         if (empty($this->_renderType)) {
             $builder->templatePath($builder->templatePath() . DS . $type);
         } else {
             $builder->templatePath(preg_replace("/([\\/\\\\]{$this->_renderType})\$/", DS . $type, $builder->templatePath()));
         }
         $this->_renderType = $type;
         $builder->layoutPath($type);
     }
     $response = $this->response;
     if ($response->getMimeType($type)) {
         $this->respondAs($type, $options);
     }
     $helper = ucfirst($type);
     if (!in_array($helper, $controller->helpers) && empty($controller->helpers[$helper])) {
         $helperClass = App::className($helper, 'View/Helper', 'Helper');
         if ($helperClass !== false) {
             $controller->helpers[] = $helper;
         }
     }
 }

 /**
  * Toggle ajax field.
  *
  * @param Table $table
  * @param $id
  * @param $value
  * @param string $field
  */
 public function fieldToggle(Table $table, $id, $value, $field = 'status')
 {
     $this->_controller->serializeAjax = false;
     if (empty($id) || $value === null) {
         throw new Exception(__d('union', 'Invalid content'));
     }
     $this->_controller->viewBuilder()->layout('ajax')->templatePath('Common');
     $record = $table->get($id);
     $record->{$field} = (int) (!$value);
     if ($entity = $table->save($record)) {
         $this->_controller->set('record', $entity);
         $this->_controller->render('Union/Core.toggle');
     } else {
         throw new Exception(__d('union', 'Failed toggling field {0} to {1}', $field, $record->{$field}));
     }
 }

 /**
  * {@inheritDoc}
  */
 protected function _getController()
 {
     if (!($request = Router::getRequest(true))) {
         $request = new Request();
     }
     $response = new Response();
     try {
         $controller = new TestAppsErrorController($request, $response);
         $controller->viewBuilder()->layout('banana');
     } catch (\Exception $e) {
         $controller = new Controller($request, $response);
         $controller->viewBuilder()->templatePath('Error');
     }
     return $controller;
 }