public function unhandleField($entity_type, $field_type, $field_name, &$value)
{
if (!is_array($value)) {
return;
}
if (!array_key_exists('url', $value)) {
return;
}
if (!array_key_exists('original_path', $value)) {
return;
}
if (!array_key_exists('uuid', $value)) {
return;
}
if (!array_key_exists('uid', $value)) {
return;
}
// Make sure a file doesn't already exist with that UUID.
$entity = Entity::loadByUUID($value['uuid'], 'file');
if ($entity) {
$definition = $entity->definition;
} else {
// Make sure a file doesn't already exist with that URI.
$query = db_select('file_managed', 'f');
$query->addField('f', 'fid');
$query->condition('f.uri', $value['original_path']);
$query->range(0, 1);
$result = $query->execute()->fetch();
if ($result) {
$entity = Entity::load($result->fid, 'file');
if ($entity) {
$definition = $entity->definition;
}
}
}
// If we haven't found the file yet, upload it.
if (!isset($definition)) {
// Decode the contents of the file.
$contents = file_get_contents($value['url']);
if ($contents === false) {
throw new FileHandlerException('There was an error fetching the contents of the file.');
}
// Save the file.
$file = file_save_data($contents, $value['original_path']);
if (!$file || !$file->fid) {
throw new FileHandlerException('There was an error saving the file to the database.');
}
$file->uuid = $value['uuid'];
$file->uid = $value['uid'];
file_save($file);
$definition = $file;
}
// Don't completely reset the entity.
foreach ((array) $definition as $key => $val) {
$this->unresolved_definition->{$key} = $val;
}
}
protected function handleIndividualValue($entity_type, $field_type, $field_name, &$value, $delta)
{
if (!is_array($value)) {
return;
}
if (!array_key_exists('fid', $value)) {
throw new ImageCropFieldHandlerException('The field ' . $field_name . ' does not have a file ID.');
}
$entity = Entity::load($value['fid'], 'file');
if (!$entity) {
throw new FileReferenceHandlerException('The field ' . $field_name . ' has no value.');
}
$value['fid'] = self::createReferenceDefinition($entity);
$this->addDependency($entity);
// Get the original image and store it.
$source_file = _imagefield_crop_file_to_crop($value['fid']);
if (!$source_file) {
throw new ImageCropFieldHandlerException('The field ' . $field_name . ' does not have a valid source file ID.');
}
$source_file_entity = Entity::load($source_file->fid, 'file');
if (!$source_file_entity) {
throw new ImageCropFieldHandlerException('The field ' . $field_name . ' has no source image.');
}
$value['source_fid'] = self::createReferenceDefinition($source_file_entity);
$this->addDependency($source_file_entity);
// Handle the UID now.
if (array_key_exists('uid', $value)) {
$entity = Entity::load($value['uid'], 'user');
if (!$entity) {
throw new FileReferenceHandlerException('The field ' . $field_name . ' is associated with a user that doesn\'t exist.');
}
$value['uid'] = self::createReferenceDefinition($entity);
$this->addDependency($entity);
}
// Make sure the dimensions of the cropbox are always set.
if (isset($this->entity->definition->{$field_name})) {
$original_entity_definition_language = reset($this->entity->definition->{$field_name});
// First language.
if (array_key_exists($delta, $original_entity_definition_language)) {
$original_entity_definition = $original_entity_definition_language[$delta];
if (!array_key_exists('cropbox_x', $value)) {
$value['cropbox_x'] = array_key_exists('cropbox_x', $original_entity_definition) ? $original_entity_definition['cropbox_x'] : 0;
}
if (!array_key_exists('cropbox_y', $value)) {
$value['cropbox_y'] = array_key_exists('cropbox_y', $original_entity_definition) ? $original_entity_definition['cropbox_y'] : 0;
}
if (!array_key_exists('cropbox_width', $value)) {
$value['cropbox_width'] = array_key_exists('cropbox_width', $original_entity_definition) ? $original_entity_definition['cropbox_width'] : 0;
}
if (!array_key_exists('cropbox_height', $value)) {
$value['cropbox_height'] = array_key_exists('cropbox_height', $original_entity_definition) ? $original_entity_definition['cropbox_height'] : 0;
}
}
}
}
public function execute(\EntityDrupalWrapper $entity_raw, $remote_raw, $force)
{
$remote = publisher_remote_load($remote_raw);
if (!$remote) {
return false;
}
$entity = Entity::load($entity_raw->getIdentifier(), $entity_raw->type());
if (!$entity) {
return false;
}
publisher_send_entity($entity, $remote, array('force' => $force));
return true;
}
protected function handleIndividualValue($entity_type, $field_type, $field_name, &$value, $delta)
{
// Try to load the entity.
if (!array_key_exists('tid', $value)) {
throw new TaxonomyReferenceHandlerException('The term identifier did not exist on the entity.');
}
$entity = Entity::load($value['tid'], 'taxonomy_term');
if (!$entity) {
throw new TaxonomyReferenceHandlerException('The entity ' . $value['tid'] . ' does not exist.');
}
// Set the reference definition for the field.
$value['tid'] = self::createReferenceDefinition($entity);
$this->addDependency($entity, true);
$this->addRelationship($this->original_entity, $entity, $field_name, $delta);
}
protected function handleIndividualValue($entity_type, $field_type, $field_name, &$value, $delta)
{
// Get the information for the specific field.
$target_type = $this->getTargetType($field_name);
if (!array_key_exists('target_id', $value)) {
throw new EntityReferenceHandlerException('The field ' . $field_name . ' does not have a target ID.');
}
$entity = Entity::load($value['target_id'], $target_type);
if (!$entity) {
throw new EntityReferenceHandlerException('The field ' . $field_name . ' has no value.');
}
$value['target_id'] = self::createReferenceDefinition($entity);
$this->addDependency($entity, true);
$this->addRelationship($this->original_entity, $entity, $field_name, $delta);
}
public function handleField($entity_type, $field_type, $field_name, &$value)
{
if ($entity_type == 'user' && ($value === 0 || $value === '0')) {
return;
}
// We should be getting a number for the value.
if (!is_numeric($value)) {
throw new IDHandlerException('The field of type ' . $field_type . ' does not have a numeric value.');
}
// Load the entity.
$entity = Entity::load($value, $entity_type);
if (!$entity) {
throw new IDHandlerException('The entity ' . $value . ' does not exist.');
}
// Update the value.
$value = self::createReferenceDefinition($entity);
}
public function handleField($entity_type, $field_type, $field_name, &$value)
{
if ($value === 0 || $value === '0') {
return;
}
// Ignore anonymous user.
// We should be getting a number for the value.
if (!is_numeric($value)) {
throw new UserHandlerException('The field of type ' . $field_type . ' does not have a numeric value.');
}
// Load the user entity.
$entity = Entity::load($value, 'user');
if (!$entity) {
throw new UserHandlerException('The user ' . $value . ' does not exist.');
}
// Update the value.
$value = self::createReferenceDefinition($entity);
$this->addDependency($entity);
}
public function resolve($recurse = true)
{
// Get all revisions for the entity.
$diff = new EntityDiff($this->entity);
$revisions = $diff->getRevisionHistory();
if (is_array($revisions)) {
// Make it so that we process the latest revision last.
$revisions = array_reverse($revisions);
foreach ($revisions as $revision_id) {
$entity = Entity::load($this->base_entity->id(), $this->base_entity->type());
$entity->setRevision($revision_id);
$this->entity = $entity;
$this->base_entity = clone $entity;
$this->resolveDependencies($recurse, $entity->definition);
}
} else {
$this->resolveDependencies($recurse);
}
}
protected function handleIndividualValue($entity_type, $field_type, $field_name, &$value, $delta)
{
global $base_url;
if (!is_array($value)) {
throw new FileReferenceHandlerException('The field ' . $field_name . ' has an invalid value.');
}
if (!array_key_exists('fid', $value)) {
throw new FileReferenceHandlerException('The field ' . $field_name . ' does not have a file ID.');
}
$entity = Entity::load($value['fid'], 'file');
if (!$entity) {
throw new FileReferenceHandlerException('The field ' . $field_name . ' has no value.');
}
if (!file_exists(str_replace($base_url, DRUPAL_ROOT, urldecode(file_create_url($entity->definition->uri))))) {
drupal_set_message(t('The file in the field !field does not exist. Setting the value to <code>NULL</code>', array('!field' => $field_name)), 'warning');
$value = null;
return;
}
$value['fid'] = self::createReferenceDefinition($entity);
$this->addDependency($entity, true);
$this->addRelationship($this->original_entity, $entity, $field_name, $delta, array('alt' => !empty($value['alt']) ? $value['alt'] : '', 'title' => !empty($value['title']) ? $value['title'] : '', 'display' => !empty($value['display']) ? $value['display'] : true, 'description' => !empty($value['description']) ? $value['description'] : ''));
}
protected function handleSingle($mlid, $field_type)
{
if (!is_numeric($mlid)) {
throw new MenuLinkHandlerException('The link ID ' . $mlid . ' is not numeric.');
}
$entity = Entity::load($mlid, 'menu_link');
if (!$entity) {
throw new MenuLinkHandlerException('The entity ' . $mlid . ' does not exist.');
}
if ($entity->uuid() == $this->entity->uuid()) {
return 'self';
}
if ($field_type == 'menu_links') {
// If the menu item is associated with the node, make the menu item
// depend on the node, not the other way around.
$sources = array($entity->uuid());
$this->addDependency($this->original_entity, $sources);
}
// Don't create a source of the node if the type is menu links.
$this->addDependency($entity, $field_type !== 'menu_links');
return self::createReferenceDefinition($entity);
}
protected function urlToFileEntity($url)
{
$url = urldecode(DRUPAL_ROOT . EntityPathHelper::normalizeUrl($url));
if (file_exists($url)) {
// Get the filename.
$filename = pathinfo($url, PATHINFO_FILENAME) . '.' . pathinfo($url, PATHINFO_EXTENSION);
$filesize = filesize($url);
$files = db_select('file_managed', 'f')->fields('f', array('fid', 'uri', 'filesize'))->condition('filename', $filename)->condition('filesize', $filesize)->execute();
$found_fid = -1;
while ($row = $files->fetch()) {
$result_uri = drupal_realpath($row->uri);
if ($result_uri == drupal_realpath($url)) {
$found_fid = $row->fid;
break;
}
}
if ($found_fid !== -1) {
return Entity::load($found_fid, 'file');
} else {
// Create the file entity.
if ($contents = file_get_contents($url)) {
$public_files_directory = DRUPAL_ROOT . '/' . variable_get('file_public_path', conf_path() . '/files') . '/';
$schema_url = 'public://' . str_replace($public_files_directory, '', $url);
// This will basically re-create the same file with the same filename, so we don't
// need to check to see if the file already exists because we don't care to replace
// the file with itself.
$file = file_save_data($contents, $schema_url, FILE_EXISTS_REPLACE);
return Entity::load($file->fid, 'file');
}
}
}
return false;
}
