<?php

/**-----------------------------------------------
*
* Rooty, 2018 <rooty@rooty.me>
*
*
* This software is protected by copyright, please
* read the file COPYRIGHT.
* This program is distributed in the hope that it
* will be useful, but without any warranty; without
* even the implied warranty of merchantability or
* fitness for a particular purpose. Please
* read the file LICENCE.
*
* Fichier package.upload.php
* Ce fichier contient les classe de gestion d'upload
* Il est a inclure dans votre script avec l'instruction includePackage(upload.php)
*
* @author Rooty <www.rooty.me|rooty@rooty.me>
* @since 2005/03/09
* @link www.rooty.me
* @version 0.3
* @package package
* @subpackage upload
* @copyright Copyright &copy; 2009-2018, Rooty
*/
if ( !defined('SYSTEM_IN') )
{
 die("Hacking attempt");
}

/**
* Temps autorisé pour l'upload
*/
define('CONF_UPLOAD_TIME', 10000);

/**
* Permet la gestion des limites d'upload
* Cette classe n'est pas à utiliser directement<br/>
* Voir ses extention:
* - UploadToDir
* - UploadToDb
* Le fichier est a inclure dans votre script avec l'instruction includePackage(upload.php)
* @package package
* @subpackage upload
*/
class UploadLimit
{
/**#@+
* @access private
*/

/**
* @var chaine
* @desc identifiant du noeud de limitation
*/
var $nid=0;

/**
* @var chaine
* @desc objet treeNode...
*/
var $treeNode=null;

/**
* @var chaine
* @desc identifiant de l'utilisateur courant
*/
var $uid=0;

/**#@-*/

/**
*Constructeur de la classe Upload PHP4
*
* @access public
* @param chaine nom du champ
*/
	function UploadLimit($nid="", $uid="")
	{
		$this->__construct($nid, $uid);
	}

/**
*Constructeur de la classe Upload PHP5
*
* @access public
* @param chaine nom du champ
*/
	function __construct($nid="", $uid="")
	{
		$this->setNid( (($nid!="") && (is_numeric($nid)))?$nid:nid() );
		$this->setUid( (($uid!="") && (is_numeric($uid)))?$uid:nid() );
	}

/**
* setteur du nid, indique a quel endroit on prend une limitation
* @access public
* @param entier id du noeud
*/
	function setNid($id)
	{
		$this->nid=$id;
		$this->treeNode=$GLOBALS["SYSTEM_MANAGER"]["TREE_NODE"]->createInstance($id);
	}

/**
* getteur du nid, indique a quel endroit on prend une limitation
* @access public
* @param entier id du noeud
*/
	function getNid()
	{
		return $this->nid;
	}

/**
* setteur de l'uid, indique a quel endroit on prend une limitation
* @access public
* @param entier id du noeud
*/
	function setUid($id)
	{
		$this->uid=$id;
	}

/**
* getteur de l'uid, indique a quel endroit on prend une limitation
* @access public
* @param entier id du noeud
*/
	function getUid()
	{
		return $this->uid;
	}

/**
* recupere l'espace utilisé pour le noeud
* @access protected
* @todo modifier pour que la gestion se fasse sur l'oid
* @param entier id du noeud
* @param entier id de l'utilisateur
* @param entier id du noeud
*/
	function getUseSpace($nid="", $uid="")
	{
		$nid=(isset($nid) && is_numeric($nid))?$nid:$this->getNid();					// par défaut le nid de l'obj
		$uid=(isset($uid) && is_numeric($uid))?$uid:0;									// par défaut 0

		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$treeNode=$GLOBALS["SYSTEM_MANAGER"]["TREE_NODE"]->createInstance( $nid );

		$tabNode=$treeNode->getSonArray();
		$tabNode[]=$treeNode->getId();

		/* Consultation dans la table des entête de fichier du poid des docs pour ces noeuds */
		$sql="SELECT sum(file_size) as sum FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."file WHERE ";

		/* Calcul des opt pour les noeuds */
		$sql.="( file_nid=".$this->getNid();
		if (count($tabNode)>1)
		{
			for($i=0; $i<count($tabNode); $i++)
			{
				$sql.=" OR file_nid=".$tabNode[$i];
			}
		}
		$sql.=" ) ";

		/* si c uniquement pour 1 utilisateur */
		if ( $uid!=0 )
		{
			$sql.=" AND (file_uid=".$uid.") AND file_limit_owner=1";
		}

		/* gestion du resultat */
		$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($sql);
		if ($GLOBALS["SYSTEM_DATABASE_CONN"]->sql_numrows()>0)
		{
			$row = $GLOBALS['SYSTEM_DATABASE_CONN']->sql_fetchrow();
			return $row["sum"];
		}else{
			return 0;
		}
	}

/**
* recupere la taille affectée à un utilisateur
*fonctionne récursivement si la limite utilisateur n'est pas fixée sur le noeud mm<br/>
*consulte la table user_space
* @access public
* @param entier id du noeud
* @return entier taille pour l'utilisateur, ou faux si aucune affectée
*/
	function getMaxSpaceForUser($nid="", $uid=0)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$nid=($nid!="")?$nid:$this->getNid();

		$sql ="SELECT user_space FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."user_space WHERE ";
		$sql.=" user_space_nid=".$nid." AND ( user_space_uid=".$this->getUid()." OR user_space_uid=0 ) ORDER BY user_space_uid DESC";			# l'ordre permet de gérer si l'uid de l'utilisateur existe

		/* gestion du resultat */
		$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($sql);
		if ($GLOBALS["SYSTEM_DATABASE_CONN"]->sql_numrows()>0)
		{
			for ($i=0; $i<$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_numrows(); $i++)
			{
				$row = $GLOBALS['SYSTEM_DATABASE_CONN']->sql_fetchrow();
			}
			return $row["user_space"];
		}else{
			if ($nid!=0)
			{
				$Node=$this->treeNode->getNodeId($nid);
				return $this->getMaxSpaceForUser( $Node->getIdPere() );
			}else{
				return false;
			}
		}
	}

/**
* recupere la taille affectée à un utilisateur
*fonctionne récursivement si la limite utilisateur n'est pas fixée sur le noeud mm<br/>
*consulte la table user_space
* @access public
* @param entier id du noeud
* @return entier taille pour l'utilisateur, ou faux si aucune affectée
*/
	function getSingleMaxSpaceForUser($nid="", $uid=0)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$nid=($nid!="")?$nid:$this->getNid();

		$sql ="SELECT user_space FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."user_space WHERE ";
		$sql.=" user_space_nid=".$nid." AND ( user_space_uid=".$uid." ) ORDER BY user_space_uid DESC";			# l'ordre permet de gérer si l'uid de l'utilisateur existe

		/* gestion du resultat */
		$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($sql);
		if ($GLOBALS["SYSTEM_DATABASE_CONN"]->sql_numrows()>0)
		{
			for ($i=0; $i<$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_numrows(); $i++)
			{
				$row = $GLOBALS['SYSTEM_DATABASE_CONN']->sql_fetchrow();

		}
			return $row["user_space"];
		}else{
			return false;
		}
	}

/**
* recupere la taille affectée à un noeud
*fonctionne récursivement si la limite n'est pas fixée sur le noeud mm<br/>
*consulte la table user_space
* @access public
* @param entier id du noeud
* @return entier taille pour l'utilisateur, ou faux si aucune affectée
*/
	function getMaxSpaceForNode($nid="")
	{

		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$nid=($nid!="")?$nid:$this->getNid();

		$sql ="SELECT node_space FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."node_space WHERE ";
		$sql.=" node_space_nid=".$nid." ";			# l'ordre permet de gérer si l'uid de l'utilisateur existe

		/* gestion du resultat */
		$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($sql);
		if ($GLOBALS["SYSTEM_DATABASE_CONN"]->sql_numrows()>0)
		{
			for ($i=0; $i<$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_numrows(); $i++)
			{
				$row = $GLOBALS['SYSTEM_DATABASE_CONN']->sql_fetchrow();
			}
			return $row["node_space"];
		}else{
			if ($nid!=0)
			{
				$Node=$this->treeNode->getNodeId($nid);
				return $this->getMaxSpaceForNode( $Node->getIdPere() );
			}else{
				return false;
			}
		}
	}

/**
* recupere la taille affectée à un noeud
*fonctionne récursivement si la limite n'est pas fixée sur le noeud mm<br/>
*consulte la table user_space
* @access public
* @param entier id du noeud
* @return entier taille pour l'utilisateur, ou faux si aucune affectée
*/
	function getSingleMaxSpaceForNode($nid="")
	{

		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$nid=($nid!="")?$nid:$this->getNid();

		$sql ="SELECT node_space FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."node_space WHERE ";
		$sql.=" node_space_nid=".$nid." ";			# l'ordre permet de gérer si l'uid de l'utilisateur existe

		/* gestion du resultat */
		$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($sql);
		if ($GLOBALS["SYSTEM_DATABASE_CONN"]->sql_numrows()>0)
		{
			for ($i=0; $i<$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_numrows(); $i++)
			{
				$row = $GLOBALS['SYSTEM_DATABASE_CONN']->sql_fetchrow();
			}
			return $row["node_space"];
		}else{
			return false;
		}
	}

/**
* recupere la taille affectée à un noeud
*fonctionne récursivement si la limite n'est pas fixée sur le noeud mm<br/>
*consulte la table node_space
* @access public
* @param entier id du noeud
* @return entier taille pour l'utilisateur, ou faux si aucune affectée
*/
	function isSetNodeLimit($nid="")
	{

		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$nid=($nid!="")?$nid:$this->getNid();

		$sql ="SELECT node_space FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."node_space WHERE ";
		$sql.=" node_space_nid=".$nid." ";			# l'ordre permet de gérer si l'uid de l'utilisateur existe

		/* gestion du resultat */
		$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($sql);
		if ($GLOBALS["SYSTEM_DATABASE_CONN"]->sql_numrows()>0)
		{
			return true;
		}else{
			return false;
		}
	}

/**
* recupere la taille affectée à un noeud
*fonctionne récursivement si la limite n'est pas fixée sur le noeud mm<br/>
*consulte la table user_space
* @access public
* @param entier id du noeud
* @return entier taille pour l'utilisateur, ou faux si aucune affectée
*/
	function getDownMaxSpaceForNode(&$tree, $nid="")
	{

		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$nid=($nid!="")?$nid:$this->getNid();

		/* Génération de l'option */
		$opt="";

		$tab=$tree->getSonOfIdPereArray($nid);
		$tabtmp=$tree->getSonOfIdPereArray($nid);

		/* on exploite tous les sous noeud */
		while (count($tabtmp)>0)
		{
			$tabtoTest=array();
			$tab=array_merge($tab, $tabtmp);
			for ($i=0; $i<count($tabtmp); $i++)
			{
				$tabtoTest=array_merge($tree->getSonOfIdPereArray($tabtmp[$i]), $tabtoTest);
			}
			$tabtmp=$tabtoTest;
		}

		$tab=array_merge($tab, array($nid));
		$opt="";
		for ($i=0; $i<count($tab); $i++)
		{
			if ($i>0)
				$opt.=" OR ";
			$opt.=" node_space_nid=".$tab[$i];
		}

		$sql ="SELECT * FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."node_space WHERE ";
		$sql.=" ".$opt;			# l'ordre permet de gérer si l'uid de l'utilisateur existe

		/* gestion du resultat */
		$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($sql);
		if ($GLOBALS["SYSTEM_DATABASE_CONN"]->sql_numrows()==0 || (count($tab)==0) )
			return 0;

		// Alimentation du tableau de résultat
		for ($i=0; $i<$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_numrows(); $i++)
		{
			$row[$i] = $GLOBALS['SYSTEM_DATABASE_CONN']->sql_fetchrow();
		}
		return $this->treeTabSizeForNid($row, $tree, $nid);
	}

	// Traitement en fonction de l'arbo
	function treeTabSizeForNid(&$tabRow, &$tree, $nid)
	{
		$val=0;
		$tabSonOfNid=$tree->getSonOfIdPereArray($nid);

		// on recupere la valeur associée
		for ($j=0; $j<count($tabRow);$j++)
		{
			if($tabRow[$j]["node_space_nid"]==$nid)
			{
				$find=true;
				return $tabRow[$j]["node_space"];
			}
		}

		// Pour chaque fils du noeud courant
		for($i=0;$i<count($tabSonOfNid);$i++)
		{
			$find=false;

			// on recupere la valeur associée
			for ($j=0; $j<count($tabRow);$j++)
			{
				if($tabRow[$j]["node_space_nid"]==$tabSonOfNid[$i])
				{
					$find=true;
					$val+=$tabRow[$j]["node_space"];
					break;
				}
			}
			if(!$find)
				$val+=$this->treeTabSizeForNid($tabRow, $tree, $tabSonOfNid[$i]);
		}
		return $val;
	}

/**
* recupere la taille restante pour 1 noeud &&|| 1 utilisateur
*on indiquera ici si on fonctionne en mode:
* - user (le poids s'applique pour l'utilisateur)<br/>
* - node (le poids est relatif a l'arbo uniquement)
*
* @access public
* @param chaine "NODE" || "USER"
* @return entier taille pour l'utilisateur, ou faux si aucune affectée
*/
	function getFreeSpace($mode="NODE")
	{
		$nid=(isset($nid) && is_numeric($nid))?$nid:$this->getNid();					// par défaut le nid de l'obj

		if ($mode=="NODE"){
			$useSpace		=$this->getUseSpace($nid, "");
			$maxSpaceNode	=$this->getMaxSpaceForNode();
			/* on renvoi la valeur min entre quota sur noeud ou utilisateur */
			return ($maxSpaceNode-$useSpace);

		} elseif {
			($mode=="USER"){
			$maxSpaceNode	=$this->getMaxSpaceForNode();
			$useUserSpace		=$this->getUseSpace($nid, $this->getUid() );	// spaceUsed By user
			$useNodeSpace		=$this->getUseSpace($nid, "" );					// spaceUsed By node
			$maxSpaceUser	=$this->getMaxSpaceForUser();

			/* on renvoi la valeur min entre quota sur noeud ou utilisateur */
			return ( ($maxSpaceNode-$useNodeSpace)<($maxSpaceUser-$useUserSpace) )?($maxSpaceNode-$useNodeSpace):($maxSpaceUser-$useUserSpace);
		}
	}

/**
* la taille du fichier est valide pour la communautée (et l'utilisateur si celui-ci remplis)
*si on remplis l'utilisateur, on passe en mode, utilisateur propriétaire du fichier
* @access public
* @param entier taille du fichier
* @param chaine NODE || USER (gestion de la propriété pour 1 utilisateur ou 1 noeud)
* @return entier taille pour l'utilisateur, ou faux si aucune affectée
*/
	function isValidSize($size, $mode="NODE")
	{
		return ( $this->getFreeSpace($mode)<$size )?true:false;
	}

/**
* ajoute la creation d'une limite sur utilisateur
* @access public
* @param entier id du noeud
* @param entier id de l'utilisateur
* @param limite
* @return entier taille pour l'utilisateur, ou faux si aucune affectée
*/
	function createUserLimit($nid, $uid, $limit)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$sql="INSERT INTO ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."user_space (user_space_uid, user_space_nid, user_space) VALUES (".$uid.", ".$nid.", ".$limit.")";

		/* gestion du resultat */
		$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($sql);
	}

/**
* modification d'une limite sur utilisateur
* @access public
* @param entier id du noeud
* @param entier id de l'utilisateur
* @param limite
* @return entier taille pour l'utilisateur, ou faux si aucune affectée
*/

function updateUserLimit($nid, $uid, $limit)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$sql="UPDATE ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."user_space SET user_space=".$limit." WHERE user_space_uid=".$uid." AND user_space_nid=".$nid;
		
		/* gestion du resultat */
		$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($sql);
	}

/**
* modification d'une limite sur utilisateur
* @access public
* @param entier id du noeud
* @param entier id de l'utilisateur
* @param limite
* @return entier taille pour l'utilisateur, ou faux si aucune affectée
*/
	function deleteUserLimit($nid, $uid)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$sql="DELETE FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."user_space WHERE user_space_uid=".$uid." AND user_space_nid=".$nid;
		/* gestion du resultat */
		$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($sql);
	}

/**
* ajoute la creation d'une limite sur noeud
* @access public
* @param entier id du noeud
* @param entier id de l'utilisateur
* @param limite
* @return entier taille pour l'utilisateur, ou faux si aucune affectée
*/
	function createNodeLimit($nid, $limit)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$sql="INSERT INTO ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."node_space (node_space_nid, node_space) VALUES (".$nid.", ".$limit.")";
		/* gestion du resultat */
		$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($sql);
	}

/**
* modification d'une limite sur noeud
* @access public
* @param entier id du noeud
* @param entier id de l'utilisateur
* @param limite
* @return entier taille pour l'utilisateur, ou faux si aucune affectée
*/
	function updateNodeLimit($nid, $limit)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$sql="UPDATE ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX.."node_space SET node_space=".$limit." WHERE node_space_nid=".$nid;
		/* gestion du resultat */
		$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($sql);
	}

/**
* destruction d'une limite sur noeud
* @access public
* @param entier id du noeud
* @param entier id de l'utilisateur
* @param limite
* @return entier taille pour l'utilisateur, ou faux si aucune affectée
*/
	function deleteNodeLimit($nid)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$sql="DELETE FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."node_space WHERE node_space_nid=".$nid;
		/* gestion du resultat */
		$GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($sql);
	}
}

/**
* Permet la gestion des upload
* Cette classe n'est pas à utiliser directement<br/>
* Voir ses extention:
* - UploadToDir
* - UploadToDb
* Le fichier est a inclure dans votre script avec l'instruction includePackage(upload.php)
* @package package
* @subpackage file
*/
class Upload
{
/**#@+
* @access private
*/

/**
* @var chaine
* @desc entier gére la limitation sur le noeud ou l'utilisateur
*/
var $limitOwner=0;

/**
* @var chaine
* @desc nom de l'élément du formulaire
*/
var $fieldName="upload";

/**
* @var chaine
* @desc nom du fichier (est transformé si celui-ci existe) (fonctionnement fichier)
*/
var $fileName;

/**#@-*/

	//
	// Constructor
	//
/**
*Constructeur de la classe Upload PHP4
*
* @access public
* @param chaine nom du champ
*/
	function Upload($fieldName="upload")
	{
                 $this->__construct($fieldName);
	}

/**
*Constructeur de la classe Upload PHP5
*
* @access public
* @param chaine nom du champ
*/
	function __construct($fieldName="upload")
	{
		$this->fieldName=$fieldName;
		$this->fileName=($this->originalFileName());
		$this->setLimitOwner(false);					# la gestion des quotas se fé d'abord sur la communautée
	}

/**
* getteur du nid, indique a quel endroit on prend une limitation
* @access public
* @param entier id du noeud
*/
	function getLimitOwner()
	{
		return ($this->limitOwner==0)?false:true;
	}

/**
* setteur de l'uid, indique a quel endroit on prend une limitation
* @access public
* @param booleen active la limite de quota sur l'utilisateur...
*/
	function setLimitOwner($bool)
	{
		$this->limitOwner=($bool==true)?1:0;
	}

/**
* uploadFile:retourne la clé du fichier enregistré... id ou nom...
* @access public
* @return retourne la clé du fichier enregistré... id ou nom...
*/
	function uploadFile()
	{
		return "";
	}

/**
* getFileInfo:retourne un tableau des infos fichier (nom, id, size, type=>extention)
* @access public
* @return tableau tableau des infos fichier (nom, id, size, type=>extention)
*/
	function getFileInfo($id)
	{
		return array();
	}

/**
* getFileContent:retourne les données du fichier
* pour l'affichage utiliser printHeaders pour forcer les headers en "application/octet-stream"
* @access public
* @return data
*/
	function getFileContent($id)
	{
		return "";
	}

/**
* removeFile:detruit le fichier correspondant
* @access public
* @return booleen
*/
	function removeFile($id)
	{
		return true;
	}

/**
* removeFileFromOid:detruit les fichiers correspondant a l'objet de coordination
* @access public
* @return booleen
*/
	function removeFileFromOid($oid)
	{
		return true;
	}

/**
* validfileName:retourne le nom "valide" du fichier
* sans caractères spèciaux et avec un seul point dans la chaine.
* @access public
* @return chaine nom du fichier
*/
	function validfileName()
	{
		$s=strtolower($this->fileName);
		$s=preg_replace('/[^a-z0-9_\-\.]/i', '',$s);
		//$s=$this->pointReplace($s);
		return $s;
	}

/**
* pointReplace:retourne le nom "valide" du fichier
*remplace tous les points en trop sur le nom du fichier
* @access public
* @return data
*/
	function pointReplace($chaine)
	{
		$posdeb= strpos($chaine,".");
		$posfin= strlen($chaine);

		// fin chaine sans le point
		$chainefin= substr($chaine, $posdeb+1, $posfin);

		// s'il existe un autre point
		if (strpos($chainefin,".")==false)
		{
			// cas pas d'autre point !!!
			return $chaine;
		}
		else
		{
			// cas un autre point existe
			// -- on remplace le point et on rapelle la fction !!
			$modif=substr($chaine, 0, $posdeb).$this->PointReplace($chainefin);
			return $modif;
		}
	}

/**
* extentionFinder:retourne l'extention du fichier
*retourne l'extention à partir de la chaine (type "php, html etc.")...
* @access public
* @return data
*/
	function extentionFinder($chaine)
	{
		$posdeb= strpos($chaine,".");
		$posfin= strlen($chaine);

		// fin chaine sans le point c-a-d l'extension
		$extension= substr($chaine, $posdeb+1, $posfin);
		return $extension;
	}

/**
* formatfileName:a partir du nom du fichier courant propose un nom de fichier
*charte le nom de fichier de type nom+"_n"+extention ($this->fileName)
*si n existe on a alors il est incrémenté sinon ajouté
* @access public
* @return booleen
*/
	function formatfileName()
	{
		// remarque le fileName de fichier est déjà testé sans carac spéciaux
		$chaine=$this->fileName;
		$len=strlen($chaine);
		$posPoint=strpos($chaine,".",0);	// position du point dans la chaine

		if ($posPoint===false)
		{
			$posPoint=$len;
			$extChaine="";
		}
		else
		{
			$extChaine=substr($chaine,$posPoint,($len-$posPoint));
		}
		$fileNameChaine=substr($chaine,0,$posPoint);

		// récupération de l'indice si existant
		$boolIndice=false;
		if ($posPoint>2)
		{
			// on recherche "_"
			if (substr($fileNameChaine,$posPoint-3,1)=="_")
			{
				// on essaye de récupérer l'indice
				if (Is_numeric(substr($fileNameChaine,$posPoint-2,2)))
				{
					// cas l'indice existe
					$indice=substr($fileNameChaine,$posPoint-2,2);
					$indice++;
					if ($indice<10)
						$indice="0".$indice;
					//fileName de chaine résultant !!!
					$fileNameChaine=substr($fileNameChaine,0,$posPoint-2).$indice;
					$boolIndice=true;
				}
			}
		}
		// cas nouveau fichier sans indice
		if ($boolIndice==false)
		{
			$fileNameChaine.="_01";
		}
		$this->fileName=$fileNameChaine.$extChaine;
		return true;
	}

/**
* originalFileName:durant l'upload donne le nom réel du fichié téléchargé
* @access public
* @return booleen
*/
	function originalFileName()
	{
		if(isset($_FILES[$this->fieldName]))
			return $_FILES[$this->fieldName]["name"];
		else
			return "";
	}

/**
* isValidPostFile:indique pour le champ de l'objet si un upload à été effectué
* @access public
* @return booleen
*/
	function isValidPostFile()
	{
		if( (isset($_FILES[$this->fieldName]["tmp_name"])) && ($_FILES[$this->fieldName]["tmp_name"]!="none") )
			return true;
		else
			return false;
	}

/**
* setPhpPerms:affecte le permission PHP(si possible) pour le bon déroulement de l'upload
* @access public
* @return booleen
*/
	function verifPhpPerms()
	{
		$retour=0;

		if ( (ini_get("file_uploads")== false) )
		{
			addError(1, get_class($this), "Les uploads sont interdits et ne peuvent être modifiés-> voir php.ini", __line__, __file__);
			$retour++;
		}

		return $retour;
	}

/**
* printHeaders:force le navigateur de l'utilisateur à télécharger le document.
* @param chaine nom du fichier
* @param entier taille du fichier
* @param chaine type du fichier (par défaut:application/octet-stream)
* @access public
* @return booleen
*/
	function printHeaders($fileName, $fileSize, $fileType="application/octet-stream")
	{
		if (!headers_sent())
		{
			header("Pragma: public");
			header("Expires: 0");
			header("Cache-Control: private");
			$filename = basename($fileName);
			header("Content-Type: $fileType");
			header("Content-Disposition: attachment; filename=$filename");
			header("Accept-Ranges: bytes");
			header("Content-Length: $fileSize");
			header ("Content-Description: PHP Generated Data");
			return true;
		}else{
			return false;
		}
	}

/**
* affichage du formulaire de saisie
* @todo l'affichage devrait avoir une template propre ou un système de bloc permettant de le customiser
* @param chaine nom du bloc a utiliser pour l'affichage
* @param chaine nom/id du fichier
* @param chaine url de redirection pour lire le fichier
* @return booleen
*/
	function MxPrintFormUpload($blocPath="upload", $docId="", $urlRead="")
	{
		// On affiche le nom

		$str ="<input type='hidden' name='MAX_FILE_SIZE' value='10000000000000'/>\n<input type='file' name='".$this->fieldName."' value=''/>";
		$str.='<input type="hidden" name="'.$this->fieldName.'_id" value=""/>';

		// On affiche le document
		if ($docId!="" || $docId==0)
		{
			$tabInfo=$this->getFileInfo($docId);

			if (count($tabInfo)>0)
			{
				$str ='<table class="tabledetail"><tr><td>';
				// Récupération du type de fichier à partir de l'extention
				// ---  recuperation de l'extension
				$extention= $this->extentionFinder($tabInfo["name"]);
				$nomIcone = $extention.".png";
				$dirImage = $GLOBALS['CONF_DATA_PATH']."data/image/icons/";

				if (file_exists($dirImage.strtolower($nomIcone))==true)
					$img="<img src='".$dirImage.$nomIcone."'/>";
				else
					$img="<img src='".$dirImage."default.png'/>";

				$str.=$img."";
				// Fin récupération du picto

				$str.='</td><td><a href="'.$urlRead.'">'.$tabInfo["name"].'</a></td></tr>';

				$str.="</table>";
				$str.='<p><mx:text id="TxtFileDelete"/> :</p>';
				$str.='<div class="boxcheck"><label><mx:text id="BtnYes"/></label>';
				$str.='<input type="radio" name="'.$this->fieldName.'" value="1"/></div>';
				$str.='<div class="boxcheck"><label><mx:text id="BtnNo"/></label>';
				$str.='<input type="radio" name="'.$this->fieldName.'" value="0" checked/></div>';
				$str.='<div><input type="hidden" name="'.$this->fieldName.'_id" value="'.$tabInfo["file_id"].'"/>';
				$str.='</div>';
				$str.="";
			}
		}
		$GLOBALS["SYSTEM_TEMPLATE"]->MxBloc($blocPath, "modify", $str);

		return true;
	}

/**
* recupere le chemin de l'icone
*/
	function getImagePath($name)
	{
		$extention= $this->extentionFinder($name);
		$nomIcone = $extention.".png";
		$dirImage = $GLOBALS['CONF_DATA_PATH']."data/image/icons/";

		if (file_exists($dirImage.strtolower($nomIcone))==true)
			$img="".$dirImage.$nomIcone."";
		else
			$img="".$dirImage."default.png";
		return $img;
	}
}

/**
* Classe UploadToDb
*
* Permet la gestion des upload dans une bd<br/>
* Le fichier est a inclure dans votre script avec l'instruction includePackage(upload.php)
* @package package
* @subpackage upload
*/
class UploadToDb extends Upload
{

/**#@+
* @access private
*/

/**
* @var entier
* @desc taille max des paquets sql (fonctionnement Bd)
*/
var $maxSqlSize=40000;

/**
* @var chaine
* @desc chemin du repertoire de telechargement (fonctionnement bd)
*/
var $file_id=0;

/**#@-*/

/**
*Constructeur de la classe UploadToBd
*
*<p>Initialise la classe</p>
* @access public
* @param chaine nom du champ
* @param entier taille max des paquets sql
*/
	function UploadToDb($fieldName="upload", $maxSqlSize=40000)
	{
		$this->__construct($fieldName, $maxSqlSize);
	}

/**
*Constructeur de la classe UploadToBd
*
*<p>Initialise la classe</p>
* @access public
* @param chaine nom du champ
* @param entier taille max des paquets sql
*/
	function __construct($fieldName="upload", $maxSqlSize=40000)
	{
		parent::__construct($fieldName);
		$this->maxSqlSize=$maxSqlSize;
	}

/**
* uploadFile:retourne la clé du fichier enregistré... (id automatique de la Bd)
*se sert des Tables "prefixe systeme"+files et "prefixe systeme"filesdata<br/>
*la table "prefixe systeme"files contient:<br/>
* - file_id : identifiant auto<br/>
* - name : nom du fichier<br/>
* - type : extention du fichier<br/>
* - size : taille du fichier<br/>
*<i>Cette table stocke les infos générales du fichier</i>
*la table "prefixe systeme"filedata contient:<br/>
* - id   : identifiant auto<br/>
* - file_id : identifiant du fichier correspondant<br/>
* - type : extention du fichier<br/>
* - size : taille du fichier<br/>
*<i>Cette table stocke les données du fichier sous forme de ligne
* la taille de ces lignes est déterminée par maxSqlSize (par défaut 50000)
*</i>
* @access public
* @param entier node id (noeud ou l'upload est effectué)
* @param entier object id (objet propriétaire du fichier)
* @param chaine fonction pour les test d'upload a NODE || USER si=false -> pas de test... /defaut NODE
* @return retourne la clé du fichier enregistré... id de l'enregistrement
*/
	function uploadFile($nid, $oid, $uid="", $mode="NODE")
	{
		$uid=($uid=="")?$GLOBALS["SYSTEM_USER_SESSION"]->user->getId():$uid;
		set_time_limit( CONF_UPLOAD_TIME );
		/* préfixe de la table */
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$boolUploaded=false;
		/* Récupération de la valeur */
		$erreur=0;

		if ($this->isValidPostFile())
		{
			$tmp=$_FILES[$this->fieldName]["tmp_name"];

			/* Vérification de la taille restante */
			$uploadLimit=new UploadLimit($nid, $uid);

			if (filesize($tmp)<$uploadLimit->getFreeSpace($mode) || $mode==false)
			{
				// Max packet size
				if (file_exists($tmp))
					$filehandle = fopen($tmp, "rb");
				else
					return false;
				$query=    "INSERT INTO ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."file (file_name, file_type, file_extention, file_size, file_location, file_nid, file_oid, file_uid, file_limit_owner) VALUES('".$this->validfileName()."', '".$_FILES[$this->fieldName]["type"]."', '".$this->extentionFinder($this->validfileName())."', ".filesize($tmp).", 'BD', $nid, $oid, $uid, ".$this->limitOwner.")";
				// Execute Query
				$result = $GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($query);
				$file_id = $GLOBALS["SYSTEM_DATABASE_CONN"]->sql_nextid();

				while (!feof ($filehandle)) {
					$data = base64_encode(fread($filehandle, $this->maxSqlSize));
					$query = "INSERT INTO ".$prefixe."filedata (file_id, filedata_data, nid, oid) VALUES($file_id,\"".$data."\", $nid, $oid)";
					$result = $GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($query);
				}
				fclose ($filehandle);
				$boolUploaded=true;
			}

		}
		return ($boolUploaded==true)?$file_id:false;
	}

/**
* getFileInfo:retourne un tableau des infos fichier (nom, id, size, type=>extention)
* @access public
* @return tableau tableau des infos fichier (nom, id, size, type=>extention)
*/
	function getFileInfo($id)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$row=array();
		if (is_numeric($id) && ($id!=0) )
		{
			$query ="SELECT * from ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."file WHERE file_id=$id";

			$result=$GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($query);

			if($GLOBALS['SYSTEM_DATABASE_CONN']->sql_numrows()>0)
			{
				$row = $GLOBALS['SYSTEM_DATABASE_CONN']->sql_fetchrow();
			}
		}
		return $row;
	}

/**
* getFileContent:retourne les données du fichier
* pour l'affichage utiliser voir printHeaders
* @access public
* @return data
*/
	function getFileContent($id, $nid, $oid)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$data="";
		if (is_numeric($id) && ($id!=0) )
		{
			$query ="select file_id, name, type, size from ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."file where file_id='$id'";

			$result=$GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($query);

			if($GLOBALS['SYSTEM_DATABASE_CONN']->sql_numrows()>0)
			{
				$row = $GLOBALS['SYSTEM_DATABASE_CONN']->sql_fetchrow();
				$GLOBALS['SYSTEM_DATABASE_CONN']->sql_freeresult();

				/* recupere les éléments du fichier */
				$query = "select file_id, filedata_data from ".$prefixe."filedata where file_id='$id' AND oid=$oid ORDER BY file_id ASC";

				$result=$GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($query);

				if($GLOBALS['SYSTEM_DATABASE_CONN']->sql_numrows()>0)
				{
					/* decode les fragments et recombine le fichier */
					$data = "";
					while ($row = mysql_fetch_array($result)) {
						$data .= base64_decode($row ["data"]);
					}
					$GLOBALS['SYSTEM_DATABASE_CONN']->sql_freeresult();
				}
			}
		}
		return $data;
	}

/**
* removeFile:detruit le fichier correspondant
* pour l'affichage utiliser printHeaders
* @access public
* @param entier identifiant du fichier
* @param entier identifiant du noeud
* @param entier identifiant de l'objet
* @return booleen
*/
	function removeFile($id, $nid, $oid)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$row=array();
		if (is_numeric($id) && ($id!=0) )
		{
			$query ="DELETE FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."file where file_id='$id' AND oid=$oid";
			$result=$GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($query);

			$query ="DELETE FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."filedata where file_id='$id' AND oid=$oid";
			$result=$GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($query);
			return true;
		}else{
			return false;
		}
	}

/**
* removeFileFromOid:detruit les fichiers correspondant a l'objet de coordination
* @param entier identifiant de l'objet
* @access public
* @return booleen
*/
	function removeFileFromOid($oid)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$row=array();
		if (is_numeric($oid) && ($oid!=0) )
		{
			$query ="DELETE FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."file WHERE oid=$oid";
			$result=$GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($query);

			$query ="DELETE FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."filedata WHERE oid=$oid";
			$result=$GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($query);
			return true;
		}else{
			return false;
		}
	}

/**
* checkStruct:verifie que la structure de BD existe, sinon cet élément la crée
*
* @access public
* @return tableau tableau des infos fichier (nom, id, size, type=>extention)
*/
         function checkStruct()
         {
                $sql="SHOW TABLE STATUS";
                $GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($sql);
         }
}


/**
* Classe UploadToDb
*
* Permet la gestion de Wyzis
* @todo Les tests ne sont pas encore fait pour la gestion de fichier sur disque...
* @package package
* @subpackage file
*/
class UploadToDir extends Upload
{
/**#@+
* @access private
*/

/**
* @var chaine
* @desc chemin du repertoire de telechargement (fonctionnement fichier)
*/
var $uploadDir="./data/upload/";

/**#@-*/

/**
*Constructeur de la classe UploadToDir
*
*<p>Initialise la classe</p>
*
* @param chaine nom du champ
* @param chaine nom du repertoire
*/
	function UploadToDir($fieldName="upload", $uploadDir=null)
	{
		$this->__construct($fieldName, $uploadDir);
	}

/**
*Constructeur de la classe UploadToDir
*
*<p>Initialise la classe</p>
* le fichier est a inclure dans votre script avec l'instruction includePackage(upload.php)
* @param chaine nom du champ
* @param chaine nom du repertoire
*/
	function __construct($fieldName="upload", $uploadDir=null)
	{
		parent::__construct($fieldName);
		$this->uploadDir=(!is_null($uploadDir))?$uploadDir:$GLOBALS["CONF_DATA_PATH"]."data/upload/";
	}

/**
* uploadFile:retourne la clé du fichier enregistré... nom du fichier ou faux
*enregistre le fichier uploade si existant dans le repertoire upload dir<br/>
* on notera que le nom du fichier est formaté et que 1 fichier ne peut pas être écraser<br/>
*
* @access public
* @param entier identifiant du noeud
* @param entier identifiant de l'objet
* @param entier identifiant de l'utilisateur
* @param chaine mode de fonctionement false
* @return retourne la clé du fichier enregistré... nom du fichier
*/
	function uploadFile($nid, $oid, $uid, $mode="NODE", $chmod="")
	{
		$uid=($uid=="")?$GLOBALS["SYSTEM_USER_SESSION"]->user->getId():$uid;
		set_time_limit( CONF_UPLOAD_TIME );

		$boolUploaded=false;
		/* Récupération de la valeur */
		$erreur=0;
		if ($this->isValidPostFile())
		{

			$tmp=$_FILES[$this->fieldName]["tmp_name"];

			/* Vérification de la taille restante */
			$uploadLimit=new UploadLimit($nid, $uid);

			if (filesize($tmp)<$uploadLimit->getFreeSpace($mode) || $mode==false || $mode=="NONE")
			{
				/* Initialisation du fileName de fichier */
				$this->fileName = $this->validfileName();
				/* jusqu'a ce que le fileName de fichier soit correct (par rapport au disque) */
				do
				{
					/* Cas changement du fileName de fichier (si existant) */
					if ($erreur==2)
					{
						$this->formatfileName();
					}
					$erreur=$this->isUploadedFile();
				}while ($erreur!=0 && $erreur!=1);

				/* fonction depuis Php4 qui test en mm temps si le fichier a été uploadé */
				$boolUploaded = move_uploaded_file($_FILES[$this->fieldName]["tmp_name"] , $this->uploadDir.$this->fileName);

				if ($boolUploaded==true)
				{
					if ($chmod!="")
						chmod($this->uploadDir.$this->fileName, $chmod);
					if ($mode!="NONE")
					{
						$query="INSERT INTO ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."file (file_name, file_type, file_extention, file_size, file_location, nid, oid, uid, file_limit_owner)";
						$query.="VALUES('".$this->uploadDir.$this->fichier."', '".$_FILES[$this->fieldName]["type"]."', '".$this->extentionFinder($this->fichier)."',";
						$query.=filesize($_FILES[$this->fieldName]["tmp_name"]).", 'FILE', ".$nid.", ".$oid.", ".$uid.", ".$this->limitOwner.")";
						// Execute Query
						$result = $GLOBALS["SYSTEM_DATABASE_CONN"]->sql_query($query);
						$file_id = $GLOBALS["SYSTEM_DATABASE_CONN"]->sql_nextid();
					}
				}
			}
		}
		return ($boolUploaded==true)?$this->fileName:false;
	}

/**
* getFileInfo:retourne un tableau des infos fichier (nom, id, size, type=>extention)
*
* @access public
* @param entier identifiant du fichier
* @param entier identifiant du noeud
* @param entier identifiant de l'objet
* @return tableau tableau des infos fichier (nom, id, size, type=>extention)
*/
	function getFileInfo($id, $nid, $oid)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$row=array();
		if (is_numeric($id) && ($id!=0) )
		{
			$query ="SELECT * from ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."file WHERE file_id=$id AND oid=$oid";

			$result=$GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($query);

			if($GLOBALS['SYSTEM_DATABASE_CONN']->sql_numrows()>0)
			{
				$row = $GLOBALS['SYSTEM_DATABASE_CONN']->sql_fetchrow();
			}
		}
		return $row;
	}

/**
* getFileContent:retourne les données du fichier
* pour l'affichage utiliser voir printHeaders
*
* @access public
* @param entier identifiant du fichier
* @param entier identifiant du noeud
* @param entier identifiant de l'objet
* @return data
*/
	function getFileContent($id, $nid, $oid)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$row=array();
		if (is_numeric($id) && ($id!=0) )
		{
			$query ="SELECT * from ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."file WHERE file_id=$id AND oid=$oid";

			$result=$GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($query);

			if($GLOBALS['SYSTEM_DATABASE_CONN']->sql_numrows()>0)
			{
				$row = $GLOBALS['SYSTEM_DATABASE_CONN']->sql_fetchrow();
				if (file_exists($this->uploadDir.$row["name"]))
				{
					$file=new File($this->uploadDir.$row["name"], "r");
					return $file->readAll();
				}else{
					return false;
				}
			}
		}
		return false;
	}

/**
* removeFile:detruit le fichier correspondant
* pour l'affichage utiliser printHeaders
*
* @access public
* @param entier identifiant du fichier
* @param entier identifiant du noeud
* @param entier identifiant de l'objet
* @return booleen
*/
	function removeFile($id, $nid, $oid)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$row=array();
		if (is_numeric($id) && ($id!=0) )
		{
			$query ="SELECT * from ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."file WHERE file_id=$id AND oid=$oid";

			$result=$GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($query);

			if($GLOBALS['SYSTEM_DATABASE_CONN']->sql_numrows()>0)
			{
				$row = $GLOBALS['SYSTEM_DATABASE_CONN']->sql_fetchrow();
				if (file_exists($this->uploadDir.$row["name"]))
				{
					$query ="DELETE FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."file where file_id='$id' AND oid=$oid";
					$result=$GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($query);

					$query ="DELETE FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."filedata where file_id='$id' AND oid=$oid";
					$result=$GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($query);

					delete($this->uploadDir.$row["name"]);
					return true;
				}
			}
		}
		return false;
	}

/**
* removeFileFromOid:detruit les fichiers correspondant a l'objet de coordination
* @access public
* @param entier identifiant de l'objet
* @return booleen
*/
	function removeFileFromOid($oid)
	{
		//$prefixe=(!defined("DATA_ACCES_TABLE_PREFIX"))?"": DATA_ACCES_TABLE_PREFIX ;
		$row=array();
		if (is_numeric($oid) && ($oid!=0) )
		{
			$query ="SELECT * from ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."file WHERE oid=$oid";

			$result=$GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($query);

			if($GLOBALS['SYSTEM_DATABASE_CONN']->sql_numrows()>0)
			{
				$row = $GLOBALS['SYSTEM_DATABASE_CONN']->sql_fetchrow();
				if (file_exists($this->uploadDir.$row["name"]))
				{
					$query ="DELETE FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."file WHERE file_id='$id' AND oid=$oid";
					$result=$GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($query);

					$query ="DELETE FROM ".DATA_ACCES_TABLE_PREFIX.DATA_ACCES_PACKAGE_PREFIX."filedata WHERE file_id='$id' AND oid=$oid";
					$result=$GLOBALS['SYSTEM_DATABASE_CONN']->sql_query($query);

					delete($this->uploadDir.$row["name"]);
					return true;
				}
			}
		}
		return false;
	}

	// verification de l'existance du fichier sur disque !!!
	// sert a ne pas dupliquer la clé sur le nom du fichier... on garde les anciens...
	function isUploadedFile()
	{
		$erreur = 0;

		$perms_dest = fileperms($this->uploadDir);
		if ($perms_dest!=false)
		{
			$perms_dest = $perms_dest & 07;
			/* Le répertoire doit être lisible, inscriptible et éxécutable*/
			if (!(($perms_dest & 01) && ($perms_dest & 02) && ($perms_dest & 04)))
			{
				/* Le répertoire doit être lisible, inscriptible et éxécutable*/
				return 1;
			}
			clearstatcache();
			//echo $uploadDirImage.$this->fichier;
			if (file_exists($this->uploadDir.$this->fileName)==true)
			{
				return 2;
			}
		}else{
			/* repertoire non lisible */
			return 1;
		}
		return 0;
	}

}

/**
* Converti un num (en octect) en valeur affichable
*/
function convertOctToPrint($num)
{
	return round(($num/1024), 0);
}
/**
* Converti une valeur affichable en un num (oct)
*/
function convertPrintToOct($num)
{
	return round(($num*1024), 0);
}
?>