Consultar entidades referenciadas
$query = \Drupal::entityQuery('node')->condition('type', 'calificacion_pregunta');
$query->condition('field_answer.entity:node.nid', '67276');
$count = $query->execute();
dump($count); Contar nodos
$query = \Drupal::entityQuery('node')->condition('type', 'calificacion_pregunta');
$count = $query->count()->execute();Operaciones en php, elimino registros de un nodo
$result = \Drupal::entityQuery("node")
->condition("type", "calificacion")
->accessCheck(FALSE)
->sort('created' , 'DESC')
->range(0,1000)
->execute();
$storage_handler = \Drupal::entityTypeManager()->getStorage("node");
$entities = $storage_handler->loadMultiple($result);
$storage_handler->delete($entities);
$result2 = \Drupal::entityQuery("node")
->condition("type", "calificacion")
->accessCheck(FALSE)
->execute();
echo "\n Antes->: 96841";
echo "\n Despues:".count($result2);Obtener id después de guardar
use Drupal\node\Entity\Node;
$auditoria = Node::create(['type' => 'auditoria']);
$auditoria->set('title', 'transaction8 - ' . date('Y-m-d h:i:s'));
$auditoria->set('field_input', json_encode($data));
$auditoria->save();
$nid = $auditoria->id();
Muestra imagen renderizada
use DrupalimageEntityImageStyle;
img_alt => $node->field_imagen_reporte->alt,
img_uri => ImageStyle::load(thumbnail)->buildUrl($node->field_imagen_reporte->entity->getFileUri()),
img_dft => $node->field_imagen_reporte->entity->url();
Muestra Imagen de una entidad
$entity = Drupal::entityQuery(node);
$entity->condition(type, predicadores);
$entity->range(0,5);
$nids = $entity->execute();$nodes = Drupal
odeEntityNode::loadMultiple($nids);$i = 0;
$data = [];
foreach ($nodes as $key => $node) {
$data[$i][title] = $node->title->value;
$data[$i][imagen] = file_create_url($node->field_image->entity->getFileUri())
$i++;
}
Imagenes relativas en drupal
$path = ImageStyle::load(imagen_front)->buildUrl($node->field_imagen->entity->getFileUri());
$path_relative = file_url_transform_relative($path);
$row[image] = $path_relative;
http://nireneko.com/articulo/como-trabajar-con-la-entity-api-en-drupal-8
$entity = Drupal::entityQuery(node);
$entity->condition(type, directorio);
$entity->condition(status, 1, =);
$entity->sort(field_dependencia.entity.weight, ASC);
$entity->sort(field_cargo.entity.weight, ASC);
$nids = $entity->execute();
$nodes = Node::loadMultiple($nids);
use Drupal
odeEntityNode;
$node = Node::create( array(
type=>miembro,
title => nodo 24,
body => nodo 24,
));
$node->save();
Actualizar una taxonomia refrenciada
$node->set(field_categoria,4);
$node->save();
Con array
$nids = [58,56];
foreach ($nids as $key => $nid) {
$node = Node::load($nid);
$node->set(field_categoria,5);
$node->save();
}
Captura nodos
$entity = Drupal::entityQuery(node);
$entity->condition(type, intervencion);
$entity->condition(field_aprobado_pero_no_iniciado, 0, =);
$entity->sort(title, ASC);
$nids = $entity->execute();
$nodes = Drupal
odeEntityNode::loadMultiple($nids);foreach ($nodes as $key => $node) {
$node->set(‘field_tags’,194);
$node->save();
}
Comprobaciones
// Comprobar que el objeto es realmente una entidad.
if ($object instanceof DrupalCoreEntityEntityInterface) { }
// Asegurarse que es una entidad de contenido.
if ($entity instanceof DrupalCoreEntityContentEntityInterface) { }
// Obtener el tipo de entidad.
$entity->getEntityTypeId();
// Asegurarse de que es un nodo.
if ($entity instanceof Drupal
odeNodeInterface) { }
// Es mejor usar entityType() por si el tipo de entidad es dinámico.
$needed_type = node; if ($entity->getEntityTypeId() == $needed_type) { }
PHP
Obtener informacion de la entidad
Las entidades tienen ciertos metodos genericos a traves de los cuales podemos obtener informacion, como la id, el bundle, la revision, si es nueva, crear un clon… (documentacion):
// Obtener la ID.
$entity->id();
// Obtener el bundle.
$entity->bundle();
// Comprobar si la entidad es nueva.
$entity->isNew();
// Obtener la etiqueta de la entidad, reemplaza al método obsoleto entity_label().
$entity->label().
// Obtener la URI de la entidad.
// @todo: Esto puede cambiar con la nueva API para las URI.
$entity->uri();
// Crear un duplicado que se puede guardar como una nueva entidad.
$duplicate = $entity->createDuplicate();
PHP
Crear una entidad
// Crear una entidad de manera dinámica.
$node = entity_create(node, array( title => Mi nodo, body => El contenido para el campo body. Esto funciona como la nueva Api de campos de entidades. Se le asignara el campo el valor al primer valor del campo con el idioma predeterminado., ));
// Tambien puedes usar el metodo estatico 'create()' si conoces la clase de la entidad.
$node = Node::create(array(title => Titulo del nodo));
// Utilizando el gestor de entidades.
$node = Drupal::entityTypeManager()->getStorage(node)->create(array(type => article, title => Otro nodo));
PHP
Cargar entidades
// Usar el metodo estatico.
$node = Node::load(1);
// Carga una sola entidad dinamica, en Drupal 7 existita la funcion entity_load() que cargaba multiples entidades,
// ahora se ha renombrado a entity_load_multiple() y entity_load() en Drupal 8 carga una sola entidad.
$entity = entity_load($entity_type, $id);
// Utilizando el gestor de almacenamiento.
$entity = Drupal::entityTypeManager()->getStorage($entity_type)->load(1);
// Cargar multiples entidades, tambien existe entity_load_multiple() para cargar entidades de manera dinamica.
$entity = Drupal::entityTypeManager()->getStorage($entity_type)->loadMultiple(array(1, 2, 3));
PHP
Guardar una entidad
// Guardar una entidad.
$entity->save();
PHP
El método save() funciona con entidades nuevas y ya existentes; Las entidades de contenido, de manera predeterminada el como se guarden depende de que previamente tengan una id o no.
// El siguiente código almacenara el nodo con la id 5, esto fallara si ya existe un nodo con esa id.
$node->nid->value = 5; $node->enforceIsNew(TRUE); $node->save()
PHP
Eliminar entidades
// Eliminar una sola entidad.
$entity = Drupal::entityTypeManager()->getStorage(node)->load(1);
$entity->delete();
// Eliminar multiples entidades a lmismo tiempo.
Drupal::entityTypeManager()->getStorage($entity_type)->delete(array($id1 => $entity1, $id2 => $entity2));
PHP
Control de acceso
El metodo ‘access()’ se puede usar para comprobar quien puede hacer que accion con una entidad. El metodo soporta diferentes operaciones, las estandar son ‘view’, ‘update’, ‘delete’ y ‘create’.
// Comprueba si se tiene acceso para visualizar la entidad.
// De manera predeterminada, se comprueba el usuario actualmente autentificado.
if ($entity->access(view)) { }
// Comprobar si un usuario en concreto puede eliminar la entidad.
if ($entity->access(delete, $account)) { }
PHP
El permiso para crear entidades, es un poco especial, cuando comprobarmo este permiso, lo normal es que no exista todavía una entidad ya la vamos a crear, para comprobar este permiso hayq ue utilizar el EntityTypeManager:
Drupal::entityTypeManager()->getAccessController(node)->createAccess(article);
PHP
Y con eso comprobamos si el usuario actual puede crear entidades del tipo nodo y del bundle ‘article’.
Drupal 8: Database Queries
$node = Node::create(
array(
type => $data[tipo][value],
title => $data[title][value],
field_monto => $data[monto][value],
field_fecha => $data[fecha][value],
body => [
value => $data[body][value]
],
)
);$node = Node::load($data[nid][value]);
if($node->delete()){
$response = 1;
}
By Claudio
$node = Drupal\node\Entity\Node::load(37748);
dump($node->field_monto_espanol_total->value);
$node->field_monto_espanol_total = 113400;
$node->save();
dump($node->field_monto_espanol_total->value);use Drupal\node\Entity\Node;
$node = Node::load(42320);
$node->set(moderation_state,aprobado);
$node->save();