aNieto2K Desarrollo web, Wordpress, y alguna cosilla más

Para ser un buen desarrollador de plugins para Wordpress debemos mejorar algunos de nuestros puntos de interacción con el usuario. Para ello Wordpress nos ofrece una serie de opciones para mejorar la información relacionada con el plugin que hemos desarrollado.

plugin_action_links

Se trata de un filtro que se aplicara siempre que entremos en la página de gestión de plugins. En él podemos modificar la salida de links que el plugin nos ofrece:

(Ver Imagen)

Estos links pueden, por ejemplo, llevarnos directamente a la página de configuración del plugin. Un valor añadido que hará que el plugin gane un poco de calidad.

<?php
// Asociamos la función add_plugin_links() al filtro
add_filter('plugin_action_links', 'add_plugin_links', 10, 2);

// Declaramos la función
function add_plugin_links($links, $file) {
	// Marcamos el plugin actual
	static $this_plugin;
	if (!$this_plugin) $this_plugin = plugin_basename(__FILE__);

		// Comprobamos que el plugin que estamos mostrando por pantalla es el nuestro.
		if ($file == $this_plugin ){

		// Definimos el enlace a "Configuración"
		$settings_link = '<a href="index.php">Configuración</a>';

		// Añadimos el nuevo link a los ya existentes
		array_unshift($links, $settings_link);
	}
	// Devolvemos los links
	return $links;
}
?>

after_plugin_row

Otra forma de ofrecer más información al usuario es informar de que existe una actualización pendiente para el plugin. Para ello podemos mostrar un mensaje en la parte inferior del plugin y así se verá claramente la actualización:

(Ver Imagen)

Esto hará que el usuario sea consciente del cambio de versión que está disponible en cada momento. Para ello Wordpres nos ofrece la posibilidad de comprobar un fichero alojado en nuestro servidor que indicará la versión y la contrastará con la instalada (siempre y cuando el servidor permita este tipo de peticiones).

<?php
// Asociamos add_plugin_row() al action.
add_action('after_plugin_row', 'add_plugin_row', 10, 2);

// Declaramos la función
function add_plugin_row($links, $file) {
	global $wp_version;
	// Marcamos el plugin actual
	static $this_plugin;
	if (!$this_plugin) $this_plugin = plugin_basename(__FILE__);

	// Comprobamos que el plugin que estamos mostrando por pantalla es el nuestro.
	if ($file == $this_plugin ){
		// ¿Está disponible la actualización de plugins?
		$current = get_option('update_plugins');
		if (!isset($current->response[$file])) return false;

		// Controlamos el número de columnas disponibles dependiendo de la versión.
		$columns = substr($wp_version, 0, 3) == "2.8" ? 3 : 5;

		// Definimos la ruta de nuestro fichero de información.
		$url = "http://www.yoursite.com/info.txt";

		// Lanzamos la consulta externa.
		$update = wp_remote_fopen($url);

		// Pintamos el mensaje de alerta.
		echo '<td colspan="'.$columns.'">';
		echo $update;
		echo '</td>';
	}
}

Minimizando

Apartir de Wordpress 2.7 disponemos de 2 posibilidades más:

<?php
// Nombre del plugin
$plugin_name = "miplugin";

// Filtros específicos para cada plugin
add_filter("plugin_action_links_$plugin_name", "....");
add_action("after_plugin_row_$plugin_name", "....");
?>

¿Estás pensando en añadir una funcionalidad a Wordpress y no sabes por donde empezar a extenderlo? ¿te gustaría hacer las tareas más comunes de tu día a día con el blog sean más fáciles? Pues solo necesitas conocer, como actuar frente a esta pregunta.

¿Como y donde puedo extender Wordpress?

Wordpress, por defecto, nos presenta 3 formas de extender las funcionalidades de Wordpress:

1. Mediante actions.
2. Mediante filters.
3. Mediante declaración de funciones.

Todas ellas sin necesidad de tocar el código propio del núcleo de Wordpress, evitando así tener que hacer modificaciones cada vez que actualicemos nuestro Wordpres.

Extender Wordpress mediante Actions

Uno de los métodos que podemos usar y que están disponibles el la API de Wordpress es el uso de actions. Como su nombre indica, actions son las acciones definidas por el equipo de Wordpress en las que podremos añadir nuestras propias funcionalidades.

<?php add_action($tag, $function_to_add, $priority = 10, $accepted_args = 1); ?>

Esta función que tanto hemos visto en plugins o código que hemos mostrado para extender Wordpress, hace una función muy importante y cada parámetro aporta un grado más de personalización.

• $tag: Nombre del action (ahora los veremos).
• $function_to_add: Nombre de la función que ejecutaremos al activarse el action ($tag).
• $priority: Prioridad de ejecución, de menor a mayor.
• $accepted_args: Aceptamos (o no) el paso de parámetros a nuestra función.

Ejemplo:

<?php
define("TWITTER_USER", 'username');
define("TWITTER_PASS", 'password');
define("TWITTER_MESSAGE", '[Post] %name%: %link% <-- %title%');

function update_twitter($post_ID = '')  {
	$curl_handle = curl_init();

	// Nombre del blog
	$message = str_replace("%name%", get_bloginfo('name'), TWITTER_MESSAGE);

	// Cargamos el post
	$post = get_post($post_ID);

	// Enlace y título
	$message = str_replace("%link%", $post->guid, $message);
	$message = str_replace("%title%", $post->post_title, $message);

	// Enviamos el Tweet
	curl_setopt($curl_handle, CURLOPT_URL, 'http://twitter.com/statuses/update.xml');
	curl_setopt($curl_handle, CURLOPT_CONNECTTIMEOUT, 2);
	curl_setopt($curl_handle, CURLOPT_RETURNTRANSFER, 1);
	curl_setopt($curl_handle, CURLOPT_POST, 1);
	curl_setopt($curl_handle, CURLOPT_POSTFIELDS, "status=$message";
	curl_setopt($curl_handle, CURLOPT_USERPWD, TWITTER_USER.":"TWITTER_PASS);
	$buffer = curl_exec($curl_handle);
	curl_close($curl_handle);
  return $post_ID;
}
// Añadimos funcionalidad a publish_post
add_action('wp_insert_post', 'update_twitter');
?>

No le hagais mucho caso al código, es ilustrativo y puede producir un funcionamiento erroneo en Wordpress

En este código, vemos lo sencillo que es añadir una funcionalidad a nuestro Wordpress. En este caso, estamos añadiendo al action wp_insert_post la función update_twitter(). En este caso, una vez hayamos pulsado el botón de publicar en nuestro Wordpress, este ejecutará la función update_twitter() y esta enviará a Twitter un aviso de un nuevo artículo.

¿Donde se extienden los actions?

Este ejemplo solo debe servir para hacernos una idea de como añadir funcionalidades a nuestro Wordpress, lo interesante es que debemos conocer los actions disponibles para extender nuestro Wordpress.

La API nos muestra un listado bastante detallado de los action disponibles. Pero si tenemos alguna duda lo mejor es siempre revisar el código.

En el fichero post.php del directorio wp-includes/ podemos encontrar en la línea 1534 la llamada do_action() que lanzará las acciones asociadas al nombre wp_insert_post.

[...]
	wp_transition_post_status($post_status, $previous_status, $post);

	if ( $update)
		do_action('edit_post', $post_ID, $post);

	do_action('save_post', $post_ID, $post);
	do_action('wp_insert_post', $post_ID, $post);

	return $post_ID;
}
[...]

do_action(), es la función encargada de lanzar el array de acciones asociadas a la key definida por el primer parámetro. En este caso wp_insert_post, lanzará nuestra función que recibirá por parámetro $post_ID que estamos pasando con el do_action(). Suplementaríamente estamos paando un segundo parámetro con $post, que contiene el objeto con los valores que componen el post que acabamos de insertar en la BD.

Revisando el código de Wordpress encontraremos una infinidad de do_action() que permiten extender Wordpress en casi todos los puntos en los que queramos añadir una nueva funcionalidad.

Mediante filters

Los filters, están mucho más extendidos por el núcleo de Wordpress. Como su nombre indica, sirven para filtrar variables que nos podemos encontrar en cualquier funcionalidad de Wordpress.

Al igual que los actions, podemos extender la funcionalidad de nuestro Wordpress en ellos.

Ejemplo

<?php
	function noShowIPs($IP = '') {
		// Mostramos solo los primeros 7 carácteres
		return substr($IP, 0, 7);
	}
	// Aplicamos el filtro
	add_filter('get_comment_author_IP', 'noShowIPs');
?>

En este pequeño ejemplo, indicamos que no queremos mostrar la IP completa del usuario que comenta en nuestro Wordpress cuando se usa la función get_comment_author_IP(). Mediante un substr() devolvemos los 7 primeros dígitos de $IP.

¿Donde se extienden los filters?

Al igual que los actions, los filters están en los ficheros que componen Wordpress. En el ejemplo que hemos montado previamente hemos hecho uso de get_comment_author_IP() que se encuentra en el fichero comment-template.php del directorio wp-includes/. Si nos dirigimos a la línea 173 veremos el siguiente código.

[...]
function get_comment_author_IP() {
	global $comment;
	return apply_filters('get_comment_author_IP', $comment->comment_author_IP);
}
[...]

apply_filters() es el do_action() de los filters, ya que se encarga de recorrer el array de filtros definidos para la key establecida y los va aplicando uno trás otro. En nuestro caso, recibimos la IP del comentarista para posteriormente devolver una IP recortada.

Mediante declaración de funciones

Esta forma, es quizas la más obvia, pero no por ello deja de ser potente.

En muchos casos, usamos plugins por que son más fáciles de instalar, pero bien bien, podrían ser sustituidos por funciones alojadas en ficheros concretos de Wordpress. Obtendríamos el mismo resultado.

Ejemplo

<?php
function ult_comments($cuantos = 5) {
    global $wpdb;
    $comentarios = $wpdb->get_results($wpdb->prepare("
                            SELECT  wc.comment_date, wc.comment_author, wp.post_title, wp.guid, wp.comment_count
                            FROM ".$wpdb->comments." as wc, ".$wpdb->posts." as wp
                            WHERE wc.comment_post_ID = wp.ID
                            AND  wc.comment_approved = '1'
                            AND wc.comment_type = ''
                            ORDER BY wc.comment_date DESC LIMIT 0,%d;",$cuantos ));
    foreach ($comentarios as $comentario) {
			echo '<li>
				<a href="'.$comentario->guid.'" title="'.$comentario->post_title.'">'.$comentario->post_title.'
				  <small>'.$comentario->comment_count.'</small>
                                </a>
        			<small>Por '.$comentario->comment_author.' hace '.since_date($comentario->comment_date).'</small>
                              </li>';
    }
}
?>

Uno de los puntos recomendados para alojar este tipo de funciones, es el fichero functions.php de nuestro theme. Todas las funciones definidas en él serán visibles desde nuestro themes, plugins, …

En este caso, definimos esta función que nos devolverá los últimos 5 comentarios del blog en el fichero functions.php. Una vez definida, podremos usarla en nuestro theme, donde más rábia nos dé, simplementa llamándola.

<ul>
<?php ult_comments(10); // 10 últimos comentarios ?>
</ul>

¿Que podemos hacer con todo esto?

Pues lo que queramos, podemos hacer que Wordpress se transforme a nuestra voluntad. Nos permite desde añadir funcionalidades que nos ayudan en el día a día, hasta cambiar el concepto de blog por el de CMS, Miniblog, …

Edito:

NUNCA SE DEBE TOCAR EL CÓDIGO DE WORDPRESS

Este artículo intenta mostrar las diferentes formas de extender Wordpress, sin necesidad de tocar los ficheros que componen el núcleo de Wordpress, osea la raíz y wp-includes/ y wp-admin/. Para poder extenderlo puedes hacer uso de los fichero functions.php de tu theme o generar un plugin con dichas funcionalidades dentro.

La limitación, está en nuestra cabeza

Wordpress está pensado para que uno o varios autores introduzcan entradas en él. Y despues los usuarios puedan comentar estas entradas, pero previamente estas deben estar introducidas sinó, el concepto Blog en sí, no tiene ningún sentido. Pero Wordpress va un poco más allá y nos permite hacer que el sistema de insercción de entradas no esté, necesariamente, vinculado al Wordpress.

Para ello, tenemos la función wp_insert_post(), una función a la que le pasaremos los parámetros que compondrán una entrada en nuestro Blog.

Los chicos de WPEngineer.com hacen un repaso a estos parámetros y nos muestran un sistema muy sencillo de realizar insercciones ajenas a nuestro Blog. Está claro que este sistema es peligroso, y que requiere que el usuario esté logueado para realizar la insercción.

wp_insert_post()

wp_insert_post($postarr = array())

Vemos que esta función recibe un parámetro, un array que estará compuesto con los parámetros necesarios para formar una entrada.

Los valores de este parámetro pueden ser:

<?php
$post = array(
  'comment_status' => [ 'closed' | 'open' ] // 'closed' no permite comentarios.
  'ID' => [ <post id> ] // únicamente si estamos actualizando un comentario.
  'menu_order' => [ <order> ] //Si es una nueva página, especifica el orden en el que debería aparecer
  'page_template => [ <template file> ] // Indica el template para la página.
  'ping_status' => [ ? ] // Activamos o desactivamos los pingbacks
  'pinged' => [ ? ] //?
  'post_author' => [ <user ID> ] //ID del usuario
  'post_category => [ array(<category id>, <...>) ] // Categorías del post.
  'post_content' => [ <the text of the post> ] // Contenido del post.
  'post_date' => [ Y-m-d H:i:s ] // Fecha de creación del post.
  'post_date_gmt' => [ Y-m-d H:i:s ] // Fecha de creación en GMT.
  'post_excerpt' => [ <an excerpt> ] // El resumen del post.
  'post_parent' => [ <post ID> ] // El post padre.
  'post_password' => [ ? ] // El password del post.
  'post_status' => [ 'draft' | 'publish' | 'pending' ] // Estado de la publicación
  'post_title' => [ <the title> ] // Título del post.
  'post_type' => [ 'post' | 'page' ] // Post o Página.
  'tags_input' => [ '<tag>, <tag>, <...>' ] // Tags asociados al post.
  'to_ping' => [ ? ] //?
);
// Insertamos el post
wp_insert_post( $post );
?>

Conociendo esto, ya podemos usar funcionalidades de Wordpress fuera de Wordpress.

// Incluimos las funcionalidades de Wordpress
require( '../my_wordpress_install_root/wp-load.php' );

// Creamos el array
$my_post = array();
$my_post['post_title']    = 'Mi post';
$my_post['post_content']  = 'This is my post.';
$my_post['post_status']   = 'publish';
$my_post['post_author']   = 1;
$my_post['post_category'] = array(0);

// Insertamos el post en la base de datos
wp_insert_post( $my_post );"

AyudaWordpress nos muestra un tutorial muy interesante para ocultar contenido a los usuario no registrados mediante el uso de ShortCodes.

Y es que con unas pocas líneas en Wordpress se pueden hacer cosas realmente útiles y potentes.

// Functions.php
add_shortcode( 'visitante', 'shortcode_para_visitantes' );
function shortcode_para_visitantes( $atts, $content = null ) {
if ( ( is_user_logged_in() && !is_null( $content ) ) || is_feed() )
return $content;
return 'Para ver este contenido, <a href="' . site_url('wp-login.php?action=register', 'login') . '">debes estár registrado</a>';
}

Una vez añadido a nuestro functions.php podremos usar [visitante][/visitante] para ocultar el contenido que queramos a los visitantes no registrados.

[visitante]
Aquí pones lo que te apetezca que quieras que vean solo los no registrados
[/visitante]

Más opciones en AyudaWordpress.

La proliferación de blogs ha hecho que le contenido esté muy distribuido por Internet y de un artículo pueden llegar a salir miles de links (pingbacks) en los que puede haber debate sobre el mismo contenido inicial.

Imagina que pueda estar vinculado con todos los blogs (Wordpress) que han hecho un ping a tus artículo, y que en tu blog puedas mostrar los comentarios de estos blogs (siempre y cuando estos lo permitan).

getCommentsFromPingbacks() es una función que he montado que permite mostrar de los pingbacks encontrados por cada post, un listado de comentarios sobre esa anotación en cada uno de los anteriores pingbacks.

El código

<?php
include_once(ABSPATH . WPINC . '/rss.php');
function getCommentsFromPingbacks($postID = 0, $limit = 5, $propios = false){
  global $wpdb;
  // Obtenemos la dirección de nuestro blog
  $localhost = '';
  if ($propios)
  	$localhost = "AND comment_author_url NOT LIKE '".get_option("siteurl")."%";

  // Lanzamos petición
  $urls = $wpdb->get_results("SELECT comment_author, comment_author_url FROM $wpdb->comments WHERE comment_post_ID = ".intval($postID)."  $localhost AND comment_type = 'pingback' AND comment_agent LIKE '%WordPress%' LIMIT ".intval($limit));

  // Sinó hay pingbacks, salimos
	if (!$urls) return;

	// Recorremos los pingbacks
	foreach($urls as $url) {
		// Parátro RSS de comentarios
		if (strpos($url->comment_author_url,'?') === false) $actual = $url->comment_author_url.'?feed=comments-rss2';
		else $actual = $url->comment_author_url.'&feed=comments-rss2';

   // Leemos comentarios
    $rss = fetch_rss($actual);

    // Si no hay $rss o items seguimos con el siguiente.
    if (!$rss || !$rss->items) continue; 

	$items = array_reverse($rss->items);

	echo '<h3>'.$url->comment_author.'</h3><ul class="external_comments">';
	for($id = count($items); $id>0; $id--){
        $item = false;
        // Datos basicos
        $item->comment_author = $items[$id]['dc']['creator'];
        $item->comment_author_url = $items[$id]['link'];
        $item->comment_date = $items[$id]['pubdate'];
        $item->comment_content = $items[$id]['content']['encoded'];

        // comment_ID
        $item->comment_ID = 'external-'.$id;
        $item->comment_type = 'external';

	// Pintamos el comentario
        createComments($item);
    }
    echo '</ul>';
  }
}
/*
   Pintamos el comentario
*/
function createComments($com) {
	echo '<li>
		<h4>'.$com->comment_author.'</h4>
		<small>'.$com->comment_date.'</small>
		<div class="comment_content">
			'.$com->comment_content.'
		</div>
	</li>';
}

// Solicitamos los comentarios del post
getCommentsFromPingbacks($post->ID);
?>

El código, se encarga de buscar pingbacks en el post indicado como parámetro. Además podemos indicar un límite de sitios que comprobar, por defecto le he puesto 5 (hay que tener en cuenta el tiempo de carga de la página) y despues como tercer parámetro podemos indicar si queremos que aparezcan los comentarios enlazados de nuestro propio blog.

Una vez localizadas las url’s de los pingbacks, procedemos a solicitar los comentarios, para ello usamos el parámetro de Wordpress feed=comments_rss2, que nos devolverá un RSS con los comentarios del post. Esto implica una limitación de tamaño (sinó recuerdo mal, no he podido probarlo) y que el blog externo debe tenerlo activo. Mediante el uso de fetch_rss() podremos realizar la petición y además recibir el comentario como un objeto fácil de iterar y procesar.

El código está pensado para usarse en el sistema de comentarios de Wordpress 2.7, creando un comentario virtual con los datos necesarios para que el callback de wp_lists_comments() pueda procesarlo como un comentario.

Por defecto, indicará el atributo class de cada comentario, como “external”, esto es debido al comment_type que lo informamos en la función.

Para el ejemplo, he montado createComments() que recibe un parémtro $com, que es el comentario con los datos necesarios.

¿Donde iría este código?

Pues este código solo necesita que se cumpla una premisa y es que el ID del comentario esté informado. Realmente puede ir cualquier parte de Wordpress siempre y cuando se pase el ID de un artículo de nuestro Wordpress. Si usamos el ejemplo tal cual, debería estar dentro del Loop y más concretamente en el fichero comments.php de nuestro theme, pero lo mejor es ir probando y ubicarlo en el sitio que creamos más acertado.

¿Que os parece?

Opiniones, impresiones, se agredecen.

En AyudaWordpress nos cuenta Fernando que en la nueva versión de Wordpress, la 2.8. El fichero my-hacks.php dejará de ser soportado, lo que significa que todo lo que tengamos definido en él, dejará de funcionar. Hace ya casi 6 años que se anunciaba esta funcionalidad y desde entonces ha ido creciendo en muchos blogs alojando esos scripts que no sabíamos donde colocar. Ahora tendremos que buscar un lugar donde ubicar estos scripts:

1. functions.php: El fichero functions.php es el que encontramos dentro de nuestro theme. En él podemos incluir todo el contenido de my-hacks.php y funcionará perfectamente.
2. plugin: Podemos aprovechar el fichero my-hacks.php para convertirlo en un plugin con funcionalidades varias. ¿Como? Sigue leyendo

Es muy sencillo, únicamente hemos de añadir esto al principio del fichero:

/*
Plugin Name: my-Hacks.php
Plugin URI: http://
Description: my-hacks.php convertido en plugin
Author: TU MISMO
Version: 1.0
Author URI: http://
*/

Despues lo úbicamos en la carpeta wp-content/plugins/ y nos aparecerá un plugin más en el panel de plugins de panel administrador. Lo activamos y listo. Ya tenemos my-hacks.php fuera de la raiz. ¿Fácil verdad?

En WeblogToolsCollection publican un artículo con el que nos muestran como realzar los resultados de nuestras búsquedas mediante el uso de un pequeño script con jQuery. Simplemente tendremos que realizar dos pasos muy sencillos para que nuestro theme ayude al usuario a encontrar esa palabra que está buscando.

1. Añadimos jQuery y la palabra a buscar

function hls_set_query() {
  $query  = attribute_escape(get_search_query());

  if(strlen($query) > 0){
    echo '
      <script type="text/javascript">
        var hls_query  = "'.$query.'";
      </script>
    ';
  }
}

function hls_init_jquery() {
  wp_enqueue_script('jquery');
}

add_action('init', 'hls_init_jquery');
add_action('wp_print_scripts', 'hls_set_query');

Añadiendo este código al fichero functions.php de nuestro theme dispondremos de jQuery en nuestro theme, y además tendremos una variable javascript (hls_query) con el valor de la búsqueda que jQuery deberá encontrar en el texto y resaltar.

2. Añadimos el script a nuestro header.php

 <style type="text/css" media="screen">
    .hls { background: #D3E18A; }
  </style>
  <script type="text/javascript">
  jQuery.fn.extend({
    highlight: function(search, insensitive, class){
      var regex = new RegExp("(<[^>]*>)|(\\b"+ search.replace(/([-.*+?^${}()|[\]\/\\])/g,"\\$1") +")", insensitive ? "ig" : "g");
      return this.html(this.html().replace(regex, function(a, b, c){
        return (a.charAt(0) == "<") ? a : "<strong class=\""+ class +"\">" + c + "</strong>";
      }));
    }
  });
  jQuery(document).ready(function($){
    $("#post-area").highlight(hls_query, 1, "hls");
  });
  </script>

Este código se encargará de buscar en nuestro contenido, concretamente en el id #post-area (hay que reemplazarlo por nuestro el contenedor de nuestros posts), y resaltará el texto buscado con la clase CSS .hls que está definida al inicio del código.

Importante

1. Reemplaza #post-area por el valor del contenedor de posts.
2. Cambia el color del resaltado reemplazando el valor (#D3E18A) por uno que se ajuste a tu diseño.

Alternativa

Si quieres resaltar los resultados sin necesidad de usar javascript, puedes usar WP-Resalta Busqueda.

En Real Ultimate Waffe, comentan la idea de incluir la propiedad __autoload() de PHP5 a la lógica de Wordpress. Y la idea es muy interesante.

__autoload() es una funcionalidad de PHP5 que nos permite ejecutar código al llamar cualquier Clase que no esté declarada, uniendo esto a que generalmente se usa un fichero para declarar una clase podemos hacer cosas como:

<?php
function __autoload($class_name) {
    require_once $class_name . '.php';
}

$obj  = new MyClass1();
$obj2 = new MyClass2();
?>

En el ejemplo, vemos que cargamos el fichero $class_name.php desde la función __autoload() que será llamada a la hora de instanciar cada una de las clases. En este ejemplo, llamará a los fichero MyClass1.php y MyClass2.php.

En Wordpress se podría usar esta característica para evitar la carga innecesaria de ficheros que no llegamos a usar. De esta forma además de optimizar las llamadas a disco, evitamos cargar innecesariamente objetos en memoria que no vamos a usar.

Lástima que para poder usarlo debamos replantear parte de la estructura base de Wordpress, pero no descarto que en una futura versión veamos esta mejora que aportará muchos beneficios en cuanto a recursos se refiere.

Hoy Bitacoras.com ha abierto al público su API pública que nos permitirá disfrutar de las posibilidades que toda la información dela que disponen. Sin duda es una gran noticia ya que una de las bazas con la que juegan Bitacoras es que disponen de una gran cantidad de información relevante y es un gran paso a delánte para todos el que la pongan a nuestra disposición.

He tenido el privilegio, junto a Marcos Besteiro de PropiedadPrivada de realizar una serie de pruebas sobre la API (antes de abrirla al público) y me ha sorprendido la velocidad de respuesta y la facilidad de uso que han conseguido para las peticiones. Sin duda es una herramienta digna de explotar.

¿Que podemos obtener?

Basta con entrar en la documentación de la API para ver las grandes posibilidades que nos están brindando.

1. Portada
2. Canales
3. Buscar
4. Geo
5. Recomendaciones
6. Descubrimientos
7. Sigue a
8. Le siguen
9. Comunidad
10. Comentarios
11. Recibidos
12. Inbox
13. Top bitacoras
14. Top usuarios

Estos son las opciones de las que podemos obtener datos para nuestras aplicaciones. Las que mediante una simple petición HTTP nos permite realizar la petición condicionando el formato de respuesta que deseemos:

• JSON
• XML
• PHP
• RSS
• ATOM

Marcos, nos deslumbra con una serie de ejemplos creados apartir del uso de la API, para mostrarnos algunas posibilidades que nos ofrece la API.

Mi granito de arena

Para hacer más fácil las peticiones, os dejo aquí la función que monté para hacer las pruebas, es muy sencilla de usar (como veremos en el ejemplo).

function get_from_bitacoras($que) {
		$methods = array("portada", "canales", "buscar", "geo", "recomendaciones", "comentarios", "sigue_a", "le_siguen", "comunidad");
		extract($que);

		if (!in_array($method, $methods)) die("Método no existente");
		if (!isset($params["key"]) || empty($params["key"])) die("Necesitas una KEY");

		$curl_handle=curl_init();
		curl_setopt($curl_handle,CURLOPT_URL,"http://api.bitacoras.com/".$method);
		curl_setopt($curl_handle,CURLOPT_CONNECTTIMEOUT,2);
		curl_setopt($curl_handle,CURLOPT_RETURNTRANSFER,1);
		curl_setopt($curl_handle, CURLOPT_POST,1);
		curl_setopt($curl_handle, CURLOPT_POSTFIELDS,$params);
		curl_setopt($curl_handle, CURLOPT_FOLLOWLOCATION  ,1);
		curl_setopt($curl_handle, CURLOPT_HEADER,0);
		$buffer = curl_exec($curl_handle);

		curl_exec($curl_handle);
		curl_close($curl_handle);
		return $buffer;
}

Como podeis ver, es muy sencilla . Simplemente nos comprueba que el método que pasemos por parámetro sea uno de los indicados en la API. Veamos un ejemplo de uso

define("BIT_KEY", "AQUI_TU_KEY");
define("BIT_CACHE_TIME", 60 * 60 * 24); // 1 Día
define("BIT_CACHE_DIR", "cache/"); // /cache/

function save_cache($file, $content){
	file_put_contents($file, $content);
}

function get_comments_bitacoras($guid = ''){
		if (empty($guid)) return;
		$file = BIT_CACHE_DIR.md5($guid);
		if (file_exists($file) && filemtime($file) + BIT_CACHE_TIME < time()) {
			$respuesta = file_get_contents($file);
		} else {
			$arr = array(
				'method' => 'comentarios',
				'params' => array(
					'key' => BIT_KEY,
					'format' => 'php',
					'url' => urlencode($guid)
					)
				);
			$respuesta = get_from_bitacoras($arr);
			save_cache($file, $respuesta);
		}

		$return = unserialize($respuesta);
		if ($return->status == 'success') return $return->data;
		else return array();
}

Esta función, que está pensada para integrarse con Wordpress, nos permite obtener los parámetros que nuestra noticia haya tenido en bitacoras.com. Este código podría ir en el fichero functions.php de nuestro theme. Y despues de añadir nuestra KEY y crear sinó existe el directorio cache/ en la raiz de nuestro Wordpress. La función lleva incorporada un pequeño sistema de caché mediante fichero para no lanzar una petición por visita, de esta forma estamos haciendo una caché de 24 horas sobre cada una de las peticiones (osea por noticia).

Para invocar la función, únicamente tendremos que usar el siguiente código, podemos insertarlo en el fichero comments.php de nuestro theme:

$bit_comments = get_comments_bitacoras($post->guid);
foreach($bit_comments as $bit_comment){
	.....
}

De esta forma estamos obteniendo los comentarios y los recorremos uno a uno para ir pintándolos en nuestro theme. Para ello simplemente tenemos que conocer los parámetros devueltos con los que podemos mostrar la información de los comentarios.

• autor: nombre completo del autor
• alias: alias en Bitacoras.com del autor
• avatar: imagen del usuario (32×32px)
• fecha: fecha de publicación
• texto: contenido filtrado, con etiquetas HTML