phpDocumentor VFront
Function-Libraries
[ class tree: VFront ] [ index: VFront ] [ all elements ]

Source for file func.comuni.php

Documentation is available at func.comuni.php

  1. <?php
  2. /**
  3. * Libreria di funzioni comuni.
  4. * Si tratta di funzioni incluse in quasi tutti gli script e di uso comune in tutta l'applicazione VFront
  5. @package VFront
  6. @subpackage Function-Libraries
  7. @author Mario Marcello Verona <marcelloverona@gmail.com>
  8. @copyright 2007 Mario Marcello Verona
  9. @version 0.90
  10. @license http://www.gnu.org/licenses/gpl.html GNU Public License
  11. */
  12.  
  13.  
  14.  
  15. /**
  16.  * Pulisce da spazi bianchi, aggiunge gli slash e rimuove eventuali tags i campi inseriti.
  17.  * Viene utilizzata per ragioni di sicurezza in contesti di invio di dati da parte del client.
  18.  *
  19.  * @param array $post_dom 
  20.  * @return array 
  21.  */
  22. function pulisci_dom($post_dom){
  23.     
  24.     if(!is_array($post_dom)){
  25.         
  26.         return false;
  27.     }
  28.     
  29.     while(list($k,$val)=each($post_dom)){
  30.         if(is_array($val)){
  31.             while(list($kk,$valval)=each($val)){
  32.                 $_var[$k][$kk]=addslashes(stripslashes(strip_tags(trim($valval))));
  33.             }
  34.         }
  35.         else{
  36.             $_var[$k]=addslashes(stripslashes(strip_tags(trim($val))));
  37.         }
  38.     }
  39.     
  40.     return $_var;
  41. }
  42.  
  43.  
  44. /**
  45.  * Dato un numerico indicante l'ID del gruppo viene restituito il nome dello stesso
  46.  *
  47.  * @param int $gid ID del gruppo
  48.  * @return string Nome del gruppo
  49.  */
  50. function gid2nome_gruppo($gid){
  51.     
  52.     global $link,$db1;
  53.     
  54.     $q=vmsql_query("SELECT nome_gruppo FROM {$db1['frontend']}.gruppo WHERE gid=".intval($gid),$link);
  55.     list($nome_grvmsql_fetch_row($q);
  56.     
  57.     return $nome_gr;
  58.     
  59. }
  60.  
  61.  
  62.  
  63. /**
  64.  * Estrae le parti di una data in formato internazionale e restituisce le parti della stessa in un array.
  65.  * Fornisce inoltre un valore di chiave "ita" giÓ pronto con la data in formato italiano.
  66.  *
  67.  * @param string $dataISO 
  68.  * @param bool $ora 
  69.  * @return array 
  70.  */
  71. function dataISO2ITA($dataISO,$ora=false){
  72.     
  73.     $dataITA['d']=substr($dataISO,8,2);
  74.     $dataITA['m']=substr($dataISO,5,2);
  75.     $dataITA['Y']=substr($dataISO,0,4);
  76.     $dataITA['ita']=substr($dataISO,8,2)."/".substr($dataISO,5,2)."/".substr($dataISO,0,4);
  77.     
  78.     if($ora){
  79.         $dataITA['h']=substr($dataISO,11,2);
  80.         $dataITA['i']=substr($dataISO,14,2);
  81.         $dataITA['s']=substr($dataISO,17,2);
  82.         $dataITA['ita_noh']=$dataITA['ita'];
  83.         
  84.         $dataITA['ita'].= " alle ".$dataITA['h'].":".$dataITA['i'];
  85.     }
  86.         
  87.     return $dataITA;
  88. }
  89.  
  90.  
  91. /**
  92.  * Funzione di trasformazione di data e ora da formato internazionale a formato italiano.
  93.  * Richiama a sua volta la funzione dataISO2ITA()
  94.  *
  95.  * @param string $dataISO 
  96.  * @see function dataISO2ITA
  97.  * @return string 
  98.  */
  99. function dataoraITA($dataISO){
  100.     
  101.     $ar=dataISO2ITA($dataISO,true);
  102.     
  103.     return $ar['ita_noh']." ".$ar['h'].":".$ar['i'].":".$ar['s'];
  104.     
  105. }
  106.  
  107.  
  108.  
  109. /**
  110.  * Funzione di trasformazione di data da formato internazionale a formato italiano o con data e la T.
  111.  * Richiama a sua volta la funzione dataISO2ITA()
  112.  *
  113.  * @param unknown_type $dataISO 
  114.  * @param unknown_type $ora 
  115.  * @see function dataISO2ITA
  116.  * @see function dataoraITA
  117.  * @return unknown 
  118.  */
  119. function dataITA($dataISO,$ora=false){
  120.     
  121.     $ddataISO2ITA($dataISO,$ora);
  122.     if($ora){
  123.         return $d['ita_noh']."T".$dataITA['h'].$dataITA['i'].$dataITA['s'];
  124.     }
  125.     else{
  126.         return $d['ita'];
  127.     }
  128.     
  129. }
  130.  
  131.  
  132. /**
  133.  * Funzione interna per la determinazione dei campi coinvolti da una data query SQL
  134.  *
  135.  * @param string $sql 
  136.  * @return string 
  137.  */
  138. function analisi_select_from($sql){
  139.     
  140.     global $link;
  141.     
  142.     if(!vmsql_try($sql,$link,true)){
  143.         return false;
  144.     }
  145.     
  146.     // parsing della query
  147.     $campi eregi_replace("SELECT",'',$sql);
  148.     
  149.     list($campi,$monnezzapreg_split("'[\W]FROM[\W]'i",$campi);
  150.         
  151.  
  152. //    $campi = trim(strtok($campi,'FROM'));
  153. //    $campi = trim(strtok($campi,'from'));
  154.  
  155.     
  156.  
  157.     // quanti campi ci sono?
  158.     if(ereg(',',$campi)){
  159.  
  160.         $ar_campi=explode(",",$campi);
  161.         
  162.         
  163.         return array(trim($ar_campi[0]),trim($ar_campi[1]));
  164.     }
  165.     else{
  166.         return array(trim($campi));
  167.     }
  168.     
  169. }
  170.  
  171. /**
  172.  * UtilitÓ che da un 1:0 restituisce "Si" o "No" con la classe CSS omonima
  173.  *
  174.  * @param int $int 
  175.  * @return string 
  176.  */
  177. function high_si_no($int){
  178.  
  179.     return ($int'<span class="si">Si</span>' :  '<span class="no">No</span>' ;
  180. }
  181.  
  182. /**
  183.  * Funzione per generare l'ordinamento delle tabelle secondo una colonna data
  184.  *
  185.  * @param string $etichetta 
  186.  * @param int $ord 
  187.  * @param string $desc 
  188.  */
  189. function table_sort($etichetta,$ord,$desc=""){
  190.     
  191.     $getord(isset($_GET['ord'])) ? (int) $_GET['ord'$ord;
  192.     $sort (isset($_GET['sort'])) $_GET['sort'0;
  193.     
  194.     if($desc!=""){
  195.         
  196.         $title="title=\"$desc\"";        
  197.     }
  198.     else{
  199.         $title="";
  200.     }
  201.     
  202.     if(isset($_GET['ord']&& $ord==$_GET['ord']){
  203.         
  204.         $class="tab-ord";    
  205.         if($sort=="d"){
  206.                 return "<a class=\"$class desc\" href=\"".$_SERVER['PHP_SELF']."?gid=".$_GET['gid']."&amp;ord=$ord&amp;sort=a\" $title>$etichetta</a>";
  207.             }
  208.             else {
  209.             
  210.                 return "<a class=\"$class asc\" href=\"".$_SERVER['PHP_SELF']."?gid=".$_GET['gid']."&amp;ord=$ord&amp;sort=d\" $title>$etichetta</a>";;
  211.         }
  212.         
  213.     }
  214.     else{
  215.         return "<a href=\"".$_SERVER['PHP_SELF']."?gid=".$_GET['gid']."&amp;ord=$ord&amp;sort=a\" $title>$etichetta</a>";    
  216.     }
  217.     
  218. }
  219.  
  220. /**
  221.  * Funzione che recupera l'ordinamento impostato in una tabella data
  222.  *
  223.  * @param string $tabella 
  224.  * @param int $gid 
  225.  * @return string 
  226.  */
  227. function prendi_orderby($tabella,$gid=0){
  228.     
  229.     global $link,$db1;
  230.     
  231.     // Prendi il campo di ordinamento dalla tabella:
  232.     $q_orderby vmsql_query("SELECT orderby , orderby_sort FROM {$db1['frontend']}.registro_tab WHERE table_name='$tabellaAND gid=$gid ",$link);
  233.     
  234.     list($orderby,$orderby_sortvmsql_fetch_row($q_orderby);
  235.     
  236.     return $orderby." ".$orderby_sort;
  237. }
  238.  
  239.  
  240.  
  241.  
  242.  
  243. /**
  244.  * Funzione di debug.
  245.  * Scrive in un file di testo le query o il testo che viene passato con il parametro $sql
  246.  * E' utile soprattutto in operazioni di tipo AJAX.
  247.  *
  248.  * @param string $sql 
  249.  * @param string $filename 
  250.  */
  251. function rpc_debug($sql,$filename="./rpc.debug.txt"){
  252.     
  253.     global $RPC_DEBUG;
  254.     
  255.     if($RPC_DEBUG){
  256.         
  257.         if($fp=@fopen($filename,"a")){
  258.             
  259.             fwrite($fp,date("Y-m-d H:i:s")." --- ".str_replace(array("\n","\r")," ",$sql)."\n");
  260.             fclose($fp);
  261.         }
  262.     }
  263. }
  264.  
  265.  
  266.  
  267. /**
  268.  * Funzione di scrittura del log delle operazioni compiute mediante le maschere di VFront
  269.  * E' dipendente dal parametro $RPC_LOG, definito nel file di configurazione (default conf/conf.vfront.php)
  270.  *
  271.  * @param string $op 'select'|'insert'|'delete'|'update'|'ripristino'
  272.  * @param string $tabella 
  273.  * @param int $uid 
  274.  * @param int $gid 
  275.  * @param string $info_pk 
  276.  * @param bool $storico 
  277.  * @param string $storico_pre 
  278.  * @param string $storico_post 
  279.  * @param string $info_browser 
  280.  * @return mixed 
  281.  */
  282. function rpc_log($op,$tabella,$uid,$gid,$info_pk='',$storico=true,$storico_pre='',$storico_post='',$info_browser=''){
  283.     
  284.     global $RPC_LOG$db1$link;
  285.     
  286.     if($RPC_LOG){
  287.         
  288.         if(!in_array($op,array('select','insert','delete','update','ripristino','duplicazione'))){
  289.             
  290.             $op='sconosciuta';            
  291.         }
  292.         
  293.         $gid= (int) $gid;
  294.         $uid = (int) $uid;
  295.         
  296.         switch($op){
  297.             
  298.             case 'ripristino'
  299.             
  300.                     
  301.             
  302.                     $id_record $info_pk;
  303.             
  304.                         $sql="INSERT INTO {$db1['frontend']}.log (op,tabella,uid,gid,id_record,info_browser
  305.                           VALUES ('$op','$tabella',$uid,$gid,'$id_record','$info_browser')";
  306.                     
  307.                     $test=vmsql_try($sql,$link,false);
  308.             break;    
  309.             
  310.             case 'sconosciuta'
  311.             
  312.                     $id_record $info_pk;
  313.             
  314.                         $sql="INSERT INTO {$db1['frontend']}.log (op,tabella,uid,gid,id_record,info_browser
  315.                           VALUES ('$op','$tabella',$uid,$gid,'$id_record','$info_browser')";
  316.                     
  317.                     $test=vmsql_try($sql,$link,false);
  318.             break;    
  319.             
  320.             case 'duplicazione'
  321.             
  322.                     $id_record $info_pk;
  323.             
  324.                         $sql="INSERT INTO {$db1['frontend']}.log (op,tabella,uid,gid,id_record,info_browser,storico_post
  325.                           VALUES ('$op','$tabella',$uid,$gid,'$id_record','$info_browser','$storico_post')";
  326.                     
  327.                     $test=vmsql_try($sql,$link,false);
  328.             break;    
  329.             
  330.                     
  331.             case 'insert'
  332.             
  333.                 $id_record $info_pk;
  334.             
  335.                     if($storico){
  336.                         $storico_post=addslashes($storico_post);
  337.                         $sql="INSERT INTO {$db1['frontend']}.log (op,tabella,uid,gid,storico_post,id_record,info_browser
  338.                           VALUES ('$op','$tabella',$uid,$gid,'$storico_post','$id_record','$info_browser')";
  339.                     }else{
  340.                         
  341.                         $sql="INSERT INTO {$db1['frontend']}.log (op,tabella,uid,gid,id_record,info_browser
  342.                           VALUES ('$op','$tabella',$uid,$gid,'$id_record','$info_browser')";
  343.                     }
  344.                     
  345.                     $test=vmsql_try($sql,$link,false);
  346.                     $ID_LOG=vmsql_insert_id($link,"{$db1['frontend']}.log",'id_log');
  347.             break;
  348.             
  349.             
  350.             case 'delete':
  351.                     
  352.                     if($storico){
  353.                         
  354.                         $condizione='';
  355.                         $id='';
  356.                         
  357.                             foreach ($info_pk as $k=>$val){
  358.                                 $val=addslashes(stripslashes(utf8_decode($val)));
  359.                                 $condizione.=" $k='$valAND";
  360.                                 $id.=$val."|";
  361.                             }
  362.                             
  363.                             $condizione=substr($condizione,0,-3);
  364.                             $id=substr($id,0,-1);
  365.                         
  366.                         
  367.                         $q_storico_pre=vmsql_query("SELECT * FROM $tabella WHERE $condizione",$link);
  368.                         
  369.                         $RS_pre=vmsql_fetch_assoc($q_storico_pre);
  370.                         
  371.                         $storico_pre=addslashes(serialize($RS_pre));
  372.                         
  373.                         $sql="INSERT INTO {$db1['frontend']}.log (op,tabella,uid,gid,id_record,storico_pre,info_browser
  374.                               VALUES ('$op','$tabella',$uid,$gid,'$id','$storico_pre','$info_browser')";
  375.                     }
  376.                     else{
  377.  
  378.                         $condizione='';
  379.                         $id='';
  380.                         
  381.                             foreach ($info_pk as $k=>$val){
  382.                                 $val=addslashes(stripslashes(utf8_decode($val)));
  383.                                 $condizione.=" $k='$valAND";
  384.                                 $id.=$val."|";
  385.                             }
  386.                             
  387.                             $condizione=substr($condizione,0,-3);
  388.                             $id=substr($id,0,-1);
  389.                 
  390.                         
  391.                         $sql="INSERT INTO {$db1['frontend']}.log (op,tabella,uid,gid,id_record,info_browser
  392.                               VALUES ('$op','$tabella',$uid,$gid,'$id','$info_browser')";
  393.                     }
  394.                     
  395.                     $test=vmsql_try($sql,$link,false);
  396.                     
  397.                     $ID_LOG=vmsql_insert_id($link,"{$db1['frontend']}.log",'id_log');
  398.                     
  399.             break;
  400.             
  401.             
  402.             case 'update':
  403.                     
  404.                     if($storico){
  405.                         
  406.                         $condizione='';
  407.                         $id='';
  408.                         
  409.                             foreach ($info_pk as $k=>$val){
  410.                                 $val=addslashes(stripslashes(utf8_decode($val)));
  411.                                 $condizione.=" $k='$valAND";
  412.                                 $id.=$val."|";
  413.                             }
  414.                             
  415.                             $condizione=substr($condizione,0,-3);
  416.                             $id=addslashes(substr($id,0,-1));
  417.                         
  418.                         
  419.                         $q_storico_pre=vmsql_query("SELECT * FROM $tabella WHERE $condizione",$link);
  420.                         
  421.                         $RS_pre=vmsql_fetch_assoc($q_storico_pre);
  422.                         
  423.                         $storico_pre=addslashes(serialize($RS_pre));
  424.                         $storico_post=addslashes($storico_post);
  425.                         
  426.                         $sql="INSERT INTO {$db1['frontend']}.log (op,tabella,uid,gid,id_record,storico_pre,storico_post,info_browser
  427.                               VALUES ('$op','$tabella',$uid,$gid,'$id','$storico_pre','$storico_post','$info_browser')";
  428.                         $test=vmsql_try($sql,$link,false);
  429.                         
  430.                         $ID_LOG=vmsql_insert_id($link,"{$db1['frontend']}.log",'id_log');
  431.                         
  432.                     }
  433.                     else{
  434.  
  435.                         $condizione='';
  436.                         $id='';
  437.                         
  438.                             foreach ($info_pk as $k=>$val){
  439.                                 $val=addslashes(stripslashes(utf8_decode($val)));
  440.                                 $condizione.=" $k='$valAND";
  441.                                 $id.=$val."|";
  442.                             }
  443.                             
  444.                             $condizione=substr($condizione,0,-3);
  445.                             $id=substr($id,0,-1);
  446.                 
  447.                         
  448.                         $sql="INSERT INTO {$db1['frontend']}.log (op,tabella,uid,gid,id_record,info_browser
  449.                               VALUES ('$op','$tabella',$uid,$gid,'$id','$info_browser')";
  450.                         
  451.                         $test=vmsql_try($sql,$link,false);
  452.                         
  453.                         $ID_LOG=vmsql_insert_id($link,"{$db1['frontend']}.log",'id_log');
  454.                         
  455.                     }
  456.             break;
  457.             
  458.             
  459.         }
  460.         
  461.     }
  462.     else{
  463.         rpc_debug("Operazione $op saltata");
  464.     }
  465.     
  466.     return $ID_LOG;
  467. }
  468.  
  469.  
  470. /**
  471.  * Funzione di ordinamento dei valori di una matrice
  472.  * secondo una colonna scelta in ordine ascendente o discendente
  473.  * Funziona con una logica simile a l'SQL
  474.  *
  475.  * @param array $matrice La matrice data
  476.  * @param string $campo Il nome del campo
  477.  * @param string $tipo Metodo di ordinamento (ASC o DESC)
  478.  * @return array La nuova matrice ordinata
  479.  */
  480. function ordina_matrice($matrice,$campo,$tipo="ASC"){
  481.     
  482.     if(!is_array($matrice|| count($matrice)<){
  483.         return $matrice;
  484.     }
  485.     
  486.     // Scorre la matrice
  487.     foreach($matrice as $k=>$ar){
  488.         $new[$k]=array($ar[$campo],$ar);
  489.     }
  490.     
  491.     if($tipo=="DESC"){
  492.         rsort($new);
  493.     }else{
  494.         sort($new);
  495.     }
  496.     
  497.     $ordinata=array();
  498.     
  499.     while(list($k,$ar)=each($new)){
  500.         
  501.         $ordinata[$k]=$new[$k][1];
  502.     }    
  503.     
  504.     return $ordinata;
  505.     
  506. }
  507.  
  508. ?>

Documentation generated on Sat, 22 Sep 2007 11:50:09 +0200 by phpDocumentor 1.4.0a2