Aldolat.it — Post con tag Guide Su WordPress

Aggiungere un menu di gestione rapida in WordPress

aldolat@gmail.com (Aldo Latino) — Sun, 17 Nov 2019 08:51:40 +0000

Quando ci capita di dover andare di continuo tra il front-end e alcune pagine di amministrazione del sito fatto con WordPress, che si trovano magari in sottomenu di qualche menu principale, ecco che tornerebbe utile avere nella barra degli strumenti, quella che sta in cima alle varie pagine, i collegamenti che ci servono di più. Nella figura qui sotto vedete il menu Gestione rapida, con alcune voci di più comune utilizzo.

Il menu Gestione rapida aggiunto alla barra del menu principale di WordPress.

WordPress ci consente di farlo grazie alle sue API. Come al solito, sarà necessario aggiungere una funzione al file functions.php del tema attualmente in uso (metodo sconsigliato) oppure al nostro plugin personalizzato (metodo consigliato), dove raccogliamo tutte le modifiche che ci servono anche quando cambiamo tema.

Ecco la funzione:

 1/**
 2 * Add a custom menu to the WordPress toolbar.
 3 *
 4 * @param object WP_Admin_Bar $admin_bar Core class used to implement the Toolbar API.
 5 */
 6function add_items_to_wordpress_toolbar( WP_Admin_Bar $admin_bar ) {
 7    // Stop the function if the current user cannot manage options.
 8    if ( ! current_user_can( 'manage_options' ) ) {
 9        return;
10    }
11 
12    // Create the root menu.
13    $admin_bar->add_menu(
14        array(
15            'id'    => 'rapid-management',
16            'title' => esc_html__( 'Rapid Management', 'text-domain' ),
17            'href'  => admin_url( '#' ),
18            'meta'  => array(
19                'title'  => esc_html__( 'Rapid Management', 'text-domain' ),
20                'target' => '_self',
21                'class'  => 'rm-root-menu',
22            ),
23        )
24    );
25 
26    // Add the first menu item.
27    $admin_bar->add_menu(
28        array(
29            'id'     => 'rapid-management-posts',
30            'parent' => 'rapid-management',
31            'title'  => esc_html__( 'Posts', 'text-domain' ),
32            'href'   => admin_url( 'edit.php' ),
33            'meta'   => array(
34                'title'  => __( 'Edit posts', 'text-domain' ),
35                'target' => '_self',
36                'class'  => 'rm-posts',
37            ),
38        )
39    );
40 
41    // Add the second menu item.
42    $admin_bar->add_menu(
43        array(
44            'id'     => 'rapid-management-pages',
45            'parent' => 'rapid-management',
46            'title'  => esc_html__( 'Pages', 'text-domain' ),
47            'href'   => admin_url( 'edit.php?post_type=page' ),
48            'meta'   => array(
49                'title'  => esc_html__( 'Edit pages', 'text-domain' ),
50                'target' => '_self',
51                'class'  => 'rm-pages',
52            ),
53        )
54    );
55 
56    // Add other items here...
57}
58 
59add_action( 'admin_bar_menu', 'add_items_to_wordpress_toolbar', 100 );

Potete aggiungere tutti i link che volete al posto della riga // Add other items here.... Vanno chiaramente adattate le righe, modificando ID, title, ecc.

L'articolo Aggiungere un menu di gestione rapida in WordPress è uno scritto di aldolat.it. Rispettane le condizioni di licenza.

WordPress e l’attributo rel del tag HTML link

aldolat@gmail.com (Aldo Latino) — Sat, 05 Jan 2019 21:13:53 +0000

Mentre stavo leggendo quali sono i meta tag HTML considerati da Google nell’indicizzazione delle pagine, mi sono imbattuto nell’articolo correlato Indicare a Google i contenuti suddivisi in più pagine. Siccome ho qualche articolo suddiviso in più pagine, come questo, ho voluto verificare se e come sono inseriti questi tag nel codice.

E ho notato qualcosa di strano.

Un ripasso veloce

L’attributo rel="next" e rel="prev" per il tag HTML <link> inserito nel tag <head> va usato per indicare che la pagina che si sta leggendo fa parte di un articolo unico suddiviso in più pagine. Il W3C definisce next così:

The next keyword indicates that the document is part of a sequence, and that the link is leading to the document that is the next logical document in the sequence.

W3C, Link type “next”.

mentre per prev dice:

The prev keyword indicates that the document is part of a sequence, and that the link is leading to the document that is the previous logical document in the sequence.

W3c, Link type “prev”.

Per cui, se un articolo è suddiviso in 5 parti e stiamo leggendo la pagina 1 della serie, il tag <link> sarà così:

<link rel="next" href="http://www.example.com/parte-2" />

mentre nella pagina 2 avremo:

<link rel="prev" href="http://www.example.com/parte-1" /> <link rel="next" href="http://www.example.com/parte-3" />

e nell’ultima:

<link rel="prev" href="http://www.example.com/parte-4" />

Cosa ho notato

E veniamo ora al punto. Ho scoperto che WordPress non usa in modo corretto questo attributo, in quanto lo usa per indicare il post precedente e il post successivo a quello che si sta leggendo. Ad ogni modo è possibile intervenire per ripristinare l’uso corretto del tag <link>.

Non ho verificato se esiste un ticket su questa cosa, ma comunque ho cercato se qualcuno si fosse già accorto del problema. Tra i risultati vi segnalo questo post, da cui ho tratto ispirazione per il mio articolo e in parte per la funzione che vi propongo sotto. Vi voglio evidenziare questo passaggio di quanto scrive l’autore:

Currently (version 4.2.2), wordpress already adds a rel=“prev” and rel=“next” tag to single posts, but these tags are added to all posts irrespective of whether they have pagination or not. And oddly enough, the pages that have pagination do not have these tags. Having these tags on non-paginated posts makes little to no sense from the SEO perspective and it only serves as additional clutter you can get rid of.

Mukesh M, Adding Rel=“Next” And Rel=“Prev” Tags To Paginated Single Posts (Using NextPage Tag).

Rimozione del tag <link> di WordPress

Se avete un plugin personale con le funzioni che vi trascinate dietro anche quanto cambiate tema, inserite la seguente riga:

remove_action( 'wp_head', 'adjacent_posts_rel_link_wp_head', 10, 0 );

Se non avete questo tipo di plugin, inseritela nel file functions.php del tema in uso.

Aggiunta del tag <link> corretto

Aggiungiamo ora la funzione che utilizza in modo corretto il tag <link> e il suo attributo rel="next" e rel="prev" solo quando il post o la pagina sono suddivisi in più pezzi.

Aggiungete le righe seguenti al plugin personale o al file functions.php del tema. Il codice è abbastanza commentato.

 1/**
 2 * Prints the HTML tags link rel prev and next in the header.
 3 *
 4 * The attributes prev and next for the HTML tags link in the header
 5 * must be used when an article in divided into multiple pieces, so that the
 6 * first page has a link tag to the second part, the second page has a link
 7 * to the previous part and to the following part, the last page has a link
 8 * to the previous part.
 9 *
10 * WordPress uses incorrectly these tags to link the current post to the previous
11 * and the following posts, as if all the published posts belong to a single big article.
12 *
13 * @link https://support.google.com/webmasters/answer/1663744?hl=it&ref_topic=4617741
14 * @global object $wp_query The WP_Query object.
15 */
16function add_link_tag_header() {
17    // Get the global variable $wp_query, which will be used later.
18    global $wp_query;
19
20    // Figure out if we have a paginated post/page and count them.
21    $total_pages = count( explode( '<!--nextpage-->', $wp_query->post->post_content ) );
22
23    // If we are in a post/page and the total number of pages is greater than 1.
24    if ( is_singular() && 1 < $total_pages ) {
25        // Get the current number of page.
26        $current_page = intval( get_query_var( 'page' ) );
27
28        // If we are in the first page, change the number to 1 (in an array, the first element has number = 0).
29        if ( 0 === $current_page ) {
30            $current_page = 1;
31        }
32
33        echo "\n\n" . '<!-- Function: add_link_tag_header() -->' . "\n";
34
35        // Add prev HTML link tag.
36        if ( $current_page > 1 && $current_page <= $total_pages ) {
37            echo '<link rel="prev" href="' . esc_url( trailingslashit( get_permalink() . ( $current_page - 1 ) ) ) . '" />' . "\n";
38        }
39
40        // Add next HTML link tag.
41        if ( $current_page >= 1 && $current_page < $total_pages ) {
42            echo '<link rel="next" href="' . esc_url( trailingslashit( get_permalink() . ( $current_page + 1 ) ) ) . '" />' . "\n";
43        }
44
45        echo '<!-- Function: add_link_tag_header() -->' . "\n\n";
46    }
47}
48add_action( 'wp_head', 'add_link_tag_header' );</code>

Una volta messa in opera la modifica, alla pagina 6 di un articolo di 10 pagine avremo all’interno dal tag <head> qualcosa di questo tipo:

<!-- Function: add_link_tag_header() -->
<link rel="prev" href="https://www.example.com/titolo-del-post/5/" />
<link rel="next" href="https://www.example.com/titolo-del-post/7/" />
<!-- Function: add_link_tag_header() -->

Tutto questo in attesa che gli sviluppatori di WordPress sistemino la cosa.

L'articolo WordPress e l’attributo rel del tag HTML link è uno scritto di aldolat.it. Rispettane le condizioni di licenza.

Segnalare un articolo vecchio in modo automatico /2

aldolat@gmail.com (Aldo Latino) — Sun, 18 Dec 2016 21:52:52 +0000

Vi pubblico una versione aggiornata della funzione per controllare l’età di un post e visualizzare un messaggio. Ne parlai tanti anni fa e, mentre stavo facendo ordine tra i miei script, ci ho voluto mettere mano. Da tempo ne conservo una copia su Gist, che oggi ho aggiornato.

Ecco la funzione:

  1/**
  2 * Check if a post is older than a certain date and, if so, returns a message.
  3 * The message can also be triggered under certain taxonomies.
  4 * In addition posts that have certain taxonomies could ever be excluded.
  5 * The message can be displayed only on single posts.
  6 *
  7 * @param array $args {
  8 *    The options for the function.
  9 *
 10 *    @type string           $time             The time unit where to calculate the age of the post.
 11 *                                             Default 'year'.
 12 *                                             Accepts 'month', 'week', 'day', 'hour', 'minute'.
 13 *    @type integer          $max_quantity     The maximum value for the age of the post.
 14 *    @type string           $taxonomy_include The name of the taxonomy under which the message is triggered.
 15 *                                             Default empty.
 16 *                                             Accepts any taxonomy name.
 17 *    @type string|int|array $term_include     The term name/term_id/slug or array of them to check for.
 18 *    @type string           $taxonomy_exclude The name of the taxonomy under which the message is not triggered.
 19 *    @type string|int|array $term_exclude     The term name/term_id/slug or array of them to check for.
 20 *    @type bool             $on_single_only   Whether the function should be executed only on single posts.
 21 *    @type string           $message          The message to be displayed.
 22 *                                             The string must contain '%s' in order to display the number (1 year, 5 months, ecc.).
 23 * }
 24 *
 25 * @example We want to display an alert message only
 26 *    - on technical posts that have the category 'Tech Ninja' and/or the category 'Computer Experts';
 27 *    - older than 6 months ago;
 28 *    - but we do not want the message on those posts that have the tag 'Featured' and/or the tag 'Premium Post'.
 29 *    - Also the message must be displayed on single posts only.
 30 *    In this case, here how to call the function:
 31 *    $args = array(
 32 *       'time'             => 'month',
 33 *       'max_quantity'     => 6,
 34 *       'taxonomy_include' => 'category',
 35 *       'term_include'     => array( 'Tech Ninja', 'Computer Experts' ),
 36 *       'taxonomy_exclude' => 'post_tag',
 37 *       'term_exclude'     => array( 'Featured', 'Premium post' ),
 38 *       'on_single_only'   => true,
 39 *       'message'          => 'This is a technical post of %s ago. Instructions could not be valid anymore.'
 40 *    );
 41 *    check_post_age( $args );
 42 *
 43 * @return string A HTML P element with a notice.
 44 */
 45function check_post_age( $args ) {
 46    $defaults = array(
 47        'time'             => 'year',
 48        'max_quantity'     => 1,
 49        'taxonomy_include' => '',
 50        'term_include'     => '',
 51        'taxonomy_exclude' => '',
 52        'term_exclude'     => '',
 53        'on_single_only'   => true,
 54        'message'          => __( 'This post is obsolete! It was written %s ago.', 'my-translation-domain')
 55    );
 56    $args = wp_parse_args( $args, $defaults );
 57    extract( $args, EXTR_SKIP );
 58
 59    /*
 60     * Check if on single posts we have to hide the message and make sure we are on a single post.
 61     * Otherwise stop the function.
 62     */
 63    if ( $on_single_only && ! is_single() )
 64        return;
 65
 66    // Let's define $diff_time, the difference in seconds between today and the time of the post.
 67    global $post;
 68    $today = current_time( 'timestamp' );
 69    $post_time = get_the_time( 'U', $post->ID );
 70    $diff_time = $today - $post_time;
 71
 72    // Make sure $max_quantity is a non-negative integer.
 73    $max_quantity = absint( $max_quantity );
 74
 75    // Lets define $limit_time, the time beyond which the message is triggered.
 76    switch ( $time ) :
 77        case 'year' :
 78            $limit_time = YEAR_IN_SECONDS * $max_quantity;
 79        break;
 80        case 'month' :
 81            $limit_time = 30 * DAY_IN_SECONDS * $max_quantity;
 82        break;
 83        case 'week' :
 84            $limit_time = WEEK_IN_SECONDS * $max_quantity;
 85        break;
 86        case 'day' :
 87            $limit_time = DAY_IN_SECONDS * $max_quantity;
 88        break;
 89        case 'hour' :
 90            $limit_time = HOUR_IN_SECONDS * $max_quantity;
 91        break;
 92        case 'minute' :
 93            $limit_time = MINUTE_IN_SECONDS * $max_quantity;
 94        break;
 95    endswitch;
 96
 97    $output = '';
 98
 99    // Check if the age of the post is beyond the limit time.
100    if ( $diff_time > $limit_time ) {
101        /*
102         * Check these conditions:
103         *      1. if $taxonomy_include is empty OR the post has the specified taxonomy
104         *      2. AND the post has not the specified taxonomy.
105         *
106         * The function empty( $taxonomy_include ) triggers the notice in case we do not specify any taxonomy,
107         * for example if we want that all posts older that the limit time should trigger the notice.
108         */
109        if ( ( empty( $taxonomy_include ) || has_term( $term_include, $taxonomy_include, $post->ID ) ) && ! has_term( $term_exclude, $taxonomy_exclude, $post->ID ) ) {
110            $message = sprintf( $message, human_time_diff( $post_time, $today ) );
111            $output .= "\n" . '<!--googleoff: all-->' . "\n";
112            $output .= '<p class="obsolete-post-warning">' . $message . '</p>' . "\n";
113            $output .= '<!--googleon: all-->' . "\n\n";
114        }
115    }
116
117    return $output;
118}

Rispetto al post di tanti anni fa, la funzione è ora unica. Utilizzata così com’è, visualizza l’avviso su qualunque post più vecchio di un anno fa e va richiamata in questo modo:

1function check_this_post_age( $content ) {
2    $args = array();
3    $content = check_post_age( $args ) . $content;
4    return $content;
5}
6add_filter( 'the_content', 'check_this_post_age' );

Qualora si voglia visualizzare il messaggio solo su determinati post su cui è bene avvisare l’utente (ad esempio su post più tecnici che possano essere diventati obsoleti), questi i parametri da personalizzare:

 1function check_this_post_age( $content ) {
 2    $args = array(
 3        'time'             => 'year',
 4        'max_quantity'     => 1,
 5        'taxonomy_include' => 'category',
 6        'term_include'     => array( 'Tech Ninja', 'Wi-Fi Stereo' ),
 7        'taxonomy_exclude' => 'post_tag',
 8        'term_exclude'     => array( 'Safe Tag', 'Save my post' ),
 9        'on_single_only'   => true,
10        'message'          => 'This is a technical post I wrote %s ago. Be careful and test everything!',
11     );
12    $content = check_post_age( $args ) . $content;
13    return $content;
14}
15add_filter( 'the_content', 'check_this_post_age' );

In questo caso, l’avviso sarà mostrato se il post ha una certa età (1 anno) e se appartiene alla categoria «Tech Ninja» e/o «Wi-Fi Stereo». Se però il post ha il tag «Safe Tag» e/o «Save my post» il messaggio non sarà visualizzato. Il messaggio, inoltre, viene visualizzato solo sul post singolo e non sulla pagina degli archivi o sulla pagina indice. Qualora lo si voglia anche in questi casi, basta dichiarare false il parametro on_single_only.

Il parametro message restituisce il messaggio, appunto, e se contiene la stringa %s essa verrà sostituita dalla quantità di tempo trascorsa.

Alcuni esempi di applicazione di questa funzione possono essere visti in questo articolo (un post tecnico, pubblicato più di un anno fa) e in quest’altro articolo (un post tecnico con un tag che evita l’apparizione del messaggio di avviso).

Un’ultima annotazione. Quel  e  dice al motore di ricerca di Google di non indicizzare il blocco di testo che ci sta in mezzo, altrimenti nei risultati di ricerca si vedrà sempre il testo «Questo è un post tecnico ecc…», laddove Google in genere mostra lo snippet del testo. Qui si trovano per maggiori informazioni.

L'articolo Segnalare un articolo vecchio in modo automatico /2 è uno scritto di aldolat.it. Rispettane le condizioni di licenza.

Crearsi un plugin per le funzioni personalizzate

aldolat@gmail.com (Aldo Latino) — Sat, 21 Apr 2012 13:14:43 +0000

Ricorderete che nel mio post precedente consigliavo di aggiungere una funzione personalizzata in un plugin apposito, destinato a raccogliere tutte le funzioni che volete aggiungere al vostro blog. Dovrete creare da voi stessi questo plugin e non è per nulla difficile. In questo modo, quando vorrete aggiungere una nuova funzione globale del blog (per “globale” intendo che non sia legata specificamente al tema che state usando), vi basterà aggiungerla in coda alle altre e sarà subito disponibile. In aggiunta, se cambiate tema, le funzioni saranno sempre disponibili e, se dovete disattivarle, vi basterà disattivare il plugin.

Vediamo come si fa.

Il file principale

Create una cartella sul vostro PC e datele il nome che più vi aggrada, ad esempio “funzioni-mio-blog”, senza usare spazi. Al suo interno create un file di testo, utilizzando un editor di testo puro, e chiamatelo ad esempio funzioni-mio-blog.php.

All’interno di questo file incollate l’intestazione del plugin, ad esempio:

<?php
/*
  Plugin Name: Le funzioni del mio blog
  Description:  Contiene le funzioni personalizzate del mio blog.
  Plugin URI: http://www.example.com/wordpress/wordpress-plugins/funzioni-mio-blog/
  Author: Mio Nome
  Author URI: http://www.example.com/
  Version: 1.0
  License: GPLv3 or later
*/

Questa intestazione serve a WordPress per capire che si tratta di un plugin e che deve trattarlo in quanto tale. L’unica riga veramente necessaria è solo quella del “Plugin Name”, ma le altre sono altamente raccomandate.

A seguire potete inserire la vostra prima funzione. Ad esempio, questa:

 1function get_archive_count() {
 2    // Ci servono queste due variabili globali
 3    global $wp_query, $paged;
 4
 5    // Preleviamo il numero di post trovati
 6    $arc_count = $wp_query->found_posts;
 7
 8    // Se ci sono più pagine
 9    if ( $arc_count > get_option( 'posts_per_page' ) ) {
10        // Se siamo sulla prima pagina impostiamo il valore a 1
11        if( $paged == 0 ) $paged = 1; // La prima pagina di una serie ha valore 0;
12        // Stampiamo la riga con il numero di pagine
13        $output = sprintf( __( '%1$s posts &amp;mdash; page %2$s of %3$s', 'my-plugin' ), $arc_count, $paged, $wp_query->max_num_pages );
14    // Altrimenti, se c'è una sola pagina
15    } else {
16        // Stampiamo la riga senza il numero di pagine
17        $output = sprintf( _n( '%s post', '%s posts', $arc_count, 'my-plugin'), number_format_i18n( $arc_count ) );
18    }
19
20    // Restituiamo l'output
21    return $output;
22}

È la funzione di cui vi parlavo nel mio precedente post. Dopo la chiusura della funzione (cioè l’ultima parentesi graffa), andate a capo (anche più volte per distanziare visivamente le funzioni tra loro) e potete incollare tutte quelle che desiderate. Ricordate che ogni funzione è definita in questo modo:

function nome_funzione() {
  // contenuto della funzione
}

I commenti possono essere di due tipi:

a riga singola, preceduti dal doppio slash (//);
a righe multiple, aperti da slash-asterisco (/*) e chiusi da asterisco-slash (*/).

Ad esempio:

 1function nome_funzione() {
 2  // Recuperiamo la variabile globale $wp_query
 3  global $wp_query;
 4
 5  /* Stampiamo una informazione
 6     del post
 7     che ci interessa
 8  */
 9  echo '<p class="post-info">' . get_post_meta( $wp_query->post->ID, 'post_info', true ) . '</p>';
10}

Commentare le varie righe di codice è molto utile non solo per chi legge il vostro codice, ma anche per voi stessi se, a distanza di tempo, lo riprendete e non ricordate esattamente a che serve quella riga o perché l’avete messa lì.

Una volta che avrete inserito tutte le funzioni che vi servono, caricate via FTP la directory del plugin /wp-content/plugins/ oppure comprimetela in formato .zip e caricatela dal pannello di amministrazione di WordPress e attivate il plugin.

Questo è in sostanza quello che serve di base per farvi questo plugin personalizzato. Visto che il plugin, per sua natura, non va condiviso con altri perché contiene funzioni che servono solo a voi, non è necessario seguire le altre indicazioni che il Codex chiede, come ad esempio la creazione del file readme.txt, un file fondamentale se si vuole pubblicare il plugin sul repository di WordPress. Il senso di questo articolo non è infatti la pubblicazione di questo particolare plugin, ma quello di poterselo creare da sé e di non perdersi le funzioni che ci piacerebbe tenere ad ogni cambio di tema.

Spezzare il plugin in più file

Se il plugin cresce e sta diventando pieno di funzioni, potrebbe essere utile organizzarlo in maniera più razionale, in modo da trovare subito le funzioni che stiamo cercando.

Il plugin che mi sono creato è organizzato così:

file principale
  |--> inc/filtri.php
  |--> inc/funzioni.php
  |--> inc/widgets.php
  |--> inc/shortcodes-docs.php
  |--> e così via...

In altre parole, nella directory principale del plugin c’è solo il file principale mentre nella sotto directory inc/ ci sono diversi file, dove ognuno di essi contiene funzioni in base alla loro natura, come si intuisce dai nomi del file.

Il file principale è costituito da queste righe:

 1<?php
 2/*
 3  Plugin Name: Le funzioni del mio blog
 4  Description:  Contiene le funzioni personalizzate del mio blog.
 5  Plugin URI: http://www.example.com/wordpress/wordpress-plugins/funzioni-mio-blog/
 6  Author: Mio Nome
 7  Author URI: http://www.example.com/
 8  Version: 1.0
 9  License: GPLv3 or later
10*/
11
12include_once 'inc/filtri.php';
13include_once 'inc/funzioni.php';
14include_once 'inc/widgets.php';
15include_once 'inc/shortcodes-docs.php';
16// e così via...

Per ogni file da caricare si inserisce una riga di include_once. I file da caricare contengono soltanto le funzioni, senza altre specifiche particolari.

L'articolo Crearsi un plugin per le funzioni personalizzate è uno scritto di aldolat.it. Rispettane le condizioni di licenza.

Visualizzare il numero di post trovati in un archivio o una ricerca

aldolat@gmail.com (Aldo Latino) — Wed, 18 Apr 2012 20:03:26 +0000

Restando ancora in tema di variabili di WordPress relative alle pagine, vorrei spendere una parola su una funzionalità che mi piace quando navigo in un archivio, quella cioè di sapere quanti post sono stati trovati se consulto l’archivio di un tag o di una categoria o se effettuo una ricerca. Questa funzionalità è implementata da tempo, ovviamente, in questo blog: ad esempio la trovate se cercate “Linux” o se visitate questa pagina d’archivio. Mi sembra, tra l’altro, un piccolo servizio in più per chi visita il nostro blog.

Implementare questa funzionalità è semplice e basta incollare poche righe nel proprio plugin contenente tutte le funzioni personalizzate o, al limite, nel file functions.php del proprio tema. Evitate, però, di usare questo file, perché esso serve per quelle caratteristiche proprie del tema: se lo cambiate, perdete le funzioni che vorreste avere anche nel nuovo.

La funzione

La funzione che ci serve consta di pochissime righe:

 1function get_archive_count() {
 2    // Ci servono queste due variabili globali
 3    global $wp_query, $paged;
 4
 5    // Preleviamo il numero di post trovati
 6    $arc_count = $wp_query->found_posts;
 7
 8    // Se ci sono più pagine
 9    if ( $arc_count > get_option( 'posts_per_page' ) ) {
10        // Se siamo sulla prima pagina impostiamo il valore a 1
11        if( $paged == 0 ) $paged = 1; // La prima pagina di una serie ha valore 0;
12        // Stampiamo la riga con il numero di pagine
13        $output = sprintf( __( '%1$s posts &mdash; page %2$s of %3$s', 'my-plugin' ), $arc_count, $paged, $wp_query->max_num_pages );
14    // Altrimenti, se c'è una sola pagina
15    } else {
16        // Stampiamo la riga senza il numero di pagine
17        $output = sprintf( _n( '%s post', '%s posts', $arc_count, 'my-plugin'), number_format_i18n( $arc_count ) );
18    }
19
20    // Restituiamo l'output
21    return $output;
22}

Per usarla è sufficiente che nel punto preferito del proprio tema si incolli questa chiamata:

echo get_archive_count();

o magari anche:

echo '<p>' . get_archive_count() . '</p>';

La logica di funzionamento è la seguente: se ci troviamo con più pagine da mostrare, l’output della funzione dovrà visualizzare sia il numero di post trovati che il numero di pagina che stiamo vedendo; altrimenti mostrerà solo il numero dei post. In altre parole, se abbiamo più pagine, vogliamo vedere qualcosa del genere: “58 articoli — Pagina 3 di 6”; altrimenti basta solo “8 articoli”, nel caso di pochi post.

Il codice mi sembra commentato a sufficienza. Eventualmente, ne parliamo nei commenti.

Photo courtesy: dolescum, Archives’ stacks, CC by-nc-sa.

L'articolo Visualizzare il numero di post trovati in un archivio o una ricerca è uno scritto di aldolat.it. Rispettane le condizioni di licenza.

Query personalizzate e paginazione dei post

aldolat@gmail.com (Aldo Latino) — Mon, 09 Apr 2012 20:26:05 +0000

Avete creato un query personalizzata per tirare fuori dal database tutti i vostri post archiviati sotto un certa categoria. I post sono circa 200 e per evitare di caricare una pagina con così tanti articoli decidete saggiamente che sarebbe bene mostrarne un certo quantitativo per pagina o, magari, tanti quanti avete scelto di mostrarne nelle preferenze di WordPress. Subito dopo il loop, quindi, inserite la riga:

next_posts_link( "Pagina precedente" );

e poi questa:

previous_posts_link( "Pagina successiva" );

Però vi accorgete che i link non appaiono.

Questione di query

Il motivo è presto detto. Quando in una pagina statica (cioè una pagina creata ad hoc) create una nuova query, abbiate presente che esiste già una query principale che popola la variabile globale $wp_query. In questa variabile, nel nostro caso della pagina statica creata appositamente, andranno le informazioni inerenti questa, come la data di creazione, il suo nome, il suo contenuto e tante altre. Le funzioni citate nelle due righe di sopra fanno riferimento proprio a questa variabile, infischiandosene della variabile popolata dalla query personalizzata.

Il punto sta, quindi, nel collegare le due funzioni poc’anzi citate alla query personalizzata. Lo si fa usando il secondo parametro che le due funzioni mettono a disposizione:

next_posts_link( $label, $max_pages );
previous_posts_link( $label, $max_pages );

Quel $max_pages quindi diventerà:

next_posts_link( "Pagina precedente", $mia_variabile->max_num_pages );
previous_posts_link( "Pagina successiva", $mia_variabile->max_num_pages );

Quel $mia_variabile è la variabile utilizzata per creare la query personalizzata, quella cioè che conterrà tutti i post e le loro informazioni, come ad esempio:

$mia_variabile = new WP_Query( $args );

Ma non finisce qui

Dopo aver collegato correttamente la funzione per la visualizzazione dei link alle pagine successiva e precedente, vi accorgete che la pagina 2 visualizza i post della prima, la 3 pure e così via.

Quest’altro punto va risolto aggiungendo un’ulteriore riga tra gli argomenti della query. Ad esempio:

$args = array(
  'category_name'  => 'mie-ricette',
  'tag'            => 'le-regionali',
  'posts_per_page' => 10,
  'orderby'        => 'date',
  'order'          => 'DESC',
  'paged'          => get_query_var( 'paged' )
);

$mia_variabile = new WP_Query( $args );

La riga che ci interessa è la 7. Con quella riga diciamo a WordPress di visualizzare la pagina (paged) X che gli è stata fornita quando abbiamo fatto clic sul link Pagina successiva (o precedente). Altrimenti per lui paged sarà sempre quello della prima.

Un esempio di tutto quanto fin qui detto lo trovate nelle mie pagine Featured posts, Guide su GNU/Linux e Guide su WordPress.

Note finali

1. Se volete che i post visualizzati in ogni pagina siano tanti quanti avete deciso nelle preferenze di WordPress, sostituite la riga 4 con questa:

'posts_per_page' => get_option( 'posts_per_page' ),

che va a prelevarsi proprio il valore impostato.

2. Se volete, poi, che l’output di next_posts_link venga inserito in una variabile anziché visualizzato, utilizzate get_next_posts_link e get_previous_posts_link.

3. se utilizzate il plugin WP-PageNavi, sappiate che anch’esso può essere reindirizzato sulla query personalizzata in questo modo:

wp_pagenavi( array( "query" => $mia_variabile ) );

4. Come rilevato nei commenti a questo post e come descritto nel Codex, se la pagina statica è usata anche come homepage, le righe contenenti gli argomenti vanno modificate in tal senso:

$paged = ( get_query_var( 'page' ) ) ? get_query_var( 'page' ) : 1;
$args = array(
  'category_name'  => 'mie-ricette',
  'tag'            => 'le-regionali',
  'posts_per_page' => 10,
  'orderby'        => 'date',
  'order'          => 'DESC',
  'paged'          => $paged
)

Grazie a Jonathan per la segnalazione.

Per approfondire

La classe WP_Query
Cosa è il Loop?
La funzione next posts link nel Codex
La funzione previous posts link nel Codex
Il codice della funzione get_next_posts_link
Il mio breve articolo sulle variabili di pagina
Jeff Starr, Definitive Guide to WordPress Page Navigation
WPCanyon, Solution if previous_posts_link() and next_posts_link() are not working

L'articolo Query personalizzate e paginazione dei post è uno scritto di aldolat.it. Rispettane le condizioni di licenza.

Offuscare le email: lo shortcode per WordPress

aldolat@gmail.com (Aldo Latino) — Thu, 15 Sep 2011 06:38:23 +0000

WordPress ha una funzione poco nota, messa alcuni giorni fa in evidenza da WP Recipes e poi ripresa da Panese. La funzione si chiama antispambot e serve ad offuscare gli indirizzi email ai crawler finalizzati allo spam.

Vorrei spendere, però, qualche parola in più sul suo funzionamento.

La funzione di WordPress

La funzione va usata direttamente nei template o nei plugin in questo modo:

antispambot( $email_address, $hex_encoding );

dove $email_address è l’indirizzo email e $hex_encoding serve a indicare a WordPress se deve offuscare l’indirizzo (1) o no (0). Per capire meglio la variabile $hex_encoding, osserviamo queste due righe di PHP:

echo antispambot( 'nomeutente@example.com', 0 ) . '<br />' . "\n";
echo antispambot( 'nomeutente@example.com', 1 );

Se le eseguiamo, ecco cosa ci fa vedere il browser:

nomeutente@example.com
%6e%6f%6de%75%74en%74e@e%78am%70l%65.com

ed ecco cosa c’è nel sorgente HTML (fare clic per ingrandire):

Quindi entrambe le righe vengono offuscate nel sorgente, ma la prima riga — dove abbiamo usato 0 — è mostrata in chiaro nella pagina renderizzata dal browser.

L’offuscamento, poi — oltre ad operare solo in alcune lettere dell’indirizzo — è del tutto casuale. Se si prova a ricaricare la pagina, esso cambia continuamente, ad esempio:

nomeute%6ete%40exam%70l%65.com oppure
%6e%6fm%65ut%65n%74e@ex%61mple.%63%6fm oppure
no%6d%65ute%6e%74%65@%65x%61mp%6ce.co%6d.

Avendo presente questo, si deduce che la variabile $hex_encoding = 1 va usata come indirizzo per href, mentre $hex_encoding = 0 va usata se si vuole far visualizzare in chiaro l’indirizzo (che sarà offuscato comunque nel sorgente). Ecco un esempio d’uso concreto:

echo '<a href="mailto:' . antispambot( 'nomeutente@example.com', 1 ) . '">' . antispambot( 'nomeutente@example.com', 0 ) . '</a>';

che genera questo nel sorgente (fare clic per ingrandire):

mentre nel browser vedremmo normalmente l’indirizzo email col suo link.

Il risultato finale, come abbiamo visto, sarà che il lettore non si accorgerà dell’offuscamento perché il browser opererà in modo automatico l’azione di decodifica del sorgente HTML, dove invece è visibile solo la stringa codificata.

Di questa utile funzione ho preparato uno shortcode, in modo da renderla disponibile anche quando scriviamo un post.

Com’è fatto lo shortcode

Eccolo:

 1/**
 2 * Hides email addresses from spam bot.
 3 *
 4 * @param array $atts {
 5 *    The various options. The only required is "address".
 6 *
 7 *    @type string  $type    The type of protocol to be used.
 8 *                           Default: 'email'.
 9 *                           Accepts: 'email', 'jabber'.
10 *    @type string  $address The address to be used (required).
11 *    @type string  $class   The CSS class for the HTML element.
12 *    @type string  $subject The default subject for the email when the user clicks on the link.
13 *    @type string  $text    The text to be linked with the email/Jabber address.
14 *    #type boolean $link    Whether the HTML element should be a link or a span element.
15 * }
16 * @example [email address="name@example.com"]
17 * @return string The formatted HTML email link or span.
18 */
19function ubnsc_email( $atts ) {
20    $defaults = array(
21        'type'    => 'email',
22        'address' => '',
23        'class'   => '',
24        'subject' => '',
25        'text'    => '',
26        'link'    => '1',
27    );
28 
29    $atts = shortcode_atts( $defaults, $atts );
30 
31    switch ( $atts['type'] ) {
32        case 'email':
33            $protocol = 'mailto:';
34            break;
35        case 'jabber':
36            $protocol = 'xmpp:';
37            break;
38    }
39 
40    $atts['address'] = sanitize_email( $atts['address'] );
41 
42    if ( $atts['class'] ) {
43        $atts['class'] = ' class="' . sanitize_html_class( esc_attr( $atts['class'] ) ) . '"';
44    }
45 
46    if ( $atts['subject'] ) {
47        $atts['subject'] = '?subject=' . esc_attr( $atts['subject'] );
48    }
49 
50    if ( empty( $atts['text'] ) ) {
51        $atts['text'] = antispambot( $atts['address'] );
52    }
53 
54    if ( '1' === $atts['link'] ) {
55        $output = '<a' . $atts['class'] . ' href="' . $protocol . antispambot( $atts['address'], 1 ) . $atts['subject'] . '">' . $atts['text'] . '</a>';
56    } else {
57        $output = '<span' . $atts['class'] . '>' . $atts['text'] . '</span>';
58    }
59 
60    return $output;
61}
62add_shortcode('email', 'ubnsc_email');

Come si usa

Va inserito nel file functions.php del vostro tema oppure, meglio, in un plugin che sarebbe bene crearsi se — quando cambiate tema — volete portarvi appresso tutte le vostre funzioni personalizzate. Nella sua forma più semplice si usa così:

... la mia email è: [email address="nomeutente@example.com"]

che restituisce:

… la mia email è: nomeutente@example.com

Potete anche specificare il testo da visualizzare in chiaro:

... e questa è [email address="nomeutente@example.com" text="la mia email"]

che restituisce:

… e questa è la mia email

Se volessimo usare un’immagine al posto del testo in chiaro, ecco come fare:

... e questa è la mia email: [email address="nomeutente@example.com" text="<img src='http://example.com/images/email_offuscata.jpg' alt='' />"]

che restituisce questo:

… e questa è la mia email:

Chiaramente l’immagine dovrete prepararla per conto vostro.

Fin qui l’uso più comune. Può capitare, però, che vogliate indicare un indirizzo per il vostro account Jabber. Ecco come farlo:

... e questo è [email type="jabber" address="nomeutente@example.com" text="il mio account Jabber"]

che restituirà questa riga:

… e questo è il mio account Jabber

Un clic su questo link vi apre il client di messaggistica.

Se voleste infine aggiungere una classe all’elemento A dell’HTML — come nel caso della creazione di un microformato hCard — potete usare questa forma:

[email class=email address="nomeutente@example.com" text="la mia email"]

che sarà restituita così:

… e questa è la mia email

Se osservate il sorgente di questa riga vedrete la classe applicata.

Mostrare l’indirizzo senza link

Qualora volessimo soltanto visualizzare l’indirizzo email senza farlo apparire come un link, basta usare l’opzione link="0" e l’output sarà senza link, ad esempio:

... e questa è la mia email: [email address="nomeutente@example.com" link="0"]

che restituirà:

… e questa è la mia email: nomeutente@example.com

Quanto sia realmente efficace questa funzione di WordPress non saprei dirvelo con certezza. Probabilmente è un sistema che può dare una mano a confondere i bot alla ricerca di indirizzi email.

Aggiornamento

Come richiesto da un lettore, la funzione è stata aggiornata inserendo l’opzione per inserire il subject dell’email. Ad esempio:

[email address="nomeutente@example.com" subject="This is the subject"]

L'articolo Offuscare le email: lo shortcode per WordPress è uno scritto di aldolat.it. Rispettane le condizioni di licenza.

Le variabili relative alle pagine in WordPress

aldolat@gmail.com (Aldo Latino) — Thu, 28 Jul 2011 09:28:02 +0000

Visto che per l’ennesima volta mi sono scordato di appuntarmi in Tomboy il contenuto di queste variabili, lo faccio adesso anche sul blog, così magari vi tornano utili.

Si tratta di alcune variabili globali di WordPress relative alla paginazione di post (quando leggete “post” intendo dire articolo e pagina statica) e di pagine d’archivio. Trovate segnalato se la variabile va usata all’interno del loop; per dichiararla globale si usa global $variabile;.

Variabili globali di post e pagina

$multipage
Dice se un post è suddiviso in più pagine o no. Va usata nel loop.
Ad esempio, se un post è suddiviso in 5 pagine, il valore sarà true.

$numpages
Contiene il numero di pagine di un post suddiviso in più pagine. Va usata nel loop.
Ad esempio, se un post è suddiviso in 5 pagine, il valore sarà 5.

$page
Contiene il numero di pagina visualizzata di un post suddiviso in più pagine.
Ad esempio, se stiamo visualizzando la pagina 3 di un post suddiviso in 5 pagine, il valore sarà 3.

$pages
È un array contenente tanti elementi quante sono le pagine di un post. Va usato nel loop.
Ad esempio, se un post è suddiviso in 3 pagine, l’array conterrà 3 elementi (0, 1, 2) e ciascun elemento conterrà una parte del post.

Variabili globali d’archivio

$paged
Contiene il numero di pagina visualizzata di un archivio.
Ad esempio, se stiamo vedendo la pagina 5 dell’archivio del tag “wordpress”, il valore sarà 5.

$wp_query->max_num_pages
Contiene il numero totale di pagine in cui un archivio è suddiviso. Non è una variabile globale, ma un elemento dell’array $wp_query, che quindi andrà dichiarato globalmente (global $wp_query;)
Ad esempio, se abbiamo impostato WordPress per mostrare 5 post per pagina e abbiamo 20 post con tag “wordpress”, il valore sarà 4 per la pagina d’archivio del tag “wordpress”.

L'articolo Le variabili relative alle pagine in WordPress è uno scritto di aldolat.it. Rispettane le condizioni di licenza.

Autenticazione multifattoriale con Perfect Paper Passwords

aldolat@gmail.com (Aldo Latino) — Fri, 27 May 2011 17:40:11 +0000

Qualche mese fa ho scritto un post sul plugin One-Time Password che ha lo scopo di rendere più sicura l’autenticazione nella propria area amministrativa di WordPress mediante l’uso dell’omonima tecnica detta One-Time Password. In breve, con questo sistema possiamo autenticarci alla Bacheca di WordPress usando una password usa-e-getta che può sostituire la password di WordPress (ottimo in caso di utilizzo in un Internet Cafè) o aggiungersi ad essa.

Oltre a questo plugin, ne esiste un altro che fa qualcosa di molto simile: Perfect Paper Passwords. Con esso avrete a disposizione una password usa-e-getta che si aggiunge (e non si sostituisce) a quella di WordPress.

Autenticazione forte

Sappiamo che per autenticarsi a un sistema informatico con ragionevole sicurezza è buona cosa utilizzare un’autenticazione a due fattori:

qualcosa che si sa (username e password)
qualcosa che si ha (un oggetto, che può essere un token, una smartcard, una chiavetta USB, la SIM del telefono, la biometria o anche un semplice taccuino con password usa-e-getta).

Questo è anche il sistema usato da molte banche per i loro servizi online. In questo modo, anche se un malintenzionato dovesse entrare in possesso delle vostre credenziali, non potrebbe accedere al sistema perché non ha il secondo fattore di autenticazione, il quale appunto cambia continuamente.

Questo plugin vi dà la possibilità di implementare in WordPress il sistema OTP in modo facile e gratuito.

Uso del plugin

Una volta attivato e impostato correttamente il plugin, ecco anzitutto come si presenterà la vostra area di login:

Dopo averlo installato e attivato, troverete le sue impostazioni nella pagina del vostro profilo. La scelta di posizionarlo lì è dettata dal fatto che il plugin permette, a ciascun utente registrato del vostro blog, un’autenticazione personalizzata tramite OTP. Ciascuno, quindi, potrà scegliere se attivare per il proprio profilo questo tipo di autenticazione o meno. La schermata della parte di questa pagina che ci interessa è la seguente (fare clic per ingrandire l’immagine):

Attivate il checkbox, scegliete la lunghezza della OTP,¹ inserite una frase (non limitatevi a una semplice password) che dovete conoscere solo voi e fate clic sul pulsante Aggiorna profilo che sta a fondo pagina. La sezione della pagina si presenterà più o meno così (fare clic per ingrandire l’immagine):

Troverete una sequenza di lettere e numeri nel campo Chiave di sequenza (Sequence Key): copiatela e andate su https://www.grc.com/ppp.htm per completare i passaggi. Da questa pagina di GRC otterremo un One-Time Pad, cioè un foglio con alcune mini password.

Inserite anzitutto in questo box la chiave di sequenza copiata poco fa:

Scegliete la lunghezza della OTP:

e lasciate tutto il resto come si trova. Cambiate, se lo volete, il nome che verrà stampato in cima al taccuino:

In fondo alla pagina premete il pulsante finale:

Vi apparirà la pagina finale con il vostro taccuino di password usa-e-getta:

Stampatelo, ritagliatelo tenendo assieme i tre blocchi e piegatelo: vi verrà in un formato carta di credito. Conservatelo con cura. Potete anche stamparlo in PDF e conservarlo in un luogo sicuro, se volete usare il copia e incolla.

Mettete ora alla prova il plugin, uscendo dalla bacheca. Quando vi autenticherete troverete la schermata che vi ho già presentato:

Come vedete, oltre alle solite credenziali, il sistema vi chiederà la one-time password. La scritta

Codice: C2 Card: 1

vi indica quale OTP inserire fra quelle che avete voi. In questo caso sta chiedendo la C2 del foglio 1, visto che le precedenti le avevamo già usate:

Se qualcosa va storto

Come per qualunque plugin, se non riuscite ad autenticarvi, accedete via FTP al vostro dominio e rinominate la directory del plugin.

Quale plugin utilizzare

È più una scelta personale, tenendo conto anche delle proprie esigenze. Il plugin One-Time Password si presenta con funzioni più ampie (potete, ad esempio, far sì che venga immessa una OTP per compiere determinate azioni amministrative) e non necessita di siti esterni per funzionare; inoltre è ancora più sicuro dell’altro in ambienti di cui non ci si fida (il famoso Internet Cafè), perché potete disabilitare la password di WordPress. Il plugin che abbiamo visto, invece, è più semplice nelle sue opzioni, senza che questo pregiudichi la sua sicurezza; solo che il primo ha indubbiamente qualche punto a suo vantaggio se si hanno determinate esigenze.

Per approfondire

L’autore del plugin è Henrik Schack, danese, e nel suo blog trovate la pagina dove lo presenta.

Per quanto riguarda Perfect Paper Passwords, Steve Gibson spiega i dettagli nelle pagine dedicate. In fondo a essa ci sono ulteriori link.

Photo credits: Jessica Paterson, Padlocks, CC by, 2012.

Sappiate che già con 4 caratteri avrete a disposizione 16.777.216 combinazioni possibili, più che sufficienti per garantirvi un’adeguata sicurezza. I token delle banche posso fornire al massimo 1.000.000 di combinazioni (6 cifre da 000 000 a 999 999). ↩︎

L'articolo Autenticazione multifattoriale con Perfect Paper Passwords è uno scritto di aldolat.it. Rispettane le condizioni di licenza.

Evitare il texturize di WordPress

aldolat@gmail.com (Aldo Latino) — Sat, 16 Apr 2011 18:38:01 +0000

Nel cantiere continuamente aperto, che è questo blog, ho trasferito tutti gli shortcode che andavo copiando di tema in tema in un plugin apposito, UBN Shortcodes, in modo da averli sempre disponibili anche su temi che intendo solo provare. Si tratta di funzioni che mi aiutano parecchio nella stesura degli articoli; unito poi all’uso di AddQuicktag¹ la cosa diventa straordinaria.

Mentre facevo questa operazione, ho aggiunto uno shortcode dedicato all’elemento pre e mi sono accorto che WordPress cambiava le virgolette diritte " in quelle tipografiche “. Mi chiedevo come mai, visto che se usavo direttamente quell’elemento il cambio non veniva operato. Era chiaro che bisognava dare uno sguardo al file /wp-includes/formatting.php e, di preciso, alla funzione wptexturize($text), una vecchia conoscenza per chi ha a che fare con la creazione di temi e plugin. Questa funzione, che appunto trasforma alcuni caratteri in altri, non viene eseguita su quei caratteri che si trovano all’interno di alcuni elementi HTML prestabiliti, e cioè:

$default_no_texturize_tags = array('pre', 'code', 'kbd', 'style', 'script', 'tt');

Come vedete, troviamo anche il nostro pre. Alla riga successiva, troviamo un altro array, ma stavolta dedicato agli shortcode da non “texturizzare”. L’array, però, contiene solo code:

$default_no_texturize_shortcodes = array('code');

Per questo motivo il mio shortcode [pre] subiva gli effetti “nefasti” di wptexturize.

Per includere in un tema o in un plugin anche altri shortcode all’array, è sufficiente aggiungere un filtro. Infatti, se nel file formatting.php guardiamo un po’ oltre, vediamo questa riga:

$no_texturize_shortcodes = '(' . implode( '|', apply_filters( 'no_texturize_shortcodes', $default_no_texturize_shortcodes ) ) . ')';

dove la presenza di apply_filters ci consente di ampliare gli shortcode che non subiscono alcuna modifica al loro contenuto. Più tecnicamente, dobbiamo creare un array di elementi HTML da assegnare a no_texturize_shortcodes che verranno quindi aggiunti all’array principale $default_no_texturize_shortcodes.

Basta così creare una funzione apposita nel proprio tema o plugin che può suonare più o meno così:

add_filter('no_texturize_shortcodes',  'ubn_no_texturize_shortcodes');

function ubn_no_texturize_shortcodes( $shortcodes_array ) {
  $shortcodes_array = array( 'pre', 'tt' );

  return $shortcodes_array;
}

Ho inserito sia pre che tt, cioè due shortcode che uso io: potete sostituirli con quelli che volete o aggiungerne d altri. Questa semplice funzione vi garantisce che il testo inserito all’interno rimarrà intatto. Con questa tecnica si può allargare, ovviamente, pure l’array dedicato ai “tags”, anche se comunque non vedo necessità di farlo.

Scrissi qualcosa su AddQuicktag in questo post. ↩︎

L'articolo Evitare il texturize di WordPress è uno scritto di aldolat.it. Rispettane le condizioni di licenza.