'9')
$vsChar = "-";
$vsTemp.=$vsChar;
}
$vaTemp = explode("-",$vsTemp);
if(count($vaTemp)==3)
{
if(strlen($vaTemp[2])==2)
{
$vaTemp[2] = substr(date("Y"),0,2).$vaTemp[2];
}
$vaTime=Array();
$vaTime["tm_hour"]=0;
$vaTime["tm_min"]=0;
$vaTime["tm_sec"]=0;
$vaTime["tm_mday"]=ltrim($vaTemp[0],"0");
$vaTime["tm_mon"]=ltrim($vaTemp[1],"0")-1;
$vaTime["tm_year"]=$vaTemp[2]-1900;
}
}
else
$vaTime = Util::strptime($psValue,$psFrom);
//echo $psValue."|".$paPar[0];
//print_r($vaTime);echo "
";
if($vaTime)
{
//echo "2";
if(($vaTime["tm_hour"]<0)||($vaTime["tm_hour"]>23))
$vaTime["tm_hour"] = 0;
if(($vaTime["tm_min"]<0)||($vaTime["tm_min"]>59))
$vaTime["tm_min"] = 0;
if(($vaTime["tm_sec"]<0)||($vaTime["tm_sec"]>59))
$vaTime["tm_sec"] = 0;
$vnTime = mktime($vaTime["tm_hour"],$vaTime["tm_min"],$vaTime["tm_sec"],
$vaTime["tm_mon"]+1,$vaTime["tm_mday"],1900+$vaTime["tm_year"]);
$vsRes = strftime($psTo,$vnTime);
//echo "|".$vnTime."|
";
//echo $paPar[1].",".$vnTime.",".$vsRes;
}
else
$vsRes = null;
}
//die($vsRes);
//echo "!".$vsRes."!";
return $vsRes;
}
static function ifNull($pxValue,$pxSost = S_NULL)
{
if(is_null($pxValue))
return $pxSost;
return $pxValue;
}
/**
* Emula (parte) dell'strptime per Windows
* Accetta i seguenti formati:
* %Y-%m-%d [%H o %h]:[%i]:[%s]
* %y-%m-%d [%H o %h]:[%i]:[%s]
* %d-%m-%y [%H o %h]:[%i]:[%s]
* %d-%m-%Y [%H o %h]:[%i]:[%s]
* [%H o %h]:[%i]:[%s]
* %Y%m%d (per as/400)
* %H%i%s (per as/400)
*
* NOTE:
* oltre al "-" come divisore sono accettati "/" e "\" e lo spazio " "
* per le ore � obbligatorio il ":"
* in pratica accetta formati con data/ora o solo ora (inteso h:m:s o h:m o h)
*
* @param unknown_type $psDate
* @param unknown_type $psFormat
* @return unknown
*/
static function strptime($psDate,$psFormat="")
{
if ((!defined('B_USE_STRPTIME')) || B_USE_STRPTIME)
{
return(strptime($psDate,$psFormat));
}
$psDate=trim($psDate);
$vbErr=false;
if($psFormat=="")
{
$vsAnno="";
if($vsAnno=="")
{
$vsT=substr($psDate,0,4);
$vnT=(int)$vsT;
if($vnT>=1900)
$vsAnno="sx4";
}
if($vsAnno=="")
{
$vsT=substr($psDate,-4);
$vnT=(int)$vsT;
if($vnT>=1900)
$vsAnno="dx4";
}
$vsTime="";
$vsTime2="";
if(strpos($psDate,":")!==false)
{
if($vsAnno=="dx4")
$vbErr=true;
if(strlen($psDate)<=8 and $vsAnno=="")
$vsTime="onlyTime";
else
$vsTime="Time";
// se il primo : � nella stessa pos dell'ultimo :
// allora c'� n'� solo 1 e non si sono i secondi ma solo ore e minuti
if(strpos($psDate,":")==strrpos($psDate,":"))
$vsTime2="%H:%i";
else
$vsTime2="%H:%i:%s";
}
if(!$vbErr)
{
if($vsAnno=="sx4")
$psFormat="%Y-%m-%d";
elseif($vsAnno=="dx4")
$psFormat="%d-%m-%Y";
elseif($vsTime<>"onlyTime")
$psFormat="%d-%m-%y";
$psFormat .=$vsTime2;
}
}
/**
* Guido Allione. Adattamento per l'AS/400. Modifica molto brutta... ma questa funzione
* andr� riscritta prima o poi.
*/
if($psFormat=="%Y%m%d")
{
$psDate=substr($psDate,0,4)."-".substr($psDate,4,2)."-".substr($psDate,6,2);
$psFormat="%Y-%m-%d";
}
if($psFormat=="%H%i%s")
{
$psDate=substr($psDate,0,2).":".substr($psDate,2,2).":".substr($psDate,4,2);
$psFormat="%H:%i:%s";
}
//***********************************************************
// INIZIA PARTE DI CONVERSIONE
//***********************************************************
$vaRis=array("tm_mday"=>0,"tm_mon"=>0,"tm_year"=>0,"tm_hour"=>0,"tm_min"=>0,"tm_sec"=>0,"tm_wday"=>0,
"tm_yday"=>0,"unparsed"=>$psDate);
/**
tm_sec Seconds after the minute (0-61)
tm_min Minutes after the hour (0-59)
tm_hour Hour since midnight (0-23)
tm_mday Day of the month (1-31)
tm_mon Months since January (0-11)
tm_year Years since 1900
tm_wday Days since Sunday (0-6)
tm_yday Days since January 1 (0-365)
unparsed the date part which was not recognized using the specified format
*/
$vsDiv="";
if(strpos($psDate,"-")!==false)
$vsDiv="-";
elseif(strpos($psDate,"/")!==false)
$vsDiv="/";
elseif(strpos($psDate,"\\")!==false)
$vsDiv="\\";
$vbOnlyTime=false;
if($vsDiv=="")
{
if(strpos($psDate,":")!==false)
{
$vbOnlyTime=true;
$vsDiv=":";
}
else
return $vaRis;
}
$vsDate=$psDate;
if($vsDiv<>":") $vsDate=str_replace($vsDiv,":",$vsDate);
$vsDate=str_replace(" ",":",$vsDate);
$vaTmp=explode(":",$vsDate);
$vaPart=array();
foreach($vaTmp as $vsTmp)
{
$vsTmp=trim($vsTmp);
if($vsTmp<>"")
$vaPart[]=(int)$vsTmp;
}
if(count($vaPart)<3 and !$vbOnlyTime)
return $vaRis;
if(!$vbOnlyTime)
{
if(strtolower(substr($psFormat,0,2))=="%y")
{
if($vaPart[0]>1000)
$vaRis["tm_year"]=$vaPart[0];
elseif($vaPart[0]>50)
$vaRis["tm_year"]=1900+$vaPart[0];
else
$vaRis["tm_year"]=2000+$vaPart[0];
$vaRis["tm_mon"]=$vaPart[1];
$vaRis["tm_mday"]=$vaPart[2];
}
elseif(strtolower(substr($psFormat,0,2))=="%d")
{
$vaRis["tm_mday"]=$vaPart[0];
$vaRis["tm_mon"]=$vaPart[1];
if($vaPart[2]>1000)
$vaRis["tm_year"]=$vaPart[2];
elseif($vaPart[2]>50)
$vaRis["tm_year"]=1900+$vaPart[2];
else
$vaRis["tm_year"]=2000+$vaPart[2];
}
else
return $vaRis;
}
if($vbOnlyTime)
$vnX=0;
else
$vnX=3;
if(isset($vaPart[$vnX]))
$vaRis["tm_hour"]=$vaPart[$vnX];
$vnX++;
if(isset($vaPart[$vnX]))
$vaRis["tm_min"]=$vaPart[$vnX];
$vnX++;
if(isset($vaPart[$vnX]))
$vaRis["tm_sec"]=$vaPart[$vnX];
if($vaRis["tm_year"]<1000 or $vaRis["tm_year"]>2900)
$vaRis["tm_year"]=0;
else
$vaRis["tm_year"] = $vaRis["tm_year"] - 1900;
if($vaRis["tm_mon"]<1 or $vaRis["tm_mon"]>12)
$vaRis["tm_mon"]=0;
else
$vaRis["tm_mon"] = $vaRis["tm_mon"] - 1;
if($vaRis["tm_mday"]<1 or $vaRis["tm_mday"]>31) $vaRis["tm_mday"]=0;
if($vaRis["tm_hour"]<0 or $vaRis["tm_hour"]>23) $vaRis["tm_hour"]=0;
if($vaRis["tm_min"]<0 or $vaRis["tm_min"]>59) $vaRis["tm_min"]=0;
if($vaRis["tm_sec"]<0 or $vaRis["tm_sec"]>59) $vaRis["tm_sec"]=0;
if($vaRis["tm_year"]>0)
{
$vnTime=mktime($vaRis["tm_hour"],$vaRis["tm_min"],$vaRis["tm_sec"],$vaRis["tm_mon"],$vaRis["tm_mday"],$vaRis["tm_year"]);
$vaRis["tm_wday"]=date("w",$vnTime);
$vaRis["tm_yday"]=date("z",$vnTime);
}
$vaRis["unparsed"]="";
return $vaRis;
}
function array2String($paKey)
{
$vsRes = "";
foreach($paKey as $k => $v)
{
$vsRes .= $k."=".urlencode($v)."&";
}
return substr($vsRes,0,-1);
}
static function string2Array($pxKey)
{
if(is_array($pxKey))
{
$vaRes = $pxKey;
}
else
{
$pxKey = trim($pxKey,"&");
$vaChiavi = explode("&",$pxKey);
$vaRes = Array();
//echo "chiavi\r\n";
//print_r($vaChiavi);
foreach($vaChiavi as $vsChiave)
{
list($k,$v) = explode("=",$vsChiave);
$vaRes[$k] = urldecode($v);
}
}
return $vaRes;
}
public static function prettyVarDump($paInput, $poMore = null, $pbPrintStack = true, $pbDie = true, $pbUseRapidTree = true) {
echo 'Variabile monitorata
';
if (!empty($paInput) && is_array($paInput) && $pbUseRapidTree)
self::prettyArrayDump($paInput,false, array('title' => 'Input', 'id' => 'Input'), false);
else
echo '' . var_export($paInput, true) . '
';
if ($poMore != null) {
echo 'Ulteriori informazioni
';
if (!empty($poMore) && is_array($poMore) && $pbUseRapidTree)
self::prettyArrayDump($poMore,false, array('title' => 'More', 'id' => 'more'), false);
else
echo '' . var_export($poMore, true) .'
';
}
if ($pbPrintStack) {
echo 'Stack Trace
';
if ($pbUseRapidTree)
self::prettyArrayDump(debug_backtrace(),false, array('title' => 'Stack trace', 'id' => 'StackTrace'), false);
else
echo '' . var_export(debug_backtrace(), true) . '
';
}
if ($pbDie) die();
}
public static function addToElenco($psInput, $psNewString, $psSeparator = ' ') {
if (strlen($psInput) == 0) {
return $psNewString;
} else {
return $psInput . $psSeparator . $psNewString;
}
}
public static function prettyArrayDump($paInput, $pbTree=false,$paParam=array(), $pbDie = true) {
if ($pbDie) die(rapidTree::viewArray($paInput,$pbTree,$paParam));
echo rapidTree::viewArray($paInput,$pbTree,$paParam);
}
}
?>ArrayToConst($vaConfig_array["app-constants"]);
//salvo la configurazione dell'applicazione
$this->maAppConfig = $vaConfig_array;
$this->msFsPathCache = ($psFsCache=="" ? (defined("FS_CACHE") ? FS_CACHE : false) : $psFsCache)."path.cache.txt";
$this->mbCache = defined("B_CACHE_ENABLE") ? B_CACHE_ENABLE : $pbCache;
if($this->mbCache)
$this->maCache = $this->ReadCache($this->msFsPathCache);
}
/**
* Dato un array, lo legge e trasforma in costanti define() il contenuto
* Il nome della costante � la chiave dell'elemento dell'array
* il valore � il prefix + valore dell'elemento (se non � un array), altrimenti �, se presente
* il contenuto dell'elemento["__attr"]["value"] (per compatibilit� con gli output XML della classe
* XMLParser)
* @param array $paArray array di input
* @param string $psPrefix usato per i richiami ricorsivi, lasciare il default "".
* @return void
*/
private function ArrayToConst($paArray,$psPrefix="")
{
foreach($paArray as $vsKey=>$vxValue)
{
if(!is_array($vxValue) and !is_object($vxValue) and !defined($vsKey) and substr($vsKey,0,2)<>"__")
define($vsKey,$psPrefix.$vxValue);
elseif(is_array($vxValue))
{
if(isset($vxValue["__attr"]["value"]) and !defined($vsKey))
define($vsKey,$psPrefix.$vxValue["__attr"]["value"]);
if(substr($vsKey,0,2)<>"__")
{
$vaCons=get_defined_constants(true);
$vaCons=isset($vaCons["user"]) ? $vaCons["user"] : array();
$this->ArrayToConst($vxValue,$psPrefix.(isset($vaCons[$vsKey]) ? $vaCons[$vsKey] : ""));
}
}
}
}
/**
* Questa funzione legge il File di cache nella forma Nome;Tipo;FileConPercorso.
* Il nome del file di cache solitamente � in FS_APP/cache/path.cache.txt
* @return Array Vuoto se non esiste il file di cache, oppure Array[serialize(argomenti)] => FileConPercorso
*/
public function ReadCache()
{
$vaRis = array();
if(!file_exists($this->msFsPathCache))
return $vaRis;
$vrFile = @fopen($this->msFsPathCache, "r");
if($vrFile)
{
while(($vsLinea=fgets($vrFile, 4096))!==false)
{
$vsLinea = str_replace(array("\n","\r"), "", $vsLinea);
$vaTmp = explode(AUTOLOAD_CACHE_SEP, $vsLinea);
if(count($vaTmp)==3)
$vaRis[$vaTmp[1]] = $vaTmp[0];
}
fclose($vrFile);
}
return $vaRis;
}
/**
* Questo metodo scrive la cache (vedere ReadCache).
* La funzione chiamante deve ottenere prima un lock per evitare scritture contemporanee
* @param $psFile path del file
* @param $psArg serialize dei dati
* @return true se ha scritto la cache con successo. false altrimenti
*/
public function WriteCache($psFile, $psArg="nondef")
{
$vbRes = false;
$vbFE = file_exists($this->msFsPathCache);
$vbLineExists = false;
if($vbFE)
{
$vrFile = fopen($this->msFsPathCache, "r");
$vbLineExists = false;
while(!$vbLineExists && ($vsLineRead=fgets($vrFile, 4096))!==false)
$vbLineExists = strpos($vsLineRead, $psFile.AUTOLOAD_CACHE_SEP.$psArg.AUTOLOAD_CACHE_SEP)===0;
fclose($vrFile);
}
if(!$vbLineExists)
{
$vnRis = file_put_contents($this->msFsPathCache, $psFile.AUTOLOAD_CACHE_SEP.$psArg.AUTOLOAD_CACHE_SEP.time()."\n", FILE_APPEND);
if(!$vbFE)
chmod($this->msFsPathCache, 0777);
$vbRes = $vnRis>0;
}
return $vbRes;
}
/**
* Partendo da un path ritorna un array che descrive in quanti punti (Ed in che versioni) � stata trovata la libreria.
* La struttura del risultato � Array([livello] => array(lista path+file), [Livello] => ...)
* La lista � da ordinare con krsort()
* @param string $psNome Nome della classe da trovare
* @param string $pxPath (stringa) Percorso file system in cui fare la ricerca,
* @param array $pxPath (array) Lista di percorsi file system in cui fare la ricerca,
* @param string $psTipo (default="") si pu� specificare se solo "class", "func", "page", ...
* @param array $pxExt (default=array("php")) estensioni da considerare
* @param string $pxExt Singola estensione da considerare
* @param integer $pnMaxLevel (default=100) massimo livello di profondit� (per prevenire loop)
* @param integer $pnIndex variabile interna, non cambiare il default.
* @return Array Array([livello] => array(lista path+file), [Livello] => ...)
* @author Guido Allione 18/07/06 prima versione
* @author Guido Allione 18/07/06 seconda versione
*/
private function searchListFile($psNome,$pxPath,$psTipo="",$pxExt=array("php"),$pnMaxLevel=100,$pnIndex=1000)
{
$pnPath=0;
// se $pxExt non � un array, lo trasformo in un array.
if(!is_array($pxExt))
$pxExt=array($pxExt);
// se $psNome ha una estensione, gliela tolgo e aggiungo l'estensione nella ricerca.
$vaBase=pathinfo($psNome);
if(isset($vaBase["extension"]))
{
$psNome=basename($psNome,".".$vaBase["extension"]);
if(!in_array($vaBase["extension"],$pxExt))
$pxExt[]=$vaBase["extension"];
}
if(!is_array($pxPath))
{
$pxPath=array($pxPath);
$pnPath=$pnIndex;
}
else
$pnPath=count($pxPath);
$vaResult=Array();
foreach ($pxPath as $psPath)
{
if(!file_exists($psPath))
continue;
$voDir=dir($psPath);
while(($vsNome=$voDir->read())!==false)
{
if(is_dir($psPath."/".$vsNome) and $vsNome<>"." and $vsNome<>".." and $pnMaxLevel>0)
{
// e' una directory, percorro l'albero fino ad un livello max di $pnMaxLevel.
$vaResult_next=AutoLoad::searchListFile($psNome,$psPath."/".$vsNome,$psTipo,$pxExt,$pnMaxLevel-1,$pnPath);
foreach ($vaResult_next as $vsLivello => $vaPathFile)
foreach ($vaPathFile as $vsPathFile)
$vaResult[$vsLivello][]=$vsPathFile;
}
else
{
// e' un file, se mi interessa, lo elenco
$vaNome=explode(".",$vsNome);
$vaNome_info=pathinfo($vsNome);
if($vaNome[0]==$psNome and in_array($vaNome_info["extension"],$pxExt))
{
if(count($vaNome)==2)
{
// caso NomeFile.ext
if($psTipo=="")
$vaResult[str_pad($pnPath,5,"0",STR_PAD_LEFT)."-000000-".str_pad($pnMaxLevel,5,"0",STR_PAD_LEFT)][]=$psPath."/".$vsNome;
}
elseif(count($vaNome)==3)
{
// caso nomefile.tipo.ext
if($psTipo=="" or $psTipo==$vaNome[1])
$vaResult[str_pad($pnPath,5,"0",STR_PAD_LEFT)."-000000-".str_pad($pnMaxLevel,5,"0",STR_PAD_LEFT)][]=$psPath."/".$vsNome;
}
elseif(count($vaNome)==4)
{
// caso nomefile.livello.tipo.ext
if(($psTipo=="" or $psTipo==$vaNome[2]))
$vaResult[str_pad($pnPath,5,"0",STR_PAD_LEFT)."-".str_pad($vaNome[1],6,"0",STR_PAD_LEFT)."-".str_pad($pnMaxLevel,5,"0",STR_PAD_LEFT)][]=$psPath."/".$vsNome;
}
else
{
// gli altri casi gli ignoro.
}
}
}
}
$voDir->Close();
$pnPath--;
}
return $vaResult;
}
/**
* Questa funzione ritorna il file pi� recente (in termini di versione) tra i percorsi ricercati.
* Usabile in modalit� statica
* @param string $psNome Nome della classe da trovare
* @param variant $pxPath (stringa) Percorso file system in cui fare la ricerca,
* @param variant $pxPath (array) Lista di percorsi file system in cui fare la ricerca,
* @param string $psTipo (default="") si pu� specificare se solo "class", "func", "page", ...
* @param string $pxExt Singola Estensione da considerare
* @param array $pxExt (default array("php"), lista estensioni da considerare.
* @return string Percorso+Nome File pi� recente trovato.
* @return false Non trovato
*/
public function GetRecentFile($psNome,$pxPath,$psTipo="",$pxExt=array("php"))
{
$vaResult = AutoLoad::searchListFile($psNome,$pxPath,$psTipo,$pxExt);
if(count($vaResult)>0)
{
krsort($vaResult);
reset($vaResult);
$vaRis = current($vaResult);
$vxRis = $vaRis[0];
$vxRis = str_replace("//", "/", $vxRis);
}
else
$vxRis = false;
return $vxRis;
}
/**
* Questa funzione ritorna il file pi� recente (in termini di versione) tra i percorsi ricercati.
* Notare che, a parit� di parametri, la ricerca viene fatta una sola volta e poi messa in cache.
* Per resettare la cache, agire su $pbResetCache.
* NON usabile in modalit� statica.
* @param string $psNome Nome della classe da trovare
* @param variant $pxPath (stringa) Percorso file system in cui fare la ricerca,
* @param variant $pxPath (array) Lista di percorsi file system in cui fare la ricerca,
* @param string $psTipo (default="") si pu� specificare se solo "class", "func", "page", ...
* @param string $pxExt Singola Estensione da considerare
* @param array $pxExt (default array("php")), lista estensioni da considerare.
* @return string Percorso+Nome File pi� recente trovato.
* @return false Non trovato
*/
public function GetRecentFileCache($psNome,$pxPath,$psTipo="",$pxExt=array("php"))
{
$vaArg = func_get_args();
$vsArg = str_replace("\"","",serialize($vaArg));
if(isset($this->maCache[$vsArg]))
return $this->maCache[$vsArg];
// il path non � in sessione -> aggiornamento sessione in base al file di cache, se non basta ricerca su file-system
$vxRis = false;
$vxLock = Util::getLock("cache-weblib", 30);
if($vxLock!==false)
{
// aggiornamento cache in sessione
if($this->mbCache)
{
$this->maCache = $this->ReadCache($this->msFsPathCache);
if(isset($this->maCache[$vsArg]))
return $this->maCache[$vsArg];
}
// rierca su file-system
$vxRis = $this->GetRecentFile($psNome, $pxPath, $psTipo, $pxExt);
// aggiornamento cache su file e quindi in sessione
if($vxRis!==false and $this->mbCache)
{
$this->WriteCache($vxRis, $vsArg);
$this->maCache = $this->ReadCache($this->msFsPathCache);
}
Util::releaseLock($vxLock);
}
return $vxRis;
}
/**
* Funzione richiamata in sysx.x.x/lib/weblib5/framework.NNNNxx.page.php dalla funzione di autoload.
* Ritorna percorso e nome file pi� recente per la classe richiesta.
* La ricerca avviene secondo il seguente criterio di ricerca:
* App/modules App/managers, App/lib, Sys/modules, Sys/managers, Sys/Lib, Sys/WebLib5
* @param string $psNome nome della classe
* @return string percorso + nome file classe.
*/
public function GetRecentClass($psNome)
{
global $gaSearchPaths;
$vaPaths = Array();
foreach($gaSearchPaths as $vaPath)
{
$vaPaths[] = $vaPath["fs"]."modules/";
$vaPaths[] = $vaPath["fs"]."managers/";
$vaPaths[] = $vaPath["fs"]."lib/";
}
return $this->GetRecentFileCache($psNome, $vaPaths, "class", "php");
}
/**
* Ritorna percorso e nome file pi� recente per il template richiesto.
* La ricerca avviene secondo il seguente criterio di ricerca:
* App/module-xx/html/ App/manager-xx/html/, App/html/,
* sys/module-xx/html/ sys/manager-xx/html/, sys/html/,
* (solo App/html/ e sys/html/ se $psModule non viene specificato)
*
* @param string $psNome nome del template
* @param string $psModule Modulo che ha effettuato la richiesta
* @return string percorso + nome file template.
*/
public function GetRecentTemplate($psNome,$psModule="")
{
global $gaSearchPaths;
if(!isset($GLOBALS["goSystem"]) and $psModule<>"")
die("AutoLoad Class: non � possibile usare GetRecentTemplate senza avere l'ambiente WebLib5 caricato.");
if($psModule<>"")
{
global $goSystem;
// qui carico la cfg tenendo conto dell'istanza
$vaModConfig=$goSystem->getModuleConfig($psModule);
// qui tolgo l'istanza per cercare nella cartella giusta
list($psModule,$vsInstance) = $this->explodeModuleName($psModule);
}
$vaPaths = Array();
foreach($gaSearchPaths as $vaPath)
{
if($psModule<>"")
{
$vaPaths[]=$vaPath["fs"]."modules/".$psModule."/html/";
$vaPaths[]=$vaPath["fs"]."managers/".$vaModConfig["manager"]."/html/";
}
$vaPaths[]=$vaPath["fs"]."html/";
}
return $this->GetRecentFileCache($psNome,$vaPaths,"",array("html","htm","shtml","shtm","php"));
}
/**
* Prende un array e lo ritorna a pari struttura eseguendo alcuni comandi:
* in particolare:
* #EVAL: effettua un eval() di quello che segue, il risultato finisce nell'elemento dell'array corrente
* #TRUE: trasforma in true, il risultato finisce nell'elemento dell'array corrente
* #FALSE: trasforma in false, il risultato finisce nell'elemento dell'array corrente
*
* @param array $paArray array di input
* @return array array di output
*
* @author Guido Allione 0102ga 30/08/2006
*/
function EvalArray($paArray)
{
$vaRis=array();
if(is_array($paArray))
{
foreach ($paArray as $vsKey => $vxValue)
{
if(is_array($vxValue))
$vaRis[$vsKey]=$this->EvalArray($vxValue);
elseif(substr($vxValue,0,6)=="#EVAL:")
{
$vsTmp="\$vaRis[\"$vsKey\"]=".substr($vxValue,6);
@eval($vsTmp);
}
elseif($vxValue=="#FALSE")
$vaRis[$vsKey]=false;
elseif($vxValue=="#TRUE")
$vaRis[$vsKey]=true;
else
$vaRis[$vsKey]=str_replace(array("\\n","\\r","\\t","\\0","\\x0B"),array("\n","\r","\t","\0","\x0B"),$vxValue);
}
}
return $vaRis;
}
/**
* Questo Metodo ritorna la configurazione di un Modulo.
* La configurazione del modulo � composta dei seguenti file (in ordine
* di priorit�, dal pi� importante):
*
* eventuale configurazione $paConfig_init.
*
* app/modules/$psModule/$psModule.cnf.php
* app/modules/$psModule/$psModule.xml
* (se non trovati in)
* app/modules/$psModule.cnf.php
* app/modules/$psModule.xml
*
* MERGE CON.....
*
* (se trovata la configurazione del modulo e pertanto il relativo manager).
* app/manager/manager_del_modulo/manager_del_modulo.cnf.php
* app/modules/manager_del_modulo/manager_del_modulo.xml
* (se non trovati in)
* app/manager/manager_del_modulo.cnf.php
* app/modules/manager_del_modulo.xml
*
* MERGE CON.....
*
* (se trovata la configurazione del modulo e pertanto il relativo manager).
* app/config.cnf.php
* app/config.xml
*
* MERGE CON.....
*
* IDEM COME SOPRA ANCHE PER SYS/...
*
* NOTA DI NON RETROCOMPATIBILITA CON WEBLIB 5.0
* A) Non � previsto il caricamento di configurazioni di manager a pi� di un livello di extends
* B) Essendo gestiti gli XML, le configurazioni avranno degli elementi __attr, __name, __value, __dtd
* ecc... non previste nelle configurazioni standard.
*
* @param string $psModule Nome del modulo
* @param array $pxConfig_init Configurazione dinamica come array o stringa XML
* @return array Configurazione Finale.
*/
public function GetModuleConfig($psModule="",$pxConfig_init=array())
{
global $gaSearchPaths;
// Se sono in un modulo con multi istanza fingo di essere nel modulo puro e setto una variabile con il nome dell'istanza da utilizzare per caricare la configurazione aggiuntiva
list($psModule,$vsInstance) = $this->explodeModuleName($psModule);
if(is_array($pxConfig_init))
$vaConfig_array[]=$pxConfig_init;
elseif(is_string($paxConfig_init) and $pxConfig_init<>"")
$vaConfig_array[]=$this->GetArrayXml($pxConfig_init,"S");
$vsManager="";
/**
* Ricerca 0: In caso di modulo con istanza cerco la configurazione istanza se c'�
* File di configurazione del app/modules/nome_modulo/ versione cnf o xml
* e se non lo trova, in app/modules direttametne cnf o xml.
*/
/* per ogni path configurato eseguo le solite ricerche
rispetto alla precedente versione facci il marge anche all'intero della stessa casistica.
Ad esempio mergio modules/aaa/aaa.cnf.php modules/aaa.cnf.php
*/
$vaPaths = array
(
Array
(
"file"=>"modules/".$psModule."/".$psModule."_".$vsInstance.".cnf.php",
"xml"=>false,
),
/*
Array
(
"file"=>"modules/".$psModule."/".$psModule."_".$vsInstance.".".CONFIG_XML_EXT,
"xml"=>true,
),
*/
Array
(
"file"=>"modules/".$psModule."_".$vsInstance.".cnf.php",
"xml"=>false,
),
/*
Array
(
"file"=>"modules/".$psModule."_".$vsInstance.".".CONFIG_XML_EXT,
"xml"=>true,
),
*/
Array
(
"file"=>"modules/".$psModule."/".$psModule.".cnf.php",
"xml"=>false,
),
/*
Array
(
"file"=>"modules/".$psModule."/".$psModule.".".CONFIG_XML_EXT,
"xml"=>true,
),
*/
Array
(
"file"=>"modules/".$psModule.".cnf.php",
"xml"=>false,
),
/*
Array
(
"file"=>"modules/".$psModule.".".CONFIG_XML_EXT,
"xml"=>true,
),
*/
Array
(
"file"=>"managers/{manager}/{manager}.cnf.php",
"xml"=>false,
),
/*
Array
(
"file"=>true,
"xml"=>"managers/{manager}/{manager}.".CONFIG_XML_EXT,
),
*/
Array
(
"file"=>"managers/{manager}.cnf.php",
"xml"=>false,
),
/*
Array
(
"file"=>"managers/{manager}".CONFIG_XML_EXT,
"xml"=>true,
),
*/
/* questo lo tolgo per� contenendo costanti crea problemi
Array
(
"file"=>"config.cnf.php",
"xml"=>false,
),
*/
/*
Array
(
"file"=>"config.".CONFIG_XML_EXT,
"xml"=>true,
),
*/
);
$vaRes = array();
foreach($gaSearchPaths as $vaPath)
{
foreach($vaPaths as $vaSubPath)
{
$vsPath = $vaPath["fs"].$vaSubPath["file"];
$vbManager=false;
if(strpos($vaSubPath["file"],"managers/")===0) // se inizia per managers/
{
$vbManager=true;
if(array_key_exists("manager",$vaRes))
$vsPath = str_replace("{manager}",$vaRes["manager"],$vsPath);
}
$vbGlobal=false;
if(strpos($vaSubPath["file"],"config.")===0) // se inizia per config.
{
$vbGlobal=true;
}
// Sse sono in un path senza manager oppure conosco il nome del manager procedo
if(!$vbManager || array_key_exists("manager",$vaRes))
if(is_readable($vsPath))
{
if($vaSubPath["xml"]) // file xml
{
$vaRes=array_merge($vaRes,$this->GetArrayXml($vsPath,"F"));
}
else // file php
{
include($vsPath);
if($vbGlobal)
$vsVar = "gaConfig";
else if ($vbManager)
$vsVar = "gaManagerConfig";
else
$vsVar = "gaModuleConfig";
if(!isset($$vsVar))
trigger_error("Il File $vsPath deve contenere la definizione dell'array \$$vsVar.", E_USER_ERROR);
$vaRes=array_merge($vaRes,$$vsVar);
unset($gaModuleConfig);
}
}
}
}
global $gaEnvConfig;
if(is_array($gaEnvConfig)&&array_key_exists("modules",$gaEnvConfig)&&array_key_exists($psModule,$gaEnvConfig["modules"]))
$vaRes = $this->array_merge_recursive2($vaRes,$gaEnvConfig["modules"][$psModule]);
return $vaRes;
}
/**
* Questa funzione fonde insieme due array dando priorit� a $paArray2.
* A parit� di elemento (a qualsiasi livello) viene preso $paArray2 in caso
* di conflitto, altrimenti avviene la fusione.
*
* NOTA: identica a quella presente nelle librerie di funzioni, riportata
* unicamente per dare autonomia alla classe AutoLoad.
*
* @param array $paArray1 Array secondario
* @param array $paArray2 Array Principale
* @return array Fusione dei due array passati come parametro.
*/
public function array_merge_recursive2($paArray1, $paArray2)
{
if (!is_array($paArray1) or !is_array($paArray2))
{
return $paArray2;
}
foreach ($paArray2 AS $sKey2 => $sValue2)
{
// originale
//$paArray1[$sKey2] = array_merge_recursive2(@$paArray1[$sKey2], $sValue2);
// modificato
if(array_key_exists($sKey2,$paArray1))
$paArray1[$sKey2] = $this->array_merge_recursive2($paArray1[$sKey2], $sValue2);
else
$paArray1[$sKey2] = $paArray2[$sKey2];
}
return $paArray1;
}
/**
* A fronte della nuova implementazione di sottomoduli,
* ModuloNome:instanza , questo metodo si occupa di
* ritornare la l'array con due elementi numerici: Modulo ed Istanza.
*
* @param string $psModule Modulo o Modulo:Istanza
* @return array
*/
static function explodeModuleName($psModule)
{
$vsInstance = null;
if(strpos($psModule,":")!==false)
{
$vaTemp = explode(":",$psModule);
$psModule = $vaTemp[0];
$vsInstance = $vaTemp[1];
}
return array($psModule,$vsInstance);
}
/**
* Questo metodo si occupa di fare alcuni controlli sulla configurazione
* o sulla sicurezza all'inizio della sessione di WebLib.
* Per questo motivo questo metodo va richimato nel framework
* all'interno dell'if che istanzia per la prima volta $goSystem.
*
*/
function checkConfigAndSecurity()
{
//
}
/**
* Restituisce la configurazione dell'applicazione
*
* @return array
*/
function getAppConfig()
{
return $this->maAppConfig;
}
}
?>