You are here

Home » API reference » Content type groups 7.2 » content_type_groups.controller.inc

class ContentTypeGroupController in Content type groups 7.2

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

Hierarchy

Expanded class hierarchy of ContentTypeGroupController

1 string reference to 'ContentTypeGroupController'
content_type_groups_entity_info in ./content_type_groups.module
Implements hook_entity_info().

File

./content_type_groups.controller.inc, line 74
Contains controllers and entity hooks for the content_type_group entity.

View source 
class ContentTypeGroupController extends EntityAPIController {
  public function create(array $values = array()) {
    $values += array(
      'type' => NULL,
      'name' => '',
      'content_types' => array(),
    );
    return parent::create($values);
  }
  protected function buildQuery($ids, $conditions = array(), $revision_id = FALSE) {
    $query = parent::buildQuery($ids, $conditions, $revision_id);

    // Specify additional fields from the user and node tables.
    $query
      ->leftJoin('content_type_groups_types', 't', 'base.type = t.group_type');
    $query
      ->addField('t', 'content_type', 'content_type');
    $query
      ->addField('t', 'weight', 'weight');
    return $query;
  }

  /**
   * Overridden.
   * @see EntityAPIController#load($ids, $conditions)
   *
   * 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.
   */
  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;
  }

}

Members

Namesort descending Modifiers Type Description Overrides
ContentTypeGroupController::buildQuery protected function Overrides DrupalDefaultEntityController::buildQuery(). Overrides EntityAPIController::buildQuery
ContentTypeGroupController::create public function Implements EntityAPIControllerInterface. Overrides EntityAPIController::create
ContentTypeGroupController::load public function Overridden. Overrides EntityAPIController::load
DrupalDefaultEntityController::$cache protected property Whether this entity type should use the static cache.
DrupalDefaultEntityController::$entityCache protected property Static cache of entities, keyed by entity ID.
DrupalDefaultEntityController::$entityInfo protected property Array of information about the entity.
DrupalDefaultEntityController::$entityType protected property Entity type for this controller instance.
DrupalDefaultEntityController::$hookLoadArguments protected property Additional arguments to pass to hook_TYPE_load().
DrupalDefaultEntityController::$idKey protected property Name of the entity's ID field in the entity database table.
DrupalDefaultEntityController::$revisionKey protected property Name of entity's revision database table field, if it supports revisions.
DrupalDefaultEntityController::$revisionTable protected property The table that stores revisions, if the entity supports revisions.
DrupalDefaultEntityController::attachLoad protected function Attaches data to entities upon loading. 4
DrupalDefaultEntityController::cacheGet protected function Gets entities from the static cache. 1
DrupalDefaultEntityController::cacheSet protected function Stores entities in the static entity cache.
DrupalDefaultEntityController::cleanIds protected function Ensures integer entity IDs are valid.
DrupalDefaultEntityController::filterId protected function Callback for array_filter that removes non-integer IDs.
EntityAPIController::$bundleKey protected property
EntityAPIController::$cacheComplete protected property
EntityAPIController::$defaultRevisionKey protected property
EntityAPIController::buildContent public function Implements EntityAPIControllerInterface. Overrides EntityAPIControllerInterface::buildContent
EntityAPIController::delete public function Implements EntityAPIControllerInterface. Overrides EntityAPIControllerInterface::delete 1
EntityAPIController::deleteRevision public function Implements EntityAPIControllerRevisionableInterface::deleteRevision(). Overrides EntityAPIControllerRevisionableInterface::deleteRevision
EntityAPIController::export public function Implements EntityAPIControllerInterface. Overrides EntityAPIControllerInterface::export 1
EntityAPIController::import public function Implements EntityAPIControllerInterface. Overrides EntityAPIControllerInterface::import
EntityAPIController::invoke public function Implements EntityAPIControllerInterface. Overrides EntityAPIControllerInterface::invoke 1
EntityAPIController::query public function Builds and executes the query for loading.
EntityAPIController::renderEntityProperty protected function Renders a single entity property.
EntityAPIController::resetCache public function Overrides DrupalDefaultEntityController::resetCache(). Overrides DrupalDefaultEntityController::resetCache 1
EntityAPIController::save public function Implements EntityAPIControllerInterface. Overrides EntityAPIControllerInterface::save 1
EntityAPIController::saveRevision protected function Saves an entity revision.
EntityAPIController::view public function Implements EntityAPIControllerInterface. Overrides EntityAPIControllerInterface::view 1
EntityAPIController::__construct public function Overridden. Overrides DrupalDefaultEntityController::__construct 1