Ya existe mucha documentación sobre cómo crear taxonomías y cómo usarlas en los custom post types, pero… ¿cómo usar las taxonomías que usa WordPress por defecto? A esta pregunta no existe mucha documentación, y menos en español. Por esto, he decidido volver a escribir en TodoWP y hacer un pequeño manual de cómo usar específicamente tags en un tipo de post personalizado.

Los ingredientes para lograrlo son:

1. La definición o declaración del post type
2. La conexión del tipo de post con la taxonomía
3. El cambio en el query por defecto

Lo primero es tener el custom post type:

register_post_type('alojamiento',
array(
'labels' => array(
'name' => 'Alojamientos',
'singular_name' => 'Alojamiento'
),
'capability_type' => 'post',
'public' => true,
'supports' => array('title','editor'),
'taxonomies' => array('post_tag')
)
);

Este es un ejemplo básico de cómo se registra un post type, lo importante en este ejemplo es la linea donde se registran las posibles taxonomías para este tipo.

'taxonomies' => array('post_tag')

Nota: en esta parte no es necesario poner todas las taxonomías que se usarían. Luego se pueden crear taxonomías personalizadas para usarlas con este tipo de post.

Hasta el momento aun no ponemos usarla, ¿por qué? Porque el editor no nos mostrará la caja que permite agregar las etiquetas. Para esto nuestro segundo ingrediente.


register_taxonomy_for_object_type('post_tag', 'alojamiento');


Esta última linea se coloca también en la acción init, al igual que el register_post_type. Hasta el momento todo funciona perfecto, podemos crear custom post y asignarles etiquetas. Incluso si agregamos un widget con la nube de etiquetas aparecerán las que hayamos creado y nos indicará cuántos posts tienen esa etiqueta.

Pero aún hay un problema: si en esa nube de etiquetas entramos a ver el listado de posts no veremos los de tipo especial, incluso aparecerán los posts normales, pero no los especiales.

Para esto nuestro tercer ingrediente. El problema radica en que el query que internamente tiene WordPress en el momento de solicitar los contenidos que se pasan a la plantilla para ser mostrados no incluye los post types.


function agregar_los_custom_posts($query)
{
if(is_tag() && empty($query->query_vars['suppress_filters']))
{
$post_types = array('post', 'alojamiento');
$query->set('post_type', $post_types);
return $query;
}
}
add_filter( 'pre_get_posts', 'agregar_los_custom_posts' );


Este filtro logra agregar nuestro o nuestros tipos al query en caso necesario.

Espero que esto les ayude cuando estén en sus desarrollos. Comenten sus resultados.

A pesar de que a veces es más rápido escribir directamente en los templates (sidebar.php por ejemplo), el hecho de hacerlo programáticamente será una ventaja para dirigir los eventuales cambios en las categorías desde la administración.

Además del código que aquí os proponemos, una serie de loops personalizados con get_posts también podría dar el mismo resultado, pero todavía tendríamos que escribir las categorías directamente en el template para encabezar cada loop o bien encontrar una forma de repartirlas dinámicamente.

Es por eso que nos puede convenir usar el código siguiente. Lo tendremos que pegar en nuestro functions.php.

Copiar y pegar

No olvidemos que el código debe ser colocado al final de todo de functions.php, independiente de lo demás. Si nuestro tema de WordPress no dispone de un functions.php, lo podremos crear con un editor de texto como Notepad++, muy adecuado para crear archivos y editarlos.

Para terminar abriremos sidebar.php y, orientándonos entre cada “div” y relacionándolas con cada elemento que luego es mostrado en la web, escogeremos el lugar donde queremos escribir la llamada a esa nueva función que acabamos de añadir a nuestro tema.

El código para sidebar.php sería el siguiente:

<div id="sidebar">
		<h3>Navegación</h3>
		<ul>
			<li><a title="Inicio" href="<?php bloginfo('url'); ?>">Home</a></li>
			<?php
			fb_posts_by_category();

			wp_list_pages( 'title_li=&sort_column=menu_order&exclude=2,14,49' );
			?>
		</ul>
</div>

Tenemos a una div con el identificador “sidebar” para trabajar su diseño en style.css. Además, un encabezado para la navegación y la lista, que nos dará:

- Un link al Inicio
- La lista de nuestras categorías con artículos como submenú
- Algunas páginas estáticas. Habrá que modificar las que aquí en el ejemplo se excluyen en “exclude=” si queremos apartar alguna en particular. Un “include=” puede resultar igualmente útil. Si no queremos páginas en absoluto, se puede borrar el wp_list_pages íntegro sin peligro.

¡Comentad como siempre vuestras investigaciones!

Hoy vamos a pegar un código en functions.php que nos permitirá mostrar una lista de artículos relacionados siempre y cuando hayamos incluído cierto shortcode al final del artículo que estemos escribiendo escribiendo.

Copiar y pegar

Guardamos y regresamos a nuestros artículos. A los que les añadamos este shortcode…

     [related_posts]

…mostrarán una lista de relacionados, basada en las etiquetas.

El shortcode lo podemos emplazar (he ahí otra ventaja además del poder escoger artículo a artículo si lo usamos o no) allí donde queramos: principio, mitad o final del post.

Las nuevas funcionalidades que llegan con esta versión y que tienen que ver con los menús nos permitirán seleccionar qué elementos dinámicos incluiremos en la navegación de nuestra web, como tags, categorías o links, desde la misma Administración. Hemos pensado que sería interesante acercarnos a la creación de menús para tenerla fresca a la hora de implementar las nuevas posibilidades que WordPress nos ofrece en su última versión.

Recordemos que la más típica forma de crear un menú es usando elementos de lista, “floteados” a la izquierda o dispuestos como “inline”, y sin list-style-type, aunque en HTML5 (que está aún en proyecto) tendremos una forma más rapida para crearlos, con el tag “nav”.

Vamos a usar la forma convencional con HTML4 y a suponer que estamos creando desde cero un tema de WordPress para nuestra web. En style.css, podríamos usar el siguiente CSS:

/*
tipografía
*/

#mi_menu{
	font-family:Arial,sans-serif;
	font-size:10px;
	}

/*
formatear el marco de lista
*/

#mi_menu ul{
	margin:0;
	padding:0;
	list-style-type:none;
	}

/*
cada elemento de lista, con float:left para que cree lista horizontal
*/
#mi_menu li{
	float:left;
	height:18px;
	line-height:18px;
	text-align:center;
	background: #eee;
	}

/*
los enlaces de la lista, en display:block para que ocupen todo el espacio y sea fácil clicarlos
*/

#mi_menu li a{
	display:block;
	padding: 9px 24px;
	background: #eee;
	color:#111;
	text-decoration:none;
	border-right: 1px solid #ddd;
	}

/*
un efecto de color a escoger, cuando el mouse sobrevuela cada elemento
*/

#mi_menu li a:hover{
	background: #555;
	color:#eee
	}

Veamos ahora cómo debería estar dispuesta la lista en HTML:

	<div id="mi_menu">
	<ul>
		<li><a href="#">Elemento Uno</a>
		</li>
		<li><a href="#">Elemento Dos</a>
		</li>
		<li><a href="#">Elemento Tres</a>
		</li>
		<li><a href="#">Elemento Cuatro</a>
		</li>
		<li><a href="#">Elemento Cinco</a>
		</li>
		<li><a href="#">Elemento Seis</a>
		</li>
		<li><a href="#">Elemento Siete</a>
		</li>
		<li><a href="#">Elemento Ocho</a>
		</li>
	</ul>
	</div>

Ejemplo

Pero en vez de crearla elemento a elemento, lo interesante será que dinámicamente se nos creen los elementos de lista: por ejemplo, a través de algunas de nuestras páginas y de nuestras categorías, que en ese caso enlazarían a una página de archivo.

Nuestra lista

Son dos “template tags” en concreto las que nos lo permitirán: wp_list_pages y wp_list_categories.

Normalmente los listaríamos así:

<ul>
<?php wp_list_pages(); ?>
<?php wp_list_categories(); ?>
</ul>

Pero habrá, por supuesto, que considerar que no vamos simplemente a necesitar todas las páginas creadas, ni todas las categorías, ni un orden puramente alfabético.

Por tanto, ¿cómo “matizar” ambas llamadas a la base de datos? Echemos un vistazo a las posibilidades que ambos recursos nos ofrecen.

Antes de nuestra lista: variables para listar páginas

Antes de escribir el código para nuestra lista con ambas llamadas, tendremos que pegar dos conjuntos de variables que afectarán, el primero, a wp_list_pages, y el segundo a wp_list_categories. Empecemos por el primero.

<?php $paginas = array(
    'depth'        => 0,
	//un valor de 0 lista páginas, y si tienen sub-páginas, las añade como sub-listas también
	//esto nos va bién cuando queremos crear un submenú.
	//un valor de -1 lista TODAS las páginas, en una lista simple
	//un valor de 1 lista páginas madre &uacute:nicamente
	//un valor de 2, 3, etc lista páginas sólo a ése nivel de profundidad

	//Podemos hacer que una página pertenezca a otra como subpágina en nuestra Administración
	//(cuando vamos a clicar para que se publique)

    'show_date'    => ,
	//si delante de la coma escribimos por ejemplo: created
	//se nos listará la fecha de publicación de la página

    'date_format'  => get_option('date_format'),
	//si queremos fecha, aquí usaremos el formato que se puede especificar en la Admin

    'child_of'     => 0,
	//ahora está a 0, es decir, inactivo
	//si escribimos ahí la ID numérica de una página nos devolverá las sub-páginas que ésta tuviera
	//en vez de la pagina directamente

    'exclude'      => ,
	//lugar para escribir la ID de las paginas que queremos excluír -separadas por comas-

    'include'      => ,
	//SOLAMENTE tráeme estas IDs (una manera potente de pedir determinadas páginas de entre todas las que tengamos)

    'title_li'     => ,
	//lugar para especificar si queremos un título genérico para las páginas
					//en los menús horizontales, no es habitual, en los verticales sí

    'echo'         => 1,
	//muestro o guardo como PHP?
	//1 significa muestro (imprimo), 0 significa guardo (para trabajar con PHP más tarde)

    'authors'      => ,
	//ID numéricas de páginas creadas por tal o cual autor sólamente

    'sort_column'  => 'menu_order, post_title',
	//en la Administració, a cada pagina se le puede dar un valor para ordenarla
	//hay que buscar el campo adecuado para ello cuando estamos editando la página
	//será el orden en que salgan en nuestra lista
	//aquí, si la opción está desetimada, tenemos un "fallback" para ordenarlas por título
	//otras opciones son: post_title, post_date, post_modified, ID, post_author, post_name

    'link_before'  => ,
	//algo para poner delante del nombre de la página
	//por ejemplo, el signo +
    'link_after'   => ,
	//algo para poner después del nombre de la página
	//por ejemplo, de nuevo el signo +

    'meta_key'  => ,
	//sólo las páginas que tengan activado cierto campo personalizado

    'meta_value'   => ,
	//sólo las páginas que tengan activado cierto VALOR de campo personalizado

    'exclude_tree' =>
	//añadir aquí la ID de una pagina y sus sub-páginas para excluír al grupo entero

	); ?>

Obviamente podemos sólo especificar algunos de los elementos y ahorrarnos la larga lista de argumentos para simplemente poner…

<ul>
  <?php wp_list_pages('sort_column=menu_order&title_li='); ?>
</ul>

…que nos traería páginas por orden de menú, y sin título genérico de lista.

Segundo conjunto de variables: listando categorías

Con las categorías tenemos que hacer lo mismo y pegar y editar lo siguiente:

<?php $categorias = array(

    'show_option_all'    => ,
		//un valor otro que nulo, añade un link que diga "hacia todoas las categorías"

    'orderby'            => 'name',
		//ID
		//name
		//slug
		//count
		//term_group
		//(a escoger, lo típico es name)

    'order'              => 'ASC',
		//ASC -desplegar de A a Z- o DESC -desplegar de Z a A-

    'show_last_update'   => 0,
		//un valor de 1 nos da el tiempo en que el último post de ésa categoría fue escrito

    'style'              => 'list',
		//la alternativa es 'none', que separa los items con <br> tags

    'show_count'         => 0,
		//mostrar si o no (1 o 0) cuántos posts hay en cada categoría

    'hide_empty'         => 1,
		//1 esconde las categorías vacías, 0 las muestra

    'use_desc_for_title' => 1,
		//añadir la eventual descripción al atributo alt de cada link

    'child_of'           => 0,
		//una ID de categoría listará sólo sub-categorías en vez de la categoría principal, 0 es inactivo

    'feed'               => ,
		//un valor de RSS nos da links al feed de cada categoría, además de ésta

    'feed_type'          => ,
		//

    'feed_image'         => ,
		//

    'exclude'            => ,
		//ID a excluír, muy útil

    'exclude_tree'       => ,
		//olvidarse de sub-categorías o no, por defecto es mostrarlas, como aquí

	'include'            => ,
		//sólo incluír ciertas IDs

    'current_category'   => 0,
		//dar la clase current-cat (para dar css específicos) a la ID de la categoría que se escriba

    'hierarchical'       => true,
		//false nos da una lista simple, sin árbol

    'title_li'           => ,
		//lo mejor es dejarlo vacío, si queremos dar un título genérico a la lista, añadir esto __( 'Categories' )

    'number'             => NULL,
		//limitar a base de PHP las categorías retornadas, aquí lo tenemos desactivado y nos da todas las que hayan sido filtradas

    'echo'               => 1,
		//un valor de cero nos guarda los resultados para eventuales operaciones en PHP posteriores

    'depth'              => 0
		//0 : todas las cats y subcats
		//-1 : idem, pero sin distinguir (lista 'plana', sin sub-lista)
		//1 : sólo categorías pariente
		//n : 2, 3 etc, número de niveles a tener en cuenta

	);
	?>

El menú, finalmente

Una vez hayamos especificado los valores que nos interesen para páginas y categorías, podemos escribir debajo los dos template tags que nos traerán esos resultados entre la apertura y cierre de la lista:

	<ul>
		<?php wp_list_pages( $paginas ); ?>
		<?php wp_list_categories( $categorias ); ?>
	</ul>

Esperamos que esta mirada en detalle a estos dos template tags os sea útil para construir adecuadamente vuestros menús de navegación.

add_shortcode( 'member', 'member_check_shortcode' );

function member_check_shortcode( $atts, $content = null ) {
	 if ( is_user_logged_in() && !is_null( $content ) && !is_feed() )
		return $content;
	return '';
}

Salvaremos e iremos a editar los artículos con contenido “confidencial”. Todo lo que pongamos entre estos dos shortcodes…

[member]

texto, texto, texto, etc.

[/member]

…quedará escondido para un usuario que no haya ingresado en nuestro site (anónimo).

Créditos: Justin Tadlock.

1- Creando una página especial para ello

Vamos a crear un archivo llamado los-autores.php. Su contenido sería, por ejemplo, el siguiente:

<?php
/*
Template Name: Autores
*/
?>

<?php get_header(); ?>

<div class="autores">
	<ul>

	</ul>
</div>

<?php get_sidebar(); ?>

<?php get_footer(); ?>

Veréis que hemos creado lo que se llama un template personalizado de página. Su función es darle una forma distinta de la página que WP nos crearía por defecto con page.php, en este caso para listar autores programáticamente.

Fijaos que hemos dejado vacía la lista, en la que más tarde deberemos pegar algo de PHP.

Tendremos asimismo que dar algunos estilos de CSS al espacio creado:

.autores{ /*nuestro código aquí*/ }

Seguidamente, vamos a asignar este nuevo template a una página publicada y vacía en nuestra Administración:

Páginas >
  Crear Página >
    Creamos el título >
      Asignamos el template especial que acabamos de crear >
        Publicamos.

2- Abriendo functions.php y pegando el código mágico

Abriremos ahora functions.php en nuestro tema (o lo crearemos y emplazaremos junto al resto de los archivos del mismo) y pegaremos en su interior el siguiente código (al final de todo):

copiar y pegar

No olvidemos que el código debe ser emplazado entre tags de apertura y cierre de PHP, ya sean los que tengamos de entrada en el functions.php de nuestro tema, ya sea añadiéndolos si debemos crearlo:

<?php
// código propuesto aquí, acaso con el resto de funciones con las que el tema nos viniera
?>

Este código nos está preparando para que nos sea posible más tarde hacernos con el avatar de cada uno de nuestros autores registrados, su nombre, un link a su website y a su cuenta de Twitter.

Pegaremos ése código, salvaremos y cerraremos.

3- ¡Nota! Twitter como campo extra en el perfil

Ya que por defecto ese campo no está ahí y siempre puede ser interesante añadirlo (o cualquier otro campo extra), podemos seguir las instrucciones aquí.

4- Regresando a los-autores.php

Llega el final. Iremos a los-autores.php, lo abriremos y pegaremos, en el interior de la lista que dejamos a punto, el siguiente código, que nos desarrollará la función que hemos creado en functions.php:

<?php contributors(); ?>

Salvaremos y cerraremos. Nos podemos dirigir entonces a la página que publicamos, abrirla como si la fuésemos a editar y clicar en Ver Página para comprobar el resultado.

¡No olvidéis copiar su URL y añadirla al menú principal de vuestro site!

Esperamos que el truco os resulte de utilidad.

Copiar y pegar en nuestro template (allí dónde más nos convenga)

Aquí estamos invocando los cinco últimos comentarios, lo cual podremos cambiar por el número deseado modificando la segunda línea del código.

Abriremos functions.php y pegaremos lo siguiente: (copiar y pegar)

A partir de aquí, en nuestro template (por ejemplo, index.php), escogeremos el lugar que creamos más conveniente para nuestras etiquetas y escribiremos la llamada a la función:

   $args = array('categories' => '12,13,14');
   $tags = get_category_tags($args);

Por supuesto, deberemos poner los tags de apertura y cierre de PHP.

De este modo, vamos a reunir etiquetas que hayan sido usadas en artículos bajo las categorías con ID 12, 13 y 14. La identidad numérica de cada categoría la sabremos sobrevolándola con el cursor del ratón en nuestro panel de Administración.

Créditos: foros de WordPress.org

Para ello, abriremos functions.php y pegaremos el siguiente código:

function image_shortcode($atts, $content = null) {
extract( shortcode_atts( array(
'name' => '',
'align' => 'right',
'ext' => 'png',
'path' => '/wp-content/uploads/',
'url' => ''
), $atts ) );
$file=ABSPATH."$path$name.$ext";
if (file_exists($file)) {
$size=getimagesize($file);
if ($size!==false) $size=$size[3];
$output = "<img src='".get_option('siteurl')."$path$name.$ext' alt='$name' $size align='$align' class='align$align' />";
if ($url) $output = "<a href='$url' title='$name'>".$output.'</a>';
return $output;
}
else {
trigger_error("'$path$name.$ext' image not found", E_USER_WARNING);
return '';
}
}
add_shortcode('image','image_shortcode');

Este código debe, por supuesto, abrirse y cerrarse con los tags de apertura y cierre de PHP e incluirse al final de functions.php o bien entre las diversas funciones que allí ya tengamos especificadas.

Luego, en nuestros artículos, no tendremos más que escribir el siguiente shortcode:

[image name=Montevideo]

“Montevideo” es el nombre del archivo Montevideo.png.

Notad que aquí hemos permitido la inclusión de archivos en formato .png (pueden ser en .jpg pero lo tenéis que cambiar).

Esperamos que este truco sea de vuestra utilidad.

Hoy veremos una manera rápida para mostrar nuestros comentarios recientes sin plugins ni widgets. Este código podremos pegarlo primero en functions.php y luego, con una nueva función lista para nosotros, directamente en nuestros templates (por ejemplo, al final de todo de sidebar.php o incluso en alguno de los apartados que conformen nuestro footer.php).

El código es el siguiente (copiar y pegar en functions.php)

Sólo nos queda invocar los últimos comentarios con el nuevo tag que se nos habrá creado : <?php recent_comments(); ?>

Si queremos cinco comentarios en vez de 10 (que es la cantidad por defecto), podemos especificarlo así :

<?php recent_comments(’5′); ?>

Esperamos que os resulte de interés.

No tendremos más que dirigirnos a la barra lateral (sidebar.php; o pie de página, footer.php) de nuestro tema de WordPress y editarla (recomendamos como siempre a Notepad++ para escribir código) con el siguiente snippet:

Copiar y pegar en nuestro template.

Con este código estamos realizando un sondeo general a nuestra base de datos tomando los 7 posts con más comentarios, preparando sus títulos, URLs y número exacto de comentarios que tengan, y disponiéndolo todo en una lista que deberemos por supuesto “decorar” con CSS a nuestro gusto.

Con este método, quedamos como reyes porque no necesitamos largos cálculos para entender cuál de nuestros posts es más visualizado y reservamos al lector un poco de discusión con todos los comentarios que allí se mostrarán al acabar la lectura principal.

Tendremos que pegar el siguiente código en el espacio que consideremos adecuado en nuestro template (por ejemplo, tratándose del index.php, justo después de wp_header): copiar y pegar.

En la línea 15, deberemos cambiar los números allí presentes (10 y 20) por las ID numéricas de las categorías de las que deseemos mostrar los comentarios. Dichas ID las conoceremos sobrevolando con el puntero del ratón nuestras propias categorías en la Administración de WordPress.

Los créditos van, una vez más, al foro de WordPress.org, donde podréis encontrar otra versión del truco, que concierne en este caso a sub-categorías.

Esperamos que os atreváis con el código y nos planteéis cualquier duda en los comentarios.

Pensemos por ejemplo en un site amateur de periodismo, o un site de programación, o en una red donde se aceptan artículos universitarios y en todas las correcciones que allí pueden suceder tras una primera publicación. Podemos incluso pensar en una comunidad online para viajeros, donde todos quieren añadir detalles extra a sus relatos de viaje, y ganar algo más de presencia general en el blog multi-usuario.

Pues bien, elijamos estratégicamente el lugar donde queremos que aparezca la lista de últimos artículos modificados. Normalmente será la barra lateral, que en nuestro tema de WordPress tiene el nombre de sidebar.php. Añadiremos lo siguiente: copiar y pegar.

Fijaos en que hemos puesto 5 elementos para ser listados, pero podemos, por supuesto, cambiar dicha cifra. Será entonces el momento de formatear con CSS ese espacio, y hacerlo acorde con el resto del diseño del blog.

Para ello, abriremos functions.php, y pondremos el siguiente código al final de todo:

<?php
function direct_email($text="Enviar un mail a un amigo"){
global $post;
$title = htmlspecialchars($post->post_title);
$subject = 'En '.htmlspecialchars(get_bloginfo('name')).' : '.$title;
$body = 'Te recomiendo : '.$title.'. en esta página : '.get_permalink($post->ID);
$link = '<a rel="nofollow" href="mailto:?subject='.rawurlencode($subject).'&amp;body='.rawurlencode($body).'" title="'.$text.' : '.$title.'">'.$text.'</a>';
return $link;
}
?>

Sólo nos faltará poner allí donde creamos conveniente en nuestro template (dentro del loop) el siguiente nuevo template tag que hemos creado:

Compartir <?php echo direct_email('par mail') ?> con un amigo

Esperamos que lo pongáis en práctica y vuestros comentarios al respecto.

• Que estén en una lista (a estilizar con CSS).
• Que cada elemento de la lista empiece con el conjunto de etiquetas que se han añadido al artículo, enlazadas a su archivo de etiqueta.
• Que prosiga con el título del artículo, enlazado a su página individual (permalink).
• Que, a todo ello, se le añada el último comentario realizado en ese artículo, linkado, como párrafo, a la página de artículo final con todos los comentarios desplegados.

Recordemos que nos hará falta un tema que soporte comentarios y tenga el template adecuado (comments.php):

<ul>

<?php $my_query = new WP_Query('showposts=10'); ?>
<?php while ($my_query->have_posts()) : $my_query->the_post(); ?>

<li>

<?php the_tags(''); ?> : <a href="<?php the_permalink(); ?>"><?php the_title(); ?></a>

<br>

<?php $comment_array = array_reverse(get_approved_comments($post->ID)); $count = 1; if ($comment_array) { foreach($comment_array as $comment) { if ($count++ <= 1) { ?>

&mdash; Latest comment by <?php comment_author(); ?> on <?php comment_date(); ?>, <?php comment_time(); ?> :

<br>

<a href="<?php comment_link(); ?>">
<?php comment_excerpt(); ?>
</a>

<?php } } } ?>

</li>

<?php endwhile; ?>

</ul>

Aunque parezca complicado, uno acaba por necesitar loops de este tipo. ¿Qué os parece? Postead vuestras dudas en los comentarios.

<?php
//ARTÍCULOS
$num_posts = wp_count_posts( 'post' );
$num_posts = $num_posts->publish; //publish, draft
$num_posts = sprintf( __ngettext( '%s Post', '%s Posts', $num_posts ), number_format_i18n( $num_posts ) );

//PÁGINAS
$num_pages = wp_count_posts( 'page' );
$num_pages = $num_pages->publish; //publish
$num_pages = sprintf( __ngettext( '%s Page', '%s Pages', $num_pages ), number_format_i18n( $num_pages ) );

//CATEGORÍAS
$num_cats = wp_count_terms('category');
$num_tags = wp_count_terms('post_tag');

//COMENTARIOS
$num_comm = get_comment_count();
$num_comm = $num_comm['approved']; //approved, awaiting_moderation, spam, total_comments
$num_comm = sprintf( __ngettext( '%s Categorie', '%s Categories', $num_comm ), number_format_i18n( $num_comm ) );
$num_comm2 = wp_count_comments( );
$num_comm2 = $num_comm2->approved; //approved, moderated, spam, total_comments

echo '<ul>';
echo '<li>Artículos: ' . $num_posts . '</li>';
echo '<li>Páginas: ' . $num_pages . '</li>';
echo '<li>Categorías: ' . $num_cats . '</li>';
echo '<li>Etiquetas: ' . $num_tags . '</li>';
echo '<li>Comentarios a moderar: ' . $num_comm . '</li>';
echo '<li>Comentarios publicados: ' . $num_comm2 . '</li>';
echo '</ul>';
?>

En este caso la lista desplegaría el total de artículos, páginas, categorías, comentarios a moderar y comentarios publicados.

Comentadas (con barras al principio, entre líneas) tenéis varias opciones a explotar para cada tipo de recuento: que el artículo esté publicado, o que sea un borrador, etc.

//publish, draft

Emplazad una palabra o la otra en función de lo que queréis mostrar.

Por supuesto, y por otro lado, vosotros podéis seleccionar sólo una de las operaciones y recortar los elementos que la lista convocaría para ser mostrados.

Esperamos que este pequeño truco sea de vuestra utilidad.

Abriremos functions.php (o lo crearemos con un editor de texto si no lo tuviéramos, para acto seguido alojarlo junto al resto de nuestros archivos del template) y pegaremos en él el siguiente código :

function tweetmeme(){
return '<div class="tweetmeme"><script type="text/javascript" src="http://tweetmeme.com/i/scripts/button.js"></script></div>';
}
add_shortcode('tweet', 'tweetmeme');

Podremos manejar el posicionamiento del botón con la clase class=”tweetmeme” en nuestra hoja de estilos CSS :

.tweetmeme{float:left;margin:20px}

Luego no tendremos más que añadir el siguiente shortcode a nuestros artículos, que será reemplazado por un botón (ya estilizado y bastante bonito) de Re-Tweet, cortesía de Tweetmeme.com:

[tweet]

Esperamos que os saquéis una cuenta en Twitter si no la tenéis, y que mezcléis artículos y tweets.

<?php
$posts = get_posts('category=vinos-blancos&numberposts=1');
foreach($posts as $post):
setup_postdata($post);
?>
<?php the_title(); ?>
<?php the_content(); ?>
<?php endforeach; ?>

En este ejemplo, estamos convocando a un artículo (numberposts=1), el último artículo que hayamos escrito de hecho, dentro de la categoría "Vinos Blancos".

Sucesivamente, en cada columna de nuestro index.php donde quisiéramos que ello ocurriera podríamos cambiar la categoría por una nueva, y disponer así de cuatro o cinco columnas por categoría (siguiendo el ejemplo: vinos blancos, vinos tintos, vinos rosados, champagne, licores…).

Si quisiéramos, sin embargo, disponer además de las etiquetas; por ejemplo, "afrutado", "seco", "fuerte", deberemos realizar un añadido especial en nuestro loop:

<?php
$posts = get_posts('category=4&numberposts=1');
foreach($posts as $post):
setup_postdata($post);
?>

<?php the_title(); ?>
<?php the_content(); ?>

<?php $posttags = get_the_tags($post->ID); if ($posttags) {
foreach($posttags as $tag) {
echo '<a href="';
echo get_tag_link($tag);
echo '">';
echo $tag->name . ' ';
echo '</a>';
}
}
?>
<?php endforeach; ?>

Como get_posts es un tipo de loop más sencillo que el normal de WordPress, necesitaremos especificar la ID numérica de cada post ($post->ID) para que WordPress nos dé, además de título y contenido, las etiquetas correspondientes enlazadas a sus archivos de etiqueta como en este caso.

Esperamos que este truco os sea útil y vuestros comentarios.

Para ello, abriremos comments.php en nuestro tema de WordPress y localizaremos el siguiente tag:

<?php foreach ($comments as $comment) : ?>

Justo después de esta línea, iniciaremos el conteo de elementos (comentarios en este caso):

<?php $i = 0; ?>

E inmediatamente después añadiremos el incremento de elementos:

<?php $i++; ?>

A partir de aquí, tan sólo tenemos que mostrar el resultado de la operación allí donde nos convenga en el template con este tag de PHP:

<?php echo $i; ?>

Ya tendremos nuestros comentarios numerados. ¡No dudéis en comentar!

Usando zlib, una librería nativa de PHP, podremos comprimir los archivos que enviemos de forma notable y con ello dar más potencia y rapidez a nuestro site.

Para ello, vamos primero a hacer un test y comprobar que nuestro servidor tiene instalado el módulo de zlib para nosotros: creamos un archivo llamado index.php y pegamos en él lo siguiente:

<? php phpinfo (); ?>

Recordemos quitar el espacio en la apertura del php, añadido aquí a efectos de muestra. Luego lo subimos a una nueva carpeta en nuestro host llamada /test-zlib, y apuntamos nuestro navegador hasta dicho archivo, para ver si nuestra configuración tiene disponible zlib o no.

Si es el caso, iremos al header.php de nuestro tema en uso y pegaremos, antes del DOCTYPE (inicio del HTML), lo siguiente :

<? php
ini_set ('zlib.output_compression', 'On') ;
ini_set ('zlib.output_compression_level', '1') ;
?>

Guardamos y regresamos a nuestro site. Ahora deberíamos poder disfrutar de nuestro HTML ‘comprimido’ de más rápida carga.

Si queréis verificar con detalle cuánto ancho de banda nos ahorra este truco, podréis hacer la comparación por ejemplo en: http://www.port80software.com

Esperamos vuestros comentarios comentarios.

Hoy veremos un sencillo código que nos permitirá recuperar una imagen por categoría a la que el artículo haya sido asignado, y ello ya sea en el índice de nuestro site o en la página single.php de la entrada.

Antes de nada debemos contar las categorías de nuestro site y hacernos con una imagen para cada una de ellas, preferiblemente en formato .png, aunque podremos usar cualquier otro formato (en el código que os propongo se usarán PNGs).

Una vez tengamos esas imágenes, hay que nombrarlas coherentemente a las categorías que representarán y emplazarlas en un directorio dentro de las imágenes de nuestro tema en uso. Por ejemplo, para la ocasión, “cat-icons” dentro de “images“.

Cuando estén allí, abriremos el archivo con el loop en el que queramos que cada artículo muestre las categorías a las que pertenece y pegaremos el siguiente código, sustituyendo a the_category:

<h3>Artículo categorizado en :</h3>
<ul>
	<?php foreach((get_the_category()) as $cat)
	{
	$catname =$cat->category_nicename;
	echo '<li><a href="' . bloginfo('url');
	echo '/category/';
	echo $catname;
	echo '">';
	echo '<img src="' . bloginfo('template_directory');
	echo '/images/cat-icons/';
	echo $catname;
	echo ".png\" alt=\"$catname\" border=\"0\" />";
	echo $catname;
	echo "</a></li>\n";
	}
	?>
</ul>

Guardaremos y cerraremos, y nos aseguraremos entonces de que nuestra estructura de “permalinks” o enlaces permanentes es cualquier otra distinta a la que viene por defecto. Podemos escoger, por ejemplo, la segunda opción que se nos presenta.

Con esto ya tendremos iconos específicos para nuestras categorías. Esperamos vuestros comentarios.

Sin embargo, cuando el site que gestionamos pertenece a un amigo / familiar / cliente, a veces podemos considerar que será mejor que no interactúe con el sistema de actualizaciones, del que nos encargaríamos por nuestra cuenta al saber que una nueva versión está disponible.

Para desactivar la alerta de upgrade, abriremos functions.php y pegaremos el siguiente código:

if (!current_user_can('edit_users')) {
  add_action( 'init', create_function( '$a', "remove_action( 'init', 'wp_version_check' );" ), 2 );
  add_filter( 'pre_option_update_core', create_function( '$a', "return null;" ) );
}

El código deberá quedar entre los tags de apertura y cierre de php, como siempre.

Recordemos, sin embargo, que actualizar nuestras versiones de WP es siempre fundamental, porque no sólo nos dotamos de las últimas mejoras de nuestra plataforma favorita sino que nos protegemos de los últimos ataques o fallos registrados.

Este pequeño truco sólo debería ser usado con clientes que se desorienten fácilmente, y siempre y cuando estemos allí para realizar el upgrade nosotros mismos.

Para ello, tendremos que abrir functions.php y pegar allí el siguiente código:

function print_post_title() {
	global $post;
	$thePostID = $post->ID;
	$post_id = get_post($thePostID);
	$title = $post_id->post_title;
	$perm = get_permalink($post_id);
	$post_keys = array(); $post_val = array();
	$post_keys = get_post_custom_keys($thePostID);

	if (!empty($post_keys)) {
		foreach ($post_keys as $pkey) {
			if ($pkey=='url1' || $pkey=='title_url' || $pkey=='url_title') {
			$post_val = get_post_custom_values($pkey);
			}
		}
		if (empty($post_val)) {
			$link = $perm;
		} else {
			$link = $post_val[0];
		}

	} else {
		$link = $perm;
	}
	echo '<h2><a href="'.$link.'" rel="bookmark" title="'.$title.'">'.$title.'</a></h2>';
}

Salvaremos y cerraremos. Iremos ahora al index.php de nuestro tema, lo abriremos y sustituiremos allí donde se encuentre el título…

<h2><a href="<?php the_permalink() ?>" rel="bookmark" title="Permanent Link to <?php the_title(); ?>"><?php the_title(); ?></a></h2>

…por nuestro nuevo tag, recién creado en functions.php :

<?php print_post_title() ?>

Salvamos y cerramos.

A partir de aquí, cada vez que queramos que el post (que seguramente no consistirá más que en un título) enlace directamente a un sitio externo, iremos a los campos personalizados y entraremos en “nombre” lo siguiente:

ulr1

Y en “valor“, la dirección final a la que queremos que el título del artículo enlace.

Siempre que no escribamos este campo personalizado, el título actuará como siempre, normalmente llevándonos a la versión entera del artículo.

Esperamos que este truco sea de vuestro interés.

Primero, iremos a functions.php o lo crearemos como simple archivo de texto y pegaremos en su interior el siguiente código:

<?php
function dropdown_tag_cloud( $args = '' ) {
$defaults = array(
'smallest' => 8, 'largest' => 22, 'unit' => 'pt', 'number' => 45,
'format' => 'flat', 'orderby' => 'name', 'order' => 'ASC',
'exclude' => '', 'include' => ''
);
$args = wp_parse_args( $args, $defaults );

$tags = get_tags( array_merge($args, array('orderby' => 'count', 'order' => 'DESC')) ); // Always query top tags

if ( empty($tags) )
return;

$return = dropdown_generate_tag_cloud( $tags, $args ); // Here's where those top tags get sorted according to $args
if ( is_wp_error( $return ) )
return false;
else
echo apply_filters( 'dropdown_tag_cloud', $return, $args );
}

function dropdown_generate_tag_cloud( $tags, $args = '' ) {
global $wp_rewrite;
$defaults = array(
'smallest' => 8, 'largest' => 22, 'unit' => 'pt', 'number' => 45,
'format' => 'flat', 'orderby' => 'name', 'order' => 'ASC'
);
$args = wp_parse_args( $args, $defaults );
extract($args);

if ( !$tags )
return;
$counts = $tag_links = array();
foreach ( (array) $tags as $tag ) {
$counts[$tag->name] = $tag->count;
$tag_links[$tag->name] = get_tag_link( $tag->term_id );
if ( is_wp_error( $tag_links[$tag->name] ) )
return $tag_links[$tag->name];
$tag_ids[$tag->name] = $tag->term_id;
}

$min_count = min($counts);
$spread = max($counts) - $min_count;
if ( $spread <= 0 )
$spread = 1;
$font_spread = $largest - $smallest;
if ( $font_spread <= 0 )
$font_spread = 1;
$font_step = $font_spread / $spread;

// SQL cannot save you; this is a second (potentially different) sort on a subset of data.
if ( 'name' == $orderby )
uksort($counts, 'strnatcasecmp');
else
asort($counts);

if ( 'DESC' == $order )
$counts = array_reverse( $counts, true );

$a = array();

$rel = ( is_object($wp_rewrite) && $wp_rewrite->using_permalinks() ) ? ' rel="tag"' : '';

foreach ( $counts as $tag => $count ) {
$tag_id = $tag_ids[$tag];
$tag_link = clean_url($tag_links[$tag]);
$tag = str_replace(' ', '&nbsp;', wp_specialchars( $tag ));
$a[] = "\t<option value='$tag_link'>$tag ($count)</option>";
}

switch ( $format ) :
case 'array' :
$return =& $a;
break;
case 'list' :
$return = "<ul class='wp-tag-cloud'>\n\t<li>";
$return .= join("</li>\n\t<li>", $a);
$return .= "</li>\n</ul>\n";
break;
default :
$return = join("\n", $a);
break;
endswitch;

return apply_filters( 'dropdown_generate_tag_cloud', $return, $tags, $args );
}
?>

Acto seguido, iremos al template en el que nos interese insertar la lista desplegable y, orientándonos entre el HTML, pegaremos el siguiente código:

<select name="tag-dropdown" onchange="document.location.href=this.options[this.selectedIndex].value;">
<option value="#">Tags</option>
<?php dropdown_tag_cloud('number=0&order=asc'); ?>
</select>

Nuestros tags seran ahora mostradis en un desplegable.

Para ello, colaremos este código en functions.php (al final de todo):

<?php
add_theme_support( 'post-thumbnails' );
?>

Ahora podremos, desde la Administración, subir y asignar una imagen cuya función exclusiva será la de ‘representar’ al post, e “imprimirse” por tanto en nuestros templates, al lado del texto del artículo (pero independientemente de éste).

Iremos ahora a escoger en qué lugar concreto queremos que aparezca con respecto al contenido normal de nuestro artículo. Abriremos index.php, archive.php o incluso single.php, y allí donde creamos conveniente (normalmente al lado del extracto), pondremos lo siguiente :

<?php the_post_thumbnail( 'medium' ); ?>

Podremos utilizar la siguiente “jerga” para decidir qué tamaño queremos:

- thumbnail
- medium
- large

Habrá que orientarse entre los tags de HTML del template para poner la imagen allí donde creamos correcto.

Para saber más detalles acerca de esta novedad, podemos dirigirnos a la web de Justin Tadlock.

El código es el siguiente, y lo tenemos que insertar dentro del Loop, en single.php, index.php y archive.php principalmente:

Clasificado en : <?php
foreach((get_the_category()) as $category) {
if ($category->cat_ID != '5') {
echo '<a href="' . get_category_link( $category->term_id ) . '" title="' . sprintf( __( "View all posts in %s" ), $category->name ) . '" ' . '>' . $category->name.'</a> ';
}
}
?>

En vez de usar el típico the_category, lo sustituiremos con este código.

Si os fijáis en la tercera línea, es allí donde debemos especificar el número de la categoría a esconder.

Ese número podremos saberlo pasando el cursor por encima de las distintas categorías en su espacio específico en nuestra Administración y fijándonos en la URL que tienen asignada: el número al final de ésta es el que nos interesa.

Esperamos que este truco sea de vuestra utilidad.

En vez de crear la lista manualmente (y tener que editarla más tarde en los templates ante cualquier cambio), podremos desde un principio usar wp_page_menu como método para imprimir nuestra lista de páginas:

<?php wp_page_menu('exclude=24,27,28&menu_class=menu menu-de-contacto'); ?>
<?php wp_page_menu('include=24,27,28&menu_class=menu menu-principal'); ?>

Aquí se nos crearían por lo pronto dos menús con sus links preparados: el primero incluye todas nuestras páginas salvo tres, y el segundo sólo esas tres páginas. Podríamos usarlos de distinta manera, por ejemplo, uno que ocupara el 100% de la anchura de la página, y otro, más arriba, al lado de nuestro logo.

HTML de ejemplo:

<div id="encabezado">

	<div id="logo">
		<img src="<?php bloginfo('template_directory'); ?>/imagenes/logo.png">
	</div>

	<div id="menu-de-contacto">
		<?php wp_page_menu('include=24,27,28&menu_class=menu menu-de-contacto'); ?>
	</div>

	<div id="menu-principal">
		<?php wp_page_menu('exclude=24,27,28&menu_class=menu menu-principal'); ?>
	</div>

</div>

Recordemos que la ID numérica de cada página la sabremos poniendo el cursor sobre el nombre de la página en cuestión en el panel de administración, y viendo cuál es el número que llevan en su URL.

Ambos template tags nos devolverán una lista (ul, unordered list), que deberemos luego trabajar con CSS para posicionarla y crear los gráficos necesarios.

Un ejemplo de CSS para nuestro caso:

#encabezado{
	width:960px;
	margin: 0 auto;
	background:#fff
	}

#logo,#menu-de-contacto{
	width:50%;
	height:120px;
	margin-top:18px;
	float:left
	}

#menu-de-contacto li{
	list-style-type:none;
	display:inline;
	margin-right:18px;
	}

#menu-de-contacto li a{
	padding:5px;
	background:#EEE;
	color:#999
	}

#menu-principal{
	width:100%;
	height:3em;
	line-height:3em;
	margin-top:18px;
	color:#555
	}

#menu-principal li{
	list-style-type:none;
	display:inline-block;
	background:#111;
	padding: 0 9px;
	border-right: 1px solid #555
	}

Hoy veremos la forma de mostrar todo ello, y proporcionaremos algunos estilos en CSS que nos ayuden a crear los nuestros propios.

Marcelo escribió hace un tiempo sobre el tag fundamental que nos traerá las informaciones de la base de datos, es decir, de la pantalla de información sobre el autor que podemos editar en la Administración de WordPress una vez estamos registrados en el site, y donde podemos rellenar los campos de “Biografía”, “URL”, “Gravatar”, e-mail, etc.

Hoy trataremos pues la parte del CSS para tener el conjunto en una estructura que será fácilmente modificable. Empecemos:

<div id="info-autor">
	<div id="imagen-autor">
		<a href="**Web del Autor**">**Gravatar del Autor**</a>
	</div>
	<div id="bio-del-autor">
		<h4>Escrito por <a href="**Web del Autor**">**Nombre del Autor**</a></h4>
		<p>**Descripción del Autor**</p>
	</div>
</div><!--Infos Autor-->

En el código vemos los distintos elementos que deberemos transformar en PHP para que sean efectivos.

Añadamos pues el PHP necesario:

<div id="info-autor">
	<div id="imagen-autor">
		<a href="<?php the_author_meta('user_url'); ?>"><?php echo get_avatar( get_the_author_meta('user_email'), '80', '' ); ?></a>
	</div>
	<div id="bio-autor">
		<h4>Escrito por <?php the_author_link(); ?></h4>
		<p><?php the_author_meta('description'); ?></p>
	</div>
</div><!--Info Autor-->

Y preparemos ahora el CSS que dará formato al resultado final :

div#author-info {
	background: #eaeaec; padding: 10px; margin: 0 0 15px 0;
	-moz-border-radius: 8px;
	-webkit-border-radius: 8px;
	border-radius: 8px;
	overflow: auto;
}
div#author-info div#author-image {
	float: left; margin: 0 10px 5px 0; border: 5px solid #DCDCE1;
}

Tan sencillo como esto.

Repasemos todos los tags de PHP que hemos utilizado:

<?php the_author_meta('user_url'); ?>

Sirve para extraer varias porciones de información acerca del usuario (autor).

<?php echo get_avatar( get_the_author_meta('user_email'), '80', '' ); ?>

Sirve para extraer la imagen del autor, en función del Gravatar asociado a su cuenta de correo electrónico (que debe coincidir con la registrada en WordPress).

<?php the_author_link(); ?>

Imprime el nombre del autor, automáticamente enlazado a su web (la que haya indicado en su perfil).

<?php the_author_meta('description'); ?>

Muestra la principal información biográfica.

Esperemos que uséis todos estos trucos y creéis unos estupendos sites multi-autor con WordPress.

Demo

Para conseguirlo, tendremos que abrir el single.php o el index.php de nuestro tema y, dentro del loop, añadir lo siguiente:

<a class="retweet" href="<?php the_permalink(); ?>">
     <?php the_title(); ?>
</a>

Es decir, un segundo the_title (debajo del primero por ejemplo, o al final del todo del artículo, tras the_content) que esté dentro de un link con class=”retweet”.

Salvaremos y cerraremos, y nos dirigiremos a header.php.

Allí tendremos que insertar el script en cuestión, que buscará cada link con clase “retweet” y le asignará el botón de retweet, el contador y la función de conexión a Twitter.

Para incluir un script en header.php (dentro de los tags “head”) haremos lo siguiente :

<script src="<?php bloginfo('template_directory'); ?>/js/retweet/retweet.js" type="text/javascript"></script>

Suponiendo que dentro de nuestro tema tengamos un directorio llamado js y, dentro de él, el script de John Resig, al que nombraremos igualmente retweet.js.

Bajar el script (copiar/pegar, salvar y alojar en un directorio especial de nuestro tema).

Esperamos que os sea de utilidad, y aprovechamos desde aquí para saludar a John por jQuery y este magnífico script.

Hoy vamos a proponeros un código que lo hará posible, y que deberemos pegar en functions.php.

Se nos permitirá entonces disponer de un nuevo ‘template tag’, que podremos usar dentro de nuestros Loops, con el que imprimir la imagen en cuestión.

El código es el siguiente :

function catch_that_image() {
	global $post, $posts;
	$first_img = '';
	ob_start();
	ob_end_clean();
	$output = preg_match_all('/<img.+src=[\'"]([^\'"]+)[\'"].*>/i', $post->post_content, $matches);
	$first_img = $matches [1] [0];

	if(empty($first_img)){
	$first_img = "/images/default.jpg"; // default image
	}
return $first_img;
}

Recordemos que este código debe ir dentro de las declaraciones de apertura y cierre de php, que ya encontraremos en nuestro functions.php, o que habrá que añadir.

Nos dirigiremos ahora a nuestros archivos o índice, y usaremos el siguiente template tag, que equivaldrá a la primera imagen del post:

<?php echo catch_that_image(); ?>

Si lo quisiéramos linkando a la página final:

<a href="<?php the_permalink(); ?>"><?php echo catch_that_image(); ?></a>