¿Alguna vez ha querido crear sus propias plantillas de página, pero no ha tenido acceso al tema en sí? Yo, como autor de complementos de WordPress, he encontrado que este problema es particularmente molesto al desarrollar mis complementos. ¡Por suerte, la solución es bastante simple! Lo llevaré rápidamente a través de las pocas líneas de código que necesitará para crear dinámicamente Plantillas de página de WordPress de forma directa a través de PHP.
La inspiración para este artículo y la genialidad detrás de la solución de código proviene de Tom McFarlin: Estoy usando mi versión editada de su código original, que puede encontrar en su GitHub. He guardado sus comentarios (a la vez de agregar algunos de los míos), ya que lo encuentro muy útil para explicar lo que está sucediendo. ¡Yo mismo no podría haberlo dicho mejor!
Puede encontrar el código en su totalidad y un complemento de ejemplo al final de esta publicación.
¿Deberíamos empezar?
EL CÓDIGO
Crearemos nuestra función PHP usando una clase PHP. Para aquellos de ustedes que no están bien familiarizados con las clases PHP, una clase se define como un objeto que contiene una colección de funciones y variables que trabajan juntas. Revisar la Introducción a PHP.net para obtener más detalles sobre la sintaxis y la teoría.
Nuestro contenedor solo necesitará 3 variables:
- El plugin Slug: Esto simplemente se usa como un identificador único para el complemento.
- Instancia de clase: Como estamos agregando una instancia de esta clase al encabezado de WordPress, será mejor que la almacenemos.
- Matriz de plantillas: Como probablemente pueda adivinar, esta es una matriz que contiene los nombres y títulos de las plantillas.
Aquí están en código:
class PageTemplater {
/**
* A Unique Identifier
*/
protected $plugin_slug;
/**
* A reference to an instance of this class.
*/
private static $instance;
/**
* The array of templates that this plugin tracks.
*/
protected $templates;Obtener instancia de clase
Como dije previamente, agregaremos una instancia de nuestra clase al encabezado de WordPress usando el Añadir filtro() función. Por lo tanto, necesitaremos un método que nos devuelva (o cree) esta instancia.
Para esto, necesitaremos un método simple, que se llamará ‘get_instance’. Compruébalo a continuación;
/**
* Returns an instance of this class.
*/
public static function get_instance() {
if( null == self::$instance ) {
self::$instance = new PageTemplater();
}
return self::$instance;
}Este será el método llamado cuando nuestra clase se agregue al encabezado de WordPress usando ‘add_action ()’.
Filtros de WordPress
Ahora que hemos resuelto el método ‘get_instance’, tenemos que aclarar qué sucede cuando realmente se crea una instancia.
Usaremos el software incorporado de WordPress. Añadir filtro() función para agregar una instancia de nuestra clase en puntos clave a lo largo de la línea de tiempo de inicialización de WordPress. Con este método, insertaremos los datos de nuestras plantillas de página en espacios relevantes, como decirle a WordPress qué archivo usar como plantilla cuando se llama a la página y el título para mostrar en el menú desplegable del Editor de página.
Para esto, necesitamos usar el ‘__construir’ método (esto se ejecutará cuando la clase sea instanciada).
/**
* Initializes the plugin by setting filters and administration functions.
*/
private function __construct() {
$this->templates = array();
// Add a filter to the attributes metabox to inject template into the cache.
if ( version_compare( floatval( get_bloginfo( 'version' ) ), '4.7', '<' ) ) {
// 4.6 and older
add_filter(
'page_attributes_dropdown_pages_args',
array( $this, 'register_project_templates' )
);
} else {
// Add a filter to the wp 4.7 version attributes metabox
add_filter(
'theme_page_templates', array( $this, 'add_new_template' )
);
}
// Add a filter to the save post to inject out template into the page cache
add_filter(
'wp_insert_post_data',
array( $this, 'register_project_templates' )
);
// Add a filter to the template include to determine if the page has our
// template assigned and return it's path
add_filter(
'template_include',
array( $this, 'view_project_template')
);
// Add your templates to this array.
$this->templates = array(
'goodtobebad-template.php' => 'It's Good to Be Bad',
);
}Aquí están sucediendo 4 cosas diferentes (ignorando ‘$ this-> templates = array ();’, que solo está preparando la variable para su uso);
- Líneas 9 – 13: Este filtro agrega ‘register_project_templates’ al gancho ‘page_attributes_dropdown_pages_args’. Esto está llenando el caché de WordPress con nuestras nuevas plantillas, ‘engañando’ a WordPress haciéndole creer que los archivos de plantilla de página existen realmente en el directorio de plantillas. Esto agrega las plantillas de página a la lista desplegable en el meta cuadro de atributos de página en el editor de páginas.
- Líneas 16 – 20: Aquí estamos haciendo esencialmente lo mismo que el bloque de código anterior, excepto que esta vez estamos agregando nuestra plantilla de página (si está seleccionada) a los datos de publicación guardados al mismo tiempo.
- Líneas 23-28: Este filtro agrega el ‘template_include’ al gancho ‘view_project_template’. Ésta es una función muy importante; esto le dice a WordPress dónde está realmente su archivo de plantilla de página. WordPress utilizará la ruta proporcionada por este para representar la página final.
- Líneas 31 – 34: Aunque esto es simple, es muy importante. Aquí es donde especifica las plantillas de página que desea agregar y el ruta relativa al archivo donde se encuentra el archivo de plantilla de página (a modo de ejemplo, ‘algo.php’). He incluido un ejemplo (que se utilizará en el complemento de ejemplo). Vea a continuación un ejemplo general:
$this->templates = array(
'FILE_PATH_AND_NAME' => 'TEMPLATE_TITLE',
'awesome-template.php' => 'Awesome',
'templates/organised-template.php' => 'Organised',
);(Comer, dormir) Codificar, repetir según sea necesario.
register_project_templates ()
He aludido a este método previamente; veamos qué hace realmente.
Básicamente, el propósito de este método es manipular el caché de WordPress, insertando los datos relevantes sobre nuestras plantillas de página en los lugares correctos. Primero eche un vistazo al código y después lo explicaré.
public function register_project_templates( $atts ) {
// Create the key used for the themes cache
$cache_key = 'page_templates-' . md5( get_theme_root() . '/' . get_stylesheet() );
// Retrieve the cache list.
// If it doesn't exist, or it's empty prepare an array
$templates = wp_get_theme()->get_page_templates();
if ( empty( $templates ) ) {
$templates = array();
}
// New cache, therefore remove the old one
wp_cache_delete( $cache_key , 'themes');
// Now add our template to the list of templates by merging our templates
// with the existing templates array from the cache.
$templates = array_merge( $templates, $this->templates );
// Add the modified cache to allow WordPress to pick it up for listing
// available templates
wp_cache_add( $cache_key, $templates, 'themes', 1800 );
return $atts;
}En ese mismo momento. La línea 4 es el primer lugar para buscar. Como habrás adivinado, estamos generando una ‘clave de caché’. Esto se utilizará como un identificador único para nuestro datos de plantilla de página. El uso de la función md5 () simplemente crea un identificador de cadena único para evitar enfrentamientos.
A continuación, en la línea 8, estamos buscando y recuperando la caché de la plantilla de página (si ya existe): esto devolverá una matriz de rutas y títulos. En las líneas 9-11, verificamos si hubo algún resultado de la consulta de caché. Si es así, genial. Si no es así, cree una matriz local para contener los datos que fusionaremos en la caché.
El siguiente paso es crucial. En la línea 14 nosotros Borrar la caché de plantilla de página existente. No se preocupe, no se pierden datos, se almacenan en la variable $ templates.
En la línea 18 fusionamos el caché de plantillas de página existente con nuestras nuevas entradas, y en la línea 22 volvemos a insertar todo el caché de plantillas de página en el sistema de WordPress.
¡Sencillo!
view_project_template ()
Ahora estamos en nuestro método final; aquí es donde le decimos a WordPress dónde está el archivo de plantilla de página real.
/**
* Checks if the template is assigned to the page
*/
public function view_project_template( $template ) {
// Get global post
global $post;
// Return template if post is empty
if ( ! $post ) {
return $template;
}
// Return default template if we don't have a custom one defined
if ( !isset( $this->templates[get_post_meta(
$post->ID, '_wp_page_template', true
)] ) ) {
return $template;
}
$file = plugin_dir_path(__FILE__). get_post_meta(
$post->ID, '_wp_page_template', true
);
// Just to be safe, we check if the file exist first
if ( file_exists( $file ) ) {
return $file;
} else {
echo $file;
}
// Return template
return $template;
}Bien, entonces, este método se comparará con la variable $ post global (línea 6). Comprueba si se ha configurado una plantilla de página (‘_wp_page_template’) para la publicación (lo que significa que debe ser una página). Si no es así, no importa: las no páginas no pueden tener plantillas de página.
La línea 16 especifica la ubicación del archivo de plantilla de página. Como he establecido previamente, verifica el archivo de plantilla de página especificado en el directorio raíz de su complemento. (A pesar de todo, esto se puede cambiar fácilmente; consulte a continuación).
// Just changing the page template path
// WordPress will now look for page templates in the subfolder 'templates',
// instead of the root
$file = plugin_dir_path(__FILE__). 'templates/' .get_post_meta(
$post->ID, '_wp_page_template', true
);Posteriormente de esto, en las líneas 21-24, solo tenemos un poco de validación que verifica si el archivo realmente existe. Si es así, ¡genial! Si no es así, vaya… Lo más probable es que reciba un mensaje de error de PHP si WordPress no puede encontrar el archivo de plantilla, o incluso una pantalla en blanco. Si alguno de estos síntomas le suena familiar, simplemente verifique la ruta del archivo de la plantilla imprimiendo la variable $ file en la pantalla.
Si planea usar este código comercialmente (lo cual es libre de hacer, mi versión del código viene sin licencia, de este modo, puede hacer con él lo que quiera), realmente recomiendo invertir algo de tiempo en el manejo de errores para obtener el máximo fiabilidad.
Eso es eso. Con nuestra clase completada, solo queda una cosa por hacer: agregarla al encabezado de WordPress.
add_action( 'plugins_loaded', array( 'PageTemplater', 'get_instance' ) );¡Felicidades si lo lograste! Espero que haya encontrado útil lo que tengo que decir y se beneficie de ello en el futuro.
CÓDIGO COMPLETO
A continuación se muestra el código completo del complemento para copiar y pegar fácilmente.
<?php
/*
Plugin Name: Page Template Plugin : 'Good To Be Bad'
Plugin URI: http://www.wpexplorer.com/wordpress-page-templates-plugin/
Version: 1.1.0
Author: R Marketing Digital
Author URI: http://www.wpexplorer.com/
*/
class PageTemplater {
/**
* A reference to an instance of this class.
*/
private static $instance;
/**
* The array of templates that this plugin tracks.
*/
protected $templates;
/**
* Returns an instance of this class.
*/
public static function get_instance() {
if ( null == self::$instance ) {
self::$instance = new PageTemplater();
}
return self::$instance;
}
/**
* Initializes the plugin by setting filters and administration functions.
*/
private function __construct() {
$this->templates = array();
// Add a filter to the attributes metabox to inject template into the cache.
if ( version_compare( floatval( get_bloginfo( 'version' ) ), '4.7', '<' ) ) {
// 4.6 and older
add_filter(
'page_attributes_dropdown_pages_args',
array( $this, 'register_project_templates' )
);
} else {
// Add a filter to the wp 4.7 version attributes metabox
add_filter(
'theme_page_templates', array( $this, 'add_new_template' )
);
}
// Add a filter to the save post to inject out template into the page cache
add_filter(
'wp_insert_post_data',
array( $this, 'register_project_templates' )
);
// Add a filter to the template include to determine if the page has our
// template assigned and return it's path
add_filter(
'template_include',
array( $this, 'view_project_template')
);
// Add your templates to this array.
$this->templates = array(
'goodtobebad-template.php' => 'It's Good to Be Bad',
);
}
/**
* Adds our template to the page dropdown for v4.7+
*
*/
public function add_new_template( $posts_templates ) {
$posts_templates = array_merge( $posts_templates, $this->templates );
return $posts_templates;
}
/**
* Adds our template to the pages cache in order to trick WordPress
* into thinking the template file exists where it doens't really exist.
*/
public function register_project_templates( $atts ) {
// Create the key used for the themes cache
$cache_key = 'page_templates-' . md5( get_theme_root() . '/' . get_stylesheet() );
// Retrieve the cache list.
// If it doesn't exist, or it's empty prepare an array
$templates = wp_get_theme()->get_page_templates();
if ( empty( $templates ) ) {
$templates = array();
}
// New cache, therefore remove the old one
wp_cache_delete( $cache_key , 'themes');
// Now add our template to the list of templates by merging our templates
// with the existing templates array from the cache.
$templates = array_merge( $templates, $this->templates );
// Add the modified cache to allow WordPress to pick it up for listing
// available templates
wp_cache_add( $cache_key, $templates, 'themes', 1800 );
return $atts;
}
/**
* Checks if the template is assigned to the page
*/
public function view_project_template( $template ) {
// Get global post
global $post;
// Return template if post is empty
if ( ! $post ) {
return $template;
}
// Return default template if we don't have a custom one defined
if ( ! isset( $this->templates[get_post_meta(
$post->ID, '_wp_page_template', true
)] ) ) {
return $template;
}
$file = plugin_dir_path( __FILE__ ). get_post_meta(
$post->ID, '_wp_page_template', true
);
// Just to be safe, we check if the file exist first
if ( file_exists( $file ) ) {
return $file;
} else {
echo $file;
}
// Return template
return $template;
}
}
add_action( 'plugins_loaded', array( 'PageTemplater', 'get_instance' ) );EL PLUGIN
Al mismo tiempo puede descargar el código completo como complemento en Github.
PRIMER PLANO DEL EDITOR
Aquí hay un primer plano del complemento en acción. ¿Ve la plantilla de página agregada en Atributos de página?
