Author: pepesan

Curso de desarrollo de módulos con Drupal 7 (IX): Creación y gestión de Entidades (Parte I)

18 mayo 2012
pepesan
No comments
Categories: desarrollo, desarrollo de módulos, devel, development, drupal, drupal7, entidades, entities

Como siempre crearemos un nuevo módulo pero esta vez definiremos una entidad que manejaremos desde Drupal. Este caso es un poco más complejo que el de la creación de un nuevo tipo de contenido, debido a que deberemos realizar todas las funcionalidades de gestión de información para esta nueva entidad.
Crearemos un carpeta para el módulo llamada “entity_example” y un nuevo fichero .info con el siguiente contenido:

; $Id: ajax_example.info,v 1.3 2010/08/11 23:16:27 rfay Exp $

name = Ejemplo de Entidad
description = Módulo de ejemplo que muestra como usar el API de Entidades de Drupal
core = 7.x
package = Modulos de ejemplo
files[] = entity_example.module
files[] = entity_example.install

Definiendo el Modelo de la BBDD

Como se vió en la tercera entrega es posible definir un esquema de bbdd para que nuestro módulo disponga de un conjunto de tablas y campos sobre los que manejar la información que necesita gestionar. Generamos un nuevo fichero entity_example.install, pero esta vez sólo tendremos la implementación de hook_squema():

<?php
// $Id$

/**
 * @file
 * Install/Update/Uninstall functions for entity_example module.
 */

/**
 * Implements hook_schema().
 *
 * @see hook_schema()
 * @link schemaapi Schema API @endlink
 */
function entity_example_schema() {
  $schema[‘example_entity’] = array(
    ‘description’ => ‘The base table for example entity’,
    ‘fields’ => array(
      ‘eeid’ => array(
        ‘description’ => ‘The primary identifier for a entity.’,
        ‘type’ => ‘serial’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
      ),
      ‘title’ => array(
        ‘description’ => ‘The title of this entity, always treated as non-markup plain text.’,
        ‘type’ => ‘varchar’,
        ‘length’ => 255,
        ‘not null’ => TRUE,
        ‘default’ => ”,
      ),
      ‘perm’ => array(
        ‘type’ => ‘int’,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘size’ => ‘tiny’,
        ‘description’ => ‘Whether the example entity is permanent(1) or not(0).’,
      ),
      ‘dstart’ => array(
        ‘type’ => ‘int’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘description’ => ‘Start date of example entity. Format: Ymd’,
      ),
      ‘dend’ => array(
        ‘type’ => ‘int’,
        ‘unsigned’ => TRUE,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘description’ => ‘End date of example entity. Format: Ymd’,
      ),
      ‘weight’ => array(
        ‘type’ => ‘int’,
        ‘not null’ => TRUE,
        ‘default’ => 0,
        ‘description’ => ‘The weight of this example entity.’,
      ),
    ),
    ‘primary key’ => array(‘eeid’),
    ‘indexes’ => array(
      ‘perm’ => array(‘perm’),
      ‘dstart’ => array(‘dstart’),
      ‘dend’ => array(‘dend’),
    ),
  );
  return $schema;
}

Como podemos ver en modelo es sencillo:

  • Campos:
    • eeid: numero entero, sin signo, no puede ser null y clave primaria de la tabla
    • title: varchar de 255 caracteres que almacenará el título
    • perm: entero pequeño (tiny) que almacena valores 0 y 1
    • dstart y dend: fecha inicio y fin 
    • weigth: peso de la entidad.
  • Clave primaria: campo eeid
  • indices:
    • perm
    • dstart
    • dend

Hasta aquí el modelo está definido, cuando se active el módulo se generará la tabla ‘example_entity’ con las especificaciones que le hemos definido.

Añadir Permisos, hook_permission()

Ahora añadiremos el fichero .module donde colocaremos el resto del código del módulo.
Debido a que estamos manejando una nueva entidad será necesario aplicar nuevos permisos con el módulo para así poder controlar mejor que operaciones pueden realizar los usuarios. Para ello utilizaremos el hook_permission().  aquí tenemos un ejemplo de uso para el módulo:
/**
 * Implements hook_permission().
 */
function entity_example_permission() {
  return array(
    ‘administer example entity’ =>  array(
      ‘title’ => t(‘Administer example entity’),
      ‘restrict access’ => TRUE,
    ),
  );
}
Como puede verse el hook debe devolver un array asociativo con un elemento para cada nuevo permiso. En este caso es “administer example entity”, donde configuramos que su valor es otro array con el título (title) y si restrigiremos el acceso a la funcionalidad (restrict access), que en este caso lo haremos.

Definición de la entidad: hook_entity_info()

La definición de la entidad se realiza a través del hook_entity_info(), veamos un ejemplo de implementación para este módulo:
/**
 * Implementa hook_entity_info().
 */
function entity_example_entity_info() {
  $return = array(
    ‘entity_example’ => array(
      ‘label’ => t(‘Example entity’),
      ‘base table’ => ‘example_entity’,
      ‘uri callback’ => ‘entity_example_uri’,
      ‘fieldable’ => TRUE,
      ‘entity keys’ => array(
        ‘id’ => ‘eeid’,
      ),
      ‘bundles’ => array(
        ‘entity_example’ => array(
          ‘label’ => t(‘Example entity’),
          ‘admin’ => array(
            ‘path’ => ‘admin/structure/entity_example’,
            ‘access arguments’ => array(‘administer example entity’),
          ),
        ),
      ),
    ),
  );
  return $return;
}
Como puede verse se devuelve un array asociativo son los datos principales de las entidades que queremos definir. En este caso se está definiendo la entidad ‘entity_example’ como índice del array principal. Dentro del array que define cada entidad nos encontramos con los siguientes campos:

  • label: etiqueta principal
  • base_table: nombre de la tabla que gestiona la entidad
  • uri callback: nombre dela función que sabe manejar las URL’s de la entidad, nos permitirá pasar por URL la entidad que manejamos.
  • fieldable: booleano que define si la entidad es manejable mediante campos (Field API)
  • entity keys: array de claves primarias de la entidad, en este caso es el campo eeid
  • bundles: conjuntos de entidades que queremos gestionar, en este caso solo daremos una de alta correspondiendo a la entidad que hemos dado de alta ‘entity_example’
    • nombre_entidad: aqui referenciamos el bundle con la entidad
      • label: etiqueta de la entidad para el bundle
      • admin: array con los datos de la administración del bundle para la entidad
        • path: rura de acceso a la administración
        • access arguments: array de permisos necesarios para la gestión de la entidad

A continuación debemos programar la función que permite manejar las rutas de la entidad para Drupal:
/**
 * Entity uri callback.
 */
function entity_example_uri($entity_example) {
  return array(
    ‘path’ => ‘entity_example/’ . $entity_example->eeid,
  );
}
Como puede verse nos pasan la entidad entera y devolvemos el path con el ID de la entidad que nos pasan en el campo “path” concatenado con la rura principal “entity_example/”.
Tambiñen deberemos sobreescribir el hook_admin_paths(), para que funcionen correctamente las rutas de edición de entidades:
/**
 * Implements hook_admin_paths().
 */
function entity_example_admin_paths() {
  $paths = array(
    ‘entity_example/*/edit’ => TRUE,
  );
  return $paths;
}
 De esta manera cambiaremos algunos paths administrativos del módulo, en concreto el que tiene que ver con la edición de elementos de la entidad.
Esto se entenderá mucho mejor cuando veamos los enlaces generados con el hook_menu().

Entradas del menú para hacer el CRUD

Como se ha mencionado anteriormente será necesario dar de alta todas las funcionalidades de la gestión de la nueva entidad y sus enlaces en el menú, como siempre, lo haremos a través del hook_menu():

/**
 * Implements hook_menu().
 */
function entity_example_menu() {
  $items[‘entity_example/%entity_example’] = array(
    ‘title’ => ‘Example entity’,
    ‘title callback’ => ‘entity_example_page_title’,
    ‘title arguments’ => array(1),
    ‘page callback’ => ‘entity_example_page’,
    ‘page arguments’ => array(1),
    ‘access arguments’ => array(‘access content’),
    ‘type’ => MENU_CALLBACK,
  );
  $items[‘entity_example/%entity_example/view’] = array(
    ‘title’ => ‘View’,
    ‘type’ => MENU_DEFAULT_LOCAL_TASK,
  );
  $items[‘entity_example/%entity_example/edit’] = array(
    ‘title’ => ‘Edit’,
    ‘page callback’ => ‘drupal_get_form’,
    ‘page arguments’ => array(‘entity_example_form_edit’, 1),
    ‘access arguments’ => array(‘administer example entity’),
    ‘type’ => MENU_LOCAL_TASK,
    ‘weight’ => 10,
  );

  $items[‘admin/structure/entity_example’] = array(
    ‘title’ => ‘Example entities’,
    ‘description’ => ‘Manage example entities on your site.’,
    ‘access arguments’ => array(‘administer example entity’),
    ‘page callback’ => ‘entity_example_page_admin’,
    ‘page arguments’ => array(‘list’),
    ‘weight’ => -10,
  );

  $items[‘admin/structure/entity_example/list’] = array(
    ‘title’ => ‘List’,
    ‘type’ => MENU_DEFAULT_LOCAL_TASK,
    ‘weight’ => -10,
  );

  $items[‘admin/structure/entity_example/create’] = array(
    ‘title’ => ‘Add example entity’,
    ‘page arguments’ => array(‘create’),
    ‘access arguments’ => array(‘administer example entity’),
    ‘type’ => MENU_LOCAL_ACTION,
  );

  return $items;
}

Como podemos ver estamos gestionando muchos enlaces, así que explicaremos uno a uno su significado para entender mejor su funcionamiento, en la siguiente entrega.

Referencias:

Licencia Creative Commons

Curso de Desarrollo de Módulos con Drupal 7 (VIII): Features

18 mayo 2012
pepesan
No comments
Categories: desarrollo, desarrollo de módulos, devel, development, drupal, drupal7, features, modules

El módulo Features es una ayuda a los desarrolladores e implantadores de sitios web hechos con Drupal. Una vez instalado y activado podremos interactuar con él a través del path “admin/structure/features”…

como puede verse en la captura, disponemos del listado principal de Features disponibles en nuestro Drupal. A continuación pulsaremos en la pestaña “Create Feature”…

De esta manera podemos configurar la nueva Feature, introduciendo los datos en el formulario:

  • Nombre.
  • Descripción.
  • Package: nombre del paquete donde encontraremos el módulo que contiene la Feature.
  • Versión.
  • URL of Update XML: url de actualización de la feature
  • Edit components: aquí seleccionaremos los distintos componentes de nuestro Drupal que queremos añadir a la feature.

Según vayamos seleccionando los componentes, se nos irán desplegando distintas opciones desde los distintos módulos instalados en nuestro drupal, por lo que podremos seleccionar, desde Tipos de Contenidos a Views para irlas añadiendo a nuestra feature…

Una vez hayamos terminado de añadir componentes a la feature, pulsaremos en el botón “Download Feature”, esto nos permitirá descargar aquellos componentes como un fichero desplegable en otros Drupal instalados. El fichero generado por Features es un fichero comprimido que incluye aquellos componentes seleccionado en forma de código.

Despliegue de la Feature por primera vez

Para instalar y configurar la feature se realiza, inicialmente de la misma manera que se instla un módulo, subiendolo a través del interfaz, o simplemente, descomprimiendo el fichero descargado en el directorio “sites/all/modules”. 
Para poder realizar correctamente la activación será necesario seguir una serie de pasos:

  • Realizar un backup completo de la instalación
  • Verificar que los módulos de los que depende la feature han sido correctamente instalados y activados.

Una vez instalado deberemos activar el nuevo módulo…

Una vez activado, nos moveremos de nuevo a “admin/structure/features” y nos encontremos con la nueva feature…

Procederemos a activarla, mrcando la checkbox al lado de la feature y pulsando en el botón “Guardar la Configuración”.Debería aparecer como “Predeterminado” por lo que ya deberíamos disponer de todas las funcionalidades y Componentes desplegados en el sitio web.

Exportando modificaciones de la feature

Una vez desplegada la feature en el sitio en producción será necesario poder realizar actualizaciones de la funcionalidad y de los componentes integrados en la misma, para ello será necesario reempaquetar la feature con los cambios y realizar el despliegue de nuevo de la feature.
Para ello, el primer paso es modificar la feature, desde el listado de features, pulsamos en el enlace “Recreate” al lado de la feature que queremos modificar.
Añadiremos los nuevos componentes y volveremos a descargar la feature.
Posteriormente volveremos a subir la feature a la instancia de drupal en producción. Y el administrador podrá elegir que cambios quiere Actualizar “Update” o revertir “Revert”.

Referencias: 

Licencia Creative Commons

Curso de Desarrollo de Módulos con Drupal 7 (VII): Nuevo índice de Contenidos

16 mayo 2012
pepesan
No comments
Categories: drupal, drupal7, módulos interesantes drupal, temas interesantes

  Temas de Referencia

Licencia Creative Commons

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

1 mayo 2012
pepesan
No comments
Categories: blocks, bloques, curso, Database API, desarrollo, devel, development, drupal, drupal7, modelo, module

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

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