You are here

Home » API reference » Views RSS 8.3 » RssFields.php

class RssFields in Views RSS 8.3

Same name in this branch
  1. 8.3 src/Plugin/views/style/RssFields.php \Drupal\views_rss\Plugin\views\style\RssFields
  2. 8.3 src/Plugin/views/row/RssFields.php \Drupal\views_rss\Plugin\views\row\RssFields
Same name and namespace in other branches
  1. 8.2 src/Plugin/views/style/RssFields.php \Drupal\views_rss\Plugin\views\style\RssFields

Default style plugin to render an RSS feed from fields.

Plugin annotation


@ViewsStyle(
  id = "rss_fields",
  title = @Translation("RSS Feed - Fields"),
  help = @Translation("Generates an RSS feed from fields in a view."),
  theme = "views_view_rss",
  display_types = {"feed"}
)

Hierarchy

Expanded class hierarchy of RssFields

File

src/Plugin/views/style/RssFields.php, line 28
Definition of Drupal\views\Plugin\views\style\Rss.

Namespace

Drupal\views_rss\Plugin\views\style
View source 
class RssFields extends StylePluginBase {

  /**
   * Does the style plugin for itself support to add fields to it's output.
   *
   * @var bool
   */
  protected $usesRowPlugin = TRUE;

  /**
   * Does the style plugin support grouping of rows.
   *
   * @var bool
   */
  protected $usesGrouping = FALSE;

  /**
   * {@inheritdoc}
   */
  public function validate() {
    $errors = parent::validate();
    $plugin = $this->displayHandler
      ->getPlugin('row');
    if ($plugin
      ->getPluginId() !== 'views_rss_fields') {
      $errors[] = $this
        ->t('Style %style requires an <em>RSS Feed - Fields</em> row plugin.', array(
        '%style' => $this->definition['title'],
      ));
    }
    return $errors;
  }

  /**
   * {@inheritdoc}
   */
  public function attachTo(array &$build, $display_id, $path, $title) {
    $url_options = array();
    $input = $this->view
      ->getExposedInput();
    if ($input) {
      $url_options['query'] = $input;
    }
    $url_options['absolute'] = TRUE;
    $url = _url($this->view
      ->getUrl(NULL, $path), $url_options);

    // Add the RSS icon to the view.
    $this->view->feedIcons[] = [
      '#theme' => 'feed_icon',
      '#url' => $url,
      '#title' => $title,
    ];

    // Attach a link to the RSS feed, which is an alternate representation.
    $build['#attached']['html_head_link'][][] = array(
      'rel' => 'alternate',
      'type' => 'application/rss+xml',
      'title' => $title,
      'href' => $url,
    );
  }

  /**
   * {@inheritdoc}
   */
  protected function defineOptions() {
    $options = parent::defineOptions();

    // Namespace defaults.
    $namespaces = views_rss_get('namespaces');
    if (count($namespaces)) {
      foreach ($namespaces as $module => $module_namespaces) {
        foreach (array_keys($module_namespaces) as $namespace) {
          $options['namespaces'][$module][$namespace] = array(
            'default' => NULL,
          );
        }
      }
    }
    if (function_exists('rdf_get_namespaces')) {
      $options['namespaces']['add_rdf_namespaces'] = array(
        'default' => FALSE,
      );
    }

    // Channel element defaults.
    $channel_elements = views_rss_get('channel_elements');
    if (count($channel_elements)) {
      foreach ($channel_elements as $module => $module_channel_elements) {
        foreach (array_keys($module_channel_elements) as $element) {
          list($namespace, $element_name) = views_rss_extract_element_names($element, 'core');
          $options['channel'][$namespace][$module][$element_name] = array(
            'default' => NULL,
          );
        }
      }
    }

    // Other feed settings defaults.
    $options['feed_settings']['absolute_paths'] = array(
      'default' => 1,
    );
    $options['feed_settings']['feed_in_links'] = array(
      'default' => 0,
    );
    return $options;
  }

  /**
   * {@inheritdoc}
   */
  public function buildOptionsForm(&$form, FormStateInterface $form_state) {
    parent::buildOptionsForm($form, $form_state);
    $initial_labels = array(
      '' => $this
        ->t('- None -'),
    );
    $view_fields_labels = $this->displayHandler
      ->getFieldLabels();
    $view_fields_labels = array_merge($initial_labels, $view_fields_labels);
    $form['uses_fields']['#type'] = 'hidden';

    // Element groups could be used both in channel and item settings.
    $element_groups = views_rss_get('element_groups');

    // Channel elements settings.
    $channel_elements = views_rss_get('channel_elements');
    if (count($channel_elements)) {
      foreach ($channel_elements as $module => $module_channel_elements) {
        foreach ($module_channel_elements as $element => $definition) {
          if (!isset($definition['configurable']) || $definition['configurable']) {
            list($namespace, $element_name) = views_rss_extract_element_names($element, 'core');

            // Add fieldset for namespace if not yet added.
            if (!isset($form['channel'][$namespace])) {
              $form['channel'][$namespace] = array(
                '#type' => 'details',
                '#title' => t('Channel elements : @namespace', array(
                  '@namespace' => $namespace,
                )),
                '#description' => t('Provide values for &lt;channel&gt; elements in "@namespace" namespace. See <a href="@guide_url">Views RSS documentation</a> for more information.', array(
                  '@namespace' => $namespace,
                  '@guide_url' => Url::fromUri('http://drupal.org/node/1344136'),
                )),
                '#open' => FALSE,
              );
            }

            // Prepare form element.
            $default_value = NULL;
            if (!empty($this->options['channel'][$namespace][$module][$element_name])) {
              $default_value = $this->options['channel'][$namespace][$module][$element_name];
            }
            $form_item = array(
              '#type' => 'textfield',
              '#title' => Xss::filter(isset($definition['title']) ? $definition['title'] : $element_name),
              '#description' => Xss::filter(isset($definition['description']) ? $definition['description'] : NULL),
              '#default_value' => $default_value,
            );

            // Allow to overwrite default form element.
            if (!empty($definition['settings form'])) {
              $form_item = array_merge($form_item, $definition['settings form']);

              // Make sure that #options is an associative array.
              if (!empty($definition['settings form']['#options'])) {
                $form_item['#options'] = views_rss_map_assoc($definition['settings form']['#options']);
              }
            }
            if (!empty($definition['settings form options callback'])) {
              $function = $definition['settings form options callback'];
              $form_item['#options'] = views_rss_map_assoc($function());
            }

            // Add help link if provided.
            if (!empty($definition['help'])) {
              $form_item['#description'] .= ' ' . \Drupal::l('[?]', Url::fromUri($definition['help']), array(
                'attributes' => array(
                  'title' => t('Need more information?'),
                ),
              ));
            }

            // Check if element should be displayed in a subgroup.
            if (!empty($definition['group'])) {

              // Add a subgroup to the form if it not yet added.
              if (!isset($form['channel'][$namespace][$module][$definition['group']])) {

                // Does module provide the group definition?
                $group_title = !empty($element_groups[$module][$definition['group']]['title']) ? $element_groups[$module][$definition['group']]['title'] : $definition['group'];
                $group_description = !empty($element_groups[$module][$definition['group']]['description']) ? $element_groups[$module][$definition['group']]['description'] : NULL;
                $form['channel'][$namespace][$module][$definition['group']] = array(
                  '#type' => 'fieldset',
                  '#title' => Xss::filter($group_title),
                  '#description' => Xss::filter($group_description),
                  '#collapsible' => TRUE,
                  '#collapsed' => TRUE,
                );
              }
              $form['channel'][$namespace][$module][$definition['group']][$element_name] = $form_item;
            }
            else {
              $form['channel'][$namespace][$module][$element_name] = $form_item;
            }
          }
        }
      }
    }
    $form['namespaces'] = array(
      '#type' => 'details',
      '#title' => $this
        ->t('Namespaces'),
      '#open' => FALSE,
    );
    if (function_exists('rdf_get_namespaces')) {
      $form['namespaces']['add_rdf_namespaces'] = array(
        '#type' => 'checkbox',
        '#title' => $this
          ->t('Merge RDF namespaces'),
        '#description' => $this
          ->t('Enabling this option will merge RDF namespaces into the XML namespaces in case they are used in the RSS content.'),
        '#default_value' => $this->options['namespaces']['add_rdf_namespaces'],
      );
    }

    // Undefined namespaces derived from <channel> and/or <item>
    // elements defined by extension modules.
    $namespaces = views_rss_get('namespaces');
    if (count($namespaces)) {
      foreach ($namespaces as $module => $module_namespaces) {
        foreach ($module_namespaces as $namespace => $definition) {
          if (empty($definition['uri'])) {

            // Add fieldset for namespace if not yet added.
            if (!isset($form['namespaces'])) {
              $form['namespaces']['#description'] = t('Enter missing URLs for namespaces derived from &lt;channel&gt; and/or &lt;item&gt; elements defined by extension modules.');
            }
            if (!empty($this->options['namespaces'][$module][$namespace])) {
              $default_value = $this->options['namespaces'][$module][$namespace];
            }
            else {
              $default_value = NULL;
            }
            $form['namespaces'][$module][$namespace] = array(
              '#type' => 'textfield',
              '#title' => check_plain($namespace),
              '#default_value' => $default_value,
            );
          }
        }
      }
    }

    // Other feed settings.
    $form['feed_settings'] = array(
      '#type' => 'details',
      '#title' => $this
        ->t('Other feed settings'),
      '#open' => FALSE,
    );
    $form['feed_settings']['absolute_paths'] = array(
      '#type' => 'checkbox',
      '#title' => $this
        ->t("Replace relative paths with absolute URLs"),
      '#description' => $this
        ->t('Enabling this option will replace all relative paths (like <em>/node/1</em>) with absolute URLs (<em>!absolute_url</em>) in all feed elements configured to use this feature (for example &lt;description&gt; element).', array(
        '!absolute_url' => trim($GLOBALS['base_url'], '/') . '/node/1',
      )),
      '#default_value' => !empty($this->options['feed_settings']['absolute_paths']),
      '#weight' => 1,
    );
    $form['feed_settings']['feed_in_links'] = array(
      '#type' => 'checkbox',
      '#title' => $this
        ->t('Display feed icon in the links attached to the view'),
      '#default_value' => !empty($this->options['feed_settings']['feed_in_links']),
      '#weight' => 3,
    );
  }
  public function validateOptionsForm(&$form, FormStateInterface $form_state) {
    parent::validateOptionsForm($form, $form_state);
    $hook = 'views_rss_options_form_validate';
    $modules = \Drupal::moduleHandler()
      ->getImplementations($hook);
    foreach ($modules as $module) {
      \Drupal::moduleHandler()
        ->invoke($module, $hook, array(
        $form,
        $form_state,
      ));
    }
  }
  public function submitOptionsForm(&$form, FormStateInterface $form_state) {
    parent::submitOptionsForm($form, $form_state);
    $hook = 'views_rss_options_form_submit';
    $modules = \Drupal::moduleHandler()
      ->getImplementations($hook);
    foreach ($modules as $module) {
      \Drupal::moduleHandler()
        ->invoke($module, $hook, array(
        $form,
        $form_state,
      ));
    }
  }

  /**
   * Return an array of additional XHTML elements to add to the channel.
   *
   * @return
   *   An array that can be passed to format_xml_elements().
   */
  protected function getChannelElements() {
    $elements = array();
    foreach (views_rss_get('channel_elements') as $module => $module_channel_elements) {
      foreach ($module_channel_elements as $element => $definition) {
        list($element_namespace, $element_name) = views_rss_extract_element_names($element, 'core');

        // Try to fetch namespace value from view configuration.
        if (isset($this->options['channel'][$element_namespace][$module][$element_name])) {
          $element_value = $this->options['channel'][$element_namespace][$module][$element_name];
        }
        elseif (isset($definition['default_value'])) {
          $element_value = $definition['default_value'];
        }
        else {
          $element_value = NULL;
        }

        // Start building XML channel element array compatible with
        // format_xml_elements().
        $rss_element = array(
          'key' => $element,
          'value' => $element_value,
        );
        if (!empty($element_namespace) && $element_namespace != 'core') {
          $rss_element['namespace'] = $element_namespace;
        }

        // It might happen than a preprocess function will need to split one
        // element into multiple ones - this will for example happen for channel
        // <category> element, if multiple categories were provided (separated
        // by a comma) - they will need to be printed as multiple <category>
        // elements - therefore we need to work on array of RSS elements here.
        $rss_elements = array(
          $rss_element,
        );

        // Preprocess element value.
        if (isset($definition['preprocess functions']) && is_array($definition['preprocess functions'])) {
          foreach ($definition['preprocess functions'] as $preprocess_function) {
            if (function_exists($preprocess_function)) {
              $item_variables = array(
                'elements' => &$rss_elements,
                'item' => $this->options['channel'],
                'view' => $this->view,
              );
              $preprocess_function($item_variables);
            }
          }
        }
        foreach ($rss_elements as $rss_element) {
          if (!empty($rss_element['value']) || !empty($rss_element['attributes'])) {
            $elements[] = $rss_element;
          }
        }
      }
    }
    return $elements;
  }

  /**
   * Get RSS feed description.
   *
   * @return string
   *   The string containing the description with the tokens replaced.
   */
  public function getDescription() {
    $description = $this->options['description'];

    // Allow substitutions from the first row.
    $description = $this
      ->tokenizeValue($description, 0);
    return $description;
  }
  protected function getNamespaces() {
    $namespaces = array();
    foreach (views_rss_get('namespaces') as $module => $module_namespaces) {
      foreach ($module_namespaces as $namespace => $definition) {

        // Check if definition provided through modules hooks
        // should be overwritten by module configuration.
        if (isset($this->options['namespaces'][$module][$namespace]) && !empty($this->options['namespaces'][$module][$namespace])) {
          $definition['uri'] = $this->options['namespaces'][$module][$namespace];
        }

        // Add namespace to feed array.
        if (!empty($definition['uri'])) {

          // Namespaces with prefix, for example xml:base="" or xmlns:dc=""
          if (!empty($definition['prefix'])) {
            $namespace_key = $definition['prefix'] . ':' . $namespace;
            $namespaces[$namespace_key] = $definition['uri'];
          }
          else {
            $namespaces[$namespace] = $definition['uri'];
          }
        }
      }
    }
    return $namespaces;
  }

  /**
   * {@inheritdoc}
   */
  public function render() {
    $rows = '';
    $this->namespaces = $this
      ->getNamespaces();

    // Fetch any additional elements for the channel and merge in their
    // namespaces.
    $this->channel_elements = $this
      ->getChannelElements();
    foreach ($this->view->result as $row_index => $row) {
      $this->view->row_index = $row_index;
      $rows .= $this->view->rowPlugin
        ->render($row);
    }
    $build = array(
      '#theme' => $this
        ->themeFunctions(),
      '#view' => $this->view,
      '#options' => $this->options,
      '#rows' => $rows,
    );
    unset($this->view->row_index);
    return $build;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
DependencySerializationTrait::$_entityStorages protected property An array of entity type IDs keyed by the property name of their storages.
DependencySerializationTrait::$_serviceIds protected property An array of service IDs keyed by property name used for serialization.
DependencySerializationTrait::__sleep public function 1
DependencySerializationTrait::__wakeup public function 2
MessengerTrait::$messenger protected property The messenger. 29
MessengerTrait::messenger public function Gets the messenger. 29
MessengerTrait::setMessenger public function Sets the messenger.
PluginBase::$configuration protected property Configuration information passed into the plugin. 1
PluginBase::$definition public property Plugins's 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::$pluginDefinition protected property The plugin implementation definition. 1
PluginBase::$pluginId protected property The plugin_id.
PluginBase::$renderer protected property Stores the render API renderer. 3
PluginBase::$view public property The top object of a view. 1
PluginBase::calculateDependencies public function Calculates dependencies for the configured plugin. Overrides DependentPluginInterface::calculateDependencies 14
PluginBase::create public static function Creates an instance of the plugin. Overrides ContainerFactoryPluginInterface::create 62
PluginBase::DERIVATIVE_SEPARATOR constant A string which is used to separate base plugin IDs from the derivative ID.
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::getBaseId public function Gets the base_plugin_id of the plugin instance. Overrides DerivativeInspectionInterface::getBaseId
PluginBase::getDerivativeId public function Gets the derivative_id of the plugin instance. Overrides DerivativeInspectionInterface::getDerivativeId
PluginBase::getPluginDefinition public function Gets the definition of the plugin implementation. Overrides PluginInspectionInterface::getPluginDefinition 3
PluginBase::getPluginId public function Gets the plugin_id of the plugin instance. Overrides PluginInspectionInterface::getPluginId
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::isConfigurable public function Determines if the plugin is configurable.
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 Unpack options over our existing defaults, drilling down into arrays so that defaults don't get totally blown away. Overrides ViewsPluginInterface::unpackOptions
PluginBase::usesOptions public function Returns the usesOptions property. Overrides ViewsPluginInterface::usesOptions 8
PluginBase::viewsTokenReplace protected function Replaces Views' tokens in a given string. The resulting string will be sanitized with Xss::filterAdmin. 1
PluginBase::VIEWS_QUERY_LANGUAGE_SITE_DEFAULT constant Query string to indicate the site default language.
PluginBase::__construct public function Constructs a PluginBase object. Overrides PluginBase::__construct
RssFields::$usesGrouping protected property Does the style plugin support grouping of rows. Overrides StylePluginBase::$usesGrouping
RssFields::$usesRowPlugin protected property Does the style plugin for itself support to add fields to it's output. Overrides StylePluginBase::$usesRowPlugin
RssFields::attachTo public function
RssFields::buildOptionsForm public function Provide a form to edit options for this plugin. Overrides StylePluginBase::buildOptionsForm
RssFields::defineOptions protected function Information about options for all kinds of purposes will be held here. Overrides StylePluginBase::defineOptions
RssFields::getChannelElements protected function Return an array of additional XHTML elements to add to the channel.
RssFields::getDescription public function Get RSS feed description.
RssFields::getNamespaces protected function
RssFields::render public function Render the display in this style. Overrides StylePluginBase::render
RssFields::submitOptionsForm public function Handle any special handling on the validate form. Overrides PluginBase::submitOptionsForm
RssFields::validate public function Validate that the plugin is correct and can be saved. Overrides StylePluginBase::validate
RssFields::validateOptionsForm public function Validate the options form. Overrides StylePluginBase::validateOptionsForm
StringTranslationTrait::$stringTranslation protected property The string translation service. 1
StringTranslationTrait::formatPlural protected function Formats a string containing a count of items.
StringTranslationTrait::getNumberOfPlurals protected function Returns the number of plurals supported by a given language.
StringTranslationTrait::getStringTranslation protected function Gets the string translation service.
StringTranslationTrait::setStringTranslation public function Sets the string translation service to use. 2
StringTranslationTrait::t protected function Translates a string to the current language or to a given language.
StylePluginBase::$defaultFieldLabels protected property Should field labels be enabled by default. 1
StylePluginBase::$groupingTheme protected property The theme function used to render the grouping set.
StylePluginBase::$rendered_fields protected property Stores the rendered field values, keyed by the row index and field name.
StylePluginBase::$rowTokens protected property Store all available tokens row rows.
StylePluginBase::$usesFields protected property Does the style plugin for itself support to add fields to its output. 3
StylePluginBase::$usesOptions protected property Denotes whether the plugin has an additional options form. Overrides PluginBase::$usesOptions
StylePluginBase::$usesRowClass protected property Does the style plugin support custom css class for the rows. 3
StylePluginBase::buildSort public function Called by the view builder to see if this style handler wants to interfere with the sorts. If so it should build; if it returns any non-TRUE value, normal sorting will NOT be added to the query. 1
StylePluginBase::buildSortPost public function Called by the view builder to let the style build a second set of sorts that will come after any other sorts in the view. 1
StylePluginBase::defaultFieldLabels public function Return TRUE if this style enables field labels by default. 1
StylePluginBase::destroy public function Clears a plugin. Overrides PluginBase::destroy
StylePluginBase::elementPreRenderRow public function #pre_render callback for view row field rendering.
StylePluginBase::evenEmpty public function Should the output of the style plugin be rendered even if it's a empty view. 2
StylePluginBase::getField public function Gets a rendered field.
StylePluginBase::getFieldValue public function Get the raw field value.
StylePluginBase::getRowClass public function Return the token replaced row class for the specified row.
StylePluginBase::init public function Overrides \Drupal\views\Plugin\views\PluginBase::init(). Overrides PluginBase::init
StylePluginBase::preRender public function Allow the style to do stuff before each row is rendered.
StylePluginBase::query public function Add anything to the query that we might need to. Overrides PluginBase::query 1
StylePluginBase::renderFields protected function Renders all of the fields for a given style and store them on the object.
StylePluginBase::renderGrouping public function Group records as needed for rendering.
StylePluginBase::renderGroupingSets public function Render the grouping sets.
StylePluginBase::renderRowGroup protected function Renders a group of rows of the grouped view.
StylePluginBase::tokenizeValue public function Take a value and apply token replacement logic to it.
StylePluginBase::trustedCallbacks public static function Lists the trusted callbacks provided by the implementing class. Overrides PluginBase::trustedCallbacks
StylePluginBase::usesFields public function Return TRUE if this style also uses fields. 3
StylePluginBase::usesGrouping public function Returns the usesGrouping property. 3
StylePluginBase::usesRowClass public function Returns the usesRowClass property. 3
StylePluginBase::usesRowPlugin public function Returns the usesRowPlugin property. 10
StylePluginBase::usesTokens public function Return TRUE if this style uses tokens.
StylePluginBase::wizardForm public function Provide a form in the views wizard if this style is selected.
StylePluginBase::wizardSubmit public function Alter the options of a display before they are added to the view. 1
TrustedCallbackInterface::THROW_EXCEPTION constant Untrusted callbacks throw exceptions.
TrustedCallbackInterface::TRIGGER_SILENCED_DEPRECATION constant Untrusted callbacks trigger silenced E_USER_DEPRECATION errors.
TrustedCallbackInterface::TRIGGER_WARNING constant Untrusted callbacks trigger E_USER_WARNING errors.