<?php

/**

 * @file

 * Field attach API, allowing entities (nodes, users, ...) to be 'fieldable'.

 */

/**

 * Exception thrown by field_attach_validate() on field validation errors.

 */

class FieldValidationException extends FieldException {

  var $errors;

 /**

  * Constructor for FieldValidationException.

  *

  * @param $errors

  *   An array of field validation errors, keyed by field name and

  *   delta that contains two keys:

  *   - 'error': A machine-readable error code string, prefixed by

  *     the field module name. A field widget may use this code to decide

  *     how to report the error.

  *   - 'message': A human-readable error message such as to be

  *     passed to form_error() for the appropriate form element.

  */

  function __construct($errors) {

    $this->errors = $errors;

    parent::__construct(t('Field validation errors'));

  }

}

/**

 * @defgroup field_storage Field Storage API

 * @{

 * Implement a storage engine for Field API data.

 *

 * The Field Attach API uses the Field Storage API to perform all "database

 * access". Each Field Storage API hook function defines a primitive database

 * operation such as read, write, or delete. The default field storage module,

 * field_sql_storage.module, uses the local SQL database to implement these

 * operations, but alternative field storage backends can choose to represent

 * the data in SQL differently or use a completely different storage mechanism

 * such as a cloud-based database.

 *

 * Each field defines which storage backend it uses. The Drupal system variable

 * 'field_storage_default' identifies the storage backend used by default.

 *

 * See @link field Field API @endlink for information about the other parts of

 * the Field API.

 */

/**

 * Argument for an update operation.

 *

 * This is used in hook_field_storage_write when updating an

 * existing entity.

 */

define('FIELD_STORAGE_UPDATE', 'update');

/**

 * Argument for an insert operation.

 *

 * This is used in hook_field_storage_write when inserting a new entity.

 */

define('FIELD_STORAGE_INSERT', 'insert');

/**

 * @} End of "defgroup field_storage".

 */

/**

 * @defgroup field_attach Field Attach API

 * @{

 * Operate on Field API data attached to Drupal entities.

 *

 * Field Attach API functions load, store, display, generate Field API

 * structures, and perform a variety of other functions for field data attached

 * to individual entities.

 *

 * Field Attach API functions generally take $entity_type and $entity arguments

 * along with additional function-specific arguments. $entity_type is the type

 * of the fieldable entity, such as 'node' or 'user', and $entity is the entity

 * itself.

 *

 * hook_entity_info() is the central place for entity types to define if and

 * how Field API should operate on their entity objects. Notably, the

 * 'fieldable' property needs to be set to TRUE.

 *

 * The Field Attach API uses the concept of bundles: the set of fields for a

 * given entity is defined on a per-bundle basis. The collection of bundles for

 * an entity type is defined its hook_entity_info() implementation. For

 * instance, node_entity_info() exposes each node type as its own bundle. This

 * means that the set of fields of a node is determined by the node type. The

 * Field API reads the bundle name for a given entity from a particular

 * property of the entity object, and hook_entity_info() defines which property

 * to use. For instance, node_entity_info() specifies:

 * @code $info['entity keys']['bundle'] = 'type'@endcode

 * This indicates that for a particular node object, the bundle name can be

 * found in $node->type. This property can be omitted if the entity type only

 * exposes a single bundle (all entities of this type have the same collection

 * of fields). This is the case for the 'user' entity type.

 *

 * Most Field Attach API functions define a corresponding hook function that

 * allows any module to act on Field Attach operations for any entity after the

 * operation is complete, and access or modify all the field, form, or display

 * data for that entity and operation. For example, field_attach_view() invokes

 * hook_field_attach_view_alter(). These all-module hooks are distinct from

 * those of the Field Types API, such as hook_field_load(), that are only

 * invoked for the module that defines a specific field type.

 *

 * field_attach_load(), field_attach_insert(), and field_attach_update() also

 * define pre-operation hooks, e.g. hook_field_attach_pre_load(). These hooks

 * run before the corresponding Field Storage API and Field Type API

 * operations. They allow modules to define additional storage locations (e.g.

 * denormalizing, mirroring) for field data on a per-field basis. They also

 * allow modules to take over field storage completely by instructing other

 * implementations of the same hook and the Field Storage API itself not to

 * operate on specified fields.

 *

 * The pre-operation hooks do not make the Field Storage API irrelevant. The

 * Field Storage API is essentially the "fallback mechanism" for any fields

 * that aren't being intercepted explicitly by pre-operation hooks.

 *

 * @link field_language Field Language API @endlink provides information about

 * the structure of field objects.

 *

 * See @link field Field API @endlink for information about the other parts of

 * the Field API.

 */

/**

 * Invoke a field hook.

 *

 * @param $op

 *   Possible operations include:

 *   - form

 *   - validate

 *   - presave

 *   - insert

 *   - update

 *   - delete

 *   - delete revision

 *   - view

 *   - prepare translation

 * @param $entity_type

 *   The type of $entity; e.g. 'node' or 'user'.

 * @param $entity

 *   The fully formed $entity_type entity.

 * @param $a

 *   - The $form in the 'form' operation.

 *   - The value of $view_mode in the 'view' operation.

 *   - Otherwise NULL.

 * @param $b

 *   - The $form_state in the 'submit' operation.

 *   - Otherwise NULL.

 * @param $options

 *   An associative array of additional options, with the following keys:

 *  - 'field_name': The name of the field whose operation should be

 *    invoked. By default, the operation is invoked on all the fields

 *    in the entity's bundle. NOTE: This option is not compatible with

 *    the 'deleted' option; the 'field_id' option should be used

 *    instead.

 *  - 'field_id': The id of the field whose operation should be

 *    invoked. By default, the operation is invoked on all the fields

 *    in the entity's' bundles.

 *  - 'default': A boolean value, specifying which implementation of

 *    the operation should be invoked.

 *    - if FALSE (default), the field types implementation of the operation

 *      will be invoked (hook_field_[op])

 *    - If TRUE, the default field implementation of the field operation

 *      will be invoked (field_default_[op])

 *    Internal use only. Do not explicitely set to TRUE, but use

 *    _field_invoke_default() instead.

 *  - 'deleted': If TRUE, the function will operate on deleted fields

 *    as well as non-deleted fields. If unset or FALSE, only

 *    non-deleted fields are operated on.

 *  - 'language': A language code or an array of language codes keyed by field

 *    name. It will be used to narrow down to a single value the available

 *    languages to act on.

 */

function _field_invoke($op, $entity_type, $entity, &$a = NULL, &$b = NULL, $options = array()) {

  // Merge default options.

  $default_options = array(

    'default' => FALSE,

    'deleted' => FALSE,

    'language' => NULL,

  );

  $options += $default_options;

  // Determine the list of instances to iterate on.

  list(, , $bundle) = entity_extract_ids($entity_type, $entity);

  $instances = _field_invoke_get_instances($entity_type, $bundle, $options);

  // Iterate through the instances and collect results.

  $return = array();

  foreach ($instances as $instance) {

    // field_info_field() is not available for deleted fields, so use

    // field_info_field_by_id().

    $field = field_info_field_by_id($instance['field_id']);

    $field_name = $field['field_name'];

    $function = $options['default'] ? 'field_default_' . $op : $field['module'] . '_field_' . $op;

    if (function_exists($function)) {

      // Determine the list of languages to iterate on.

      $available_languages = field_available_languages($entity_type, $field);

      $languages = _field_language_suggestion($available_languages, $options['language'], $field_name);

      foreach ($languages as $langcode) {

        $items = isset($entity->{$field_name}[$langcode]) ? $entity->{$field_name}[$langcode] : array();

        $result = $function($entity_type, $entity, $field, $instance, $langcode, $items, $a, $b);

        if (isset($result)) {

          // For hooks with array results, we merge results together.

          // For hooks with scalar results, we collect results in an array.

          if (is_array($result)) {

            $return = array_merge($return, $result);

          }

          else {

            $return[] = $result;

          }

        }

        // Populate $items back in the field values, but avoid replacing missing

        // fields with an empty array (those are not equivalent on update).

        if ($items !== array() || isset($entity->{$field_name}[$langcode])) {

          $entity->{$field_name}[$langcode] = $items;

        }

      }

    }

  }

  return $return;

}

/**

 * Invoke a field hook across fields on multiple entities.

 *

 * @param $op

 *   Possible operations include:

 *   - load

 *   - prepare_view

 *   For all other operations, use _field_invoke() / field_invoke_default()

 *   instead.

 * @param $entity_type

 *   The type of $entity; e.g. 'node' or 'user'.

 * @param $entities

 *   An array of entities, keyed by entity id.

 * @param $a

 *   - The $age parameter in the 'load' operation.

 *   - Otherwise NULL.

 * @param $b

 *   Currently always NULL.

 * @param $options

 *   An associative array of additional options, with the following keys:

 *  - 'field_name': The name of the field whose operation should be

 *    invoked. By default, the operation is invoked on all the fields

 *    in the entity's bundle. NOTE: This option is not compatible with

 *    the 'deleted' option; the 'field_id' option should be used instead.

 *  - 'field_id': The id of the field whose operation should be

 *    invoked. By default, the operation is invoked on all the fields

 *    in the entity's' bundles.

 *  - 'default': A boolean value, specifying which implementation of

 *    the operation should be invoked.

 *    - if FALSE (default), the field types implementation of the operation

 *      will be invoked (hook_field_[op])

 *    - If TRUE, the default field implementation of the field operation

 *      will be invoked (field_default_[op])

 *    Internal use only. Do not explicitely set to TRUE, but use

 *    _field_invoke_multiple_default() instead.

 *  - 'deleted': If TRUE, the function will operate on deleted fields

 *    as well as non-deleted fields. If unset or FALSE, only

 *    non-deleted fields are operated on.

 *  - 'language': A language code or an array of arrays of language codes keyed

 *    by entity id and field name. It will be used to narrow down to a single

 *    value the available languages to act on.

 *

 * @return

 *   An array of returned values keyed by entity id.

 */

function _field_invoke_multiple($op, $entity_type, $entities, &$a = NULL, &$b = NULL, $options = array()) {

  // Merge default options.

  $default_options = array(

    'default' => FALSE,

    'deleted' => FALSE,

    'language' => NULL,

  );

  $options += $default_options;

  $fields = array();

  $grouped_instances = array();

  $grouped_entities = array();

  $grouped_items = array();

  $return = array();

  // Go through the entities and collect the fields on which the hook should be

  // invoked.

  //

  // We group fields by id, not by name, because this function can operate on

  // deleted fields which may have non-unique names. However, entities can only

  // contain data for a single field for each name, even if that field

  // is deleted, so we reference field data via the

  // $entity->$field_name property.

  foreach ($entities as $entity) {

    // Determine the list of instances to iterate on.

    list($id, $vid, $bundle) = entity_extract_ids($entity_type, $entity);

    $instances = _field_invoke_get_instances($entity_type, $bundle, $options);

    foreach ($instances as $instance) {

      $field_id = $instance['field_id'];

      $field_name = $instance['field_name'];

      $field = field_info_field_by_id($field_id);

      $function = $options['default'] ? 'field_default_' . $op : $field['module'] . '_field_' . $op;

      if (function_exists($function)) {

        // Add the field to the list of fields to invoke the hook on.

        if (!isset($fields[$field_id])) {

          $fields[$field_id] = $field;

        }

        // Extract the field values into a separate variable, easily accessed

        // by hook implementations.

        // Unless a language suggestion is provided we iterate on all the

        // available languages.

        $available_languages = field_available_languages($entity_type, $field);

        $language = is_array($options['language']) && !empty($options['language'][$id]) ? $options['language'][$id] : $options['language'];

        $languages = _field_language_suggestion($available_languages, $language, $field_name);

        foreach ($languages as $langcode) {

          $grouped_items[$field_id][$langcode][$id] = isset($entity->{$field_name}[$langcode]) ? $entity->{$field_name}[$langcode] : array();

          // Group the instances and entities corresponding to the current

          // field.

          $grouped_instances[$field_id][$langcode][$id] = $instance;

          $grouped_entities[$field_id][$langcode][$id] = $entities[$id];

        }

      }

    }

    // Initialize the return value for each entity.

    $return[$id] = array();

  }

  // For each field, invoke the field hook and collect results.

  foreach ($fields as $field_id => $field) {

    $field_name = $field['field_name'];

    $function = $options['default'] ? 'field_default_' . $op : $field['module'] . '_field_' . $op;

    // Iterate over all the field translations.

    foreach ($grouped_items[$field_id] as $langcode => &$items) {

      $entities = $grouped_entities[$field_id][$langcode];

      $instances = $grouped_instances[$field_id][$langcode];

      $results = $function($entity_type, $entities, $field, $instances, $langcode, $items, $a, $b);

      if (isset($results)) {

        // Collect results by entity.

        // For hooks with array results, we merge results together.

        // For hooks with scalar results, we collect results in an array.

        foreach ($results as $id => $result) {

          if (is_array($result)) {

            $return[$id] = array_merge($return[$id], $result);

          }

          else {

            $return[$id][] = $result;

          }

        }

      }

    }

    // Populate field values back in the entities, but avoid replacing missing

    // fields with an empty array (those are not equivalent on update).

    foreach ($grouped_entities[$field_id] as $langcode => $entities) {

      foreach ($entities as $id => $entity) {

        if ($grouped_items[$field_id][$langcode][$id] !== array() || isset($entity->{$field_name}[$langcode])) {

          $entity->{$field_name}[$langcode] = $grouped_items[$field_id][$langcode][$id];

        }

      }

    }

  }

  return $return;

}

/**

 * Invoke field.module's version of a field hook.

 *

 * This function invokes the field_default_[op]() function.

 * Use _field_invoke() to invoke the field type implementation,

 * hook_field_[op]().

 *

 * @see _field_invoke()

 */

function _field_invoke_default($op, $entity_type, $entity, &$a = NULL, &$b = NULL, $options = array()) {

  $options['default'] = TRUE;

  return _field_invoke($op, $entity_type, $entity, $a, $b, $options);

}

/**

 * Invoke field.module's version of a field hook on multiple entities.

 *

 * This function invokes the field_default_[op]() function.

 * Use _field_invoke_multiple() to invoke the field type implementation,

 * hook_field_[op]().

 *

 * @see _field_invoke_multiple()

 */

function _field_invoke_multiple_default($op, $entity_type, $entities, &$a = NULL, &$b = NULL, $options = array()) {

  $options['default'] = TRUE;

  return _field_invoke_multiple($op, $entity_type, $entities, $a, $b, $options);

}

/**

 * Helper for _field_invoke(): retrieves a list of instances to operate on.

 *

 * @param $entity_type

 *   The entity type.

 * @param $bundle

 *   The bundle name.

 * @param $options

 *   An associative array of options, as provided to _field_invoke(). Only the

 *   following keys are considered :

 *   - deleted

 *   - field_name

 *   - field_id

 *   See _field_invoke() for details.

 *

 * @return

 *   The array of selected instance definitions.

 */

function _field_invoke_get_instances($entity_type, $bundle, $options) {

  if ($options['deleted']) {

    // Deleted fields are not included in field_info_instances(), and need to

    // be fetched from the database with field_read_instances().

    $params = array('entity_type' => $entity_type, 'bundle' => $bundle);

    if (isset($options['field_id'])) {

      // Single-field mode by field id: field_read_instances() does the filtering.

      // Single-field mode by field name is not compatible with the 'deleted'

      // option.

      $params['field_id'] = $options['field_id'];

    }

    $instances = field_read_instances($params, array('include_deleted' => TRUE));

  }

  elseif (isset($options['field_name'])) {

    // Single-field mode by field name: field_info_instance() does the

    // filtering.

    $instances = array(field_info_instance($entity_type, $options['field_name'], $bundle));

  }

  else {

    $instances = field_info_instances($entity_type, $bundle);

    if (isset($options['field_id'])) {

      // Single-field mode by field id: we need to loop on each instance to

      // find the right one.

      foreach ($instances as $instance) {

        if ($instance['field_id'] == $options['field_id']) {