Uno script Gulp per automatizzare la compilazione dei files Sass (scss)

Gulpjs

Gulp js è una libreria javascript che permette di automatizzare svariate tipologie di noiose procedure che gli sviluppatori normalmente fanno “a mano”.

Proprio in questa direzione ho deciso di scrivere un breve script gulp che consente di automatizzare la ricompilazione dei fogli di stile SASS (scss), per evitarmi di lanciare, ad ogni modifica dei files, il comando sass sorgente.scss destinazione.css.

L’unico prerequisito per utilizzare gulp è di aver installato Nodejs ed il suo package manager npm (che viene installato di default insieme a node). Una volta installato node e scaricati i sorgenti del mio script basterà lanciare:

sudo npm install

…ed npm installerà per voi tutte le dipendenze necessarie!

Lo script prevede due modalità di esecuzione tramite i seguenti comandi:

  • gulp: compila i vostri scss presenti nella sottocartella src in un unico css nella root directory minifizzato (sass –style compressed)
  • gulp dev: compila gli scss in modalità espansa (sass –style expanded)

Questi due comandi avviano un task che rimane “in ascolto” e ad ogni modifica di un file scss rilancia il comando evitando il noioso compito di lanciare ogni volta la compilazione dei files per vedere le modifiche allo stile delle vostre web app/siti. In questo modo potrete scrivere le direttive di stile come si faceva prima dell’avvento di SASS/LESS e vedere immediatamente le nuove modifiche “live”.

Ho previsto un repository github “gulp-for-sass” con questo mini-progetto, scaricabile e modificabile liberamente!

Evitare il caching del css di WordPress

wordpress_logo

In questo brevissimo articolo vi dimostrerò come evitare che il browser degli utenti usi una versione non aggiornata del vostro css di WordPress.

Con questa breve funzione andremo ad inserire un parametro in fondo al richiamo del foglio di stile che inserisca il timestamp dell’ultima modifica del file, in modo che la cache continui a funzionare fino a quando non sarete voi a modificare il file.

<link href="<?php echo get_bloginfo('template_url'); ?>/style.css?v=<?php echo filemtime(get_stylesheet_directory().'/style.css'); ?>" rel="stylesheet" media="screen">

Come potete vedere abbiamo applicato il concetto al css principale di wordpress ma si può applicare a qualsiasi file css, js o di immagini. La funzione di php utilizzata è la filemtime.

Calibrare la batteria di un Macbook Pro e non solo…

E’ passato quasi un anno da quando ho abbandonato il mondo dei pc per passare a mac. Ma non voglio stressarvi su quanto mi trovi bene in questo mondo rispetto all’altro, per il momento siete salvi ;-). Voglio invece raccontarvi di una piccola scoperta fatta.

Quando ho avuto tra le mani il mio Macbook Pro, una delle prime cose su cui mi sono documentato è stato il “come usare al meglio la batteria”. Viste le passate esperienze da ignorante su questo argomento, e dato che il mio vecchio pc era arrivato ad avere una quindicina di minuti di autonomia rispetto alle due ore e mezza iniziali, desideravo non ripetere l’esperienza negativa. Dopo poche ricerche sono finito su questa pagina ufficiale di apple.

Apple consiglia di usare a piacere il proprio mac senza preoccuparsi troppo della batteria, seguendo solo alcune semplici regole. L’elemento essenziale delle batterie al litio è quello di far “muovere” gli elettroni che stanno all’interno delle batterie, è sconsigliabile quindi lavorare sempre collegati alla rete elettrica. L’uso ottimale è quello di un pendolare che usa la batteria del suo mac sul treno mentre va a lavoro e poi una volta arrivato in ufficio lo collega alla rete, per poi fare la stessa cosa nel viaggio di ritorno.

Fortunatamente non tutti prendiamo il treno, e non mi sembra cosa buona e giusta prendere il treno solo per ottimizzare l’uso della propria batteria, ma ricordatevi di farla scaricare e ricaricare di tanto in tanto.

Oltre a ciò Apple consiglia di calibrare la batteria una volta ogni due mesi (o una volta al mese ancora meglio). La calibrazione non richiede nulla di troppo faticoso ma soltanto alcuni piccoli accorgimenti. Riporto di seguito i passi da seguire per effettuare la calibrazione della batteria del vostro mac (la pagina ufficiale è questa):

  1. Collegare l’alimentatore al proprio mac e caricarlo completamente fino a quando la luce del connettore non diventa verde o quando l’icona della batteria nella barra in alto non segnala la carica completata.
  2. Lasciare l’alimentatore collegato al mac per due ore o più. Durante questa fase potete tranquillamente continuare ad usare il vostro mac.
  3. Passate almeno le due ore, scollegare il cavo dell’alimentatore con il mac acceso e iniziare (o continuare) ad usarlo per scaricare la batteria.
  4. Portare la carica della batteria al minimo, salvare i lavori e usare il mac fino a quando non va in stato di stop autonomamente.
  5. A questo punto lasciare spento il mac per almeno 5 ore
  6. Passate le 5 ore, ricollegare il mac all’alimentatore e caricarlo fino a raggiungere la carica completa (è possibile usare il mac in questa fase).

Come vi dicevo ho fatto una scoperta: sul nuovo pc che uso per lavoro ho installato Ubuntu 10.04, il quale ha l’applicazione di gestione della batteria che segnala la carica di fabbrica della batteria in uso e l’ultima carica raggiunta. Vedendo che dopo alcune scariche e ricariche l’ultima carica raggiunta si allontanava dalla carica di fabbrica ho provato a seguire la stessa procedura che uso per calibrare la batteria del mac e…. funziona! ;-). Dopo aver calibrato la batteria, Ubuntu mi segnalava l’ultima carica raggiunta identica alla carica di fabbrica.

In definitiva credo che tutti i notebook di ultima generazione (ovvero con batteria al litio) possano seguire questa procedura.

Grazie ad Apple per queste preziose indicazioni per mantenere al meglio le batterie dei nostri portatili! ;-)

Creare un web service con SOAP e PHP

Ai tempi dell’università, nel corso di programmazione in rete tenuto dal Prof. Matteo Baldoni, avevamo realizzato un ottimo progetto in Java di agenti che interagivano tra di loro.
Era anche questo una specie di servizio web anche se era realizzato con RMI ovvero Remote Method Invocation, ossia una funzione di java che consente di invocare metodi di oggetti remoti da altre java virtual machine.

Oggi visto che sono ancora a casa per l’influenza, ho deciso di documentarmi sui web services in php, dato che probabilmente dovrò realizzare un progetto in cui potrebbero tornarmi utili.

Seguendo l’ottima guida “PHP 6, Guida per lo sviluppatore” di Lecky-Thompson, Novicki e Myer (ve la consiglio vivamente se siete interessati all’argomento, è davvero ottima), ho deciso di riprodurre l’esempio di un client-server SOAP(Simple Object Access Protocol). Innanzitutto SOAP è un protocollo per lo scambio di messaggi tra agenti software, ossia un client tramite soap può richiamare funzioni di un server inviando e ricevendo parametri. E fin qui nulla di strano mi direte voi… Infatti, la cosa interessante deve ancora arrivare! La peculiarità di scrivere software implementando SOAP è che client e server possono essere scritti in linguaggi diversi, essendo quest’ultimo appunto un protocollo e non una componente software. Tutti i linguaggi più comuni hanno delle classi che implementano SOAP, sia lato server sia lato client. Diventa così facile capire che una volta scritto un server SOAP che implementa alcune funzioni, possono esserci N client che sfruttano queste funzioni per leggere dati comuni o interagire con applicazioni sul web.

Ecco allora che ci spieghiamo come sia possibile che tutte le applicazioni web più famose, da quelle di google, a facebook fino a twitter, mettano a disposizione metodi per interagire dall’esterno con i loro servizi (le famose API, Application Programming Interface).

Come vi dicevo ho messo in pratica l’esempio che ho trovato sulla guida di PHP, potete raggiungerla a questo indirizzo. L’esempio non fa altro che realizzare un server che ha un metodo che prende in input un nome e restituisce un saluto, comprensivo del nome inviato. Il client ovviamente preso in input il nome invia la richiesta al server e stampa il saluto ricevuto. Nulla di complicato, ma si riescono ad intuire le potenzialità di questo protocollo.

I due script in php come vedrete fra poco, sono molto semplici, e non richiedono più di una decina di righe di codice ciascuno, la parte fondamentale di questo esempio è però il file wsdl, ossia il file xml di dichiarazione dei metodi messi a disposizione dal server. Questo file non è indispensabile ma è utile a chi implementa i client per sfruttare tutte le funzioni messe a disposizione da SOAP.

Come vi dicevo dal lato server il codice php è semplice:

function sayHello($name){
    $salutation="Ciao ".$name.", sarai lieto di sapere che sto funzionando!";
    return $salutation;
}
$server= new SoapServer("test.wsdl");
$server->addFunction("sayHello");
$server->handle();

Il file xml per le dichiarazioni è invece un po’ più complesso ma con un po’ di attenzione non sarà difficile comprenderne il significato:

<?xml version="1.0" encoding="UTF-8" ?>
<definitions name="test"
targetNamespace="http://URL_CARTELLA_SERVER_SOAP"
xmlns:tns="http://URL_CARTELLA_SERVER_SOAP"
xmlns:soap="http://schemas.xmlsoap.org/wsdl/soap/"
xmlns:xsd="http://www.w3.org/2001/XMLSchema"
xmlns:soapenc="http://schemas.xmlsoap.org/soap/encoding/"
xmlns:wsdl="http://schemas.xmlsoap.org/wsdl/"
xmlns="http://schemas.xmlsoap.org/wsdl/">

    <message name="sayHelloRequest">
        <part name="name" type="xsd:string"/>
    </message>
    <message name="sayHelloResponse">
        <part name="salutation" type="xsd:string"/>
    </message>

    <portType name="sayHelloPortType">
        <operation name="sayHello">
            <input message="tns:sayHelloRequest" />
            <output message="tns:sayHelloResponse" />
        </operation>
    </portType>

    <binding name="sayHelloBinding" type="tns:sayHelloPortType">
        <soap:binding style="rpc" transport="http://schemas.xmlsoap.org/soap/http" />
        <operation name="sayHello">
            <soap:operation soapAction="" />

            <input>
                <soap:body use="encoded" namespace="" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
            </input>
            <output>
                <soap:body use="encoded" namespace="" encodingStyle="http://schemas.xmlsoap.org/soap/encoding/" />
            </output>
        </operation>
    </binding>
    <documentation>UNA VOSTRA DESCRIZIONE DEL SERVIZIO</documentation>
    <service name="sayHelloService">
        <port name="sayHelloPort" binding="sayHelloBinding">
            <soap:address location="http://URL_SCRIPT_PHP_SERVER_SOAP" />
        </port>
    </service>
</definitions>

Fatto ciò, non ci resta che scrivere il codice per il client (tralascio il banale form html, ma metto a disposizione lo zip con tutto dentro):

$wsdl_url="http://URL_AL_DEL_FILE_WSDL";
if(isset($_POST['name'])){
    if($_POST['name']!=null){
        $client=new SoapClient($wsdl_url);
        print_r($client->sayHello(htmlentities($_POST['name'])));
    }
}

La cosa fondamentale per poter utilizzare SOAP è che il vostro php abbia l’estensione php_soap abilitata, ma se ho capito bene, da php6 viene inclusa di default tra le funzioni del core di php. Tra l’altro essendo inclusa nelle funzioni default di php è scritta in C per cui molto più veloce rispetto a scrivere codice php, di conseguenza, in queste applicazioni l’unico collo di bottiglia potrebbe essere la lentezza della linea o i tempi di ping/risposta di client e/o server.

Se siete pigri e volete testare il codice senza dovervi sbattere, eccolo qui, pronto per voi già impacchettato ;-)

Prossimamente testerò anche REST un altro metodo per realizzare web service con meno rogne, non serve infatti nessun file di dichiarazione, ma anche meno rigido e controllato.

Sincronizzare Google Calendar con iCal su Mac e iPhone

iCal e Google Calendar

Bentornati a tutti dalle vacanze, oggi ritorno con un articolo dedicato ai macachi come me.

Avete bisogno di tener traccia dei vostri appuntamenti, eventi, ricorrenze? Be’ esistono i calendari elettronici, oppure le agendine elettroniche, oppure le agende cartacee…. oppure Google Calendar

Ieri sera, parlavo con Denny (che devo ringraziare per l’input di questa mattina, SENZA di lui non sarei riuscito a scoprire questa sciccheria… :-P ) e mi ha detto che usava un’estensione di thunderbird per tenere traccia di tutti gli appuntamenti, eventi ecc… Siccome anche io, a lavoro, uso la stessa estensione per thunderbird, gli ho spiegato secondo me cosa non funzionava di quel sistema e cioè che gli eventi creati rimanevano sul pc e non c’era nessun metodo per ricevere avvisi via mail o meglio ancora sms. Avevo infatti provato Google Calendar e notato che aveva la splendida funzionalità di impostare gli avvisi via sms.

Stamattina perciò dopo esserci ritrovati su gtalk abbiamo cercato qualche sistema per sincronizzare i calendari software con il servizio di google, scoprendo che quasi tutti i calendari supportando lo standard calDav.

Vi spiego ora come sincronizzare iCal, il software per il calendario su mac, con Google Calendar:

  • nella barra dei menu, selezionare iCal->Preferenze
  • selezionare il tab “Account” e poi premere “+” per aggiungere un nuovo account.
  • come “Tipo account” dovreste già avere “Google”, se non ci fosse selezionate la voce “calDav”
  • a questo punto vi basterà inserire l’indirizzo del server google (google.com), la vostra mail completa che usate per accedere ai servizi di google e la relativa password

Ora quando creerete un nuovo evento su iCal, questo verrà automaticamente sincronizzato on-line.

La stessa cosa può essere fatta su iPhone:

  • per prima cosa collegatevi all’indirizzo https://www.google.com/calendar/iphoneselect e confermate di voler usare il calendario di google dal vostro iPhone.
  • ora andate nelle impostazioni e selezionate la voce “Mail, contatti, calendari”
  • selezionate la voce “aggiungi account” e scegliete “altro”
  • qui troverete la voce “aggiungi account calDav”
  • inserite di nuovo le informazioni relative al vostro login e al server google (google.com)

Ora avrete iCal sul vostro mac e sul vostro iPhone che salverà le informazioni su google Calendar e in qualsiasi momento potrete accedere ai vostri appuntamenti, eventi e ricorrenze

Ancora grazie a Denny per il supporto, nonostante sia dichiaratamente anti-apple :-P

Installare un server VPN con OpenVPN su Ubuntu Server

Qualche giorno fa, a lavoro ho configurato il mio primo server vpn. Avevamo la necessità di accedere alla rete dell’ufficio anche dall’esterno. Insomma ci avrebbe fatto comodo essere “virtualmente” in ufficio quando fisicamente non è possibile. Avevo ricevuto consigli in merito a queste necessità, e mi era stato detto che come OpenVPN non ce n’erano molti. Ovviamente Open VPN è un software gratuito e multipiattaforma, aveva quindi tutti i prerequisiti necessari per piacermi.

Diciamo che prima di intraprendere il lavoro ho perso qualche minuto a cercare la documentazione necessaria, che mi avrebbe accompagnato durante il cammino.

Inizialmente avevo preso un pc davvero modesto (con processore AMD Duron, qualcosa di simile al Sempron ma un po’ più vecchio ;-) ) con 40 ghiga di disco e 512 Mb di ram SO DIMM, credendo di usarlo come test per la macchina vera. Ovviamente ho installato Ubuntu server come sistema operativo, scaricando l’ultima versione (10.04) siccome è un LTS. Nell’installazione del S.O. non c’è stato alcun inghippo, oramai queste ultime versioni sono una pacchia, filano dritte dritte in pochi minuti verso il traguardo ;-).

Una volta installato Ubuntu ho seguito il wiki in inglese per la corretta installazione di open vpn. Come prima passo, la guida consiglia di configurare un bridge sulla scheda ethernet per consentire al segmento LAN di essere connesso al segmento WAN, consentendo (se si vuole) di filtrare i pacchetti che li attraversano con un firewall. Per fare ciò basta installare un pacchetto chiamato bridge-utils con il comando:

sudo apt-get install bridge-utils

Fatto ciò si deve editare il file di configurazione della rete con il comando:

sudo vim /etc/network/interfaces

modificarlo come segue:

auto lo
iface lo inet loopback

auto br0
iface br0 inet static
        address 192.168.0.10
        network 192.168.0.0
        netmask 255.255.255.0
        broadcast 192.168.0.255
        gateway 192.168.0.1
        bridge_ports eth0
        bridge_fd 9
        bridge_hello 2
        bridge_maxage 12
        bridge_stp off

Così facendo si assegna il bridge all’interfaccia eth0 con l’ip 192.168.0.10.

Adesso potete riavviare il servizio networking:

sudo /etc/init.d/networking restart

(per evitare di dover digitare sempre il comando sudo davanti ad ogni comando vi consiglio di digitare sudo su una volta per tutte)

Ora possiamo passare all’installazione vera e propria di OpenVPN:

apt-get install openvpn

Finita l’installazione del pacchetto creiamo una cartella che conterrà i programmi per generare le chiavi e le chiavi stesse:

cp -r /usr/share/doc/openvpn/examples/easy-rsa/2.0 /etc/openvpn/
mv /etc/openvpn/2.0 /etc/openvpn/easy-rsa

Dopodichè editiamo il file vars in modo da modificare le seguenti linee con le informazioni che ci riguardano:

export KEY_COUNTRY="US"
export KEY_PROVINCE="NC"
export KEY_CITY="Winston-Salem"
export KEY_ORG="Example Company"
export KEY_EMAIL="steve@example.com"

Salvate il file e chiudetelo. Accertandovi di essere loggati come utente di root, iniziate la procedura di generazione delle chiavi:

cd /etc/openvpn/easy-rsa/
source ./vars
./clean-all
./build-dh
./pkitool --initca
./pkitool --server server
cd keys
openvpn --genkey --secret ta.key
cp server.crt server.key ca.crt dh1024.pem ta.key /etc/openvpn/

Ora che abbiamo generato le chiavi e i certificati per il server procediamo a generare quelli per il client (basterà ripetere la prossima procedura modificando l’identificativo del client per generare altre chiavi/certificati):

cd /etc/openvpn/easy-rsa/
source vars
./pkitool client1

Copiate ora sul client i file:

  • /etc/openvpn/ca.crt
  • /etc/openvpn/easy-rsa/keys/client1.crt
  • /etc/openvpn/easy-rsa/keys/client1.key
  • /etc/openvpn/ta.key

Ora non ci resta che editare i file di configurazione per server e client (partiamo da una configurazione di esempio):

cp /usr/share/doc/openvpn/examples/sample-config-files/server.conf.gz /etc/openvpn/
gzip -d /etc/openvpn/server.conf.gz
vim /etc/openvpn/server.conf

Accertatevi di correggere le seguenti linee con i vostri dati:

local 192.168.0.10
dev tap0
script-security 3
up "/etc/openvpn/up.sh br0"
down "/etc/openvpn/down.sh br0"
proto tcp
;server 10.8.0.0 255.255.255.0
server-bridge 192.168.0.10 255.255.255.0 192.168.0.100 192.168.0.110
push "route 192.168.0.1 255.255.255.0"
tls-auth ta.key 0 # This file is secret
user nobody
group nogroup
cipher AES-256-CBC

La voce local sarà quella corrispondente all’indirizzo del vostro bridge, come la prima voce accanto a server-bridge. La seconda voce di server-bridge sarà la subnet mask mentre la terza e la quarta sarà il range di ip che openvpn assegnerà ai client che si connetteranno alla rete.
Il comando push “route… servirà per creare una rotta sugli indirizzi della LAN.
Fatto ciò, creiamo i due script per l’avvio e la chiusura dell’interfaccia virtuale (la tap0 che vedete nel file di configurazione). Creiamo il file up.sh come segue:

vim /etc/openvpn/up.sh
#!/bin/sh
BR=$1
DEV=$2
MTU=$3
/sbin/ifconfig $DEV mtu $MTU promisc up
/usr/sbin/brctl addif $BR $DEV

e il file down.sh così:

vim /etc/openvpn/down.sh
#!/bin/sh
BR=$1
DEV=$2
/usr/sbin/brctl delif $BR $DEV
/sbin/ifconfig $DEV down

Rendiamoli eseguibili:

chmod 755 /etc/openvpn/down.sh
chmod 755 /etc/openvpn/up.sh

Ora che il server è correttamente configurato, possiamo dare una riavviata al servizion openvpn:

/etc/init.d/openvpn/restart

Adesso passiamo al file di configurazione del client:

sudo cp /usr/share/doc/openvpn/examples/sample-config-files/client.conf /etc/openvpn

Il quale dovrà contenere:

dev tap
proto tcp
remote 192.168.0.10 1194
cert client1.crt
key client1.key
tls-auth ta.key 1
cipher AES-256-CBC

Ora copiate nella cartella di configurazione del client il file appena editato (chiamatelo client1.conf o client1.ovpn). Ovviamente si presuppone che i file delle chiavi e dei certificati siano nella stessa cartella di quest’ultimo file (sul client). Riavviate anche qui openvpn e il gioco è quasi fatto. Dico quasi perchè per potervi connettere al server dall’esterno dovrete dire al vostro router di aprirvi la porta 1194 e reindirizzare il traffico proveniente dall’esterno verso l’ip 192.168.0.10 (quello del bridge).

Ora siete davvero pronti per collegarvi dall’esterno alla vostra LAN (così com’è stato configurato openvpn non è possibile accedere da dentro la LAN alla vpn appena creata).

Spero di non aver dimenticato niente! ;-)

Che ve ne pare?

Riempire dinamicamente una jTable in Java

Ultimamente sto utilizzando intensamente Java per lavoro. Sto realizzando un gestionale abbastanza corposo, dove ho potuto sperimentare diverse cose interessanti.

Nel disegnare le interfacce, uno degli oggetti che sto trovando sempre più utile, è la jTable, nient’altro che una semplice tabella (la vecchia DataGrid di visual basic). Inizialmente avevo trovato un po’ ostico capire come funzionasse, nonostante ci fossero parecchi esempi che danno molti consigli su come usarle. Una delle pagine di esempi più complete è questa sul sito oracle.

Voglio però spendere qualche riga per spiegare come poter facilmente caricare una jTable leggendo i dati da un resultset o da un elenco qualsiasi.

Penso che il concetto più semplice per utilizzare al meglio le jTable sia implementare una List<T> (dove T può essere un array di Object o di String o una vostra classe personale, fate voi) con una ArrayList o una LinkedList. Questa lista terrà aggiornata la jTable.

Personalmente creo sempre un metodo che chiamo “refreshTable” che legge i dati dalla lista e li inserisce nella tabella. Il metodo non farà altro che usare un iteratore per scorrere la lista e creare una matrice di Object da passare alla nostra jTable per riempirla.

        //Creo array di intestazioni
        String [] headers=this.getTableHeaders();
        //Creo matrice di dati
        Object[][] data=new Object[this.lista.size()][headers.length];
        int i=0;
        for(Iterator<String[]> it=lista.iterator();it.hasNext();){
            String[] tmp=it.next();
            for(int j=0;j<tmp.length;j++){
                data[i][j]=tmp[j];
            }
            i++;
        }
        //Setto dati e intestazioni della tabella
        this.myJTable.setModel(new javax.swing.table.DefaultTableModel(data, headers){@Override public boolean isCellEditable(int rowIndex, int mColIndex) { return false; }});
        //Setto larghezza colonne
        this.setTableCellsSize(this.myJTable);
        //Imposto allinamento delle celle al centro
        DefaultTableCellRenderer renderer=new DefaultTableCellRenderer();
        renderer.setHorizontalAlignment(DefaultTableCellRenderer.CENTER);
        this.myJTable.setDefaultRenderer(this.myJTable.getColumnClass(0), renderer);
        this.myJTable.updateUI();

Così facendo abbia riempito la nostra jTable. Il metodo che fa ciò è il setModel(), al quale io passo sempre una matrice di Object che contiene i dati veri e propri e un array di String che contiene le intestazioni della tabella (che leggo dal mio metodo this.getTableHeaders() ). Oltre a questo ho creato un metodo (this.setTableCellsSize() ) che imposta la larghezza delle varie colonne della tabella:

        int prefWidth=(this.getWidth()/2)/(this.getHeadersTable()).length;
        tbl.setAutoResizeMode(jTable.AUTO_RESIZE_OFF);

        tbl.getColumnModel().getColumn(0).setPreferredWidth(prefWidth+20);
        tbl.getColumnModel().getColumn(1).setPreferredWidth(prefWidth+100);
        tbl.getColumnModel().getColumn(2).setPreferredWidth(prefWidth+20);
        tbl.getColumnModel().getColumn(3).setPreferredWidth(prefWidth-30);
        tbl.getColumnModel().getColumn(4).setPreferredWidth(prefWidth+20);
        tbl.getColumnModel().getColumn(5).setPreferredWidth(prefWidth+20);
        tbl.getColumnModel().getColumn(6).setPreferredWidth(prefWidth-20);
        tbl.getColumnModel().getColumn(7).setPreferredWidth(prefWidth+20);

Nelle ultime righe ho invece dichiarato un Renderer per settare l’allineamento al centro delle celle della jTable.

Prestate attenzione alla linea dove viene eseguita la setModel(): qui ho riscritto il metodo isCellEditable, in modo che restituisca sempre false. Così facendo qualsiasi cella della nostra jTable non potrà essere editata.

Se vi servissero esempi più dettagliati (ad esempio per inserire delle checkbox in una delle colonne o per aprire menu al pressione del tasto destro del mouse sulla tabella) fate un fischio! ;-)

Servire dinamicamente le immagini con php, Mysql e Imagick

Nessuno se ne sarà accorto ed effettivamente è un po’ impossibile notarlo se uno non lo sa ;-)

Ormai da una settimana però ho messo in funzione uno strumento “self-made” per la gestione delle immagini del mio blog.

Spulciando un po’ più attentamente google webmaster tools tra le funzioni sperimentali ho trovato un prestazioni del sito

In questa sezione google presenta un’analisi delle prestazioni del proprio sito (in termini di tempo e kilobyte di dati) e fornisce consigli su come ridurre i tempi di caricamento.

Siccome il mio hosting mi limita lo spazio web, utilizzavo un piccolo escamotage per caricare le foto del blog: le caricavo su picasa e sfruttavo i server di google per fornirle. Webmaster tools mi consigliava però di ridurre al minimo le ricerche DNS e infatti molto spesso le foto venivano reperite da diversi server di picasa. Tutto ciò contribuiva ad incrementare il tempo di caricamento del sito per cui ho preso la decisione di darmi da fare :-P

Come detto, il mio hosting mi limita lo spazio web, ma non ho limiti per quanto riguarda il db MySQL, per cui ho deciso di realizzare una mini-applicazione in php per salvare le immagini su database e servirle dinamicamente. Tutto questo con due funzioni che sfruttano la classe Imagick (installata sul server dove risiede il mio dominio).

Il concetto si basa in sostanza su tre pagine.

La prima sarà un form per far scegliere all’utente l’immagine da uploadare:

<form action="....." method="POST" enctype="multipart/form-data">.....</form>

La seconda, una pagina che riceve il parametro con l’immagine e la salva nel database:

il file è contenuto nell’array

$_FILES['image']['tmp_name']

dove image è il nome del parametro ricevuto via POST.

Qui ci servirà la prima funzione che sfrutterà la classe Imagick:

        public static function prepare_image($file){
		$img=new Imagick();
		$handler=fopen($file,'r');
		$ret=null;
		if(!feof($handler)){
			$fstr=fread($handler,filesize($file));
			$img->readImageBlob($fstr);
			/*Richiamo il metodo resize*/
			$img->setFormat('jpg');
			$img->setImageCompression(Imagick::COMPRESSION_JPEG);
			$img->setImageCompressionQuality(100);
			$ret=addslashes($img->getImageBlob());
			$img->destroy();
		}
		fclose($handler);
		return $ret;
	}

Dove la variabile $file sarà il contenuto dell’array di cui parlavamo prima. A questo punto potremo salvare il valore restituito dalla funzione nel database (il campo dovrà essere di tipo blob o meglio ancora longblob).

Fatto ciò possiamo passare alla terza pagina, quella che servirà l’immagine letta dal db.

Quest’ultima dovrà ricevere come parametro l’id dell’immagine da leggere sul db. La query la lascio fare a voi, io vi spiego la seconda funzione che ci servirà ;-) (molto più “leggera” della prima):

        public static function get_image_from_blob($blob){
		 $img=new Imagick();
		 $img->readImageBlob($blob);
		 $img->setFormat('jpg');
		 return $img;
	}

In questo caso il parametro $blob sarà il valore blob letto dal db, e la funzione ci restituirà l’immagine. A questo punto non vi resta che stampare l’immagine:

header('Content-Type: image/jpeg);
echo $img;

Abbastanza semplice no?
E dopo la prima settimana di utilizzo lascio a voi valutare i risultati ;-) :

Ovviamente tramite Imagick potete anche fare il resize dinamico delle immagini, ma non vorrei confondervi troppo le idee :-P

Rispondere ai commenti su Facebook attraverso le e-mail

Come pubblicato qualche ora fa sul blog di facebook, oggi è stata introdotta una nuova funzionalità del social network più usato al mondo, davvero molto interessante: la replica ai commenti via mail.

Quando un utente scrive un commento sulla nostra bacheca o sulle nostre foto/video, se nelle impostazioni della privacy non sono state disattivate le notifiche, facebook ci avvisa con una e-mail dell’evento. Fino ad oggi nella mail di avviso c’era un link da cui si poteva effettuare il login e successivamente rispondere al commento. Da oggi invece, basterà cliccare su “rispondi” dal proprio client di posta e inviare il testo in replica al commento ricevuto e questo verrà automaticamente aggiunto alla coda dei commenti.

Credo sia una funzionalità davvero molto comoda, sia per partecipare ad una conversazione senza perdere troppo tempo, per chi si trova indaffarato sul posto di lavoro o chi non ha tempo di collegarsi al sito, sia per chi per diverse ragioni non può accedere al social network direttamente. Questa funzione permetterà di incrementare enormemente le conversazioni via commenti fra utenti… Un bell’applauso agli sviluppatori di facebook, per questa nuova, semplice ma utilissima features!

[ad]

Un tool open source per la progettazione dei database

Ogni buon programmatore che si rispetti sa che non si può creare un database dal nulla. Proprio i database sono alla base di qualsiasi software degno di nota, e sono indispensabili per la realizzazione di un sito web.

Da buon fanatico di progetti open source, ma soprattutto dell’ambiente php-mysql per la creazione di web application mi sono dato da fare nel mio sport preferito e ho trovato un tool davvero interessante.

Si chiama MySQL workbench e proviene dagli stessi laboratori dai quali ci viene fornito uno dei DBMS open source più conosciuti al mondo. E’ da qualche mese che lo uso ogni volta in cui ho bisogno di realizzare un db, a lavoro o a casa e lo trovo davvero utile e funzionale. Che cos’è workbench? Semplice! Un sw che consente di progettare un database, partendo dalla realizzazione dello schema E-R e risparmiando molto lavoro a noi poveri programmatori.

In sostanza basta disegnare lo schema del database inserendo tabelle, chiavi primarie, chiavi esterne, indici, trigger, viste e chi più ne ha più ne metta, e workbench farà per noi tutto il resto. Una volta disegnato lo schema infatti, sarà possibile esportare la struttura del db creato e reimportarla nel nostro DBMS. Io uso abitualmente MySQL e workbench mi permette di esportare in un file .sql le query di creazione della mia base dati, pienamente compatibili con questo DBMS, e di creare con una import il database vero e proprio.

Esiste in due versioni, la community e la standard, la prima rilasciata gratuitamente sotto licenza GPL mentre la seconda a pagamento (e con alcune funzionalità in più) al costo di 79$ per svillupatore per anno. Ovviamente non mi sono potuto permettere di acquistare la versione standard, ma la community svolge il suo egregio lavoro in maniera impeccabile.

Dimenticavo, workbench è multipiattaforma ossia esiste nella versione per Linux (comodo pacchetto debian autoinstallante, o rpm), nella versione per Mac OS X e nella versione per Windows in modo che nessuno possa lamentarsi e tutti possano progettare in tutta serenità i propri database sul proprio sistema preferito.

Direi che non vi resta che provarlo!
[ad]