Newer
Older
Angie Byron
committed
<?php
/**
* @file
* Attach custom data fields to Drupal entities.
Angie Byron
committed
*/
Alex Pott
committed
use Drupal\Component\Utility\Html;
use Drupal\Component\Utility\Xss;
use Drupal\Core\Entity\EntityTypeInterface;
use Drupal\Core\Extension\Extension;
use Drupal\field\Field;
/*
Dries Buytaert
committed
* Load all public Field API functions. Drupal currently has no
* mechanism for auto-loading core APIs, so we have to load them on
* every page request.
*/
require_once __DIR__ . '/field.info.inc';
require_once __DIR__ . '/field.form.inc';
require_once __DIR__ . '/field.purge.inc';
require_once __DIR__ . '/field.deprecated.inc';
Angie Byron
committed
/**
* @defgroup field Field API
* @{
Jennifer Hodgdon
committed
* Attaches custom data fields to Drupal entities.
*
* The Field API allows custom data fields to be attached to Drupal entities and
* takes care of storing, loading, editing, and rendering field data. Any entity
* type (node, user, etc.) can use the Field API to make itself "fieldable" and
* thus allow fields to be attached to it. Other modules can provide a user
* interface for managing custom fields via a web browser as well as a wide and
* flexible variety of data type, form element, and display format capabilities.
Angie Byron
committed
*
Jennifer Hodgdon
committed
* The Field API defines two primary data structures, Field and Instance, and
* the concept of a Bundle. A Field defines a particular type of data that can
* be attached to entities. A Field Instance is a Field attached to a single
* Bundle. A Bundle is a set of fields that are treated as a group by the Field
* Attach API and is related to a single fieldable entity type.
*
* For example, suppose a site administrator wants Article nodes to have a
* subtitle and photo. Using the Field API or Field UI module, the administrator
* creates a field named 'subtitle' of type 'text' and a field named 'photo' of
* type 'image'. The administrator (again, via a UI) creates two Field
* Instances, one attaching the field 'subtitle' to the 'node' bundle 'article'
* and one attaching the field 'photo' to the 'node' bundle 'article'. When the
catch
committed
* node storage loads an Article node, it loads the values of the
Jennifer Hodgdon
committed
* 'subtitle' and 'photo' fields because they are both attached to the 'node'
* bundle 'article'.
Jennifer Hodgdon
committed
* - @link field_types Field Types API @endlink: Defines field types, widget
* types, and display formatters. Field modules use this API to provide field
* types like Text and Node Reference along with the associated form elements
* and display formatters.
*
* - @link field_crud Field CRUD API @endlink: Create, updates, and deletes
* fields, bundles (a.k.a. "content types"), and instances. Modules use this
* API, often in hook_install(), to create custom data structures.
*
* - @link field_attach Field Attach API @endlink: Connects entity types to the
* Field API. Field Attach API functions load, store, generate Form API
* structures, display, and perform a variety of other functions for field
* data connected to individual entities. Fieldable entity types like node and
* user use this API to make themselves fieldable.
*
* - @link field_info Field Info API @endlink: Exposes information about all
* fields, instances, widgets, and related information defined by or with the
* Field API.
*
* - @link field_purge Field API bulk data deletion @endlink: Cleans up after
Dries Buytaert
committed
* bulk deletion operations such as deletion of field or field_instance.
Jennifer Hodgdon
committed
*
* - @link field_language Field language API @endlink: Provides native
* multilingual support for the Field API.
Angie Byron
committed
*/
/**
Dries Buytaert
committed
* Implements hook_help().
Angie Byron
committed
*/
function field_help($path, $arg) {
switch ($path) {
case 'admin/help#field':
$output = '';
$output .= '<h3>' . t('About') . '</h3>';
$output .= '<p>' . t('The Field module allows custom data fields to be defined for <em>entity</em> types (entities include content items, comments, user accounts, and taxonomy terms). The Field module takes care of storing, loading, editing, and rendering field data. Most users will not interact with the Field module directly, but will instead use the <a href="@field-ui-help">Field UI module</a> user interface. Module developers can use the Field API to make new entity types "fieldable" and thus allow fields to be attached to them. For more information, see the online handbook entry for <a href="@field">Field module</a>.', array('@field-ui-help' => url('admin/help/field_ui'), '@field' => 'http://drupal.org/documentation/modules/field')) . '</p>';
$output .= '<h3>' . t('Uses') . '</h3>';
$output .= '<dl>';
$output .= '<dt>' . t('Enabling field types') . '</dt>';
$output .= '<dd>' . t('The Field module provides the infrastructure for fields and field attachment; the field types and input widgets themselves are provided by additional modules. The modules can be enabled from the <a href="@modules">Modules administration page</a>. Drupal core includes the following field type modules: Text, Number, Email, Link, Telephone, Image, File, Options, Taxonomy, and Entity Reference. Additional fields and widgets may be provided by contributed modules, which you can find in the <a href="@contrib">contributed module section of Drupal.org</a>.', array('@modules' => url('admin/modules'), '@contrib' => 'http://drupal.org/project/modules', '@options' => url('admin/help/options')));
Angie Byron
committed
Angie Byron
committed
// Make a list of all widget and field modules currently enabled, ordered
// by displayed module name (module names are not translated).
Angie Byron
committed
$items = array();
$info = system_get_info('module');
Angie Byron
committed
$field_widgets = \Drupal::service('plugin.manager.field.widget')->getDefinitions();
Angie Byron
committed
$field_types = \Drupal::service('plugin.manager.field.field_type')->getUiDefinitions();
$providers = array();
Alex Pott
committed
foreach (array_merge($field_types, $field_widgets) as $plugin) {
$providers[] = $plugin['provider'];
Angie Byron
committed
}
Alex Pott
committed
$providers = array_unique($providers);
sort($providers);
foreach ($providers as $provider) {
// Skip plugins provided by core components as they do not implement
// hook_help().
if (isset($info[$provider]['name'])) {
$display = $info[$provider]['name'];
if (\Drupal::moduleHandler()->implementsHook($provider, 'help')) {
$items[] = l($display, 'admin/help/' . $provider);
}
else {
$items[] = $display;
}
Angie Byron
committed
}
}
if ($items) {
$output .= ' ' . t('Currently enabled field and input widget modules:');
$item_list = array(
'#theme' => 'item_list',
'#items' => $items,
);
$output .= drupal_render($item_list);
}
Angie Byron
committed
return $output;
}
}
Dries Buytaert
committed
/**
Dries Buytaert
committed
* Implements hook_cron().
Dries Buytaert
committed
*/
function field_cron() {
Dries Buytaert
committed
// Do a pass of purging on deleted Field API data, if any exists.
$limit = \Drupal::config('field.settings')->get('purge_batch_size');
Dries Buytaert
committed
field_purge_batch($limit);
}
Angie Byron
committed
/**
Angie Byron
committed
* Implements hook_system_info_alter().
*
Jennifer Hodgdon
committed
* Goes through a list of all modules that provide a field type and makes them
Angie Byron
committed
* required if there are any active fields of that type.
Angie Byron
committed
*/
function field_system_info_alter(&$info, Extension $file, $type) {
// It is not safe to call entity_load_multiple_by_properties() during
// maintenance mode.
if ($type == 'module' && !defined('MAINTENANCE_MODE')) {
$fields = entity_load_multiple_by_properties('field_config', array('module' => $file->getName(), 'include_deleted' => TRUE));
Angie Byron
committed
if ($fields) {
$info['required'] = TRUE;
// Provide an explanation message (only mention pending deletions if there
// remains no actual, non-deleted fields)
$non_deleted = FALSE;
foreach ($fields as $field) {
Alex Pott
committed
if (empty($field->deleted)) {
Angie Byron
committed
$non_deleted = TRUE;
break;
}
}
if ($non_deleted) {
if (\Drupal::moduleHandler()->moduleExists('field_ui')) {
Dries Buytaert
committed
$explanation = t('Field type(s) in use - see <a href="@fields-page">Field list</a>', array('@fields-page' => url('admin/reports/fields')));
Angie Byron
committed
}
else {
$explanation = t('Fields type(s) in use');
}
}
else {
$explanation = t('Fields pending deletion');
}
$info['explanation'] = $explanation;
}
Angie Byron
committed
}
}
Dries Buytaert
committed
/**
* Implements hook_entity_bundle_field_info().
Dries Buytaert
committed
*/
function field_entity_bundle_field_info(EntityTypeInterface $entity_type, $bundle, array $base_field_definitions) {
if ($entity_type->isFieldable()) {
// Configurable fields, which are always attached to a specific bundle, are
// added 'by bundle'.
return Field::fieldInfo()->getBundleInstances($entity_type->id(), $bundle);
Dries Buytaert
committed
}
}
Angie Byron
committed
/**
* Implements hook_entity_bundle_create().
Angie Byron
committed
*/
function field_entity_bundle_create($entity_type, $bundle) {
// Clear the cache.
field_cache_clear();
}
Angie Byron
committed
/**
* Implements hook_entity_bundle_rename().
*/
function field_entity_bundle_rename($entity_type, $bundle_old, $bundle_new) {
$instances = entity_load_multiple_by_properties('field_instance_config', array('entity_type' => $entity_type, 'bundle' => $bundle_old));
foreach ($instances as $instance) {
if ($instance->entity_type == $entity_type && $instance->bundle == $bundle_old) {
$id_new = $instance->entity_type . '.' . $bundle_new . '.' . $instance->field_name;
Angie Byron
committed
$instance->set('id', $id_new);
$instance->bundle = $bundle_new;
$instance->allowBundleRename();
$instance->save();
Angie Byron
committed
}
}
// Clear the field cache.
field_cache_clear();
}
/**
* Implements hook_entity_bundle_delete().
*
* This deletes the data for the field instances as well as the field instances
* themselves. This function actually just marks the data and field instances as
* deleted, leaving the garbage collection for a separate process, because it is
* not always possible to delete this much data in a single page request
* (particularly since for some field types, the deletion is more than just a
* simple DELETE query).
*/
function field_entity_bundle_delete($entity_type, $bundle) {
// Get the instances on the bundle. entity_load_multiple_by_properties() must
// be used here since field_info_instances() does not return instances for
// disabled entity types or bundles.
$instances = entity_load_multiple_by_properties('field_instance_config', array('entity_type' => $entity_type, 'bundle' => $bundle));
foreach ($instances as $instance) {
$instance->delete();
}
// Clear the cache.
field_cache_clear();
Angie Byron
committed
}
/**
* Implements hook_rebuild().
*/
function field_rebuild() {
field_cache_clear();
Angie Byron
committed
}
Dries Buytaert
committed
/**
Dries Buytaert
committed
* Implements hook_modules_installed().
Dries Buytaert
committed
*/
Dries Buytaert
committed
function field_modules_installed($modules) {
field_cache_clear();
Dries Buytaert
committed
}
/**
Dries Buytaert
committed
* Implements hook_modules_uninstalled().
Dries Buytaert
committed
*/
Dries Buytaert
committed
function field_modules_uninstalled($modules) {
Alex Pott
committed
field_cache_clear();
Angie Byron
committed
}
/**
Jennifer Hodgdon
committed
* Clears the field info and field data caches.
Angie Byron
committed
*/
function field_cache_clear() {
\Drupal::cache('entity')->deleteAll();
Dries Buytaert
committed
field_info_cache_clear();
Angie Byron
committed
}
/**
Jennifer Hodgdon
committed
* Filters an HTML string to prevent cross-site-scripting (XSS) vulnerabilities.
*
Angie Byron
committed
* Like \Drupal\Component\Utility\Xss::filterAdmin(), but with a shorter list
* of allowed tags.
Angie Byron
committed
*
Jennifer Hodgdon
committed
* Used for items entered by administrators, like field descriptions, allowed
* values, where some (mainly inline) mark-up may be desired (so
* drupal_htmlspecialchars() is not acceptable).
*
* @param $string
* The string with raw HTML in it.
*
* @return
* An XSS safe version of $string, or an empty string if $string is not valid
* UTF-8.
Angie Byron
committed
*/
function field_filter_xss($string) {
Alex Pott
committed
return Html::normalize(Xss::filter($string, _field_filter_xss_allowed_tags()));
Angie Byron
committed
}
/**
Jennifer Hodgdon
committed
* Returns a list of tags allowed by field_filter_xss().
Angie Byron
committed
*/
function _field_filter_xss_allowed_tags() {
return array('a', 'b', 'big', 'code', 'del', 'em', 'i', 'ins', 'pre', 'q', 'small', 'span', 'strong', 'sub', 'sup', 'tt', 'ol', 'ul', 'li', 'p', 'br', 'img');
}
/**
Jennifer Hodgdon
committed
* Returns a human-readable list of allowed tags for display in help texts.
Angie Byron
committed
*/
function _field_filter_xss_display_allowed_tags() {
return '<' . implode('> <', _field_filter_xss_allowed_tags()) . '>';
}
/**
* @} End of "defgroup field".
*/
Dries Buytaert
committed
Angie Byron
committed
/**
* Assembles a partial entity structure with initial IDs.
*
Jennifer Hodgdon
committed
* @param object $ids
Angie Byron
committed
* An object with the properties entity_type (required), entity_id (required),
* revision_id (optional) and bundle (optional).
*
* @return \Drupal\Core\Entity\EntityInterface
Angie Byron
committed
* An entity, initialized with the provided IDs.
*/
function _field_create_entity_from_ids($ids) {
$id_properties = array();
Alex Pott
committed
$entity_type = \Drupal::entityManager()->getDefinition($ids->entity_type);
if ($id_key = $entity_type->getKey('id')) {
Alex Pott
committed
$id_properties[$id_key] = $ids->entity_id;
Dries Buytaert
committed
}
Alex Pott
committed
if (isset($ids->revision_id) && $revision_key = $entity_type->getKey('revision')) {
Alex Pott
committed
$id_properties[$revision_key] = $ids->revision_id;
Angie Byron
committed
}
Alex Pott
committed
if (isset($ids->bundle) && $bundle_key = $entity_type->getKey('bundle')) {
Alex Pott
committed
$id_properties[$bundle_key] = $ids->bundle;
Angie Byron
committed
}
return entity_create($ids->entity_type, $id_properties);
/**
* Implements hook_hook_info().
*/
function field_hook_info() {
$hooks['field_views_data'] = array(
'group' => 'views',
);
$hooks['field_views_data_alter'] = array(
'group' => 'views',
);
return $hooks;
}