PageRenderTime 61ms CodeModel.GetById 23ms RepoModel.GetById 0ms app.codeStats 0ms

/class.xuser.inc

https://github.com/jcplat/console-seolan
PHP | 894 lines | 749 code | 62 blank | 83 comment | 202 complexity | f98181b0bfa2b3006a46cdcdf1d89dba MD5 | raw file
Possible License(s): LGPL-2.0, LGPL-2.1, GPL-3.0, Apache-2.0, BSD-3-Clause 
    

  1. <?php
    2. 

  2. /// classe representant un utilisateur authentifie
    3. 

  3. class XUser  {
    4. 

  4.   const DB_SESSION_CACHE_PREFIX='cache::';
    5. 

  5. 

  6.   public $table='USERS';
    7. 

  7.   public $_cur=NULL;
    8. 

  8.   public $_curoid=NULL;
    9. 

  9.   public $_debug=false;
    10. 

  10.   public $admin=false;
    11. 

  11.   static $_cacheml=array();
    12. 

  12.   static $_C81=array();
    13. 

  13.   static $_C82=array();
    14. 

  14.   static $_C8OID = array();
    15. 

  15.   static $_C8OIDS = array();
    16. 

  16.   static $_cache_sGroup=array();
    17. 

  17.   static $_cache_listObjectAccess=array();
    18. 

  18. 

  19.   // creation d'un utilisateur ou d'un object utilisateur a partir d'un alias, d'un uid, d'un ar avec UID
    20. 

  20.   function __construct($ar=NULL) {
    21. 

  21.     if(is_string($ar)) {
    22. 

  22.       if(Kernel::isAKoid($ar)) $this->_curoid=$ar;
    23. 

  23.       else {
    24. 

  24. 	$uid=selectQueryGetOne('SELECT KOID FROM USERS WHERE alias="'.$ar.'" LIMIT 1');
    25. 

  25. 	if(!empty($uid)) $this->_curoid=$uid['KOID'];
    26. 

  26.       }
    27. 

  27.     }
    28. 

  28.     if(empty($this->_curoid)) {
    29. 

  29.       $p = new XParam($ar, array('UID'=>TZR_USERID_NOBODY));
    30. 

  30.       $this->_curoid=$p->get('UID');
    31. 

  31.     }
    32. 

  32.     if($this->_curoid!=TZR_USERID_NOBODY) $this->load();
    33. 

  33.     else{
    34. 

  34.       $this->_cur['ldata']='';
    35. 

  35.       $this->_cur['luser']='';
    36. 

  36.     }
    37. 

  37.   }
    38. 

  38. 

  39.   static function clearCache() {
    40. 

  40.     XUser::$_cacheml = array();
    41. 

  41.     XUser::$_C81 = array();
    42. 

  42.     XUser::$_C82 = array();
    43. 

  43.     XUser::$_cache_sGroup = array();
    44. 

  44.     XUser::$_cache_listObjectAccess=array();
    45. 

  45.     XUser::clearDbSessionDataAndRightCache();
    46. 

  46.   }
    47. 

  47. 

  48.   static public function authentified() {
    49. 

  49.     $uid=getSessionVar('UID');
    50. 

  50.     if(!empty($uid) && ($uid!='USERS:0')) return true;
    51. 

  51.     return false;
    52. 

  52.   }
    53. 

  53.   static function get_current_user_uid() {
    54. 

  54.     $uid= getSessionVar('UID');
    55. 

  55.     if(empty($uid)) $uid=TZR_USERID_NOBODY;
    56. 

  56.     return $uid;
    57. 

  57.   }
    58. 

  58.   static function isNobody() {
    59. 

  59.     $uid= getSessionVar('UID');
    60. 

  60.     if(empty($uid)) return true;
    61. 

  61.     if($uid==TZR_USERID_NOBODY) return true;
    62. 

  62.     return false;
    63. 

  63.   }
    64. 

  64.   public static function &get_user() {
    65. 

  65.     return $GLOBALS['XUSER'];	
    66. 

  66.   }
    67. 

  67.   function uid() {
    68. 

  68.     return $this->_curoid;
    69. 

  69.   }
    70. 

  70.   function isRoot() { return(!empty($this->_cur['grp']) && in_array(TZR_GROUPID_ROOT,$this->_cur['grp'])); }
    71. 

  71. 

  72.   /// rend le nom en clair de l'utilisateur authentifie
    73. 

  73.   function fullname() {
    74. 

  74.     return $this->_cur['fullnam'];
    75. 

  75.   }
    76. 

  76.   /// rend le home du backoffice de l'utilisateur
    77. 

  77.   function bohome() {
    78. 

  78.     if(!empty($this->_cur['bohome']) && Kernel::objectExists($this->_cur['bohome']))
    79. 

  79.       return $this->_cur['bohome'];
    80. 

  80.     else
    81. 

  81.       return 'home';
    82. 

  82.   }
    83. 

  83.   /// rend le top du menu backoffice de l'utilisateur
    84. 

  84.   function botop() {
    85. 

  85.     if(!empty($this->_cur['bohome']) && Kernel::objectExists($this->_cur['bohome']))
    86. 

  86.       return $this->_cur['bohome'];
    87. 

  87.     else
    88. 

  88.       return 'top';
    89. 

  89.   }
    90. 

  90.   /// rend l'email en clair de l'utilisateur authentifie
    91. 

  91.   function email() {
    92. 

  92.     return $this->_cur['email'];
    93. 

  93.   }
    94. 

  94.   /// rend la date de derniere connexion en clair de l'utilisateur authentifie
    95. 

  95.   function lastconnection() {
    96. 

  96.     return $this->_cur['lastcon'];
    97. 

  97.   }
    98. 

  98. 

  99.   function language($ar=NULL) {
    100. 

  100.     return array(@$this->_cur['ldata'],@$this->_cur['luser']);
    101. 

  101.   }
    102. 

  102. 

  103.   function load() {
    104. 

  104.     $this->_cur = selectQuery('SELECT * FROM '.$this->table .' WHERE KOID="'.$this->_curoid.'"')->fetch(PDO::FETCH_ASSOC);
    105. 

  105.     $this->_cur['grp'] = explode('||', $this->_cur['GRP']);
    106. 

  106.     if(empty($this->_cur['luser']))
    107. 

  107.       $this->_cur['luser'] = TZR_DEFAULT_LANG;
    108. 

  108.     if(XShell::admini_mode() && !XUser::isNobody()) {
    109. 

  109.       if(!in_array(TZR_GROUPID_AUTH,$this->_cur['grp']))
    110. 

  110.         $this->_cur['grp'][]=TZR_GROUPID_AUTH;
    111. 

  111.     }
    112. 

  112.     elseif(!in_array(TZR_GROUPID_NOBODY,$this->_cur['grp']))
    113. 

  113.       $this->_cur['grp'][]=TZR_GROUPID_NOBODY;
    114. 

  114.   }
    115. 

  115. 

  116.   function getUserList($myselfIncluded = true) {
    117. 

  117.     $LANG_USER = XShell::getLangUser();
    118. 

  118. 

  119.     $liste = array();
    120. 

  120.     $cond='';
    121. 

  121.     if ( !$myselfIncluded ) {
    122. 

  122.       $cond.=' KOID != "'.$this->_curoid.'" ';
    123. 

  123.     }
    124. 

  124.     $requete = 'select * from USERS '.$cond.' order by fullnam';
    125. 

  125. 

  126.     $rs=selectQuery($requete);
    127. 

  127.     $liste=array();
    128. 

  128.     $ors=array();
    129. 

  129.     while($rs && ($ors=$rs->fetch())) {
    130. 

  130.       $fullnam=$ors['fullnam'];
    131. 

  131.       $alias=$ors['alias'];
    132. 

  132.       $liste[$ors['KOID']]="$fullnam [$alias]";
    133. 

  133.     }
    134. 

  134.     return $liste;
    135. 

  135.   }
    136. 

  136. 

  137.   function groups($refresh=false) {
    138. 

  138.     if(!$refresh && !empty($this->_cur['groups'])) return $this->_cur['groups'];
    139. 

  139.     $limits=array();
    140. 

  140.     $limits['USERS']=array('GRP');
    141. 

  141.     $limits['GRP']=array('GRPS');
    142. 

  142.     $g1=Kernel::followLinks(array($this->_curoid),$limits);
    143. 

  143.     // Si l'utilisateur est authentifié, il fait parti du groupe "Utilisateurs authentifié" automatiquement
    144. 

  144.     if(!XUser::isNobody() && !in_array(TZR_GROUPID_AUTH, $g1)) $g1[]=TZR_GROUPID_AUTH;
    145. 

  145.     // Si l'utilisateur fait parti du groupe "Utilisateurs authentifiés", il ne fera pas parti du groupe "Tout le monde"
    146. 

  146.     if(!in_array(TZR_GROUPID_AUTH, $g1) && !in_array(TZR_GROUPID_NOBODY, $g1)) $g1[]=TZR_GROUPID_NOBODY;
    147. 

  147.     $this->_cur['groups']=$g1;
    148. 

  148.     return $g1;
    149. 

  149.   }
    150. 

  150. 

  151.   static function sGroups($uoid) {
    152. 

  152.     if(!is_array($uoid)) $uoid=array($uoid);
    153. 

  153.     $idx=implode('-',$uoid);
    154. 

  154.     if(empty(XUser::$_cache_sGroup[$idx])){
    155. 

  155.       $limits=array();
    156. 

  156.       $limits['USERS']=array('GRP');
    157. 

  157.       $limits['GRP']=array('GRPS');
    158. 

  158.       $g1=Kernel::followLinks($uoid,$limits);
    159. 

  159.       if(!XUser::isNobody() && !in_array(TZR_GROUPID_AUTH, $g1)) $g1[]=TZR_GROUPID_AUTH;
    160. 

  160.       if(!in_array(TZR_GROUPID_AUTH, $g1) && !in_array(TZR_GROUPID_NOBODY, $g1)) $g1[]=TZR_GROUPID_NOBODY;
    161. 

  161.       XUser::$_cache_sGroup[$idx]=array_unique($g1);
    162. 

  162.     }
    163. 

  163.     return XUser::$_cache_sGroup[$idx];
    164. 

  164.   }
    165. 

  165. 

  166.   // Rend vrai si l'utiliser uid est dans les groupes $grps (attention si $parents==true, en ajoute dans grps les groupes parents et surtout GRP:0 ou GRP:2 selon si authentifié ou pas)
    167. 

  167.   function inGroups($grps,$parents=true) {
    168. 

  168.     if(!is_array($grps)) $grps=array($grps);
    169. 

  169.     $mygroups = $this->groups();
    170. 

  170.     if($parents) $otgroups = XUser::sGroups($grps);
    171. 

  171.     else $otgroups = $grps;
    172. 

  172.     $r1=array_intersect($mygroups, $otgroups);
    173. 

  173.     if(empty($r1)) {
    174. 

  174.       return false;
    175. 

  175.     }
    176. 

  176.     return true;
    177. 

  177.   }
    178. 

  178. 

  179.   /// Compare 2 niveaux de sécurité pour une classe donnée
    180. 

  180.   static public function compareSecLevels($class,$lvl1,$lvl2,$op){
    181. 

  181.     if(is_numeric($class)){
    182. 

  182.       $mod=XModule::objectFactory($class);
    183. 

  183.       $class=get_class($mod);
    184. 

  184.     }
    185. 

  185.     $secs=call_user_func(array($class,'secList'),NULL);
    186. 

  186.     $res1=array_search($lvl1,$secs);
    187. 

  187.     $res2=array_search($lvl2,$secs);
    188. 

  188.     return eval('return '.$res1.$op.$res2.';');
    189. 

  189.   }
    190. 

  190. 

  191.   /// Vérifie si l'utilisateur courant peut attribuer un droit spécifique à un objet
    192. 

  192.   static public function isAuthorizedToSetAccess($class,$moid,$lang,$oid,$lvl){
    193. 

  193.     if($lvl=='default') return true;
    194. 

  194.     $actlvl=XUser::secure8maxlevel($moid,$oid,null,$lang);
    195. 

  195.     return XUser::compareSecLevels($moid,$lvl,$actlvl,'<=');
    196. 

  196.   }
    197. 

  197. 

  198.   /// Positionnement du niveau d'accés dans la base de donnéees
    199. 

  199.   public function setUserAccess($class,$moid,$lang,$oid,$level,$uoid=NULL,$cache=false,$force=true,$comment='') {
    200. 

  200.     if(empty($uoid)) $uoid=$this->_curoid;
    201. 

  201.     if(!$force && !$cache && !XShell::isRoot()){
    202. 

  202.       if(!XUser::isAuthorizedToSetAccess($class,$moid,$lang,$oid,$level)) return false;
    203. 

  203.     }
    204. 

  204.     $table=($cache?'ACL4_CACHE':'ACL4');
    205. 

  205.     $aoid=substr(md5(uniqid('')),0,40);
    206. 

  206.     if(!empty($moid)) {
    207. 

  207.       $q='DELETE FROM '.$table.' where AMOID="'.$moid.'" and ALANG="'.$lang.'" and AKOID="'.$oid.'" and AGRP="'.$uoid.'"';
    208. 

  208.       $q2='INSERT INTO '.$table.'(AOID,UPD,AGRP,AFUNCTION,ALANG,AMOID,AKOID,OK,ACOMMENT) '.
    209. 

  209. 	'values ("'.$aoid.'",NULL,"'.$uoid.'","'.$level.'","'.$lang.'","'.$moid.'","'.$oid.'",1,"'.$comment.'")';
    210. 

  210.       $q3='DELETE FROM ACL4_CACHE where AMOID="'.$moid.'" and ALANG="'.$lang.'"';
    211. 

  211.       if(!$cache) XLogs::update('security', $uoid, 'Delete security rules for moid='.$moid.' oid='.$oid.' user='.$uoid.' lang='.$lang);
    212. 

  212.     } else {
    213. 

  213.       $q='DELETE FROM '.$table.' where ACLASS="'.$class.'" and ALANG="'.$lang.'" and AKOID="'.$oid.'" and AGRP="'.$uoid.'"';
    214. 

  214.       $q2='INSERT INTO '.$table.'(AOID,UPD,AGRP,AFUNCTION,ACLASS,ALANG,AKOID,OK,ACOMMENT) '.
    215. 

  215. 	'values ("'.$aoid.'",NULL,"'.$uoid.'","'.$level.'","'.$class.'","'.$lang.'","'.$oid.'",1,"")';
    216. 

  216.       $q3='DELETE FROM ACL4_CACHE where ACLASS="'.$class.'" and ALANG="'.$lang.'"';
    217. 

  217.       if(!$cache) XLogs::update('security', $uoid, 'Delete security rules for class='.$class.' oid='.$oid.' user='.$uoid.' lang='.$lang);
    218. 

  218.     }
    219. 

  219.     if($lang=='all'){
    220. 

  220.       $q=str_replace('and ALANG="all"','',$q);
    221. 

  221.       $q3=str_replace('and ALANG="all"','',$q3);
    222. 

  222.     }
    223. 

  223.     // On efface d'eventuels drois deja presents
    224. 

  224.     updateQuery($q);
    225. 

  225.     // On efface le cache du module
    226. 

  226.     if(!$cache) updateQuery($q3);
    227. 

  227. 

  228.     if($level!='default') {
    229. 

  229.       if($lang=='all'){
    230. 

  230. 	foreach($GLOBALS['TZR_LANGUAGES'] as $lg=>$locale){
    231. 

  231. 	  updateQuery(str_replace('"all"','"'.$lg.'"',$q2));
    232. 

  232. 	  $this->_cacheml[$class.$moid.$lg.$uoid.$oid]=$level;
    233. 

  233. 	}
    234. 

  234.       }else{
    235. 

  235. 	updateQuery($q2);
    236. 

  236. 	$this->_cacheml[$class.$moid.$lang.$uoid.$oid]=$level;
    237. 

  237.       }
    238. 

  238.       if(!$cache) XLogs::update('security', $uoid, "New security rules for '$uoid',1,'$level','$class','$lang','$moid','$oid',1");
    239. 

  239.     }else{
    240. 

  240.       unset($this->_cacheml[$class.$moid.$lang.$uoid.$oid]);
    241. 

  241.     }
    242. 

  242.     return true;
    243. 

  243.   }
    244. 

  244.   
    245. 

  245.   /// Copie des acces sur un oid vers un autre oid
    246. 

  246.   public function copyUserAccess($oidsrc, $oiddst, $moid) {
    247. 

  247.     $rs=selectQuery('select * FROM ACL4 where AMOID="'.$moid.'" and AKOID="'.$oidsrc.'"');
    248. 

  248.     while($ors=$rs->fetch()) {
    249. 

  249.       // on verifie que l'acl n'existe pas
    250. 

  250.       $n=countSelectQuery('select count(*) from ACL4 where AGRP="'.$ors['AGRP'].'" and AFUNCTION="'.$ors['AFUNCTION'].'" and ACLASS="'.$ors['ACLASS'].'" '.
    251. 

  251. 			  'and ALANG="'.$ors['ALANG'].'" and AMOID="'.$ors['AMOID'].'" and AKOID="'.$oiddst.'" and OK="'.$ors['OK'].'"');
    252. 

  252.       if(!$n){
    253. 

  253.         $aoid=substr(md5(uniqid("")),0,40);
    254. 

  254.         updateQuery('INSERT INTO ACL4(AOID,AGRP,AFUNCTION,ACLASS,ALANG,AMOID,AKOID,OK) values ("'.
    255. 

  255. 		    $aoid.'","'.$ors['AGRP'].'","'.$ors['AFUNCTION'].'","'.$ors['ACLASS'].'","'.$ors['ALANG'].
    256. 

  256. 		    '","'.$ors['AMOID'].'","'.$oiddst.'","'.$ors['OK'].'")');
    257. 

  257.       }
    258. 

  258.     }
    259. 

  259.     $rs->closeCursor();
    260. 

  260.     XLogs::update('security',$oiddst,'Copy security rules from '.$oidsrc.' to '.$oiddst.' on '.$moid);
    261. 

  261.   }
    262. 

  262. 

  263.   /// Copie tous les droits d'un utilisateur/groupe vers un autre
    264. 

  264.   function copyAllUserAccess($suid,$duid){
    265. 

  265.     $rs=selectQuery('select * FROM ACL4 where AGRP="'.$suid.'"');
    266. 

  266.     while($ors=$rs->fetch()) {
    267. 

  267.       $aoid=md5(uniqid(''));
    268. 

  268.       updateQuery('INSERT INTO ACL4(AOID,AGRP,AFUNCTION,ACLASS,ALANG,AMOID,AKOID,OK) values ("'.$aoid.'","'.$duid.'","'.$ors['AFUNCTION'].'",'.
    269. 

  269. 		  '"'.$ors['ACLASS'].'","'.$ors['ALANG'].'","'.$ors['AMOID'].'","'.$ors['AKOID'].'","'.$ors['OK'].'")');
    270. 

  270.     }
    271. 

  271.     $rs->closeCursor();
    272. 

  272.     XLogs::update('security',$duid,'Copy all security rules from '.$suid);
    273. 

  273.   }
    274. 

  274.   
    275. 

  275.   /// Effaccement des droits correspondant a un module, une langue, un oid, des utilisateurs donnes
    276. 

  276.   public function clearUserAccess($class, $moid, $lang, $oid, $uoid=NULL) {
    277. 

  277.     if(!empty($uoid)) $AGRP=' and AGRP="'.$uoid.'"';
    278. 

  278.     else $AGRP='';
    279. 

  279.     updateQuery('DELETE FROM ACL4 where ACLASS="'.$class.'" and AMOID="'.$moid.'" and ALANG="'.$lang.'" and AKOID="'.$oid.'"'.$AGRP);
    280. 

  280.     XLogs::update('security',$oid,'Clear security rules for '.$class.','.$moid.','.$lang.','.$oid.' on '.$AGRP);
    281. 

  281.   }
    282. 

  282.   
    283. 

  283.   /// Rend la liste des droits pour un moid/oid
    284. 

  284.   public function getObjectAccess($mod, $lang, $oid=NULL, $grp=NULL) {
    285. 

  285.     if(!$mod) return array();
    286. 

  286.     if(is_numeric($mod)) $mod=XModule::objectFactory($mod);
    287. 

  287.     if(!$mod) return array(array(),array());
    288. 

  288.     $seclistfull = $seclist = $mod->secList();
    289. 

  289.     $level=self::secure8maxlevel($mod,$oid,$grp,$lang);
    290. 

  290.     $cnt=count($seclist);
    291. 

  291.     $i=$cnt-1;
    292. 

  292.     while($i>=0) {
    293. 

  293.       if(!($level==$seclist[$i])) {
    294. 

  294. 	unset($seclist[$i]);
    295. 

  295. 	$i--;
    296. 

  296.       } else break;
    297. 

  297.     }
    298. 

  298.     if(count($seclist)<=0) $seclist=array("none");
    299. 

  299.     return array($seclist,$seclistfull);
    300. 

  300.   }
    301. 

  301.   /// Alias de getObjectAccess
    302. 

  302.   public function getUserAccess($class, $moid, $lang=NULL, $oid=NULL, $grp=NULL) {
    303. 

  303.     return $this->getObjectAccess($moid, $lang, $oid, $grp);
    304. 

  304.   }
    305. 

  305. 

  306.   /// recherche des acces pour tous les utilsiateurs sur module donne. si $oid, alors sur objet
    307. 

  307.   static function getModuleAccess(XModule &$mod,$all=true) {
    308. 

  308.     global $TZR_LANGUAGES;
    309. 

  309.     list($users, $groups) = XUser::getUsersAndGroups(true,$all);
    310. 

  310.     $x1=self::get_user();
    311. 

  311.     foreach($users['lines_oid'] as $i=>$uoid) {
    312. 

  312.       $users['lines_nsec'][$i]=count($users['lines_sec'][$i][TZR_DEFAULT_LANG][0]);
    313. 

  313.       $users['lines_sec'][$i]=array();
    314. 

  314.       foreach($TZR_LANGUAGES as $lang=>$v){
    315. 

  315. 	$users['lines_sec'][$i][$lang]=$x1->getUserAccess(get_class($mod), $mod->_moid, $lang, NULL, $uoid);
    316. 

  316.       }
    317. 

  317.     }
    318. 

  318. 

  319.     foreach($groups['lines_oid'] as $i=>$uoid) {
    320. 

  320.       $groups['lines_nsec'][$i]=count($groups['lines_sec'][$i][TZR_DEFAULT_LANG][0]);
    321. 

  321.       $groups['lines_sec'][$i]=array();
    322. 

  322.       foreach($TZR_LANGUAGES as $lang=>$v){
    323. 

  323. 	$groups['lines_sec'][$i][$lang]=$x1->getUserAccess(get_class($mod), $mod->_moid, $lang, NULL, $uoid);
    324. 

  324.       }
    325. 

  325.     }
    326. 

  326. 	
    327. 

  327.     return array($users, $groups);
    328. 

  328.   }
    329. 

  329. 

  330.   public function getObjectsAccess($mod, $lang, &$oids) {
    331. 

  331.     $l=$this->getObjectAccess($mod, $lang);
    332. 

  332.     $l=array_flip($l[0]);
    333. 

  333.     if(empty($mod->object_sec)) {
    334. 

  334.       $levs = array();
    335. 

  335.       foreach($oids as $i => $oid) {
    336. 

  336. 	$levs[$i]=$l;
    337. 

  337.       }
    338. 

  338.     } else {
    339. 

  339.       $hasrules=XUser::getObjectsWithSec($mod,XUser::get_current_user_uid());
    340. 

  340.       $hasrules=array_flip($hasrules);
    341. 

  341.       $levs = array();
    342. 

  342.       foreach($oids as $i => $oid) {
    343. 

  343. 	if(array_key_exists($oid,$hasrules)){
    344. 

  344. 	  $l2 = $this->getObjectAccess($mod, $lang, $oid);
    345. 

  345. 	  $l2=array_flip($l2[0]);
    346. 

  346. 	  $levs[$i]=$l2;
    347. 

  347. 	}else{
    348. 

  348. 	  $levs[$i]=$l;
    349. 

  349. 	}
    350. 

  350.       }
    351. 

  351.     }
    352. 

  352.     return $levs;
    353. 

  353.   }
    354. 

  354. 

  355.   /// Pour un user/group donné, retourne les oids pour lesquels des droits spécifique ont été posé
    356. 

  356.   static function &getObjectsWithSec($mod,$uid){
    357. 

  357.     $uids=XUser::sGroups($uid);
    358. 

  358.     $hasrules=selectQueryGetColumn('(select AKOID from ACL4 where AGRP in ("'.implode('","',$uids).'") and AMOID="'.$mod->_moid.'" and AKOID!="" AND AKOID NOT LIKE "_field%") UNION DISTINCT '.
    359. 

  359. 				   '(select AKOID from ACL4_CACHE where AGRP in ("'.implode('","',$uids).'") and AMOID="'.$mod->_moid.'" and AKOID!="" and ACOMMENT="'.XSession::CS8_EMPTY_CHECK.'")');
    360. 

  360.     return $hasrules;
    361. 

  361.   }
    362. 

  362. 

  363.   public function listObjectAccess(XModule &$mod, $lang, $oid, $details=false) {
    364. 

  364.     $lang_cond="";
    365. 

  365.     if(!empty($lang)) $lang_cond = "and ALANG='$lang'";
    366. 

  366.     $rs=selectQuery("select * from ACL4 where AMOID='".$mod->_moid."' ".$lang_cond." and AKOID='$oid' order by AGRP,ALANG");
    367. 

  367.     $r=array();
    368. 

  368.     $k = new Kernel();
    369. 

  369.     $ors=array();
    370. 

  370.     while( $ors=$rs->fetch()) {
    371. 

  371.       if($details) {
    372. 

  372. 	$d1=&XUser::$_cache_listObjectAccess[$ors['AGRP']];
    373. 

  373. 	if(!$d1) $d1=XDataSource::objectDisplayHelper($ors['AGRP']);
    374. 

  374. 	if(is_array($d1)) {
    375. 

  375. 	  if($d1['ofullnam']->raw) $names[]='B-'.$d1['ofullnam']->raw;
    376. 

  376.           else $names[]='A-'.$d1['oGRP']->raw;
    377. 

  377. 	  $r['acl_uid'][]=$ors['AGRP'];
    378. 

  378. 	  $r['acl_own'][]=$d1;
    379. 

  379. 	  $r['acl_level'][]=$ors['AFUNCTION'];
    380. 

  380. 	  $r['acl_lang'][]=$ors['ALANG'];
    381. 

  381. 	  $r['acl_longlevel'][]=XLabels::getSysLabel('security',$ors['AFUNCTION']);
    382. 

  382. 	} else {
    383. 

  383. 	  updateQuery('delete from ACL4 where AGRP = "'.$ors['AGRP'].'"');
    384. 

  384. 	}
    385. 

  385.       } else $r['acl_uid'][]=$ors['AGRP'];
    386. 

  386.     }
    387. 

  387.     if($details) array_multisort($names,$r['acl_uid'],$r['acl_own'],$r['acl_level'],$r['acl_lang'],$r['acl_longlevel']);
    388. 

  388.     $r["oid"]=$oid;
    389. 

  389.     if(XShell::admini_mode() && ($lang==TZR_DEFAULT_LANG)) {
    390. 

  390.       if(!$oid){
    391. 

  391. 	 $r['title']=XLabels::getSysLabel('general','module','text').' '.$mod->modulename;
    392. 

  392.       }elseif((substr($oid,0,7)!='_field-') && Kernel::objectExists($oid)){
    393. 

  393. 	$otab=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$oid);
    394. 

  394. 	$ro = $otab->display(array("_publishedonly"=>true,"tplentry"=>TZR_RETURN_DATA,"oid"=>$oid, '_archive'=>''));
    395. 

  395. 	$r["title"]=$ro['link'];
    396. 

  396.       }else{
    397. 

  397. 	$r['title']=$mod->xset->desc[substr($oid,7)]->label;
    398. 

  398.       }
    399. 

  399.     }
    400. 

  400.     $r["lang"]=$lang;
    401. 

  401.     $r["moid"]=$mod->_moid;
    402. 

  402.     $r["classname"]=get_class($mod);
    403. 

  403.     return $r;
    404. 

  404.   }
    405. 

  405. 

  406.   public function editObjectAccess(XModule &$mod, $lang, $oid) {
    407. 

  407.     $rs=selectQuery("select * from ACL4 where AMOID='".$mod->_moid."' and ALANG='$lang' and AKOID='$oid'");
    408. 

  408.     $r=array();
    409. 

  409.     $k = new Kernel();
    410. 

  410.     $ls = $this->getObjectAccess($mod,$lang,$oid);
    411. 

  411.     $ors=array();
    412. 

  412.     while( $ors=$rs->fetch()) {
    413. 

  413.       $d1=$k->data_display(array("tplentry"=>TZR_RETURN_DATA, "oid"=>$ors['AGRP'],
    414. 

  414. 				 '_options'=>array('error'=>'return')));
    415. 

  415.       if(is_array($d1)) {
    416. 

  416. 	$r['acl_uid'][]=$ors['AGRP'];
    417. 

  417. 	$r['acl_own'][]=$d1;
    418. 

  418. 	$r['acl_level'][]=$ors['AFUNCTION'];
    419. 

  419. 	$r['acl_longlevel'][]=XLabels::getSysLabel('security',$ors['AFUNCTION']);
    420. 

  420.       } else {
    421. 

  421. 	updateQuery('delete from ACL4 where AGRP = "'.$ors['AGRP'].'"');
    422. 

  422.       }
    423. 

  423.     }
    424. 

  424.     $rs->closeCursor();
    425. 

  425.     return $r;
    426. 

  426.   }
    427. 

  427. 

  428.   /// envoi d'un mail a  l'utilisateur, ou a $mail si $mail est renseigné
    429. 

  429.   /// $mail peut etre : une adresse, un tableau d'adresses, un tableau de la forme (mail=>mail,name=>nom), un tableau de tableau mail/nom
    430. 

  430.   public function sendMail2User($subject,$message,$email=NULL,$from=NULL,$archive=true,$filename=NULL,$filetitle=NULL,$stringattachment=NULL,$mime=NULL,$params=array()) {
    431. 

  431.     if(!XUser::isNobody() && empty($email)) {
    432. 

  432.       $rs=selectQuery('select * from USERS where KOID="'.$this->_curoid.'"');
    433. 

  433.       if($rs && $ors=$rs->fetch()) {
    434. 

  434. 	$email = $ors['email'];
    435. 

  435.       }
    436. 

  436.     }
    437. 

  437.     if(empty($email)) return;
    438. 

  438.     if(empty($from)) $from=TZR_SENDER_ADDRESS;
    439. 

  439.     $xmail=new XMail();
    440. 

  440.     $xmail->setTZRSubject($subject);
    441. 

  441.     $xmail->logActive=$archive;
    442. 

  442.     @$xmail->_modid=$params['moid'];
    443. 

  443.     @$xmail->_mtype=$params['mtype'];
    444. 

  444.     if(is_array($from)){
    445. 

  445.       $xmail->From=$from[0];
    446. 

  446.       $xmail->FromName=$from[1];
    447. 

  447.     }else{
    448. 

  448.       $xmail->From=$from;
    449. 

  449.       $xmail->FromName="";
    450. 

  450.     }
    451. 

  451.     if(preg_match("/(^<html>)/",$message)) {
    452. 

  452.       $xmail->IsHTML(true);
    453. 

  453.       if(!empty($params['sign'])) $xmail->setTZRBody($message);
    454. 

  454.       else $xmail->Body=$message;
    455. 

  455.     } else {
    456. 

  456.       $xmail->IsHTML(false);
    457. 

  457.       if(!array_key_exists('sign',$params) || !empty($params['sign'])) $xmail->setTZRBody(wordwrap($message, 65));
    458. 

  458.       else $xmail->Body=wordwrap($message, 65);
    459. 

  459.     }
    460. 

  460.     if(!empty($filename)){
    461. 

  461.       if(!is_array($filename)) $filename=array($filename);
    462. 

  462.       if(!is_array($filetitle)) $filetitle=array($filetitle);
    463. 

  463.       foreach($filename as $i=>$fn){
    464. 

  464. 	$xmail->AddAttachment($filename[$i], $filetitle[$i]);
    465. 

  465.       }
    466. 

  466.     }
    467. 

  467.     if(!empty($stringattachment)) $xmail->AddStringAttachment($stringattachment, $filetitle, "base64", $mime);
    468. 

  468. 

  469.     if(!is_array($email)) $email=array($email);
    470. 

  470.     elseif(array_key_exists('mail',$email)) $email=array($email);
    471. 

  471.     foreach($email as $i=>$mail){
    472. 

  472.       $xmail->ClearAllRecipients();
    473. 

  473.       if(is_array($mail)) $xmail->AddAddress($mail['mail'],$mail['name']);
    474. 

  474.       else $xmail->AddAddress($mail);
    475. 

  475.       $xmail->Send();
    476. 

  476.       if($archive) XLogs::update("mail sent", '',"To: $mail\nSubject: $subject\n".$xmail->Body);
    477. 

  477.     }
    478. 

  478.   }
    479. 

  479.   
    480. 

  480.   // creation d'un nouvel utilisateur
    481. 

  481.   // fonction non autorisée depuis internet
    482. 

  482.   //
    483. 

  483.   function newUser($ar=NULL) {
    484. 

  484.     $p = new XParam($ar,array());
    485. 

  485.     $tplentry=$p->get("tplentry");
    486. 

  486. 

  487.     $login = $p->get("login");
    488. 

  488.     $passwd = $p->get("passwd");
    489. 

  489.     $thenlog = $p->get("_thenlog");
    490. 

  490.     $login=preg_replace('/([^[A-Za-z0-9]]+)/','',$login);
    491. 

  491.     $status=false;
    492. 

  492.     if(empty($login) && ($login!="root")) {
    493. 

  493.       $message=XLabels::getSysLabel("xmoduser.aliasnotaccepted");
    494. 

  494.     } else {
    495. 

  495.       $cnt=countSelectQuery("select COUNT(*) from USERS where alias='$login'");
    496. 

  496.       if($cnt>0) {
    497. 

  497. 	$status=false;
    498. 

  498. 	$message=XLabels::getSysLabel("xmoduser.existing_user");
    499. 

  499.       } else {
    500. 

  500. 	$xuser=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.'USERS');
    501. 

  501. 	$ar["alias"]=$login;
    502. 

  502. 	$ar["passwd"]=$passwd;
    503. 

  503. 	$ar["GRP"]=$p->get("GRP","local");
    504. 

  504. 	$xuser->procInput($ar);
    505. 

  505. 	if($thenlog) {
    506. 

  506. 	  $xsession=new XSession();
    507. 

  507. 	  $xsession->procAuth(array("login"=>$login, "password"=>$passwd));
    508. 

  508. 	  $status=true;
    509. 

  509. 	}
    510. 

  510.       }
    511. 

  511.     }
    512. 

  512.     $r=array("status"=>$status, "message"=>$message);
    513. 

  513.     if($tplentry==TZR_RETURN_DATA) {
    514. 

  514.       return $r;
    515. 

  515.     }
    516. 

  516.     return XShell::toScreen1($tplentry, $r);
    517. 

  517.   }
    518. 

  518. 

  519.   function &getUserName($user) {
    520. 

  520.     static $names=array();
    521. 

  521.     if(!empty($names[$user])) return $names[$user];
    522. 

  522.     $rs=selectQuery("SELECT * FROM USERS WHERE KOID='$user'");    
    523. 

  523.     if($ors=$rs->fetch()) {
    524. 

  524.       $names[$user]=array(1=>$ors['fullnam'],2=>$user);
    525. 

  525.     } else {
    526. 

  526.       $names[$user]=array(1=>'',2=>'');
    527. 

  527.     }
    528. 

  528.     $rs->closeCursor();
    529. 

  529.     return $names[$user];
    530. 

  530.   }
    531. 

  531. 

  532.   /// recherche de la liste des utilisateurs et groupes
    533. 

  533.   static function &getUsersAndGroups($valid=false,$all=true,$directory=NULL) {
    534. 

  534.     if(empty($directory)) {
    535. 

  535.       $xuser = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS=USERS');
    536. 

  536.       $cond=array();
    537. 

  537.       if(!$all || $all==='groups') $cond['GRP']=array('!=','');
    538. 

  538.       if($valid){
    539. 

  539. 	if($xuser->fieldExists('DATEF') && $xuser->fieldExists('DATET')) {
    540. 

  540. 	  $cond['DATET']=array('>=',date('Y-m-d'));
    541. 

  541. 	  $cond['DATEF']=array('<=',date('Y-m-d'));
    542. 

  542. 	}
    543. 

  543. 	if($xuser->fieldExists('PUBLISH')) {
    544. 

  544. 	  $cond['PUBLISH']=array('=',1);
    545. 

  545. 	}
    546. 

  546.       }
    547. 

  547.       $select=(!empty($cond)?$xuser->select_query(array('cond'=>$cond)):'');;
    548. 

  548.       $acl_user=$xuser->browse(array('tplentry'=>TZR_RETURN_DATA,'order'=>'fullnam','select'=>$select,'pagesize'=>'9999','selectedfields'=>array('fullnam','GRP','alias')));
    549. 

  549.     } else {
    550. 

  550.       $xuser = XModule::objectFactory($directory);
    551. 

  551.       if(empty($xuser)) return array();
    552. 

  552.       $select='';
    553. 

  553.       if($valid && $xuser->xset->fieldExists('DATEF') && $xuser->xset->fieldExists('DATET')) {
    554. 

  554.         $select = 'DATET >= "'.date('Y-m-d').'"';
    555. 

  555.         $select .= 'AND DATEF <= "'.date('Y-m-d').'"';
    556. 

  556.       }
    557. 

  557.       $acl_user=$xuser->browse(array('_local'=>1, 'select'=>$select, 'pagesize'=>9999, 'order'=>'fullnam', 'selectedfields'=>array('fullnam','GRP','alias')));
    558. 

  558.     }
    559. 

  559.     // On récupère tous les groupes et sous-groupes des utilisateurs actifs
    560. 

  560.     $grps = self::sGroups($acl_user['lines_oid']);
    561. 

  561.     // Si le paramètre "all" est activé, on ajoute les groupes "Tout le monde" et "Utilisateurs authentifiés" à la liste
    562. 

  562.     if($all && $all!=='users') $grps = array_merge($grps, array('GRP:*','GRP:2'));
    563. 

  563.     $grps=array_unique($grps);
    564. 

  564.     $xgrp=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS=GRP');
    565. 

  565.     $select=$xgrp->select_query(array('cond'=>array('KOID'=>array('=',$grps))));
    566. 

  566.     $acl_grp=$xgrp->browse(array('tplentry'=>TZR_RETURN_DATA, 'order'=>'GRP','pagesize'=>'1000','select'=>$select));
    567. 

  567.     $ar=array(&$acl_user,&$acl_grp);
    568. 

  568.     return $ar;
    569. 

  569.   }
    570. 

  570. 

  571.   /// Vérifie le niveau de droit d'une fonction sur un module pour un ensemble d'oid
    572. 

  572.   /// $function : nom de la fonction à tester
    573. 

  573.   /// $mod : module à tester
    574. 

  574.   /// $oid : oid ou tableau d'oid à tester
    575. 

  575.   /// $user : uid du user à tester
    576. 

  576.   /// $lang : langue à tester
    577. 

  577.   /// @return : [ fonction accessible (bool), nb de regle parcourue (int), niveau max de droit (string) ]
    578. 

  578.   static function secure8($function, $mod, $oid=null, $user=null, $lang=null, $checkparent=true) {
    579. 

  579.     // Recherche de la liste des groupes/users a tester
    580. 

  580.     if(!$user) $user=XUser::get_current_user_uid();
    581. 

  581.     elseif(is_object($user)) $user=$user->_curoid;
    582. 

  582.     $g1 = XUser::sGroups($user);
    583. 

  583. 

  584.     // Si on est dans le groupe des administrateurs on a tous les droits
    585. 

  585.     if(in_array(TZR_GROUPID_ROOT, $g1)) return array(true,1,'admin');
    586. 

  586.     $g1=array_unique($g1);
    587. 

  587.     // Récupération du module et nettoyage des oids
    588. 

  588.     if(is_numeric($mod)) $mod=XModule::objectFactory($mod);
    589. 

  589.     if(!$lang) $lang=TZR_DEFAULT_LANG;
    590. 

  590. 

  591.     if(!$mod->objectSecurityEnabled() || !$oid){
    592. 

  592.       $oids=array('');
    593. 

  593.     }elseif(!is_array($oid)){
    594. 

  594.       $oids=array($oid);
    595. 

  595.     }else{
    596. 

  596.       $oids=array_unique($oid,SORT_REGULAR);
    597. 

  597.     }
    598. 

  598.     $ooids=$oids;
    599. 

  599. 

  600.     // Liste des droits necessaires pour l'execution de la fonction
    601. 

  601.     $needed = $mod->secGroups($function);
    602. 

  602.     if(!is_array($needed)) return false;
    603. 

  603.     list($minlvl)=$needed;
    604. 

  604.     if($minlvl=='none') return array(true,1,'none');
    605. 

  605. 

  606.     // Condition SQL
    607. 

  607.     $cond='"'.implode('","',$g1).'"';
    608. 

  608. 

  609.     // Vérifie le cache statique
    610. 

  610.     $idx=$cond.$minlvl.$mod->_moid.implode('',$oids).$lang;
    611. 

  611.     if(isset(XUser::$_C81[$idx])){
    612. 

  612.       return XUser::$_C81[$idx];
    613. 

  613.     }
    614. 

  614. 

  615.     // Nombre de requete effectuée pour trouver un droit. Si à la fin du while celui ci vaut 0, c'est qu'aucune regle n'a été trouvé en base et qu'il faut donc faire jouer l'heritage
    616. 

  616.     $found=false;
    617. 

  617.     $rqs=0;
    618. 

  618.     $maxlvl=null;
    619. 

  619.     $maxlvluid='';
    620. 

  620.     $cache=true;
    621. 

  621.     $nboids=count($oids);
    622. 

  622.     $firstoid=$oids[0];
    623. 

  623.     // Si on ne demande le droit que d'un oid sur un user, on vérifié le cache SQL
    624. 

  624.     // Ce cas étant le plus courant, c'est le seul cache SQL disponible pour l'instant
    625. 

  625.     $cacheenabled=($mod->rightCacheEnabled() && $nboids==1 && self::oidIsUser($user));
    626. 

  626. 

  627.     while(($oid=array_shift($oids))!==null){
    628. 

  628.       // Vérifie si l'objet est locké ou pas
    629. 

  629.       if(!empty($GLOBALS['XLOCK']) && !empty($oid) && !in_array('ro',$needed)) {
    630. 

  630. 	$locked=$GLOBALS['XLOCK']->locked($oid, $lang);
    631. 

  631. 	if(!empty($locked) && $user!=$locked['OWN']){
    632. 

  632. 	  return array(false,1,'none');
    633. 

  633. 	}
    634. 

  634.       }
    635. 

  635. 

  636.       // Cache SQL
    637. 

  637.       if($cacheenabled){
    638. 

  638. 	XAudit::plusplus('secure8-cachesql');
    639. 

  639. 	$cache=selectQueryGetOne('select OK,AMAX from ACL4_CACHE where AFUNCTION="'.$function.'" AND AGRP="'.$user.'" and ALANG="'.$lang.'" and AMOID="'.$mod->_moid.'" AND AKOID="'.$oid.'"');
    640. 

  640. 	if($cache){
    641. 

  641. 	  XAudit::plusplus('secure8-cachesql-ok');
    642. 

  642. 	  $rqs++;
    643. 

  643. 	  $found=(bool)$cache['OK'];
    644. 

  644. 	  list($maxlvl,$maxlvluid)=explode(';',$cache['AMAX']);
    645. 

  645. 	  break;
    646. 

  646. 	}
    647. 

  647.       }
    648. 

  648. 

  649.       // On recupere toutes les regles en base ou dans le cache statique
    650. 

  650.       $idx2=$cond.$mod->_moid.$oid.$lang;
    651. 

  651.       if(!isset(XUser::$_C82[$idx2])){
    652. 

  652. 	XAudit::plusplus('secure8-query');
    653. 

  653. 	XUser::$_C82[$idx2]=selectQueryGetAll('SELECT * FROM ACL4 WHERE AGRP IN ('.$cond.')  AND AKOID="'.$oid.'" AND AMOID="'.$mod->_moid.'" AND ALANG="'.$lang.'" /* secure8 */');
    654. 

  654.       }
    655. 

  655.       $rs=&XUser::$_C82[$idx2];
    656. 

  656.       foreach($rs as &$acl){
    657. 

  657. 	$rqs++;
    658. 

  658. 	$lvl=array_search($acl['AFUNCTION'], $needed);
    659. 

  659. 	// Si on trouve une regle sur le user, elle a la priorité, on recupere le resultat et on stoppe la boucle
    660. 

  660. 	if(self::oidIsUser($acl['AGRP'])){
    661. 

  661. 	  $maxlvl=$lvl;
    662. 

  662. 	  $found=($lvl!==false);
    663. 

  663. 	  break;
    664. 

  664. 	}
    665. 

  665. 	if($lvl!==false) {
    666. 

  666. 	  $found=true;
    667. 

  667. 	}
    668. 

  668. 	// Si le niveau detecté est supérieur ou qu'il est egal sur la personne demandée (cette derniere condition est necessaire pour etre sur qu'il s'agit d'un heritage ou pas)
    669. 

  669. 	if($lvl>$maxlvl || $maxlvl===null || ($lvl==$maxlvl && $acl['AGRP']==$user)){
    670. 

  670. 	  $maxlvl=$lvl;
    671. 

  671. 	  $maxlvluid=$acl['AGRP'];
    672. 

  672. 	}
    673. 

  673.       }
    674. 

  674.       // Si une regle positive a été trouvée, pas la peine de passer à l'oid suivant
    675. 

  675.       if($found) break;
    676. 

  676.     }
    677. 

  677.     
    678. 

  678.     // Si aucune règle n'a été trouvé en base et si on est pas déjà au niveau du module (oid vide), on va tester d'enventuels parents
    679. 

  679.     if($checkparent && !$rqs && !empty($firstoid) && $mod->objectSecurityEnabled()){
    680. 

  680.       $parents=$mod->getParentsOids($ooids);
    681. 

  681.       if(!empty($parents)){
    682. 

  682. 	$res=self::secure8($function,$mod,$parents,$user,$lang);
    683. 

  683. 	$found=$res[0];
    684. 

  684. 	$rqs+=$res[1];
    685. 

  685. 	$maxlvl=$res[2];
    686. 

  686. 	$maxlvluid=$res[3];
    687. 

  687.       }
    688. 

  688.     }
    689. 

  689. 

  690.     // Recupere le niveau max de droit
    691. 

  691.     if(is_numeric($maxlvl)) $maxlvl=$needed[$maxlvl];
    692. 

  692.     elseif($maxlvl===NULL) $maxlvl='none';
    693. 

  693.     // Si la personne avec les droits les plus élevé est celle demandée à l'origine, on retourne une chaine vide pour siginifier que ce n'est pas de l'heritage
    694. 

  694.     if($maxlvluid==$user) $maxlvluid='';
    695. 

  695. 

  696.     // Si on ne demande le droit que d'un oid sur un user, on met le résultat en cache SQL
    697. 

  697.     // Va de paire avec le select ACL4_CACHE quelques lignes au dessus
    698. 

  698.     if($cacheenabled && !$cache){
    699. 

  699.       XUser::setCache($user, $function, $lang, $mod->_moid, $firstoid, $found, 'secure8', $maxlvl, $maxlvluid);
    700. 

  700.     }
    701. 

  701.     XUser::$_C81[$idx]=array($found,$rqs,$maxlvl,$maxlvluid);
    702. 

  702.     return XUser::$_C81[$idx];
    703. 

  703.   }
    704. 

  704.   static function setCache($user=null, $function, $lang=null, $moid, $oid, $ok, $comment, $maxlevel, $maxleveluid) {
    705. 

  705.     if (empty($user))
    706. 

  706.       $user = XUser::get_current_user_uid();
    707. 

  707.     if (empty($lang))
    708. 

  708.       $lang = TZR_DEFAULT_LANG;
    709. 

  709.     $aoid=substr(md5(uniqid('')),0,40);
    710. 

  710.     updateQuery('insert into ACL4_CACHE(AOID,ACOMMENT,AGRP,AFUNCTION,ALANG,AMOID,AKOID,OK,AMAX) '.
    711. 

  711.                 'values("'.$aoid.'","'.$comment.'","'.$user.'","'.$function.'","'.$lang.'",'.$moid.',"'.$oid.'",'.(int)$ok.',"'.$maxlevel.';'.$maxleveluid.'")');
    712. 

  712.   }
    713. 

  713.   
    714. 

  714.   /// retourne les oids pour lesquels des droits sont positionnées et ceux du module(clef vide)
    715. 

  715.   static function secure8oids($mod, $user=null, $lang=TZR_DEFAULT_LANG) {
    716. 

  716.     if (!$lang)
    717. 

  717.       $lang = TZR_DEFAULT_LANG;
    718. 

  718.     // Recherche de la liste des groupes/users a tester
    719. 

  719.     if (!$user) $user=XUser::get_current_user_uid();
    720. 

  720.     elseif (is_object($user)) $user=$user->_curoid;
    721. 

  721.     $g1 = XUser::sGroups($user);
    722. 

  722.     if (is_object($mod)) 
    723. 

  723.       $mod = $mod->_moid;
    724. 

  724.     $idx = "$user-$mod-$lang";
    725. 

  725.     // 
    726. 

  726.     if (!isset(XUser::$_C8OIDS[$idx])) {
    727. 

  727.       $cond='"'.implode('","',$g1).'"';
    728. 

  728.       $acls = selectQuery('SELECT AKOID, AFUNCTION, AGRP FROM ACL4 WHERE AGRP IN ('.$cond.')  AND AMOID="'.$mod.'" AND ALANG="'.$lang.'" order by AGRP desc /* secure8oids */')->fetchAll(PDO::FETCH_GROUP); // users before group
    729. 

  729.       XUser::$_C8OIDS[$idx] = $acls;
    730. 

  730.     }
    731. 

  731.     return XUser::$_C8OIDS[$idx];
    732. 

  732.   }
    733. 

  733.   
    734. 

  734.   /// Vérifie les droits sur un module/oid/user
    735. 

  735.   static function secure8oid($function, $mod, $oid=null, $user=null, $lang=TZR_DEFAULT_LANG, $checkparent=false) {
    736. 

  736.     if (!$lang)
    737. 

  737.       $lang = TZR_DEFAULT_LANG;
    738. 

  738.     if (XShell::isRoot())
    739. 

  739.       return true;
    740. 

  740.     if (is_numeric($mod)) 
    741. 

  741.       $mod = XModule::objectFactory($mod);
    742. 

  742.     $needed = $mod->secGroups($function);
    743. 

  743.     if (!is_array($needed)) 
    744. 

  744.       return false;
    745. 

  745.     list($minlvl) = $needed;
    746. 

  746.     if ($minlvl=='none') 
    747. 

  747.       return true;
    748. 

  748.     // Vérifie si l'objet est locké ou pas
    749. 

  749.     if(!empty($GLOBALS['XLOCK']) && !empty($oid) && !in_array('ro', $needed)) {
    750. 

  750.       $locked=$GLOBALS['XLOCK']->locked($oid, $lang);
    751. 

  751.       if(!empty($locked) && $user!=$locked['OWN']){
    752. 

  752.         return false;
    753. 

  753.       }
    754. 

  754.     }
    755. 

  755.     $idx = "$function-".$mod->_moid."-$oid-$user-$lang-$checkparent";
    756. 

  756.     if (isset(XUser::$_C8OID[$idx])) 
    757. 

  757.       return XUser::$_C8OID[$idx];
    758. 

  758.     $acls = XUser::secure8oids($mod, $user, $lang);
    759. 

  759.     // les règles utilisateur viennent avant celle des groupes
    760. 

  760.     foreach ($acls[$oid] as $acl) {
    761. 

  761.       $level = $acl['AFUNCTION'];
    762. 

  762.       if (in_array($level, $needed))
    763. 

  763.         return XUser::$_C8OID[$idx] = true;
    764. 

  764.       // si une règle est positionné sur l'utilisateur, elle a priorité
    765. 

  765.       if ($acl['AGRP'] == $user) 
    766. 

  766.         break;
    767. 

  767.     }
    768. 

  768.     if (!isset($acls[$oid]) && $checkparent) {
    769. 

  769.       $parents = $mod->getParentsOids(array($oid));
    770. 

  770.       foreach ($parents as $parentOid) {
    771. 

  771.         if (XUser::secure8oid($function, $mod, $parentOid, $user, $lang, $checkparent)) {
    772. 

  772.           return XUser::$_C8OID[$idx] = true;
    773. 

  773.         }
    774. 

  774.       }
    775. 

  775.     }
    776. 

  776.     // default le module
    777. 

  777.     foreach ($acls[''] as $acl) {
    778. 

  778.       $level = $acl['AFUNCTION'];
    779. 

  779.       if (in_array($level, $needed))
    780. 

  780.         return XUser::$_C8OID[$idx] = true;
    781. 

  781.       if ($acl['AGRP'] == $user)
    782. 

  782.         break;
    783. 

  783.     }
    784. 

  784.     return XUser::$_C8OID[$idx] = false;
    785. 

  785.   }
    786. 

  786. 

  787.   /// Vérifie si une methode sur une classe est accessible. Cela n'est possible que si la methode est acessible par tout le monde
    788. 

  788.   static function secure8class($class, $function){
    789. 

  789.     if(XShell::isRoot()) return true;
    790. 

  790.     $secs=call_user_func(array($class,"secGroups"),$function);
    791. 

  791.     return in_array('none',$secs);
    792. 

  792.   }
    793. 

  793. 

  794.   /// Retourne le niveau max d'accès pour un module/oid
    795. 

  795.   static function secure8maxlevel($mod, $oid='', $user=NULL, $lang=TZR_DEFAULT_LANG) {
    796. 

  796.     $sec=self::secure8(':list', $mod, $oid, $user, $lang);
    797. 

  797.     return $sec[2];
    798. 

  798.   }
    799. 

  799. 

  800.   /// Vérifie si un oid représente un user
    801. 

  801.   static function oidIsUser($oid){
    802. 

  802.     return (strpos($oid,'USERS:')===0);
    803. 

  803.   }
    804. 

  804. 

  805.   /// Teste si le user USERS:self existe
    806. 

  806.   static function selfExists() {
    807. 

  807.     static $done=false;
    808. 

  808.     static $exists=false;
    809. 

  809.     if(!$done) {
    810. 

  810.       $exists=countSelectQuery('SELECT COUNT(KOID) FROM USERS WHERE KOID="'.TZR_SELF_USER.'"');
    811. 

  811.       $done=true;
    812. 

  812.     }
    813. 

  813.     return $exists;
    814. 

  814.   }
    815. 

  815. 

  816.   /// Récupere une variable de session en base de données
    817. 

  817.   static function getDbSessionData($varname){
    818. 

  818.     static $cache=array();
    819. 

  819. 

  820.     $sessid=session_id();
    821. 

  821.     if(!$sessid) return null;
    822. 

  822.     if(!array_key_exists($varname,$cache)){
    823. 

  823.       $row=selectQueryGetOne('select value from _VARS where sessid="'.$sessid.'" and name="'.$varname.'"');
    824. 

  824.       if($row) $cache[$varname]=unserialize($row['value']);
    825. 

  825.       else return null;
    826. 

  826.     }
    827. 

  827.     return $cache[$varname];
    828. 

  828.   }
    829. 

  829.   /// Récupere une variable de cache en base de données
    830. 

  830.   static function getDbCacheData($varname){
    831. 

  831.     return self::getDBSessionData(self::DB_SESSION_CACHE_PREFIX.$varname);
    832. 

  832.   }
    833. 

  833. 

  834.   /// Ajoute/modifie une variable de session en base de données
    835. 

  835.   static function setDbSessionData($varname,$value){
    836. 

  836.     $sessid=session_id();
    837. 

  837.     if(!$sessid) return null;
    838. 

  838.     updateQuery('replace into _VARS (sessid,user,name,value) values ("'.$sessid.'","'.XUser::get_current_user_uid().'","'.$varname.'",'.$GLOBALS['TZR_DB']->quote(serialize($value)).')');
    839. 

  839.   }
    840. 

  840.   /// Ajoute/modifie une variable de cache en base de données
    841. 

  841.   static function setDbCacheData($varname,$value){
    842. 

  842.     return self::setDbSessionData(self::DB_SESSION_CACHE_PREFIX.$varname,$value);
    843. 

  843.   }
    844. 

  844. 

  845.   /// Efface une variable de session en base de données
    846. 

  846.   static function deleteDbSessionDataUPD($varname){
    847. 

  847.     $sessid=session_id();
    848. 

  848.     if(!$sessid) return null;
    849. 

  849.     updateQuery('delete from _VARS where sessid="'.$sessid.'" and name="'.$varname.'"');
    850. 

  850.   }
    851. 

  851.   /// Efface une variable de cache en base de données
    852. 

  852.   static function deleteDbCacheDataUPD($varname){
    853. 

  853.     return self::deleteDbSessionDataUPD(self::DB_SESSION_CACHE_PREFIX.$varname);
    854. 

  854.   }
    855. 

  855. 

  856.   /// Met à jour l'upd d'une variable de session en base de données
    857. 

  857.   static function updateDbSessionDataUPD($varname){
    858. 

  858.     $sessid=session_id();
    859. 

  859.     if(!$sessid) return null;
    860. 

  860.     updateQuery('update ignore _VARS set UPD=NOW() where sessid="'.$sessid.'" and name="'.$varname.'"');
    861. 

  861.   }
    862. 

  862.   /// Met à jour l'upd d'une variable de cache en base de données
    863. 

  863.   static function updateDbCacheDataUPD($varname){
    864. 

  864.     return self::updateDbSessionDataUPD(self::DB_SESSION_CACHE_PREFIX.$varname);
    865. 

  865.   }
    866. 

  866. 

  867.   /// Efface toutes les données d'une session en base de données
    868. 

  868.   static function clearDbSessionDataAndRightCache(){
    869. 

  869.     $sessid=session_id();
    870. 

  870.     if(!$sessid) return null;
    871. 

  871.     updateQuery('delete from _VARS where sessid="'.$sessid.'"');
    872. 

  872.     updateQuery('delete from ACL4_CACHE where AGRP="'.XUser::get_current_user_uid().'"');
    873. 

  873.   }
    874. 

  874. 

  875.   /// Efface toutes les données de session/cache périmées en base de données
    876. 

  876.   static function clearOldDbSessionDataAndRightCache(){
    877. 

  877.     // Efface le cache
    878. 

  878.     updateQuery('delete from _VARS where sessid is not null and name like "'.self::DB_SESSION_CACHE_PREFIX.'%" and UPD<="'.date('Y-m-d H:i:s',strtotime('-10 minutes')).'"');
    879. 

  879.     
    880. 

  880.     // Efface les sessions
    881. 

  881.     $rs=selectQuery('select sessid from _VARS where name="last_activity" and UPD<="'.date('Y-m-d H:i:s',strtotime('-'.TZR_SESSION_DURATION.' seconds')).'"');
    882. 

  882.     while($rs && $ors=$rs->fetch()){
    883. 

  883.       updateQuery('delete from _VARS where sessid="'.$ors['sessid'].'"');
    884. 

  884.     }
    885. 

  885. 

  886.     // Efface le cache des droits des users qui n'ont plus de session actives
    887. 

  887.     $rs=selectQuery('select distinct(AGRP) as AGRP from ACL4_CACHE');
    888. 

  888.     while($rs && $ors=$rs->fetch()){
    889. 

  889.       $nb=countSelectQuery('select count(*) from _VARS where name="last_activity" and user="'.$ors['AGRP'].'"');
    890. 

  890.       if(!$nb) updateQuery('delete from ACL4_CACHE where AGRP="'.$ors['AGRP'].'"');
    891. 

  891.     }
    892. 

  892.   }
    893. 

  893. }
    894. 

  894. ?>
    895. 

  895.