<?php
|
/*---------------------------------------------------------------*/
|
/*
|
Titre : SimpleFiles
|
|
URL : https://phpsources.net/code_s.php?id=294
|
Auteur : Oprichnik
|
Date édition : 13 Aout 2007
|
*/
|
/*---------------------------------------------------------------*/
|
|
/***********************************************************
|
* Auteur : Mallory Dessaintes
|
* Email de l'auteur : mallory.dessaintes@gmail.com
|
* Site Web : http://oprichnik.monespace.be
|
*
|
* Documentation : "documentation.html"
|
*
|
*
|
* VERSION : [1.0]
|
*
|
*
|
***********************************************************/
|
|
class simplefiles {
|
|
private $read_default_return_structure;
|
private $lastId;
|
private $flock_on;
|
|
private $backup_on;
|
private $backup_dir;
|
private $backup_time;
|
|
private $hash_on;
|
private $hash_fields;
|
private $hash_type;
|
|
private $crypt_on;
|
private $crypt_fields;
|
private $crypt_password;
|
private $crypt_functions;
|
|
private $select_a_u_fichier;
|
private $select_a_read;
|
private $select_last_id;
|
|
// ---------------------------------------------------------------
|
|
function __construct() {
|
$this->read_default_return_structure = 2;
|
$this->flock_on = true;
|
$this->backup_on = false;
|
$this->crypt_on = false;
|
$this->hash_on = false;
|
$this->select_a_read = false;
|
$this->select_last_id = false;
|
}
|
|
// ---------------------------------------------------------------
|
|
private function is_assoc_array($array) {
|
if(!is_array($array))
|
return false;
|
|
$next = 0;
|
foreach ($array as $k=>$v) {
|
if ($k === $next)
|
return false;
|
$next++;
|
}
|
return true;
|
}
|
|
private function is_assoc_multi_array($array) {
|
foreach($array as $k => $valeur) {
|
if(!$this->is_assoc_array($valeur))
|
return false;
|
}
|
|
return true;
|
}
|
|
private function sort_by_key($array, $index) {
|
$sort = array();
|
//préparation d'un nouveau tableau basé sur la clé à trier
|
foreach ($array as $key => $val) {
|
$sort[$key] = $val[$index];
|
}
|
|
asort($sort);
|
//formation du nouveau tableau trié selon la clé
|
$output = array();
|
foreach($sort as $key => $val) {
|
$output[] = $array[$key];
|
|
}
|
return $output;
|
}
|
|
private function str_decode($str,$filter) {
|
$filter = md5($filter);
|
$letter = -1;
|
$newstr = '';
|
$str = base64_decode($str);
|
$strlen = strlen($str);
|
|
for ( $i = 0; $i < $strlen; $i++ )
|
{
|
$letter++;
|
|
if ( $letter > 31 )
|
{
|
$letter = 0;
|
}
|
|
$neword = ord($str{$i}) - ord($filter{$letter});
|
|
if ( $neword < 1 )
|
{
|
$neword += 256;
|
}
|
|
$newstr .= chr($neword);
|
}
|
|
return $newstr;
|
}
|
|
private function str_encode($str,$filter) {
|
$filter = md5($filter);
|
$letter = -1;
|
$newpass = '';
|
|
$strlen = strlen($str);
|
|
for ( $i = 0; $i < $strlen; $i++ )
|
{
|
$letter++;
|
|
if ( $letter > 31 )
|
{
|
$letter = 0;
|
}
|
|
$neword = ord($str{$i}) + ord($filter{$letter});
|
|
if ( $neword > 255 )
|
{
|
$neword -= 256;
|
}
|
|
$newstr .= chr($neword);
|
|
}
|
|
return base64_encode($newstr);
|
}
|
|
private function cryptAndHashTest($array) { // tableau unidimensionnel
|
$result = $array;
|
|
foreach($array as $cle => $valeur) {
|
if($this->hash_on == true && in_array($cle,$this->hash_fields)
|
or $this->hash_fields[0] == "*")
|
($this->hash_type == "sha1")?$result[$cle] =
|
sha1($valeur):$result[$cle] = md5($valeur);
|
if($this->crypt_on == true && in_array($cle,$this->crypt_fields)
|
or $this->crypt_fields[0] == "*") {
|
if($this->crypt_functions)
|
$result[$cle] = call_user_func($this->crypt_functions[0],
|
$result[$cle],$this->crypt_password);
|
// Je modifie $result[$cle] et non pas $valeur comme au dessus
|
// car si le script a hashé dans le script du dessus et qu'il doit
|
// être crypté en dessous cela ne marchera pas en reprenant la
|
// valeur du tableau d'argument
|
else
|
$result[$cle] = $this->str_encode($result[$cle],
|
$this->crypt_password);
|
}
|
|
|
}
|
return $result;
|
}
|
|
private function decryptTest($array) { // array[][]
|
$result = $array;
|
|
foreach($array as $cle => $valeur) {
|
foreach($valeur as $cle2 => $valeur2) {
|
if($this->crypt_on == true && in_array($cle2,$this->crypt_fields)
|
or $this->crypt_fields[0] == "*") {
|
if($this->crypt_functions)
|
$result[$cle][$cle2] = call_user_func($this->crypt_functions[1],
|
$valeur2,$this->crypt_password);
|
else
|
$result[$cle][$cle2] = $this->str_decode($valeur2,
|
$this->crypt_password);
|
}
|
}
|
}
|
return $result;
|
}
|
|
private function backupTest($u_fichier) {
|
if($this->backup_on) {
|
$pathInf = pathinfo($u_fichier);
|
|
$last_num_backup = 0;
|
|
while(file_exists($this->backup_dir.$pathInf["filename"]."_
|
".$last_num_backup.".backup"))
|
$last_num_backup++;
|
|
if(!file_exists($this->backup_dir.$pathInf["filename"]."_0.backup"))
|
$filemtime = 0;
|
else
|
$filemtime = filemtime($this->backup_dir.$pathInf["filename"]."_
|
".($last_num_backup-1).".backup");
|
|
if(file_exists($u_fichier) && (time() - $filemtime > $this->backup_time))
|
copy($u_fichier,$this->backup_dir.$pathInf["filename"]."_
|
".$last_num_backup.".backup");
|
}
|
}
|
|
// ---------------------------------------------------------------
|
|
public function escapeQuotes($str) {
|
if(get_magic_quotes_gpc())
|
$str = stripslashes($str);
|
|
$str = str_replace('\\','\\\\',$str);
|
$str = str_replace("'","\\'",$str);
|
|
return $str;
|
}
|
|
public function escape2Quotes($str) {
|
if(get_magic_quotes_gpc())
|
$str = stripslashes($str);
|
|
$str = str_replace('\\','\\\\',$str);
|
$str = str_replace('"','\\"',$str);
|
|
return $str;
|
}
|
|
public function setReadDrs($i_s) { // default return structure
|
if($i_s == 1 or $i_s == 2 or $i_s == 3 or $i_s == 4)
|
{ // 1 vecteur 2 associatif 3 les deux 4 like file
|
$this->read_default_return_structure = $i_s;
|
return true;
|
}
|
else
|
return false;
|
}
|
|
public function setFlock($status) {
|
if($status)
|
$this->$flock_on = true;
|
else
|
$this->$flock_on = false;
|
|
return true;
|
}
|
|
public function setBackup($status,$dir = false,$time = 86400) {
|
if($status == true) {
|
if(ctype_digit($time) == true) {
|
$this->backup_on = true;
|
|
if($dir[strlen($dir)-1] != "/")
|
$dir .= "/";
|
|
$this->backup_dir = $dir;
|
}
|
else
|
return false;
|
}
|
else
|
$this->backup_on = false;
|
|
return true;
|
}
|
|
public function setHash($status,$fields = false,$type = false) {
|
// fields séparés par des "," type = "md5" ou "sha1"
|
if($status && $fields && $type) {
|
$this->hash_on = true;
|
$this->hash_fields = explode(",",$fields);
|
$this->hash_type = $type;
|
}
|
else
|
$this->hash_on = false;
|
|
return true;
|
}
|
|
public function setCrypt($status,$fields = false,$password = false) {
|
// fields séparés par des ","
|
if($status && $fields && $password) {
|
$this->crypt_on = true;
|
$this->crypt_fields = explode(",",$fields);
|
$this->crypt_password = $password;
|
}
|
else
|
$this->crypt_on = false;
|
|
return true;
|
}
|
|
public function setCryptFunctions($CryptFctName,$DecryptFctName) {
|
if(function_exists($CryptFctName) && function_exists($DecryptFctName)) {
|
$this->crypt_function[0] = $CryptFctName;
|
$this->crypt_function[1] = $DecryptFctName;
|
|
return true;
|
}
|
else
|
return false;
|
}
|
|
public function getLastId() {
|
return $this->lastId;
|
}
|
|
public function unik() {
|
$ttime = str_replace(".","",time() + microtime(true)); // total time
|
echo $ttime."<br />";
|
$a_ttime = str_split($ttime);
|
$ar_ttime = array_reverse($a_ttime);
|
|
$result = "";
|
$chars = array("a","b","c","d","e","f","g","h","i","j","k","l","m",
|
"n","o","p","q","r","s","t","u","v","w","x","y","z",
|
"A","B","C","D","E","F","G","H","I","J","K","L","M","N","O","P","Q",
|
"R","S","T","U","V","W","X","Y","Z");
|
for($i=0;$i<count($ar_ttime);$i++) {
|
$result .= $chars[mt_rand(0,count($chars)-1)].$ar_ttime[$i];
|
}
|
return $result;
|
}
|
|
public function valueExist($value,$field,$haystack,$caseSensitive = true) {
|
|
if($caseSensitive)
|
$value = strtolower($value);
|
|
if(!is_array($haystack)) {
|
require($haystack);
|
$haystack = $FILE;
|
}
|
|
foreach($haystack as $line) {
|
if($caseSensitive)
|
$line[$field] = strtolower($line[$field]);
|
|
if($line[$field] == $value)
|
return true;
|
}
|
return false;
|
}
|
|
public function read($u_fichier,$where = false,$orderBy = false,
|
$limit = false,$i_return_structure = false)
|
{ # Ancienne structure where = "pseudo='oprichn,ik',
|
'dracau'&email='mallory.dessaintes@gmail.com'"
|
|
if(!file_exists($u_fichier))
|
return false;
|
if(!isset($FILE_LAST_ID))
|
$FILE_LAST_ID = 0;
|
|
require($u_fichier);
|
|
if(!isset($FILE))
|
return array(); // Il n'y a rien à retourner
|
elseif(!$this->is_assoc_multi_array($FILE))
|
return false;
|
elseif($this->crypt_on)
|
$FILE = $this->decryptTest($FILE);
|
|
if($where) {
|
if(!is_array($where)) {
|
|
$result = array();
|
|
foreach($FILE as $k => $valeur) {
|
// On parcourt le fichier pour trouver les lignes à retourner
|
$LINE = $valeur;
|
$eval = "if($where) { $result[] = $valeur; }";
|
ob_start(); // Securité pour ne rien afficher à l'écran
|
eval($eval);
|
ob_clean();
|
}
|
|
}
|
else {
|
|
$a_where = $where;
|
|
$result = array();
|
|
foreach($FILE as $cle => $valeur) {
|
// On parcourt le fichier pour trouver les lignes à retourner
|
$i2 = 0;
|
foreach($a_where as $cle2 => $valeur2) {
|
// On parcourt le tableau where à chaque ligne du fichier
|
//pour voir si il correspond avec where
|
if(is_array($valeur2)) {
|
if(in_array($valeur[$cle2],$valeur2))
|
$result[] = $valeur;
|
}
|
else {
|
if($valeur[$cle2] == $valeur2)
|
$result[] = $valeur;
|
}
|
}
|
}
|
}
|
}
|
else
|
$result = $FILE;
|
|
// On modifie le tableau en fonction du paramètre orderBy
|
|
if($orderBy) {
|
if(strtolower($orderBy) == "desc")
|
$result = array_reverse($result);
|
else {
|
list($orderBy_champ,$orderBy_asc_dsc) = explode(" ",$orderBy);
|
|
$result = $this->sort_by_key($result,$orderBy_champ);
|
|
if(strtolower($orderBy_asc_dsc) == "desc")
|
$result = array_reverse($result);
|
|
}
|
}
|
|
// On modifie le tableau en fonction du paramètre limit
|
|
if($limit) { // Structure : $limit = "0-5" =>
|
//On prend les 5 premiers ou $limit = "5"
|
$tmp_result = array();
|
if(strpos($limit,"-") !== false) {
|
$a_limit = explode("-",$limit);
|
for($i=$a_limit[0];$i<min($a_limit[0]+$a_limit[1],count($result));$i++)
|
{
|
$tmp_result[$i] = $result[$i];
|
}
|
}
|
else {
|
for($i=0;$i<min($limit,count($result));$i++) {
|
$tmp_result[$i] = $result[$i];
|
}
|
}
|
$result = $tmp_result;
|
}
|
|
// On retourne un tableau selon le paramètre de retour (type de tableau)
|
|
if(!$i_return_structure)
|
$i_return_structure = $this->read_default_return_structure;
|
|
if($i_return_structure == 1) {
|
$result2 = array(); $i = 0;
|
foreach($result as $valeur) {
|
foreach($valeur as $valeur2) {
|
$result2[$i][] = $valeur2;
|
}
|
$i++;
|
}
|
return $result2;
|
}
|
elseif($i_return_structure == 3) {
|
$result2 = array(); $i = 0;
|
foreach($result as $valeur) {
|
foreach($valeur as $cle => $valeur2) {
|
$result2[$i][] = $valeur2;
|
$result2[$i][$cle] = $valeur2;
|
}
|
$i++;
|
}
|
return $result2;
|
}
|
elseif($i_return_structure == 4) {
|
$result2 = array(); $i = 0;
|
foreach($result as $valeur) {
|
foreach($valeur as $cle => $valeur2) {
|
$result2[$i] = $valeur2;
|
$i++;
|
}
|
}
|
return $result2;
|
}
|
else
|
return $result;
|
|
// ---------------------------------------------------------------
|
}
|
|
public function readArrayLikeFile($FILE,$where = false,$orderBy = false,
|
$limit = false,$i_return_structure = false) {
|
# Ancienne structure where = "pseudo='oprichn,ik',
|
'dracau'&email='mallory.dessaintes@gmail.com'"
|
|
if(!isset($FILE))
|
return array(); // Il n'y a rien à retourner
|
elseif(!$this->is_assoc_multi_array($FILE))
|
return false;
|
|
if($where) {
|
if(!is_array($where)) {
|
|
$result = array();
|
|
foreach($FILE as $k => $valeur) {
|
// On parcourt le fichier pour trouver les lignes à retourner
|
$LINE = $valeur;
|
$eval = "if($where) { \$result[] = \$valeur; }";
|
ob_start(); // Securité pour ne rien afficher à l'écran
|
eval($eval);
|
ob_clean();
|
}
|
|
}
|
else {
|
|
$a_where = $where;
|
|
$result = array();
|
|
foreach($FILE as $cle => $valeur) {
|
// On parcourt le fichier pour trouver les lignes à retourner
|
$i2 = 0;
|
foreach($a_where as $cle2 => $valeur2) {
|
// On parcourt le tableau where à chaque ligne du fichier
|
//pour voir si il correspond avec where
|
if(is_array($valeur2)) {
|
if(in_array($valeur[$cle2],$valeur2))
|
$result[] = $valeur;
|
}
|
else {
|
if($valeur[$cle2] == $valeur2)
|
$result[] = $valeur;
|
}
|
}
|
}
|
}
|
}
|
else
|
$result = $FILE;
|
|
// On modifie le tableau en fonction du paramètre orderBy
|
|
if($orderBy) {
|
if(strtolower($orderBy) == "desc")
|
$result = array_reverse($result);
|
else {
|
list($orderBy_champ,$orderBy_asc_dsc) = explode(" ",$orderBy);
|
|
$result = $this->sort_by_key($result,$orderBy_champ);
|
|
if(strtolower($orderBy_asc_dsc) == "desc")
|
$result = array_reverse($result);
|
|
}
|
}
|
|
// On modifie le tableau en fonction du paramètre limit
|
|
if($limit) { // Structure : $limit = "0-5" =>
|
// On prend les 5 premiers ou $limit = "5"
|
$tmp_result = array();
|
if(strpos($limit,"-") !== false) {
|
$a_limit = explode("-",$limit);
|
for($i=$a_limit[0];$i<min($a_limit[0]+$a_limit[1],count($result));$i++)
|
{
|
$tmp_result[$i] = $result[$i];
|
}
|
}
|
else {
|
for($i=0;$i<min($limit,count($result));$i++) {
|
$tmp_result[$i] = $result[$i];
|
}
|
}
|
$result = $tmp_result;
|
}
|
|
// On retourne un tableau selon le paramètre de retour (type de tableau)
|
|
if(!$i_return_structure)
|
$i_return_structure = $this->read_default_return_structure;
|
|
if($i_return_structure == 1) {
|
$result2 = array(); $i = 0;
|
foreach($result as $valeur) {
|
foreach($valeur as $valeur2) {
|
$result2[$i][] = $valeur2;
|
}
|
$i++;
|
}
|
return $result2;
|
}
|
elseif($i_return_structure == 3) {
|
$result2 = array(); $i = 0;
|
foreach($result as $valeur) {
|
foreach($valeur as $cle => $valeur2) {
|
$result2[$i][] = $valeur2;
|
$result2[$i][$cle] = $valeur2;
|
}
|
$i++;
|
}
|
return $result2;
|
}
|
elseif($i_return_structure == 4) {
|
$result2 = array(); $i = 0;
|
foreach($result as $valeur) {
|
foreach($valeur as $cle => $valeur2) {
|
$result2[$i] = $valeur2;
|
$i++;
|
}
|
}
|
return $result2;
|
}
|
else
|
return $result;
|
|
// ---------------------------------------------------------------
|
}
|
|
public function add($u_fichier,$a_add) {
|
// Si une seule ligne à insérer
|
if(!isset($a_add[0]))
|
// Car les indices du tableau sont indexés associativement
|
$__result[0] = $a_add;
|
else
|
$__result = $a_add;
|
|
if(file_exists($u_fichier)) {
|
require($u_fichier);
|
|
if(!isset($FILE_LAST_ID))
|
$FILE_LAST_ID = 0;
|
elseif(isset($FILE) && !$this->is_assoc_multi_array($FILE))
|
return false;
|
}
|
else
|
$FILE_LAST_ID = 0;
|
|
$i = 0;
|
|
$_result = $__result;
|
|
foreach($__result as $cle => $valeur) {
|
foreach($valeur as $cle2 => $valeur2) {
|
if($cle2 == "ID")
|
// Si un champ a pour nom ID, sa valeur est
|
// automatisée et correspond au numéro d'entrée
|
$_result[$i][$cle2] = ++$FILE_LAST_ID;
|
}
|
|
// CRYPTAGE ET HACHAGE -------------------------------------------
|
|
if($this->crypt_on or $this->hash_on)
|
$_result[$i] = $this->cryptAndHashTest($valeur);
|
$i++;
|
|
// ---------------------------------------------------------------
|
}
|
|
$this->lastId = $FILE_LAST_ID;
|
|
if(isset($FILE)) // Si le fichier existait déjà et qu'il n'est pas vide
|
$result = array_merge($FILE,$_result);
|
else
|
$result = $_result;
|
|
// FLOCK ---------------------------------------------------------
|
|
$pathInf = pathinfo($u_fichier);
|
$flockFilename = $pathInf["dirname"]."/".$pathInf["filename"].".flock";
|
|
if($this->flock_on) {
|
touch($flockFilename);
|
$ffo = fopen($flockFilename,"r"); // File flock open
|
flock($ffo,LOCK_EX);
|
}
|
else
|
if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
|
unlink($flockFilename);
|
|
// ---------------------------------------------------------------
|
|
// BACKUP --------------------------------------------------------
|
|
$this->backupTest($u_fichier);
|
|
// ---------------------------------------------------------------
|
|
$fo = fopen($u_fichier,"w");
|
|
|
|
fputs($fo,"<?php \n\$FILE_LAST_ID = $FILE_LAST_ID;\n\n");
|
|
$i = 0;
|
foreach($result as $cle => $valeur) {
|
foreach($valeur as $cle2 => $valeur2) {
|
fputs($fo,"\$FILE[$i][\"".$cle2."\"] =
|
stripslashes(\"".addslashes($valeur2)."\");\n");
|
}
|
$i++;
|
}
|
|
fputs($fo,"?>");
|
|
fclose($fo);
|
|
// FLOCK ---------------------------------------------------------
|
|
if($this->flock_on) {
|
flock($ffo,LOCK_UN);
|
fclose($ffo);
|
}
|
|
// ---------------------------------------------------------------
|
|
return true;
|
}
|
|
public function mod($u_fichier,$where,$a_mod) {
|
// $a_mod est un tableau d'une dimension associatif
|
if(!file_exists($u_fichier))
|
return false;
|
|
require($u_fichier);
|
|
if(!isset($FILE_LAST_ID))
|
$FILE_LAST_ID = 0;
|
|
if(!isset($FILE))
|
return false; // Il n'y a rien à retourner
|
elseif(!$this->is_assoc_multi_array($FILE))
|
return false;
|
elseif($this->crypt_on)
|
$FILE = $this->decryptTest($FILE);
|
|
// CRYPTAGE ET HACHAGE -------------------------------------------
|
|
if($this->crypt_on or $this->hash_on)
|
$a_mod = $this->cryptAndHashTest($a_mod);
|
|
// ---------------------------------------------------------------
|
|
if($where) {
|
if(!is_array($where)) {
|
|
$result = $FILE;
|
|
foreach($FILE as $k => $valeur) {
|
// On parcourt le fichier pour trouver les lignes à retourner
|
$LINE = $valeur;
|
$eval =
|
"if($where) { \$result[\$k] = array_merge(\$result[\$k],\$a_mod); }";
|
ob_start(); // Securité pour ne rien afficher à l'écran
|
eval($eval);
|
ob_clean();
|
}
|
}
|
else {
|
|
$a_where = $where;
|
|
$result = $FILE;
|
|
foreach($FILE as $cle => $valeur) {
|
// On parcourt le fichier pour trouver les lignes à retourner
|
foreach($a_where as $cle2 => $valeur2) { // On parcourt le
|
//tableau where à chaque ligne du fichier pour voir si
|
//il correspond avec where
|
if(is_array($valeur2)) {
|
if(in_array($valeur[$cle2],$valeur2))
|
$result[$cle] = array_merge($result[$cle],$a_mod);
|
}
|
else {
|
if($valeur[$cle2] == $valeur2)
|
$result[$cle] = array_merge($result[$cle],$a_mod);
|
}
|
}
|
}
|
}
|
}
|
else { // on modifie toutes les lignes
|
$result = $FILE;
|
|
foreach($FILE as $cle => $valeur) {
|
$result[$cle] = array_merge($result[$cle],$a_mod);
|
}
|
}
|
|
|
// FLOCK ---------------------------------------------------------
|
|
$pathInf = pathinfo($u_fichier);
|
$flockFilename = $pathInf["dirname"]."/".$pathInf["filename"].".flock";
|
|
if($this->flock_on) {
|
touch($flockFilename);
|
$ffo = fopen($flockFilename,"r"); // File flock open
|
flock($ffo,LOCK_EX);
|
}
|
else
|
if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
|
unlink($flockFilename);
|
|
// ---------------------------------------------------------------
|
|
// BACKUP --------------------------------------------------------
|
|
$this->backupTest($u_fichier);
|
|
// ---------------------------------------------------------------
|
|
$fo = fopen($u_fichier,"w");
|
|
fputs($fo,"<?php\n\$FILE_LAST_ID = $FILE_LAST_ID;\n\n");
|
|
$i = 0;
|
foreach($result as $cle => $valeur) {
|
foreach($valeur as $cle2 => $valeur2) {
|
fputs($fo,"\$FILE[$i][\"".$cle2."\"] =
|
stripslashes(\"".addslashes($valeur2)."\");\n");
|
}
|
$i++;
|
}
|
|
fputs($fo,"?>");
|
|
fclose($fo);
|
|
// FLOCK ---------------------------------------------------------
|
|
if($this->flock_on) {
|
flock($ffo,LOCK_UN);
|
fclose($ffo);
|
}
|
|
// ---------------------------------------------------------------
|
|
return true;
|
}
|
|
public function del($u_fichier,$where) {
|
if(!file_exists($u_fichier))
|
return false;
|
if(!isset($FILE_LAST_ID))
|
$FILE_LAST_ID = 0;
|
|
require($u_fichier);
|
|
if(!isset($FILE))
|
return false; // Il n'y a rien à retourner
|
elseif(!$this->is_assoc_multi_array($FILE))
|
return false;
|
elseif($this->crypt_on)
|
$FILE = $this->decryptTest($FILE);
|
|
if($where) {
|
if(!is_array($where)) {
|
|
$result = $FILE;
|
|
foreach($FILE as $k => $valeur) {
|
// On parcourt le fichier pour trouver les lignes à retourner
|
$LINE = $valeur;
|
$eval = "if($where) { unset(\$result[\$k]); }";
|
echo $eval."<br>";
|
ob_start(); // Securité pour ne rien afficher à l'écran
|
eval($eval);
|
ob_clean();
|
}
|
}
|
else {
|
|
$a_where = $where;
|
|
$result = $FILE;
|
|
foreach($FILE as $cle => $valeur) {
|
// On parcourt le fichier pour trouver les lignes à retourner
|
foreach($a_where as $cle2 => $valeur2) {
|
// On parcourt le tableau where à chaque ligne du fichier
|
//pour voir si il correspond avec where
|
if(is_array($valeur2)) {
|
if(in_array($valeur[$cle2],$valeur2))
|
unset($result[$cle]);
|
}
|
else {
|
if($valeur[$cle2] == $valeur2)
|
unset($result[$cle]);
|
}
|
}
|
}
|
}
|
}
|
else
|
$result = array();
|
|
// ---------------------------------------------------------------
|
|
$_result = array();
|
|
foreach($result as $valeur) {
|
// Pour que les indices se suivent (on a supprimé certains avant)
|
$_result[] = $valeur;
|
}
|
|
$result = $_result;
|
|
// FLOCK ---------------------------------------------------------
|
|
$pathInf = pathinfo($u_fichier);
|
$flockFilename = $pathInf["dirname"]."/".$pathInf["filename"].".flock";
|
|
if($this->flock_on) {
|
touch($flockFilename);
|
$ffo = fopen($flockFilename,"r"); // File flock open
|
flock($ffo,LOCK_EX);
|
}
|
else
|
if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
|
unlink($flockFilename);
|
|
// ---------------------------------------------------------------
|
|
// BACKUP --------------------------------------------------------
|
|
$this->backupTest($u_fichier);
|
|
// ---------------------------------------------------------------
|
|
$fo = fopen($u_fichier,"w");
|
|
fputs($fo,"<?php\n\$FILE_LAST_ID = $FILE_LAST_ID;\n\n");
|
|
$i = 0;
|
foreach($result as $cle => $valeur) {
|
foreach($valeur as $cle2 => $valeur2) {
|
fputs($fo,"\$FILE[$i][\"".$cle2."\"] =
|
stripslashes(\"".addslashes($valeur2)."\");\n");
|
}
|
$i++;
|
}
|
|
fputs($fo,"?>");
|
|
fclose($fo);
|
|
// FLOCK ---------------------------------------------------------
|
|
if($this->flock_on) {
|
flock($ffo,LOCK_UN);
|
fclose($ffo);
|
}
|
|
// ---------------------------------------------------------------
|
|
return true;
|
}
|
|
public function uRead($u_fichier) {
|
if(!file_exists($u_fichier))
|
return false;
|
|
require($u_fichier);
|
|
if(!isset($FILE))
|
return array(); // Il n'y a rien à retourner
|
|
return $FILE;
|
}
|
|
public function uMod($u_fichier,$a_mod) {
|
if(file_exists($u_fichier))
|
require($u_fichier);
|
|
if(!isset($FILE))
|
$FILE = array();
|
|
$result = array_merge($FILE,$a_mod);
|
|
// FLOCK ---------------------------------------------------------
|
|
$pathInf = pathinfo($u_fichier);
|
$flockFilename = $pathInf["dirname"]."/".$pathInf["filename"].".flock";
|
|
if($this->flock_on) {
|
touch($flockFilename);
|
$ffo = fopen($flockFilename,"r"); // File flock open
|
flock($ffo,LOCK_EX);
|
}
|
else
|
if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
|
unlink($flockFilename);
|
|
// ---------------------------------------------------------------
|
|
// BACKUP --------------------------------------------------------
|
|
$this->backupTest($u_fichier);
|
|
// ---------------------------------------------------------------
|
|
$fo = fopen($u_fichier,"w");
|
|
fputs($fo,"<?php\n");
|
|
$str_put = "\$FILE = ".var_export($result,true)."\n";
|
|
fputs($fo,$str_put);
|
|
fputs($fo,"?>");
|
|
fclose($fo);
|
|
// FLOCK ---------------------------------------------------------
|
|
if($this->flock_on) {
|
flock($ffo,LOCK_UN);
|
fclose($ffo);
|
}
|
|
// ---------------------------------------------------------------
|
|
return true;
|
}
|
|
// ---------------------------------------------------------------
|
|
public function select_start($u_fichier,&$var_to_affect_read = false) {
|
if(file_exists($u_fichier)) {
|
require($u_fichier);
|
|
if(!isset($FILE))
|
$FILE = array();
|
elseif($this->crypt_on)
|
$FILE = $this->decryptTest($FILE);
|
|
$this->select_u_fichier = $u_fichier;
|
$this->select_a_read = $FILE;
|
$var_to_affect_read = $FILE;
|
|
return true;
|
}
|
else
|
return false;
|
}
|
|
public function select() {
|
$i = 0;
|
|
if($this->select_a_read) {
|
while(!isset($this->select_a_read[$i])) {
|
$i++;
|
}
|
|
$result = $this->select_a_read[$i];
|
unset($this->select_a_read[$i]);
|
|
return $result;
|
}
|
else
|
return false;
|
}
|
|
public function select_close($a_to_write) {
|
|
if(!$this->select_u_fichier)
|
return false;
|
|
// FLOCK ---------------------------------------------------------
|
|
$pathInf = pathinfo($this->select_u_fichier);
|
$flockFilename = $pathInf["dirname"]."/".$pathInf["filename"].".flock";
|
|
if($this->flock_on) {
|
touch($flockFilename);
|
$ffo = fopen($flockFilename,"r"); // File flock open
|
flock($ffo,LOCK_EX);
|
}
|
else
|
if(file_exists($flockFilename)) // Pour éviter les fichiers inutiles
|
unlink($flockFilename);
|
|
// ---------------------------------------------------------------
|
|
// BACKUP --------------------------------------------------------
|
|
$this->backupTest($this->select_u_fichier);
|
|
// ---------------------------------------------------------------
|
|
$result = array();
|
$i = 0;
|
|
if($this->crypt_on or $this->hash_on) {
|
foreach($a_to_write as $valeur) {
|
$result[$i] = $this->cryptAndHashTest($valeur);
|
$i++;
|
}
|
}
|
else
|
$result = $a_to_write;
|
|
$fo = fopen($this->select_u_fichier,"w");
|
|
fputs($fo,"<?php\n");
|
|
$i = 0;
|
foreach($result as $cle => $valeur) {
|
foreach($valeur as $cle2 => $valeur2) {
|
fputs($fo,"\$FILE[$i][\"".$cle2."\"] =
|
stripslashes(\"".addslashes($valeur2)."\");\n");
|
}
|
$i++;
|
}
|
|
fputs($fo,"?>");
|
|
fclose($fo);
|
|
// FLOCK ---------------------------------------------------------
|
|
if($this->flock_on) {
|
flock($ffo,LOCK_UN);
|
fclose($ffo);
|
}
|
|
// ---------------------------------------------------------------
|
|
return true;
|
}
|
|
// ---------------------------------------------------------------
|
}
|
|
?>
|
|
|
Invité
22 Juil 2010 à 10:23Dommage, pas d'exemple d'utilisation ...
Invité
25 Aout 2009 à 12:41+1 : sans exemple ce n'est pas facile à comprendre (à moins d'explorer chaque méthode...), serait-il possible d'en avoir ?
Invité
26 Avril 2009 à 20:18Un exemple aurai été le bienvenu .....