Creando plugin Wordpress - 03

 11- USUARIOS

-Para crear un usuario lo mas facil desde el admin-

FUNCIONES PARA AGREGAR USUARIO:

wp_create_user( string $username, string $password, 

string $email = '' )

wp_insert_user()

FUNCIONES DE AYUDA

username_exists() / email_exists( string $email ) /

wp_generate_password()

TRAER DATOS DE USUARIO.

Para traer el usuario tengo que saber el id del usuario.

get_userdata( int $user_id )

1- FORMA BÁSICA DE CREAR USUARIO

Voy a crear un archivo en la carpeta "includes" llamado "usuario.php" y dentro voy a crera una clase:

<?php

class User{

    public function samanta_user(){

        $user_login = 'samanta';

        $user_pass  = wp_generate_password( 18, false ); //False: No caracteres especiales

        $user_email = 'samanta';

        //Validamos que no existe ese usuario

        $user_id = username_exists( $user_login );

        if( !$user_id && email_exists($user_email) === false){

            //Crear usuario y RETORNA ID

            $user_id = wp_create_user(

                $user_login,

                $user_pass,

                $user_email

            );

            //Enviar email al usuario

            //Validar con "is_wp_error"

            if(!is_wp_error($user_id)){

                wp_email( $user_email, 'Bienvenido!', "Su contraseña es $user_pass" );

            }

        }

    }

    

}

Lo llamo en Master con el hook "init":

//Crear Usuario

        $this->cargador->add_action('init', $this->user, 'samanta_user');

2-FORMA COMPLEJA DE CREAR USUARIO (ARRAY | OBJETO)

Vamos a crear un usuario pasandole un array:

public function maria_user_array(){

        $userdata = [

            'user_login' => 'maria',

            'user_pass'  => wp_generate_password( 18, false ),

            'user_email' => 'maria@maria.com',

            'first_name' => 'María',

            'last_name'  => 'Prosdócimo',

            'user_url'   => 'maria.com',

            'description'=> 'Soy una persona exitosa y muy feliz!',

            'role'       => 'editor'

        ];

        //Validamos que no exista ese usuario

        $user_id = username_exists( $userdata['user_login'] );

        if( !$user_id && email_exists($userdata['user_email']) === false ){

            $user_id = wp_insert_user( $userdata );

            //Enviar email

            wp_email( $userdata['user_email'], 'Bienvenido', 

            "Su contraseña es {$userdata['user_pass']}" );

        }

    }

Y en Master:

$this->cargador->add_action('init', $this->user, 'maria_user_array');

3- CREAR USUARIO CREANDO UNA INSTANCIA DE WP_USER

public function juan_user_wpuser(){

        $userdata = new WP_User;

        $userdata->user_login = 'Juan';

        $userdata->user_pass  = wp_generate_password( 18, false );

        $userdata->user_email = 'marias123@marias.com';

        $userdata->first_name = 'María';

        $userdata->last_name  = 'Prosdócimo';

        $userdata->user_url   = 'maria.com';

        $userdata->description= 'Soy una persona exitosa y muy feliz!';

        $userdata->role       = 'editor';

        

        //Validamos que no exista ese usuario

        $user_id = username_exists( $userdata->user_login );

        if( !$user_id && email_exists($userdata->user_email) === false ){

            $user_id = wp_insert_user( $userdata );

            //Enviar email

            //wp_email( $userdata->user_email, 'Bienvenido', "Su contraseña es {$userdata->user_pass}" );

        }

    }

En master:

$this->cargador->add_action('init', $this->user, 'juan_user_wpuser');

OBTENIENDO INFORMACION DE UN USUARIO

1- 

get_userdata( int $user_id )

$userdata = get_userdata(2);

var_dump($userdata);

2- 

get_user_by( string $field, int|string $value )

$userdata = get_user_by('ID', 4);

echo $userdata->first_name;

//O: 

$userdata = get_user_by('email', 'maria@maria.com');

echo $userdata->first_name;

3-

new WP_User( int $id )

new WP_User( string $user_login )

$userdata = new WP_User( 'Juan' );

echo '<br>' . $userdata->user_email;

4- INSTANCIA ESTÁTICA

WP_User::get_data_by( string $field, string|int $value )

//4- (Pasa solo algunos datos!)

$userdata = WP_User::get_data_by('email', 'maria@maria.com');

echo $userdata->user_email;

OBTENIENDO INFORMACION DEL USUARIO ACTUAL

El metodo NO RECIBE NINGUN PARAMETRO:

wp_get_current_user()

//5- Current User

$userdata = wp_get_current_user();

echo 'The current user is: ' . $userdata->user_login;

ACTUALIZAR USUARIOS

wp_update_user( array|object|WP_User $userdata )

//Actualizar Usuario

    public function update_user(){

        $userdata = [

            'ID' => 3,

            'first_name' => 'Samy',

            'last_name'  => 'Prosdocimo Varela'

        ];

        $user_id = wp_update_user($userdata);

        //Vlidar no hay error

        if( !is_wp_error($user_id) ){

            echo "El usuario ha sido actualizado correctamente!";

        }else{

            var_dump($user_id);

        }

    }

En Master:

//Actualizar usuario

        $this->cargador->add_action('init', $this->user, 'update_user');

ELIMINAR USUARIOS

//Eliminar Usuario

    public function delete_user(){

        require_once ABSPATH . 'wp-admin/includes/user.php';

        wp_delete_user(6);

    }

Y en Master:

//Eliminar usuario

        $this->cargador->add_action('init', $this->user, 'delete_user');

METADATOS DE USUARIO

Las funciones cambian un poco y se agregan en la TABLA "USERMETA".

FUNCIONES:

add_user_meta() | get_user_meta() | update_user_meta()

delete_user_meta()

GANCHOS PARA LOS METACAMPOS DE USUARIO:

GANCHOS PARA LOS METACAMPOS DE USUARIO

user_new_form           -> Página de agregar usuario 

user_register           -> Para guardar desde la página de agregar usuario 

show_user_profile       -> Página del perfil del usuario activo 

personal_options_update -> Guardar desde el eprfil de usuario activo 

edit_user_profile       -> Página de edición de un usuario 

edit_user_profile_update-> Guardar desde la página de edición de un usuario

Vamos a hacer un campo de metadatos, para redes sociales.

Vamos a crear en "includes" un archivo llamado "meta-social-user.php".

<?php

class MP_Social_User{ //'$social' es un array

    public function add_user_meta_fields($user){

        $social = get_user_meta( $user->ID, 'mp_social', true ); //'mp_social' es el name del input

                                                //Un array porque tiene varios fields

        if( isset($social) && is_array($social) ){

            extract($social, EXTR_OVERWRITE); //Vuelve nombres asociativos en variables

        }else{

            $facebook  = '';

            $twitter   = '';

            $instagram = '';

        }

        $output = "

        <h3>Redes Sociales</h3>

        <table class='form-table'>

            <tr class='form-required user-social-wrap'>

                <th scope='row'><label for='facebook'>Facebook</label></th>

                <td>

                    <input class='regular-text' type='text' name='mp_social[facebook]' id='facebook' size='40' value='$facebook'>

                    <p class='description'>Agrega la url de Facebook</p>

                </td>

            </tr>

            <tr class='form-required user-social-wrap'>

                <th scope='row'><label for='twitter'>Twitter</label></th>

                <td>

                    <input class='regular-text' type='text' name='mp_social[twitter]' id='twitter' size='40' value='$twitter'>

                    <p class='description'>Agrega la url de Twitter</p>

                </td>

            </tr>

            <tr class='form-required user-social-wrap'>

                <th scope='row'><label for='instagram'>Instagram</label></th>

                <td>

                    <input class='regular-text' type='text' name='mp_social[instagram]' id='instagram' size='40' value='$instagram'>

                    <p class='description'>Agrega la url de Instagram</p>

                </td>

            </tr>

        </table>

        ";

        echo $output;

    }

} 

En Master:

$this->cargador->add_action('user_new_form', $this->meta_social_user, 

'add_user_meta_fields');

AHORA!, Si me voy a "editar usuario" o al "usuario actual" voy a ver que esos campos no aparecen.

NOS FALTAN 2 GANCHOS DE ACCION POR AGREGAR

El gancho para la pagina de edicion del usuario y el gancho o hook para la pagina del usuario actual, de modo que Master quedaria asi:

//Agregar meta social media en usuario

        $this->cargador->add_action('user_new_form', $this->meta_social_user, 'add_user_meta_fields');

        $this->cargador->add_action('show_user_profile', $this->meta_social_user, 'add_user_meta_fields');

        $this->cargador->add_action('edit_user_profile', $this->meta_social_user, 'add_user_meta_fields');

-GUARDAR LA INFORMACION

Vamos  a hacer un método para guardar esa informacion:

Y siempre estos metodos de guardado nos van a pedir el id.

public function save_user_meta_fields( $user_id ){

        if( !current_user_can('edit_user') ){

            return;

        }

        //Valido si existe el POST

        if( isset( $_POST['mp_social'] ) ){

            //Antes de guardar: Desinfectar

            $_POST['mp_social']['facebook'] = sanitize_term_field( $_POST['mp_social']['facebook'] );

            $_POST['mp_social']['twitter'] = sanitize_term_field( $_POST['mp_social']['twitter'] );

            $_POST['mp_social']['instagram'] = sanitize_term_field( $_POST['mp_social']['instagram'] );

            //Funcion para guardar

            update_user_meta( $user_id, 'mp_social', $_POST['mp_social'] );

        }

    }

Y llamamos en "Master" a estos dos ganchos que nos faltan:

//Guardar meta social media en usuario

        $this->cargador->add_action('user_register', $this->meta_social_user, 'save_user_meta_fields');

        $this->cargador->add_action('personal_options_update', $this->meta_social_user, 'save_user_meta_fields');

        $this->cargador->add_action('edit_user_profile_update', $this->meta_social_user, 'save_user_meta_fields');

Se tendrian que validar las urls con expresiones regulares!.

ROLES

wp_role() --> Funcion que retorna un objeto de WP_Role

add_role() | remove_role() | get_role()

WP_Roles::add_role

-AGREGAR UN ROL

Voy a crear un archivo nuevo llamado "role.php" y lo voy a meter dentro de la carpeta "includes".

class MP_Role{

    //Agregar nuevo rol

    public function add_role(){

        $wp_roles = new WP_Roles;

        $capacidades = [

            'edit_posts'           => true,

            'edit_published_posts' => true,

            'publish_Post'         => true,

            'read'                 => true,

            'upload_files'         => true,

            'mailing_masivos'      => true

        ];

        //'mailing_masivos' es creado por nosotros

        $wp_roles->add_role(

            'rolstar', //Nombre

            'Rolstar', //Nombre público

            $capacidades

        );

        

        if(current_user_can('mailing_masivos')){

            //Mostrar toda la página de administracion

        }

    }

}

En Master:

$this->cargador->add_action('init', $this->role, 'add_role');

ELIMINAR

$wp_roles->remove_role('rolstar');

OBTENER INFORMACION DE ROL:

$rolstar = $wp_roles->get_role( 'rolstar' );

MANIPULANDO EL ROL DE UN USUARIO

Para ver los roles que tiene un usuario:

$juan = new WP_User( 5 );

var_dump($juan->roles);

Existen 2 formas de agregar un rol a un usuario:

WP_User::add_role() | WP_User::set_role()

$juan->add_role('contributor');

MOSTRAR CAPACIDADDES DE ROL:

 var_dump( $juan->allcaps );

ELIMINAR ROL:

$juan->remove_role( 'contributor' );

MANIPULANDO LAS CAPACIDADES DE UN ROL

Quiero mostrar todas las capacidades de un rol:

$wp_roles = new WP_Roles;

        $rolstar = $wp_roles->get_role( 'rolstar' );

        var_dump( $rolstar->capabilities );

ELIMINAR CAPACIDAD DE UN ROL:

 $rolstar->remove_cap('rolstar', 'mailing_masivos');

AGREGAR CAPACIDAD A UN ROL:

//AGREGAR

        $rolstar->add_cap('rolstar', 'mailing_masivos');

csd

Creando plugin Wordpress - 02

 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:

wp_enqueue_style()

wp_enqueue_script()

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()

wp_tag_cloud()

get_the_terms_list()

get_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