Spanish (Español) translation by Eva Collados Pascual (you can also view the original English article)
Cuando se trata de crear un Tipo de Entrada Personalizada dentro de un plugin de WordPress, siempre encontramos el mismo problema: necesitas crear un archivo personalizado single-[cpt_slug].php en tu carpeta de temas si no quieres usar el archivo single.php predeterminado de tu tema.
En este artículo me gustaría cubrir dos aspectos del uso de plantillas personalizadas. El primer paso es mostrar que podemos usar un archivo personalizado contenido directamente en el propio plugin en lugar de cargar el archivo single.php predeterminado, y el segundo es cómo crear tu propio archivo personalizado en tu carpeta de temas.
Muchos plugins como Easy Digital Downloads o Shopp, utilizan este método: el plugin comprueba si has definido una plantilla personalizada en tu carpeta de temas y, si es el caso, se carga el archivo, de lo contrario se carga el archivo de plantilla de plugin predeterminado. En ninguno de los dos casos se carga el archivo single.php predeterminado del tema.
Definir el plugin y su estructura
El primer paso es crear un plugin, vamos a llamarlo "Template Chooser". Crea una carpeta "template-chooser" en /wp-content/plugins/, con la siguiente estructura:
La estructura del pluginA continuación, abre el archivo principal template-choose.php y coloca el siguiente código de encabezado del plugin:
1 |
/*
|
2 |
Plugin Name: CPT template Chooser
|
3 |
Plugin URL: https://wp.tutsplus.com/
|
4 |
Description: Loads a custom template file instead of the default single.php
|
5 |
Version: 0.1
|
6 |
Author: Remi Corson
|
7 |
Author URI: http://wp.tutsplus.com/
|
8 |
*/
|
Definir las constantes del plugin
Más adelante en el plugin tendremos que recuperar fácilmente la URL del plugin y su ruta, y por eso que necesitamos definir algunas constantes:
1 |
|
2 |
/*
|
3 |
|--------------------------------------------------------------------------
|
4 |
| CONSTANTS
|
5 |
|--------------------------------------------------------------------------
|
6 |
*/
|
7 |
|
8 |
if ( ! defined( 'RC_TC_BASE_FILE' ) ) |
9 |
define( 'RC_TC_BASE_FILE', __FILE__ ); |
10 |
if ( ! defined( 'RC_TC_BASE_DIR' ) ) |
11 |
define( 'RC_TC_BASE_DIR', dirname( RC_TC_BASE_FILE ) ); |
12 |
if ( ! defined( 'RC_TC_PLUGIN_URL' ) ) |
13 |
define( 'RC_TC_PLUGIN_URL', plugin_dir_url( __FILE__ ) ); |
Registrar un tipo de entrada personalizada
Para ir más allá, tenemos que configurar un nuevo tipo de entrada personalizada, vamos a crear un CPT "Testimonial", con algunos soportes y características muy básicas. Como el objetivo del artículo no consiste en enseñar a crear un tipo de entrada personalizada, usaré un código bastante simple dividido en 3 partes: las etiquetas del tipo de entrada personalizada, los soportes y los argumentos de tipo de entrada personalizada. Todo esto se incrusta en una sola función:
1 |
|
2 |
/*
|
3 |
|--------------------------------------------------------------------------
|
4 |
| DEFINE THE CUSTOM POST TYPE
|
5 |
|--------------------------------------------------------------------------
|
6 |
*/
|
7 |
|
8 |
/**
|
9 |
* Setup testimonial Custom Post Type
|
10 |
*
|
11 |
* @since 1.0
|
12 |
*/
|
13 |
|
14 |
function rc_tc_setup_post_types() { |
15 |
|
16 |
// Custom Post Type Labels
|
17 |
$labels = array( |
18 |
'name' => esc_html__( 'Testimonials', 'rc_tc' ), |
19 |
'singular_name' => esc_html__( 'Testimonial', 'rc_tc' ), |
20 |
'add_new' => esc_html__( 'Add New', 'rc_tc' ), |
21 |
'add_new_item' => esc_html__( 'Add New Testimonial', 'rc_tc' ), |
22 |
'edit_item' => esc_html__( 'Edit Testimonial', 'rc_tc' ), |
23 |
'new_item' => esc_html__( 'New Testimonial', 'rc_tc' ), |
24 |
'view_item' => esc_html__( 'View Testimonial', 'rc_tc' ), |
25 |
'search_items' => esc_html__( 'Search Testimonial', 'rc_tc' ), |
26 |
'not_found' => esc_html__( 'No testimonial found', 'rc_tc' ), |
27 |
'not_found_in_trash' => esc_html__( 'No testimonial found in trash', 'rc_tc' ), |
28 |
'parent_item_colon' => '' |
29 |
);
|
30 |
|
31 |
// Supports
|
32 |
$supports = array( 'title', 'editor' ); |
33 |
|
34 |
// Custom Post Type Supports
|
35 |
$args = array( |
36 |
'labels' => $labels, |
37 |
'public' => true, |
38 |
'publicly_queryable' => true, |
39 |
'show_ui' => true, |
40 |
'query_var' => true, |
41 |
'can_export' => true, |
42 |
'rewrite' => array( 'slug' => 'testimonials', 'with_front' => true ), |
43 |
'capability_type' => 'post', |
44 |
'hierarchical' => false, |
45 |
'menu_position' => 25, |
46 |
'supports' => $supports, |
47 |
'menu_icon' => RC_TC_PLUGIN_URL . '/includes/images/testimonials_icon.png', // you can set your own icon here |
48 |
);
|
49 |
|
50 |
// Finally register the "testimonial" custom post type
|
51 |
register_post_type( 'testimonial' , $args ); |
52 |
}
|
53 |
|
54 |
add_action( 'init', 'rc_tc_setup_post_types' ); |
No usar el archivo single.php predeterminado
Ahora que nuestro tipo de entrada personalizada está registrada, necesitamos crear una función que le diga a WordPress que no use el archivo single.php predeterminado del tema.
Porque sí, por defecto, al mostrar un tipo de entrada personalizada en el front-end WordPress comprobarás si existe un archivo llamado single-testimonial.php y lo cargará. Si no, buscará el archivo single.php. Pero no queremos usar ninguno de ellos.
Queremos que WordPress cargue un archivo personalizado desde el plugin. Para ello, tenemos que enganchar una nueva función al filtro "template_include". En esta función el objetivo es comprobar el tipo de entrada y actuar en consecuencia:
1 |
|
2 |
/*
|
3 |
|--------------------------------------------------------------------------
|
4 |
| FILTERS
|
5 |
|--------------------------------------------------------------------------
|
6 |
*/
|
7 |
|
8 |
add_filter( 'template_include', 'rc_tc_template_chooser'); |
9 |
|
10 |
/*
|
11 |
|--------------------------------------------------------------------------
|
12 |
| PLUGIN FUNCTIONS
|
13 |
|--------------------------------------------------------------------------
|
14 |
*/
|
15 |
|
16 |
/**
|
17 |
* Returns template file
|
18 |
*
|
19 |
* @since 1.0
|
20 |
*/
|
21 |
|
22 |
function rc_tc_template_chooser( $template ) { |
23 |
|
24 |
// Post ID
|
25 |
$post_id = get_the_ID(); |
26 |
|
27 |
// For all other CPT
|
28 |
if ( get_post_type( $post_id ) != 'testimonial' ) { |
29 |
return $template; |
30 |
}
|
31 |
|
32 |
// Else use custom template
|
33 |
if ( is_single() ) { |
34 |
return rc_tc_get_template_hierarchy( 'single' ); |
35 |
}
|
36 |
|
37 |
}
|
Cargar la plantilla correcta
Como puedes ver, en la línea 33 estamos llamando a una nueva función rc_tc_get_template_hierarchy(). Esta es la función que comprobará si WordPress tiene que cargar el archivo personalizado desde el plugin o la plantilla desde la carpeta del tema.
Ten en cuenta que cuando estoy hablando de la "plantilla de la carpeta del tema", estoy hablando de la carga de un archivo personalizado en lugar del single.php.
Digamos que no quieres cargar la plantilla incluida en el plugin sino crear tu propia plantilla personalizada, todo lo que tienes que hacer es crear una nueva carpeta en la carpeta del tema, denomínala "plugin_template" y dentro de esta carpeta crear un archivo single.php. Este será tu nuevo archivo single.php predeterminado que se cargará sólo para los testimonios que se muestran en el front-end.
¿Me sigues? Bien, vamos a crear la función:
1 |
|
2 |
/**
|
3 |
* Get the custom template if is set
|
4 |
*
|
5 |
* @since 1.0
|
6 |
*/
|
7 |
|
8 |
function rc_tc_get_template_hierarchy( $template ) { |
9 |
|
10 |
// Get the template slug
|
11 |
$template_slug = rtrim( $template, '.php' ); |
12 |
$template = $template_slug . '.php'; |
13 |
|
14 |
// Check if a custom template exists in the theme folder, if not, load the plugin template file
|
15 |
if ( $theme_file = locate_template( array( 'plugin_template/' . $template ) ) ) { |
16 |
$file = $theme_file; |
17 |
}
|
18 |
else { |
19 |
$file = RC_TC_BASE_DIR . '/includes/templates/' . $template; |
20 |
}
|
21 |
|
22 |
return apply_filters( 'rc_repl_template_' . $template, $file ); |
23 |
}
|
24 |
|
25 |
/*
|
26 |
|--------------------------------------------------------------------------
|
27 |
| FILTERS
|
28 |
|--------------------------------------------------------------------------
|
29 |
*/
|
30 |
|
31 |
add_filter( 'template_include', 'rc_tc_template_chooser' ); |
La plantilla predeterminada del plugin
Ahora crea un nuevo testimonio desde el área de administración. Después abre includes/templates/single.php y luego copia y pega este sencillo código:
1 |
|
2 |
<?php get_header(); ?> |
3 |
|
4 |
we are in the plugin custom file |
5 |
|
6 |
<?php get_footer(); ?> |
Si visualizas el testimonio en el frontend deberías ver el "we are in the plugin custom file" (estamos en el archivo personalizado del plugin). Eso es lo que queríamos. Pero si el archivo de plantilla de plugin no se ajusta a tus necesidades o si simplemente deseas crear un diseño más personal, puede crear un archivo en tu carpeta de temas.
La plantilla predeterminada del tema
Para crear una plantilla personalizada que no utilice la predeterminada del plugin, puedes crear una nueva carpeta llamada "plugin_templates" en tu carpeta de temas. Crea un nuevo archivo llamado single.php y coloca este código:
1 |
|
2 |
<?php get_header(); ?> |
3 |
|
4 |
we are in the theme custom file |
5 |
|
6 |
<?php get_footer(); ?> |
Conclusión
Entonces, ¿qué hicimos exactamente? Bueno, hemos creado un plugin que registra un tipo de entrada personalizada denominada "Testimonial". Logramos crear una funcionalidad que carga un archivo personalizado almacenado en la carpeta del plugin en lugar de los archivos predeterminados single.php o single-testimonial.php de la carpeta del tema. También logramos cargar un archivo personalizado en su lugar desde la carpeta de temas ubicado en "plugin_templates".
¿Por qué es genial? Porque cuando creas tu propio plugin puedes proporcionar una plantilla predeterminada para mostrar el tipo de entrada personalizada de manera que estás proporcionando al usuario final la opción de usar o no su propia plantilla.
By
