/**
  * Checks block revision related operations.
  */
 public function testRevisions()
 {
     $blocks = $this->blocks;
     $logs = $this->revisionLogs;
     foreach ($blocks as $delta => $revision_id) {
         // Confirm the correct revision text appears.
         $loaded = entity_revision_load('block_content', $revision_id);
         // Verify revision log is the same.
         $this->assertEqual($loaded->getRevisionLog(), $logs[$delta], format_string('Correct log message found for revision !revision', array('!revision' => $loaded->getRevisionId())));
     }
     // Confirm that this is the default revision.
     $this->assertTrue($loaded->isDefaultRevision(), 'Third block revision is the default one.');
     // Make a new revision and set it to not be default.
     // This will create a new revision that is not "front facing".
     // Save this as a non-default revision.
     $loaded->setNewRevision();
     $loaded->isDefaultRevision(FALSE);
     $loaded->body = $this->randomMachineName(8);
     $loaded->save();
     $this->drupalGet('block/' . $loaded->id());
     $this->assertNoText($loaded->body->value, 'Revision body text is not present on default version of block.');
     // Verify that the non-default revision id is greater than the default
     // revision id.
     $default_revision = entity_load('block_content', $loaded->id());
     $this->assertTrue($loaded->getRevisionId() > $default_revision->getRevisionId(), 'Revision id is greater than default revision id.');
 }

 /**
  * {@inheritdoc}
  *
  * Mark the accessible IDs a user can see. We do not unset unaccessible
  * values, as other may want to act on those values, even if they can
  * not be accessed.
  */
 public function prepareView(array $entities_items)
 {
     $target_ids = array();
     $revision_ids = array();
     // Collect every possible entity attached to any of the entities.
     foreach ($entities_items as $items) {
         foreach ($items as $item) {
             if (!empty($item->revision_id)) {
                 $revision_ids[] = $item->revision_id;
             } elseif (!empty($item->target_id)) {
                 $target_ids[] = $item->target_id;
             }
         }
     }
     $target_type = $this->getFieldSetting('target_type');
     $target_entities = array();
     if ($target_ids) {
         $target_entities = entity_load_multiple($target_type, $target_ids);
     }
     if ($revision_ids) {
         // We need to load the revisions one by-one.
         foreach ($revision_ids as $revision_id) {
             $target_entity = entity_revision_load($target_type, $revision_id);
             // Use the revision ID in the key.
             $identifier = $target_entity->id() . ':' . $revision_id;
             $target_entities[$identifier] = $target_entity;
         }
     }
     // Iterate through the fieldable entities again to attach the loaded data.
     foreach ($entities_items as $items) {
         $rekey = FALSE;
         foreach ($items as $item) {
             // If we have a revision ID, the key uses it as well.
             $identifier = !empty($item->revision_id) ? $item->target_id . ':' . $item->revision_id : $item->target_id;
             if ($item->target_id !== 0) {
                 if (!isset($target_entities[$identifier])) {
                     // The entity no longer exists, so empty the item.
                     $item->setValue(NULL);
                     $rekey = TRUE;
                     continue;
                 }
                 $item->entity = $target_entities[$identifier];
                 if (!$item->entity->access('view')) {
                     continue;
                 }
             } else {
                 // This is an "auto_create" item, just leave the entity in place.
             }
             // Mark item as accessible.
             $item->access = TRUE;
         }
         // Rekey the items array if needed.
         if ($rekey) {
             $items->filterEmptyItems();
         }
     }
 }

 /**
  * {@inheritdoc}
  */
 public function getTarget()
 {
     if (!isset($this->target) && isset($this->revision_id)) {
         // If we have a valid reference, return the entity's TypedData adapter.
         $entity = entity_revision_load($this->getTargetDefinition()->getEntityTypeId(), $this->revision_id);
         $this->target = isset($entity) ? $entity->getTypedData() : NULL;
     }
     return $this->target;
 }

 /**
  * Executes the revision tests for the given entity type.
  *
  * @param string $entity_type
  *   The entity type to run the tests with.
  */
 protected function runRevisionsTests($entity_type)
 {
     // Create initial entity.
     $entity = $this->container->get('entity_type.manager')->getStorage($entity_type)->create(array('name' => 'foo', 'user_id' => $this->webUser->id()));
     $entity->field_test_text->value = 'bar';
     $entity->save();
     $names = array();
     $texts = array();
     $created = array();
     $revision_ids = array();
     // Create three revisions.
     $revision_count = 3;
     for ($i = 0; $i < $revision_count; $i++) {
         $legacy_revision_id = $entity->revision_id->value;
         $legacy_name = $entity->name->value;
         $legacy_text = $entity->field_test_text->value;
         $entity = entity_load($entity_type, $entity->id->value);
         $entity->setNewRevision(TRUE);
         $names[] = $entity->name->value = $this->randomMachineName(32);
         $texts[] = $entity->field_test_text->value = $this->randomMachineName(32);
         $created[] = $entity->created->value = time() + $i + 1;
         $entity->save();
         $revision_ids[] = $entity->revision_id->value;
         // Check that the fields and properties contain new content.
         $this->assertTrue($entity->revision_id->value > $legacy_revision_id, format_string('%entity_type: Revision ID changed.', array('%entity_type' => $entity_type)));
         $this->assertNotEqual($entity->name->value, $legacy_name, format_string('%entity_type: Name changed.', array('%entity_type' => $entity_type)));
         $this->assertNotEqual($entity->field_test_text->value, $legacy_text, format_string('%entity_type: Text changed.', array('%entity_type' => $entity_type)));
     }
     for ($i = 0; $i < $revision_count; $i++) {
         // Load specific revision.
         $entity_revision = entity_revision_load($entity_type, $revision_ids[$i]);
         // Check if properties and fields contain the revision specific content.
         $this->assertEqual($entity_revision->revision_id->value, $revision_ids[$i], format_string('%entity_type: Revision ID matches.', array('%entity_type' => $entity_type)));
         $this->assertEqual($entity_revision->name->value, $names[$i], format_string('%entity_type: Name matches.', array('%entity_type' => $entity_type)));
         $this->assertEqual($entity_revision->field_test_text->value, $texts[$i], format_string('%entity_type: Text matches.', array('%entity_type' => $entity_type)));
         // Check non-revisioned values are loaded.
         $this->assertTrue(isset($entity_revision->created->value), format_string('%entity_type: Non-revisioned field is loaded.', array('%entity_type' => $entity_type)));
         $this->assertEqual($entity_revision->created->value, $created[2], format_string('%entity_type: Non-revisioned field value is the same between revisions.', array('%entity_type' => $entity_type)));
     }
     // Confirm the correct revision text appears in the edit form.
     $entity = entity_load($entity_type, $entity->id->value);
     $this->drupalGet($entity_type . '/manage/' . $entity->id->value . '/edit');
     $this->assertFieldById('edit-name-0-value', $entity->name->value, format_string('%entity_type: Name matches in UI.', array('%entity_type' => $entity_type)));
     $this->assertFieldById('edit-field-test-text-0-value', $entity->field_test_text->value, format_string('%entity_type: Text matches in UI.', array('%entity_type' => $entity_type)));
 }

/**
 * fix to get values from nested field collections nested in other field collections 
 *
 * @param string[] $fields is an array of strings that represents the levels of the nest - so array('content_column', 'column_title') woud be for content title in content column
 * @param mixed[] $collection is a...it's "drupal magic" which is more like drupal voodoo and the tpls are the pin-cusion dolls linked to your soul and every time you hack them it causes physical pain
 * @param string $value is a bunch of who-cares
 * @param mixed $default is null - recently a stackoverflow.com survey listed back-end web devs as the least satisfied with their jobs that is not a joke but right now is making it sad and funny at the same time
 * @return mixed[]
 */
function mos_field_collection_nested_values($fields, $collection, $value = 'value', $default = null)
{
    $collection = mos_array_first($collection['entity']['field_collection_item']);
    $values = array();
    $collections = array();
    $fields = array_values($fields);
    foreach ($fields as $key => $field) {
        $fields[$key] = 'field_' . mos_preg_remove('/^field_/', $field);
    }
    foreach (mos_array_get(mos_array_get($collection, $fields[0], array()), '#items', array()) as $item) {
        //$collections[] = mos_array_first(mos_object_to_array(entity_load('field_collection_item', array($item['value']))));
        $collections[] = mos_object_to_array(entity_revision_load('field_collection_item', $item['revision_id']));
    }
    foreach ($collections as $key => $collection) {
        $values[$key] = array();
        foreach (mos_array_get(mos_array_get($collection, $fields[1], $default), 'und', array()) as $key2 => $nested) {
            $values[$key][$key2] = $nested[$value];
        }
    }
    return $values;
}

  /**
   * Loads all entities contained in the passed-in $results.
   *.
   * If the entity belongs to the base table, then it gets stored in
   * $result->_entity. Otherwise, it gets stored in
   * $result->_relationship_entities[$relationship_id];
   *
   * @param \Drupal\views\ResultRow[] $results
   *   The result of the SQL query.
   */
  public function loadEntities(&$results) {
    $entity_information = $this->getEntityTableInfo();
    // No entity tables found, nothing else to do here.
    if (empty($entity_information)) {
      return;
    }

    // Extract all entity types from entity_information.
    $entity_types = array();
    foreach ($entity_information as $info) {
      $entity_type = $info['entity_type'];
      if (!isset($entity_types[$entity_type])) {
        $entity_types[$entity_type] = \Drupal::entityManager()->getDefinition($entity_type);
      }
    }

    // Assemble a list of entities to load.
    $ids_by_type = array();
    foreach ($entity_information as $info) {
      $relationship_id = $info['relationship_id'];
      $entity_type = $info['entity_type'];
      $entity_info = $entity_types[$entity_type];
      $id_key = !$info['revision'] ? $entity_info->getKey('id') : $entity_info->getKey('revision');
      $id_alias = $this->getFieldAlias($info['alias'], $id_key);

      foreach ($results as $index => $result) {
        // Store the entity id if it was found.
        if (isset($result->{$id_alias}) && $result->{$id_alias} != '') {
          $ids_by_type[$entity_type][$index][$relationship_id] = $result->$id_alias;
        }
      }
    }

    // Load all entities and assign them to the correct result row.
    foreach ($ids_by_type as $entity_type => $ids) {
      $flat_ids = iterator_to_array(new \RecursiveIteratorIterator(new \RecursiveArrayIterator($ids)), FALSE);

      // Drupal core currently has no way to load multiple revisions. Sad.
      if (isset($entity_information[$entity_type]['revision']) && $entity_information[$entity_type]['revision'] === TRUE) {
        $entities = array();
        foreach ($flat_ids as $revision_id) {
          $entity = entity_revision_load($entity_type, $revision_id);
          if ($entity) {
            $entities[$revision_id] = $entity;
          }
        }
      }
      else {
        $entities = entity_load_multiple($entity_type, $flat_ids);
      }

      foreach ($ids as $index => $relationships) {
        foreach ($relationships as $relationship_id => $entity_id) {
          if (isset($entities[$entity_id])) {
            $entity = $entities[$entity_id];
          }
          else {
            $entity = NULL;
          }

          if ($relationship_id == 'none') {
            $results[$index]->_entity = $entity;
          }
          else {
            $results[$index]->_relationship_entities[$relationship_id] = $entity;
          }
        }
      }
    }
  }

 /**
  * Loads all entities contained in the passed-in $results.
  *.
  * If the entity belongs to the base table, then it gets stored in
  * $result->_entity. Otherwise, it gets stored in
  * $result->_relationship_entities[$relationship_id];
  */
 function loadEntities(&$results)
 {
     $entity_information = $this->getEntityTableInfo();
     // No entity tables found, nothing else to do here.
     if (empty($entity_information)) {
         return;
     }
     // Assemble a list of entities to load.
     $ids_by_type = array();
     foreach ($entity_information as $entity_type => $info) {
         $entity_info = \Drupal::entityManager()->getDefinition($entity_type);
         $id_key = empty($table['revision']) ? $entity_info->getKey('id') : $entity_info->getKey('revision');
         $id_alias = $this->getFieldAlias($info['alias'], $id_key);
         foreach ($results as $index => $result) {
             // Store the entity id if it was found.
             if (isset($result->{$id_alias}) && $result->{$id_alias} != '') {
                 $ids_by_type[$entity_type][$index] = $result->{$id_alias};
             }
         }
     }
     // Load all entities and assign them to the correct result row.
     foreach ($ids_by_type as $entity_type => $ids) {
         $info = $entity_information[$entity_type];
         $relationship_id = $info['relationship_id'];
         // Drupal core currently has no way to load multiple revisions. Sad.
         if ($info['revision']) {
             $entities = array();
             foreach ($ids as $revision_id) {
                 $entity = entity_revision_load($entity_type, $revision_id);
                 if ($entity) {
                     $entities[$revision_id] = $entity;
                 }
             }
         } else {
             $entities = entity_load_multiple($entity_type, $ids);
         }
         foreach ($ids as $index => $id) {
             if (isset($entities[$id])) {
                 $entity = $entities[$id];
             } else {
                 $entity = NULL;
             }
             if ($relationship_id == 'none') {
                 $results[$index]->_entity = $entity;
             } else {
                 $results[$index]->_relationship_entities[$relationship_id] = $entity;
             }
         }
     }
 }

 /**
  * Check if the field translation attached to the entity revision identified
  * by the passed arguments were correctly stored.
  */
 private function checkTranslationRevisions($id, $revision_id, $available_langcodes)
 {
     $field_name = $this->fieldStorage->getName();
     $entity = entity_revision_load($this->entityTypeId, $revision_id);
     foreach ($available_langcodes as $langcode => $value) {
         $passed = $entity->getTranslation($langcode)->{$field_name}->value == $value + 1;
         $this->assertTrue($passed, format_string('The @language translation for revision @revision was correctly stored', array('@language' => $langcode, '@revision' => $entity->getRevisionId())));
     }
 }

 public function setRevision($revision_id)
 {
     $revision = \entity_revision_load($this->type(), $revision_id);
     if (!$revision) {
         return false;
     }
     $this->definition = $revision;
     return true;
 }