8-METADATOS Y METABOXES
9-ENQUEUE (CSS Y JS)
Ganchos para el encolamiento:
FRONTEND
do_action( 'wp_enqueue_scripts' )
ADMIN
do_action( 'admin_enqueue_scripts')
INICIO DE SESION
do_action( 'login_enqueue_scripts' )
FUNCIONES DE ENCOLAMIENTO:
Por ejemplo, voy a cargar estilos en el admin, voy a crear una carpeta dentro del directorio del plugin, que se llama "admin" y dentro creo otra carpeta que se llama "css" y dentro un archivo "estilos.css", quedaria asi:
function mp_cargando_css( $hook ){
if( $hook != 'toplevel_page_mp-test' ){ //"mp-test" el nombre de la config
return;
}
wp_enqueue_style(
'mp_styles',
plugins_url('/admin/css/admin-style.css', __FILE__),
array(),
'1.0.0',
'all'
);
wp_enqueue_script(
'mp_scripts',
plugins_url('/admin/js/admin-app.js', __FILE__),
array(),
'1.0.0',
true
);
//De-register
wp_deregister_script('jquery');
//Registrar Jquery Nuevo
wp_register_script(
'jqueryNew',
'https://code.jquery.com/jquery-3.5.1.min.js'
);
//Cargar Jquery Nuevo
wp_enqueue_script('jqueryNew');
}
add_action('admin_enqueue_scripts', 'mp_cargando_css');
10-TAXONOMIAS
register_taxonomy( string $taxonomy, array|string $object_type, array|string $args = array() )
add_action('init', function)
function taxonomia_color(){
$post_type = ['post'];
$labels = [
'name' => 'Colores',
'singular_name' => 'Color',
'search_items' => 'Buscar Color',
'all_items' => 'Todos los colores',
'edit_item' => 'Editar Color',
'update_item' => 'Actualizar color',
'add_new_item' => 'Agregar nuevo Color',
'new_item_name' => 'Nuevo nombre del color',
'menu_name' => 'Color'
];
$args = [
'hierarchical' => true,
'labels' => $labels
];
register_taxonomy(
'color', //$taxonomy:string,
$post_type, //$object_type:array|string
$args //$args:array|string )
);
}
add_action( 'init', 'taxonomia_color' );
10-Crear Objeto cargador de Acciones y filtros
PROGRMACION ORIENTADA A OBJETOS
Vamos a dejar de usar programacion por procedimiento y vamos a usar programacion orientada a objetos y modular.
-Vamos a crear un objeto para que nos ayude a cargar las acciones- y la vamos a cargar en:
-Vamos a crear una carpeta llamada "includes" y vamos a cargarla en el archivo del plugin:
Y dentro un archivo llamado "cargador.php".
(CARGAR Y LLAMAR ARCHIVOS)
//1 )
//require_once plugin_dir_path( __FILE__ ) . 'carpeta/archivo.php';
//2 ) Crear Constante:
define('PLUGIN_DIR_PATH', plugin_dir_path( __FILE__ ));
Entonces vamos a usar esa constante:
require_once PLUGIN_DIR_PATH . 'admin/cargador.php';
Ahora, en el archivo "cargador.php" vamos a hacer una clase para ir cargando las acciones.
-Voy a cargar la propieda $actions y va a ser igual a un narray
<?php
class MP_Cargador{
public function __construct(){
$this->actions = [];
}
public function add_action($hook, $component, $callback, $priority, $accepted_args){
$this->actions = $this->add( $this->actions, $hook, $component, $callback, $priority, $accepted_args );
}
public function add($hooks, $hook, $component, $callback, $priority, $accepted_args){
$hooks[] = [
'hook' => $hook,
'component' => $component,
'callback' => $callback,
'priority' => $priority,
'accepted_args' => $accepted_args
];
}
public function run(){
foreach($this->actions as $hook){
add_action( $hook['hook'],
[ $hook['component'], $hook['callback'],
$hook['priority'],
$hook['accepted_args'] ] );
}
}
}
Lo que hace basicamente es meter en un array las acciones que le pasemos.
Vamos a hacer otra clase que es "taxonomias" y la vamos a requerir tambien, la clase la vamos a poner en el archivo "taxonomias.php" que esta en la carpeta "includes".
require_once PLUGIN_DIR_PATH . 'includes/cargador.php';
require_once PLUGIN_DIR_PATH . 'includes/taxonomia-color.php';
Ahora en taxonomias, la convertimos en una clase:
<?php
class TaxonomiaColor{
public function color(){
$post_type = ['post'];
$labels = [
'name' => 'Colores',
'singular_name' => 'Color',
'search_items' => 'Buscar Color',
'all_items' => 'Todos los colores',
'edit_item' => 'Editar Color',
'update_item' => 'Actualizar color',
'add_new_item' => 'Agregar nuevo Color',
'new_item_name' => 'Nuevo nombre del color',
'menu_name' => 'Color'
];
$args = [
'hierarchical' => true,
'labels' => $labels
];
register_taxonomy(
'color', //$taxonomy:string,
$post_type, //$object_type:array|string
$args //$args:array|string )
);
}
}
Vamos a crear ahora un OBJETO MASTER donde vamos a guardar las taxonomias, los custom post types, etc
Lo vamos a crear en "includes" -----> "mp-master.php"
Y en esta clase vamos a cargar lo que son las dependencias en una funcion, o sea las taxonomias y el cargador.
<?php
class MP_Cargador{
public function __construct(){
}
public function cargarDependencias(){
}
}
<?php
class MP_Master{
protected $plugin_dir_path;
protected $cargador;
public function __construct(){
$this->plugin_dir_path = plugin_dir_path( __FILE__ );
$this->cargarDependencias();
}
public function cargarDependencias(){
require_once $this->plugin_dir_path . 'cargador.php';
$this->cargador = new MP_Cargador;
}
public function run(){
$this->cargador->run();
}
}
-Ahora tenemos que llamar a master en el archivo principal del plugin.
require_once PLUGIN_DIR_PATH . 'includes/mp-master.php';
Ahora vamos a crear una funcion en el mismo archivo principal del plugin para instanciar a la clase cargador.
require_once PLUGIN_DIR_PATH . 'includes/mp-master.php';
function run_mp_master(){
$mp_master = new MP_Master;
$mp_master->run();
}
run_mp_master();
MODULARIZANDO LOS ENCOLAMIENTOS STYLES Y SCRIPTS
Creamos en "includes" otro archivo llamado "enqueue.php" para cargar estilos y script, en el archivo "enqueue.php":
<?php
class CargadorEstilosScripts{
private $version;
private $plugin_dir_url;
public function __construct(){
$this->version = '1.0.0';
$this->plugin_dir_url = plugin_dir_url(__FILE__);
$this->cargandoCss();
$this->cargandoScript();
}
public function cargandoCss(){
wp_enqueue_style(
'mp_styles',
$this->plugin_dir_url . 'css/admin-style.css',
array(),
$this->version,
'all'
);
}
public function cargandoScript(){
wp_enqueue_script(
'mp_scripts',
$this->plugin_dir_url . 'js/admin-app.js',
array(),
$this->version,
true
);
}
}
Y en el archivo "master.php":
<?php
class MP_Master{
protected $plugin_dir_path;
protected $cargador;
protected $taxonomia;
protected $enqueue;
public function __construct(){
$this->plugin_dir_path = plugin_dir_path( __FILE__ );
$this->cargarDependencias();
$this->definir_admin_hooks();
}
public function cargarDependencias(){
require_once $this->plugin_dir_path . 'cargador.php';
require_once $this->plugin_dir_path . 'taxonomia-color.php';
require_once $this->plugin_dir_path . 'enqueue.php';
$this->cargador = new MP_Cargador;
$this->taxonomia = new TaxonomiaColor;
$this->enqueue = new CargadorEstilosScripts;
}
//En este metodo voy a cargar las acciones
public function definir_admin_hooks(){
$this->cargador->add_action( 'init', $this->taxonomia, 'color' );
$this->cargador->add_action('admin_enqueue_scripts', $this->enqueue,
'cargandoCss');
$this->cargador->add_action('admin_enqueue_scripts', $this->enqueue,
'cargandoScript');
}
public function run(){
$this->cargador->run();
}
}
CREANDO CUSTOM POST TYPE
Vamos a crear un archivo llamado "custom_post_type.php" y lo metemos denrto de nuestra carpeta de "includes", y vamos a cerar un custom post type de carro y de producto dentro:
<?php
class CustomPostCarro{
public function carro(){
$labels = [
'name' => __('Carro', 'miidioma'),
'singular_name' => __('Carro', 'miidioma'),
'add_new' => __('Agregar nuevo'),
'add_new_item' => __('Agregar nuevo Carro')
];
$args = [
'labels' => $labels,
'public' => true,
'has_archive' => true,
'supports' => ['title', 'editor', 'thumbnail'],
'rewrite' => ['slug' => 'Carros']
];
register_post_type('carro', $args);
}
}
Y ahora lo llamamos en el archivo "master":
<?php
class MP_Master{
protected $plugin_dir_path;
protected $cargador;
protected $taxonomia;
protected $enqueue;
public function __construct(){
$this->plugin_dir_path = plugin_dir_path( __FILE__ );
$this->cargarDependencias();
$this->definir_admin_hooks();
}
public function cargarDependencias(){
require_once $this->plugin_dir_path . 'cargador.php';
require_once $this->plugin_dir_path . 'taxonomia-color.php';
require_once $this->plugin_dir_path . 'enqueue.php';
require_once $this->plugin_dir_path . 'custom_post_type.php';
$this->cargador = new MP_Cargador;
$this->taxonomia = new TaxonomiaColor;
$this->enqueue = new CargadorEstilosScripts;
$this->cpt = new CustomPostCarro;
}
//En este metodo voy a cargar las acciones
public function definir_admin_hooks(){
$this->cargador->add_action( 'init', $this->taxonomia, 'color' );
$this->cargador->add_action('admin_enqueue_scripts', $this->enqueue, 'cargandoCss');
$this->cargador->add_action('admin_enqueue_scripts', $this->enqueue, 'cargandoScript');
$this->cargador->add_action('init', $this->cpt, 'carro');
}
public function run(){
$this->cargador->run();
}
}
Ahora que tenemos creado el custom post type de carro, y que hemos agregado un par de carros, podemos crearle una taxonomia para poder ver a los coches por marca.
Entonces: vamos a crear una taxonomia que se llama "marca".
<?php
class TaxonomiaColor{
public function color(){
$post_type = ['post'];
$labels = [
'name' => 'Colores',
'singular_name' => 'Color',
'search_items' => 'Buscar Color',
'all_items' => 'Todos los colores',
'edit_item' => 'Editar Color',
'update_item' => 'Actualizar color',
'add_new_item' => 'Agregar nuevo Color',
'new_item_name' => 'Nuevo nombre del color',
'menu_name' => 'Color'
];
$args = [
'hierarchical' => true,
'labels' => $labels
];
register_taxonomy(
'color', //$taxonomy:string,
$post_type, //$object_type:array|string
$args //$args:array|string )
);
}
//Taxonomia de Marca
public function marca(){
$post_type = ['carro'];
$labels = [
'name' => 'Marcas',
'singular_name' => 'Marca',
'search_items' => 'Buscar Marca',
'all_items' => 'Todos las Marcas',
'edit_item' => 'Editar Marca',
'update_item' => 'Actualizar Marca',
'add_new_item' => 'Agregar nuevo Marca',
'new_item_name' => 'Nuevo nombre del Marca',
'menu_name' => 'Marca'
];
$args = [
'hierarchical' => true,
'labels' => $labels
];
register_taxonomy(
'marca', //$taxonomy:string,
$post_type, //$object_type:array|string
$args //$args:array|string )
);
}
}
Y nos vamos a "master.php" para incluir esta taxonomia.
$this->cargador->add_action('init', $this->taxonomia, 'marca');
PAGINA PERSONALIZADA PARA LA TAXONOMIA
Las taxonomias viene por defecto en "archive.php", vamos a crear una pagina personalizada para las taxonomia "maraca", por ejemplo.
Nos vamos a la carpeta del tema que usamos (en este caso "twenty twenty") y tenemos que crear un archivo con el prefijo "taxonomy" y el nombre que le dimos a la taxonomia creada.
"taxonomy-marca.php".
Y alli dentro creamos el Loop de Wp.
Ahora, si le quiero poner estilos voy a tener que llamar a los estilos del frontend.
FUNCIONES PARA OBTENER LOS TERMINOS DE UNA TAXONOMIA:
the_terms()
Para MOSTRAR TAXONOMIAS EN LA PAGINA:
En el archivo de "taxonomy-marca"
<?php
while(have_posts()){
the_post();?>
<h1><?php the_title(); ?></h1>
<p><?php the_terms($post->ID, 'marca'); ?></p>
<?php } ?>
o:
<p><?php the_terms($post->ID, 'marca', 'Marca: ', ' / ', '.'); ?></p>
O:
<?php
$marcas = get_the_term_list($post->ID, 'marca');
echo $marcas;
?>
AGREGANDO UN CAMPO "META" PARA LAS TAXONOMIAS.
Los datos que creemos en estos campos meta se lamacenaran en la tabla "termmeta".
Por ejemplo queremos crear un nuevo campo meta en la taxonomia para guardar el modelo
Vamos a crear un archivo llamado "meta_field_marca.php" en "includes".
<?php
class MP_Meta_field_marca{
public function add_meta_field(){
}
public function edit_meta_field($term){
}
public function save_meta_field($termId){
}
}
1- AGREGAR EN LA TAXONOMIA EL HTML DE META
<?php
class MP_Meta_field_marca{
//Html ADD
public function add_meta_field(){
$output = "
<div class='form-field'>
<label for='modelo'>Modelo</label>
<input type='text' name='modelo'>
</div>
";
echo $output;
}
public function edit_meta_field($term){
}
public function save_meta_field($termId){
}
}
Y lo cargo en Master:
//Cargando meta field de taxonomia marca
$this->cargador->add_action('marca_add_form_fields', $this->modelo,
'add_meta_field');
2- AGREGAR HTML DE FIELD PARA EDITAR
//Html EDIT
public function edit_meta_field($term){
$modelo = get_term_meta( $term->term_id, 'modelo', true ); //'modelo' es el
name del input
$modelo = isset($modelo) ? $modelo : '';
$output = "
<tr class='form-field form-required term-name-wrap'>
<th scope='row'><label for='modelo'>Modelo</label></th>
<td><input type='text' name='modelo' id='modelo' size='40' value='$modelo'>
</td>
<p class='description'>Año de modelo del término del carro</p>
</tr>";
echo $output;
}
En Master:
$this->cargador->add_action('marca_edit_form_fields', $this->modelo, 'edit_meta_field');
3- GUARDAR DATOS EN TABLA TERMMETA:
public function save_meta_field($termId){
$modelo = get_term_meta( $termId, 'modelo', true );//'modelo' es el 'name' del 'input'
if( isset($_POST['modelo']) ){
update_term_meta($termId, 'modelo', $_POST['modelo']);
}else{
delete_term_meta($termId, 'modelo', $_POST['modelo']);
}
}
En Master:
//Para guardar en BBDD: (2 acciones)
$this->cargador->add_action('create_marca', $this->marca, 'save_meta_field');
$this->cargador->acc_action('edited_marca', $this->marca, 'save_meta_field');
cs
No hay comentarios:
Publicar un comentario