Club Drupal

CONTENTS OF THIS FILE

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

 * Introduction

 * Requirements

 * Installation

 * Configuration

 * Using field collection with entity translation

 * Maintainers

INTRODUCTION

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

Provides a field collection field to which any number of fields can be attached.

REQUIREMENTS

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

This project require the following projects:

 * Entity API (https://www.drupal.org/project/entity)

INSTALLATION

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

Install as you would normally install a contributed Drupal. See:

https://drupal.org/documentation/install/modules-themes/modules-7 for further

information.

CONFIGURATION

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

 * Add a field collection field to any entity, e.g. to a node. For that use the

   the usual "Manage fields" interface provided by the "field ui" project of

   Drupal, e.g "Admin -> Structure -> Content types -> Article -> Manage fields"

 * Then go to "Admin -> Structure-> Field Collection" to define some fields for

 * By the default, the field collection is not shown during editing of the host

 * Widgets for embedding the form for creating field collections in the

    project might provide such widgets itself too.

USING FIELD COLLECTION WITH ENTITY TRANSLATION

-----------

  * Field Collection items must be selected as a translatable entity type at

  * When using nested field collections, the configuration of the fields and

    enable entity translation as defined in step 1, and set the outer

    field collection field as translatable and all its sub-fields to language

    undefined. The sub-field collections and its sub-fields should also be

    its fields.

MAINTAINERS

-----------

Current maintainers:

 * Joel Muzzerall (jmuzz) - https://www.drupal.org/user/2607886

 * Joel Farris (Senpai) - https://www.drupal.org/user/65470

 * Lee Rowlands (larowlan) - https://www.drupal.org/user/395439

 * Nedjo Rogers (nedjo) - https://www.drupal.org/user/4481

 * Ra Mänd (ram4nd) - https://www.drupal.org/user/601534

 * Renato Gonçalves (RenatoG) - https://www.drupal.org/user/3326031

 * Wolfgang Ziegler (fago) - https://www.drupal.org/user/16747

    // Use negative delta to get item from the end.

    if ($delta < 0) {

      // Add negative pseudo-delta to total amount of items to get the real

      // delta. Example (field_collection with 5 elements): count() == 5:

      // 5 + -1 = 4, which would be the last element in this example.

      $delta = count($items) + $delta;

    }

    '#description' => t('The relationship can only create one context, but multiple items can be related. Please type in the number you want. The first one will be 0. Use negative delta to get items from the end. The last item will be -1'),

 * Contains API documentation and examples for the Field Collection.

 * This hook is invoked before the field collection item is saved to the

 * database.

 * This hook is called after the content has been assembled in a structured

 * Provide diff field functions for the Field Collection.

 * Diff field callback for parsing Field Collection fields comparative values.

  if (empty($entity)) {

  $actual_mode = !empty($view_mode_settings[$view_mode]['custom_settings']) ? $view_mode : 'default';

    // Any view mode is supported in relation to hiding fields, but only if

    // selected.

      $old_items = array();

      $new_items = array();

      if (!empty($entity->{$field_name}[$langcode])) {

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

      }

      $func = $field['module'] . '_field_diff_view_prepare';

      if (function_exists($func)) {

        $func($old_items, $new_items, $field_context);

      }

      if (!empty($new_items)) {

        $raw_values = $func($new_items, $field_context);

          $values[] = is_array($raw_value) ? implode(', ', $raw_value) : $raw_value;

        $result[] = check_plain($instance['label'] . ': ' . implode(', ', $values));

   * Field Collection field info.

   * Field Collection revision ID.

      if ($field['cardinality'] == 1) {

      if ($this->item_id) {

      return t('New !instance_label', array('!instance_label' => $label));

    $this->fetchHostDetails($entity);

    if (!$this->hostEntityType || isset($entity->tid)) {

    if (!empty($this->hostEntityId) && $this->isInUse()) {

      if (is_array($this->hostEntityId)) {

        $current_id = in_array($recieved_id, $this->hostEntityId)

          ? $recieved_id

          : FALSE;

      }

      else {

        $current_id = $this->hostEntityId;

      }

      list($current_id) = $current_host ? entity_extract_ids($this->hostEntityType, $current_host) : array($recieved_id);

  /**

   * Collects info about the field collection's host.

   *

   * @param $hostEntity

   *   The host entity object. (optional)

   */

  protected function fetchHostDetails($hostEntity = NULL) {

        $field_info = $this->fieldInfo();

        $query->fieldCondition($field_info, 'revision_id', $this->revision_id);

        if ($hostEntity) {

          $entity_type = key($field_info['bundles']);

          $bundle = current($field_info['bundles'][$entity_type]);

          $entity_info = entity_get_info($entity_type);

          $key = $entity_info['entity keys']['id'];

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

          $query->entityCondition('entity_id', $hostEntity->{$key});

          $query->entityCondition('bundle', $bundle);

          if (isset($entity_info['entity keys']['language'])) {

            $query->propertyCondition('language', $hostEntity->language);

          }

        }

        $query->addTag('DANGEROUS_ACCESS_CHECK_OPT_OUT');

            if (isset($item['entity']) && $item['entity'] === $this) {

              if (isset($item['entity']) && $item['entity'] === $this) {

    if (empty($this->langcode) || $this->delta() === NULL) {

   * Field Collection items may be contained in from non-default host entity

      throw new Exception('Unable to create a field collection item without a given host entity.');

    if (!empty($this->is_new) && field_collection_item_is_translatable() && $this->langcode() == LANGUAGE_NONE) {

    $host_entity = $this->hostEntity();

    if (!$host_entity) {

      throw new Exception('Unable to save a field collection item without a valid reference to a host entity.');

    }

    // If this is creating a new revision, also do so for the host entity.

    if (!empty($this->revision) || !empty($this->is_new_revision)) {

      $host_entity->revision = TRUE;

      if (!empty($this->default_revision)) {

        entity_revision_set_default($this->hostEntityType, $host_entity);

      }

    }

    // Set the host entity reference, so the item will be saved with the host.

    // @see field_collection_field_presave()

    $delta = $this->delta();

    if (isset($delta)) {

      $host_entity->{$this->field_name}[$this->langcode()][$delta] = array('entity' => $this);

    else {

      $host_entity->{$this->field_name}[$this->langcode()][] = array('entity' => $this);

    }

    return entity_save($this->hostEntityType, $host_entity);

          // Source (translatable_field) is set, therefore continue

          // processing.

          if (isset($this->{$translatable_field}[$source_language])

            && !isset($this->{$translatable_field}[$langcode])) {

            // Destination (translatable_field) is not set, therefore safe to

            // copy the translation.

            $this->{$translatable_field}[$langcode] = $this->{$translatable_field}[$source_language];

      else {

name = Field Collection

; Information added by Drupal.org packaging script on 2019-09-03

version = "7.x-1.1"

datestamp = "1567537827"

    // Also add type-specific host entity references for all entity types that

    // have at least one field collection field.

    $field_collection_fields = field_read_fields(array('type' => 'field_collection'));

    $entity_types = entity_get_info();

    foreach (field_info_instances() as $entity_type => $bundles) {

      foreach ($bundles as $bundle => $fields) {

        if (array_intersect_key($fields, $field_collection_fields)) {

          $args = array('@type' => $entity_types[$entity_type]['label']);

          $properties["host_entity_$entity_type"] = array(

            'label' => t('Host entity (@type)', $args),

            'type' => $entity_type,

            'description' => t('The @type containing the field collection field (empty if this field collection is attached to an item of a different type).', $args),

            'getter callback' => 'field_collection_item_get_specific_type_host_entity',

            'computed' => TRUE,

          );

          break;

        }

      }

    }

  if (module_exists('entitycache')) {

    $schema['cache_entity_field_collection_item'] = drupal_get_schema_unprocessed('system', 'cache');

    $schema['cache_entity_field_collection_item']['description'] = 'Cache table used to store field_collection_item entity records.';

  }

    $ids = $select->execute()->fetchCol();

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

/**

 * Update revisions created before revision support was implemented.

 */

function field_collection_update_7009(&$sandbox) {

  $items_per_pass = 10;

  $field_collection_fields = field_read_fields(array('type' => 'field_collection'));

  // If you don't have any field_collecton fields then skip this update.

  if (empty($field_collection_fields)) {

    return;

  }

  if (!isset($sandbox['current_field'])) {

    $sandbox['field_collection_fields'] = array_keys($field_collection_fields);

    $sandbox['current_field'] = 0;

    $sandbox['current_field_collection_item'] = 0;

    $sandbox['field_name'] = $sandbox['field_collection_fields'][$sandbox['current_field']];

    $sandbox['inner_fields'] = field_read_instances(array('entity_type' => 'field_collection_item', 'bundle' => $sandbox['field_name']));

  }

  // Find field collection items with duplicate revision ids.

  $query = db_select("field_revision_{$sandbox['field_name']}", 't')

    ->fields('t', array("{$sandbox['field_name']}_revision_id"))

    ->range($sandbox['current_field_collection_item'], $items_per_pass)

    ->groupBy("t.{$sandbox['field_name']}_revision_id");

  $query->addExpression("COUNT(t.{$sandbox['field_name']}_revision_id)", 'vidcount');

  $query->havingCondition('vidcount', 2, '>=');

  $vids = $query->execute()->fetchCol();

  // Each revision ID that occurs more than once.

  foreach ($vids as $field_collection_duplicated_revision_id) {

    // Find every instance of this revision ID.

    $copies = db_select("field_revision_{$sandbox['field_name']}", 't')

      ->fields('t')

      ->condition("{$sandbox['field_name']}_revision_id", $field_collection_duplicated_revision_id)

      ->execute()

      ->fetchAllAssoc('revision_id');

    $first_copy = reset($copies);

    $field_collection_item_id = $first_copy->{"{$sandbox['field_name']}_value"};

    // Find the currently used revision of this field collection item.

    $field_collection_item_current_revision = db_select('field_collection_item', 'fci')

      ->fields('fci', array('revision_id'))

      ->condition('item_id', $field_collection_item_id)

      ->execute()

      ->fetchField();

    // Find new revisions of this field collection item that were made after

    // revisions were enabled in update_7003.

    $modern_revisions = db_select("field_revision_{$sandbox['field_name']}", 't')

      ->fields('t')

      ->condition("{$sandbox['field_name']}_revision_id", $field_collection_duplicated_revision_id, '<>')

      ->condition("{$sandbox['field_name']}_value", $field_collection_item_id)

      ->orderBy('revision_id')

      ->execute()

      ->fetchAllAssoc('revision_id');

    // Intentionally skip the first instance as it doesn't need to be modified.

    while (FALSE !== ($row_to_replace = next($copies))) {

      $new_revision_id = _field_collection_update_7009_new_revision($field_collection_item_id, $row_to_replace, $sandbox['inner_fields'], $sandbox['field_name']);

      // Create copies of inner fields with new revision number.

      foreach ($sandbox['inner_fields'] as $field) {

        // Get the data to copy.

        $data_rows = db_select("field_revision_{$field['field_name']}", 't')

          ->fields('t')

          ->condition('entity_type', 'field_collection_item')

          ->condition('revision_id', $field_collection_duplicated_revision_id)

          ->execute();

        // Add new copy of data with new revision id.

        while ($each_row = $data_rows->fetchAssoc()) {

          $each_row['revision_id'] = $new_revision_id;

          db_insert("field_revision_{$field['field_name']}")

            ->fields(array_keys($each_row), array_values($each_row))

            ->execute();

        }

      }

      // Update the host's field data with new revision number.

      db_update("field_revision_{$sandbox['field_name']}")

        ->fields(array("{$sandbox['field_name']}_revision_id" => $new_revision_id))

        ->condition('entity_type', $row_to_replace->entity_type)

        ->condition('revision_id', $row_to_replace->revision_id)

        ->condition('delta', $row_to_replace->delta)

        ->condition('language', $row_to_replace->language)

        ->execute();

    }

    if ($field_collection_item_current_revision == $field_collection_duplicated_revision_id) {

      _field_collection_update_7009_update_data($new_revision_id, $field_collection_duplicated_revision_id);

      // Update the current field collection item data in its host.

      db_update("field_data_{$sandbox['field_name']}")

        ->fields(array('revision_id' => $new_revision))

        ->condition('revision_id', $old_revision)

        ->condition('entity_type', $row_to_replace->entity_type)

        ->execute();

    }

    foreach ($modern_revisions as $each_modern_revision) {

      $new_revision_id = _field_collection_update_7009_new_revision($field_collection_item_id, $each_modern_revision, $sandbox['inner_fields'], $sandbox['field_name']);

      // Update inner fields with new revision number.

      foreach ($sandbox['inner_fields'] as $field) {

        db_update("field_revision_{$field['field_name']}")

          ->fields(array('revision_id' => $new_revision_id))

          ->condition('revision_id', $each_modern_revision->{$sandbox['field_name'] . '_revision_id'})

          ->condition('entity_type', 'field_collection_item')

          ->execute();

      }

      // Update the host's field data with new revision number.

      db_update("field_revision_{$sandbox['field_name']}")

        ->fields(array("{$sandbox['field_name']}_revision_id" => $new_revision_id))

        ->condition('entity_type', $each_modern_revision->entity_type)

        ->condition('revision_id', $each_modern_revision->revision_id)

        ->condition('delta', $each_modern_revision->delta)

        ->condition('language', $each_modern_revision->language)

        ->execute();

      if ($field_collection_item_current_revision == $each_modern_revision->{"{$sandbox['field_name']}_revision_id"}) {

        _field_collection_update_7009_update_data($new_revision_id, $each_modern_revision->{"{$sandbox['field_name']}_revision_id"});

        // Update the current field collection item data in its host.

        db_update("field_data_{$sandbox['field_name']}")

          ->fields(array('revision_id' => $new_revision))

          ->condition('revision_id', $old_revision)

          ->condition('entity_type', $each_modern_revision->entity_type)

          ->execute();

      }

      // Remove old copy of revision.

      db_delete('field_collection_item_revision')

        ->condition('revision_id', $each_modern_revision->revision_id)

        ->execute();

    }

    $sandbox['current_field_collection_item']++;

  }

  $sandbox['#finished'] = 0;

  if (count($vids) < $items_per_pass) {

    $sandbox['current_field']++;

    if ($sandbox['current_field'] == count($sandbox['field_collection_fields'])) {

      $sandbox['#finished'] = 1;

      return;

    }

    $sandbox['current_field_collection_item'] = 0;

    $sandbox['field_name'] = $sandbox['field_collection_fields'][$sandbox['current_field']];

    $sandbox['inner_fields'] = field_read_instances(array('entity_type' => 'field_collection_item', 'bundle' => $sandbox['field_name']));

  }

}

function _field_collection_update_7009_new_revision($field_collection_item_id, $row_to_replace, $inner_fields, $field_name) {

  // Add to field_collection_item_revision table.

  $new_revision_id = db_insert('field_collection_item_revision')

    ->fields(array('item_id'), array($field_collection_item_id))

    ->execute();

  return $new_revision_id;

}

function _field_collection_update_7009_update_data($new_revision, $old_revision) {

  // Update the current field collection item.

  db_update('field_collection_item')

    ->fields(array('revision_id' => $new_revision))

    ->condition('revision_id', $old_revision)

    ->execute();

}

   * @param \stdClass $collection

   * @param \stdClass $row

        if (property_exists($entity_old, $field) && !property_exists($collection, $field)) {

    if ($status !== FALSE || in_array($this->hostEntityType, array('node', 'field_collection_item'))) {

    return FALSE;

 *   The id of the revision to load.

 *

 * @return

 *   The entity object, or FALSE if there is no entity with the given revision

 *   id.

 * @param $ids

 *   An array of entity IDs, or FALSE to load all entities.

 * @param $conditions

 *   (deprecated) An associative array of conditions on the base table, where

 *   the keys are the database fields and the values are the values those

 *   fields must have. Instead, it is preferable to use EntityFieldQuery to

 *   retrieve a list of entity IDs loadable by this function.

 * @param $reset

 *   Whether to reset the internal cache for the requested entity type.

 *

      $count = substr_count($path, '/') + 1;

  if (isset($items['admin/structure/field-collections/%field_collection_field_name/fields']) && module_exists('field_ui')) {

 *

 * return string

 *

 * @return array

    'edit field collections' => array(

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

      'description' => t('Edit field collections.'),

    ),

 *

  if ($op != 'view' && isset($item) && !$item->isInUse()) {

  if (user_access('edit field collections', $account)) {

    return TRUE;

  }

  $hostEntity = $item->hostEntity() !== FALSE ? $item->hostEntity() : NULL;

  $entity_access = entity_access($op == 'view' ? 'view' : 'update', $item->hostEntityType(), $hostEntity, $account);

  return $entity_access && field_access($op, $field, $item->hostEntityType(), $hostEntity, $account);

    if (!empty($host_entity->revision) || isset($item['entity'])) {

        $un_item->updateHostEntity($host_entity, $host_entity_type);

  $ids = field_collection_field_item_to_ids($items);

  if ($ids && field_info_field($field['field_name'])) {

/**

 * Implements hook_field_load().

 *

 * Invokes the load hooks for the fields contained in new, unsaved field

 * collection items. This allows images inside a field collection item to be

 * seen on a node's preview page before it's saved.

 */

function field_collection_field_load($entity_type, $entities, $field, $instances, $langcode, &$items, $age) {

  foreach ($items as &$each_item) {

    foreach ($each_item as &$each_field_collection_item) {

      if (!empty($each_field_collection_item['entity'])) {

        _field_invoke_multiple('load', 'field_collection_item', array(NULL => &$each_field_collection_item['entity']));

      }

    }

  }

}

    if (!empty($item['revision_id'])

      && $entity = field_collection_item_revision_load($item['revision_id'])) {

      $entity->deleteRevision(TRUE);

  if (isset($item['entity'])) {

function field_collection_entity_preload($entities, $langcode, &$items, $fields) {

  static $local_entity_cache = array();

  $fc_ids = array();

  // Collect every possible term attached to any of the fieldable entities.

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

    foreach ($items[$id] as $delta => $item) {

      // Check if this item is in our local entity cache

      if (isset($local_entity_cache[$item['value']])) {

        $items[$id][$delta]['field_collection'] = $local_entity_cache[$item['value']];

        continue;

      }

      // Force the array key to prevent duplicates.

      $fc_ids[$item['value']] = $item['value'];

    }

  }

  if ($fc_ids) {

    $new_entities = array();

    $terms = field_collection_item_load_multiple($fc_ids);

    // Iterate through the fieldable entities again to attach the loaded

    // field collection data.

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

      $rekey = FALSE;

      foreach ($items[$id] as $delta => $item) {

        // Check whether the field collection field instance value could be loaded.

        if (isset($terms[$item['value']])) {

          // Replace the instance value with the term data.

          $e = $terms[$item['value']];

          $local_entity_cache[$item['value']] = $e;

          $items[$id][$delta]['field_collection'] = $e;

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

            if (isset($e->$field_name)) {

              $field_data = $e->$field_name;

              if (isset($field_data[$langcode])) {

                $new_entities[$e->item_id] = $e->item_id;

                $items[$e->item_id] = $field_data[$langcode];

              }

            }

          }

        }

        // Otherwise, unset the instance value, since the field colletion entity does not exist.

        else {

          unset($items[$id][$delta]);

          $rekey = TRUE;

        }

      }

      if ($rekey) {

        // Rekey the items array.

        $items[$id] = array_values($items[$id]);

      }

    }

    field_collection_entity_preload($new_entities, $langcode, $items, $fields);

  }

}

function field_collection_field_formatter_prepare_view($entity_type, $entities, $field, $instances, $langcode, &$items, $displays) {

  $fields = field_read_fields(array('type' => 'field_collection'));

  field_collection_entity_preload($entities, $langcode, $items, $fields);

}

        // Existing field collections should be loaded without cache so that

        // node Preview will work for both existing nodes and new ones.

        if (isset($item['entity']->item_id)) {

          // Load without cache.

          $field_collection = field_collection_item_load($item['entity']->item_id, TRUE);

        }

        else {

          $field_collection = field_collection_field_get_entity($item);

        }

        if ($field_collection) {

          $element[$delta]['entity'] = $field_collection->view($view_mode);

          $element[$delta]['entity'] = $field_collection->view($view_mode);

      if ($entity_type != 'node' && !empty($settings['description'])) {

    'field_collection_sorter' => array(

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

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

      'behaviors' => array(

        'multiple values' => FIELD_BEHAVIOR_CUSTOM,

        'default value' => FIELD_BEHAVIOR_DEFAULT,

      ),

    ),

      if ($delta > 0 && $delta == $field_state['items_count'] && field_collection_hide_blank_items($field)) {

      if ($field_state['items_count'] == 0 && field_collection_hide_blank_items($field)) {

    case 'field_collection_sorter':

      $elements = array();

      $field_name = $field['field_name'];

      $parents = $form['#parents'];

      $field_state = field_form_get_state($parents, $field_name, $langcode, $form_state);

      $count = $field_state['items_count'];

      for ($delta = 0; $delta < $count; $delta++) {

        $item_id = isset($items[$delta]['value']) ? $items[$delta]['value'] : NULL;

        $revision_id = isset($items[$delta]['revision_id']) ? $items[$delta]['revision_id'] : NULL;

        // add a label component to visually identify this field collection item

        $element['label'] = array();

        if ($item_id) {

          $item = field_collection_item_load($item_id);

          $element['label']['#markup'] = $item ? $item->label() : $item_id;

        }

        // the field stored value (item_id) and revision_id values

        // so we need hidden fields to represent them

        $element['value'] = array(

          '#type' => 'hidden',

          '#default_value' => $item_id,

        );

        $element['revision_id'] = array(

          '#type' => 'hidden',

          '#default_value' => $revision_id,

        );

        // Input field for the delta (drag-n-drop reordering).

        // We name the element '_weight' to avoid clashing with elements

        // defined by widget.

        $element['_weight'] = array(

          '#type' => 'weight',

          '#title' => t('Weight for row @number', array('@number' => $delta + 1)),

          '#title_display' => 'invisible',

          // Note: this 'delta' is the FAPI 'weight' element's property.

          '#delta' => $count,

          '#default_value' => isset($items[$delta]['_weight']) ? $items[$delta]['_weight'] : $delta,

          '#weight' => 100,

        );

        $elements[$delta] = $element;

      }

      if ($elements) {

        $elements += array(

          '#theme' => 'field_multiple_value_form',

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

          '#cardinality' => $field['cardinality'],

          '#title' => check_plain($instance['label']),

          '#required' => FALSE,

          '#description' => field_filter_xss($instance['description']),

          '#max_delta' => $count-1,

        );

      }

      return $elements;

        && field_access('edit', $field, $entity_type)) {

        && $field['settings']['hide_blank_items']

        && $form[$field_name][$element_langcode][0]['#entity'] instanceof FieldCollectionItemEntity

        && field_collection_item_is_empty($form[$field_name][$element_langcode][0]['#entity'])) {

    if ($field['cardinality'] == FIELD_CARDINALITY_UNLIMITED

        && $instance['widget']['type'] === 'field_collection_embed'

        && $field['type'] === 'field_collection') {

  if ($entity_type === 'field_collection_item'

    if (count($item) > 1) {

      // If $item contains more thing than 'entity', then it is sent from VBO.

      // We clone the object to avoid that the same field collection item of the

      // faked object is attached to multiple host objects.

      return clone $item['entity'];

    }

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

  if (isset($field_name) && !isset($item['entity'])) {

  if (!empty($element['#field_collection_required_elements']) && !field_collection_item_is_empty($field_collection_item)) {

          if (is_array($field_values) && count($elements['#array_parents']) < $field_depth) {

  if ($form_state['submitted'] && !form_get_error($element)) {

/**

 * Entity property info getter callback for the host entity property.

 */

function field_collection_item_get_specific_type_host_entity($item, array $options, $name) {

  // These properties' machine names have the form "host_entity_TYPE".

  if (substr($name, 0, 12) !== 'host_entity_') {

    return NULL;

  }

  return $item->hostEntityType() === substr($name, 12) ? $item->hostEntity() : NULL;

}

      elseif (is_array($value) && isset($value['value'], $value['revision_id'])) {

  if (field_behaviors_widget('multiple values', $instance) == FIELD_BEHAVIOR_CUSTOM) {

    return devel_generate_multiple('_field_collection_devel_generate', $object, $field, $instance, $bundle);

  }

  return _field_collection_devel_generate($object, $field, $instance, $bundle);

}

function _field_collection_devel_generate($object, $field, $instance, $bundle) {

            // Check if this field collection item belongs to the source language

            if (!isset($field_value['entity'])

              && ($fc_entity = field_collection_field_get_entity($field_value))

              && in_array($fc_entity->item_id, $source_items)) {

              // Clone the field collection item

              $new_fc_entity = clone $fc_entity;

              $new_fc_entity->item_id = NULL;

              $new_fc_entity->revision_id = NULL;

              $new_fc_entity->is_new = TRUE;

              // Set the new entity for saving it later

              $entity->{$field_name}[$language][$delta]['entity'] = $new_fc_entity;

            }

          }

        }

      }

    }

  }

}

/**

 * Implements hook_feeds_processor_targets_alter()

 */

function field_collection_feeds_processor_targets_alter(&$targets, $entity_type, $bundle_name) {

  // Load up.

  $loaded = &drupal_static(__FUNCTION__, FALSE);

  if (!$loaded) {

    $loaded = TRUE;

    $path = drupal_get_path('module', 'feeds') . '/mappers';

    $files = drupal_system_listing('/.*\.inc$/', $path, 'name', 0);

    foreach ($files as $file) {

      if (strpos($file->uri, '/mappers/') !== FALSE) {

        require_once DRUPAL_ROOT . '/' . $file->uri;

      }

    }

  }

  foreach (field_info_instances($entity_type, $bundle_name) as $name => $instance) {

    $info = field_info_field($name);

    if ($info['type'] == 'field_collection') {

      $sub_type = 'field_collection_item';

      $new_targets = module_invoke_all('feeds_processor_targets', $sub_type, $info['field_name']);

      drupal_alter('feeds_processor_targets', $new_targets, $sub_type, $info['field_name']);

      foreach ($new_targets as $sub_name => $target) {

        $new_name = t($info['field_name']) . ':' . t($sub_name);

        $targets[$new_name] = $target;

        if (isset($target['name'])) {

          $targets[$new_name]['name'] = $instance['label'] . ':' . $target['name'];

        }

        // We override callback for now and retrieve original later.

        $targets[$new_name]['callback'] = 'field_collection_feeds_set_target';

      }

    }

  }

}

/**

 * Process Field Collection items.

 *

 * @param  [type] $source       [description]

 * @param  [type] $entity       [description]

 * @param  [type] $target       [description]

 * @param  [type] $value        [description]

 * @param  [type] $main_mapping [description]

 * @return [type]               [description]

 */

function field_collection_feeds_set_target($source, $entity, $target, $value, $main_mapping) {

  $sub_targets = &drupal_static(__FUNCTION__, array());

  $args = explode(':', $target);

  $target = array_shift($args);

  $sub_target = implode(':', $args);

  $sub_type = 'field_collection_item';

  $new_targets = module_invoke_all('feeds_processor_targets', $sub_type, $target);

  drupal_alter('feeds_processor_targets', $new_targets, $sub_type, $target);

  // Now we retrieve old callbacks and keep then on a static cache.

  if (!isset($sub_targets[$target])) {

    $sub_targets[$target] = array();

    drupal_alter('feeds_processor_targets', $sub_targets[$target], $sub_type, $target);

  }

  $_sub_targets = $new_targets;

  $value = is_array($value) ? $value : array($value);

  $info = field_info_field($target);