Curso de Desarrollo de Módulos con Drupal 7 (VI): Creación de Bloques

Una vez gestionados los datos principales del módulo, a veces, es necesario poder presentar información en forma de bloques, tal como mencionamos en la 7ª entrega del curso de Drupal 7.
A continuación, detallaremos los pasos fundamentales para la generación de bloques desde un módulo.

Declaración de un Bloque: hook_block_info()

Este el el hook principal para la definición de bloques. Veamos un ejemplo de definición en un fichero .module:
<?php
/**
 * @file
 * Module file for block_example.
 */
/**
* Implementa hook_block_info().
*/
function current_posts_block_info() {
  $blocks[‘current_posts’] = array(
    ‘info’ => t(‘Current posts’), //El nombre que aparecerá en el listado de bloques
    ‘cache’ => DRUPAL_CACHE_PER_ROLE, //Default
  );
  return $blocks;
}
A partir de est momento debería salir el bloque en el listado de bloques.

Obtención de información

Es el momento de recoger los datos que queremos presentar en el bloque, para ello utilizamos una función creada por nosotros:
/**
* Función de obtención de Contenido
*
* Intenta recoger los elementos que están en la base de datos entre una fecha y otra.
*
* @return
*   Un result set de los post entre dos fechas.
*/
function current_posts_contents(){
  //Coge la fecha de hoy
  $today = getdate();
  //Calcula la fecha hace una semana
  $start_time = mktime(0, 0, 0,$today[‘mon’],($today[‘mday’] – 7), $today[‘year’]);
  //Coge la hora actual como la fecha final
  $end_time = time();

  //Usa el API de Database para hacer la consulta
  $query = db_select(‘node’, ‘n’)
    ->fields(‘n’, array(‘nid’, ‘title’, ‘created’))
    ->condition(‘status’, 1) //Published.
    ->condition(‘created’, array($start_time, $end_time), ‘BETWEEN’)
    ->orderBy(‘created’, ‘DESC’) //Most recent first.
    ->execute();

//devuelve los resultados de la consulta
  return $query;
}

Generando la salida del bloque: hook_block_view()

Para generar la salida será necesario implementar el hook_block_view() en el fichero .module. Veamos un ejemplo de utilización:
/**
* Implementa hook_block_view().
*
* Prepara los contenidos del bloque
*/
function current_posts_block_view($delta = ”) {
   //verifica que bloque es el que quiere presentar
  switch($delta){
   //en caso de que sea nuestro bloque
    case ‘current_posts’:
      //genera un array para definir el bloque
      $block[‘subject’] = t(‘Current posts’);
      //verifica los permisos del usuario, en este caso para acceder al contenido
      if(user_access(‘access content’)){
        //Usamos nuestra función para recoger los datos
        $result = current_posts_contents();
        //Genera un array para introducir los datos de la consulta de manera estructurada
        $items = array();
        //Bucle que recorre los resultados y obtiene cada nodo para introducir los datos en el array
        foreach ($result as $node){
          $items[] = array(
            ‘data’ => l($node->title, ‘node/’ . $node->nid),
          );
        }
        //Verifica que el array no esta vacio
        if (empty($items)) { //No content in the last week.
          $block[‘content’] = t(‘No posts available.’);
        }
        else {
          //Pasa los datos a la funcion theme para maquetarlos
          $block[‘content’] = theme(‘item_list’, array(
            ‘items’ => $items));
        }
      }
  }
  //Devuelve el bloque a dibujar
  return $block;
}

Probando

Una vez genradas estas funciones será necesario activar el módulo, verificar que el bloque está presente en el listado, asignarle una región y recargar la página para ver los resultados.
Licencia Creative Commons

Curso de desarrollo de módulos para Drupal 7(III): hook_schema explicado con el módulo User

Para entender bien esta entrega será necesario tener conocimientos avanzados de uso de arrays en PHP.
Como explicar el hook_schema requiere de un modelo de datos en concreto vamos a apoyarnos sobre el módulo User, que forma parte del nucleo de Drupal.
Abrimos el fichero “modules/user/user.install” desde Aptana para ver su contenido, pulsando doble clic sobre él. Y nos encontramos con el siguiente código en la función user_schema():
/**
 * Implements hook_schema().
 */
function user_schema() {
  $schema[‘authmap’] = array(
    ‘description’ => ‘Stores distributed authentication mapping.’,
    ‘fields’ => array(
      ‘aid’ => array(
        ‘description’ => ‘Primary Key: Unique authmap ID.’,
        ‘type’ => ‘serial’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
      ),
      ‘uid’ => array(
        ‘type’ => ‘int’,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘description’ => “User’s {users}.uid.”,
      ),
      ‘authname’ => array(
        ‘type’ => ‘varchar’,
        ‘length’ => 128,
        ‘not null’ => TRUE,
        ‘default’ => ”,
        ‘description’ => ‘Unique authentication name.’,
      ),
      ‘module’ => array(
        ‘type’ => ‘varchar’,
        ‘length’ => 128,
        ‘not null’ => TRUE,
        ‘default’ => ”,
        ‘description’ => ‘Module which is controlling the authentication.’,
      ),
    ),
    ‘unique keys’ => array(
      ‘authname’ => array(‘authname’),
    ),
    ‘primary key’ => array(‘aid’),
    ‘foreign keys’ => array(
      ‘user’ => array(
        ‘table’ => ‘users’,
        ‘columns’ => array(‘uid’ => ‘uid’),
      ),
    ),
  );

  $schema[‘role_permission’] = array(
    ‘description’ => ‘Stores the permissions assigned to user roles.’,
    ‘fields’ => array(
      ‘rid’ => array(
        ‘type’ => ‘int’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
        ‘description’ => ‘Foreign Key: {role}.rid.’,
      ),
      ‘permission’ => array(
        ‘type’ => ‘varchar’,
        ‘length’ => 128,
        ‘not null’ => TRUE,
        ‘default’ => ”,
        ‘description’ => ‘A single permission granted to the role identified by rid.’,
      ),
      ‘module’ => array(
        ‘type’ => ‘varchar’,
        ‘length’ => 255,
        ‘not null’ => TRUE,
        ‘default’ => ”,
        ‘description’ => “The module declaring the permission.”,
      ),
    ),
    ‘primary key’ => array(‘rid’, ‘permission’),
    ‘indexes’ => array(
      ‘permission’ => array(‘permission’),
    ),
    ‘foreign keys’ => array(
      ‘role’ => array(
        ‘table’ => ‘roles’,
        ‘columns’ => array(‘rid’ => ‘rid’),
      ),
    ),
  );

  $schema[‘role’] = array(
    ‘description’ => ‘Stores user roles.’,
    ‘fields’ => array(
      ‘rid’ => array(
        ‘type’ => ‘serial’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
        ‘description’ => ‘Primary Key: Unique role ID.’,
      ),
      ‘name’ => array(
        ‘type’ => ‘varchar’,
        ‘length’ => 64,
        ‘not null’ => TRUE,
        ‘default’ => ”,
        ‘description’ => ‘Unique role name.’,
        ‘translatable’ => TRUE,
      ),
      ‘weight’ => array(
        ‘type’ => ‘int’,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘description’ => ‘The weight of this role in listings and the user interface.’,
      ),
    ),
    ‘unique keys’ => array(
      ‘name’ => array(‘name’),
    ),
    ‘primary key’ => array(‘rid’),
    ‘indexes’ => array(
      ‘name_weight’ => array(‘name’, ‘weight’),
    ),
  );

  $schema[‘users’] = array(
    ‘description’ => ‘Stores user data.’,
    ‘fields’ => array(
      ‘uid’ => array(
        ‘type’ => ‘int’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
        ‘description’ => ‘Primary Key: Unique user ID.’,
        ‘default’ => 0,
      ),
      ‘name’ => array(
        ‘type’ => ‘varchar’,
        ‘length’ => 60,
        ‘not null’ => TRUE,
        ‘default’ => ”,
        ‘description’ => ‘Unique user name.’,
      ),
      ‘pass’ => array(
        ‘type’ => ‘varchar’,
        ‘length’ => 128,
        ‘not null’ => TRUE,
        ‘default’ => ”,
        ‘description’ => “User’s password (hashed).”,
      ),
      ‘mail’ => array(
        ‘type’ => ‘varchar’,
        ‘length’ => 254,
        ‘not null’ => FALSE,
        ‘default’ => ”,
        ‘description’ => “User’s e-mail address.”,
      ),
      ‘theme’ => array(
        ‘type’ => ‘varchar’,
        ‘length’ => 255,
        ‘not null’ => TRUE,
        ‘default’ => ”,
        ‘description’ => “User’s default theme.”,
      ),
      ‘signature’ => array(
        ‘type’ => ‘varchar’,
        ‘length’ => 255,
        ‘not null’ => TRUE,
        ‘default’ => ”,
        ‘description’ => “User’s signature.”,
      ),
      ‘signature_format’ => array(
        ‘type’ => ‘varchar’,
        ‘length’ => 255,
        ‘not null’ => FALSE,
        ‘description’ => ‘The {filter_format}.format of the signature.’,
      ),
      ‘created’ => array(
        ‘type’ => ‘int’,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘description’ => ‘Timestamp for when user was created.’,
      ),
      ‘access’ => array(
        ‘type’ => ‘int’,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘description’ => ‘Timestamp for previous time user accessed the site.’,
      ),
      ‘login’ => array(
        ‘type’ => ‘int’,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘description’ => “Timestamp for user’s last login.”,
      ),
      ‘status’ => array(
        ‘type’ => ‘int’,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘size’ => ‘tiny’,
        ‘description’ => ‘Whether the user is active(1) or blocked(0).’,
      ),
      ‘timezone’ => array(
        ‘type’ => ‘varchar’,
        ‘length’ => 32,
        ‘not null’ => FALSE,
        ‘description’ => “User’s time zone.”,
      ),
      ‘language’ => array(
        ‘type’ => ‘varchar’,
        ‘length’ => 12,
        ‘not null’ => TRUE,
        ‘default’ => ”,
        ‘description’ => “User’s default language.”,
      ),
      ‘picture’ => array(
        ‘type’ => ‘int’,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘description’ => “Foreign key: {file_managed}.fid of user’s picture.”,
      ),
      ‘init’ => array(
        ‘type’ => ‘varchar’,
        ‘length’ => 254,
        ‘not null’ => FALSE,
        ‘default’ => ”,
        ‘description’ => ‘E-mail address used for initial account creation.’,
      ),
      ‘data’ => array(
        ‘type’ => ‘blob’,
        ‘not null’ => FALSE,
        ‘size’ => ‘big’,
        ‘serialize’ => TRUE,
        ‘description’ => ‘A serialized array of name value pairs that are related to the user. Any form values posted during user edit are stored and are loaded into the $user object during user_load(). Use of this field is discouraged and it will likely disappear in a future version of Drupal.’,
      ),
    ),
    ‘indexes’ => array(
      ‘access’ => array(‘access’),
      ‘created’ => array(‘created’),
      ‘mail’ => array(‘mail’),
    ),
    ‘unique keys’ => array(
      ‘name’ => array(‘name’),
    ),
    ‘primary key’ => array(‘uid’),
    ‘foreign keys’ => array(
      ‘signature_format’ => array(
        ‘table’ => ‘filter_format’,
        ‘columns’ => array(‘signature_format’ => ‘format’),
      ),
    ),
  );

  $schema[‘users_roles’] = array(
    ‘description’ => ‘Maps users to roles.’,
    ‘fields’ => array(
      ‘uid’ => array(
        ‘type’ => ‘int’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘description’ => ‘Primary Key: {users}.uid for user.’,
      ),
      ‘rid’ => array(
        ‘type’ => ‘int’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘description’ => ‘Primary Key: {role}.rid for role.’,
      ),
    ),
    ‘primary key’ => array(‘uid’, ‘rid’),
    ‘indexes’ => array(
      ‘rid’ => array(‘rid’),
    ),
    ‘foreign keys’ => array(
      ‘user’ => array(
        ‘table’ => ‘users’,
        ‘columns’ => array(‘uid’ => ‘uid’),
      ),
      ‘role’ => array(
        ‘table’ => ‘roles’,
        ‘columns’ => array(‘rid’ => ‘rid’),
      ),
    ),
  );

  return $schema;
}

Como puede verse en el ejemplo, básicamente está utilizando una variable llamada “$schema” que al final de la función devuelve. Dicha variable es un array que contiene un índice por cada tabla que necesita generar.
Por ejemplo si queremos generar la tabla ‘users’, indicamos que sobre el array $schema metemos un nuevo elemento con el índice ‘users’ y como valor metemos otro array.
El primer elemento del array valor de la tabla ‘users’ será la descripción de la tabla, cuyo índice será ‘description’ y cuyo valor será una cadena de caracteres con la descripción de la tabla.
El segundo elemento tendrá como índice el nombre de ‘fields’ y contiene un array con las defniciones de los campos de la tabla.
Así tendremos un array $schema definido de esta manera:
$schema[‘users’] = array(
    ‘description’ => ‘Stores user data.’,
    ‘fields’ => array()
);
En dicho array de campos (‘fields’), vamos introducciendo cada campo como un elemento cuyo índice es el nombre del campo y su valor es otro array con los metadatos del campo que queremos meter en la tabla, como el caso del campo ‘uid’…
$schema[‘users’] = array(
    ‘description’ => ‘Stores user data.’,
    ‘fields’ => array(
      ‘uid’ => array(
        ‘type’ => ‘int’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
        ‘description’ => ‘Primary Key: Unique user ID.’,
        ‘default’ => 0,
      )
     )
);
En este caso, el campo uid, tiene los siguientes elementos definidos:

  • type: tipo de campo definido por drupal
  • unasigned: valor booleano que permite definir si el campo es con o sin signo. Sólo disponible para campos numéricos.
  • not_null: valor booleano que nos indica si es campo puede ser null o no
  • description: descripción del campo
  • default: valor por defecto del campo

Como puede verse dicha definición de campo es una estructuración en forma de array de las típias configuraciones que solemos hacer en la propia base de datos cuando creamos un campo nuevo.
De esta manera ñadiríamos todos los campos que queremos que tenga la tabla, como distintos elementos del valor del array ‘fields’.
A continuación seguramente será necesario indicar de todos los campos cual (o cuales) es la clave primaria, en el caso de la tabla de users el campo ‘uid’ es el campo de clave primaria de la tabla, por lo que tenemos que insertar un nuevo elemento en el array principal $schema[‘users’] llamado ‘primary_key’ cuyo valor es un array con el nombre de los campos que son clave primaria. Por lo que el código quedaría así:
$schema[‘users’] = array(
    ‘description’ => ‘Stores user data.’,
    ‘fields’ => array(
      ‘uid’ => array(
        ‘type’ => ‘int’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
        ‘description’ => ‘Primary Key: Unique user ID.’,
        ‘default’ => 0,
      )
     ),
    ‘primary key’ => array(‘uid’)
);
 En el caso de la tabla users, tambiñen necesita hacer uso de índices sobre campos, para ello introduce también dentro del array $schema[‘users’] un elemento cuyo índice es ‘indexes’ cuyo valor debería ser un array con el nombre del índice y su valor un array con los nombres de los campos que queremos introducir en el índice. Así quedaría el array de la siguiente manera…
$schema[‘users’] = array(
    ‘description’ => ‘Stores user data.’,
    ‘fields’ => array(
      ‘uid’ => array(
        ‘type’ => ‘int’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
        ‘description’ => ‘Primary Key: Unique user ID.’,
        ‘default’ => 0,
      )//aquí introduciríamos el resto de elementos para definir el resto de campos de la tabla
     ),
    ‘primary key’ => array(‘uid’) ,
    ‘indexes’ => array(
      ‘access’ => array(‘access’),
      ‘created’ => array(‘created’),
      ‘mail’ => array(‘mail’),
    )
);
En este ejemplo, define 3 índices, sobre los campos access, created y mail. Por otra parte podemos definir índices únicos sobre campos, para ello debemos introducir un elemento más con índice ‘unique keys’ cuyo valor es un array con los nombres del índice y el valor de ese elemento es otro array con los campos que pertenecen a dicho array, en el ejemplo…
$schema[‘users’] = array(
    ‘description’ => ‘Stores user data.’,
    ‘fields’ => array(
      ‘uid’ => array(
        ‘type’ => ‘int’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
        ‘description’ => ‘Primary Key: Unique user ID.’,
        ‘default’ => 0,
      )//aquí introduciríamos el resto de elementos para definir el resto de campos de la tabla

     ),
    ‘primary key’ => array(‘uid’) ,
    ‘indexes’ => array(
      ‘access’ => array(‘access’),
      ‘created’ => array(‘created’),
      ‘mail’ => array(‘mail’),
    ),
    ‘unique keys’ => array(
      ‘name’ => array(‘name’),
    )
);
En el ejemplo crea un índice único llamado ‘name’  sobre el campo ‘name’. Dejamos para otro momento el índice ‘foreing keys’ por que tendríamos que explicar el modelo entero de users.

Debemos pensar que Drupal utilizará este hook para crear las tablas necesarias en la base de datos para el módulo, pero seguiríamos necesitando modificar el hook_install para introducir los datos iniciales en las tablas definidas en el hook_schema, como en el ejemplo…
// Insert a row for the anonymous user.
  db_insert(‘users’)
    ->fields(array(
      ‘uid’ => 0,
      ‘name’ => ”,
      ‘mail’ => ”,
    ))
    ->execute();
  Debido que al realizar la desinstalación del módulo user no hay que realizar más acciones que el borrado de las tablas generadas con la definición del hook_schema, el módulo user no necesita un hook_uninstall().

Práctica

  1. Genera un nuevo módulo en base a unos requisitos de base de datos dados.
  2. Define el hook_schema definiendo el modelo de base de datos
  3. Define el hook_install para introducir los datos iniciales en las tablas
  4. Prueba a realizar la instalación e activación del módulo, comprueba si las tablas se han generado correctamente.
  5. prueba a desactivar y desinstalar el módulo y mira a ver si ha borrado correctamente las tablas en la BBDD.

Referencias

Licencia Creative Commons

Curso de Symfony 2 (I): Conceptos fundamentales

Este conjunto de tutoriales tratarán sobre el desarrollo de aplicaciones web con Symfony 2.0
En este primer tutorial trataremos de explicar los conceptos fundamentales del Framework de Symfony 2.0, para que así las siguientes entregas se puedan llegar a entender mucho más facilmente.

El glosario de términos que utilizaremos son los siguientes:

  • HTTP/S: protocolo principal de la web.
  • Petición: información enviada desde el cliente HTTP al servidor.
  • URL: Parte de la petición HTTP que define entre otras cosas el servidor, la ruta el fichero y un conjunto de parámetros.
  • Respuesta: información devuelta por parte del servidor al cliente.
  • Base de Datos: fuente de información estructurada en tablas, campos y relaciones.
  • Modelo-Vista-Controlador: patrón de diseño de aplciaciones de tres capas.
  • Modelo: conjunto de clases y objetos que manejan la conexión y las consultas a la base de datos.
  • Control: conjunto de clases que gestionan y procesan la información y la lógica de negocio de una aplicación.
  • Vista: conjunto de ficheros que componen el apartado visual de una aplicación, con lo que interactúa el usuario.
  • Controlador Principal Web: Clase principal que captura las peticiones entrantes de una aplicación web y pasa el control a las distintas funcionalidades de la aplicación web.
  • Módulo: agrupación de funcionalidades de una aplicación. Una aplicación suele contener distintos módulos. Por ejemplo, la gestión de clientes.
  • Acción: funcionalidad específica de un módulo, por ejemplo, dar de alta un cliente.
  • Plantilla: fichero que permite la generación dinámica de una vista de un módulo, por ejemplo la vista que presenta la información de un cliente.
  • Controlador de Módulo: Clase que implementa las funcionalidades del Control de un Módulo.
  • Bundle o Componente:  conjunto de funcionalidades de alto nivel, podría decirse que es un conjunto de módulos.
  • Framework: conjunto de herramientas y bibliotecas que facilitan la tarea del programados a la hora de desarrollar aplicaciones.

Flujo de la gestión de una petición con Symfony 2

Una de las cuestiones principales a la hora de entender un nuevo framework web, es la manera en la cual se gestionan las peticiones web internamente, de cara a comprender qué pasos van dándose hasta la resolución de una petición.
Gracias al libro de Symfony 2 disponemos de un gráfico revelador respecto al funcionamiento interno de Symfony 2.

Como puede observarse en este diagrama, las distintas peticiones son gestionadas por un Controlador Principal de la Aplicación Web o Control de la Aplicación. Como sucede en otros frameworks, como Spring, todas las peticiones son despachadas por este controlador principal, el cual trata de averiguar que parte de la aplicación debe ser ejecutada para resolver la petición.
La localización de la funcionalidad se realiza a través de un sistema de routing, o mapping, como quiera verse, en el que se relacionan las distintas direcciones URL con las funcionalidades existentes en la aplicación.
Una vez localizada la funcionalidad a ejecutar, se cede el control a un Controlador de módulo el cual ejecuta la Acción específica que resolverá la petición generando una Respuesta.

Componentes principales

Los componentes principales de Symfony 2 son los siguientes:

  • HttpFundation: contiene las clases Request y Response, entre otras
  • Routing: sistema de enrutado de peticiones
  • Form: clases de manejo de formularios y envíos
  • Validator: clases de validación de datos
  • ClassLoader: sistema de carga de clases
  • Templating: sistema de gestión de plantillas
  • Security: herramientas de seguridad
  • Translation: sistema de traducciones

Referencias: 

Symfony 2.0 Book: http://symfony.com/doc/current/book/index.html

Licencia Creative Commons

Suscríbete al Boletín

Si quieres estar al tanto de las novedades del blog, ya sabes :)
* = campo obligatorio

powered by MailChimp!

Archivos

Uso de cookies

Este sitio web utiliza cookies para que usted tenga la mejor experiencia de usuario. Si continúa navegando está dando su consentimiento para la aceptación de las mencionadas cookies y la aceptación de nuestra política de cookies, pinche el enlace para mayor información. ACEPTAR

Aviso de cookies