Inicio / Blog / Curso de desarrollo de entidades en drupal 7
Imagen de Daniel
Daniel M. Fernandez
Comp. Science Engineer
23 Ene 2017
Curso
de desarrollo de entidades en drupal 7

El curso estará estructura por un conjunto de artículos que abarcaran los aspectos básicos a conocer para desarrollar entidades en drupal 7. Este desarrollo estará basado en un ejemplo práctico que ayudara a salir de un ambiente conceptual y adentrarnos en un caso particular.

Body: 

Primera parte

Conocimientos previos para entender este tutorial:

PHP, Desarrollo en drupa, POO, Base de datos relacionales.

Nota: Este tutorial enfocará solo los aspectos dirigidos a entity api, no se explicará nada relacionado al desarrollo común de módulos de drupal, se toma como consenso que ya es un conocimiento previamente tomado.

 

Objetivo del curso

Aprender mediante un ejemplo práctico como desarrollar entidades en drupal7.

 

Subjetivos:

  • Como crear entidades en drupal 7.
  • Gestión entre entidades.

 

Introducción:

El curso estará estructura por un conjunto de artículos que abarcarán los aspectos básicos a conocer para desarrollar entidades en drupal 7. Este desarrollo estará basado en un ejemplo práctico que ayudara a salir de un ambiente conceptual y adentrarnos en un caso particular.

 

Caso práctico:

Se pretende desarrollar un módulo para drupal 7 que permita llevar las estadísticas de campeonatos de fútbol, donde se gestionen los torneos, jornadas y partidos por jornadas, así como  toda la gestión de equipos que participen en cada uno de los torneo.

 

 

Un torneo se conforma por varias jornadas y varios equipos,  una jornada por muchos partidos y estos a su vez por 2 equipos.

Se debe llevar una tabla de resultados donde se reporten la cantidad de juegos jugados, juegos perdidos, juegos empatados y ganados, así como la cantidad de goles a favor y en contra y el total de puntos acumulados por cada equipo participante en el torneo.

Desarrollo Tema 1:

Nota: Se tomará la entidad torne como base para explicar todo el contenido del código mostrado.

Puntos a tratar:

  1. Extraer las  entidades del caso práctico.
  2. Implementación del hook_schema.
  3. Implementación del hook_entity_info.
  4. Implementación de nuestros EntityController.

 

Desarrollo:

Extraer las  entidades del caso práctico.

  1. /* Implements hook_schema().
  2.   *
  3.   */
  4. function module_name_schema() {
  5. $schema = array();
  6.  
  7. //--------------------MODULE_NAME_TORNEO----------------------
  8. $schema ['module_name_torneo'] = array(
  9. 'fields' => array(
  10. 'torneo_id' => array( //nombre de la propiedad o columna de la entidad
  11. 'unsigned' => TRUE, //auto incrementado el campo
  12. 'type' => 'serial', // se define el tipo de dato
  13. 'not null' => TRUE, //Si puede o no ser nudo este valor
  14. ),
  15. 'categoria_id' => array(
  16. 'type' => 'int', // se define el tipo de dato
  17. 'default' => 0, //se define valor por defecto
  18. ),
  19. 'estado' => array(
  20. 'type' => 'int',
  21. 'default' => 0,
  22. ),
  23. 'nombre' => array(
  24. 'type' => 'varchar',
  25. 'length' => '100', //se asigna un tamaño del campo
  26. 'default' => '',
  27. ),
  28. ),
  29. 'primary key' => array(//se declara la llave primaria de la entidad
  30. 'torneo_id'
  31. ),
  32. );
  33. //Continuamos con las otras entidades de la misma forma que //anteriormente se explicó...
  34. return $schema;
  35. }

 

 

 


Implementación del hook_entity_info:

  1. function module_name_entity_info() {
  2.  
  3. //------------------------------module_name_torneo-------------------------------------------
  4. $info['module_name_torneo'] = array(
  5. //Etiqueta para identificar la entidad.
  6. 'label' => t('module_name_torneo'),
  7.  
  8. //Controlador que maneja los métodos de la entidad, por defecto es
  9. // EntityAPIController.
  10. 'controller class' => 'Entitymodule_name_torneoController',
  11.  
  12. //Definimos la tabla relacionada en el hook_schema() que manejará esta //entidad.
  13. 'base table' => 'module_name_torneo',
  14.  
  15. //Define la función que retornara la entidad en cuestión
  16. 'uri callback' => 'module_name_torneo_uri',
  17.  
  18. //Se le da la posibilidad a la entidad de agregar nuevos campos, como hace las //entity node,user...
  19.  
  20. 'fieldable' => TRUE,
  21. //Identificador de la entidad, llave que se definió en el hook_schema() para esta entidad.
  22.  
  23. 'entity keys' => array(
  24. 'id' => 'torneo_id' ,//llave de la tabla
  25. ),
  26.  
  27. //Así definimos un bundle para agrupar entidades de un mismo
  28. //tipo o que represente herencias, y quede de una forma organizada.
  29. //ejemplo es Content Type que agrupa a artículos, paginas básicas...
  30. 'bundles' => array(
  31. 'module_name_torneo_bundle' => array(
  32. //Etiqueta del bundle
  33. 'label' => 'module_name_torneo bundle',
  34. //Datos administrativos de la entidad
  35. 'admin' => array(
  36. //Definimos la dirección desde donde se administrara la entidad.
  37. 'path' => 'admin/structure/module_name_torneo/manage',
  38.  
  39. //Permiso que se debe tener para poder gestionar esta entidad,
  40. //este permiso debe de ser declarado previamente en el hook__permission() del módulo en cuestión.
  41. 'access arguments' => array('administer module_name_torneo entities'),
  42. ),
  43. ),
  44. ),
  45. //Se definen los modos de vistas para distintos contexto donde participe esta entidad, se puede relacionar con el modulo view.
  46. 'view modes' => array(
  47. 'tweaky' => array(
  48. 'label' => t('Tweaky'),
  49. 'custom settings' => FALSE,
  50. ),
  51. )
  52. );
  53. //Se debe continuar con la implementación de las 3 entidades restantes de la misma manera que implementada esta.
  54.  
  55. return $info;
  56. }

Implementación de nuestros EntityController:

El EntityController conforma la  capa de negocio de la entidad, es donde se definen nuevos métodos o redefinen otros a nuestra conveniencia, esta clase es a la que hace referencia el hook_entity_info anteriormente explicado 'controller class' => 'Entitymodule_name_torneoController', cuando se solicite un método de una de las entidades serán buscados en este controlador y luego ejecutado. EntityAPIController ya implementa por defecto los métodos principales save,delete,update,load. Si se utiliza EntityAPIController en el en el hook_entity_info  ('controller class' => EntityAPIController)  no será necesario  implementar un nuevo controlador, solo si necesitamos realizar operaciones especifica en nuestra entidad.

 

Conclución:

Hasta aquí la primera parte de este curso, entre los aspectos tratados en esta primera parte, se destaca la  creación de entidades,implementación de EntityController e integración con el hook_schema() y hook_entity_info, en próximos capítulos veremos la integración con los módulos y la gestión de los field, las vistas y el manejo entre entidades a través del EntityContoller implementado en esta primera parte.

  1. //Se crea esta interfaz porque cualquiera puede alterar la entidad con el hook ¬¬//hook_entity_info_alter(). Aquí se da a saber que métodos necesita la clase //para que interactúe con el resto del módulo.
  2. interface Entitymodule_name_torneoControllerInterface
  3. extends DrupalEntityControllerInterface {
  4. public function create();
  5. public function save($entity);
  6. public function delete($entity);
  7. }
  8.  
  9. //Esta clase permite implementar los nuevos métodos no heredados de ¬¬//DrupalDefaultEntityController y re implementar los de la interface //anteriormente explicada a su conveniencia.
  10. class Entitymodule_name_torneoController
  11. extends DrupalDefaultEntityController
  12. implements Entitymodule_name_torneoControllerInterface {
  13.  
  14. //Se crea una nueva entidad y se definen los vlores por defecto de la misma.
  15. public function create() {
  16. $entity = new stdClass();
  17. $entity->type = 'module_name_torneo';
  18. $entity->bundle_type = 'module_name_torneo';
  19. $entity->torneo_id=0;
  20. $entity->categoria_id=0;
  21. $entity->estado=0;
  22. $entity->nombre='';
  23.  
  24. return $entity;
  25. }
  26.  
  27. //Este método es el encargado de guardar o actualizar la entidad en caso que ya exista.
  28. public function save($entity) {
  29.  
  30. //Se invoca el hook_entity_presave() de entity api.
  31. module_invoke_all('entity_presave', $entity, 'module_name_torneo');
  32. //Se toman las llaves de la entidad, en caso de que ya exista la entidad y se //quiera actualizar en caso de ser una nueva entidad se retorna un array vacío.
  33. $primary_keys = $entity->torneo_id ? 'torneo_id' : array();
  34. //Se escribe el registro de la entidad.
  35. drupal_write_record('module_name_torneo', $entity, $primary_keys);
  36.  
  37. //se define la variable invocation con valor de inserción por defecto.
  38. $invocation = 'entity_insert';
  39. //verificando si la entidad existe o es nueva, si es nueva existira al ¬¬menos una //llave en el array $primary_keys (llave primaria definida en el //hook_entity_info()) .
  40. if (empty($primary_keys)) {
  41. //insertando los nuevos campos adicionados a la entidad (como la entidad no contien llaves, se inserta como nueva)
  42. field_attach_insert('module_name_torneo', $entity);
  43. }
  44. else {
  45. //Si contiene alguna llave es que ya la entidad existe y lo que debe hacer es actualizarse los nuevos campos.
  46. field_attach_update('module_name_torneo', $entity);
  47. //Se cambia el valor de la variable del insert anteriormente asignado a update.
  48. $invocation = 'entity_update';
  49. }
  50. //Se invoca el hook 'entity_update o 'entity_insert' en dependencia del valor //que traiga en el campo llave de la entidad.
  51. module_invoke_all($invocation, $entity, 'module_name_torneo');
  52. return $entity;
  53. }
  54.  
  55. //Metodo eliminar de la entidad
  56. public function delete($entity) {
  57. //Se invoca el metodo delete_multiple posteriormente explicado.
  58. $this->delete_multiple(array($entity));
  59. }
  60.  
  61. //Este método elimina 1 o varias entidades en dependencia de lo que se envié //en el array $entities pasado como parámetro.
  62. public function delete_multiple($entities) {
  63. $torneo_ids = array();
  64. if (!empty($entities)) {
  65. //Se crea una transaction
  66. $transaction = db_transaction();
  67. try {
  68. //Se recorre el array de entidades y se invoca el hook 'entity_delete' de la //entity API y se eliminan los campos añadidos a la entidad.
  69. foreach ($entities as $entity) {
  70.  
  71. module_invoke_all('entity_delete', $entity, 'module_name_torneo');
  72. field_attach_delete('module_name_torneo', $entity);
  73. //Se guarda cada uno de los ids o llaves de la entidad que se eliminará.
  74. $torneo_ids[] = $entity->torneo_id;
  75. }
  76. //Se eliminan los registros de la tabla module_name_torneo que tengan en su campo de llave primaria alguno de los ids del array , $torneo_ids.
  77. db_delete('module_name_torneo')
  78. ->condition('torneo_id', $torneo_ids, 'IN')
  79. ->execute();
  80. }
  81. catch (Exception $e) {
  82. //Se reinvierte el proseso si ocurrio un problema en la ejecución.
  83. $transaction->rollback();
  84. watchdog_exception('torneo_id', $e);
  85. throw $e;
  86. }
  87. }
  88. }
  89. // Aquí podemos definir tantos métodos como necesitemos en nuestra entidad
  90. }

Anexo:

Si no quedo muy claro la explicación de la integración entre hook_schema, hook_entity_info y EntityController, se le muestra una imagen donde se refleja la integración entre los mismo.

 

Se refleja la relación entre Schema,entity_info y contoladores, el hoock_entity_info  integra todo ,¨base table¨ integra el schema con la entidad,y ¨controller class¨ integra los controladores  que la gestionarán, y estos a su vez implementan todos los metodos de la misma.