public function ContentTypeGroupController::load in Content type groups 7.2

Overridden.

In contrast to the parent implementation, multiple rows are grouped by field type to handle multiple content types for each CTG. This is identical to parent::load() except for the marked section.

Overrides EntityAPIController::load

See also

EntityAPIController#load($ids, $conditions)

File

./content_type_groups.controller.inc, line 104

Contains controllers and entity hooks for the content_type_group entity.

Class

ContentTypeGroupController

Content Type Group controller (equivalent to a model in MVC).

Code

public function load($ids = array(), $conditions = array()) {
  $entities = array();

  // Revisions are not statically cached, and require a different query to
  // other conditions, so separate the revision id into its own variable.
  if ($this->revisionKey && isset($conditions[$this->revisionKey])) {
    $revision_id = $conditions[$this->revisionKey];
    unset($conditions[$this->revisionKey]);
  }
  else {
    $revision_id = FALSE;
  }

  // Create a new variable which is either a prepared version of the $ids
  // array for later comparison with the entity cache, or FALSE if no $ids
  // were passed. The $ids array is reduced as items are loaded from cache,
  // and we need to know if it's empty for this reason to avoid querying the
  // database when all requested entities are loaded from cache.
  $passed_ids = !empty($ids) ? array_flip($ids) : FALSE;

  // Try to load entities from the static cache.
  if ($this->cache && !$revision_id) {
    $entities = $this
      ->cacheGet($ids, $conditions);

    // If any entities were loaded, remove them from the ids still to load.
    if ($passed_ids) {
      $ids = array_keys(array_diff_key($passed_ids, $entities));
    }
  }

  // Support the entitycache module if activated.
  if (!empty($this->entityInfo['entity cache']) && !$revision_id && $ids && !$conditions) {
    $cached_entities = EntityCacheControllerHelper::entityCacheGet($this, $ids, $conditions);

    // If any entities were loaded, remove them from the ids still to load.
    $ids = array_diff($ids, array_keys($cached_entities));
    $entities += $cached_entities;

    // Add loaded entities to the static cache if we are not loading a
    // revision.
    if ($this->cache && !empty($cached_entities) && !$revision_id) {
      $this
        ->cacheSet($cached_entities);
    }
  }

  // Load any remaining entities from the database. This is the case if $ids
  // is set to FALSE (so we load all entities), if there are any ids left to
  // load or if loading a revision.
  if (!($this->cacheComplete && $ids === FALSE && !$conditions) && ($ids === FALSE || $ids || $revision_id)) {
    $queried_entities = array();
    foreach ($this
      ->query($ids, $conditions, $revision_id) as $record) {

      // Skip entities already retrieved from cache.
      if (isset($entities[$record->{$this->idKey}])) {
        continue;
      }

      // For DB-based entities take care of serialized columns.
      if (!empty($this->entityInfo['base table'])) {
        $schema = drupal_get_schema($this->entityInfo['base table']);
        foreach ($schema['fields'] as $field => $info) {
          if (!empty($info['serialize']) && isset($record->{$field})) {
            $record->{$field} = unserialize($record->{$field});

            // Support automatic merging of 'data' fields into the entity.
            if (!empty($info['merge']) && is_array($record->{$field})) {
              foreach ($record->{$field} as $key => $value) {
                $record->{$key} = $value;
              }
              unset($record->{$field});
            }
          }
        }
      }

      // THIS IS THE ONLY PART OVERRIDDEN FROM PARENT
      $all_node_types = node_type_get_names();
      if (isset($queried_entities[$record->{$this->idKey}])) {
        $queried_entities[$record->{$this->idKey}]->content_types[$record->content_type] = array(
          'name' => $all_node_types[$record->content_type],
          '#weight' => $record->weight,
        );
      }
      else {
        $content_type = array(
          'name' => $all_node_types[$record->content_type],
          '#weight' => $record->weight,
        );
        $record->content_types = array(
          $record->content_type => $content_type,
        );
        unset($record->content_type);
        unset($record->weight);
        $queried_entities[$record->{$this->idKey}] = $record;
      }

      // END OVERRIDE
    }
  }

  // Pass all entities loaded from the database through $this->attachLoad(),
  // which attaches fields (if supported by the entity type) and calls the
  // entity type specific load callback, for example hook_node_load().
  if (!empty($queried_entities)) {
    $this
      ->attachLoad($queried_entities, $revision_id);
    $entities += $queried_entities;
  }

  // Entitycache module support: Add entities to the entity cache if we are
  // not loading a revision.
  if (!empty($this->entityInfo['entity cache']) && !empty($queried_entities) && !$revision_id) {
    EntityCacheControllerHelper::entityCacheSet($this, $queried_entities);
  }
  if ($this->cache) {

    // Add entities to the cache if we are not loading a revision.
    if (!empty($queried_entities) && !$revision_id) {
      $this
        ->cacheSet($queried_entities);

      // Remember if we have cached all entities now.
      if (!$conditions && $ids === FALSE) {
        $this->cacheComplete = TRUE;
      }
    }
  }

  // Ensure that the returned array is ordered the same as the original
  // $ids array if this was passed in and remove any invalid ids.
  if ($passed_ids && ($passed_ids = array_intersect_key($passed_ids, $entities))) {
    foreach ($passed_ids as $id => $value) {
      $passed_ids[$id] = $entities[$id];
    }
    $entities = $passed_ids;
  }
  return $entities;
}