9.11.1. Lavorare con i campi delle entità tramite programmazione

Recuperare i valori dei campi nelle entità è piuttosto semplice, ma ci sono diversi modi per farlo. Vediamo come lavorare al meglio con i valori dei campi nel codice personalizzato. Puoi sempre consultare le informazioni più aggiornate sulla gestione dei campi nel sito ufficiale:

https://www.drupal.org/docs/8/api/entity-api/working-with-the-entity-api

In questo articolo analizzeremo alcuni esempi pratici di utilizzo dei valori dei campi.

Non è necessario ricordare a memoria come funzionano determinati campi: puoi sempre tornare su questa pagina per rinfrescarti la memoria. Col tempo, consulterai sempre più spesso la documentazione e capirai quanto sia semplice lavorare con i campi in Drupal. Nel frattempo, puoi aggiungere questa pagina ai preferiti come promemoria rapido.

Lavorare con i nodi

Caricare un nodo tramite il suo nid:

$nid = 234; 
$node_storage = \Drupal::entityTypeManager()->getStorage('node');
$node = $node_storage->load($nid);

Ottenere l’ID del nodo:

$node->id();

Ottenere il bundle del nodo o dell’entità:

$node->bundle();   
$entity->getType(); 

Ottenere i valori dei campi:

$node->get('title')->value;           
$node->get('created')->value;      
$node->get('body')->value;          
$node->get('body')->summary;         
$node->get('field_foo')->value;     
$node->get('field_image')->target_id;

Puoi anche usare una sintassi abbreviata per ottenere i valori:

$node->title->value;
$node->created->value;
$node->body->value;
$node->body->summary;
$node->field_foo->value;
$node->field_image->target_id;

Caricare nodi specifici in base al valore di un campo:

$query = \Drupal::entityQuery('node')
  ->condition('type', 'article')
  ->condition('field_terms', 42);
$nids = $query->execute();
$nodes = $node_storage->loadMultiple($nids);
  
foreach ($nodes as $node) {
  print $node->title->value;
  $node->set('title', "Nuovo titolo per il nodo");
  $node->save();
}

Modificare i valori nei campi:

$node->set('title', "Nuovo titolo");
$node->set('body', array(
'summary' => "Introduzione",
'value' => "Testo completo",
'format' => 'basic_html',
));
$node->save();

Per i campi con un solo valore, puoi usare una forma ancora più breve:

$node->title = 'Nuovo titolo';
$node->field_text = 'testo';

Ottenere i valori di campi multipli:

$nids = \Drupal::entityQuery('node')->condition('type', 'album')->execute();
$nodes = Node::loadMultiple($nids);
 
$data = array();
foreach($nodes as $node) {
  $photo = array();
  foreach($node->get('field_image')->getValue() as $file){
    $fid = $file['target_id']; // ottieni il fid del file
    $photo[] = \Drupal\file\Entity\File::load($fid)->getFileUri();
  }
 
  $data[] = array(
    'album_name' => $node->get('field_album_name')->getValue(),
    'place' => $node->get('field_place')->getValue(),
    'author' => $node->get('field_author')->getValue(),
    'photo' => $photo,
  );
}

Lavorare con i campi file

I file vengono aggiunti alle altre entità tramite campi di riferimento e, accedendo a questi campi, possiamo ottenere l’ID del file e successivamente le sue informazioni.

Ottenere un file tramite ID:

$fid = 42; 
$file_storage = \Drupal::entityTypeManager()->getStorage('file');
$file = $file_storage->load($fid);

Ottenere l’oggetto file da un campo del nodo:

$file = $node->field_image->entity;

Ottenere alcuni campi dell’oggetto file:

$file->getFileUri();   // "public://file123.jpg"
// Puoi convertire l’URI in URL: file_url_transform_relative(file_create_url($file->getFileUri()));   
// "/sites/default/files/public/file123.jpg"
$file->filename->value;   // "file123.jpg"
$file->filemime->value;   // "image/jpeg"
$file->filesize->value;   // 63518  (dimensione in byte)
$file->created->value;    // 1511206249  (timestamp Unix)
$file->changed->value;    // 1511234256  (timestamp Unix)
$file->id();

Puoi visualizzare i valori delle proprietà del file disponibili nella tabella file_managed come segue:

echo $file->uid->target_id;               // 1
echo $file->uid->value;                   // Non funziona! Usa target_id.
echo $file->uid->entity->name->value;    
echo $file->uid->entity->timezone->value; // "Asia/Omsk"

Lavorare con i campi di riferimento a entità

Puoi ottenere più valori da campi di riferimento a entità e gestirli con un ciclo foreach:

foreach ($node->field_my_entity_reference as $reference) {  
  print $reference->target_id;  
  print $reference->entity->title->value;  
}

Modificare un campo di riferimento a entità multiplo:

$nids = [3,4,5,6];  
$node->set('field_my_entity_reference', $nids);
$node->save();

Aggiungere nuovi valori a un campo di riferimento a entità mantenendo i valori esistenti:

$nids = [3,4,5,6];   // esempio di valore
foreach ($nids as $nid) {
  $node->field_my_entity_reference[] = [
    'target_id' => $nid
  ];
}
$node->save();

Confrontare i valori vecchi e nuovi nei campi

La classe FieldItemListInterface (che sta dietro ogni campo) dispone del metodo equals():

/**
 * Implementa hook_entity_update().
 */
function mymodule_entity_update(\Drupal\Core\Entity\EntityInterface $entity) {
  // Verifica che l’entità abbia effettivamente il campo.
  if (!$entity->hasField('field_wikipage_access') || !isset($entity->original)) {
    return;
  }

  $new_values = $entity->get('field_wikipage_access');
  $old_values = $entity->original->get('field_wikipage_access');

  // Booleano rapido: cambiato o no?
  if ($new_values->equals($old_values)) {
    return;  // Nessuna modifica, esci.
  }

  // …altrimenti continua (vedi sotto).
}

Lavorare con i paragrafi

$my_paragraph = null;
  
foreach ($node->get('field_paragraph_reference') as $paragraph) {
  if ($paragraph->entity->getType() == 'your_paragraph_type') {  
    $my_paragraph = $paragraph->entity;
  }
}
  
if (!empty($my_paragraph)) {
  print $my_paragraph->field_somefield->value;
  
  print $my_paragraph->title->value;  // Non funziona!
} 
else {
  print "Il nodo non contiene questo tipo di paragrafo.";
}

Ottenere il tipo di paragrafo:

$my_paragraph->getType();

Utilizzeremo questi esempi in futuro per scrivere moduli personalizzati che lavorano con hook e oggetti entità.