Convertire ppt in pdf dalla bash con OpenOffice.

Spesso mi trovo nella situazione di dover convertire molti file ppt in pdf.
OpenOffice è un ottimo strumento per leggere i ppt su una qualsiasi distribuzione Linux (e non solo) in mancanza di Microsoft Office e fornisce degli ottimi strumenti per la conversione dei documenti in PDF.
Convertire decine di file ppt in pdf con il consueto metodo:
– aprire il file con OpenOffice
– esportarlo/salvarlo in pdf
è troppo laborioso e fa perdere molto tempo!!

Con la versione 3 di OpenOffice ho scoperto una cosa interessantissima: si può avviare l’applicativo come un servizio server.
Ho pensato di avviare così OpenOffice come demone e di utilizzare un software apposito che mi permettesse di passare al nuovo demone i miei file ppt e convertirli in pdf.
Cercando in rete ho trovato JODConverter.
Esattamente ciò di cui avevo bisogno: con JODConverter ho la possibilità di passare a OpenOffice lanciato in backgroud, cioè come demone o servizio, i miei file ppt e di ottenere la conversione in pdf.

Per automatizzare le varie operazioni mi sono creato un piccolo script bash che riporto qui sotto.
Credo di averlo ben commentato ed è autoesplicativo di conseguenza non sto a spiegare meglio come si lancia OpenOffice in backgroud e come si usa JODConverter. Per avere maggiori informazioni rimando alle pagine ufficiali dei due progetti:
JODConverter
OpenOffice

Alcune operazioni preliminari per far funzionare correttamente lo script:
– scaricare e scompattare il pacchetto contenente JODConverter nella cartella home dell’utente, io nello script utilizzo la versione 2.2.1, modificare le stringhe dello script a seconda della versione o della path del proprio JODConverter;
– leggere il mio precedente articolo su come colorare la bash in quanto lo script contiene delle variabili per colorare gli output utilizzando lo script “colori”.

Il mio script:

#!/bin/bash                                  
# .colori è il mio script shell contenente i codici per colorare la bash
. colori                                                                

echo -e "n-----------------------------------------------------------------"
echo -e "|   Avvio openoffice in modalità backgroud   |"                     
echo -e "|$RED   ooffice -headless -accept="socket,port=8100;urp;" $Z             |"
echo -e "-----------------------------------------------------------------n"         
# con questo comando avvio openoffice come servizio in ascolto sulla porta 8100       
ooffice -headless -accept="socket,port=8100;urp;"&                                    
# mi salvo da parte il pid del processo così alla fine del lavoro lo uccido senza problemi
pidOO=$!                                                                                  
# Chiedo se convertire tutti i file ora o se passarli uno ad uno                          
echo -n -e "$GREEN Convertire tutti i file ppt della directory corrente?$Z [s/...]n"     
read d                                                                                    
for file in *                                                                             
do                                                                                        
     if echo "$file" | grep -q ".ppt" ; then                                              
       if [[ $d != 's' ]]; then                                                           
         echo -e "Convertire:$RED $file$Z in pdf? [s/...]"                                
         read -s -n1 n                                                                    
       else                                                                               
         n='s'                                                                            
       fi                                                                                 
       if [[ $n = 's' ]] ; then                                                           
          filePDF=${file/%.ppt/.pdf}                                                      
          if [ -f $filePDF ] ; then                                                       
            echo -e "   File $RED $filePDF $Z è già convertito: Size is $BLUE$(ls -lh $filePDF | awk '{ print $5 }')$Z"
            echo -e "   File $RED $file $Z di origine Size is $BLUE$(ls -lh $file | awk '{ print $5 }')$Z"             
            # recupero le dimensioni dei file in modo da stampare sullo schermo le info sul loro peso.                 
            DimFile0=$(ls -l $file | awk '{ print $5 }')                                                               
            DimFile1=$(ls -l $filePDF | awk '{ print $5 }')                                                            
            let diff="$DimFile0 - $DimFile1"                                                                           
            if (($diff >= 1048576)); then                                                                              
               scarto=$(echo "scale=2; $diff/1048576" | bc)                                                            
               unita="MByte"                                                                                           
            else                                                                                                       
               scarto=$(echo "scale=2; $diff/1024" | bc)                                                               
               unita="KByte"                                                                                           
            fi                                                                                                         
            echo -e "   Risparmio di: $BLUE$scarto $unita $Z"                                                          
            echo                                                                                                       
          else                                                                                                         
            echo -e "$GRAY Inizio conversione di $file $(ls -lh $file | awk '{ print $5 }')"                           
            # Con questo comando indico a JODConverter di convertire i file                                            
            # sto utilizzando la versione 2.2.1, il software è stato scaricato e scompattato nella home directory      
            # dell'utente                                                                                              
            # modificare la path a jodconverter nel caso si utilizzi una versioni differente o posizione diversa del programma
            java -jar ~/jodconverter-2.2.1/lib/jodconverter-cli-2.2.1.jar $file $filePDF                                      
            echo -e "conversione finita:$Z"                                                                                   
            echo -e "   File originario$RED $file$Z di Size is $BLUE$(ls -lh $file | awk '{ print $5 }')$Z"                   
            echo -e "   Convertito in$RED $filePDF$Z di Size is $BLUE$(ls -lh $filePDF | awk '{ print $5 }')$Z"               
            DimFile0=$(ls -l $file | awk '{ print $5 }')                                                                      
            DimFile1=$(ls -l $filePDF | awk '{ print $5 }')                                                                   
            let diff="$DimFile0 - $DimFile1"                                                                                  
            if (($diff >= 1048576)); then                                                                                     
               scarto=$(echo "scale=2; $diff/1048576" | bc)                                                                   
               unita="MByte"                                                                                                  
            else                                                                                                              
               scarto=$(echo "scale=2; $diff/1024" | bc)                                                                      
               unita="KByte"                                                                                                  
            fi                                                                                                                
            echo -e "   Risparmio di: $BLUE$scarto $unita $Z"                                                                 
            echo                                                                                                              
          fi                                                                                                                  
          let dimtotPDF="$dimtotPDF + $DimFile1"
          let dimtotppt="$dimtotppt + $DimFile0"
       fi
     fi
done
# Informazioni su peso iniziale e finale di tutti i file convertiti
dimtotppt=$(echo "scale=2; $dimtotppt/1048576" | bc)
echo -e "Dimensione totale dei file ppt:$RED $dimtotppt$Z MB"
dimtotPDF=$(echo "scale=2; $dimtotPDF/1048576" | bc)
echo -e "Dimensione totale dei file pdf:$RED $dimtotPDF$Z MB"
# Uccido il demone OpenOffice
kill $pidOO
exit