class RestExport

Same name in other branches
  1. 9 core/modules/rest/src/Plugin/views/display/RestExport.php \Drupal\rest\Plugin\views\display\RestExport
  2. 8.9.x core/modules/rest/src/Plugin/views/display/RestExport.php \Drupal\rest\Plugin\views\display\RestExport
  3. 11.x core/modules/rest/src/Plugin/views/display/RestExport.php \Drupal\rest\Plugin\views\display\RestExport

The plugin that handles Data response callbacks for REST resources.

Hierarchy

Expanded class hierarchy of RestExport

Related topics

3 files declare their use of RestExport
CollectRoutesTest.php in core/modules/rest/tests/src/Unit/CollectRoutesTest.php
RestExportTest.php in core/modules/rest/tests/src/Kernel/Views/RestExportTest.php
SerializerTest.php in core/modules/rest/tests/src/Unit/Plugin/views/style/SerializerTest.php

File

core/modules/rest/src/Plugin/views/display/RestExport.php, line 28

Namespace

Drupal\rest\Plugin\views\display
View source
class RestExport extends PathPluginBase implements ResponseDisplayPluginInterface {
    
    /**
     * {@inheritdoc}
     */
    protected $usesAJAX = FALSE;
    
    /**
     * {@inheritdoc}
     */
    protected $usesPager = FALSE;
    
    /**
     * {@inheritdoc}
     */
    protected $usesMore = FALSE;
    
    /**
     * {@inheritdoc}
     */
    protected $usesAreas = FALSE;
    
    /**
     * {@inheritdoc}
     */
    protected $usesOptions = FALSE;
    
    /**
     * Overrides the content type of the data response, if needed.
     *
     * @var string
     */
    protected $contentType = 'json';
    
    /**
     * The mime type for the response.
     *
     * @var string
     */
    protected $mimeType = 'application/json';
    
    /**
     * The renderer.
     *
     * @var \Drupal\Core\Render\RendererInterface
     */
    protected $renderer;
    
    /**
     * The collector of authentication providers.
     *
     * @var \Drupal\Core\Authentication\AuthenticationCollectorInterface
     */
    protected $authenticationCollector;
    
    /**
     * The authentication providers, like 'cookie' and 'basic_auth'.
     *
     * @var string[]
     */
    protected $authenticationProviderIds;
    
    /**
     * The serialization format providers, keyed by format.
     *
     * @var string[]
     */
    protected $formatProviders;
    
    /**
     * Constructs a RestExport object.
     *
     * @param array $configuration
     *   A configuration array containing information about the plugin instance.
     * @param string $plugin_id
     *   The plugin_id for the plugin instance.
     * @param mixed $plugin_definition
     *   The plugin implementation definition.
     * @param \Drupal\Core\Routing\RouteProviderInterface $route_provider
     *   The route provider.
     * @param \Drupal\Core\State\StateInterface $state
     *   The state key value store.
     * @param \Drupal\Core\Render\RendererInterface $renderer
     *   The renderer.
     * @param string[] $authentication_providers
     *   The authentication providers, keyed by ID.
     * @param string[] $serializer_format_providers
     *   The serialization format providers, keyed by format.
     */
    public function __construct(array $configuration, $plugin_id, $plugin_definition, RouteProviderInterface $route_provider, StateInterface $state, RendererInterface $renderer, array $authentication_providers, array $serializer_format_providers) {
        parent::__construct($configuration, $plugin_id, $plugin_definition, $route_provider, $state);
        $this->renderer = $renderer;
        // $authentication_providers as defined in
        // \Drupal\Core\DependencyInjection\Compiler\AuthenticationProviderPass
        // and as such it is an array, with authentication providers (cookie,
        // basic_auth) as keys and modules providing those as values (user,
        // basic_auth).
        $this->authenticationProviderIds = array_keys($authentication_providers);
        $this->formatProviders = $serializer_format_providers;
    }
    
    /**
     * {@inheritdoc}
     */
    public static function create(ContainerInterface $container, array $configuration, $plugin_id, $plugin_definition) {
        return new static($configuration, $plugin_id, $plugin_definition, $container->get('router.route_provider'), $container->get('state'), $container->get('renderer'), $container->getParameter('authentication_providers'), $container->getParameter('serializer.format_providers'));
    }
    
    /**
     * {@inheritdoc}
     */
    public function initDisplay(ViewExecutable $view, array &$display, ?array &$options = NULL) {
        parent::initDisplay($view, $display, $options);
        // If the default 'json' format is not selected as a format option in the
        // view display, fallback to the first format available for the default.
        if (!empty($options['style']['options']['formats']) && !isset($options['style']['options']['formats'][$this->getContentType()])) {
            $default_format = reset($options['style']['options']['formats']);
            $this->setContentType($default_format);
        }
        // Only use the requested content type if it's not 'html'. This allows
        // still falling back to the default for things like views preview.
        $request_content_type = $this->view
            ->getRequest()
            ->getRequestFormat();
        if ($request_content_type !== 'html') {
            $this->setContentType($request_content_type);
        }
        $this->setMimeType($this->view
            ->getRequest()
            ->getMimeType($this->getContentType()));
    }
    
    /**
     * {@inheritdoc}
     */
    public function getType() {
        return 'data';
    }
    
    /**
     * {@inheritdoc}
     */
    public function usesExposed() {
        return TRUE;
    }
    
    /**
     * {@inheritdoc}
     */
    public function displaysExposed() {
        return FALSE;
    }
    
    /**
     * Sets the request content type.
     *
     * @param string $mime_type
     *   The response mime type. E.g. 'application/json'.
     */
    public function setMimeType($mime_type) {
        $this->mimeType = $mime_type;
    }
    
    /**
     * Gets the mime type.
     *
     * This will return any overridden mime type, otherwise returns the mime type
     * from the request.
     *
     * @return string
     *   The response mime type. E.g. 'application/json'.
     */
    public function getMimeType() {
        return $this->mimeType;
    }
    
    /**
     * Sets the content type.
     *
     * @param string $content_type
     *   The content type machine name. E.g. 'json'.
     */
    public function setContentType($content_type) {
        $this->contentType = $content_type;
    }
    
    /**
     * Gets the content type.
     *
     * @return string
     *   The content type machine name. E.g. 'json'.
     */
    public function getContentType() {
        return $this->contentType;
    }
    
    /**
     * Gets the auth options available.
     *
     * @return string[]
     *   An array to use as value for "#options" in the form element.
     */
    public function getAuthOptions() {
        return array_combine($this->authenticationProviderIds, $this->authenticationProviderIds);
    }
    
    /**
     * {@inheritdoc}
     */
    protected function defineOptions() {
        $options = parent::defineOptions();
        // Options for REST authentication.
        $options['auth'] = [
            'default' => [],
        ];
        // Set the default style plugin to 'json'.
        $options['style']['contains']['type']['default'] = 'serializer';
        $options['row']['contains']['type']['default'] = 'data_entity';
        $options['defaults']['default']['style'] = FALSE;
        $options['defaults']['default']['row'] = FALSE;
        // Remove css/exposed form settings, as they are not used for the data display.
        unset($options['exposed_form']);
        unset($options['exposed_block']);
        unset($options['css_class']);
        return $options;
    }
    
    /**
     * {@inheritdoc}
     */
    public function optionsSummary(&$categories, &$options) {
        parent::optionsSummary($categories, $options);
        // Authentication.
        $auth = $this->getOption('auth') ? implode(', ', $this->getOption('auth')) : $this->t('No authentication is set');
        unset($categories['page'], $categories['exposed']);
        // Hide some settings, as they aren't useful for pure data output.
        unset($options['show_admin_links'], $options['analyze-theme']);
        $categories['path'] = [
            'title' => $this->t('Path settings'),
            'column' => 'second',
            'build' => [
                '#weight' => -10,
            ],
        ];
        $options['path']['category'] = 'path';
        $options['path']['title'] = $this->t('Path');
        $options['auth'] = [
            'category' => 'path',
            'title' => $this->t('Authentication'),
            'value' => Unicode::truncate($auth, 24, FALSE, TRUE),
        ];
        // Remove css/exposed form settings, as they are not used for the data
        // display.
        unset($options['exposed_form']);
        unset($options['exposed_block']);
        unset($options['css_class']);
    }
    
    /**
     * {@inheritdoc}
     */
    public function buildOptionsForm(&$form, FormStateInterface $form_state) {
        parent::buildOptionsForm($form, $form_state);
        if ($form_state->get('section') === 'auth') {
            $form['#title'] .= $this->t('The supported authentication methods for this view');
            $form['auth'] = [
                '#type' => 'checkboxes',
                '#title' => $this->t('Authentication methods'),
                '#description' => $this->t('These are the supported authentication providers for this view. When this view is requested, the client will be forced to authenticate with one of the selected providers. Make sure you set the appropriate requirements at the <em>Access</em> section since the Authentication System will fallback to the anonymous user if it fails to authenticate. For example: require Access: Role | Authenticated User.'),
                '#options' => $this->getAuthOptions(),
                '#default_value' => $this->getOption('auth'),
            ];
        }
    }
    
    /**
     * {@inheritdoc}
     */
    public function submitOptionsForm(&$form, FormStateInterface $form_state) {
        parent::submitOptionsForm($form, $form_state);
        if ($form_state->get('section') == 'auth') {
            $this->setOption('auth', array_keys(array_filter($form_state->getValue('auth'))));
        }
    }
    
    /**
     * {@inheritdoc}
     */
    public function collectRoutes(RouteCollection $collection) {
        parent::collectRoutes($collection);
        $view_id = $this->view->storage
            ->id();
        $display_id = $this->display['id'];
        if ($route = $collection->get("view.{$view_id}.{$display_id}")) {
            $style_plugin = $this->getPlugin('style');
            // REST exports should only respond to GET methods.
            $route->setMethods([
                'GET',
            ]);
            $formats = $style_plugin->getFormats();
            // If there are no configured formats, add all formats that serialization
            // is known to support.
            if (!$formats) {
                $formats = $this->getFormatOptions();
            }
            // Format as a string using pipes as a delimiter.
            $route->setRequirement('_format', implode('|', $formats));
            // Add authentication to the route if it was set. If no authentication was
            // set, the default authentication will be used, which is cookie based by
            // default.
            $auth = $this->getOption('auth');
            if (!empty($auth)) {
                $route->setOption('_auth', $auth);
            }
        }
    }
    
    /**
     * Determines whether the view overrides the given route.
     *
     * @param string $view_path
     *   The path of the view.
     * @param \Symfony\Component\Routing\Route $view_route
     *   The route of the view.
     * @param \Symfony\Component\Routing\Route $route
     *   The route itself.
     *
     * @return bool
     *   TRUE, when the view should override the given route.
     */
    protected function overrideApplies($view_path, Route $view_route, Route $route) {
        $route_has_format = $route->hasRequirement('_format');
        $route_formats = $route_has_format ? explode('|', $route->getRequirement('_format')) : [];
        $view_route_formats = $view_route->hasRequirement('_format') ? explode('|', $view_route->getRequirement('_format')) : [];
        return $this->overrideAppliesPathAndMethod($view_path, $view_route, $route) && (!$route_has_format || array_intersect($route_formats, $view_route_formats) != []);
    }
    
    /**
     * {@inheritdoc}
     */
    public static function buildResponse($view_id, $display_id, array $args = []) {
        $build = static::buildBasicRenderable($view_id, $display_id, $args);
        // Setup an empty response so headers can be added as needed during views
        // rendering and processing.
        $response = new CacheableResponse('', 200);
        $build['#response'] = $response;
        
        /** @var \Drupal\Core\Render\RendererInterface $renderer */
        $renderer = \Drupal::service('renderer');
        $output = (string) $renderer->renderRoot($build);
        $response->setContent($output);
        $cache_metadata = CacheableMetadata::createFromRenderArray($build);
        $response->addCacheableDependency($cache_metadata);
        $response->headers
            ->set('Content-type', $build['#content_type']);
        return $response;
    }
    
    /**
     * {@inheritdoc}
     */
    public function execute() {
        parent::execute();
        return $this->view
            ->render();
    }
    
    /**
     * {@inheritdoc}
     */
    public function render() {
        $build = [];
        $build['#markup'] = $this->renderer
            ->executeInRenderContext(new RenderContext(), function () {
            return $this->view->style_plugin
                ->render();
        });
        $this->view->element['#content_type'] = $this->getMimeType();
        $this->view->element['#cache_properties'][] = '#content_type';
        // Encode and wrap the output in a pre tag if this is for a live preview.
        if (!empty($this->view->live_preview)) {
            $build['#prefix'] = '<pre>';
            $build['#plain_text'] = $build['#markup'];
            $build['#suffix'] = '</pre>';
            unset($build['#markup']);
        }
        else {
            // This display plugin is for returning non-HTML formats. However, we
            // still invoke the renderer to collect cacheability metadata. Because the
            // renderer is designed for HTML rendering, it filters #markup for XSS
            // unless it is already known to be safe, but that filter only works for
            // HTML. Therefore, we mark the contents as safe to bypass the filter. So
            // long as we are returning this in a non-HTML response,
            // this is safe, because an XSS attack only works when executed by an HTML
            // agent.
            // @todo Decide how to support non-HTML in the render API in
            //   https://www.drupal.org/node/2501313.
            $build['#markup'] = ViewsRenderPipelineMarkup::create($build['#markup']);
        }
        parent::applyDisplayCacheabilityMetadata($build);
        return $build;
    }
    
    /**
     * {@inheritdoc}
     *
     * The DisplayPluginBase preview method assumes we will be returning a render
     * array. The data plugin will already return the serialized string.
     */
    public function preview() {
        return $this->view
            ->render();
    }
    
    /**
     * Returns an array of format options.
     *
     * @return string[]
     *   An array of format options. Both key and value are the same.
     */
    protected function getFormatOptions() {
        $formats = array_keys($this->formatProviders);
        return array_combine($formats, $formats);
    }

}

Members

Title Sort descending Deprecated Modifiers Object type Summary Overriden Title Overrides
DependencyTrait::$dependencies protected property The object&#039;s dependencies.
DependencyTrait::addDependencies protected function Adds multiple dependencies.
DependencyTrait::addDependency protected function Adds a dependency.
DerivativeInspectionInterface::getBaseId public function Gets the base_plugin_id of the plugin instance. 1
DerivativeInspectionInterface::getDerivativeId public function Gets the derivative_id of the plugin instance. 1
DisplayPluginBase::$default_display public property
DisplayPluginBase::$display public property The display information coming directly from the view entity.
DisplayPluginBase::$extenders protected property Stores all available display extenders.
DisplayPluginBase::$handlers public property An array of instantiated handlers used in this display.
DisplayPluginBase::$has_exposed public property
DisplayPluginBase::$output public property Stores the rendered output of the display.
DisplayPluginBase::$plugins protected property An array of instantiated plugins used in this display.
DisplayPluginBase::$unpackOptions protected static property Static cache for unpackOptions, but not if we are in the UI.
DisplayPluginBase::$usesAttachments protected property Whether the display allows attachments. 6
DisplayPluginBase::$view public property The top object of a view. Overrides PluginBase::$view
DisplayPluginBase::acceptAttachments public function Determines whether this display can use attachments. Overrides DisplayPluginInterface::acceptAttachments
DisplayPluginBase::access public function Determines if the user has access to this display of the view. Overrides DisplayPluginInterface::access
DisplayPluginBase::ajaxEnabled public function Whether the display is actually using AJAX or not. Overrides DisplayPluginInterface::ajaxEnabled
DisplayPluginBase::applyDisplayCacheabilityMetadata protected function Applies the cacheability of the current display to the given render array.
DisplayPluginBase::attachTo public function Allows displays to attach to other views. Overrides DisplayPluginInterface::attachTo 2
DisplayPluginBase::buildBasicRenderable public static function Builds a basic render array which can be properly render cached. Overrides DisplayPluginInterface::buildBasicRenderable 1
DisplayPluginBase::buildRenderable public function Builds a renderable array of the view. Overrides DisplayPluginInterface::buildRenderable 1
DisplayPluginBase::buildRenderingLanguageOptions protected function Returns the available rendering strategies for language-aware entities.
DisplayPluginBase::calculateCacheMetadata public function Calculates the display&#039;s cache metadata by inspecting each handler/plugin. Overrides DisplayPluginInterface::calculateCacheMetadata
DisplayPluginBase::calculateDependencies public function Calculates dependencies for the configured plugin. Overrides PluginBase::calculateDependencies 2
DisplayPluginBase::defaultableSections public function Lists the &#039;defaultable&#039; sections and what items each section contains. Overrides DisplayPluginInterface::defaultableSections 1
DisplayPluginBase::destroy public function Clears a plugin. Overrides PluginBase::destroy
DisplayPluginBase::elementPreRender public function #pre_render callback for view display rendering. Overrides DisplayPluginInterface::elementPreRender
DisplayPluginBase::getAllHandlers protected function Gets all the handlers used by the display.
DisplayPluginBase::getAllPlugins protected function Gets all the plugins used by the display.
DisplayPluginBase::getArgumentsTokens public function Returns to tokens for arguments. Overrides DisplayPluginInterface::getArgumentsTokens
DisplayPluginBase::getArgumentText public function Provides help text for the arguments. Overrides DisplayPluginInterface::getArgumentText 1
DisplayPluginBase::getAttachedDisplays public function Find out all displays which are attached to this display. Overrides DisplayPluginInterface::getAttachedDisplays
DisplayPluginBase::getCacheMetadata public function Gets the cache metadata. Overrides DisplayPluginInterface::getCacheMetadata
DisplayPluginBase::getExtenders public function Gets the display extenders. Overrides DisplayPluginInterface::getExtenders
DisplayPluginBase::getFieldLabels public function Retrieves a list of fields for the current display. Overrides DisplayPluginInterface::getFieldLabels
DisplayPluginBase::getHandler public function Get the handler object for a single handler. Overrides DisplayPluginInterface::getHandler
DisplayPluginBase::getHandlers public function Get a full array of handlers for $type. This caches them. Overrides DisplayPluginInterface::getHandlers
DisplayPluginBase::getLinkDisplay public function Returns the ID of the display to use when making links. Overrides DisplayPluginInterface::getLinkDisplay
DisplayPluginBase::getMoreUrl protected function Get the more URL for this view.
DisplayPluginBase::getOption public function Gets an option, from this display or the default display. Overrides DisplayPluginInterface::getOption
DisplayPluginBase::getPagerText public function Provides help text for pagers. Overrides DisplayPluginInterface::getPagerText 1
DisplayPluginBase::getPlugin public function Get the instance of a plugin, for example style or row. Overrides DisplayPluginInterface::getPlugin
DisplayPluginBase::getRoutedDisplay public function Points to the display which can be linked by this display. Overrides DisplayPluginInterface::getRoutedDisplay
DisplayPluginBase::getSpecialBlocks public function Provides the block system with any exposed widget blocks for this display. Overrides DisplayPluginInterface::getSpecialBlocks
DisplayPluginBase::getUrl public function Returns a URL to $this display or its configured linked display. Overrides DisplayPluginInterface::getUrl
DisplayPluginBase::isBaseTableTranslatable protected function Returns whether the base table is of a translatable entity type.
DisplayPluginBase::isDefaultDisplay public function Determines if this display is the &#039;default&#039; display. Overrides DisplayPluginInterface::isDefaultDisplay 1
DisplayPluginBase::isDefaulted public function Determines if an option is set to use the default or current display. Overrides DisplayPluginInterface::isDefaulted
DisplayPluginBase::isEnabled public function Whether the display is enabled. Overrides DisplayPluginInterface::isEnabled
DisplayPluginBase::isIdentifierUnique public function Checks if the provided identifier is unique. Overrides DisplayPluginInterface::isIdentifierUnique
DisplayPluginBase::isMoreEnabled public function Whether the display is using the &#039;more&#039; link or not. Overrides DisplayPluginInterface::isMoreEnabled
DisplayPluginBase::isPagerEnabled public function Whether the display is using a pager or not. Overrides DisplayPluginInterface::isPagerEnabled
DisplayPluginBase::mergeDefaults public function Merges default values for all plugin types. Overrides DisplayPluginInterface::mergeDefaults
DisplayPluginBase::mergeHandler protected function Merges handlers default values.
DisplayPluginBase::mergePlugin protected function Merges plugins default values.
DisplayPluginBase::newDisplay public function Reacts on adding a display. Overrides DisplayPluginInterface::newDisplay 1
DisplayPluginBase::optionLink public function Returns a link to a section of a form. Overrides DisplayPluginInterface::optionLink
DisplayPluginBase::optionsOverride public function If override/revert was clicked, perform the proper toggle. Overrides DisplayPluginInterface::optionsOverride
DisplayPluginBase::outputIsEmpty public function Is the output of the view empty. Overrides DisplayPluginInterface::outputIsEmpty
DisplayPluginBase::overrideOption public function Set an option and force it to be an override. Overrides DisplayPluginInterface::overrideOption
DisplayPluginBase::preExecute public function Sets up any variables on the view prior to execution. Overrides DisplayPluginInterface::preExecute
DisplayPluginBase::query public function Add anything to the query that we might need to. Overrides PluginBase::query 1
DisplayPluginBase::renderArea public function Renders one of the available areas. Overrides DisplayPluginInterface::renderArea
DisplayPluginBase::renderFilters public function Does nothing (obsolete function). Overrides DisplayPluginInterface::renderFilters
DisplayPluginBase::renderMoreLink public function Renders the &#039;more&#039; link. Overrides DisplayPluginInterface::renderMoreLink
DisplayPluginBase::renderPager public function Checks to see if the display plugins support pager rendering. Overrides DisplayPluginInterface::renderPager 1
DisplayPluginBase::setOption public function Sets an option, on this display or the default display. Overrides DisplayPluginInterface::setOption
DisplayPluginBase::setOverride public function Flip the override setting for the given section. Overrides DisplayPluginInterface::setOverride
DisplayPluginBase::trustedCallbacks public static function Lists the trusted callbacks provided by the implementing class. Overrides PluginBase::trustedCallbacks
DisplayPluginBase::useGroupBy public function Does the display have groupby enabled? Overrides DisplayPluginInterface::useGroupBy
DisplayPluginBase::useMoreAlways public function Should the enabled display more link be shown when no more items? Overrides DisplayPluginInterface::useMoreAlways
DisplayPluginBase::useMoreText public function Does the display have custom link text? Overrides DisplayPluginInterface::useMoreText
DisplayPluginBase::usesAJAX public function Whether the display allows the use of AJAX or not. Overrides DisplayPluginInterface::usesAJAX 2
DisplayPluginBase::usesAreas public function Returns whether the display can use areas. Overrides DisplayPluginInterface::usesAreas 2
DisplayPluginBase::usesAttachments public function Returns whether the display can use attachments. Overrides DisplayPluginInterface::usesAttachments 6
DisplayPluginBase::usesExposedFormInBlock public function Checks to see if the display can put the exposed form in a block. Overrides DisplayPluginInterface::usesExposedFormInBlock 1
DisplayPluginBase::usesFields public function Determines if the display&#039;s style uses fields. Overrides DisplayPluginInterface::usesFields
DisplayPluginBase::usesLinkDisplay public function Checks to see if the display has some need to link to another display. Overrides DisplayPluginInterface::usesLinkDisplay 1
DisplayPluginBase::usesMore public function Whether the display allows the use of a &#039;more&#039; link or not. Overrides DisplayPluginInterface::usesMore 1
DisplayPluginBase::usesPager public function Whether the display allows the use of a pager or not. Overrides DisplayPluginInterface::usesPager 4
DisplayPluginBase::viewExposedFormBlocks public function Renders the exposed form as block. Overrides DisplayPluginInterface::viewExposedFormBlocks
PathPluginBase::$routeProvider protected property The route provider.
PathPluginBase::$state protected property The state key value store.
PathPluginBase::alterRoutes public function Alters a collection of routes and replaces definitions to the view. Overrides DisplayRouterInterface::alterRoutes
PathPluginBase::getAlteredRouteNames public function Returns the list of routes overridden by Views. Overrides DisplayRouterInterface::getAlteredRouteNames
PathPluginBase::getMenuLinks public function Gets menu links, if this display provides some. Overrides DisplayMenuInterface::getMenuLinks
PathPluginBase::getPath public function Returns the base path to use for this display. Overrides DisplayPluginBase::getPath
PathPluginBase::getRoute protected function Generates a route entry for a given view and display. 1
PathPluginBase::getRouteName public function Returns the route name for the display. Overrides DisplayRouterInterface::getRouteName
PathPluginBase::getUrlInfo public function Generates a URL to this display. Overrides DisplayRouterInterface::getUrlInfo
PathPluginBase::hasPath public function Checks to see if the display has a &#039;path&#039; field. Overrides DisplayPluginBase::hasPath
PathPluginBase::isDefaultTabPath protected function Determines if this display&#039;s path is a default tab.
PathPluginBase::overrideAppliesPathAndMethod protected function Determines whether an override for the path and method should happen.
PathPluginBase::remove public function Reacts on deleting a display. Overrides DisplayPluginBase::remove
PathPluginBase::validate public function Validate that the plugin is correct and can be saved. Overrides DisplayPluginBase::validate 1
PathPluginBase::validateOptionsForm public function Validate the options form. Overrides DisplayPluginBase::validateOptionsForm 1
PathPluginBase::validatePath protected function Validates the path of the display.
PluginBase::$definition public property Plugins&#039; definition.
PluginBase::$displayHandler public property The display object this plugin is for.
PluginBase::$options public property Options for this plugin will be held here.
PluginBase::$position public property The handler position.
PluginBase::doFilterByDefinedOptions protected function Do the work to filter out stored options depending on the defined options.
PluginBase::filterByDefinedOptions public function Filter out stored options depending on the defined options. Overrides ViewsPluginInterface::filterByDefinedOptions
PluginBase::getAvailableGlobalTokens public function Returns an array of available token replacements. Overrides ViewsPluginInterface::getAvailableGlobalTokens
PluginBase::getProvider public function Returns the plugin provider. Overrides ViewsPluginInterface::getProvider
PluginBase::getRenderer protected function Returns the render API renderer. 1
PluginBase::globalTokenForm public function Adds elements for available core tokens to a form. Overrides ViewsPluginInterface::globalTokenForm
PluginBase::globalTokenReplace public function Returns a string with any core tokens replaced. Overrides ViewsPluginInterface::globalTokenReplace
PluginBase::INCLUDE_ENTITY constant Include entity row languages when listing languages.
PluginBase::INCLUDE_NEGOTIATED constant Include negotiated languages when listing languages.
PluginBase::init public function Initialize the plugin. Overrides ViewsPluginInterface::init 6
PluginBase::listLanguages protected function Makes an array of languages, optionally including special languages.
PluginBase::pluginTitle public function Return the human readable name of the display. Overrides ViewsPluginInterface::pluginTitle
PluginBase::preRenderAddFieldsetMarkup public static function Moves form elements into fieldsets for presentation purposes. Overrides ViewsPluginInterface::preRenderAddFieldsetMarkup
PluginBase::preRenderFlattenData public static function Flattens the structure of form elements. Overrides ViewsPluginInterface::preRenderFlattenData
PluginBase::queryLanguageSubstitutions public static function Returns substitutions for Views queries for languages.
PluginBase::setOptionDefaults protected function Fills up the options of the plugin with defaults.
PluginBase::summaryTitle public function Returns the summary of the settings in the display. Overrides ViewsPluginInterface::summaryTitle 6
PluginBase::themeFunctions public function Provide a full list of possible theme templates used by this style. Overrides ViewsPluginInterface::themeFunctions 1
PluginBase::unpackOptions public function Unpacks options over our existing defaults. Overrides ViewsPluginInterface::unpackOptions
PluginBase::usesOptions public function Returns the usesOptions property. Overrides ViewsPluginInterface::usesOptions 8
PluginBase::viewsTokenReplace protected function Replaces Views&#039; tokens in a given string. 1
PluginBase::VIEWS_QUERY_LANGUAGE_SITE_DEFAULT constant Query string to indicate the site default language.
PluginDependencyTrait::calculatePluginDependencies protected function Calculates and adds dependencies of a specific plugin instance. 1
PluginDependencyTrait::getPluginDependencies protected function Calculates and returns dependencies of a specific plugin instance.
PluginDependencyTrait::moduleHandler protected function Wraps the module handler. 1
PluginDependencyTrait::themeHandler protected function Wraps the theme handler. 1
PluginInspectionInterface::getPluginDefinition public function Gets the definition of the plugin implementation. 6
PluginInspectionInterface::getPluginId public function Gets the plugin_id of the plugin instance. 2
RestExport::$authenticationCollector protected property The collector of authentication providers.
RestExport::$authenticationProviderIds protected property The authentication providers, like &#039;cookie&#039; and &#039;basic_auth&#039;.
RestExport::$contentType protected property Overrides the content type of the data response, if needed.
RestExport::$formatProviders protected property The serialization format providers, keyed by format.
RestExport::$mimeType protected property The mime type for the response.
RestExport::$renderer protected property The renderer. Overrides PluginBase::$renderer
RestExport::$usesAJAX protected property Whether the display allows the use of AJAX or not. Overrides DisplayPluginBase::$usesAJAX
RestExport::$usesAreas protected property Whether the display allows area plugins. Overrides DisplayPluginBase::$usesAreas
RestExport::$usesMore protected property Whether the display allows the use of a &#039;more&#039; link or not. Overrides DisplayPluginBase::$usesMore
RestExport::$usesOptions protected property Denotes whether the plugin has an additional options form. Overrides DisplayPluginBase::$usesOptions
RestExport::$usesPager protected property Whether the display allows the use of a pager or not. Overrides DisplayPluginBase::$usesPager
RestExport::buildOptionsForm public function Provide a form to edit options for this plugin. Overrides PathPluginBase::buildOptionsForm
RestExport::buildResponse public static function Builds up a response with the rendered view as content. Overrides ResponseDisplayPluginInterface::buildResponse
RestExport::collectRoutes public function Adds the route entry of a view to the collection. Overrides PathPluginBase::collectRoutes
RestExport::create public static function Creates an instance of the plugin. Overrides PathPluginBase::create
RestExport::defineOptions protected function Overrides \Drupal\views\Plugin\views\display\DisplayPluginBase:defineOptions(). Overrides PathPluginBase::defineOptions
RestExport::displaysExposed public function Determines if this display should display the exposed filters widgets. Overrides DisplayPluginBase::displaysExposed
RestExport::execute public function Executes the view and returns data in the format required. Overrides PathPluginBase::execute
RestExport::getAuthOptions public function Gets the auth options available.
RestExport::getContentType public function Gets the content type.
RestExport::getFormatOptions protected function Returns an array of format options.
RestExport::getMimeType public function Gets the mime type.
RestExport::getType public function Returns the display type that this display requires. Overrides DisplayPluginBase::getType
RestExport::initDisplay public function Initializes the display plugin. Overrides DisplayPluginBase::initDisplay
RestExport::optionsSummary public function Provides the default summary for options in the views UI. Overrides PathPluginBase::optionsSummary
RestExport::overrideApplies protected function Determines whether the view overrides the given route. Overrides PathPluginBase::overrideApplies
RestExport::preview public function The DisplayPluginBase preview method assumes we will be returning a render
array. The data plugin will already return the serialized string.
Overrides DisplayPluginBase::preview
RestExport::render public function Renders this display. Overrides DisplayPluginBase::render
RestExport::setContentType public function Sets the content type.
RestExport::setMimeType public function Sets the request content type.
RestExport::submitOptionsForm public function Handle any special handling on the validate form. Overrides PathPluginBase::submitOptionsForm
RestExport::usesExposed public function Determines if this display uses exposed filters. Overrides DisplayPluginBase::usesExposed
RestExport::__construct public function Constructs a RestExport object. Overrides PathPluginBase::__construct
TrustedCallbackInterface::THROW_EXCEPTION constant Untrusted callbacks throw exceptions.
TrustedCallbackInterface::TRIGGER_SILENCED_DEPRECATION constant Untrusted callbacks trigger silenced E_USER_DEPRECATION errors.
TrustedCallbackInterface::TRIGGER_WARNING Deprecated constant Untrusted callbacks trigger E_USER_WARNING errors.

Buggy or inaccurate documentation? Please file an issue. Need support? Need help programming? Connect with the Drupal community.