PHP: connettere un database MS Access

Connessione PHP-MS AccessIn questo post propongo una mini web-application in linguaggio PHP che consente di interagire con un database Microsoft Access. La limitazione principale è che il server deve girare in ambiente Windows. La connessione al database sfrutta la classe COM che fornisce un ambiente idoneo all’utilizzo di diversi tipi di componenti COM come per esempio applicazioni Word, Excel e Powerpoint, ma anche ADO. Questa classe, nel pacchetto PHP per Windows, è integrata nella distribuzione, e non è necessaria nessuna installazione. Per quanto riguarda la versione, sembra che quella minima sia la 4.1.x, ma non ho avuto modo di fare prove. Suggerirei comunque di utilizzare le versioni 5.2.x per stare tranquilli!

Una generica connessione ad un database MS Access, ed il riempimento di un recordset può essere avviata con queste istruzioni:

1
2
3
4
5
6
7
8
$cn = new COM("ADODB.Connection");
$cnStr = "DRIVER={Microsoft Access Driver (*.mdb)}; DBQ=".
            realpath("./nomeDatabase.mdb").";";
$cn->open($cnStr);
$rs = $cn->execute("SELECT * FROM nomeTabella");
...
$rs->Close();
$cn->Close();

Tornando alla mini-applicazione che ha uno scopo prettamente dimostrativo, le sue funzioni sono:

  • Selezionare una tabella di un file MS Access e mostrare l’elenco dei records
  • Selezionare attraverso la chiave primaria un record e modificare uno o più campi
  • Selezionare attraverso la chiave primaria un record e cancellarlo
  • Inserire un nuovo record

Per poter utilizzare l’applicazione, è necessario innanzitutto modificare le impostazioni definite nel file config.php definendo il nome e il percorso del database, il nome della tabella, il nome e la posizione della chiave primaria e la possibilità di attivare o meno la modifica e cancellazione dei record attraverso i link alla chiave primaria.

Il codice del file principale che mostra la lista dei record e i form per le modfiche, le cancellazioni e gli inserimenti è disponibile leggendo il file test.php.
Un ultimo file: modify.php si occupa di gestire le POST ed effettuare le query di inserimento, aggiornamento e cancellazione.

Alcune annotazioni: per semplificarsi la vita con Access è bene non dare mai il nome “note” ad un campo, perché è una parola chiave. Se proprio fosse necessario, bisognerà riferirsi a quel campo con la forma nometabella.note.
Altra considerazione: se in PHP è attiva la direttiva magic_quotes_gpc le variabili POST verranno trattate con i caratteri di escape per l’apostrofo.
Per memorizzare questi dati nel database, sarà quindi necessario fare prima uno stripslahes() e poi rimpiazzare gli apostrofi raddoppiandoli (che è il modo di “escapare” in Access!).
Infine, per motivi di tempo non ho gestito gli errori della classe COM, però è possibile farlo controllando le eccezione tramite la classe com_exception.

Molte curiosità sull’argomento trovano risposta in questa FAQ

Download:

Il pacchetto comprendente tutti i file PHP, il foglio stile e il database MS Access fatture.mdb è scaricabile qui.

Uno screenshot:

Screenshot dell'applicazione
Screenshot dell'applicazione

Conclusioni:

Sono convinto che le cose che sono nate per stare in coppia diano i risultati migliori, quindi PHP con MySQL. Però avere a disposizione la possibilità di interagire con un database così diffuso e così fortemente legato alle applicazioni Microsoft (Access si sposa bene con Visual Basic!) è un’ottima cosa. Non fosse altro per poter gestire delle emergenze, uno scambio di dati, la migrazione dei dati e via dicendo. O magari semplicemente per non perdere tempo e riutilizzare vecchie applicazioni con il vantaggio delle web-application.

Riferimenti ed approfondimenti:


andrea ha scritto:

l’esempio riportato è perfetto!

Alex ha scritto:

Molto utile, sono del parere che gli esempi pratici siano molto più efficaci e comprensibili di una una tonnellata di teoria.
Grazie

Librerie javascript Open-jACOB Draw2D: un tool per visual web applications?

esempio fatto con Open-jACOB Draw2DEro alla ricerca di qualche strumento web di tipo ajax-javascript che permettesse interattivamente di creare delle forme grafiche, di assegnargli delle proprietà, di ancorarle ad una griglia e ottenere un parsing xml del risultato, ed ho trovato Open-jACOB Draw2D.
Mi ha affascinato subito ed ora vi spiego il perché.
Per prima cosa, si tratta di un SDK composto da librerie javascript con licenza LGPL, nate dalle famose “DHTML graphics” del tedesco Walter Zorn.
Il lavoro di Andreas Herz, tedesco anche lui, è stato di implementare caratteristiche per la creazione di diagrammi di flusso e progettazione di circuiti elettrici, ma soprattutto di fornire allo strumento una maggiore flessibilità ed interattività (come p.e.: la gestione dei livelli di undo).
In realtà, queste librerie fanno anche parte di un progetto più complesso che si chiama Open-jACOB e ne costituiscono la componente grafica interattiva.

La cosa più accattivante secondo il mio punto di vista, è che il risultato è un prodotto compatibile con qualsiasi browser, senza alcun bisogno di plugin aggiuntivi perché tutta la grafica è gestita attraverso il DOM con dei DIV.
Niente SVG o CANVAS, semplicemente DIV opportunemente elaborati!
Qualcuno potrebbe obiettare che in questo modo la gestione delle forme vettoriali, a parte le linee e i rettangoli, risulta molto complessa e lenta ma lo scopo di questo strumento, come conferma l’autore, non è tanto quello della grafica vettoriale, piuttosto quello di un editor di diagrammi di flusso.
Invece, scavando un poco nel codice, e dalle demo on-line, io ci ho visto un interessante tool per lo sviluppo di applicazioni web interattive e “visual”. Vale a dire, combinando adeguatamente queste librerie javascript con del codice server-side, si potrebbe creare un framework RAD e WYSIWYG per lo sviluppo, totalmente Open source.
Questo tipo di framework, sia per la complessità, che per il tempo impiegato allo sviluppo, sono normalmente appannaggio di grosse ditte e le licenze sono invitabilmente di tipo commerciale.

Esempio pratico

Se la cosa incuriosice anche voi, qui potete provare una piccola demo delle potenzialità di Open-jACOB Draw2D con particolare riferimento allo sviluppo di applicazioni “visual”.
Ho ottenuto questa demo semplicemente abbinando alcune caratteristiche base dei veri esempi forniti dall’autore.

Conclusioni:

Complimenti ad Andreas Herz, davvero un bel lavoro! Credo proprio che continuerò a seguire questo progetto!

Riferimenti ed approfondimenti:

P4A framework: esempio di applicazione completa per la gestione delle fatture

Screenshot dell'applicazioneL’idea di realizzare questo esempio di applicazione in P4A è nata per comparare i tempi di sviluppo in un ambiente RAD di tipo WYSIWYG (MS Visual Basic) che genera desktop applications e un framework PHP che genera web applications. Dei vantaggi delle applicazioni web ho già scritto in un precedente articolo.
Il progetto è molto semplice: un programma che gestisce la fatturazione di una ditta che fa servizi, quindi senza magazzino.
Ho scelto questo progetto perché la realizzazione non presenta grosse difficoltà e può essere utile a qualcuno, ed anche perché ci sono dentro diversi aspetti che ricorrono anche in applicazioni più grandi, come ad esempio la gestione di tabelle master-detail e lo sviluppo di un report personalizzato in pdf.
Inoltre lo schema del database è pressoché identico a quello di un tutorial per l’approccio ai dati con Visual Basic .Net 2005 (Visual Basic 2005 passo-passo: Accesso ai dati),
in questo modo sarà più facile effettuare il confronto.
Va detto che non ho ancora realizzato l’equivalente in VB.Net, ma avendo una certa esperienza di VB6 posso dire quanto tempo avrei impiegato a realizzarlo: diciamo 2 giorni al massimo. Ebbene, considerando che la documentazione di P4A è piuttosto scarsa, che il framework non ha un’interfaccia grafica WYSIWYG con strumenti drag’n’drop e wizard per la creazione dei report, e infine, che non ho una conoscenza dello stesso paragonabile all’esperienza che ho con Visual Basic, mi sarei aspettato di impiegare come minimo il doppio del tempo, invece l’applicazione completa è stata realizzata in soli 2 giorni di lavoro nemmeno troppo assiduo (non c’erano clienti col fiato sul collo!).
Avessi voluto usare solo PHP e javascript, ci avrei messo davvero molto di più…!
Un buon risultato, visto che sappiamo quanto sia importante produrre applicazioni in breve tempo per tenere bassi i costi ed accontentare clienti sempre meno disposti ad investire grosse cifre sul software.

Quali sono le caratteristiche dell’esempio?

  • Una maschera per la gestione dell’intestazione della ditta
  • Una maschera per la gestione dell’anagrafica clienti (con ricerca per nome)
  • Una maschera per la gestione delle fatture divisa in dati fattura e dettaglio prestazioni
  • Una procedura di stampa della fattura in formato pdf
  • Una maschera per il riepilogo delle fatture emesse e la possibilità di filtraggio per periodo

Qualche screenshot…

maschera iniziale
maschera iniziale
intestazione della ditta
intestazione della ditta
anagrafica clienti
anagrafica clienti
gestione delle fatture: master
gestione delle fatture: master
gestione delle fatture: detail
gestione delle fatture: detail
stampa pdf
stampa pdf
riepilogo delle fatture
riepilogo delle fatture

 

Note tecniche:
Ho provato l’applicazione sia con P4A 2.1.7 che con l’ultima release 2.2.2.
Il funzionamento è corretto sia con PHP4.x e MySQL4.x che con PHP5.2.4 e MySQL5.0.x, in quest’ultimo caso però è necessario impostare la direttiva del php.ini: memory_limit = 64M, il default è 8M.
All’interno del pacchetto, nella directory ‘_private’ ci sono i dump .sql del database MySQL effettuati con phpMyAdmin e con Heidi, il nome del database deve essere: ‘base_app_invoices’.
Infine per la generazione del report in pdf, ho utilizzato la classe R&OS (pdf-php su Sourceforge), conosciuta anche come ezPdf e licenza di tipo Public Domain

Download:

Pacchetto zip completo di librerie R&OS

Conclusioni:

Se il rapporto 1:1 dei tempi di sviluppo con queste differenti tecnologie rimane lo stesso anche per applicazioni complesse, e constatato il vantaggio delle applicazioni web, è da considerare seriamente l’adozione di questo framework PHP fra i propri strumenti di lavoro.

Riferimenti ed approfondimenti:

PHP: un semplice datagrid per applicazioni web

Esempio di datagridE’ piuttosto frequente, quando si sviluppano applicazioni web, di dover presentare i dati di una query in un datagrid, ovvero in una tabella HTML. In tutti questi casi, può essere comodo avere già pronta una classe che formatta i dati nella tabella e scrive per noi il codice HTML. Questa classe che ho scritto, pur essendo molto semplice e spartana, presenta alcune caratteristiche interessanti:

  • Il codice generato è XHTML valido
  • La presentazione è gestita da fogli stile CSS, quindi facilmente personalizzabile
  • E’ possibile, tramite il passaggio di parametri, creare una colonna aggiuntiva di link per azioni tipo “modifica”, o “dettaglio”
  • E’ possibile visualizzare o nascondere la colonna contenente la chiave primaria
  • Aspetto gradevole e alternanza di colorazione delle singole righe per una più facile lettura dei dati

Il codice della classe è molto semplice ed autoesplicativo:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
class dataGrid
{
  var $tabData;
  var $pkField;
  var $pkIsVisible;
  var $summaryTable;
  var $linkPage;
  var $linkLabel;
 
 function dataGrid($tabData, $pkField,
          $pkIsVisible, $summaryTable,
          $linkPage, $linkLabel)
 {
    $this->arrData=$tabData;
    $this->pkId=$pkField;
    $this->pkIsVisible=$pkIsVisible;
    $this->summaryTable=$summaryTable;
    $this->linkPage=$linkPage;
    $this->linkLabel=$linkLabel;
 }
 
 function makeTable()
 {
  $rowStyle=true;
  $printTh = false;
  $printTd = false;
  print("<table class='datatable' cellspacing='0'
        summary='$this->summaryTable'>");
        print("<tr>");
  $fldCount = mysql_num_fields($this->arrData);
  for ($i=0; $i<$fldCount; $i++ ) {
   $fldName = mysql_field_name($this->arrData, $i);
   if($this->pkId!=$fldName){
    $printTh = true;
   }
   else{
    if($this->pkIsVisible){
     $printTh = true;
    }
   }
   if($printTh){
    print("<th scope='col'>");
    print($fldName);
    print("</th>");
    $printTh = false;
   }
  }
  print("</tr>");
  while($row=mysql_fetch_array($this->arrData)){
   print("<tr>");
   $rowStyle=!$rowStyle;
   for($i=0; $i<$fldCount; $i++) {
    if($rowStyle)
     $tdStyle="<td class='alt'>";
    else
     $tdStyle="<td>";
    $fldName = mysql_field_name($this->arrData, $i);
    if($this->pkId!=$fldName){
     $printTd = true;
    }
    else{
     if($this->pkIsVisible){
      $printTd = true;
     }
    }
    if($printTd){
     print($tdStyle);
     print($row[$i]);
     print("</td>");
     $printTd = false;
    }
   }
   if($this->linkPage!=NULL){
    print($tdStyle."[<a href=".$this->linkPage."?"
          .$this->pkId."=".$row[$this->pkId]
          ." title='".$this->linkLabel."'>"
          .$this->linkLabel
          ."</a>]</td>");
   }
   print("</tr>");
  }
  print("</table>");
 }
}

Come utilizzare la classe:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
//---------------------------------------------
// Database connection params
// Modify for your connection, db and query
$host = 'localhost';
$user = 'root';
$password = '';
$database = 'prova';
$query = 'select * from es_libri order by autori';
//---------------------------------------------
// open the connection to the db server
$link = mysql_connect($host,$user,$password);
// change to the right database
mysql_select_db($database);
// do the SQL query
$result = mysql_query($query);
include ('datagrid.class.php');
// Print HTML
echo '<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN"
        "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">';
echo '<html xmlns="http://www.w3.org/1999/xhtml">';
echo '<head>';
echo '<meta http-equiv="Content-Type" 
     content="text/html; charset=iso-8859-1" />';
echo '<title>CSS Tables</title>';
echo '<link href="styles.css" rel="stylesheet" 
     type="text/css" />';
echo '</head><body>';
// Use datagrid class with full options
$mydatagrid = & new datagrid($result,"ISBN",true,
           "Tabella","test.php","modifica");
$mydatagrid->makeTable();
echo '<hr />';
// Use datagrid class without showing primary key, 
//with link option
$result = mysql_query($query);
$mydatagrid = &amp; new datagrid($result,"ISBN",false,
           "Tabella","test.php","modifica");
$mydatagrid->makeTable();
echo '<hr />';
// Use datagrid class without link options
$result = mysql_query($query);
$mydatagrid = &amp; new datagrid($result,"ISBN",true,
           "Tabella",NULL,NULL);
$mydatagrid->makeTable();
echo '<hr />';
// Use datagrid class without showing primary key
$result = mysql_query($query);
$mydatagrid = &amp; new datagrid($result,"ISBN",false,
           "Tabella",NULL,NULL);
$mydatagrid->makeTable();
echo '</body></html>';

Per vedere l’esempio, cliccare qui.
Questo, invece è il pacchetto contenente la classe, il file di esempio, il foglio stile e l’sql per la creazione della tabella “es_libri”, (da creare in un db chiamato “prova”).

Note:

Il codice per questa classe viene fornito ‘as is’, senza controllo di errori, né prove efficaci in produzione.

Conclusioni:

Ogni programmatore di applicazioni web dovrebbe avere una buona scorta di classi di utilità generale, da tenere in serbo per l’occasione giusta. E’ un buon metodo per risparmiare molto tempo, credo che questa semplice classe possa far parte della collezione!

Riferimenti ed approfondimenti:

P4A framework: come stampare un pdf

P4A: toolbar con pulsante pdfNella documentazione del framework PHP P4A della Crealabs, non ci sono informazioni troppo dettagliate su come
produrre report in formato pdf. Cercando nei thread del forum, ci sono diversi frammenti ed indizi, che
aiutano parecchio, ma si perde un po’ di tempo a metterli insieme per produrre il codice necessario a
generare il report come si desidera. In questo articolo mostrerò la soluzione che ho scelto mettendo insieme i vari indizi, e applicandola alla base application “Products Catalogue” distribuita sul sito della Crealabs come applicazione di esempio.

Step 1: scelta ed installazione delle librerie pdf

In questo thread del forum, viene suggerito di usare le librerie FPDF o R&OS.
Ho scelto R&OS semplicemente perché in passato avevo avuto qualche difficoltà con FPDF, probabilmente per mia colpa. Credo che siano in sostanza equvalenti.
Una volta scaricato il pacchetto, è necessario creare nella root della applicazione (nel nostro caso: localhost/p4a/applications/products_catalogue/) una cartella che si deve chiamare
libraries. All’interno di questa cartella vengono decompresse le librerie (nel nostro caso i due files: class.pdf.php e class.ezpdf.php) e la cartella fonts contenente i file per la generazione dei font.

Step 2: Aggiunta di un pulsante nella toolbar

A questo punto bisogna creare un pulsante per la generazione del report in pdf. Personalmente ho scelto di crearlo nella toolbar, ma evidentemente si può crearlo dove si vuole.
All’interno del file products.php sarà sufficiente aggiungere questo codice PHP:

1
2
3
4
5
6
7
8
9
10
// Toolbar
$toolbar = &amp; $this->build("p4a_standard_toolbar",
                              "toolbar");
$toolbar->setMask($this);
$toolbar->addSeparator($position = "left");
// Aggiungo un pulsante alla toolbar per la stampa su pdf
$toolbar->addButton('stampapdf','pdf');
// Intercetto onClick per eseguire stampa_documento()
$this->intercept($toolbar->buttons->stampapdf,
                 'onClick','stampa_documento');

Notate che, per comodità, ho creato una variabile $toolbar contenente l’oggetto toolbar.
Il secondo parametro 'pdf' passato al metodo addButton crea automaticamente un img link all’icona pdf.png.
Questa icona deve essere presente nella cartella di default per il set di icone di P4A: localhost/p4a/icons/default/32/

In alternativa, si può impostare a NULL questo parametro per lasciare solo la scritta impostata ('stampapdf').

L’ultima riga di codice intercetta l’evento onClick sul pulsante ed esegue il metodo stampa_documento

Step 3: Aggiunta del metodo stampa_documento

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
function stampa_documento()  
// funzione per la stampa su pdf
  {
  require('class.ezpdf.php');
  $pdf =&amp; new Cezpdf('a4','portrait');
  $pdf->selectFont($_SERVER['DOCUMENT_ROOT'].
                   P4A_APPLICATION_PATH.
                   '/libraries/fonts/Helvetica');
  $db =&amp; p4a_db::singleton();
  $res = $db->getAll("SELECT model,
   brands.description AS brand,
   categories.description AS category, selling_price
   FROM products
   LEFT JOIN brands
   ON brands.brand_id = products.brand_id
   LEFT JOIN categories
   ON categories.category_id = products.category_id");
  $pdf->ezTable($res,'','Products',array('fontSize'=>12));
  $type = 'application/pdf';
  $filename = 'report.pdf';
  header("Pragma: public");
  header("Cache-Control: must-revalidate, post-check=0,
         pre-check=0");
  header("Cache-Control: private", false);
  header("Content-type: $type");
  header("Content-Disposition: attachment;
          filename=\"$filename\"");
  $pdfcode = $pdf->output(1); // flusso dati senza header
  header("Content-Length: " . strlen($pdfcode));
  echo $pdfcode;
  die();
  }

Note: nella variabile $res viene memorizzato un’array multidimensionale associativo che è il risultato della query. Come esempio ho preparato una query di tipo JOIN perché nella maggior parte dei casi, è proprio questo il tipo utilizzato.

Il path per la scelta dei font deve essere assoluto, per averlo in termini relativi è possibile utilizzare la variabile $_SERVER['DOCUMENT_ROOT'] propria del PHP e la costatnte P4A_APPLICATION_PATH propria del framework P4A.

Per forzare il browser ad aprire il report pdf in una nuova finestra, ho cambiato l’header del documento generato, specificando che il contenuto è un attachment. Altrimenti, il contenuto viene riconosciuto come mime-type 'application/pdf' e (a seconda dei browser utilizzati) viene aperto nella stessa finestra.

Infine il nuovo processo viene terminato attraverso l’istruzione die();

Download:

Il sorgente comprende anche le librerie R&OS e l’SQL per creare il database con alcuni record d’esempio per il report in pdf. Il report generato è visualizzabile qui.

Conclusioni:

Il framework P4A è uno strumento davvero ben fatto, gli autori hanno fatto un gran lavoro, adesso sta a noi utilizzatori, attraverso l’interscambio di informazioni, generare la documentazione necessaria al suo sviluppo.
A tal proposito è mia intenzione produrre altra documentazione su altri aspetti di comune interesse agli utilizzatori di questo ottimo framework.

Riferimenti ed approfondimenti:


Valerio Maglietta ha scritto:

Definire ottima questa imbeccata di Mario Spada e’ il minimo…
L’unica aggiunta che mi sento di consigliare è quello di preprocessare il contenuto della stringa da stampare tramite iconv.
Ovvero per noi Italiani:

$res = iconv(‘UTF-8’, ‘CP1252’, $res);

prima dare in pasto $res a ezTable come nell’esempio precedente

In questa maniera caratteri accentati, simbolo euro e simili, non ci daranno problemi.
Nel mio caso (so linux Ubuntu 7.10) la codifica iniziale è UTF-8 ma potrebbe essere differente (ISO-8859-1, ISO-8859-16).
CP1252 è la codifica Windows Western European (sembra che R&OS sia stato sviluppato proprio sotto win…).

Grazie 1k Mario!

Un framework PHP facile, moderno e italiano: P4A

Esempio di applicazione p4aL’utilizzo di un framework fornisce ai programmatori PHP che hanno scelto le applicazioni web come via di sviluppo, un comodo strumento per la costruzione delle maschere, le connessioni ai database, l’implementazione di menù e pulsantiere e tutti gli altri aspetti dell’applicazione che sono accessori indispensabili di qualsiasi programma. In questo modo lo sviluppatore si può concentrare maggiormente sulla logica dell’applicazione, lasciando al framework e ai suoi widget il compito della presentazione e della interazione con i dati.
Per chi ha scelto come linguaggio di sviluppo il PHP, non c’è che l’imbarazzo della scelta. Ma quali sono i criteri per fare una scelta corretta?

Secondo la mia opinione, principalmente due: il tipo di prodotto che si deve realizzare e il tempo di apprendimento per padroneggiare il framework. Altri criteri importanti sono la documentazione e la portabilità. Infatti se il framework richiede, per la propria installazione, requisiti difficilmente presenti sulla maggior parte dei provider, sarà poi difficile mettere in piedi un prodotto competitivo. Avendo l’esigenza di sviluppare un’applicazione per la gestione della produzione di una piccola impresa, la nostra scelta è caduta su un framework tutto italiano sviluppato da Andrea Giardina e Fabrizio Balliano della Crealabs denominato: P4A (PHP for Applications).

Quali sono i principali vantaggi di P4A?

  • Semplicità dell’installazione e portabilità
  • Apprendimento molto rapido
  • Persistenza dello stato durante l’esecuzione dell’applicazione
  • Presenza di utili widget per menù, navigazione del database, creazione di form e tabelle
  • Presenza di un buon numero di applicazioni base ed esempi
  • Semplicità del codice sorgente
  • Struttura moderna, orientata agli oggetti
  • l’HTML generato presenta un buon grado di accessibilità
  • Supporto ajax
  • Possibilità di interagire con gli autori in lingua italiana (chi fa questo mestiere dovrebbe conoscere bene l’inglese… ma esprimersi in madre lingua è sempre un’altra cosa!)

E quali, invece, gli svantaggi?

  • Manuali inesistenti
  • Documentazione delle classi completa ma poco dettagliata
  • Inadatto ai siti web veri e propri (gli autori stessi dichiarano che il framework è stato progettato per applicazioni web di tipo gestionale)
  • Impossibilità di avere il completo controllo del codice, ma questa è una caratteristica comune a tutti i framework, anzi quelli più complessi sono anche molto più criptici

Conclusioni:

Il framework P4A rappresenta un ottimo strumento per la realizzazione di applicazioni web, anche complesse, soprattutto di tipo gestionale. La semplicità di installazione ed utilizzo ripagano ampiamente la minore dotazione e flessibilità rispetto ai blasonati Zend Framework, Symphony e CakePhp. Seppure la dotazione manualistica è inesistente, l’ampio numero di esempi disponibili in rete e la presenza di un forum abbastanza attivo supplisce a questa mancanza. Infine l’attività di manutenzione e sviluppo da parte degli autori insieme al fatto che il prodotto ha ottenuto il ragguardevole numero di 130.000 download è garanzia di vitalità e supporto anche nel futuro.

Riferimenti ed approfondimenti: