Club Drupal

 *   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);

  // Iterate over all values.

  $delta = 0;

  $field = isset($entity->$target) ? $entity->$target : array();

  try {

    // $delta = which FC instance.

    // We iterate by subfield, not by FC.

    while (isset($value[$delta])) {

      // Zero out.

      $field_collection_item = null;

      // FC is already set on host entity.

      if (isset($field[LANGUAGE_NONE][$delta]['entity'])) {

        $field_collection_item = $field[LANGUAGE_NONE][$delta]['entity'];

      }

      // FC is on host entity, we have FC item_id, but FC is not loaded.

      elseif (isset($field[LANGUAGE_NONE][$delta]['value'])) {

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

        // Zero out field so that we don't just keep accumulating values.

        unset($field_collection_item->{$sub_target}[LANGUAGE_NONE] );

      }

      // Host entity does not have any attached FCs yet.

      if (empty($field_collection_item)) {

        $field_collection_item = entity_create('field_collection_item', array('field_name' => $target));

        $field_collection_item->setHostEntity($entity->feeds_item->entity_type, $entity);

      }

      $sub_mapping = array();

      $config = $source->importer()->getConfig();

      if (!empty($config['processor']['config']['mappings'])) {

        foreach ($config['processor']['config']['mappings'] as $mapping) {

          if ($mapping['target'] == $target . ':' . $sub_target) {

            $sub_mapping = $mapping;

            $sub_mapping['target'] = $sub_target;

            // Needs language or feeds mappers shout php notices.

            $sub_mapping['language'] = !empty($config['processor']['config']['language']) ? $config['processor']['config']['language'] : LANGUAGE_NONE;

            break;

          }

        }

      }

      if (isset($_sub_targets[$sub_target]['callback']) && function_exists($_sub_targets[$sub_target]['callback'])) {

        $callback = $_sub_targets[$sub_target]['callback'];

        // Normalize

        if (!is_array($value[$delta])) {

          $value[$delta] = array($value[$delta]);

        }

        // Check for a limit and force that limit.

        if ($info['cardinality'] !== '-1') {

          $value[$delta] = array_slice($value[$delta], 0, $info['cardinality']);

        }

        // HiJack the file callback so we can make it work.

        if ($callback == 'file_feeds_set_target') {

          $callback = 'field_collection_file_feeds_set_target';

        }

        // Allow altering with many parameters. Cannot use drupal_alter here.

        $implements = module_implements('sub_target_pre_callback_parse');

        foreach ($implements as $module_name) {

          $hook = $module_name . '_' . 'sub_target_pre_callback_parse';

          $hook($target, $sub_target, $entity, $field, $field_collection_item, $value[$delta]);

        }

        $callback($source, $field_collection_item, $sub_target, $value[$delta], $sub_mapping);

      }

      // No need to save the field collection here. Just wait until the node is saved.

      // If we save the FC here we get a huge performance degregation.

      $field[LANGUAGE_NONE][$delta]['entity'] = $field_collection_item;

      // Break when only hitting the max delta.

      if ($info['cardinality'] == $delta) {

        break;

      }

      $delta++;

    }

  }

  catch (Exception $e) {

    drupal_set_message($e->getMessage(), 'error');

    watchdog_exception('field_collection', $e, $e->getMessage());

    throw $e;

  }

  $entity->{$target} = $field;

}

/**

 * Wrapper function for file_feeds_set_target as it doesn't do the nested stuff.

 */

function field_collection_file_feeds_set_target($source, $entity, $target, $value) {

  if (empty($value)) {

    return;

  }

  module_load_include('inc', 'file');

  // Make sure $value is an array of objects of type FeedsEnclosure.

  if (!is_array($value)) {

    $value = array($value);

  }

  foreach ($value as $k => $v) {

    if (!($v instanceof FeedsEnclosure)) {

      if (is_string($v)) {

        $value[$k] = new FeedsEnclosure($v, file_get_mimetype($v));

      }

      else {

        unset($value[$k]);

      }

    }

  }

  if (empty($value)) {

    return;

  }

  $entity_type = 'field_collection_item';

  $bundle = $entity->field_name;

  // Determine file destination.

  // @todo This needs review and debugging.

  $instance_info = field_info_instance($entity_type, $target, $bundle);

  $info = field_info_field($target);

  $data = array();

  if (!empty($entity->uid)) {

    $data[$entity_type] = $entity;

  }

  $destination = file_field_widget_uri($info, $instance_info, $data);

  // Populate entity.

  $i = 0;

  $field = isset($entity->$target) ? $entity->$target : array();

  foreach ($value as $v) {

    $file = FALSE;

    try {

      $v->setAllowedExtensions($instance_info['settings']['file_extensions']);

      $file = $v->getFile($destination);

    }

    catch (Exception $e) {

      watchdog('feeds', check_plain($e->getMessage()));

    }

    if ($file) {

      $field[LANGUAGE_NONE][$i] = (array)$file;

      $field[LANGUAGE_NONE][$i]['display'] = 1; // @todo: Figure out how to properly populate this field.

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

        break;

      }

      $i++;

    }

  }

  $entity->{$target} = $field;

}

/**

 * Implementation of hook_feeds_presave().

 * Invoked before a feed item is saved.

 *

 * @param FeedsSource $source

 *   FeedsSource object that describes the source that is being imported.

 * @param $entity

 *   The entity object.

 * @param array $item

 *   The parser result for this entity.

 * @param int|null $entity_id

 *   The id of the current item which is going to be updated. If this is a new

 *   item, then NULL is passed.

 */

function field_collection_feeds_presave(FeedsSource $source, $entity, $item, $entity_id) {

  $feed_config = $source->importer()->getConfig();

  $mappings = $feed_config['processor']['config']['mappings'];

  // Only hook in when updating the entity.

  if (empty($entity_id)) {

    // Go through $mappings and find the FC fields.

    foreach ($mappings as $mapping) {

      if (strpos($mapping['target'], ':') !== FALSE) {

        $parts = explode(':', $mapping['target']);

        $fc_name = array_shift($parts);

        $info = field_info_field($fc_name);

        // If the field is not a field collection, skip it.

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

          continue;

        }

        if (isset($entity->{$fc_name})) {

          foreach ($entity->{$fc_name}[LANGUAGE_NONE] as $delta => $fc_unloaded) {

            // If an FC is not loaded, we don't want it. Unset it so it won't save.

            if (!isset($entity->{$fc_name}[LANGUAGE_NONE][$delta]['entity'])) {

              unset($entity->{$fc_name}[LANGUAGE_NONE][$delta]);