Aldolat.it — Post con tag Featured

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.

Bloccare l’accesso al file wp-login.php

aldolat@gmail.com (Aldo Latino) — Sat, 31 Jan 2015 20:35:00 +0000

È da molti mesi che riscontro tentativi continui di accesso non autorizzato alla dashboard di WordPress: qualcuno/qualcosa tenta senza sosta di indovinare il nome utente dell’amministratore e della sua password. Me ne accorgo dalle segnalazioni che mi arrivano tramite il plugin Limit login attempts.

Il plugin, che pare non essere più mantenuto (e per questo motivo cerco un’alternativa), fa bene il suo lavoro ma, nonostante ciò, non è bello per me ricevere tutte quelle email giornaliere da parte sua. Per cui ho deciso di risolvere alla base il problema.

Negare l’accesso

Poiché l’azione che si tenta è quella di autenticarsi, la via di ingresso è il file wp-login.php: è sufficiente quindi bloccare l’accesso a questo file. Bloccare l’accesso al file significa, però, che neanche noi riusciremo a entrare nella dashboard di WordPress: dovremo quindi permettere l’accesso al nostro indirizzo IP.

Basta aggiungere poche righe al file .htaccess presente nella directory radice del proprio dominio:

<Files ~ "wp-login.php">
Order Deny,Allow
Deny from all
Allow from 12.
</Files>

Con queste righe stiamo dicendo ad Apache di bloccare l’accesso al file wp-login.php a tutti (Deny from all) tranne a coloro il cui indirizzo IP inizia con 12. (Allow from 12.). Chiaramente questo numero è quello che interessa a me, per cui dovete conoscere con quale range di indirizzi generalmente il vostro provider vi fa accedere ad Internet. Se avete un indirizzo IP statico, potete aggiungerlo per intero:

Allow from 123.123.123.123

A coloro il cui indirizzo IP non inizia con 12. o non è quello esatto che avete definito, Apache restituirà un errore 403 “Accesso negato”, che eventualmente potete anche personalizzare, se il vostro hosting provider ve lo permette.

Una volta messe in opera quelle righe, il log del server mostrerà qualcosa del genere:

[Sat Jan 31 02:10:30 2015] [error] [client 5.196.253.201] client denied by server configuration: /path/to/domain.tld/folder/wp-login.php, referer: http://www.domain.tld/
[Sat Jan 31 02:10:31 2015] [error] [client 5.196.253.201] client denied by server configuration: /path/to/domain.tld/folder/wp-login.php, referer: http://www.domain.tld/wp-login.php?action=register
[Sat Jan 31 02:32:18 2015] [error] [client 192.240.201.20] client denied by server configuration: /path/to/domain.tld/folder/wp-login.php, referer: http://www.domain.tld/
[Sat Jan 31 02:32:18 2015] [error] [client 192.240.201.20] client denied by server configuration: /path/to/domain.tld/folder/wp-login.php, referer: http://www.domain.tld/wp-login.php?action=register
[Sat Jan 31 03:02:45 2015] [error] [client 104.143.23.249] client denied by server configuration: /path/to/domain.tld/folder/wp-login.php, referer: http://www.domain.tld/
[Sat Jan 31 03:02:46 2015] [error] [client 104.143.23.249] client denied by server configuration: /path/to/domain.tld/folder/wp-login.php, referer: http://www.domain.tld/wp-login.php?action=register
[Sat Jan 31 03:28:20 2015] [error] [client 173.232.118.182] client denied by server configuration: /path/to/domain.tld/folder/wp-login.php, referer: http://www.domain.tld/
[Sat Jan 31 03:28:21 2015] [error] [client 173.232.118.182] client denied by server configuration: /path/to/domain.tld/folder/wp-login.php, referer: http://www.domain.tld/wp-login.php?action=register
[Sat Jan 31 03:29:33 2015] [error] [client 198.23.134.163] client denied by server configuration: /path/to/domain.tld/folder/wp-login.php, referer: http://www.domain.tld/
[Sat Jan 31 03:29:33 2015] [error] [client 198.23.134.163] client denied by server configuration: /path/to/domain.tld/folder/wp-login.php, referer: http://www.domain.tld/wp-login.php?action=register
[Sat Jan 31 03:33:08 2015] [error] [client 37.59.75.59] client denied by server configuration: /path/to/domain.tld/folder/wp-login.php, referer: http://www.domain.tld/
[Sat Jan 31 03:33:08 2015] [error] [client 37.59.75.59] client denied by server configuration: /path/to/domain.tld/folder/wp-login.php, referer: http://www.domain.tld/wp-login.php?action=register
[Sat Jan 31 03:36:43 2015] [error] [client 88.251.177.222] client denied by server configuration: /path/to/domain.tld/folder/wp-login.php
[Sat Jan 31 03:39:33 2015] [error] [client 151.80.69.186] client denied by server configuration: /path/to/domain.tld/folder/wp-login.php, referer: http://www.domain.tld/

con la conferma che Apache sta bloccando gli accessi (client denied by server configuration). E le email di Limit login attempts sono terminate.

I motori di ricerca

Per evitare errori di scansione dei motori di ricerca ho inserito nel file robots.txt due righe che evitino la scansione delle pagine legate all’autenticazione, ad esempio:

User-agent: *
Disallow: /wp-login.php
Disallow: /wp-login.php?action=register

Chiaramente quanto sopra forse non è la soluzione migliore al problema, ma devo dire che sta funzionando bene per me ed è di facilissima implementazione.

L'articolo Bloccare l’accesso al file wp-login.php è uno scritto di aldolat.it. Rispettane le condizioni di licenza.

Posts in Sidebar è disponibile

aldolat@gmail.com (Aldo Latino) — Mon, 10 Sep 2012 17:37:15 +0000

Come ho annunciato nel precedente post, è adesso disponibile un mio nuovo plugin per WordPress: Posts in Sidebar. Si tratta di un plugin che realizzai anni fa per questo mio blog e che non ho mai pubblicato perché era costruito per me stesso, molto verticalizzato sulle mie esigenze. Con un po’ di adattamento e pazienza, vista la sua semplicità iniziale, l’ho reso utilizzabile da chiunque, aggiungendo al contempo anche svariate funzioni in più.

A cosa serve

Il plugin serve a mostrare nella sidebar un elenco di articoli prelevati secondo i criteri che si preferiscono: i post di un certo autore e/o di una categoria e/o di un tag. Questi post vengono mostrati nella barra laterale tramite un widget. In questo blog lo trovate utilizzato sia nella sidebar laterale che in quella a fondo pagina.

In una prossima versione ho intenzione di estenderne le funzionalità, includendo anche date o ID precisi di post.

Come si usa

Una volta installato tramite il pannello di WordPress e attivato, troverete un nuovo widget nella sezione apposita. Trascinate il widget nella barra laterale, nella posizione desiderata e impostatene i criteri di prelievo dei post. Di ogni post potete scegliere cosa mostrare: solo il titolo, oppure il titolo e un estratto, oppure anche l’immagine in evidenza, oppure solo l’immagine senza null’altro, oppure anche i tag, e via dicendo.

Occhio

Ogni widget che aggiungete alla sidebar genera nuove richieste (query) al database. Sono circa 5 le richieste aggiuntive (a volte anche meno). Quindi, più widget aggiungete, più risorse serviranno per la creazione della pagina.

Dove si trova

Lo trovate nel repository di WordPress, alla pagina Posts in Sidebar. Ho anche creato qui ~~[una pagina dedicata]~~ che preleva tutte le informazioni dal repository e, quindi, sono sempre aggiornate. Lì troverete anche gli screenshot inclusi nel plugin.

Spero che vi piaccia e che, soprattutto, lo troviate utile.

L'articolo Posts in Sidebar è disponibile è uno scritto di aldolat.it. Rispettane le condizioni di licenza.

Dropbox e l'autenticazione multifattoriale

aldolat@gmail.com (Aldo Latino) — Sun, 26 Aug 2012 09:46:54 +0000

Come già presente per Google e LastPass, anche Dropbox ha attivato l’autenticazione multifattoriale, anche se per ora in via sperimentale ma accessibile a chiunque voglia implementarla. Si tratta in sostanza di inserire — oltre la password — anche un’ulteriore piccola serie numerica di sei cifre, generata da un’applicazione installata sullo smartphone o inviata da Dropbox stessa al proprio telefonino tramite SMS. Io, ovviamente, ho attivato il servizio e vi dico che funziona, comprese le applicazioni del mio PlayBook che usano Dropbox.

Per attivarlo va installata la versione sperimentale di Dropbox (la 1.5.12, al momento) che trovate nel forum e quindi seguire le brevi istruzioni contenute nel post: niente di complicato. Una volta attivato il servizio, per entrare nel vostro account Dropbox tramite il browser o tramite l’applicazione ufficiale (quella che risiede nel vostro vassoio di sistema) dovrete inserire due password: quella solita + quella aggiuntiva (detta anche “Security code”). La password aggiuntiva, come già detto, può essere inviata via SMS oppure generata da voi stessi tramite l’applicazione Google Authenticator, disponibile per tutte le piattaforme di smartphone.

Per far funzionare le app di smartphone e tablet, come il PlayBook che uso, dovrete inserire invece una password specifica. La password specifica non viene generata da voi (come avviene su Google) ma viene richiesta in modo automatico quando l’app chiede di autenticarsi. Siccome la password solita non viene più riconosciuta, Dropbox invia un’email con un invito a visitare un link per avere la password specifica per quell’applicazione. In altre parole, per ogni software che intenda collegarsi all’account Dropbox vi genera automaticamente una password specifica per quell’applicazione.

Avevo letto da qualche parte che il sistema username+password non è più sufficiente al giorno d’oggi…

L'articolo Dropbox e l'autenticazione multifattoriale è uno scritto di aldolat.it. Rispettane le condizioni di licenza.

Condividere su WordPress le proprie letture via Delicious

aldolat@gmail.com (Aldo Latino) — Wed, 22 Aug 2012 21:38:45 +0000

Sicuramente ricorderete come tempo fa Google ha eliminato una funzione molto utile dal suo Reader che ci consentiva di condividere gli articoli più interessanti con i nostri follower che usavano lo stesso lettore di feed. Una mazzata per questo servizio. A me personalmente tornava utile non solo perché ci si scambiava letture interessanti, ma anche perché le condividevo in un widget del mio blog tramite un plugin apposito: Recommended Reading: Google Reader Shared, che ormai è morto.

Venendo a mancare questa funzione, ognuno ha cercato una sua soluzione. Anche io mi sono dato da fare e ho pensato di utilizzare Delicious (ancora lui! 😀 ) per questo compito, ispirato soprattutto da quanto Andrea scriveva nel suo blog. A tal fine, mesi fa mi sono creato un plugin che preleva da Delicious i segnalibri archiviati con un particolare tag e me li mostra in un widget: più o meno la stessa cosa che facevo prima, col vantaggio di avere un comodo archivio delle letture su Delicious.

Il funzionamento è semplice. Quando sono su una pagina web qualsiasi, mi basta archiviarla su Delicious come al solito ma usando anche un tag preciso, nel mio caso “letture”. Il plugin, a intervalli di un’ora, preleverà il feed e mostrerà in un widget questi titoli, con tanto di descrizione, tag, data, ecc. Il sistema funziona anche da Google Reader: in questo caso posso utilizzare il pulsante in fondo agli articoli “Invia a Delicious”. In realtà non uso questo pulsante, perché l’URL generato non mi piace (roba del tipo: http://feedproxy.google.com/~r/blah-blah-blah). Faccio invece clic sul titolo dell’articolo e quindi salvo la pagina su Delicious come per qualsiasi altra.

Il plugin, che ho creato mesi fa, si chiama Delicious Readings. Una volta installato e attivato, crea un nuovo widget che potrà essere inserito nella sidebar. Ecco come si presenta nella dashboard:

L’unico parametro essenziale è soltanto quello dell’indirizzo del feed: tutto il resto è di contorno. Questo è invece un esempio di cosa mostra:

Come vedete mostra un po’ tutto quello che è presente nelle opzioni, ma si può scegliere se visualizzare solo i titoli, se mostrare la data, i tag, ecc. Ovviamente ogni elemento HTML è associato a classi CSS che potranno essere stilizzate tramite il foglio stile del proprio tema.

Delicious Readings, pensato e costruito per me stesso come tanti altri, è stato provato solo con Delicious: non so dirvi se funziona con Pinboard o altri servizi di bookmarking.

Il plugin, che ho conservato gelosamente solo per me, non è ancora disponibile sul repository di WordPress. Mi piacerebbe condividerlo, perché forse può tornare utile a qualcuno. Prima di farlo, però, vorrei che fosse sottoposto a un controllo. Se siete interessati, scrivetelo nei commenti e ve lo mando via email.

Photo courtesy: Kate’s Twirl, CC by-nc.

L'articolo Condividere su WordPress le proprie letture via Delicious è uno scritto di aldolat.it. Rispettane le condizioni di licenza.

Google Authenticator per WordPress

aldolat@gmail.com (Aldo Latino) — Thu, 24 May 2012 20:47:03 +0000

Non starò qui a ripetere quanto ho già scritto sull’autenticazione multifattoriale come metodo abbastanza sicuro per accedere a un sistema informatico: ne ho già parlato sia in Password OTP (usa e getta) per WordPress che in Autenticazione multifattoriale con Perfect Paper Passwords.

Segnalo, invece, un plugin per WordPress ancora più comodo da usare: Google Authenticator. È stato creato dal buon Henrik Schack (autore di Perfect Paper Passwords) e vi consiglio di provarlo.

Google Authenticator (intendo il progetto di bigG) è un’applicazione per dispositivi mobili che genera costantemente codici numerici da usare come secondo mezzo di verifica durante l’autenticazione su un sistema. L’applicazione di Google è disponibile per dispositivi BlackBerry, Android e iOS. Se lo usate per accedere al vostro account su Google, sapete bene di cosa si tratta. Ecco, il plugin di Henrik porta questo meccanismo all’interno di WordPress:

Il plugin, dopo l’attivazione, richiede che ciascun utente attivi la funzionalità dal proprio profilo. Una volta attivata, vi sarà dato il codice da inserire nello smartphone.

Se accedete alla vostra installazione usando l’applicazione di WordPress per tablet, sarà necessario attivare l’opzione del plugin Enable App password: usate quindi questa password nell’applicazione del tablet.

L'articolo Google Authenticator per WordPress è 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.

Conoscere la data di creazione di un file in GNU/Linux

aldolat@gmail.com (Aldo Latino) — Fri, 19 Aug 2011 21:16:53 +0000

Questo post non sarebbe mai nato se non fosse stato per Lorenzo, che si è trovato davanti alla necessità di risalire alla data di creazione di un file. E si è accorto che questo dato non è di immediata reperibilità. Vista l’importanza di quel suo post, mi sembra giusto darne ulteriore visibilità.

Nota di aggiornamento

Con le recenti versioni di stat è possibile reperire questa informazione:

$ stat filename 
  File: filename
  Dim.: 487350          Blocchi: 952        Blocco di IO: 4096   file regolare
Device: 8,17    Inode: 56368081    Links: 1
Accesso: (0644/-rw-r--r--)  Uid: ( 1000/    aldo)   Gid: ( 1000/    aldo)
Accesso  : 2022-12-18 09:08:16.340484099 +0100
Modifica : 2019-05-07 12:17:11.000000000 +0200
Cambio   : 2021-11-13 23:14:06.304345519 +0100
Creazione: 2020-10-18 07:55:44.026567659 +0200

È anche possibile farlo con ls:

ls -l --time=birth filename

che restituisce:

-rw-r--r-- 1 aldo aldo 487350 18 ott  2020 filename

In Ext4 è possibile farlo con:

ls -i filename

che restituisce l’inode del file:

6029808 filename

e quindi:

sudo debugfs -R 'stat 6029808' /dev/sda3

dove /dev/sda3 è la partizione in cui risiede il file. Ed infatti, creando un file di test e dando quel comando, l’output è:

Inode: 6029808 Type: regular Mode: 0644 Flags: 0x80000
 Generation: 3337172570 Version: 0x00000000:00000001
 User: 1000 Group: 1000 Size: 0
 File ACL: 0 Directory ACL: 0
 Links: 1 Blockcount: 0
 Fragment: Address: 0 Number: 0 Size: 0
  ctime: 0x4e47fa9b:c3e1fd20 -- Sun Aug 14 18:40:59 2011
  atime: 0x4e47fa9b:c3e1fd20 -- Sun Aug 14 18:40:59 2011
  mtime: 0x4e47fa9b:c3e1fd20 -- Sun Aug 14 18:40:59 2011
 crtime: 0x4e47fa9b:c3e1fd20 -- Sun Aug 14 18:40:59 2011
 Size of extra inode fields: 28
 EXTENTS:
 (END)

dove la quartultima riga contiene il dato che ci interessa, cioè crtime (creation time).

Gli altri sono:

ctime (change time): Ora del cambiamento, che può includere anche solo una modifica ai permessi senza apertura del file.
atime (access time): Ora di accesso al file.
mtime (modification time): Ora di modifica del file.

Schematicamente, ecco cosa avviene (la x indica un cambio del timestamp):

	ctime	atime	mtime	crtime
Creazione file	×	×	×	×
Apertura file		×
Modifica file	×	×	×
Cambio permessi	×

Tabella 1. Quali attributi di un file vengono modificati a seconda dell’azione eseguita.

Grazie a Lorenzo per le preziose informazioni.

Photo credits: ToniVC, The Passage of Time, CC by-nc-nd, 2008.

L'articolo Conoscere la data di creazione di un file in GNU/Linux è uno scritto di aldolat.it. Rispettane le condizioni di licenza.

Modificare un file PDF

aldolat@gmail.com (Aldo Latino) — Mon, 04 Jul 2011 16:29:34 +0000

Ho a che fare in continuazione con file Acrobat PDF e loro modifica. Mi trovo benissimo nel compiere queste operazioni via terminale, anche perché mi sbrigo prima. Mi annoto anche qui queste operazioni e le condivido con voi.

Ovviamente esistono alternative che fanno uso di strumenti grafici, come PDF Mod, PDF Chain, PDF Shuffler, PDF Split and Merge (pdfsam).

I pacchetti usati in questo post sono: ghostscript, pdftk, poppler-utils, che vanno installati se non li avete già.

Manipolazione del PDF

Unire più PDF in uno solo

pdftk input_A.pdf input_B.pdf input_C.pdf cat output output.pdf

Unire tutti i PDF di una directory in uno solo

pdftk *.pdf cat output output.pdf

Dividere un unico file PDF in tanti file PDF quante sono le sue pagine

pdftk input.pdf burst

Estrarre da PDF alcune pagine

pdftk input.pdf cat 10-20 output output.pdf

Estrarre da PDF alcune pagine non consecutive

Col seguente comando estraiamo le pagine 3, dalla 10 alla 20, 25, 28, 32, dalla 45 alla fine:

pdftk input.pdf cat 3 10-20 25 28 32 45-end output output.pdf

Ruotare un PDF di 90° a destra (clockwise)

Col seguente comando ruotiamo tutte le pagine (dalla prima alla fine) verso Est:

pdftk input.pdf cat 1-endE output output.pdf

Ruotare un PDF di 90° a sinistra (counter-clockwise)

pdftk input.pdf cat 1-endW output output.pdf

Ruotare un PDF di 180°

pdftk input.pdf cat 1-endS output output.pdf

Convertire un PS in PDF

ps2pdf -dPDFSETTINGS=/screen input.ps output.pdf

dove screen può essere:

screen (72 dpi)
ebook (150 dpi)
printer (300 dpi)
prepress (300 dpi)

Convertire un PDF in PS

pdf2ps input.pdf output.ps

Ridurre le dimensioni di un PDF

gs -sDEVICE=pdfwrite -dCompatibilityLevel=1.4 -dPDFSETTINGS=/ebook -dNOPAUSE -dQUIET -dBATCH -sOutputFile=output.pdf input.pdf

Modificare i metadati di un PDF

Estraiamo prima le informazioni esistenti in un file di testo:

pdftk input.pdf dump_data output info.txt

Modifichiamo le informazioni e reimportiamole in un nuovo PDF con:

pdftk input.pdf update_info info.txt output output.pdf

Un esempio di elenco di metadati:

InfoKey: Title
InfoValue: Titolo del PDF
InfoKey: Subject
InfoValue: Soggetto del PDF
InfoKey: Keywords
InfoValue: Parole, Chiave, Del, PDF
InfoKey: Author
InfoValue: Autore del PDF

PDF e immagini

Convertire un PDF in PNG

convert -density 300 input.pdf output.png

Tutte le pagine saranno convertite in immagine. I file immagine risultanti avranno questo nome:

output-0.png --> Pagina 1
output-1.png --> Pagina 2
ecc.

La stessa conversione può essere effettuata con pdftoppm, un componente di poppler-utils.

Convertire un PDF in PNG specificando le dimensioni di uscita

convert -scale 940 input.pdf output.png

Convertire un PDF in PNG specificando la risoluzione di uscita

convert -density 300 input.pdf output.png

Estrarre da PDF una pagina e convertirla in PNG

convert input.pdf[0] output.png

0 sta per pagina 1, 1 per pagina 2 e così via. Anche in questo comando si possono usare le opzioni -scale e -density.

Estrarre da un PDF più pagine non consecutive e convertirle in PNG

convert -density 300 -scale 940 input.pdf[0,2,6,11,16,21,26,33,38] output.png

Convertire un PDF in un PDF immagine (rasterizzare il PDF)

convert -density 300 input.pdf output.pdf

Convertire più PNG in PDF (A4 verticale)

convert -adjoin -page 210x297 *.png output.pdf

Convertire più PNG in PDF (A4 orizzontale)

convert -adjoin -page 297x210 *.png output.pdf

Estrarre immagini dal PDF

È consigliabile crearsi prima una directory (ad esempio pdf_images) dove far confluire tutte le immagini e poi dare:

pdfimages input.pdf pdf_images/

Man mano che mi serviranno altri comandi, li aggiungerò in questo post.

Photo credits: leo.eloy, Senza titolo, CC by-nc, 2009.

L'articolo Modificare un file PDF è uno scritto di aldolat.it. Rispettane le condizioni di licenza.