Differenze

Queste sono le differenze tra la revisione selezionata e la versione attuale della pagina.

--- sviluppo:proggridalbero [2012/10/25 14:06] – [menLib] a.mucci
+++ sviluppo:proggridalbero [2024/10/15 09:45] (versione attuale) – modifica esterna 127.0.0.1
@@ Linea 5: / Linea 5: @@
   * [[grid_albero#Model| Codice nel Model]]
   * [[grid_albero#menLib|Codici in menLib]]
-      * [[grid_albero#Funzione GetMenu|Funzione GetMenu]]
+      * [[proggridalbero#Funzione GetMenu|Funzione GetMenu]]
-      * [[grid_albero#Funzine caricaTreeLegami|Funzine caricaTreeLegami]]
+      * [[proggridalbero#Funzione caricaTreeLegami|Funzine caricaTreeLegami]]
 \\
@@ Linea 15: / Linea 15: @@
 Come abbiamo già visto il treeGridModel utilizzato è quello Adjacency.\\
-E' importante definire, nella parte di programmazione, che comportamendo dovranno assumere i vari campi.\\
+E' importante definire, nella parte di programmazione, che comportamento dovranno assumere i vari campi.\\
 Le possibili configurazioni sono:
   * **Level :** Che assume valori integer, e indica il livello di profondità
@@ Linea 56: / Linea 56: @@
 ------
 \\
-=== menLib ===
+=== Libreria: menLib ===
 Nella libreria menLib troveremo chiaramente molte funzioni, ma ce ne interessano 2 in particolare:
-   * [[progridalbero#Funzione getMenu|Funzione getMenu]]
+   * [[proggridalbero#Funzione getMenu|Funzione getMenu]]
-   * [[progridalbero#Funzione caricaTreeLegami|Funzione caricaTreeLegami]]
+   * [[proggridalbero#Funzione caricaTreeLegami|Funzione caricaTreeLegami]]
 \\
 == Funzione getMenu ==
-\\
-Nella funzione getMenu possiamo notare che:\\
-$inc viene settato a 0\\
-Viene dichiarato l'array $albero e gli viene attribuito il valore $inc nel campo 'INDICE' di $inc.\\
-In questo caso avremo nell'array:\\
-  * [0]
-    * ↳ INDICE = 0
-**Codice nella "menLib" :**
 <code>
@@ Linea 79: / Linea 70: @@
         $albero[$inc]['INDICE'] = $inc;
 </code>
-Successivamente dovremo impostare alcuni campi obbligatori: 'level','parent','isLeaf','expanded','loaded' \\
+\\
+Nella funzione getMenu possiamo notare che:\\
+**$inc** viene settato a **0**\\
+Viene dichiarato l'array **$albero** e gli viene attribuito il valore **$inc** nel campo **'INDICE'** di **$inc.**\\
+In questo caso avremo nell'array:\\
+  * [0]
+    * ↳ INDICE = 0
+\\
+\\
+Successivamente dovremo impostare alcuni campi obbligatori: **'level','parent','isLeaf','expanded','loaded'** \\
 \\
@@ Linea 92: / Linea 93: @@
         $albero[$inc]['loaded'] = 'true';          // Carica le foglie insieme all'albero
 </code>
-E successivamente possono essere impostatati anche gli altri campi all'interno della tabella(in questo caso nell'array):
+Dopo di che possono essere impostatati anche gli altri campi all'interno dell'array :
 \\
 <code>
@@ Linea 102: / Linea 103: @@
         $albero[$inc]['pm_descrizione'] = $pm_descrizione;
         $albero[$inc]['pm_sequenza'] = 0;
-        $save_count = count($albero);              // incrementa il $save_count
+        $save_count = count($albero);
-        $albero = $this->caricaTreeLegami($chiave, $albero, 1, $inc, $only_menu, $filtro); //Richiama la funzione caricaTreeLegami
+</code>
-        if ($save_count == count($albero)) {       // Nel caso in cui il $save_count sia uguale al $count($albero) significa che non ci sono sotto livelli o foglie e quindi viene impostato come foglia.
+Alla fine dell'impostazione dei campi, possiamo notare **"$save_count = count($albero);"**.\\
-            $albero[$inc]['isLeaf'] = 'true';      //Impostato come foglia.
+La variabile **$save_count** viene quindi settata con il conteggio totale delle righe in **$albero**, che servirà più avanti come controllo.\\
+\\
+A questo punto ci servirà richiamare un'altra funzione, per definire i vari legami tra i livelli:, la funzione **creaTreeLegami** contenuta sempre nella libreria menLib.
+<code>
+        $albero = $this->caricaTreeLegami($chiave, $albero, 1, $inc, $only_menu, $filtro);
+        if ($save_count == count($albero)) {
+            $albero[$inc]['isLeaf'] = 'true';
         }
         return $albero;
     }
 </code>
-==Funzine caricaTreeLegami==
+In questo esempio possiamo notare che nell'assegnazione dei valori della funzione caricaTreeLegami:
+  * al campo **$level** assegna il valore 1 (1 perchè in questo esempio è il livello successivo al primo parent (0), ma è possibile inserire anche un autoincrementazione )
+  * al campo **$parent** assegna il valore **$inc,** ($inc perchè vi è contenuto il valore del parent iniziale, che in questo caso è 0)
 \\
-**Codice nella "menLib" :**
+La condizione ci serve per capire se abbiamo un risultato dalla funzione. Infatti potrebbe essere che non ci sia nessun sottolivello e che quindi il primo livelo (0 in questo caso) sia solo una foglia, viene quindi impostato in isLeaf = True.\\
+\\
+\\
+==Funzione caricaTreeLegami==
+La funzione caricaTreeLegami è una funzione ricorsiva che:
+  - ispeziona un gruppo di dati,
+  - scorre la tabella estratta,
+  - si ripete se trova altri sottolivelli.
+In breve stabilisce quali record nell'array sono dei "Rami" e quali le "foglie".
 <code>
     public function caricaTreeLegami($chiave, $albero, $level, $indice, $only_menu = false, $filtro = true) {
@@ Linea 127: / Linea 147: @@
                     continue;
                 }
+</code>
+In questa prima parte di codice, possiamo notare un primo controllo: **if ($level == 10)**, per evitare che la ricorrenza avvenga all'infinito.\\
+\\
+In questo esempio si vedono chiaramente anche una **SELECT** e un foreach.\\
+All'interno di quest'ultimo è possibile notare una if, dove viene controllato se il campo **$only_menu** e il campo **'pm_categoria'** nel record **ita_puntimenu_rec** non sono di tipo **ME** (Menu).\\
+Nell'esempio questo controllo è utilizzato per capire se il record che sta passando è o meno una Foglia.
+\\
+All'interno del **foreach** continueremo con l'impostazione dei campi obligatori, per quanto riguarda l'impostazione delle foglie:\\
+\\
+\\
+<code>
+                .....
+                    continue;
+              }
                 $inc = count($albero);
                 $albero[$inc] = $Ita_puntimenu_rec;
-                $albero[$inc]['INDICE'] = $inc;   // Imposta alla chiave univoca indice come $inc
+                $albero[$inc]['INDICE'] = $inc;
                 $albero[$inc]['level'] = $level;
                 $albero[$inc]['parent'] = $indice;
@@ Linea 136: / Linea 169: @@
                 $albero[$inc]['loaded'] = 'false';
                 $albero[$inc]['isLeaf'] = 'true';
+</code>
-                $sql = "SELECT * FROM ita_menu WHERE me_menu = '" . $Ita_puntimenu_rec['pm_voce'] . "'";
+Possiamo notare che la variabile **$inc**  viene settata con il conteggio totale dei record in **$albero**.\\
-                $Ita_menu_giu_rec = ItaDB::DBSQLSelect($this->ITALSOFT_DB, $sql, false);
+\\
+Successivamente, sempre all'interno del **foreach**, verrà controllato se il rercord che sta passando è o meno un menu :\\
+<code>
+                .....
+                $albero[$inc]['isLeaf'] = 'true';
+       if ($Ita_puntimenu_rec['pm_categoria'] == 'ME') {
+                    $albero[$inc]['isLeaf'] = 'false';
+                    $sql = "SELECT * FROM ita_menu WHERE me_menu = '" . $Ita_puntimenu_rec['pm_voce'] . "'";
+                    $Ita_menu_giu_rec = ItaDB::DBSQLSelect($this->ITALSOFT_DB, $sql, false);
+                    $me_id = $Ita_menu_giu_rec['me_id'];
+</code>
+Nel caso in cui si tratti di un **Menu**, possiamo subito notare l'impostazione del campo obbligatorio **'isLeaf'**definita **false**, in quanto si tratta di un Nodo e non una foglia.\\
+E' inoltre presente una **Select**, che assegnerà alla variabile $me_id il valore **'me_id'** risultante dalla query.
+\\
+Dopo di che verrà salvato il conteggio totale in **$save_count** dei record contenuti in **$albero** e la funzione avrà un "autorichiamo":
+<code>
+                ....
                 $me_id = $Ita_menu_giu_rec['me_id'];
                 $save_count = count($albero);
                 $albero = $this->caricaTreeLegami($me_id, $albero, $level + 1, $inc, $only_menu, $filtro);
-                if ($save_count == count($albero)) {      // Fa riferimento a sestessa incrementando però il level di 1. (Fino a che non arriverà a 10, come da controllo impostata all'inizio della menLib,nella funzione caricaTreeLegami)
+                if ($save_count == count($albero)) {
-                        $albero[$inc]['isLeaf'] = 'true';
+                         $albero[$inc]['isLeaf'] = 'true';
-                    } else {
-                        if (!$filtro) {
-                            $albero[$inc]['pm_descrizione'] = "<span style=\"font-weight:bold;color:darkred;\">" . $albero[$inc]['pm_descrizione'] . "</span>";
-                        }
                     }
                 }
@@ Linea 157: / Linea 204: @@
     }
 </code>
+Possiamo notare che nell'assegnazione della funzione ricorsiva i valori **$chiave,$level** e **$parent** subiscono delle variazioni:
+\\
+  * alla variabile **$chiave** viene assegnato il valore **$me_id**
+  * la variabile **$level** viene incrementata di **1**
+  * e alla variabile **$parent** viene assegnato il valore contenuto in **$inc**
+Viene inoltre riutilizzata la condizione  **if ($save_count == count($albero))** che come prima ha il compito di controllare se il risultato è differente( quindi nuovo livello) o non è variato (quindi foglia).
+Infine vi è il ritorno di $albero : **return $albero;**
+Per concludere:
+<code>
+        .....
+        $this->tree = $this->menLib->getMenu($voceMenu, $only_menu = false, $gruppo, $return_model = 'adjacency', $filtro = false);
+        $arr = array('arrayTable' => $this->tree,
+            'rowIndex' => 'idx');
+        $griglia = new TableView($this->tableId, $arr);
+        $griglia->setPageNum(1);
+        $griglia->setPageRows('1000');
+	....
+</code>
+**tree** a questo punto contiene tutto il nostro albero.\\
+Come è già stato detto in precedenza nel Generetor il nostro elemento è stato definito treeGrid, e attraverso la selezione del 'arrayTable' e la funzione TableView , il nostro albero verrà inserito nella grid.
+{{counter}} visualizzazioni.