php

Questo helper deriva naturalmente dalla funzione descritta nel precedente post.P4A mette a disposizione un widget chiamato P4A_DB_Navigator che si basa su archivi di tipo albero a liste di adiacenza e fornisce un output grafico della lista dei nodi, con un buon grado di interattività. Esiste, per esempio, un metodo che si chiama getPath() che restituisce in un array, il percorso dalla root al nodo fornito in input attraverso la chiave primaria. Purtroppo però, non esiste nessun metodo per estrarre l’insieme di nodi figli da un certo nodo parentale, così ho pensato di adottare la funzione presentata nel precedente post.

I parametri di input sono:

• $navigator – l’oggetto da cui discende (implicito)
• $id – l’identificativo del nodo da cui partire
• $table – il nome della tabella che rappresenta l’albero
• $pk – il nome della chiave primaria
• $recursor – il nome del campo che identifica il nodo parentale

Ecco il codice:

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

// File: P4A_db_navigator_getBranch.php
<?php
function P4A_db_navigator_getBranch ($navigator, $params)
{
  list($id, $table, $pk, $recursor) = $params;
  $arr = p4a_db::singleton()->getAll("SELECT * FROM $table");
  $pksArr = array();
  foreach ($arr as $rec) {
    $pksArr[$rec[$pk]]=$rec[$recursor];
  }
  $branchIds = array($id);
  $i=0;
  while ($i<count($branchIds)) {
    $newKeys = array_keys($pksArr,$branchIds[$i]);
    if (!empty($newKeys)) {
      foreach ($newKeys as $newKey){
        array_push($branchIds, $newKey);
      }
    }
    ++$i;
  }
  $res = array();
  foreach ($arr as $child) {
    if (in_array($child[$pk], $branchIds)) {
      $res[] = $child;
    }
  }
  return $res;
}
?>

Come esempio ho costruito una semplicissima maschera nella quale, ogni volta che viene selezionato un nodo, viene mostrato un messaggio con l’array dei nodi figli.

Ecco il codice:

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

class dbtree extends P4A_Base_Mask
{
  public function __construct()
  {
    parent::__construct();
    $this->setTitle('Test dbTree');
    //Source
    $this->build("p4a_db_source","dbtree")
      ->setTable("tree")
      ->setPk("id")
      ->load()
      ->firstRow();
    $this->setSource($this->dbtree);
    // db_navigator
    $this->build("p4a_db_navigator","navigator")
      ->setSource($this->dbtree)
      ->setRecursor("parent_id")
      ->setDescription("nome")
      ->setStyleProperty("height","85%")
      ->setStyleProperty("overflow","auto")
      ->collapse(true);
    // Display
    $this->display("sidebar_left",$this->navigator);
    // Intercept action afterMoveRow
    $this->intercept($this->dbtree,"afterMoveRow","showBranch");
  }
	public function showBranch()
  {
    $idCommessa = $this->dbtree->fields->id->getNewValue();
    $arr = $this->navigator->getBranch ($idCommessa, "tree", "id", "parent_id");
    $this->info(print_r($arr,true));
  }
}

L’esempio completo è scaricabile qui

Conclusioni

Lancio l’idea di mettere questa funzione fra i metodi del P4A_db_navigator, sempre che non esca fuori qualche dannato baco :-).

Riferimenti ed approfondimenti:

• PHP: estrarre un ramo da un albero a liste di adiacenza senza ricorsione

Ho scritto questi due helper per facilitare la gestione degli errori dovuti a query di aggiornamento e di cancellazione record. Gli helper sono una comodissima feature del framework P4A, si tratta dell’opportunità di scrivere funzioni personalizzate che possono essere raggiunte da qualsiasi maschera dell’applicazione. Questa caratteristica consente quindi un efficiente riutilizzo del codice, con grande vantaggio per la leggibilità dello stesso. Per costruire un helper, richiamabile da qualsiasi maschera, è necessario scrivere un file nella directory libraries, all’interno della propria applicazione salvandolo con un nome a piacere preceduto dal suffisso p4a_mask_. All’interno del file deve essere presente una funzione nominata nello stesso modo. Vediamo un esempio di albero di directory:

P4A
 |
 -- applications
      |
      -- gestione_fatture
          |
          -- objects
          |
          -- uploads
          |
          -- libraries  <-- qui! 

All’interno di questa directory posizioniamo i due file:

• p4a_mask_savewithoutpain.php
• p4a_mask_deletebreezily.php

Le due funzioni richiamano i metodi saveRow() e deleteRow() all’interno del costrutto PHP: try ... catch, intercettando gli eventuali errori e fornendo un messaggio di avviso senza interrompere il flusso del programma. Quando si utilizzano query di aggiornamento e cancellazione, è sempre bene fare dei controlli perché se si utilizzano tabelle InnoDB si rischia di rompere l’integrità referenziale, se si utilizzano indici di tipo UNIQUE si rischia la duplicazione, e così via. D’altra parte la ricerca tramite SELECT dei vincoli e/o delle chiavi duplicate è spesso troppo laboriosa, anche se in certi casi necessaria.
NOTA: try ... catch funziona solo con P4A 3.x, in quanto è disponibile a partire da PHP5.

Vediamo il codice di p4a_mask_savewithoutpain.php:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// Funzione: Salva senza soffrire :-)
function P4A_Mask_saveWithoutPain($mask, $params)
{    
    list($source) = $params;
    $mask->source = $source; 
	  try{ 
      $mask->source->saveRow();       
    } catch (Exception $e) {  
 
      $res = $e->getMessage();
      preg_match("/\SQLSTATE\[(.+)\]/",$res, $results);
 
      if ($results[1] == '23000') {
        $msg = "Errore: chiave duplicata!";
      }
      else {
        $msg = "Si e' verificato un errore nel salvataggio dei dati";
      }    
      $mask->warning($msg);  
    }
}

Le prime due righe di codice che ho spudoratamente copiato dagli helper di sistema, servono a ricevere gli oggetti: maschera chiamante e data source. Con try si tenta una saveRow(), se fallisce viene valutato il messaggio di errore per lo sbaglio più frequente: chiave duplicata. Negli altri casi viene segnalato un errore generico.

Questo, invece è il codice di p4a_mask_deletebreezily.php:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

// Funzione: cancella allegramente... :-)
function P4A_Mask_deleteBreezily($mask, $params)
{
    list($source) = $params;
    $mask->source = $source;
	  try{ 
      $mask->source->deleteRow();       
      } 
    catch (Exception $e) {  
      $res = $e->getMessage();
      $pos = strpos($res, "General error: 1451"); // Errore di rottura integrita'
                                                  // referenziale
      if ($pos==false) {
        $msg = "Si e' verificato un errore nella cancellazione";
      }
      else {
        $msg = "Errore: impossibile cancellare un record correlato";
      }
      $mask->warning($msg);  
    }
}

In questo caso ho valutato solo errori di cancellazione di record che abbiano un vincolo di relazione. Non ho ricercato nella descrizione il codice SQLSTATE perché in SQL lo stesso codice accomuna diversi casi. E’ quindi necessario utilizzare il numero di errore MySQL, che nel caso di rottura dell’integrità referenziale è 1451.

Ecco infine il codice da aggiungere alla nostra ipotetica maschera: (gli helper vengono richiamati omettendo il suffisso p4a_mask_ )

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

class test_fatture extends p4a_base_mask
{
 public function __construct()
  {
    parent::__construct();
    // DB Source
    $this->build("p4a_db_source", "source")
    // .....
    // codice della maschera...
    // .....
  }
  public function saveRow ()
  {
    $this->saveWithoutPain($this->source);
  }
  public function deleteRow()
  {
    $this->deleteBreezily($this->source);
  }
}

Infine vorrei ricordare gli helper di sistema che, grazie agli autori, ci fanno risparmiare parecchio lavoro!

• P4A_Field_loadSelectByArray – Imposta un campo di tipo select da un array.
• P4A_Field_loadSelectByTable – Imposta un campo di tipo select da una tabella.
• P4A_Frame_anchorTabPane – Ancora un tab pane ad una maschera.
• P4A_Mask_useToolbar – Imposta una toolbar e la ancora alla topbar.
• P4A_Mask_setTableAsSource – Imposta un DB_source da una tabella.
• P4A_Mask_constructSimpleEdit – Costruisce un’intera maschera! (disponibile in P4A 3.2.0)

Conclusioni

Credo che, grazie a strumenti di questo tipo, si può contribuire nello sviluppo Open Source, con poco sforzo e molto vantaggio per tutta la comunità!

Riferimenti ed approfondimenti:

• P4A – PHP For Applications – PHP RAD Framework
• P4A – PHP For Applications Wiki – Helpers
• Documentazione: p4a_helpers
• P4A forum: RE: Sample Error Handling

Andrea ha scritto:

Ciao Mario,
complimenti per i gli helper, molto utili :)

Solo un appunto, io eviterei questa linea di codice
$mask->source = $source;
In pratica cosi’ facendo rifai un’assegnazione della variabile source della maschera che non serve: nel tuo esempio quando chiami $this->build(“p4a_db_source”, “source”) hai gia’ popolato la variabile source con un db_source.
Tra l’altro nel tuo esempio non da’ alcun fastidio ma in un caso teorico potrebbe essere un problema perche’ se l’utente inizializzasse la variabile source con un oggetto diverso chiamando quella riga di codice lo andresti a sovrascrivere con risultati del tutto inaspettati (immagina un utente che nella maschera abbia scritto $this->build(‘p4a_table’,’source’)).

Per risolvere il tutto basterebbe cambiare il codice in questa maniera:
…
try{
$source->saveRow();
…

Spero di esserti stato utile, a presto
Andrea

ps spero di non aver postato questo commento due volte, la prima volta il server mi ha dato errore… nel caso ignorami ;)
30.12.08 12:04
Mario Spada Author Profile Page ha scritto:

Grazie Andrea per la correzione, hai perfettamente ragione!
30.12.08 19:55

Fra le novità più rilevanti c’è il cambio di tipo di licenza che passa dalla AGPL3 alla LGPL3. Non sono un esperto in materia, e non so dirvi molto. Da quanto ho capito si tratta di una differenza formale che regolamenta l’utilizzo e interazioni fra Librerie, Applicazioni e Lavori combinati.

Passando alle note tecniche, a parte una serie di patch e fix che risolvono alcuni bug, le novità più interessanti sono due. Una è quella del nuovo widget P4A_grid. Si tratta in pratica di una tabella editabile, molto utile per modificare singoli campi senza dover per forza utilizzare il fieldset e la toolbar.
La P4A_grid eredita dalla P4A_table tutti i metodi e le proprietà, in aggiunta presenta i seguenti:

• void autoSave ()
• void getRows ($num_page, $rows)
• void preChange ([$params = null])
• void saveData ($obj, $params)

Non ho avuto tempo di provare tutto, ma ecco un piccolo test con una tabella di prova per un’ipotetica gestione fatture:

1
2
3
4
5
6
7

  // grid
  $this->build("p4a_grid", "grid")
  ->setWidth(600)
  ->setSource($this->source)
  ->setVisibleCols(array("numero", "descrizione", "cliente"))
  ->showNavigationBar()
  ->autosave();

Il risultato è quello della immagine in alto, chiaramente il campo “lookup” non è editabile, ma il risultato è comunque fantastico. Se poi ci fosse la possibilità di riconoscere automaticamente i campi boolean e renderizzarli con una ckeckbox, e le “lookup” in select sarebbe ancora meglio! (dal post di Andrea sembra che la cosa sia già in cantiere…) Se avesse a disposizione anche un metodo per aggiungere record e cancellarli, sarebbe davvero perfetta, benché con un poco di codice e l’utilizzo dei metodi newRow() e deleteRow() questo dovrebbe essere già possibile.

Dulcis in fundo una piccola chicca, che trovo fantastica!
La possibilità di generare un’intera maschera con tutte le funzionalità per interagire con una tabella, scrivendo due sole righe di codice:

1
2
3
4
5
6
7
8

class test_clienti extends P4A_Base_Mask
{
	public function __construct()
	{
		parent::__construct();
		$this->constructSimpleEdit("clienti");
	}
}

Ma forse due righe sono troppe… ecco come fare scrivendone una sola!

1
2
3
4
5
6
7
8

class test_clienti extends P4A_Simple_Edit_Mask
{
 
	public function __construct()
	{
	 parent::__construct("clienti");
	}	
}

Questo il risultato in uno screenshot:

Nel primo caso utilizzo un nuovo helper (oggetto comodissimo particolarmente per il riutilizzo del codice) che si chiama: P4A_Mask_constructSimpleEdit() e nel secondo una classe che deriva da P4A_Base_Mask

Ci sono numerose altre novità come le migliorie nel comportamento dei CSS, la maggiore aderenza agli standard XHTML ed altri ancora che sono elencati nel file CHANGELOG.

Conclusioni

In attesa della presentazione ufficiale, mi sono permesso di elencare i due aspetti che più mi sono piaciuti! Lunga vita a P4A!

Riferimenti ed approfondimenti:

• P4A – PHP For Applications – PHP RAD Framework
• P4A – PHP For Applications Wiki
• P4A | Fabrizio Balliano
• This is not Andrea’s diary: Big news for the incoming P4A 3.2