Archive for the ‘Programmazione’ Category

Migrare prestashop da un dominio ad un altro

Questa procedura serve nel caso vogliate spostare il vostro sito prestashop da un dominio ad un altro, ad esempio per un cambio di servizio di hosting. La procedura permette di migrare completamente il vostro sito con tutti i prodotti e i plugin installati.

  • Per prima cosa rendete offline il vostro e-commerce prestashop così da non creare inconsistenza nel caso ci siano azioni da qualche utente mentre si effettua la migrazione. Per fare ciò, nel pannello di amministrazione (back-office), fare:
    Preferenze -> Manutenzione -> Attiva negozio -> NO
  • Successivamente effettuate un backup (dump) del vostro database prestashop, lo potete tranquillamente fare con phpmyadmin tramite il comando esporta
  • Dopo il DB è necessario esportare anche i file, quindi spostare tutti i file presenti nella directory di prestashop dal vecchio al nuovo dominio compresi i file nascosti. E’ possibile scaricare i file in locale per poi rifare l’upload sul nuovo server oppure trasferirli direttamente da un server all’altro attraverso il protocollo FTP. Questa operazione può durare molto tempo, anche ore se il vostro e-shop contiene molti articoli
  • A questo punto ci spostiamo definitivamente sul nuovo server, la prima operazione da fare sul nuovo server è l’import del backup del database fatto precedentemente, anche in questo caso è possibile utilizzare il tool phpmyadmin
  • Dopo aver ricaricato il DB andiamo a modificare il file di configurazione di prestashop che si trova in config/settings.inc.php, in particolare vanno modificati i parametri relativi al database:
    1. define('_DB_SERVER_', 'mioServerDatabase');
    2. define('_DB_NAME_', 'nomeDelDB');
    3. define('_DB_USER_', 'utenteDB');
    4. define('_DB_PASSWD_', 'passwordDB');
    5. define('_DB_PREFIX_', 'ps_');

    Il punto 5 è il prefisso standard di prestashop per la creazione delle tabelle, non va modificato a meno che non sia stato cambiato nella precedente installazione. Se la versione utilizzata è precedente la 1.4 va modificata anche un’altra voce:

    • define('__PS_BASE_URI__', '/cartellaInstallazione/');
  • Entriamo nel pannello di amministrazione per modificare gli URL relativi al nuovo dominio nella pagina Preferenze -> URL e SEO modificando le voci “Dominio negozio“, “Dominio SSL” e “URL principale” (quest’ultima va inserita nel caso in cui prestashop non sia installato nella directory principale del sito ma in una sottocartella e va popolata con il nome della cartella di installazione. Ad es. “/shop/” se prestashop è installato nella directory shop).
    Bisogna anche rigenerare il file robots.txt cliccando sul punsante che trovate nella stessa pagina.
  • Infine, riattiviamo il negozio
    Preferenze -> Manutenzione -> Attiva negozio -> SI

A questo punto, se non ci sono stati errori o problemi di varia natura, dovremmo poterci collegare al nostro e-commerce prestashop sul nuovo dominio con una copia speculare di quello che era installato sul precedente server.

Utilizzare lightbox su immagini caricate con innerHTML

Il lightbox è un’applicazione javascript per la visualizzazione delle immagini in maniera elegante. Per maggiori informazioni sull’utilizzo e per il download dei files andate qui.

Il lightbox è uno strumento molto utilizzato. Di recente mi è capitato di dover utilizzare il lightbox su immagini caricate dinamicamente all’interno di un div; dopo svariate prove sono giunto a utilizzare la seguente funzione javascript:

<script type="text/javascript" language="javascript">
function showImage(w,h,image) {
 var obj=document.getElementById("id_div");
 obj.innerHTML="";
 obj.innerHTML+="<a href='"+image+"' rel='lightbox'><img src='"+image+"' width='"+w+"' height='"+h+"'></a>";
 initLightbox();
 }
</script>

<div id="id_div">
</div>

La funzione showImage() va a scrivere all’interno del div con id uguale a “id_div” inserendo sia il tag <a> che il tag <img> con il metodo innerHTML, passando anche l’altezza e la larghezza che dovrà avere l’immagine. Ovviamente per poter far funzionare il lightbox bisogna inserire all’interno del tag <a> l’attributo rel=”lightbox”.
Dopodiché bisogna reinizializzare il lightbox tramite la funzione initLightbox(), questo accade perché ogni variazione dinamica dell’HTML sul codice delle immagini richiede la reinizializzazione del lightbox.
Nota: il primo innerHTML con argomento vuoto serve a evitare che le chiamate della funzione successive alla prima abbiano come effetto la sovrapposizione delle immagini precedentemente caricate.

Un’altra soluzione molto simile alla prima è la seguente:

<script type="text/javascript" language="javascript">
function showImage(w,h,image) {
 var obj=document.getElementById("linkID");
 var objIMG=document.getElementById("imgID");
 obj.href=image;
 objIMG.src=image;
 objIMG.width=w;
 objIMG.height=h;
 initLightbox();
 }
</script>

<div id="id_div">
<a id="linkID" rel="lightbox"><img id="imgID"  /></a>
</div>

La differenza rispetto al caso precedente sta nell’inserire a priori all’interno del div i tag <a> e <img> e nell’inserire dinamicamente i contenuti degli attributi.
L’utilizzo della funzione è molto semplice, basta richiamarla in un qualsiasi punto della pagina web, ad esempio tramite onclick dentro un tag.

Entrambe le soluzioni proposte sono state testate su firefox 4/5 e su IE9.

Inserire codice youtube in sito web senza errori di validazione W3C

L’inserimento dei video youtube all’interno di un sito web è un’operazione molto semplice: youtube stesso, infatti, definisce il codice da incorporare all’interno della pagina web. Il codice può essere del tipo:

<iframe width="560" height="349" src="http://www.youtube.com/embed/xxxxxxxxxxx" frameborder="0" allowfullscreen></iframe>

oppure

<object width="560" height="349"><param name="movie" value="http://www.youtube.com/v/xxxxxxxxxx?version=3&amp;hl=it_IT"></param><param name="allowFullScreen" value="true"></param><param name="allowscriptaccess" value="always"></param><embed src="http://www.youtube.com/v/xxxxxxxxxxx?version=3&amp;hl=it_IT" type="application/x-shockwave-flash" width="560" height="349" allowscriptaccess="always" allowfullscreen="true"></embed></object>

Cosa accade però se il sito deve essere accessibile?
In questo caso la situazione si complica.

Purtroppo, così come sono i due codici daranno errore sul W3C Validator, il primo per l’utilizzo del tag <iframe> e del tag <embed>, il secondo solo per l’utilizzo del tag <embed>. Non essendo possibile modificare il primo bisogna cercare di modificare il secondo codice togliendo il tag <embed>.
La soluzione è quella di usare il seguente codice:

<object width="560" height="349" type="application/x-shockwave-flash" data="http://www.youtube.com/v/xxxxxxxxxx"><p>Descrizione</p><param name="movie" value="http://www.youtube.com/v/xxxxxxxxxxx"></param><param name="allowFullScreen" value="true"></param><param name="allowscriptaccess" value="always"></param></object>

Ovviamente al posto delle xxxxxxxxxxx va inserito il codice del video. In questo modo potrete inserire i video di youtube anche in siti accessibili.
NB: ricordatevi di inserire la descrizione del video all’interno del tag <object> e prima del tag <param>; essa serve nei casi in cui il video non può essere caricato.

Classe per l’invio di file tramite il protocollo FTP in PHP

In questo articolo vedremo una classe creata per l’utilizzo delle funzioni php per il trasferimento di file attraverso il protocollo FTP (File Transfer Protocol). Ho cercato di semplificare la classe per far eseguire le funzioni elementari utili per lo scambio di file con un server FTP remoto, utilizzando anche meccanismi per la verifica dei file che controllino che il file sia già presente sul server o meno.

Come al solito posto tutto il codice e, successivamente, verrà commentato. Ho chiamato la classe simpleFtp.

<?php

class simpleFtp {

 //dati per l'accesso
 var $ftp_host = ''; //indirizzo server ftp
 var $username = ''; //nome utente per l'accesso ftp
 var $pwd = '';      //password per l'accesso ftp
 var $connect;
 var $login;
 var $source_file;
 var $destination_file;

 //nel costruttore effettuo connessione e login
 function simpleFtp(){
 //effettuo la connessione
 $this->connect = ftp_connect($this->ftp_host) or die("Si è verificato un errore durante la connessione al server ftp");

 //effettuo il login
 $this->login = ftp_login($this->connect, $this->username, $this->pwd) or die("Si è verificao un errore durante l'accesso al server ftp");

 }

 //funzione per il trasferimento dei file
 function trasferisci($sorgente, $destinazione){
 //file da trasferire
 $this->source_file = $sorgente;
 //va indicato il percorso e il nome del file
 $this->destination_file = $destinazione;
 //verifico che il file non esista già altrimenti modifico il nome
 $this->destination_file = $this->verificaFile($this->destination_file, 'put'); 

 ftp_put($this->connect, $this->destination_file, $this->source_file, FTP_BINARY) or die("Errore durante l'upload del file $source_file nel server ftp");

 }

 function preleva($destinazione, $sorgente){
 if($this->verificaEsistenza($sorgente)){
 //file da trasferire dal server remoto
 $this->source_file = $sorgente;
 //percorso e nome locale da dare al file
 $this->destination_file = $destinazione;
 //verifico che il file non esista già altrimenti modifico il nome
 $this->destination_file = $this->verificaFile($this->destination_file, 'get');        

 ftp_get($this->connect, $this->destination_file, $this->source_file, FTP_BINARY) or die("Errore durante il download del file $source_file nel server ftp");

 }else
 echo "File non trovato.";
 }

 //cancella un file sul server remoto
 function cancella($file){
 if($this->verificaEsistenza($file))
 ftp_delete($this->connect, $file) or die("Errore durante la cancellazione del file dal server ftp");
 else
 echo "File non trovato";
 }

 //cambia la directory sul server remoto
 function cambiaDirectory($dir){
 ftp_chdir($this->connect,$dir) or die('Errore durante il cambio di directory');
 }

 //restituisce la directory corrente
 function directoryCorrente(){
 return ftp_pwd($this->connect);
 }

 //cambia i permessi su un file, i permessi devono essere a 4 cifre. Es.: 0755
 function cambiaPermessiFile($permessi, $file){
 if($this->verificaEsistenza($file) && is_numeric($permessi))
 ftp_chmod($this->connect, $permessi, $file);
 else
 echo "File non trovato";
 }

 //rinomina un file sul server remoto
 function rinomina($old, $new){
 if($this->verificaEsistenza($old)){
 $new = $this->verificaFile($new, 'put');
 ftp_rename($this->connect, $old, $new);
 }
 else
 echo "File non trovato";
 }

 //restituisce un array con i nomi dei file nella directory passata
 function visualizzaFile($dir){
 $result = ftp_nlist($this->connect, $dir);
 return $result;
 }

 //crea una directory sul server remoto a partire dalla directory corrente
 function creaDirectory($dir){
 @ftp_mkdir($this->connect, $dir) or die('La directory esiste già o non hai i permessi per crearne una.');

 }

 //elimina una directory dal server remoto a partire dalla directory corrente
 function eliminaDirectory($dir){
 @ftp_rmdir($this->connect, $dir) or die('La directory non esiste o non hai i permessi per eliminarla.');

 }

 //chiudo la connessione
 function close(){
 ftp_quit($this->connect) or die("Si è verificato un errore durante la chiusura della connessione al server ftp");
 }

 //Verifico il tipo di file in base all'estensione
 function verificaFile($nomeFile, $tipo){
 $ext = explode('.', trim($nomeFile));
 $num = count($ext);
 if($ext[$num-1]=='jpg' || $ext[$num-1]=='pdf')
 if($tipo=='put')
 return $this->verifica($nomeFile, $ext[$num-1]);
 elseif($tipo=='get')
 return $this->verificaLocale($nomeFile, $ext[$num-1]);
 }

 //funzione che modifica i caratteri speciali e cambia il nome del file se dovesse già esistere sul server
 function verifica($nomeFile, $ext){
 $nomeFile=stripcslashes($nomeFile);
 $nomeFile=str_replace("'"," ",$nomeFile);
 $nomeFile=str_replace("`"," ",$nomeFile);
 $nomeFile=str_replace("\\"," ",$nomeFile);
 $nomeFile=str_replace("&"," ",$nomeFile);
 $nomeFile=str_replace("%"," ",$nomeFile);
 $nomeFile=str_replace("\""," ",$nomeFile);
 $nomeFile=str_replace("à","a",$nomeFile);
 $nomeFile=str_replace("è","e",$nomeFile);
 $nomeFile=str_replace("é","e",$nomeFile);
 $nomeFile=str_replace("ì","i",$nomeFile);
 $nomeFile=str_replace("ò","o",$nomeFile);
 $nomeFile=str_replace("ù","u",$nomeFile);

 if($this->verificaEsistenza($nomeFile)){
 $temp=substr($nomeFile, 0, -4);
 if($ext=='jpg'){
 $nomeFile=$temp.'_.jpg';
 }
 elseif($ext=='pdf'){
 $nomeFile=$temp.'_.pdf';
 }
 $nomeFile=$this->verifica($nomeFile, $ext);
 }
 return $nomeFile;

 }

 /*
 Verifico che un file esista già sul server a cui mi collego, la funzione ftp_size restituisce la dimensione del file se trova un file con quel nome nella directory indicata, altrimenti restituisce -1
 */
 function verificaEsistenza($file){
 $verifica = ftp_size($this->connect, $file);
 if($verifica==-1)
 return false;
 else
 return true;
 }

 //funzione che modifica i caratteri speciali e cambia il nome del file se dovesse già esistere in locale
 function verificaLocale($nomeFile, $ext){

 if(file_exists($nomeFile)){
 $temp=substr($nomeFile, 0, -4);
 if($ext=='jpg'){
 $nomeFile=$temp.'_.jpg';
 }
 elseif($ext=='pdf'){
 $nomeFile=$temp.'_.pdf';
 }
 $nomeFile=$this->verificaLocale($nomeFile, $ext);
 }
 return $nomeFile;

 }

}
?>

La classe utilizza le funzioni messe a disposizione da PHP per il trasferimento file utilizzando il protocollo FTP; in aggiunta, ho inserito delle funzioni per la verifica che un file si trovi già sul server (verificaEsistenza()) o, se stiamo prelevando dal server, se il file esiste in locale (verificaLocale()). Non utilizzando tali funzioni i file, se già esistenti, vengono sovrascritti senza alcun output per l’utente.
Inoltre, sono state implementate le funzioni verifica() e verificaFile() che hanno il compito di modificare il nome del file evitando i caratteri speciali e le lettere accentate e, se il file si trova già sul server, modificandone il nome inserendo degli underscore dopo il nome e prima dell’estensione. Naturalmente il bisogna conoscere il tipo di file, infatti la classe è impostata per il trasferimento di file immagini (jpg) e pdf. La classe gestisce questi 2 tipi di file ma è possibile adattarla facilmente per tipi di file qualsiasi in base alle necessità.

Gli unici parametri che vanno inseriti all’interno della classe sono i dati per l’accesso FTP al server remoto, tutto il resto verrà effettuato tramite funzioni d’accesso. Il costruttore simpleFtp() ha il compito di effettuare la connessione al server FTP e la relativa login. Seguono le funzioni principali per l’utilizzo della classe, ovvero trasferisci(), preleva() e cancella(). Tutte queste funzioni leggono il percorso del file sul server FTP a partire dalla root, quindi è necessario inserire il percorso completo al file oppure spostarsi, prima di tali operazioni, sulla directory di lavoro con la funzione cambiaDirectory().

Successivamente sono state implementate altre funzioni molto utili in alcuni ambiti, e sono la funzione cambiaPermessiFile() e rinomina(). La prima serve per modificare i permessi d’accesso al file, ad esempio si può impostare un file con i permessi 0777; la seconda serve per rinominare un fle remoto. Ovviamente, per entrambe le funzioni, si verifica prima se il file sul server esista.

La funzione directoryCorrente() restituisce il percorso della cartella del server su cui si sta lavorando mentre le funzioni creaDirectory() ed eliminaDirectory() sono utilizzate, rispettivamente, per creare ed eliminare cartelle sul server FTP; visualizzaFile(), invece, restituisce un array con la lista dei file presenti nella direcotory passata.
Infine, la funzione close() termina la connessione con il server FTP.

Per rendere maggiormente utilizzabile la classe è possibile modificarne il costruttore in modo da prendere dall’esterno i parametri per la connessione. In altri articoli, se ce ne sarà bisogno, integrerò la classe per l’utilizzo di connessioni cifrate per lo scambio di dati in FTP.

Script Php per ricerche fulltext con MySQL

Nel precedente articolo abbiamo visto la sintassi SQL per l’utilizzo degli indici fulltext nelle ricerche sul database. In questo articolo vedremo un semplice script per l’utilizzo pratico di tale ricerca utilizzando una classe appositamente scritta.

Supponiamo di avere un form con un campo di ricerca del tipo:

<form name="cerca" method="post" id="cerca" action="esito_ricerca.php">
<input type="text" name="campo" />
<input type="submit" name="invia" /></form>

Al submit si aprirà una nuova pagina php nella quale riprenderemo i valori passati ed eseguiremo le operazioni necessarie per la ricerca e la visualizzazione dei risultati. Per semplificare le cose utilizzeremo la seguente classe:

< ?php

class Ricerca
{
var $campi;
var $tabella;
var $key;
var $tuple;

function Ricerca($key, $tabella, $campi)
{
$this->key = $key;
if($tabella!="")
$this->tabella = $tabella;
if($campi!="")
$this->campi = $campi;
$this->pulisciStringa();
}

function Query()
{

$query = "SELECT *, MATCH($this->campi) AGAINST('$this->key' IN BOOLEAN MODE) AS attinenza FROM $this->tabella WHERE MATCH($this->campi) AGAINST('$this->key' IN BOOLEAN MODE) ORDER BY attinenza DESC";

$this->tuple = mysql_query($query);

}

function pulisciStringa()
{
$keyMod = strip_tags($this->key);
$keyMod = mysql_real_escape_string($keyMod);
$this->key = trim($keyMod);
}

function ricercaParole()
{
$word = explode(' ', trim($this->key));
$num = count($word);

$i=0;
while($i< $num){
$word[$i] = '+'.$word[$i];
$i++;
}
$this->key = implode(' ',$word);
}

function ricercaFrase()
{
$word = $this->key;
$word = '"'.$word.'"';
$this->key = $word;
}

}

?>

La classe è abbastanza semplice, la funzione Ricerca() ha il compito di inizializzare alcuni parametri necessari per l’esecuzione della ricerca, in particolare riceve in ingresso le chiavi di ricerca, la tabella su cui effettuare la query e i campi fulltext da analizzare.
La funzione Query() effettua la query vera e propria riportando i valori ordinati per attinenza. La funzione pulisciStringa() serve per ripulire il codice e aumentarne la sicurezza. In tale funzione si possono fare tutti i controlli e le sostituzioni di caratteri che si vogliono. Se all’interno del database i caratteri sono codificati nelle loro rispettive entità html (situazione che capita spesso se si usa un editor wysiwyg) allora è possibile utilizzare al posto di mysql_real_escape_string() la funzione htmlentities().
Ho inserito nella classe anche 2 funzioni che possono essere molto utili. La prima è ricercaParole() che ha il compito di inserire davanti a ogni parola il segno “+”. Utilizzare tale parametro equivale a effettuare una ricerca di “tutte le parole” passate, ovvero tra i risultati ci saranno soltanto tuple che contengono tutte le parole di ricerca passate. La seconda è, invece, ricercaFrase() che ha il compito di restituire tra i risultati solamente tuple che contengono la chiave di ricerca così com’è. E’ utile per ricercare una “frase esatta” all’interno dei campi e si attua inserendo la chiave di ricerca all’interno di doppi apici.

Vediamo come utilizzare la classe in una ricerca utilizzando il form precedente. Supponiamo che la connessione al database sia già stata effettuata, avremo:

$campo=$_POST['campo'];

$search = new Ricerca($campo, 'tabella', 'campo1, campo2');
$search->Query();
$cont = mysql_num_rows($search->tuple);

if($cont<1)
echo "Non vi sono risultati per la ricerca selezionata";
else{
while ($row = mysql_fetch_array($search->tuple))
{
echo $row['campo1'];
}
}

Si riprende il campo e si inizializza la classe attraverso il costruttore passandogli la chiave di ricerca, la tabella e i campi da analizzare. Successivamente effettuiamo la query e procediamo alla visualizzazione dei risultati.

Per avere tra i risultati della ricerca solo i risultati che contengono tutte le parole passate inseriamo prima della Query() la funzione ricercaParole():

$search = new Ricerca($campo, 'tabella', 'campo1, campo2');
$search->ricercaParole();
$search->Query();

mentre per ricercare una frase esatta:

$search = new Ricerca($campo, 'tabella', 'campo1, campo2');
$search->ricercaFrase();
$search->Query();

La classe vista finora è molto semplice e funzionale, può essere ampliata a piacimento per implementare funzioni che possono essere d’aiuto nel personalizzarla a seconda dei propri scopi.

Motore di ricerca per MySQL con indici fulltext

In questo articolo vedremo come creare un semplice motore di ricerca in php utilizzando gli indici fulltext di MySQL. Gli indici fulltext sono un meccanismo che consente di velocizzare le ricerche le quali risultano così molto più efficienti rispetto l’utilizzo del comando LIKE. Inoltre, con questo meccanismo, i risultati saranno visualizzati in ordine di attinenza con le chiavi di ricerca.
Affinché si possano utilizzare le ricerche fulltext bisogna prima preparare il database e, successivamente, il codice per effettuare le ricerche.

Preparazione del database
Condizione necessaria per l’utilizzo di questo tipo di ricerche è l’impostazione dei campi con indice fulltext. Tale impostazione può essere effettuata al momento della creazione della tabella o successivamente. Vediamo degli esempi.
Per impostare i campi fulltext alla creazione della tabella basta inserire nella query SQL la stringa FULLTEXT (campo1, campo2), dove i campi possono essere 1, 2 o più e sono separati da virgole. Es:

CREATE TABLE tabella(
id INT AUTOINCREMENT NOT NULL PRIMARY KEY
campo1 VARCHAR(255),
campo2 TEXT,
FULLTEXT (campo1, campo2)
);

Per inserire gli indici in una tabella già esistente basta invece utilizzare la sintassi:

ALTER TABLE tabella ADD FULLTEXT(campo1,campo2);

Se non avete voglia di scrivere la query a mano potete anche utilizzare l’interfaccia di phpmyadmin per impostare i campi: selezionate la tabella su cui aggiungere i campi, selezionate “struttura” e nella riga del campo da impostare troverete come ultima opzione una casellina che dice FULLTEXT (testo completo).

Nota: affinché si possano utilizzare gli indici fulltext è necessario che la tabella utilizzi l’engine MyISAM e che i campi siano campi di testo (VARCHAR, TEXT…..).

Sintassi per le ricerche
Il cuore delle ricerche fulltext è rappresentato dai comandi MATCH(….) e AGAINST(….) nei quali vanno inseriti rispettivamente il nome dei campi da analizzare e le chiavi di ricerca. Un esempio pratico è il seguente:

SELECT *
FROM tabella
WHERE MATCH(campo1, campo2) AGAINST(‘key’);

Vi saranno risultati solo se vi sarà un valore di attinenza con la chiave di ricerca. MATCH e AGAINST producono un valore di attinenza in virgola mobile, se tale valore è zero non vi saranno risultati. La query così formata però ha il difetto di non riportare i risultati ordinati per attinenza. Quella che segue è una query più completa e funzionale.

SELECT *, MATCH(campo1, campo2) AGAINST(‘key’, IN BOOLEAN MODE) AS attinenza
FROM tabella
WHERE MATCH(campo1, campo2) AGAINST(‘key’, IN BOOLEAN MODE)
ORDER BY attinenza DESC;

Tale query restituisce i risultati ordinati per attinenza per come viene calcolata dai comandi MATCH e AGAINST. Nella clausola AGAINST viene utilizzato altresì la dicitura IN BOOLEAN MODE, che permette di utilizzare operatori booleani per personalizzare e migliorare le ricerche.

Operatori di ricerca
Oltre ai normali operatori AND e OR logici, nelle ricerche fulltest possono essere inseriti altri tipi di operatori per meglio filtrare i risultati, tra cui:

  • Operatore +: indica che la parola a cui è anteposto deve essere presente in ogni record restituito;
  • Operatore -: indica che la parola a cui è anteposto non deve essere presente in alcun record restituito;
  • Operatori < e >: sono utilizzati per variare il contributo che la parola dona alla rilevanza (score) di un singolo record;
  • Operatori (): le parentesi sono utili al fine di raggruppare tra loro sotto-espressioni che avranno un più alto grado di precedenza;
  • Operatore ~: viene utilizzato per segnare una parola in modo che questa diminuisca l’attinenza di un record (viene utilizzato per marcare le cosidette bad words);
  • Operatore *:  è l’unico operatore che può essere posto alla fine della parola o di una parte di essa. Serve ad indicare che caratteri qualsiasi possono seguire la parola o precederla;
  • Operatore “: le parole o frasi racchiuse tra apici doppi obbligheranno MySQL ad effettuare ricerche sulla frase completa e non su ogni singola parola.

Nel prossimo articolo vedremo come usare praticamente le ricerche fulltext con php utilizzando una semplice classe.

Prelevare codice video youtube da URL o da codice incorporato con object o iframe

Mi è capitato spesso, nell’ultimo periodo, di dover inserire dei video youtube in siti web che richiedevano però modifiche del player, in particolare della sua dimensione. Per semplificare le cose ho scelto di incorporare nelle pagine uno stesso codice già personalizzato e passare a tale codice l’id del video scelto dal cliente.
Visto che ogni cliente ha un pensiero a sé stante, ho dovuto personalizzare il tutto in base alla scelta dell’utente di inserire l’URL del video, il vecchio codice di incorporamento o il nuovo codice utilizzato da youtube con il tag <iframe>. Per chi non lo sapesse, youtube ha da poco modificato il tipo di codice da incorporare con un codice che utilizza <iframe>; tale soluzione permette all’utente finale di visualizzare il video con tecnologia flash oppure HTML5 ed è particolarmente indicato per la visualizzazione dei video su dispositivi mobile. Tuttavia, il vecchio codice (tag <object>) è ancora disponibile su richiesta spuntando la voce “Utilizza vecchio codice di incorporamento” posto poco sotto il codice da incorporare.

Ho implementato una piccola funzione per l’estrazione dell’id del video in tutti e tre i casi. La riporto di seguito.

<?php
function estraiCodice($codice){
$codMod = $codice;
$tipo='';
$idVideo='';

//Verifico il tipo di codice
if(strstr($codMod, 'iframe'))
$tipo='iframe';
elseif(strstr($codMod, 'object'))
$tipo='object';
elseif(strstr($codMod, 'watch?v='))
$tipo='link';

//Operazioni nel caso di codice tradizionale con object
if($tipo=='object'){
$part = explode('?', $codice);
$cod = explode('.com/v/',$part[0]);
$idVideo = $cod[1];
}
//Operazioni nel caso di nuovo codice con iframe
elseif($tipo=='iframe'){
$part = explode('embed/', $codice);
$cod = explode('"',$part[1]);
$idVideo = $cod[0];
}
//Operazioni nel caso di inserimento di URL
elseif($tipo=='link'){
$part = explode('?v=', $codice);
if(strstr($part[1], '&')){
$cod = explode('&',$part[1]);
$idVideo = $cod[0];
}else{
$idVideo=$part[1];
}
}

return $idVideo;
}
?>

Il codice è molto semplice. Per prima cosa verifico il tipo di incorporamento che è stato inserito e, successivamente, effettuo le operazioni necessarie per estrarre l’id, che è il risultato che voglio ottenere.

SEO – L’head, i tag meta e il file robots.txt

Per un buon posizionamento nei motori di ricerca è importante strutturare la prima parte della pagina Web in maniera appropriata popolando la parte <head> attraverso i principali tag. Tra questi citeremo i tag <title> e <meta>.

<title>

Il più importante tra i tag dell’<head> è sicuramente il tag <title> che deve contenere il titolo della pagina Web. E’ un parametro molto utilizzato dai motori di ricerca per l’indicizzazione della pagina quindi le parole contenute al suo interno devono rispecchiare le principali keyword contenute nella pagina.

<meta>

Vi sono diversi parametri che si possono impostare attraverso il tag <meta>, tra di essi però quelli che interessano maggiormente il SEO sono i parametri description, keywords e robots. Il loro utilizzo è del tipo:

<meta name="description" content="contenuto del tag"></meta>
<meta name="keywords" content="contenuto del tag"></meta>
<meta name="robots" content="contenuto del tag"></meta>

Vediamoli in dettaglio:

  • description, è utilizzato per fornire una descrizione della pagina e deve essere significativo in quanto viene spesso utilizzato dai motori per visualizzare quella pagina tra i risultati. Conviene non inserire mai troppe informazioni e limitarsi a una descrizione breve e concisa che contenga le principali keyword contenute nella pagina cercando di non superare i 100-150 caratteri;
  • keywords, contiene le principali keywords (una o più parole) della pagina in maniera non discorsiva, quasi ad elenco. Le keyword vengono separate tra loro da virgole e conviene non andare oltre le 25-30 keywords per pagina. Un tempo questo tag forniva una importante indicazione per i motori, oggi invece è quasi “evitato” (google lo considera ormai pochissimo) per l’uso improprio e indiscriminato che ne è stato fatto negli anni passati;
  • robots, serve a indicare al motore di ricerca se seguire e/o indicizzare la pagina Web. Il content di questo tag non è libero come per gli altri 2 ma bensì può assumere solo 4 configurazioni:


<meta name="robots" content="index, follow"></meta>
<meta name="robots" content="noindex, follow"></meta>
<meta name="robots" content="index, nofollow"></meta>
<meta name="robots" content="noindex, nofollow"></meta>

La parte index sta a indicare al motore di ricerca che può indicizzare la pagina e quindi può farla, eventualmente, visualizzare tra le SERP; viceversa, noindex comunica al motore che quella pagina non deve essere indicizzata. La parte follow indica al motore che può seguire i link contenuti nella pagina in questione per poter indicizzare le pagine ad essa collegate; nofollow indica al motore di non seguire i link all’interno della pagina. E’ preferibile utilizzare il meno possibile il tag robots e preferire l’inserimento del file robots.txt che vedremo tra poco. NOTA: se tale tag viene omesso di default la configurazione è index,follow.

Precisiamo una cosa importante: nei tag appena visti sopra, ovvero title, meta description e meta keywords utilizzate sempre parole e frasi contenuti nella pagina Web! L’utilizzo indiscriminato di parole e frasi non contenute nella pagina ma inseriti in tali tag potrebbe portare a penalizzazioni e quindi alla visualizzazione della pagina molto più in basso nelle SERP!

Terminiamo questo articolo spendendo due parole sul file robotx.txt che, come accennato sopra, serve a indicare al motore di ricerca quali pagine indicizzare e quali no. Tale file va inserito nella root del sito, ovvero dove può essere visualizzato attraverso l’url principale. Un esempio molto semplice di tale file è il seguente:


User-Agent: *
Disallow: /pag_protetta/
Allow:/

Questo robots.txt si riferisce a tutti i motori di ricerca (User-Agent: *) e ci dice che i file all’interno della cartella “pag_protetta” (la vostra cartella che non volete far indicizzare) non vanno indicizzati mentre ciò non vale per tutte le altre pagine (Allow:/). Si possono personalizzare le regole in base ai motori di ricerca inserendo al posto di “User-Agent: *” il nome dello spider desiderato (googlebot per google, slurp per yahoo ecc…).

Invio di newsletter in PHP e gestione dello spam

In questi giorni mi sono trovato a risolvere un problema non di poco conto: le mail inviate come newsletter da alcuni siti vengono viste dai riceventi come spam. Ciò era dovuto, nella maggior parte dei casi, alla mancanza di alcuni header nelle impostazioni della mail. Purtroppo non tutti i problemi si sono risolti; infatti, su yahoo e, soprattutto, hotmail le mail venivano viste ancora come posta indesiderata, mentre l’invio su account come gmail, libero e alice non davano alcun problema. Ma procediamo con ordine e analizziamo il codice per l’invio delle mail.

Utilizziamo la classe PHPMailer per gestire in modo estremamente semplice l’invio delle mail. Per utilizzarla scarichiamo il pacchetto e inseriamo all’interno del nostro codice il file class.phpmailer.php:

require_once("include/class.phpmailer.php");

dopodiché si procede con l’inserimento delle varie opzioni:

$mail = new PHPMailer();
$mail->IsSMTP();                    // attiva l'invio tramiteSMTP
$mail->Host     = "vostro.server.smtp"; // indirizzo smtp
$mail->From     = "vostra@mail.com";
$mail->FromName = "Vostro nome";
$mail->AddReplyTo('vostra-mail@reply.com');
$mail->Sender = "vostra@mail.com";
$mail->AddAddress(mail@destinatario.com);
$mail->IsHTML(true);
$mail->Subject  =  "Oggetto della mail";
$mail->Body     =  "Corpo della mail";
if(!$mail->Send()){
echo "Si è verificato un errore nell'invio della mail";
}

Il codice è molto semplice, si istanzia un oggetto della classe in questione e abilitiamo l’invio tramite SMTP attraverso il metodo IsSMTP(). Si inseriscono i propri dati per completare le intestazioni e l’indirizzo del destinatario della mail; con il metodo IsHTML(true) impostiamo l’invio della mail come text/html così da poter inserire i tag html per gestire il formato della mail (ovviamente se è una mail di solo testo si può omettere, anzi è consigliabile come vedremo dopo). Dopo aver inserito l’oggetto e il corpo si effettua l’invio tramite il metodo Send().

Sulla classe PHPMailer ci sono da dire altre 2 cose importanti: tramite di essa si posso inviare email anche tramite server SMTP che richiedono l’autenticazione inserendo i seguenti parametri:

$mail->Username =  "username del server SMTP"; //di solito la mail utilizzata
$mail->Password = 'password'; //di solito la password della mail
$mail->SMTPAuth = true;

oppure inserire degli allegati attraverso il parametro:

$mail->AddAttachment("filename_1.zip");

Anche se in maniera breve, abbiamo fatto una panoramica abbastanza esauriente sull’utilizzo della classe PHPMailer. Con le impostazioni viste sono riuscito a non avere molti problemi con i vari gestori di account di posta che analizzano principalmente le intestazioni con i loro filtri antispam. Purtroppo è il livello del filtro che fa si che la nostra email sia considerata come spam oppure no. Di solito vi è un indice numerico che stabilisce un livello massimo di tolleranza e ogni “imprecisione” o “problema” rilevato sui vari parametri della mail (intestazione, oggetto, corpo…) incide per un valore in base alla gravità. Se la somma di tali valori supera il livello massimo di tolleranza l’email verrà vista come spam.

Se la vostra mail è puro testo non ci dovrebbero essere molti problemi avendo tutte le impostazioni apposto, al contrario, invece, se la mail contiene codice html, i filtri antispam sono molto più restrittivi soprattutto in presenza di immagini. Per cercare di non incorrere in penalizzazioni bisogna inserire un codice html il più possibile pulito e accessibile. Bisogna inserire tutti i tag in ordine con la relativa chiusura secondo la struttura

<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1" />
<title>Title della mail</title>
</head>

<body>
<!-- Corpo della mail -->
</body>
</html>

All’interno del body possiamo inserire tutti i tag che ci servono per formattare come meglio crediamo la mail (<p>, <table> ecc..) ricordandoci 3 importanti accorgimenti:

  1. se inseriamo immagini inseriamo SEMPRE gli attributi alt e title;
  2. l’attributo title va inserito anche nei link inseriti attraverso il tag <a>;
  3. se inseriamo immagini e/o molti tag html dobbiamo inserire anche abbastanza testo; da prove da me effettuate  una mail con anche solo un’immagine all’interno e poco testo viene penalizzata, mentre se il testo è abbastanza passa più facilmente senza penalizzazioni.

Rispettando queste semplici regole sono riuscito a far pervenire, anche a utenti hotmail, la mail senza che il filtro antispam la taggasse come spam. Naturalmente in molti account è possibile personalizzare la sensibilità del filtro che potrebbe dare problemi anche con accorgimenti più accurati.

L’ultimo argomento dell’articolo riguarda l’analisi di una mail taggata come spam se l’accout ci fornisce le informazioni sulle penalizzazioni effettuate dal filtro antispam. Alcuni account (come gli account  email creati su aruba, ad esempio) ci forniscono tali informazioni. Vediamo un esempio pratico di una mail taggata come spam:


Content analysis details:   (5.2 points, 5.0 required)
pts rule name              description
---- ---------------------- ------------------------------
--------------------
-0.0 NO_RELAYS              Informational: message was not relayed via  SMTP
0.0 HTML_MESSAGE           BODY: HTML included in message
1.7 MIME_HTML_ONLY         BODY: Message only has text/html MIME parts
2.5 HTML_IMAGE_ONLY_16     BODY: HTML: images with 1200-1600 bytes of  words
1.1 HTML_MIME_NO_HTML_TAG  HTML-only message, but there is no HTML tag
-0.0 NO_RECEIVED            Informational: message has no Received  headers
Questa situazione ci informa che il filtro è impostato su una sensibilità massima pari a 5.0 (5.0 required) ma l’email ha riportato un punteggio di 5.2 (5.2 points). Dall’analisi si evince che la mail era stata impostata im maniera errata, dove mancavano i tag più importanti come il tag <html> (“1.1 HTML_MIME_NO_HTML_TAG  HTML-only message, but there is no HTML tag”), era formata in gran parte da codice html con poco testo (“1.7 MIME_HTML_ONLY BODY: Message only has text/html MIME parts”) e il testo era insufficiente anche rispetto alle immagini inserite (2.5 HTML_IMAGE_ONLY_16 BODY: HTML: images with 1200-1600 bytes of words). Per informazioni più dettagliate sui vari tipi di errore si veda il seguente link aggiornato alla versione 3.3 che è quella più aggiornata al momento della scrittura dell’articolo.

SEO – Introduzione ai motori di ricerca

Al giorno d’oggi è sempre più frequente ricercare qualsiasi informazione attraverso i motori di ricerca, si arriva persino a inserire l’URL di un sito sul motore invece che sulla barra degli indirizzi! Si può ben capire che avere il proprio sito nelle prime posizioni risultanti dalla ricerca è un fattore molto importante soprattutto in ambito commerciale; spesso le aziende pagano i motori per far si che il loro sito risulti bene in vista se vengono digitate alcune parole chiave (keyword) come nel caso di google con google adwords, che propone dei link “sponsorizzati” in cima alla lista dei risultati della ricerca o inseriti laterali alla stessa pagina. Tale servizio, però, si paga “a click” e in base alla mole di visitatori il costo salirebbe vertiginosamente: in questo contesto nasce la scienza che studia in che modo funziona l’algoritmo di ricerca dei motori e le relative applicazioni pratiche per poter far comparire un sito nelle prime posizioni delle ricerche in relazione all’utilizzo di determinate keyword. Tali procedure prendono il nome di ottimizzazione dei motori di ricerca o Search  Engine Optimization (SEO)

E’ stato precedentemente citato google non a caso. Il colosso di Mountain View, infatti, è il motore di ricerca più utilizzato al mondo e il suo algoritmo di ricerca è ancora poco chiaro in tutti i suoi punti, però si hanno molte infomazioni su come lavora. La nostra trattazione di SEO consterà maggiormente su come ottimizzare una pagina web e/o un intero sito internet per google.

L’attività di SEO è un’operazione che va effettuata sia sul codice HTML che sui contenuti, non basta infatti inserire dei tag <meta> al posto giusto per fare SEO, quello serve ma non è abbastanza: i contenuti di una pagina web svolgono un ruolo importante nel farla posizionare bene utilizzando vocaboli appropriati che possano consentire una migliore visibilità da parte dei motori. L’ottimizzazione sul codice verrà trattata in un altro articolo.

Come avviene la scansione di un sito da parte di un motore di ricerca? La ricerca delle pagine web avviene attraverso meccanismi automatizzati, da script che analizzano un sito web in maniera iterativa seguendo i link che vi sono al suo interno partendo dall’URL principale fino alle pagine più interne. Tali script prendono il nome di crawler o spider. Ogni motore ha uno spider apposito, quello di google di chiama googlebot, di Yahoo si chiama Yahoo! Slurp e così via…. Lo spider continua la scansione in tutte le pagine senza fare distinzione tra le cartelle, andando così a indicizzare (e quindi rendere potenzialmente pubblici) anche file e/o pagine che si vorrebbero tenere lontano dai motori di ricerca. Per limitare la scansione si può utilizzare un file che si deve chiamare robots.txt nella root del sito indicando le directory da non indicizzare e alcune regole da utilizzare.
Importante
: il crawler dovrebbe non andare a leggere il contenuto delle cartelle che sono state indicate nel robots.txt, ma alcuni crawler lo fanno comunque, è bene tenerlo presente. Googlebot segue bene le indicazioni inserite sul robots.txt.

Terminiamo questa breve introduzione teorica sul SEO introducendo dei parametri molto cari a google: link popularity e page rank. Ogniqualvolta si effettua una ricerca si ha un elenco ordinato di risultati che prendono il nome di search engine result page (SERP). A parità di tag e di contenuti, un sito può risultare molto più in alto nelle SERP di un altro proprio in base a questi due parametri.
La link popularity è il numero dei link che puntano a una determinata pagina Web e indica la “popolarità” di un sito. Infatti, un link verso una pagina Web di un sito da parte di un altro può essere visto come un “consiglio” hai visitatori e quindi l’indicazione che il sito vale la pena di essere visitato.
Il page rank può essere visto come una link popularity “pesata” dove ci sono link che “valgono” di più e link che “valgono” di meno. Esso è un valore che va da 0 a 10 e si calcola in base al seguente algoritmo

formula per il calcolo del page rank da parte di google

formula per il calcolo del page rank da parte di google

Dove:

  • PR[A] è il valore di PageRank della pagina A che vogliamo calcolare.
  • n è il numero di pagine che contengono almeno un link verso A. Pk rappresenta ognuna di tali pagine.
  • PR[Pk] sono i valori di PageRank di ogni pagina Pk.
  • C[Pk] sono il numero complessivo di link contenuti nella pagina che offre il link.
  • d (damping factor) è un fattore deciso da Google e che nella documentazione originale assume valore 0,85. Può essere aggiustato da Google per decidere la percentuale di PageRank che deve transitare da una pagina all’altra e il valore di PageRank minimo attribuito ad ogni pagina in archivio.

Dalla formula si nota quindi che all’aumentare del numero di link complessivi dei siti che puntano ad A il PageRank aumenta. (Fonte Wikipedia)

Ovviamente, la trattazione di oggi non esaurisce tutti gli argomenti teorici riguardanti il SEO, ma è la base per poter comprendere meglio la parte pratica che verrà sviluppata nel prossimo articolo.