Agregar plantillas de página a WordPress con un complemento

Actualizar: El código se ha actualizado recientemente para funcionar en WordPress 4.7+

¿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. ¡Afortunadamente, 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 directamente 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 (además de agregar algunos de los míos), ya que lo encuentro muy útil para explicar lo que está sucediendo.¡Yo 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 versados ​​en las clases de PHP, una clase se define como un objeto que contiene una colección de funciones y variables que trabajan juntas. Consulte la Introducción a PHP.net para obtener más detalles sobre la sintaxis y la teoría.

Nuestro contenedor solo necesitará 3 variables:

  1. El plugin Slug: Esto simplemente se usa como un identificador único para el complemento.
  2. Instancia de clase: Como estamos agregando una instancia de esta clase al encabezado de WordPress, será mejor que la almacenemos.
  3. 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 anteriormente, 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’, necesitamos resolver 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 en el Editor de página.

Para esto necesitamos usar el ‘__construir’ método (esto se ejecutará cuando se cree una instancia de la clase).

/**
 * 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);

  1. 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ágina.
  2. 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 también.
  3. 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 el archivo de plantilla de su página. WordPress utilizará la ruta proporcionada por este para representar la página final.
  4. 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 está el archivo de plantilla de página (por 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 anteriormente; veamos qué hace realmente.

Básicamente, el propósito de este método es manipular la 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 luego 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 conflictos.

A continuación, en la línea 8, buscamos y recuperamos 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 Eliminar 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 global $ post (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 anteriormente, verifica el archivo de plantilla de página especificado en el directorio raíz de su complemento. (Sin embargo, 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 
);

Después 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, por lo tanto, 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 hasta el final! 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.

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 complemento

También puede descargar el código completo como complemento en Github.

Primer plano del editor de publicaciones

Aquí hay un primer plano del complemento en acción. ¿Ve la plantilla de página agregada en Atributos de página?

GTBB1

Publicaciones relacionadas

Botón volver arriba