Share
Para muchos proyectos de WordPress en estos días usamos tipos de publicaciones personalizadas. El equipo de desarrollo de WordPress creó algunos métodos prácticos para integrarlos en sus proyectos. Pero cuando usa con frecuencia tipos de correos personalizados, taxonomías y metacuadros, es muy probable que se repita. Es por eso que vamos a utilizar el poder de estas funciones de WordPress para crear una clase más poderosa, que podemos usar para registrar rápidamente tipos de publicaciones, taxonomías y metacuadros..
Así es como llamamos a nuestra clase cuando se hace..
Accentsconagua
include ('custom-post-type.php'); $ book = new Custom_Post_Type ('Libro'); $ libro-> add_taxonomy ('categoría'); $ libro-> add_taxonomy ('autor'); $ book-> add_meta_box ('Información del libro', matriz ('Año' => 'texto', 'Género' => 'texto')); $ book-> add_meta_box ('Información del autor', matriz ('Nombre' => 'texto', 'Nacionalidad' => 'texto', 'Cumpleaños' => 'texto')); Comenzamos con la creación de la clase, propiedades principales, constructor y métodos. En este tutorial los rellenaremos con nuestra lógica de programación..
class Custom_Post_Type public $ post_type_name; public $ post_type_args; public $ post_type_labels; / * Constructor de clase * / función pública __construct () / * Método que registra el tipo de publicación * / función pública register_post_type () / * Método para adjuntar la taxonomía al tipo de publicación * / función pública add_taxonomy () / * Adjunta meta box al tipo de publicación * / public function add_meta_box () / * Escucha cuando se guarda el tipo de publicación * / public function save ()
Dentro del constructor, creamos algunas variables importantes, que se utilizan dentro de toda la clase. Tambien llamamos add_action para registrar el tipo de publicación y escuchamos cuando se guarda el tipo de publicación, por lo que podemos guardar los metadatos de nuestra publicación. Si el tipo de publicación existe, add_action no se llama, pero el $ post_type_name se establece, por lo que podemos agregar taxonomías y meta cajas a ella.
función pública __construct ($ name, $ args = array (), $ labels = array ()) // Establezca algunas variables importantes $ this-> post_type_name = strtolower (str_replace (", '_', $ name)); $ this-> post_type_args = $ args; $ this-> post_type_labels = $ labels; // Agregar acción para registrar el tipo de publicación, si el tipo de publicación aún no existe si (! post_type_exists ($ this-> post_type_name)) add_action ( 'init', array (& $ this, 'register_post_type')); // Escuche el enlace de guardado $ this-> save (); Dentro de register_post_type método, que es llamado por el add_action en el constructor, primero determinamos el nombre (en mayúsculas) y el plural. Con este nombre y plural construimos nuestras etiquetas para el tipo de publicación y las sobrescribimos (y combinamos) con las etiquetas dadas de $ this-> post_type_labels variable. Luego creamos nuestros argumentos con el mismo principio..
función pública register_post_type () // Capitilice las palabras y conviértalas en plural $ name = ucwords (str_replace ('_', ", $ this-> post_type_name)); $ plural = $ name. 's'; // Establecemos las etiquetas predeterminadas basadas en el nombre del tipo de publicación y el plural. Las sobrescribimos con las etiquetas proporcionadas. $ labels = array_merge (// Matriz predeterminada ('name' => _x ($ plural, 'post type general name'), 'singular_name '=> _x ($ name,' post tipo nombre singular '),' add_new '=> _x (' Add New ', strtolower ($ name)),' add_new_item '=> __ (' Add New '. $ name) , 'edit_item' => __ ('Edit'. $ name), 'new_item' => __ ('New'. $ name), 'all_items' => __ ('All'. $ plural), 'view_item' = > __ ('Ver'. $ Nombre), 'search_items' => __ ('Buscar'. $ Plural), 'not_found' => __ ('No'. Strtolower ($ plural). 'Found'), 'not_found_in_trash '=> __ (' No '. Strtolower ($ plural).' Found in Trash '),' parent_item_colon '=> ",' menu_name '=> $ plural), // Etiquetas dadas $ this-> post_type_labels); // El mismo principio que las etiquetas. Establecemos algunos valores predeterminados y los sobrescribimos con los argumentos dados. $ args = array_merge (// matriz predeterminada ('label' => $ plural, 'labels' => $ labels, 'public' => true, 'show_ui' => true, 'support' => array ('title' , 'editor'), 'show_in_nav_menus' => true, '_builtin' => false,), // Dado args $ this-> post_type_args); // Registre el tipo de entrada register_post_type ($ this-> post_type_name, $ args); Primero comprobamos si el $ nombre El parámetro está vacío. Cuando lo es, no hacemos nada. Cuando no lo está, creamos tres variables en las que almacenamos la información para la taxonomía: $ taxonomy_name, $ taxonomy_labels y $ taxonomy_args.
función pública add_taxonomy ($ name, $ args = array (), $ labels = array ()) if (! empty ($ name)) // Necesitamos saber el nombre del tipo de publicación, para poder adjuntar la nueva taxonomía lo. $ post_type_name = $ this-> post_type_name; // Propiedades de taxonomía $ taxonomy_name = strtolower (str_replace (", '_', $ name)); $ taxonomy_labels = $ labels; $ taxonomy_args = $ args; / * Más código viene * / Después de realizar las primeras comprobaciones y luego establecer algunas variables, vamos a registrar el tipo de publicación. Pero primero comprobamos si la taxonomía ya existe..
if (! taxonomy_exists ($ taxonomy_name)) / * Cree una taxonomía y adjúntela al tipo de objeto (tipo de publicación) * / else / * La taxonomía ya existe. Vamos a adjuntar la taxonomía existente al tipo de objeto (tipo de publicación) * /
Si la taxonomía no existe, la registramos. Usamos un add_action, Pero no en la forma normal. Normalmente, el segundo parámetro de la add_action es el nombre de una función, pero ya que usamos diferentes parámetros cada vez, vamos a pasar una función sin nombre (Nota: esta característica requiere PHP 5.3+) y usar el utilizar() función. Con el utilizar() Función podemos pasar variables a la función sin nombre. Esta vez tenemos que pasar $ taxonomy_name, $ post_type_name y $ taxonomy_args registrar la taxonomia.
// Capitilice las palabras y conviértalo en plural $ name = ucwords (str_replace ('_', ", $ name)); $ plural = $ name. 'S'; // Etiquetas predeterminadas, sobrescriba con las etiquetas dadas. $ labels = array_merge (// Array predeterminado ('nombre' => _x ($ plural, 'nombre general de taxonomía'), 'nombre_ singular' => _x ($ nombre, 'nombre singular de taxonomía'), 'search_items' => __ ( 'Buscar'. $ Plural), 'all_items' => __ ('Todos'. $ Plural), 'parent_item' => __ ('Parent'. $ Name), 'parent_item_colon' => __ ('Parent'. $ name. ':'), 'edit_item' => __ ('Edit'. $ name), 'update_item' => __ ('Update'. $ name), 'add_new_item' => __ ('Add New'. $ name), 'new_item_name' => __ ('New'. $ name. 'Name'), 'menu_name' => __ ($ name),), // Etiquetas asignadas $ taxonomy_labels); // Argumentos predeterminados, sobrescritos con los argumentos dados $ args = array_merge (// matriz predeterminada ('label' => $ plural, 'labels' => $ labels, 'public' => true, 'show_ui' => true, 'show_in_nav_menus' => true, '_builtin' => false,), // Given $ taxonomy_args); // Agregue la taxonomía al tipo de publicación add_action ('init', function () use ($ taxonomy_name, $ post_type_name, $ args) register_taxonomy ($ taxonomy_name, $ post_type_name, $ args); ); Cuando la taxonomía no existe, solo la adjuntamos a nuestro tipo de publicación. Al igual que antes, utilizamos una función sin nombre y la utilizar() función. Esta vez solo tenemos que pasar. $ taxonomy_name y $ post_type_name.
add_action ('init', function () use ($ taxonomy_name, $ post_type_name) register_taxonomy_for_object_type ($ taxonomy_name, $ post_type_name);); Para registrar meta box, necesitamos el nombre del tipo de publicación, así que primero lo determinamos. Después de eso necesitamos algunas variables para el meta box en sí y hacemos que los metacampos personalizados sean globales, por lo que podemos acceder a ellos en el enlace de guardar. No cubriremos demasiados detalles aquí, porque Tammy Hart ya hizo un tutorial muy útil acerca de las meta box reutilizables.
función pública add_meta_box ($ title, $ fields = array (), $ context = 'normal', $ priority = 'default') if (! empty ($ title)) // Necesitamos saber el nombre del tipo de publicación nuevamente $ post_type_name = $ this-> post_type_name; // Meta variables $ box_id = strtolower (str_replace (", '_', $ title)); $ box_title = ucwords (str_replace ('_',", $ title)); $ box_context = $ context; $ box_priority = $ prioridad; // Hacer los campos globales globales $ custom_fields; $ custom_fields [$ title] = $ fields; / * Más código viene * / Cuando configuramos las variables y las variables globales, registramos el cuadro de meta con un add_action. Como antes, usamos una función sin nombre. Esta vez necesitamos $ box_id, $ box_title, $ post_type_name, $ box_context, $ box_priority y $ campos.
add_action ('admin_init', function () use ($ box_id, $ box_title, $ post_type_name, $ box_context, $ box_priority, $ fields) add_meta_box ($ box_id, $ box_title, function ($ post, $ data) global $ post ; // Campo Nonce para alguna validación wp_nonce_field (plugin_basename (__FILE__), 'custom_post_type'); // Obtenga todas las entradas de $ data $ custom_fields = $ data ['args'] [0]; // Obtenga los valores guardados $ meta = get_post_custom ($ post-> ID); // Revise la matriz y realice un ciclo a través de ella si (! empty ($ custom_fields)) / * Recorra $ custom_fields * / foreach ($ custom_fields as $ label => $ type) $ field_id_name = strtolower (str_replace (", '_', $ data ['id'])). '_'. strtolower (str_replace (", '_', $ label)); echo ''; , $ post_type_name, $ box_context, $ box_priority, array ($ fields)); ); Guardar todos los metadatos de la publicación. Recorremos por ellas, utilizando el global. $ custom_fields. Esta también es una cobertura rápida, consulte el tutorial de Tammy Hart sobre las meta box reutilizables..
función pública save () // Necesita el nombre del tipo de publicación nuevamente $ post_type_name = $ this-> post_type_name; add_action ('save_post', function () use ($ post_type_name) // Denegar la función de guardado automático de WordPress si (definido ('DOING_AUTOSAVE') && DOING_AUTOSAVE) return '; __FILE__))) return; global $ post; if (isset ($ _POST) && isset ($ post-> ID) && get_post_type ($ post-> ID) == $ post_type_name) global $ custom_fields; // Recorra cada uno de ellos meta box foreach ($ custom_fields as $ title => $ fields) // Recorra todos los campos foreach ($ fields como $ label => $ type) $ field_id_name = strtolower (str_replace (", '_', $ title) ). '_'. strtolower (str_replace (", '_', $ label)); update_post_meta ($ post-> ID, $ field_id_name, $ _POST ['custom_meta'] [$ field_id_name]);) ; Como puedes ver usamos strtolower (str_replace (", '_', $ string)) y ucwords (str_replace ('_', ", $ string)) un número de veces. La razón para crear esta clase es que no nos repetimos, por lo que tampoco queremos hacer eso en esta parte. Es por eso que creamos algunos métodos de ayuda. De esta manera podemos hacer esto: $ name = self :: beautify ($ string); en lugar de $ name = strtolower (str_replace (", '_', $ title));
función estática pública beautify ($ string) return ucwords (str_replace ('_', ", $ string)); función estática pública uglify ($ string) return strtolower (str_replace (", '_', $ string)) ; Otro punto son las formas plurales que creamos. Simplemente los creamos agregando una 's' a la palabra. Pero, ¿qué pasa cuando la palabra termina con una 'y'? Por esta razón, creamos un método auxiliar para determinar la forma plural de una palabra. Ahora podemos hacer esto fácilmente: $ plural = self :: pluralize ($ string) y la forma plural de nuestra palabra será determinada..
función estática pública pluralize ($ string) $ last = $ string [strlen ($ string) - 1]; if ($ last == 'y') $ cut = substr ($ string, 0, -1); // convertir y a ies $ plural = $ cortar. 'ies'; else // simplemente adjunte una s $ plural = $ cadena. 's'; devolver $ plural;
Y ahora hemos terminado. Ahora puede usar esta clase para registrar fácilmente tipos de correos, taxonomías y meta box. Si tiene alguna sugerencia o pregunta, simplemente deje un comentario para que podamos hablar sobre ello. Espero verte la próxima vez!
Además, me gustaría darle un poco de crédito a Jeffrey Way. Utilicé su clase como inspiración para mi clase y para este tutorial. También, me gustaría darle un poco de crédito a Tammy Hart, por construir el tutorial de meta boxes reutilizables. Echa un vistazo a su trabajo..
