Permissions

Constructs a Permissions object.

Gets the plugin_id of the plugin instance.

Gets the base_plugin_id of the plugin instance.

Gets the derivative_id of the plugin instance.

Gets the definition of the plugin implementation.

Determines if the plugin is configurable.

Translates a string to the current language or to a given language.

See \Drupal\Core\StringTranslation\TranslatableMarkup::__construct() for important security information and usage guidelines.

In order for strings to be localized, make them available in one of the ways supported by the

Formats a string containing a count of items.

Returns the number of plurals supported by a given language.

Gets the string translation service.

Sets the string translation service to use.

{@inheritdoc}

{@inheritdoc}

Sets the messenger.

Gets the messenger.

Creates an instance of the plugin.

Overrides \Drupal\views\Plugin\views\HandlerBase::init().

Provide some extra help to get the operator/value easier to use.

This likely has to be overridden by filters which are more complex than simple operator/value.

Information about options for all kinds of purposes will be held here.

Fills up the options of the plugin with defaults.

Filter out stored options depending on the defined options.

Do the work to filter out stored options depending on the defined options.

Unpack options over our existing defaults, drilling down into arrays so that defaults don't get totally blown away.

Clears a plugin.

Provide the basic form which calls through to subforms.

If overridden, it is best to call through to the parent, or to at least make sure all of the functions in this form are called.

Lists the trusted callbacks provided by the implementing class.

Trusted callbacks are public methods on the implementing class and can be invoked via \Drupal\Core\Security\DoTrustedCallbackTrait::doTrustedCallback().

Simple validate handler.

Simple submit handler.

Add this filter to the query.

Due to the nature of fapi, the value and the operator have an unintended level of indirection. You will find them in $this->operator and $this->value respectively.

Provide a full list of possible theme templates used by this style.

Validate that the plugin is correct and can be saved.

Returns the summary of the settings in the display.

Return the human readable name of the display.

This appears on the ui beside each plugin and beside the settings link.

Returns the usesOptions property.

Returns a string with any core tokens replaced.

Replaces Views' tokens in a given string. The resulting string will be sanitized with Xss::filterAdmin.

Returns an array of available token replacements.

Adds elements for available core tokens to a form.

Moves form elements into fieldsets for presentation purposes.

Many views forms use #tree = TRUE to keep their values in a hierarchy for easier storage. Moving the form elements into fieldsets during form building would break up that hierarchy. Therefore, we wait until the pre_render stage, where any changes we make affect presentation only and aren't reflected in $form_state->getValues().

Flattens the structure of form elements.

If a form element has #flatten = TRUE, then all of its children get moved to the same level as the element itself. So $form['to_be_flattened'][$key] becomes $form[$key], and $form['to_be_flattened'] gets unset.

Calculates dependencies for the configured plugin.

Dependencies are saved in the plugin's configuration entity and are used to determine configuration synchronization order. For example, if the plugin integrates with specific user roles, this method should return an array of dependencies listing the specified roles.

Returns the plugin provider.

Makes an array of languages, optionally including special languages.

Returns substitutions for Views queries for languages.

This is needed so that the language options returned by PluginBase::listLanguages() are able to be used in queries. It is called by the Views module implementation of hook_views_query_substitutions() to get the language-related substitutions.

Returns the render API renderer.

Return a string representing this handler's name in the UI.

Shortcut to get a handler's raw field value.

This should be overridden for handlers with formulae or other non-standard fields. Because this takes an argument, fields overriding this can just call return parent::getField($formula)

Sanitize the value for output.

Transform a string by a certain method.

Gets the module handler.

Sets the module handler.

Provides the handler some groupby.

Provide a form for aggregation settings.

Perform any necessary changes to the form values prior to storage.

There is no need for this function to actually store the data.

If a handler has 'extra options' it will get a little settings widget and another form called extra_options.

Provide defaults for the handler.

Provide a form for setting options.

Validate the options form.

Perform any necessary changes to the form values prior to storage.

There is no need for this function to actually store the data.

Determine if a filter can be exposed.

Provide default options for exposed filters.

Tell the renderer about our exposed form. This only needs to be overridden for particularly complex forms. And maybe not even then.

Render our chunk of the exposed filter form when selecting.

You can override this if it doesn't do what you expect.

Validate the exposed handler form.

Submit the exposed handler form.

Options form subform for exposed filter options.

Validate the options form.

Perform any necessary changes to the form exposes prior to storage.

There is no need for this function to actually store the data.

Shortcut to display the expose/hide button.

Shortcut to display the exposed options form.

Check whether given user has access to this handler.

Run before the view is built.

This gives all the handlers some time to set up before any handler has been fully run.

Run after the view is executed, before the result is cached.

This gives all the handlers some time to modify values. This is primarily used so that handlers that pull up secondary data can put it in the $values so that the raw data can be used externally.

Provides a unique placeholders for handlers.

Called just prior to query(), this lets a handler set up any relationship it needs.

Override ensureMyTable so we can control how this joins in.

The operator actually has influence over joining.

Display the filter on the administrative summary.

Determine if this item is 'exposed', meaning it provides form elements to let users modify the view.

Returns TRUE if the exposed filter works like a grouped filter.

Returns TRUE if users can select multiple groups items of a grouped exposed filter.

Determines if the input from a filter should change the generated query.

If set to remember exposed input in the session, store it there.

Get the join object that should be used for this handler.

This method isn't used a great deal, but it's very handy for easily getting the join if it is necessary to make some changes to it, such as adding an 'extra'.

Determines if the handler is considered 'broken', meaning it's a placeholder used when a handler can't be found.

Creates cross-database SQL date formatting.

Creates cross-database SQL dates.

Gets views data service.

{@inheritdoc}

Fetches a handler to join one table to a primary table from the data cache.

Determines the entity type used by this handler.

If this handler uses a relationship, the base class of the relationship is taken into account.

Breaks x,y,z and x+y+z into an array.

Displays the Expose form.

A submit handler that is used for storing temporary items when using multi-step changes, such as ajax requests.

Calculates options stored on the handler.

Determine if a filter can be converted into a group.

Only exposed filters with operators available can be converted into groups.

Shortcut to display the operator form.

Options form subform for setting the operator.

This may be overridden by child classes, and it must define $form['operator'];

Build strings from the operators() for 'select' options.

Validate the operator form.

Perform any necessary changes to the form values prior to storage.

There is no need for this function to actually store the data.

Shortcut to display the value form.

Options form subform for setting options.

This should be overridden by all child classes and it must define $form['value']

Validate the options form.

Perform any necessary changes to the form values prior to storage.

There is no need for this function to actually store the data.

Shortcut to display the exposed options form.

Shortcut to display the build_group/hide button.

Displays the Build Group form.

Determines if the given grouped filter entry has a valid value.

Validate the build group options form.

Validates a filter identifier.

Sets the form error if $form_state is passed or an error string if $form_state is not passed.

Save new group items, re-enumerates and remove groups marked to delete.

Provide default options for exposed filters.

Build a form containing a group of operator | values to apply as a single filter.

Builds wrapper for value and operator forms.

Build the form to let users create the group of exposed filters.

This form is displayed when users click on button 'Build group'.

Add a new group to the exposed filter groups.

Make some translations to a form item to make it more suitable to exposing.

Sanitizes the HTML select element's options.

The function is recursive to support optgroups.

Transform the input from a grouped filter into a standard filter.

When a filter is a group, find the set of operator and values that the chosen item represents, and inform views that a normal filter was submitted by telling the operator and the value selected.

The param $selected_group_id is only passed when the filter uses the checkboxes widget, and this function will be called for each item chosen in the checkboxes.

Returns the options available for a grouped filter that users checkboxes as widget, and therefore has to be applied several times, one per item selected.

If set to remember exposed input in the session, store it there.

This function is similar to storeExposedInput but modified to work properly when the filter is a group.

Can this filter be used in OR groups?

Some filters have complicated where clauses that cannot be easily used with OR groups. Some filters must also use HAVING which also makes them not groupable. These filters will end up in a special group if OR grouping is in use.

The maximum age for which this object may be cached.

The cache contexts associated with this object.

These identify a specific variation/representation of the object.

Cache contexts are tokens: placeholders that are converted to cache keys by the @cache_contexts_manager service. The replacement value depends on the request context (the current URL, language, and so on). They're converted before storing an object in cache.

The cache tags associated with this object.

When this object is modified, these cache tags will be invalidated.

Filter by no empty values, though allow the use of (string) "0".

Child classes should be used to override this function and set the 'value options', unless 'options callback' is defined as a valid function or static public method to generate these values.

This can use a guard to be used to reduce database hits as much as possible.

This kind of construct makes it relatively easy for a child class to add or remove functionality by overriding this function and adding/removing items from this array.

No description

When using exposed filters, we may be required to reduce the set.

No description

No description

No description