Club Drupal

    are set to translatable or not, they will all be translatable as every

    language for the host will have a completely separate copy of the field

    collection item(s).

        $child_plugin['title'] = t(

          '!label field collection (!field_name) from !entity_type (!bundle)',

          array(

          )

        );

        $restrictions = array('type' => array($instance['bundle']));

  if (isset($entity->{$plugin_info['field_name']})) {

    $items = field_get_items($plugin_info['entity_type'], $entity, $plugin_info['field_name']);

      $field_collection_item = field_collection_item_load($items[$delta]['value']);

    }

 * Default theme implementation for field collection items.

 *

 * Available variables:

 *   hide($content['field_example']) to temporarily suppress the printing of a

 *   given element.

 * - $title: The (sanitized) field collection item label.

  $instances = field_info_instances();

  $field_types = field_info_field_types();

  $bundles = field_info_bundles();

  $rows = array();

  foreach ($instances as $entity_type => $type_bundles) {

    foreach ($type_bundles as $bundle => $bundle_instances) {

 * This hook allows modules to determine whether a field collection is empty

 * before it is saved.

 *

 *   Whether or not the field should be considered empty.

 * @param FieldCollectionItemEntity $item

 *   The field collection we are currently operating on.

    case 'field_my_first_collection':

      $item_wrapper = entity_metadata_wrapper('field_collection_item', $item);

      $author = $item_wrapper->field_author->value();

      return "{$title} by {$author}";

  $view_mode = $context['view_mode'];

  $entity = entity_revision_load($entity_type, $item['revision_id']);

  $field_context = $context;

  $field_context['entity_type'] = $entity_type;

  $field_context['bundle'] = $bundle_name;

    // We provide a loose check on the field access.

    if (field_access('view', $field, $entity_type) || field_access('edit', $field, $entity_type)) {

      $field_context['language'] = $langcode;

      $field_context['field'] = $field;

      $field_context['instance'] = $instance;

      list($this->hostEntityId, $this->hostEntityRevisionId) = entity_extract_ids($this->hostEntityType, $this->hostEntity);

      // If the host entity is not saved yet, set the id to FALSE. So

      // fetchHostDetails() does not try to load the host entity details.

      if (!isset($this->hostEntityId)) {

        $this->hostEntityId = FALSE;

      }

    }

    list($recieved_id) = entity_extract_ids($this->hostEntityType, $entity);

      $current_id = $this->hostEntityId;

    }

    else {

  }

  protected function fetchHostDetails() {

      if ($this->item_id) {

        // For saved field collections, query the field data to determine the

        // right host entity.

          $query->age(FIELD_LOAD_REVISION);

        }

        $result = $query->execute();

        }

        else {

          $this->hostEntityId = FALSE;

        }

      }

      else {

  /**

   * Deletes the field collection item and the reference in the host entity.

   */

    parent::delete();

  }

  /**

      }

      if (!$row && !isset($this->hostEntity()->{$this->field_name}[$this->langcode()][$this->delta()])) {

        // Delete if there is no existing revision or translation to be saved.

      }

    }

  }

configure = admin/structure/field-collections

package = Fields

core = "7.x"

project = "field_collection"

    return $info;

  }

    ->expression('revision_id', 'item_id')

    ->execute();

  $archived_spec = array(

    'description' => 'Boolean indicating whether the field collection item is archived.',

    'type' => 'int',

    if ($field['translatable'] == 1 && isset($field['bundles']['field_collection_item'])) {

      $query = new EntityFieldQuery();

      $query->entityCondition('entity_type', 'field_collection_item')

      $query_result = $query->execute();

      if (isset($query_result['field_collection_item'])) {

        $results = $results + $query_result['field_collection_item'];

    }

  }

  if (count($results)) {

    $ids = array_keys($results);

    $field_collection_items = entity_load('field_collection_item', $ids);

    foreach ($field_collection_items as $item) {

    }

  }

}

 * @see http://drupal.org/node/1900640

 */

/**

 * Destination class implementing migration into field_collection.

 */

   * @param $row

   *   Raw source data object - passed through to prepare/complete handlers.

   *

   *   Array of key fields (item_id only in this case) of the collection that

   *   was saved or FALSE on failure.

   */

    if (isset($row->migrate_map_destid1)) {

      // We're updated an existing entity - start from the previous data.

      // entity_load() returns an array, so we get the field collection entity

        $entity_old = clone $entity;

        $updating = TRUE;

      }

    $this->prepare($entity, $row);

    if ($updating) {

      foreach ($entity as $field => $value) {

        if ('field_' != substr($field, 0, 6)) {

    $this->completeRollback($item_id);

    return TRUE;

  }

}

/**

 */

function field_collection_form_field_ui_field_overview_form_alter(&$form, &$form_state) {

  if (count($form['#fields'])) {

      if (!isset($field['type']['#title'])) {

        continue;

      }

      'full' => array(

        'label' => t('Full content'),

        'custom settings' => FALSE,

    ),

    'access callback' => 'field_collection_item_access',

    'deletion callback' => 'field_collection_item_delete',

 * @param $entity_type

 * @param $entity

 *

 *   A language code

 */

function field_collection_entity_language($entity_type, $entity) {

/**

 * Loads a field collection item.

 *

 *   The field collection item entity or FALSE.

 */

function field_collection_item_load($item_id, $reset = FALSE) {

 */

function field_collection_permission() {

  return array(

      'title' => t('Administer field collections'),

      'description' => t('Create and delete fields on field collections.'),

    ),

          if (!isset($cleared_host_entity_cache)) {

            list($entity_id) = entity_extract_ids($host_entity_type, $host_entity);

            entity_get_controller($host_entity_type)->resetCache(array($entity_id));

          }

          $is_default = entity_revision_is_default($host_entity_type, $host_entity);

          // If an entity type does not support saving non-default entities,

    'field_collection_list' => array(

      'label' => t('Links to field collection items'),

      'field types' => array('field_collection'),

        'edit' => t('Edit'),

        'translate' => t('Translate'),

        'delete' => t('Delete'),

    'field_collection_view' => array(

      'label' => t('Field collection items'),

      'field types' => array('field_collection'),

        'edit' => t('Edit'),

        'delete' => t('Delete'),

        'add' => t('Add'),

        'description' => TRUE,

    'field_collection_fields' => array(

      'label' => t('Fields only'),

      'field types' => array('field_collection'),

        'view_mode' => 'full',

      ),

    ),

    $elements['translate'] = array(

      '#type' => 'textfield',

      '#title' => t('Translate link title'),

      '#description' => t('Leave the title empty, to hide the link.'),

      '#access' => field_collection_item_is_translatable(),

    );

  if ($display['type'] !== 'field_collection_list') {

    $entity_type = entity_get_info('field_collection_item');

    if (!empty($entity_type['view modes'][$settings['view_mode']]['label'])) {

    }

  }

      $view_mode = !empty($display['settings']['view_mode']) ? $display['settings']['view_mode'] : 'full';

      foreach ($items as $delta => $item) {

        if ($field_collection = field_collection_field_get_entity($item)) {

          $element[$delta]['#theme_wrappers'] = array('field_collection_view');

          $element[$delta]['#attributes']['class'][] = 'field-collection-view';

          $element[$delta]['#attributes']['class'][] = 'clearfix';

      $view_mode = !empty($display['settings']['view_mode']) ? $display['settings']['view_mode'] : 'full';

      foreach ($items as $delta => $item) {

        if ($field_collection = field_collection_field_get_entity($item)) {

        }

      }

      break;

      $path = field_collection_field_get_path($field);

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

      $element['#suffix'] = '';

        $element['#suffix'] .= '<div class="description field-collection-description">' . field_filter_xss($instance['description']) . '</div>';

      }

      $title = entity_i18n_string("field:{$field['field_name']}:{$instance['bundle']}:setting_add", $settings['add']);

          '#value' => t('Remove'),

          '#validate' => array(),

          '#submit' => array('field_collection_remove_submit'),

          '#limit_validation_errors' => array(),

          '#ajax' => array(

            // 'wrapper' is filled in field_collection_field_attach_form().

 *   The entity object or FALSE.

 */

function field_collection_field_get_entity(&$item, $field_name = NULL) {

    return $item['entity'];

  }

  elseif (isset($item['value'])) {

      // Copied from _form_validate().

      if (isset($elements['#needs_validation'])) {

        $is_empty_string = (is_string($elements['#value']) && drupal_strlen(trim($elements['#value'])) == 0);

        $is_empty_value = ($elements['#value'] === 0);

        $is_empty_option = (isset($elements['#options']['_none']) && $elements['#value'] == '_none');

    // Create a field_collection field to use for the tests.

    $this->field_name = 'field_test_collection';

    $this->field = field_create_field($this->field);

    $this->field_id = $this->field['id'];

   *   Message to display.

   * @param $group

   *   The group this message belongs to, defaults to 'Other'.

   *   TRUE on pass, FALSE on fail.

   */

  protected function assertNoHookMessage($text, $message = NULL, $group = 'Other') {

    $this->assertTrue($item->archived, 'Removed field collection item is archived.');

    // Test removing an old node revision. Make sure that the field collection

    list ($node, $item) = $this->createNodeWithFieldCollection();

    $node_vid = $node->vid;

    $node->revision = TRUE;

  }

  /**

   *

   *   The language code to check.

   */

  function addLanguage($langcode) {

  /**

   * Create a translation using the Entity Translation Form.

   *

   *   Node of the basic page to create translation for.

   *   The language code of the translation.

   *   The original language code.

   */

  protected function createTranslationForm($node, $langcode, $source_langcode = 'en') {

   *

   * @param mixed $node

   *   The node to remove the translation from.

   *   The language of the translation to remove.

   *   The source language of the node.

   */

  protected function removeTranslationForm($node, $langcode, $source_langcode) {

  /**

   * Creates a translation programmatically using Entity Translation.

   *

   *   Node of the basic page to create translation for.

   *   The language code of the translation.

   */

  protected function createTranslation($node, $langcode) {

    $source_langcode = $node->language;

    field_attach_update('node', $node);

    // Reload an return the node.

    return $node;

  }

   *

   * @param mixed $node

   *   The node to remove the translation from.

   *   The language of the translation to remove.

   */

  protected function removeTranslation($node, $langcode) {

    node_save($node);

    // Reload and return the node.

    return $node;

  }

  /**

   * Creates a new revision of the node and checks the result.

   *

   *   The new revision of the node.

   */

  protected function createRevision($node, $langcode, $source_langcode) {

   *   The language to check.

   */

  protected function checkFieldCollectionContent($node, $langcode) {

      case 'en':

        $untrans_field = self::UNTRANS_FIELD_EN;

        $trans_field = self::TRANS_FIELD_EN;

        break;

      case 'de':

        $untrans_field = self::UNTRANS_FIELD_DE;

        $trans_field = self::TRANS_FIELD_DE;

  if ($host_entity_types === FALSE) {

    $host_entity_types = array();

    // Look for all field instances, filter them by type == 'field_collection'

    // and map the entity type it's connected to to the returned list.

    foreach (field_info_field_map() as $field_instance) {

    }

    $data['field_collection_item'][$pseudo_field_name]['relationship'] = array(

      'help' => t('Relate each @entity using @field.', array('@entity' => $entity, '@field' => $label)),

      'handler' => 'views_handler_relationship_entity_reverse',

      'field_name' => $field['field_name'],

    }

    return $this->table_alias;

  }

}

    outside of the rule admin module too. In fact the rules admin module is

    pretty small, as it just relies on the provided UI of the components.

  * The UI is incorporated using the faces object extension mechanism, see

The Rules module allows site administrators to define conditionally executed

actions based on occurring events (ECA-rules).

Installation

*Before* starting, make sure that you have read at least the introduction - so

you know at least the basic concepts. You can find it here:

 * Rules depends on the Entity API module, download and install it from

 * Copy the whole rules directory to your modules directory

   (e.g. DRUPAL_ROOT/sites/all/modules) and activate the Rules and Rules UI

   modules.

Documentation

-------------

Rules Scheduler

   to schedule the execution of Rules components.

 * Make sure that you have configured cron for your drupal installation as cron

   is used for scheduling the Rules components. For help see

Upgrade from Rules 6.x-1.x to Rules 7.x-2.x

     * Note that for importing an export the export needs to pass the

       configuration integrity check, what might be troublesome if the

       conversion was not 100% successful. In that case, try choosing the

     * A rule configuration might require multiple modules to be in place and

       upgraded to work properly. E.g. if you used an action provided

       by a third party module, make sure the module is in place and upgraded

    for Drupal 7. The Drupal 6 tasks are preserved in the database as long as

    you do not clear your Rules 1.x configuration though.

  * The Rules Forms module has not been updated to Drupal 7 and there are no

    automatic configuration updates.

    Thus, a possible future Rules 2.x Forms module is likely to work

    different, e.g. by working only for entity forms on the field level.

<?php

/**

 */

if (!interface_exists('FacesExtenderInterface', FALSE)) {

    /**

     * Constructs an instance of the extender.

     */

    /**

     * Returns the extended object.

     */

    public function getExtendable();

  }

  /**

if (!class_exists('FacesExtender', FALSE)) {

  /**

   */

  abstract class FacesExtender implements FacesExtenderInterface {

     */

    protected $object;

      $this->object = $object;

    }

    }

    /**

     *

     *   The method name.

     *   An array of arguments to pass to the method.

     */

    protected function call($name, array $args = array()) {

      return $this->object->call($name, $args);

    }

  }

}

    /**

     * Magic method: Invoke the dynamically implemented methods.

     */

      if (isset($this->facesMethods[$name])) {

        $method = $this->facesMethods[$name];

        // Include code, if necessary.

    }

    /**

     */

    public function extender($class) {

      if (!isset($this->facesClassInstances[$class])) {

    }

    /**

     * Returns whether the object can face as the given interface, thus it

     * implementation.

     *

     * @param $interface

     *   Whether the object can face as the interface or an array of interface

     *   names.

     */

     *

     * @param $interface

     *   The interface name or an array of interface names.

     *   The extender class, which has to implement the FacesExtenderInterface.

     *   An optional array describing the file to include before invoking the

     *   class. The array entries known are 'type', 'module', and 'name'

     *   matching the parameters of module_load_include(). Only 'module' is

     * @param $interface

     *   The interface name or FALSE to extend the object without a given

     *   interface.

     *   An array, where the keys are methods of the given interface and the

     *   values the callback functions to use.

     *   An optional array to describe files to include before invoking the

     *   callbacks. You may pass a single array describing one include for all

     *   callbacks or an array of arrays, keyed by the method names. Look at the

    /**

     * Override the implementation of an extended method.

     *

     *   the keys are methods to override and the values the callback functions

     *   to use.

     *   An optional array to describe files to include before invoking the

     *   callbacks. You may pass a single array describing one include for all

     *   callbacks or an array of arrays, keyed by the method names. Look at the

    /**

     * Adds in include files for the given methods while removing any old files.

     * If a single include file is described, it's added for all methods.

     */

    protected function addIncludes($methods, $includes) {

    }

    /**

     * Destroys all references to created instances so that PHP's garbage

     * collection can do its work. This is needed as PHP's gc has troubles with

     * circular references until PHP < 5.3.

     * This also allows to pass arguments by reference, so it may be used to

     * pass arguments by reference to dynamically extended methods.

     *

     *   The method name.

     *   An array of arguments to pass to the method.

     */

    public function call($name, array $args = array()) {

      }

      return $this->__call($name, $args);

    }

  }

// This is not necessary as the classes are autoloaded via the registry. However

// it saves some possible update headaches until the registry is rebuilt.

require_once dirname(__FILE__) . '/faces.inc';

/**

  /**

   * Overridden.

   * @see DrupalDefaultEntityController::attachLoad()

   */

  protected function attachLoad(&$queried_entities, $revision_id = FALSE) {

    $ids = array_keys($queried_entities);

    $result = db_select('rules_tags')

      ->fields('rules_tags', array('id', 'tag'))

  /**

   * Override to support having events and tags as conditions.

   * @see rules_query_rules_config_load_multiple_alter()

   */

  protected function applyConditions($entities, $conditions = array()) {

   * @param $export

   *   A serialized string in JSON format as produced by the

   *   RulesPlugin::export() method, or the PHP export as usual PHP array.

   */

  public function import($export, &$error_msg = '') {

    $export = is_array($export) ? $export : drupal_json_decode($export);

    foreach ($rules_config->events() as $event) {

      db_insert('rules_trigger')

        ->fields(array(

    }

  }

      foreach ($rules_config->dependencies as $dependency) {

        db_insert('rules_dependencies')

          ->fields(array(

      }

    }

  }

  /**

   * Overridden to support tags and events in $conditions.

   * @see EntityAPIControllerExportable::buildQuery()

   */

  protected function buildQuery($ids, $conditions = array(), $revision_id = FALSE) {

    $query_conditions =& $query->conditions();

    foreach ($query_conditions as &$condition) {

      // One entry in $query_conditions is a string with key '#conjunction'.

      if (is_array($condition)) {

        // Support using 'tags' => array('tag1', 'tag2') as condition.

        if ($condition['field'] == 'base.tags') {

  /**

   * Overridden to also delete tags and events.

   * @see EntityAPIControllerExportable::delete()

   */

  public function delete($ids, DatabaseTransaction $transaction = NULL) {

    return $return;

  }

}

/**

 * The RulesExtendable uses the rules cache to setup the defined extenders

 * and overrides automatically.

 * As soon faces is used the faces information is autoloaded using setUp().

  /**

   * The name of the info definitions associated with info about this class.

   * This would be defined abstract, if possible. Common rules hooks with class

   * info are e.g. plugin_info and data_info.

   */

   */

  protected $itemName;

  public function __construct() {

    $this->setUp();

    if (isset($this->cache[$this->hook][$this->itemName])) {

      $this->itemInfo = &$this->cache[$this->hook][$this->itemName];

    }

    if (!empty($this->itemInfo['faces_cache'])) {

      list($this->facesMethods, $this->facesIncludes, $this->faces) = $this->itemInfo['faces_cache'];

    }

  }

  /**

   */

  public function forceSetUp() {

    if (!isset($this->cache) || (!empty($this->itemInfo['faces_cache']) && !$this->faces)) {

   *   The info about the item as specified in the hook.

   * @param $interface

   *   The interface to check for.

   *   Whether it supports the given interface.

   */

  public static function itemFacesAs(&$itemInfo, $interface) {

    return in_array($interface, class_implements($itemInfo['class'])) || isset($itemInfo['faces_cache'][2][$interface]);

  }

}

/**

  /**

   * The parent element, if any.

   * @var RulesContainerPlugin

   */

  protected $parent = NULL;

  /**

   * Identifies an element inside a configuration.

   */

  protected $availableVariables;

  /**

   * Sets a new parent element.

   */

   * Iterate over all elements nested below the current element.

   *

   * This helper can be used to recursively iterate over all elements of a

   * over the object.

   *

   * @param $mode

  /**

   * Evaluate the element on a given rules evaluation state.

   */

  protected static function compare(RulesPlugin $a, RulesPlugin $b) {

    if ($a->weight == $b->weight) {

  /**

   * Returns info about parameters needed for executing the configured plugin.

   *

   *   Whether optional parameters should be included.

   *

   * @see self::pluginParameterInfo()

  }

  /**

   * E.g. this is used to assert the content type of a node if the condition

   */

  protected function variableInfoAssertions() {

    return array();

  }

  /**

   */

  public function getPluginName() {

    return $this->itemName;

   * Usually settings get processed automatically, however if $this->settings

   * has been altered manually after element construction, it needs to be

   * invoked explicitly with $force set to TRUE.

   */

  public function processSettings($force = FALSE) {

    // Process if not done yet.

  }

  /**

   *

   *

   * @throws RulesIntegrityException

   *   is thrown.

   */

  public function integrityCheck() {

      elseif (!$this->isRoot() && !isset($this->settings[$name]) && empty($info['optional']) && $info['type'] != 'hidden') {

        throw new RulesIntegrityException(t('Missing configuration for parameter %name.', array('%name' => $name)), array($this, 'parameter', $name));

      }

    }

  }

  /**

   * Returns the argument as configured in the element settings for the

   * parameter $name described with $info.

   *

   *   The name of the parameter for which to get the argument.

   * @param $info

   *   Info about the parameter.

   * @param RulesState $state

   *   The current evaluation state.

   *   (optional) The language code used to get the argument value if the

   *   argument value should be translated. By default (NULL) the current

   *   interface language will be used.

    if (!empty($this->settings[$name . ':process'])) {

      // For processing, make sure the data is unwrapped now.

      $return = rules_unwrap_data(array($arg), array($info));

      // separate parameter to process().

      $info['#name'] = $name;

      $info['#langcode'] = $langcode;

  }

  /**

   *

   *   The selector string, e.g. "node:author:mail".

   *

   * @return EntityMetadataWrapper

            }

          }

        }

        catch (EntityMetadataWrapperException $e) {

          return FALSE;

        }

  }

  /**

   */

  public function save($name = NULL, $module = 'rules') {

    if (isset($this->parent)) {

      // default configurations 'module' points to the module providing the

      // default configuration, so the module via which the rules is configured

      // is stored in the "owner" property.

      // module only for the modules providing default configurations.

      $this->module = !isset($this->module) || $module != 'rules' ? $module : $this->module;

      if (!isset($this->owner)) {

  }

  /**

   * If invoked on a rules configuration it is deleted from database. If

   * invoked on a contained rule element, it's removed from the configuration.

   */

   *   A status constant, i.e. one of ENTITY_CUSTOM, ENTITY_IN_CODE,

   *   ENTITY_OVERRIDDEN or ENTITY_FIXED.

   *

   *   TRUE if the configuration has the status, else FALSE.

   *

   * @see entity_has_status()

  }

  /**

   */

  public function destroy() {

    parent::destroy();

  }

  /**

   */

  public function form(&$form, &$form_state, array $options = array()) {

    $this->__call('form', array(&$form, &$form_state, $options));

  /**

   * Exports a rule configuration.

   *

   *   An optional prefix for each line.

   *   Optional. Set to TRUE to format the export using PHP arrays. By default

   *   JSON is used.

   * @return

   *

   * @see rules_import()

   */

  }

  /**

   */

  protected function returnExport($export, $prefix = '', $php = FALSE) {

    $this->ensureNameExists();

  public function resetInternalCache() {

    $this->availableVariables = NULL;

  }

}

/**

 */

abstract class RulesAbstractPlugin extends RulesPlugin {

  protected $infoLoaded = FALSE;

  /**

   *   The plugin implementation's name.

   *   Further information provided about the plugin. Optional.

   * @throws RulesException

   *   If validation of the passed settings fails RulesExceptions are thrown.

   */

    $this->elementName = $name;

    $this->settings = (array) $settings + array('#_needs_processing' => TRUE);

    $this->setUp();

    if (isset($this->cache[$this->itemName . '_info'][$this->elementName])) {

      $this->info = $this->cache[$this->itemName . '_info'][$this->elementName];

      // Remember that the info has been correctly setup.

      $this->infoLoaded = TRUE;

      // Register the defined class, if any.

   */

  abstract protected function executeCallback(array $args, RulesState $state = NULL);

  public function evaluate(RulesState $state) {

    $this->processSettings();

    try {

  }

  public function getPluginName() {

  }

  /**

    self::includeFiles();

    // Get the plugin's own info data.

      $info += array(

        'parameter' => isset($info['arguments']) ? $info['arguments'] : array(),

        'provides' => isset($info['new variables']) ? $info['new variables'] : array(),

      // RulesPluginImplInterface.

      unset($this->faces['RulesPluginHandlerInterface']);

      foreach ($this->faces as $interface) {

        $methods = $file_names = array();

        $includes = self::getIncludeFiles($info['module']);

        // Cache only the plugin implementation specific callbacks.

        $info['faces_cache'][$interface] = array($methods, array_filter($file_names));

      }

      $info['faces_cache'] = rules_filter_array($info['faces_cache'], 0, TRUE);