() translation by (you can also view the original English article)
A menudo, puedes tomar una decisión y elegir cómo implementarás una determinada funcionalidad. WordPress tiene un enfoque bastante flexible para casi cualquier problema, y en este tutorial vamos a echar un vistazo a la flexibilidad de la API de tipo de entrada personalizada.
Hay muchas cosas que puedes hacer con los tipos de entradas personalizadas, incluyendo la generación y administración de ciertas entradas en algunas páginas personalizadas, slideshows, galerías, e incluso elementos de portafolio. Algunas personas aún no saben que existen, otras no entienden completamente sus opciones ni cómo usarlas. En los siguientes pasos, vamos a intentar crear un plugin que utiliza concretamente lo mejor de los tipos de entradas personalizadas. Para ser más exactos, vamos a construir un plugin que genera un tipo de entrada personalizada, que a su vez, crea y administra dinámicamente otros tipos de entradas personalizadas (¡esto es como Inception!).
Paso 1 El plan
Antes incluso de empezar, vamos a echar un vistazo en detalle a lo que vamos a construir en este tutorial, cómo y por qué. El propósito de este tutorial es ayudar a que te familiarices con los tipos de entradas personalizadas en WordPress.
Para ello vamos a crear un plugin que crea un tipo de entrada personalizada principal, luego usa las entradas pertenecientes a ese tipo de entrada personalizada, con un meta box de configuración, para crear tipos de entradas personalizadas adicionales y dinámicas basadas en las opciones de la interfaz del meta box. Esto te ayudará a entender en detalle todas las opciones de las entradas personalizadas y algunas de las posibilidades que pueden ofrecer. Para los objetivos de este tutorial, damos por hecho que tienes un servidor Apache en funcionamiento con PHP y MySQL en ejecución, y una instalación de WordPress, para que puedas probar el código del plugin en una versión 3.0 o superior de WordPress.
Cada entrada va a ser interpretada como un nuevo tipo de entrada personalizada y vamos a guardar las opciones de configuración de cada entrada en campos personalizados utilizando un meta box con gran cantidad de formularios, casillas de verificación, menús desplegables y campos de texto que almacenarán y mostrarán los datos, facilitando al usuario la modificación de cualquier cosa.
Debido a que el plugin tiene 450 líneas de código, no todas aparecerán en el tutorial ya que gran parte de este código se repite y simplemente cambian las variables. No obstante, se explicará toda la funcionalidad del plugin y se proporcionará el código fuente de ejemplo.
Paso 2 Crear y comprender los ganchos
Si queremos llegar a la funcionalidad de tipo de entrada personalizada, la funcionalidad de meta box, y queremos guardar los datos en la acción de actualización o publicación, necesitamos ganchos, y debemos implementarlos en concreto para obtener el resultado deseado.
1 |
add_action('save_post', 'cpt_save_postdata'); |
2 |
add_action('add_meta_boxes', 'cpt_add_meta_boxes'); |
3 |
add_action('init', 'init_custom_post_types'); |
En este tutorial sólo vamos a requerir tres ganchos, sin filtros, y únicamente en la funcionalidad principal. Primero necesitamos un gancho para generar el tipo de entrada personalizada en tu función de devolución de llamada. Para eso vamos a usar el gancho de etiqueta init y la función de devolución de llamada con el nombre 'init_custom_post_types'. Aquí es donde ocurre toda la magia, es decir, aquí es donde declaramos nuestros tipos de entradas personalizadas y donde hacemos que sean dinámicas extrayendo los valores de la base de datos y generando tipos de entradas personalizadas dinámicas en un bucle. Esta parte del código se discutirá más adelante.
Otro gancho que necesitamos es el gancho de etiqueta 'add_meta_boxes' que apunta a la función de devolución de llamada 'cpt_add_meta_boxes' y se utiliza para generar los meta boxes dentro del tipo de entrada personalizada principal que genera todos los demás tipos de entradas personalizadas. Aquí es donde creamos los formularios que almacenarán y actualizarán los datos que necesitamos manipular para crear nuestra funcionalidad.
El último gancho que utilizamos es 'save_post' con la función de devolución de llamada de 'cpt_save_postdata' y cuya finalidad es guardar los datos publicados en el meta box. Cuando el usuario envía la página del tipo de entrada personalizada principal en el panel de administración, se envían todos los campos del formulario y este es el gancho que usamos para capturar ese contenido y guardarlo o actualizarlo en la base de datos para su posterior uso.
Paso 3 Crear el tipo de entrada personalizada principal
En primer lugar, necesitamos crear un tipo de entrada personalizada general que gestionará todo el contenido dinámico. Para ello, primero creamos un tipo de entrada personalizada genérica utilizando datos codificados de forma rígida como en el siguiente ejemplo. Empezamos creando las etiquetas. El parámetro labels es uno de los valores principales del argumento que es interpretado como una matriz. Los valores de la matriz son proporcionados por sus identificadores, específicamente name para el nombre general principal del tipo de entrada personalizada que suele ser una cadena plural del nombre del tipo de entrada personalizada, singular_name para el nombre de objeto del tipo de entrada personalizada en singular, add_new el texto de cadena para añadir nuevo, add_new_item que es el texto predeterminado para añadir una nueva entrada o página, edit_item como texto predeterminado para editar una entrada o página, all_items se utiliza para mostrar todo el texto de los nombres del tipo de entradas personalizadas donde se solicite (por ejemplo, todos los coches), view_items y search_items se utilizan al igual que el ejemplo anterior aunque para propósitos obviamente diferentes, not_found, not_fount_in_trash, parent_item_colon también son textos de reemplazo utilizados para determinadas páginas de las entradas (tipos de entradas personalizadas) funcionalidad que es posible que desees cambiar para cualquier tipo de entrada personalizada que crees.
En el siguiente ejemplo, la matriz $labels utiliza CPT para reemplazar el texto predeterminado de entrada/entradas/página/páginas. Supongo que no es necesario para algunos lectores, pero sólo para asegurarte de que no me pierdo la idea, CPT significa Custom Post Type (tipo de entrada personalizada) y es y será utilizado de varias maneras durante el tutorial.
Una nota importante, este código se inserta en la función de devolución de llamada init_custom_post_types para que funcione correctamente.
1 |
$labels = array( |
2 |
'name' => _x('CPT', 'post type general name'), |
3 |
'singular_name' => _x('CPT', 'post type singular name'), |
4 |
'add_new' => _x('Add New CPT', 'CPT'), |
5 |
'add_new_item' => __('Add New Post type'), |
6 |
'edit_item' => __('Edit CPT'), |
7 |
'new_item' => __('New CPT'), |
8 |
'all_items' => __('All CPT'), |
9 |
'view_item' => __('View CPT'), |
10 |
'search_items' => __('Search CPT'), |
11 |
'not_found' => __('No CPT found'), |
12 |
'not_found_in_trash' => __('No CPT found in Trash'), |
13 |
'parent_item_colon' => '', |
14 |
'menu_name' => __('CPT') |
15 |
);
|
16 |
|
17 |
$args = array( |
18 |
'labels' => $labels, |
19 |
'public' => true, |
20 |
'publicly_queryable' => true, |
21 |
'show_ui' => true, |
22 |
'show_in_menu' => true, |
23 |
'query_var' => true, |
24 |
'rewrite' => true, |
25 |
'capability_type' => 'post', |
26 |
'has_archive' => true, |
27 |
'hierarchical' => false, |
28 |
'menu_position' => null, |
29 |
'supports' => array('title') |
30 |
);
|
31 |
register_post_type('CPT', $args); |
La matriz principal necesaria para generar el tipo de entrada personalizada es la matriz $args, utilizada con el único propósito de establecer las opciones principales del tipo de entrada personalizada y administrar su funcionalidad.
- La primera variable de matriz se denomina labels y anteriormente nos encargamos de la estructura de ese valor.
-
public: una variable booleana, true o false, que representa la disponibilidad del tipo de entrada personalizada, si es público para la interfaz de administración o para los usuarios front-end en el tema. -
publicly_queryable: de nuevo un valor booleano que establece si el front-end tiene la capacidad de consultar los resultados del tipo de entrada personalizada. -
show_ui: un booleano que indica si se genera contenido de administrador predeterminado para el tipo de entrada personalizada o no. -
show_in_menu: otra variable booleana que requiere queshow_uisea fiel a la función, ya que su propósito es mostrar o no mostrar el tipo de entrada en el menú del panel de administración de WordPress. -
query_var: crea una clave var de consulta para este tipo de entrada personalizada. Puedes usarlo como booleano o cadena, si true es su valor predeterminado, false deshabilita el uso de la clave var de consulta y la cadena establece una clave personalizada. En nuestro ejemplo usamos el valor predeterminado y lo establecemos en true. -
rewrite: esto evita las reescrituras para este tipo de entrada. -
capability_type: como mínimo, una cadena que establece si el tipo de entrada personalizada es una entrada o una página, en una cadena de texto sin formato. Nosotros estamos usando post. -
has_archive: este parámetro habilita los archivos de entradas y utilizapost_typede forma predeterminada como slug de archivo. -
hierarchical: un booleano que establece si el tipo de entrada es jerárquica o no, es decir, si permite especificar padres o no. -
menu_position: una cadena que representa la posición en la que se mostrará el tipo de entrada en el menú. Los valores van aproximadamente de 5 a 100. -
supports: de nuevo este valor tiene un valor de matriz, esta vez con valores como title, editor, thumbnail, custom-fields, trackbacks, revisions, page-attributes y post-formats.
La matriz de argumentos principal se utiliza en la siguiente función register_post_type que tiene como primer parámetro el nombre del tipo de entrada personalizada (en nuestro caso CPT) y el segundo la variable $args.
Este ejemplo y explicación cubre la creación de nuestro tipo de entrada personalizada principal.
Paso 4 Codificar el meta box
Al principio, cubrimos los ganchos, uno de ellos implementó una etiqueta que tenía una función de devolución de llamada hecha específicamente para la implementación del meta box. Esa función tiene este aspecto:
1 |
function cpt_add_meta_boxes() { |
2 |
add_meta_box('cpt_meta_id', 'Custom Post Type Settings', 'cpt_inner_custom_box', 'CPT', 'normal'); |
3 |
}
|
Dentro de la función tenemos la función add_meta_box que tiene los parámetros predeterminados para implementar un meta box, a saber, el id único del meta box, el título del misma, la función de devolución de llamada y el tipo de entrada personalizada en la que se debe aplicar, también por último pero no menos importante, la posición (vamos a establecerlo en normal ya que queremos que aparezca justo bajo el editor).
Eso es todo para generar el uso de la API, pero ¿con qué la llenamos? Bueno, tenemos que llenarlo con todas las opciones discutidas antes en el paso 3 y para hacer esto, vamos a crear campos de formulario y rellenarlos con datos dependiendo de su tipo.
Algunas serán casillas de verificación
Estamos usando casillas de verificación para los argumentos de matriz que necesitan valores booleanos. Marcada es true y sin marcar es false.
1 |
<td><input type="checkbox" <?php |
2 |
if ($cp_publicly_queryable == "on") { |
3 |
echo "checked"; |
4 |
}
|
5 |
?> name="cp_publicly_queryable" /> Publicly Queryable </td> |
Otros serán menús desplegables
Algunos argumentos de matriz requieren varios elementos para elegir. Para ello estamos utilizando cuadros desplegables con valores codificados de forma rígida que se ajustan a nuestras necesidades.
1 |
<td>Menu Position:<br/> |
2 |
<select name="cp_menu_position"> |
3 |
<option value="post" <?php |
4 |
if ($cp_menu_position == "post") { |
5 |
echo "selected"; |
6 |
}
|
7 |
?>>Post</option> |
8 |
<option value="page" <?php |
9 |
if ($cp_menu_position == "page") { |
10 |
echo "selected"; |
11 |
}
|
12 |
?>>Page</option> |
13 |
</select>
|
14 |
</td>
|
Y otros campos de texto
Vamos a almacenar valores de cadena en estos campos de formulario.
1 |
<td>General name:<br/> <input type="text" name="cp_general_name" value="<?php echo $cp_general_name; ?>"/></td> |
Es posible que hayas notado que están llenos de variables PHP y están funcionando con datos. Pero, ¿de dónde provienen estas variables y qué hay de los datos? Para responder a esta pregunta debemos ir al siguiente paso y guardar en este momento los campos de formulario creados. Pero como no quiero hacerte retroceder y avanzar a través de los pasos, te pediré que asumas que todos los datos se guardan de alguna manera en la base de datos, te mostraré cómo, y todo lo que tenemos que hacer es extraerlo en variables como en el siguiente ejemplo:
1 |
global $post; |
2 |
|
3 |
$cp_public = get_post_meta($post->ID, 'cp_public', true); |
En nuestra función de devolución de llamada de meta box declaramos la variable global $post para obtener más adelante el ID de la entrada actual y, como los datos se almacenan como una entrada personalizada, como en el ejemplo anterior, vamos a usar la función get_post_meta para obtener el valor de clave meta almacenado para cada variable donde el primer parámetro es el ID de entrada, la segunda es la clave meta y la tercera es un booleano que le indica a la función que devuelva una cadena y no una matriz.
Existen 27 variables utilizadas en este tutorial, almacenadas como entradas personalizadas y se ven así:
1 |
$cp_public = get_post_meta($post->ID, 'cp_public', true); |
2 |
$cp_publicly_queryable = get_post_meta($post->ID, 'cp_publicly_queryable', true); |
3 |
$cp_show_ui = get_post_meta($post->ID, 'cp_show_ui', true); |
4 |
$cp_show_in_menu = get_post_meta($post->ID, 'cp_show_in_menu', true); |
5 |
$cp_query_var = get_post_meta($post->ID, 'cp_query_var', true); |
6 |
$cp_rewrite = get_post_meta($post->ID, 'cp_rewrite', true); |
7 |
$cp_has_archive = get_post_meta($post->ID, 'cp_has_archive', true); |
8 |
$cp_hierarchical = get_post_meta($post->ID, 'cp_hierarchical', true); |
9 |
$cp_capability_type = get_post_meta($post->ID, 'cp_capability_type', true); |
10 |
$cp_menu_position = get_post_meta($post->ID, 'cp_menu_position', true); |
11 |
$cp_s_title = get_post_meta($post->ID, 'cp_s_title', true); |
12 |
$cp_s_editor = get_post_meta($post->ID, 'cp_s_editor', true); |
13 |
$cp_s_author = get_post_meta($post->ID, 'cp_s_author', true); |
14 |
$cp_s_thumbnail = get_post_meta($post->ID, 'cp_s_thumbnail', true); |
15 |
$cp_s_excerpt = get_post_meta($post->ID, 'cp_s_excerpt', true); |
16 |
$cp_s_comments = get_post_meta($post->ID, 'cp_s_comments', true); |
17 |
$cp_general_name = get_post_meta($post->ID, 'cp_general_name', true); |
18 |
$cp_singular_name = get_post_meta($post->ID, 'cp_singular_name', true); |
19 |
$cp_add_new = get_post_meta($post->ID, 'cp_add_new', true); |
20 |
$cp_add_new_item = get_post_meta($post->ID, 'cp_add_new_item', true); |
21 |
$cp_edit_item = get_post_meta($post->ID, 'cp_edit_item', true); |
22 |
$cp_new_item = get_post_meta($post->ID, 'cp_new_item', true); |
23 |
$cp_all_items = get_post_meta($post->ID, 'cp_all_items', true); |
24 |
$cp_view_item = get_post_meta($post->ID, 'cp_view_item', true); |
25 |
$cp_search_items = get_post_meta($post->ID, 'cp_search_items', true); |
26 |
$cp_not_found = get_post_meta($post->ID, 'cp_not_found', true); |
27 |
$cp_not_found_in_trash = get_post_meta($post->ID, 'cp_not_found_in_trash', true); |
28 |
$cp_parent_item_colon = get_post_meta($post->ID, 'cp_parent_item_colon', true); |
Lo que necesitas entender es que todas se extraen de la misma manera, no hay nada especial o diferente en esta larga lista de variables excepto sus valores. Por supuesto, el concepto es que este código obtiene los datos de la base de datos y se utiliza más adelante en cada campo de formulario para mostrarlos en el meta box del panel de administración como un valor seleccionado, como una cadena o como una casilla de verificación marcada para los valores booleanos. Toda la funcionalidad se puede ver mejor en los archivos descargables adjuntos.
Como resultado hasta ahora, así es como se ve la entrada personalizada del meta box del tipo de entrada personalizada según nuestra implementación.
Paso 5 Guardar los datos
Todos los datos de formulario enviados desde el meta box deben guardarse en la base de datos de manera que puedan ser usados más adelante para hacer que el tipo de entrada personalizada sea dinámica y también en la funcionalidad del meta box. Para guardar los datos tenemos la función cpt_save_postdata a modo de función de devolución de llamada que hemos creado para hacer precisamente eso. Pero esta función debe rellenarse con la funcionalidad que realmente guarda los datos. Entonces, ¿cómo guardamos los datos para todos estos elementos. La respuesta fácil y más obvia son los campos personalizados. Vamos a almacenar todos estos valores en campos personalizados de la entrada personalizada individual principal, ya que serán mucho más fáciles de administrar más adelante cuando los extraigamos en función de una determinada entrada consultada.
Aquí está todo el código que debe ser ejecutado en la función especificada antes con el fin de guardar todos los datos que necesitamos.
1 |
global $post; |
2 |
if ($_POST['cpt-hidd'] == 'true') { |
3 |
$cp_public = get_post_meta($post->ID, 'cp_public', true); |
4 |
$cp_publicly_queryable = get_post_meta($post->ID, 'cp_publicly_queryable', true); |
5 |
$cp_show_ui = get_post_meta($post->ID, 'cp_show_ui', true); |
6 |
$cp_show_in_menu = get_post_meta($post->ID, 'cp_show_in_menu', true); |
7 |
$cp_query_var = get_post_meta($post->ID, 'cp_query_var', true); |
8 |
$cp_rewrite = get_post_meta($post->ID, 'cp_rewrite', true); |
9 |
$cp_has_archive = get_post_meta($post->ID, 'cp_has_archive', true); |
10 |
$cp_hierarchical = get_post_meta($post->ID, 'cp_hierarchical', true); |
11 |
$cp_capability_type = get_post_meta($post->ID, 'cp_capability_type', true); |
12 |
$cp_menu_position = get_post_meta($post->ID, 'cp_menu_position', true); |
13 |
$cp_s_title = get_post_meta($post->ID, 'cp_s_title', true); |
14 |
$cp_s_editor = get_post_meta($post->ID, 'cp_s_editor', true); |
15 |
$cp_s_author = get_post_meta($post->ID, 'cp_s_author', true); |
16 |
$cp_s_thumbnail = get_post_meta($post->ID, 'cp_s_thumbnail', true); |
17 |
$cp_s_excerpt = get_post_meta($post->ID, 'cp_s_excerpt', true); |
18 |
$cp_s_comments = get_post_meta($post->ID, 'cp_s_comments', true); |
19 |
$cp_general_name = get_post_meta($post->ID, 'cp_general_name', true); |
20 |
$cp_singular_name = get_post_meta($post->ID, 'cp_singular_name', true); |
21 |
$cp_add_new = get_post_meta($post->ID, 'cp_add_new', true); |
22 |
$cp_add_new_item = get_post_meta($post->ID, 'cp_add_new_item', true); |
23 |
$cp_edit_item = get_post_meta($post->ID, 'cp_edit_item', true); |
24 |
$cp_new_item = get_post_meta($post->ID, 'cp_new_item', true); |
25 |
$cp_all_items = get_post_meta($post->ID, 'cp_all_items', true); |
26 |
$cp_view_item = get_post_meta($post->ID, 'cp_view_item', true); |
27 |
$cp_search_items = get_post_meta($post->ID, 'cp_search_items', true); |
28 |
$cp_not_found = get_post_meta($post->ID, 'cp_not_found', true); |
29 |
$cp_not_found_in_trash = get_post_meta($post->ID, 'cp_not_found_in_trash', true); |
30 |
$cp_parent_item_colon = get_post_meta($post->ID, 'cp_parent_item_colon', true); |
31 |
|
32 |
update_post_meta($post->ID, 'cp_public', $_POST['cp_public'], $cp_public); |
33 |
update_post_meta($post->ID, 'cp_publicly_queryable', $_POST['cp_publicly_queryable'], $cp_publicly_queryable); |
34 |
update_post_meta($post->ID, 'cp_show_ui', $_POST['cp_show_ui'], $cp_show_ui); |
35 |
update_post_meta($post->ID, 'cp_show_in_menu', $_POST['cp_show_in_menu'], $cp_show_in_menu); |
36 |
update_post_meta($post->ID, 'cp_query_var', $_POST['cp_query_var'], $cp_query_var); |
37 |
update_post_meta($post->ID, 'cp_rewrite', $_POST['cp_rewrite'], $cp_rewrite); |
38 |
update_post_meta($post->ID, 'cp_has_archive', $_POST['cp_has_archive'], $cp_has_archive); |
39 |
update_post_meta($post->ID, 'cp_hierarchical', $_POST['cp_hierarchical'], $cp_hierarchical); |
40 |
update_post_meta($post->ID, 'cp_capability_type', $_POST['cp_capability_type'], $cp_capability_type); |
41 |
update_post_meta($post->ID, 'cp_menu_position', $_POST['cp_menu_position'], $cp_menu_position); |
42 |
update_post_meta($post->ID, 'cp_s_title', $_POST['cp_s_title'], $cp_s_title); |
43 |
update_post_meta($post->ID, 'cp_s_editor', $_POST['cp_s_editor'], $cp_s_editor); |
44 |
update_post_meta($post->ID, 'cp_s_author', $_POST['cp_s_author'], $cp_s_author); |
45 |
update_post_meta($post->ID, 'cp_s_thumbnail', $_POST['cp_s_thumbnail'], $cp_s_thumbnail); |
46 |
update_post_meta($post->ID, 'cp_s_excerpt', $_POST['cp_s_excerpt'], $cp_s_excerpt); |
47 |
update_post_meta($post->ID, 'cp_s_comments', $_POST['cp_s_comments'], $cp_s_comments); |
48 |
update_post_meta($post->ID, 'cp_general_name', $_POST['cp_general_name'], $cp_general_name); |
49 |
update_post_meta($post->ID, 'cp_singular_name', $_POST['cp_singular_name'], $cp_singular_name); |
50 |
update_post_meta($post->ID, 'cp_add_new', $_POST['cp_add_new'], $cp_add_new); |
51 |
update_post_meta($post->ID, 'cp_add_new_item', $_POST['cp_add_new_item'], $cp_add_new_item); |
52 |
update_post_meta($post->ID, 'cp_edit_item', $_POST['cp_edit_item'], $cp_edit_item); |
53 |
update_post_meta($post->ID, 'cp_new_item', $_POST['cp_new_item'], $cp_new_item); |
54 |
update_post_meta($post->ID, 'cp_all_items', $_POST['cp_all_items'], $cp_all_items); |
55 |
update_post_meta($post->ID, 'cp_view_item', $_POST['cp_view_item'], $cp_view_item); |
56 |
update_post_meta($post->ID, 'cp_search_items', $_POST['cp_search_items'], $cp_search_items); |
57 |
update_post_meta($post->ID, 'cp_not_found', $_POST['cp_not_found'], $cp_not_found); |
58 |
update_post_meta($post->ID, 'cp_not_found_in_trash', $_POST['cp_not_found_in_trash'], $cp_not_found_in_trash); |
59 |
update_post_meta($post->ID, 'cp_parent_item_colon', $_POST['cp_parent_item_colon'], $cp_parent_item_colon); |
60 |
}
|
Primero, extraemos las variables como lo hicimos previamente en la parte superior de la funcionalidad del meta box, y luego las actualizamos usando la función update_post_meta, a la que damos los parámetros: post id, nombre de la clave meta, nuevo valor, valor antiguo. Voila, hemos actualizado el campo personalizado de un valor. Necesitamos repetir el proceso como se ve en el ejemplo anterior para cubrir todos los valores y todas las opciones que necesitamos.
Eso es todo en lo referente al guardado de los datos.
Paso 6 Crear los tipos de entradas personalizadas dinámicas
Entonces, ¿cómo tomamos todos los datos que acabamos de guardar y los hacemos dinámicos? ¿cómo los usamos para generar tipos de entradas personalizadas? Fácil, consultamos el tipo de entrada personalizada principal, y para cada bucle de entrada extraemos los campos personalizados y, en consecuencia, colocamos los datos dentro de la matriz.
Echemos un vistazo a cómo hacer esto. En primer lugar, colocamos este código justo bajo del código del tipo de entrada personalizada principal, dentro de la función init_custom_post_types. Y así, comenzamos creando la consulta:
1 |
$the_query = new WP_Query(array('post_type' => array('CPT'))); |
2 |
while ($the_query->have_posts()) : $the_query->the_post(); |
Creamos una variable denominada $the_query en la que almacenamos el contenido de la función de clase principal invocada wp_query con los parámetros de una matriz que tiene el valor del post_type el nombre del tipo de entrada personalizada principal, es decir, CPT. Entonces iniciamos el bucle. Dentro del bucle generamos las variables que queremos que contengan los valores que necesitamos como campos personalizados utilizando el mismo enfoque usamos al extraerlos de la base de datos:
1 |
global $post; |
2 |
//*************************get the values
|
3 |
$cp_public = get_post_meta($post->ID, 'cp_public', true); |
4 |
if ($cp_public == "on") { |
5 |
$cp_public = true; |
6 |
}
|
7 |
else { |
8 |
$cp_public = false; |
9 |
}
|
10 |
$cp_publicly_queryable = get_post_meta($post->ID, 'cp_publicly_queryable', true); |
11 |
if ($cp_publicly_queryable == "on") { |
12 |
$cp_publicly_queryable = true; |
13 |
}
|
14 |
else { |
15 |
$cp_publicly_queryable = false; |
16 |
}
|
17 |
$cp_show_ui = get_post_meta($post->ID, 'cp_show_ui', true); |
18 |
if ($cp_show_ui == "on") { |
19 |
$cp_show_ui = true; |
20 |
}
|
21 |
else { |
22 |
$cp_show_ui = false; |
23 |
}
|
24 |
$cp_show_in_menu = get_post_meta($post->ID, 'cp_show_in_menu', true); // |
25 |
if ($cp_show_in_menu == "on") { |
26 |
$cp_show_in_menu = true; |
27 |
}
|
28 |
else { |
29 |
$cp_show_in_menu = false; |
30 |
}
|
31 |
$cp_query_var = get_post_meta($post->ID, 'cp_query_var', true); // |
32 |
if ($cp_query_var == "on") { |
33 |
$cp_query_var = true; |
34 |
}
|
35 |
else { |
36 |
$cp_query_var = false; |
37 |
}
|
38 |
$cp_rewrite = get_post_meta($post->ID, 'cp_rewrite', true); // |
39 |
if ($cp_rewrite == "on") { |
40 |
$cp_rewrite = true; |
41 |
}
|
42 |
else { |
43 |
$cp_rewrite = false; |
44 |
}
|
45 |
$cp_has_archive = get_post_meta($post->ID, 'cp_has_archive', true); // |
46 |
if ($cp_has_archive == "on") { |
47 |
$cp_has_archive = true; |
48 |
}
|
49 |
else { |
50 |
$cp_has_archive = false; |
51 |
}
|
52 |
$cp_hierarchical = get_post_meta($post->ID, 'cp_hierarchical', true); |
53 |
if ($cp_hierarchical == "on") { |
54 |
$cp_hierarchical = true; |
55 |
}
|
56 |
else { |
57 |
$cp_hierarchical = false; |
58 |
}
|
59 |
$cp_capability_type = get_post_meta($post->ID, 'cp_capability_type', true); |
60 |
$cp_menu_position = get_post_meta($post->ID, 'cp_menu_position', true); |
61 |
$cp_s_title = get_post_meta($post->ID, 'cp_s_title', true); |
62 |
if ($cp_s_title == "on") { |
63 |
$cp_s[] = 'title'; |
64 |
}
|
65 |
$cp_s_editor = get_post_meta($post->ID, 'cp_s_editor', true); |
66 |
if ($cp_s_editor == "on") { |
67 |
$cp_s[] = 'editor'; |
68 |
}
|
69 |
$cp_s_author = get_post_meta($post->ID, 'cp_s_author', true); |
70 |
if ($cp_s_author == "on") { |
71 |
$cp_s[] = 'author'; |
72 |
}
|
73 |
$cp_s_thumbnail = get_post_meta($post->ID, 'cp_s_thumbnail', true); |
74 |
if ($cp_s_thumbnail == "on") { |
75 |
$cp_s[] = 'thumbnail'; |
76 |
}
|
77 |
$cp_s_excerpt = get_post_meta($post->ID, 'cp_s_excerpt', true); |
78 |
if ($cp_s_excerpt == "on") { |
79 |
array_push($cp_s, 'excerpt'); |
80 |
}
|
81 |
$cp_s_comments = get_post_meta($post->ID, 'cp_s_comments', true); |
82 |
if ($cp_s_comments == "on") { |
83 |
array_push($cp_s, 'comments'); |
84 |
}
|
85 |
$cp_general_name = get_post_meta($post->ID, 'cp_general_name', true); |
86 |
$cp_singular_name = get_post_meta($post->ID, 'cp_singular_name', true); |
87 |
$cp_add_new = get_post_meta($post->ID, 'cp_add_new', true); |
88 |
$cp_add_new_item = get_post_meta($post->ID, 'cp_add_new_item', true); |
89 |
$cp_edit_item = get_post_meta($post->ID, 'cp_edit_item', true); |
90 |
$cp_new_item = get_post_meta($post->ID, 'cp_new_item', true); |
91 |
$cp_all_items = get_post_meta($post->ID, 'cp_all_items', true); |
92 |
$cp_view_item = get_post_meta($post->ID, 'cp_view_item', true); |
93 |
$cp_search_items = get_post_meta($post->ID, 'cp_search_items', true); |
94 |
$cp_not_found = get_post_meta($post->ID, 'cp_not_found', true); |
95 |
$cp_not_found_in_trash = get_post_meta($post->ID, 'cp_not_found_in_trash', true); |
96 |
$cp_parent_item_colon = get_post_meta($post->ID, 'cp_parent_item_colon', true); |
Dado que ahora estamos dentro del bucle de consulta, podemos usar una variable global de $post para obtener el ID que necesitamos. También es posible que hayas notado algunas condiciones establecidas por un if aquí y allá para la mayoría de las variables. Estos existen porque el valor booleano verdadero o algunos otros valores de cadena deben convertirse correctamente desde la cadena "on" que representan al valor booleano true que deben ser.
Después de habernos ocupado de todo esto, insertaremos las variables en la matriz de la implementación dinámica de tipo de entrada personalizada:
1 |
$labels = array( |
2 |
'name' => _x(get_the_title($post->ID), 'post type general name'), |
3 |
'singular_name' => _x($cp_singular_name, 'post type singular name'), |
4 |
'add_new' => _x($cp_add_new, get_the_title($post->ID)), |
5 |
'add_new_item' => __($cp_add_new_item), |
6 |
'edit_item' => __($cp_edit_item), |
7 |
'new_item' => __($cp_new_item), |
8 |
'all_items' => __($cp_all_items), |
9 |
'view_item' => __($cp_view_item), |
10 |
'search_items' => __($cp_search_items), |
11 |
'not_found' => __($cp_not_found), |
12 |
'not_found_in_trash' => __($cp_not_found_in_trash), |
13 |
'parent_item_colon' => __($cp_parent_item_colon), |
14 |
'menu_name' => __(get_the_title($post->ID)) |
15 |
);
|
16 |
|
17 |
$args = array( |
18 |
'labels' => $labels, |
19 |
'public' => $cp_public, |
20 |
'publicly_queryable' => $cp_publicly_queryable, |
21 |
'show_ui' => $cp_show_ui, |
22 |
'show_in_menu' => $cp_show_in_menu, |
23 |
'query_var' => $cp_query_var, |
24 |
'rewrite' => $cp_rewrite, |
25 |
'capability_type' => 'post', |
26 |
'has_archive' => $cp_has_archive, |
27 |
'hierarchical' => $cp_hierarchical, |
28 |
'menu_position' => $cp_menu_position, |
29 |
'supports' => $cp_s |
30 |
);
|
31 |
register_post_type(get_the_title($post->ID), $args); |
32 |
endwhile; |
El título de la entrada se utiliza como el nombre principal del tipo de entrada personalizada y la configuración del meta box como el resto de las propiedades. Eso es todo, todo lo que se necesita para implementar los tipos de entradas personalizadas dinámicos en WordPress. Habrás notado que también cerramos el bucle al final del anterior código.
Conclusión
Los tipos de entradas personalizadas no son difíciles de manejar y son bastante flexibles en cualquier funcionalidad que puedas requerir incluso con otros ganchos, filtros o funciones personalizadas. En este tutorial logramos cubrir una implementación dinámica concreta para la gestión de tipo de entradas personalizadas en un solo plugin, explicado, con código y archivos, para tus necesidades. Por supuesto, el uso del tipo de entrada personalizada no se limita a estos ejemplos, ya que puede utilizarse en muchos tipos de implementaciones, plugins y temas urdidos en muchos ganchos, consultados de diferentes maneras, filtrados o manipulados de muchas maneras.
