1523 lines
42 KiB
PHP
Executable File
1523 lines
42 KiB
PHP
Executable File
<?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 © 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);
|
|
}
|
|
?>
|