PageRenderTime 42ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 1ms

/class.xmodinfotree.inc

https://github.com/jcplat/console-seolan
PHP | 3241 lines | 2746 code | 202 blank | 293 comment | 486 complexity | b4262d8cd9d943f98eb8bdfea8d16a4f 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. /****c* XModule/XModInfoTree
    3. 

  3.  * NAME
    4. 

  4.  *   XModInfoTree -- gestion d'un ensemble de rubriques structurees
    5. 

  5.  * DESCRIPTION
    6. 

  6.  *   Module central de gestion d'un site internet, integrant la
    7. 

  7.  *   gestion de rubriques structurees, le rattachement d'informations
    8. 

  8.  *   a ces rubriques, ainsi que la creation de requetes.
    9. 

  9.  * SYNOPSIS
    10. 

  10.  ****/
    11. 

  11. /// Module de gestion d'un ensemble de rbriques et de pages web
    12. 

  12. class XModInfoTree extends XModule {
    13. 

  13.   public $table = 'T001';
    14. 

  14.   public $_rbrowse=NULL;
    15. 

  15.   public $cattemplate=NULL;
    16. 

  16.   public $preview='/index.php?_cachepolicy=forcecache';
    17. 

  17.   public $linkin='';
    18. 

  18.   public $urlext='';
    19. 

  19. 

  20.   /// construction de la classe gestion de rubriques
    21. 

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

  22.     parent::__construct($ar);
    23. 

  23.     XLabels::loadLabels('xmodinfotree');
    24. 

  24.     $this->_categories=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$this->table);
    25. 

  25.     $this->tname='IT'.$this->table;
    26. 

  26.     if(empty($this->_templates))
    27. 

  27.       $this->_templates=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS=TEMPLATES');
    28. 

  28.     XAlias::register($this);
    29. 

  29.   }
    30. 

  30. 

  31.   /// initialisation des options
    32. 

  32.   public function initOptions() {
    33. 

  33.     parent::initOptions();
    34. 

  34.     $this->_options->setOpt(XLabels::getSysLabel('general','table'), 'table', 'table',array('validate'=>true));
    35. 

  35.     $this->_options->setOpt(XLabels::getSysLabel('xmodinfotree','cattemplate'), 'cattemplate', 'template',
    36. 

  36. 			    array('moid'=>$this->_moid,
    37. 

  37. 				  'cond'=>"(gtype like 'categorie')"));
    38. 

  38.     $this->_options->setOpt(XLabels::getSysLabel('general','preview','text'), 'preview', 'text',NULL,'index.php?');
    39. 

  39.     $this->_options->setOpt(XLabels::getSysLabel('xmodinfotree','linkinfield','text'), 'linkin', 'field',
    40. 

  40. 			    array('compulsory'=>false),'linkin');
    41. 

  41.     $this->_options->setOpt(XLabels::getSysLabel('xmodinfotree','urlextfield','text'), 'urlext', 'field',
    42. 

  42. 			    array('compulsory'=>false),'urlext');
    43. 

  43. 

  44.     $this->_options->setOpt(XLabels::getSysLabel('xmodinfotree','odt_texttpl','text'), 'odttpltxt', 'template',
    45. 

  45. 			    array('compulsory'=>false),NULL,'ODT');
    46. 

  46.     $this->_options->setOpt(XLabels::getSysLabel('xmodinfotree','odt_texttitlefield','text'), 'odttxttitlefield', 'text', NULL, 'title','ODT');
    47. 

  47.     $this->_options->setOpt(XLabels::getSysLabel('xmodinfotree','odt_textfield','text'), 'odttxtfield', 'text', NULL, 'txt1','ODT');
    48. 

  48.     $this->_options->setOpt(XLabels::getSysLabel('xmodinfotree','odt_imagetpl','text'), 'odttplimg', 'template',
    49. 

  49. 			    array('compulsory'=>false),NULL,'ODT');
    50. 

  50.     $this->_options->setOpt(XLabels::getSysLabel('xmodinfotree','odt_imagefield','text'), 'odtimgfield', 'text', NULL,'img1','ODT');
    51. 

  51.     $this->_options->setOpt(XLabels::getSysLabel('xmodinfotree','pdf_enabled','text'), 'pdf_enabled', 'boolean', NULL,false,'PDF');
    52. 

  52.     $this->_options->setOpt(XLabels::getSysLabel('xmodinfotree','pdf_css','text'), 'pdf_css', 'text', NULL,'css/pdf.css','PDF');
    53. 

  53.     $this->_options->setOpt(XLabels::getSysLabel('xmodinfotree','pdf_css_content','text'), 'pdf_css_content', 'text', NULL,'css/page-content.css','PDF');
    54. 

  54.     $tlabel=XLabels::getSysLabel('xmodule.tracking');
    55. 

  55.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','trackchanges'),'trackchanges','boolean',NULL,NULL,$tlabel);
    56. 

  56.   }
    57. 

  57. 

  58.   /// securite des fonctions accessibles par le web
    59. 

  59.   function secGroups($function, $group=NULL) {
    60. 

  60.     $g=array('home'=>array('list','ro','rw','rwv','admin'),
    61. 

  61. 	     'procHome'=>array('rw','rwv','admin'),
    62. 

  62. 	     'rss'=>array('ro','rw','rwv','admin'),
    63. 

  63. 	     'viewpage'=>array('ro','rw','rwv','admin'),
    64. 

  64. 	     'viewsection'=>array('ro','rw','rwv','admin'),
    65. 

  65. 	     'procQuery'=>array('ro','rw','rwv','admin'),
    66. 

  66. 	     'query'=>array('ro','rw','rwv','admin'),
    67. 

  67. 	     'browse'=>array('ro','rw','rwv','admin'),
    68. 

  68. 	     'input'=>array('rw','rwv','admin'),
    69. 

  69. 	     'procInput'=>array('rw','rwv','admin'),
    70. 

  70. 	     'addSection'=>array('rw','rwv','admin'),
    71. 

  71. 	     'newsection'=>array('rw','rwv','admin'),
    72. 

  72. 	     'insertsection'=>array('rw','rwv','admin'),
    73. 

  73. 	     'editsection'=>array('rw','rwv','admin'),
    74. 

  74. 	     'savesection'=>array('rw','rwv','admin'),
    75. 

  75. 	     'newfunction'=>array('rw','rwv','admin'),
    76. 

  76. 	     'insertfunction'=>array('rw','rwv','admin'),
    77. 

  77. 	     'editfunction'=>array('rw','rwv','admin'),
    78. 

  78. 	     'savefunction'=>array('rw','rwv','admin'),
    79. 

  79. 	     'insertquery'=>array('rw','rwv','admin'),
    80. 

  80. 	     'editquery'=>array('rw','rwv','admin'),
    81. 

  81. 	     'savequery'=>array('rw','rwv','admin'),
    82. 

  82. 	     'delSection'=>array('rw','rwv','admin'),
    83. 

  83. 	     'editpage'=>array('rw','rwv','admin'),
    84. 

  84. 	     'delCat'=>array('rw','rwv','admin'),
    85. 

  85. 	     'dupCat'=>array('rw','rwv','admin'),
    86. 

  86. 	     'procEdit'=>array('rw','rwv','admin'),
    87. 

  87. 	     'procEditAllLang'=>array('rw','rwv','admin'),
    88. 

  88. 	     'editCat'=>array('rw','rwv','admin'),
    89. 

  89. 	     'moveCat'=>array('rw','rwv','admin'),
    90. 

  90. 	     'moveSection'=>array('rw','rwv','admin'),
    91. 

  91. 	     'moveSelectedCat'=>array('rw','rwv','admin'),
    92. 

  92. 	     'moveToTrash'=>array('rw','rwv','admin'),
    93. 

  93. 	     'displayImage'=>array('rw','rwv','admin'),
    94. 

  94. 	     'displaysection'=>array('ro','rw','rwv','admin'),
    95. 

  95. 	     'dupsection'=>array('rw','rwv','admin'),
    96. 

  96. 	     'publishCat'=>array('rwv','admin'),
    97. 

  97. 	     'subscribe'=>array('ro','rw','rwv','admin'),
    98. 

  98. 	     'preSubscribe'=>array('ro','rw','rwv','admin'),
    99. 

  99. 	     'export'=>array('ro','rw','rwv','admin'),
    100. 

  100. 	     'exportPdf'=>array('ro','rw','rwv','admin'),
    101. 

  101. 	     'publish'=>array('rwv','admin'),
    102. 

  102. 	     'preImportFromODT'=>array('rw','rwv','admin'),
    103. 

  103. 	     'importFromODT'=>array('rw','rwv','admin'),
    104. 

  104. 	     'adminNewSection'=>array('rw','rwv','admin'),
    105. 

  105. 	     'adminProcNewSection'=>array('rw','rwv','admin'));
    106. 

  106.     if(isset($g[$function])) {
    107. 

  107.       if(!empty($group)) return in_array($group, $g[$function]);
    108. 

  108.       else return $g[$function];
    109. 

  109.     }
    110. 

  110.     return parent::secGroups($function,$group);
    111. 

  111.   }
    112. 

  112. 

  113.   /// Action principale du menu
    114. 

  114.   public function getMainAction(){
    115. 

  115.     return $GLOBALS['TZR_SESSION_MANAGER']::complete_self().'moid='.$this->_moid.'&function=home&tplentry=mit&template=xmodinfotree/index.html';
    116. 

  116.   }
    117. 

  117. 

  118. 

  119.   /// list des tables dont on souhaite tracer les modifications
    120. 

  120.   function tablesToTrack() {
    121. 

  121.     $ret=array();
    122. 

  122.     if($this->trackchanges) {
    123. 

  123.       $tabs=selectQueryGetAll('SELECT DISTINCT tab FROM TEMPLATES WHERE modid=\''.$this->_moid.'\'');
    124. 

  124.       $ret=array($this->table);
    125. 

  125.       foreach($tabs as $tab) {
    126. 

  126. 	$ret[]=$tab['tab'];
    127. 

  127.       }
    128. 

  128.     }
    129. 

  129.     return $ret;
    130. 

  130.   }
    131. 

  131. 

  132.   /// Prepare l'ajout d'une nouvelle section function
    133. 

  133.   public function newfunction($ar=NULL){
    134. 

  134.     $p=new XParam($ar,NULL);
    135. 

  135.     $tplentry=$p->get('tplentry');
    136. 

  136.     $oidit=$p->get('oidit');
    137. 

  137.     $oidtpl=$p->get('oidtpl');
    138. 

  138.     $lang=XShell::getLangData();
    139. 

  139.     $tabletpl=Kernel::getTable($oidtpl);
    140. 

  140.     $rs=selectQuery('select * from '.$tabletpl.' where KOID="'.$oidtpl.'" AND LANG="'.$lang.'"');
    141. 

  141.     if($rs && $o1=$rs->fetch()) {
    142. 

  142.       $tabledst=$o1['tab'];
    143. 

  143.       // Infos d'affichage du template
    144. 

  144.       $template = $this->_disp2Template($oidtpl);
    145. 

  145.       $s['_tp'] = $template;
    146. 

  146. 

  147.       $s['section']=$p->get('section');
    148. 

  148.       $s['position']=$p->get('position');
    149. 

  149.       $s['oidit']=$p->get('oidit');
    150. 

  150.       $s['oidtpl']=$p->get('oidtpl');
    151. 

  151.       $moid=$s['section']['moid'];
    152. 

  152.       $f=$s['section']['function'];
    153. 

  153.       $pf='UIParam_'.$f;
    154. 

  154.       $ef='UIEdit_'.$f;
    155. 

  155.       $m=XModule::objectFactory($moid);
    156. 

  156.       if(method_exists($m,$ef)) $ret=$m->$ef();
    157. 

  157.       else{
    158. 

  158. 	$desc=$m->$pf();
    159. 

  159. 	$ret=array('fields_object'=>array());
    160. 

  160. 	foreach($desc as $fn=>&$f){
    161. 

  161. 	  $o=$desc[$fn]->edit();
    162. 

  162. 	  $ret['o'.$fn]=$ret['fields_object'][]=$o;
    163. 

  163. 	}
    164. 

  164.       }
    165. 

  165.       $this->editTemplateOptions($ret, $oidtpl, $s['oidit']);
    166. 

  166.       $groups=array();
    167. 

  167.       foreach($ret as $n=>&$v) {
    168. 

  168. 	if(!is_object($v) || !is_object($v->fielddef)) continue;
    169. 

  169. 	if(empty($v->fielddef->fgroup)) $v->fielddef->fgroup='General';
    170. 

  170. 	$groups[$v->fielddef->fgroup][]=&$v;
    171. 

  171.       }
    172. 

  172.       ksort($groups);
    173. 

  173.       if(count($groups)>1) $ret['_groups']=$groups;
    174. 

  174.       $s['olines'][]=$ret;
    175. 

  175.       XShell::toScreen1($tplentry,$s);
    176. 

  176.     }
    177. 

  177.   }
    178. 

  178. 

  179.   /// Duplication d'un module, méthode interne
    180. 

  180.   /// Retour : duplicatetables => liste des tables dupliquées par le module (cle : ancienne table, valeur : nouvelle table))
    181. 

  181.   /// Retour : duplicatemods => liste des modules dupliqués par le module (cle : ancien moid, valeur : nouveau moid))
    182. 

  182.   function _duplicateModule($newmoid,&$params,$prefix) {
    183. 

  183.     if(!is_array($params['tables'])) $params['tables']=array();
    184. 

  184.     if(!$params['noduplicatetable']){
    185. 

  185.       // duplication de la table des rubriques
    186. 

  186.       if(empty($params['tables'][$this->table])){
    187. 

  187. 	$ar['newtable']=XDSTable::newTableNumber();
    188. 

  188. 	$xset = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$this->table);
    189. 

  189. 	if(($pos=strpos($xset->getLabel(),':'))!==false) $ar['mtxt']=$prefix.substr($xset->getLabel(),$pos);
    190. 

  190. 	else $ar['mtxt']=$prefix.':'.$xset->getLabel();
    191. 

  191. 	$ar['data']=false;
    192. 

  192. 	$ar['_options']=array('local'=>1);
    193. 

  193. 	$xset2=$xset->procDuplicateDataSource($ar);
    194. 

  194. 	// correction du lien vers la rubrique mere
    195. 

  195. 	$xset21=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$ar['newtable']);
    196. 

  196. 	$xset21->procEditField(array('field'=>'linkup','table'=>$newtable,'_todo'=>'save','target'=>$ar['newtable'],
    197. 

  197. 			    'published'=>'off','queryable'=>'on','browsable'=>'on','compulsory'=>'off','translatable'=>'off',
    198. 

  198. 			    'options'=>array('comment'=>array('FR'=>'Rubrique mere'))));
    199. 

  199. 	$params['table']=$ar['newtable'];
    200. 

  200.       }else{
    201. 

  201. 	$params['table']=$params['tables'][$this->table];
    202. 

  202.       }
    203. 

  203.       // creation de la table des liens
    204. 

  204.       XModInfoTreeWd::createLinkStructure($params['table']);
    205. 

  205. 

  206.       // duplication des mises en page/gabarits
    207. 

  207.       $rs=selectQuery('SELECT KOID FROM TEMPLATES WHERE modid =\''.$this->_moid.'\'');
    208. 

  208.       $xset = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS=TEMPLATES');
    209. 

  209.       while($rs && $ors=$rs->fetch()) {
    210. 

  210. 	$ardup=array('_options'=>array('local'=>1));
    211. 

  211. 	$ardup['oid']=$ors['KOID'];
    212. 

  212. 	$nkoid=$xset->duplicate($ardup);
    213. 

  213. 	preparedUpdateQuery('UPDATE TEMPLATES set modid=? where KOID=?',array($newmoid,$nkoid));
    214. 

  214.       }
    215. 

  215.     }
    216. 

  216.     unset($params['noduplicatetable']);
    217. 

  217.     return array('duplicatetables'=>array($this->table=>$params['table']),'duplicatemods'=>array());
    218. 

  218.   }
    219. 

  219. 

  220.   /// Enregistre une section de type fonction
    221. 

  221.   public function insertfunction($ar=NULL){
    222. 

  222.     $p=new XParam($ar,NULL);
    223. 

  223.     $oidit=$p->get('oidit');
    224. 

  224.     $oidtpl=$p->get('oidtpl');
    225. 

  225.     $position=$p->get('position')+1;
    226. 

  226.     $section=$p->get('section');
    227. 

  227.     $moid=$section['moid'];
    228. 

  228.     $f=$section['function'];
    229. 

  229.     $pf='UIParam_'.$f;
    230. 

  230.     $ef='UIProcEdit_'.$f;
    231. 

  231.     $m=XModule::objectFactory($moid);
    232. 

  232.     if(method_exists($m,$ef)){
    233. 

  233.       $ret=$m->$ef($ar);
    234. 

  234.       if($ret) $section=array_merge($section,$ret);
    235. 

  235.     }else{
    236. 

  236.       $desc=$m->$pf();
    237. 

  237.       $options=array('_track'=>false);
    238. 

  238.       foreach($desc as $fn=>&$f){
    239. 

  239. 	$value=$p->get($fn);
    240. 

  240. 	$value_hid=$p->get($fn.'_HID');
    241. 

  241. 	$options[$fn.'_HID']=$value_hid;
    242. 

  242. 	$o=$desc[$fn]->post_edit($value,$options);
    243. 

  243. 	if($f->multivalued && $f->get_fgender()=='Oid' && is_array($o->raw)){
    244. 

  244. 	  $o->raw=implode('||',$o->raw);
    245. 

  245. 	}
    246. 

  246. 	$section[$fn]=$o->raw;
    247. 

  247.       }
    248. 

  248.     }
    249. 

  249.     $val=addslashes(serialize($section));
    250. 

  250.     $nitoid=self::newItOid();
    251. 

  251.     updateQuery("UPDATE ".$this->tname." SET ORDER1=ORDER1+1 where KOIDSRC='$oidit' ".
    252. 

  252.                 " AND ORDER1 >= $position");
    253. 

  253.     updateQuery('INSERT INTO '.$this->tname.' SET KOIDSRC="'.$oidit.'",KOIDDST="",KOIDTPL="'.$oidtpl.'",ORDER1="'.$position.'",'.
    254. 

  254. 		'QUERY="'.$val.'",ITOID="'.$nitoid.'"');
    255. 

  255.     return $nitoid;
    256. 

  256.   }
    257. 

  257. 

  258.   /// Prépare l'edition d'une section fonction
    259. 

  259.   function editfunction($ar=NULL){
    260. 

  260.     $p=new XParam($ar,NULL);
    261. 

  261.     $tplentry=$p->get('tplentry');
    262. 

  262.     $oidit=$p->get('oidit');
    263. 

  263.     $oidsection=$p->get('oidsection');
    264. 

  264.     list($oidit,$oiddest,$oidtemplate)=$this->_getOids($oidsection);
    265. 

  265.     $rs=selectQuery('select * from '.$this->tname.' where ITOID="'.$oidsection.'"');
    266. 

  266.     if(!$ors=$rs->fetch()) return array();
    267. 

  267.     $params=unserialize($ors['QUERY']);
    268. 

  268.     $s=array();
    269. 

  269.     $template = $this->_disp2Template($oidtemplate);
    270. 

  270.     $s['_tp'] = $template;
    271. 

  271.     $s['oidit']=$oidit;
    272. 

  272.     $s['oidsection']=$oidsection;
    273. 

  273.     $s['section']=$params;
    274. 

  274.     $moid=$params['moid'];
    275. 

  275.     $f=$params['function'];
    276. 

  276.     $pf='UIParam_'.$f;
    277. 

  277.     $ef='UIEdit_'.$f;
    278. 

  278.     $m=XModule::objectFactory($moid);
    279. 

  279.     if(method_exists($m,$ef)) $ret=$m->$ef($params);
    280. 

  280.     else{
    281. 

  281.       $desc=$m->$pf();
    282. 

  282.       $ret=array('fields_object'=>array());
    283. 

  283.       foreach($desc as $fn=>&$f){
    284. 

  284. 	$o=$f->edit($params[$fn]);
    285. 

  285. 	$ret['o'.$fn]=$ret['fields_object'][]=$o;
    286. 

  286.       }
    287. 

  287.     }
    288. 

  288.     $this->editTemplateOptions($ret, $oidtemplate, $s['oidsection'], $params);
    289. 

  289.     $groups=array();
    290. 

  290.     foreach($ret as $n=>&$v) {
    291. 

  291.       if(!is_object($v) || !is_object($v->fielddef)) continue;
    292. 

  292.       if(empty($v->fielddef->fgroup)) $v->fielddef->fgroup='General';
    293. 

  293.       $groups[$v->fielddef->fgroup][]=&$v;
    294. 

  294.     }
    295. 

  295.     ksort($groups);
    296. 

  296.     if(count($groups)>1) $ret['_groups']=$groups;
    297. 

  297.     $s['olines'][]=$ret;
    298. 

  298.     return XShell::toScreen1($tplentry,$s);
    299. 

  299.   }
    300. 

  300. 

  301.   /**
    302. 

  302.    * Ajoute les options du template à l'interface d'édition de la section fonction
    303. 

  303.    * @param &$ret array Tableau de valeurs disponible dans le template
    304. 

  304.    * @param $oid_template string KOID du template
    305. 

  305.    * @param $id_section string Identifiant unique de la section
    306. 

  306.    * @param $params array Tableau de valeurs des options du template
    307. 

  307.    */
    308. 

  308.   public function editTemplateOptions(&$ret, $oid_template, $id_section, $params = null) {
    309. 

  309.     // Récupère les options liées au TEMPLATE de mise en page
    310. 

  310.     $options_values = (object) null;
    311. 

  311.     $xoptions = $this->getTemplateOptions($oid_template, $id_section, $options_values);
    312. 

  312.     if (!is_null($xoptions)) {
    313. 

  313.       $template_options = $xoptions->getValues($options_values);
    314. 

  314.       foreach ($template_options as $option_id => $option) {
    315. 

  315. 	$xoptions->set($options_values, $option_id, $params['_tploptions'][$option_id]);
    316. 

  316.       }
    317. 

  317.       $user_module_access_levels = current(XUser::getObjectAccess($this->_moid));
    318. 

  318.       $level = in_array('admin', $user_module_access_levels) ? 'admin' : 'none';
    319. 

  319.       $ret['_tploptions'] = $xoptions->getDialog($options_values, $params['_tploptions'], '_tploptions', $level);
    320. 

  320.     }
    321. 

  321.   }
    322. 

  322. 

  323.   /** 
    324. 

  324.    * Envoi un tableau des options disponibles pour le template
    325. 

  325.    * @param $oid_template string KOID du template
    326. 

  326.    * @param $id_section string Identifiant unique de la section
    327. 

  327.    * @param $options_values array Tableau de valeurs des options du template
    328. 

  328.    * @return XOptions Objet contenant les options du template / null si inexistant
    329. 

  329.    */
    330. 

  330.   public function getTemplateOptions($oid_template, $id_section, &$options_values) {
    331. 

  331.     $template = $this->_templates->rDisplay($oid_template);
    332. 

  332.     if (empty($template['oopts']->raw)) {
    333. 

  333.       return null;
    334. 

  334.     }
    335. 

  335.     $xopts = new XOptions($id_section);
    336. 

  336.     $xopts->setOptsFromXML($options_values, $template['oopts']->raw);
    337. 

  337.     return $xopts;
    338. 

  338.   }
    339. 

  339. 

  340.   /// Enregistre une section de type fonction
    341. 

  341.   public function savefunction($ar=NULL){
    342. 

  342.     $p=new XParam($ar,NULL);
    343. 

  343.     $oidit=$p->get('oidit');
    344. 

  344.     $oidtpl=$p->get('oidtpl');
    345. 

  345.     $oidsection=$p->get('oidsection');
    346. 

  346.     $section=$p->get('section');
    347. 

  347.     $moid=$section['moid'];
    348. 

  348.     $f=$section['function'];
    349. 

  349.     $pf='UIParam_'.$f;
    350. 

  350.     $ef='UIProcEdit_'.$f;
    351. 

  351.     $m=XModule::objectFactory($moid);
    352. 

  352.     if(method_exists($m,$ef)){
    353. 

  353.       $ret=$m->$ef($ar);
    354. 

  354.       if($ret) $section=array_merge($section,$ret);
    355. 

  355.     }else{
    356. 

  356.       $desc=$m->$pf();
    357. 

  357.       $options=array('_track'=>false);
    358. 

  358.       foreach($desc as $fn=>&$f){
    359. 

  359. 	$value=$p->get($fn);
    360. 

  360. 	$value_hid=$p->get($fn.'_HID');
    361. 

  361. 	$options[$fn.'_HID']=$value_hid;
    362. 

  362. 	$o=$desc[$fn]->post_edit($value,$options);
    363. 

  363. 	if($f->multivalued && $f->get_fgender()=='Oid' && is_array($o->raw)){
    364. 

  364. 	  $o->raw=implode('||',$o->raw);
    365. 

  365. 	}
    366. 

  366. 	$section[$fn]=$o->raw;
    367. 

  367.       }
    368. 

  368.     }
    369. 

  369.     $section['_tploptions'] = $p->get('_tploptions');
    370. 

  370.     $val=addslashes(serialize($section));
    371. 

  371.     updateQuery('UPDATE '.$this->tname.' SET KOIDSRC="'.$oidit.'",KOIDDST="",QUERY="'.$val.'" where ITOID="'.$oidsection.'"');
    372. 

  372.     return $oidsection;
    373. 

  373.   }
    374. 

  374. 

  375.   /// Prepare l'ajout d'une section dans l'administration a partir d'une page donnee
    376. 

  376.   function adminNewSection($ar=NULL){
    377. 

  377.     $p=new XParam($ar,NULL);
    378. 

  378.     $tplentry=$p->get('tplentry');
    379. 

  379.     $newrub=$p->get('newrub');
    380. 

  380.     $fct=$p->get('fct');
    381. 

  381.     $r=array();
    382. 

  382.     if($newrub) $this->_categories->input(array('tplentry'=>$tplentry.'rub'));
    383. 

  383.     $xds=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS=CS8SEC');
    384. 

  384.     $xds->input(array('tplentry'=>$tplentry.'sec'));
    385. 

  385.     $this->home(array('tplentry'=>$tplentry.'tree','maxlevel'=>1,'norubric'=>true));
    386. 

  386.     $fct=XModUser2::_normalizeBookmark($fct);
    387. 

  387.     $r['fct']=$fct;
    388. 

  388.     parse_str($fct,$infos);
    389. 

  389.     $f=$infos['_function']?$infos['_function']:$infos['function'];
    390. 

  390.     if($infos['moid'] && ($f=='procQuery' || $f=='browse')){
    391. 

  391.       $mod=XModule::objectFactory($infos['moid']);
    392. 

  392.       if($mod->persistentquery){
    393. 

  393. 	$r['persistent']=1;
    394. 

  394.       }
    395. 

  395.     }
    396. 

  396.     return XShell::toScreen1($tplentry,$r);
    397. 

  397.   }
    398. 

  398. 

  399.   /// Ajoute une section dans l'administration
    400. 

  400.   function adminProcNewSection($ar=NULL){
    401. 

  401.     $p=new XParam($ar,NULL);
    402. 

  402.     $linkup=$p->get('linkup');
    403. 

  403.     $createrub=$p->get('createrub');
    404. 

  404.     if($createrub){
    405. 

  405.       $rub=$this->procInput($ar);
    406. 

  406.       $linkup=$rub['oid'];
    407. 

  407.     }
    408. 

  408.     $ar2=$p->get('sec');
    409. 

  409.     $ar2['fct']=XModUser2::_normalizeBookmark($ar2['fct']);
    410. 

  410.     $ar2['oidit']=$linkup;
    411. 

  411.     $ar2['oidtpl']='TEMPLATES:ADMIN-'.$this->_moid;
    412. 

  412.     if(!empty($ar2['persistent'])) $ar2['fct'].='&_persistent=1';
    413. 

  413.     $this->insertsection($ar2);
    414. 

  414.   }
    415. 

  415. 

  416.   /// Liste des actions générale du module
    417. 

  417.   protected function _actionlist(&$my) {
    418. 

  418.     parent::_actionlist($my);
    419. 

  419.     $myoid=@$_REQUEST['oidit'];
    420. 

  420.     $moid=$this->_moid;
    421. 

  421.     // Arbo
    422. 

  422.     $o1=new XModuleAction($this,'home',XLabels::getSysLabel('xmodinfotree','see_categories'),
    423. 

  423. 			  '&moid='.$moid.'&_function=home&template=xmodinfotree/index.html&tplentry=mit','display');
    424. 

  424.     $o1->setToolbar('general','browse');
    425. 

  425.     $my['home']=$o1;
    426. 

  426.     // Poubelle
    427. 

  427.     $o1=new XModuleAction($this,'trash',XLabels::getSysLabel('xmodinfotree','see_trash'),
    428. 

  428. 			  '&moid='.$moid.'&_function=home&template=xmodinfotree/index.html&tplentry=mit&aliastop=trash','display');
    429. 

  429.     $o1->setToolbar('general','trash');
    430. 

  430.     $my['trash']=$o1;
    431. 

  431.     // Recherche
    432. 

  432.     $o1=new XModuleAction($this,'home',XLabels::getSysLabel('general','query','text'),
    433. 

  433. 			  '&moid='.$moid.'&_function=query&template=xmodinfotree/query.html&tplentry=br','display');
    434. 

  434.     $o1->setToolbar('general','query');
    435. 

  435.     $my['query']=$o1;
    436. 

  436.     // Pile
    437. 

  437.     if($this->interactive)  {
    438. 

  438.       $o1=new XModuleAction($this,'in',$this->modulename,
    439. 

  439. 			    '&moid='.$this->_moid.'&_function=home&template=xmodinfotree/index.html&tplentry=mit');
    440. 

  440.       $my['stack'][]=$o1;
    441. 

  441.       if (!empty($myoid)) {
    442. 

  442.         $nav=$this->getPath($myoid);
    443. 

  443.         foreach($nav['oiddown'] as $i=>$oid) {
    444. 

  444.           $o1=new XModuleAction($this,'i'.$i,$nav['labeldown'][$i],
    445. 

  445.                                 '&moid='.$this->_moid.'&_function=editpage&template=xmodinfotree/viewpage.html&tplentry=it&oidit='.$oid);
    446. 

  446.           $my['stack'][]=$o1;
    447. 

  447.         }
    448. 

  448.       }
    449. 

  449.       if(XShell::_function()=='editCat'){
    450. 

  450. 	$br=&XShell::from_screen('editcat');
    451. 

  451. 	$br=&$this->_categories->rDisplayText($br['oid'],array());
    452. 

  452. 	$o1=new XModuleAction($this,'view',$br['link'],'&moid='.$this->_moid.'&_function=editpage&template=xmodinfotree/viewpage.html&tplentry=it&oidit='.$br['oid']);
    453. 

  453. 	$my['stack'][]=$o1;
    454. 

  454.       }
    455. 

  455.       $modsubmoid=XModule::getMoid(XMODSUB_TOID);
    456. 

  456.       if(!empty($modsubmoid)){
    457. 

  457. 	$o1=new XModuleAction($this,'subscribe',XLabels::getSysLabel('xmodsub','subadd','text'),
    458. 

  458. 			      '&moid='.$this->_moid.'&oid='.$myoid.'&_function=preSubscribe&tplentry=br&template=xmodinfotree/sub.html',
    459. 

  459. 			      'more');
    460. 

  460. 	$o1->menuable=true;
    461. 

  461. 	$my['subscribe']=$o1;
    462. 

  462.       }
    463. 

  463.       if($this->odttpltxt && $this->odttplimg && $this->secure(NULL,'importFromODT')){
    464. 

  464. 	$o1=new XModuleAction($this,'odtimport',XLabels::getSysLabel('xmodinfotree','odt_import','text'),
    465. 

  465. 			      '&moid='.$this->_moid.'&function=preImportFromODT&template=xmodinfotree/preImportFromODT.html&oidit='.$oid,'edit');
    466. 

  466. 	$o1->menuable=true;
    467. 

  467. 	$my['odtimport']=$o1;
    468. 

  468.       }
    469. 

  469.     }
    470. 

  470.   }
    471. 

  471. 

  472.   /// Actions spécifique à "home"
    473. 

  473.   function al_home(&$my){
    474. 

  474.     $uniqid='v'.XShell::uniqid();
    475. 

  475.     $o1=new XModuleAction($this,'foldall',XLabels::getSysLabel('xmodinfotree','fold_all','text'),
    476. 

  476. 			  '&function=home&template=xmodinfotree/index.html&moid='.$this->_moid.'&do=foldall&tplentry=mit','display');
    477. 

  477.     $o1->menuable=true;
    478. 

  478.     $my['foldall']=$o1;
    479. 

  479.     $o1=new XModuleAction($this,'unfoldall',XLabels::getSysLabel('xmodinfotree','unfold_all','text'),
    480. 

  480. 			  '&function=home&template=xmodinfotree/index.html&moid='.$this->_moid.'&do=unfoldall&tplentry=mit','display');
    481. 

  481.     $o1->menuable=true;
    482. 

  482.     $my['unfoldall']=$o1;
    483. 

  483.     if($this->secure(NULL,'input')){
    484. 

  484.       $o1=new XModuleAction($this,'input',XLabels::getSysLabel('xmodinfotree','add_subtree','text'),
    485. 

  485. 			    '&moid='.$this->_moid.'&function=input&template=xmodinfotree/new.html&linkup=','edit');
    486. 

  486.       $o1->setToolbar('general','new');
    487. 

  487.       $my['input']=$o1;
    488. 

  488.     }
    489. 

  489.     // Publier/dépulier
    490. 

  490.     if($this->_categories->fieldExists('PUBLISH') && $this->secure(NULL,':rwv')){
    491. 

  491.       $o1=new XModuleAction($this,'publish',XLabels::getSysLabel('general','approve','text'),
    492. 

  492. 			    'javascript:'.$uniqid.'.publishSelected(true);','edit');
    493. 

  493.       $o1->menuable=true;
    494. 

  494.       $my['publish']=$o1;
    495. 

  495.       $o1=new XModuleAction($this,'publish',XLabels::getSysLabel('general','unapprove','text'),
    496. 

  496. 			    'javascript:'.$uniqid.'.publishSelected(false);','edit');
    497. 

  497.       $o1->menuable=true;
    498. 

  498.       $my['unpublish']=$o1;
    499. 

  499.     }
    500. 

  500.     // Supprimer
    501. 

  501.     if($this->secure(NULL,'moveToTrash')){
    502. 

  502.       $o1=new XModuleAction($this,'del',XLabels::getSysLabel('general','delete','text'),
    503. 

  503. 			    'javascript:'.$uniqid.'.deleteselected();','edit');
    504. 

  504.       $o1->setToolbar('general','delete');
    505. 

  505.       $my['del']=$o1;
    506. 

  506.     }
    507. 

  507.     // Deplacer
    508. 

  508.     if($this->secure(NULL,'moveCat')){
    509. 

  509.       $o1=new XModuleAction($this,'move',XLabels::getSysLabel('general','move','text'),
    510. 

  510. 			    'javascript:'.$uniqid.'.moveselected();','edit');
    511. 

  511.       $o1->menuable=true;
    512. 

  512.       $my['move']=$o1;
    513. 

  513.     }
    514. 

  514.     // Dupliquer
    515. 

  515.     if($this->secure(NULL,'dupCat')){
    516. 

  516.       $o1=new XModuleAction($this,'dup',XLabels::getSysLabel('general','clone','text'),
    517. 

  517. 			    'javascript:'.$uniqid.'.duplicateselected();','edit');
    518. 

  518.       $o1->menuable=true;
    519. 

  519.       $my['dup']=$o1;
    520. 

  520.     }
    521. 

  521.     // Exporter
    522. 

  522.     if($this->secure(NULL,'export')){
    523. 

  523.       $o1=new XModuleAction($this,'export',XLabels::getSysLabel('general','export','text'),
    524. 

  524. 			    'javascript:'.$uniqid.'.exportselected();','edit');
    525. 

  525.       $o1->menuable=true;
    526. 

  526.       $my['exp']=$o1;
    527. 

  527.     }
    528. 

  528.   }
    529. 

  529.   /// Actions spécifique à "viewpage"
    530. 

  530.   function al_viewpage(&$my){
    531. 

  531.     $uniqid='v'.XShell::uniqid();
    532. 

  532.     $oid=$_REQUEST['oidit'];
    533. 

  533.     // Navigation
    534. 

  534.     $o1=new XModuleAction($this,'nav',XLabels::getSysLabel('general','navigation','text'),'#');
    535. 

  535.     $o1->menuable=true;
    536. 

  536.     $o1->newgroup='nav';
    537. 

  537.     $my['nav']=$o1;
    538. 

  538.     $o1=new XModuleAction($this,'navall',XLabels::getSysLabel('xmodinfotree','treebrowser','text'),
    539. 

  539. 			  'javascript:TZR.openPopup("'.$GLOBALS['TZR_SESSION_MANAGER']::complete_self().'function=home&template=xmodinfotree/popaction.html'.
    540. 

  540. 			  '&_skip=1&moid='.$this->_moid.'&_raw=1&maxlevel=1&oid='.$oid.'&tplentry=mit&do=add&'.
    541. 

  541. 			  '&norubric=1&action=go&moduleid='.XShell::uniqid().'");','nav');
    542. 

  542.     $o1->menuable=true;
    543. 

  543.     $my['navall']=$o1;
    544. 

  544.     $it=&XShell::from_screen('it');
    545. 

  545.     $nav=&$it['nav'];
    546. 

  546.     if($nav['up']){
    547. 

  547.       $o1=new XModuleAction($this,'navup',$nav['up']['otitle']->html,'javascript:'.$uniqid.'.gopage("'.$nav['up']['oid'].'");','nav');
    548. 

  548.       $o1->menuable=true;
    549. 

  549.       $my['navup']=$o1;
    550. 

  550.     }
    551. 

  551.     if(!empty($nav['prev'])){
    552. 

  552.       $o1=new XModuleAction($this,'navprev',$nav['prev']['otitle']->html,'javascript:'.$uniqid.'.gopage("'.$nav['prev']['oid'].'");',
    553. 

  553. 			    'nav');
    554. 

  554.       $o1->menuable=true;
    555. 

  555.       $my['navprev']=$o1;
    556. 

  556.     }
    557. 

  557.     if(!empty($nav['next'])){
    558. 

  558.       $o1=new XModuleAction($this,'navnext',$nav['next']['otitle']->html,'javascript:'.$uniqid.'.gopage("'.$nav['next']['oid'].'");',
    559. 

  559. 			    'nav');
    560. 

  560.       $o1->menuable=true;
    561. 

  561.       $my['navnext']=$o1;
    562. 

  562.     }
    563. 

  563.     $rubs=&XShell::from_screen('ssrubs');
    564. 

  564.     foreach($rubs['lines_oid'] as $i=>$roid){
    565. 

  565.       $o1=new XModuleAction($this,'navssrub'.$i,$rubs['lines_otitle'][$i]->html,'javascript:'.$uniqid.'.gopage("'.$roid.'");','nav');
    566. 

  566.       $o1->menuable=true;
    567. 

  567.       $my['navssrub'.$i]=$o1;
    568. 

  568.     }
    569. 

  569. 

  570.     // Prévisualisation
    571. 

  571.     if($this->preview){
    572. 

  572.       $o1=new XModuleAction($this,'view',XLabels::getSysLabel('general','view','text'),
    573. 

  573. 			    $this->preview.'&_lang='.XShell::getLangData().'&oidit='.$oid.'&nocache=1','edit');
    574. 

  574.       $o1->target='_blank';
    575. 

  575.       $o1->setToolbar('general','view');
    576. 

  576.       $my['view']=$o1;
    577. 

  577.     }
    578. 

  578.     // Publier/dépulier
    579. 

  579.     if($this->secure($oid,':rwv')){
    580. 

  580.       $it=XShell::from_screen('it');
    581. 

  581.       $publish=false;
    582. 

  582.       foreach($it['olines'] as $i=>$s){
    583. 

  583. 	if(isset($s['oPUBLISH'])){
    584. 

  584. 	  $publish=true;
    585. 

  585. 	  break;
    586. 

  586. 	}
    587. 

  587.       }
    588. 

  588.       if($publish){
    589. 

  589. 	$o1=new XModuleAction($this,'publish',XLabels::getSysLabel('general','approve','text'),
    590. 

  590. 			      'javascript:'.$uniqid.'.publishSelected(true);','edit');
    591. 

  591. 	$o1->menuable=true;
    592. 

  592. 	$my['publish']=$o1;
    593. 

  593. 	$o1=new XModuleAction($this,'publish',XLabels::getSysLabel('general','unapprove','text'),
    594. 

  594. 			      'javascript:'.$uniqid.'.publishSelected(false);','edit');
    595. 

  595. 	$o1->menuable=true;
    596. 

  596. 	$my['unpublish']=$o1;
    597. 

  597.       }
    598. 

  598.     }
    599. 

  599.     // Supprimer
    600. 

  600.     if($this->secure($oid,'delSection')){
    601. 

  601.       $o1=new XModuleAction($this,'del',XLabels::getSysLabel('general','delete','text'),
    602. 

  602. 			    'javascript:'.$uniqid.'.deleteselected();','edit');
    603. 

  603.       $o1->menuable=true;
    604. 

  604.       $my['del']=$o1;
    605. 

  605.     }
    606. 

  606.     // Deplacer
    607. 

  607.     if($this->secure($oid,'moveSection')){
    608. 

  608.       $o1=new XModuleAction($this,'move',XLabels::getSysLabel('general','move','text'),
    609. 

  609. 			    'javascript:'.$uniqid.'.moveselected(\'to\');','edit');
    610. 

  610.       $o1->menuable=true;
    611. 

  611.       $my['move']=$o1;
    612. 

  612.       $o1=new XModuleAction($this,'moveup',XLabels::getSysLabel('general','up','text'),
    613. 

  613. 			    'javascript:'.$uniqid.'.moveselected(\'up\');','edit');
    614. 

  614.       $o1->menuable=true;
    615. 

  615.       $my['moveup']=$o1;
    616. 

  616.       $o1=new XModuleAction($this,'movedown',XLabels::getSysLabel('general','down','text'),
    617. 

  617. 			    'javascript:'.$uniqid.'.moveselected(\'down\');','edit');
    618. 

  618.       $o1->menuable=true;
    619. 

  619.       $my['movedown']=$o1;
    620. 

  620.     }
    621. 

  621.     // Export PDF
    622. 

  622.     if($this->pdf_enabled && $this->secure($oid,'exportPdf')) {
    623. 

  623.       $o1=new XModuleAction($this,'exportPdf',XLabels::getSysLabel('xmodinfotree','export_pdf','text'),'&moid='.$this->_moid.'&_function=exportPdf&oidit='.$oid,'edit');
    624. 

  624.       $o1->target='_blank';
    625. 

  625.       $o1->ico='<img src="/tzr/templates/ico/mime/pdf.gif">';
    626. 

  626.       $o1->setToolbar();
    627. 

  627.       $my['exportPdf']=$o1;
    628. 

  628.     }
    629. 

  629.   }
    630. 

  630.   /// Actions spécifique à "editpage"
    631. 

  631.   function al_editpage(&$my){
    632. 

  632.     $this->al_viewpage($my);
    633. 

  633.   }
    634. 

  634. 

  635.   /// Refait la numérotation de l'ordre des sections d'une catégorie
    636. 

  636.   protected function _reorderSections($oid) {
    637. 

  637.     $rs=selectQuery('select ITOID,ORDER1 from '.$this->tname.' where KOIDSRC="'.$oid.'" order by ORDER1,ITOID');
    638. 

  638.     $i=0;
    639. 

  639.     while($ors=$rs->fetch()) {
    640. 

  640.       $i++;
    641. 

  641.       if($i==$ors['ORDER1']) continue;
    642. 

  642.       updateQuery('UPDATE '.$this->tname.' set ORDER1='.$i.' where ITOID="'.$ors['ITOID'].'"');
    643. 

  643.     }
    644. 

  644.     $rs->closeCursor();
    645. 

  645.   }
    646. 

  646. 

  647.   /// Refait la numérotation de l'ordre des catégories d'un noeud
    648. 

  648.   protected function _reorderCat($oid) {
    649. 

  649.     $lang=TZR_DEFAULT_LANG;
    650. 

  650.     if(!$oid) $oid='';
    651. 

  651.     $i=0;
    652. 

  652.     $rs=selectQuery('select distinct KOID,corder from '.$this->table.' where linkup="'.$oid.'" and LANG="'.$lang.'" order by corder');
    653. 

  653.     while($ors=$rs->fetch()) {
    654. 

  654.       $i++;
    655. 

  655.       if($i==$ors['corder']) continue;
    656. 

  656.       updateQuery('UPDATE '.$this->table.' set corder='.$i.',UPD=UPD where KOID="'.$ors['KOID'].'"');
    657. 

  657.     }
    658. 

  658.     $rs->closeCursor();
    659. 

  659.   }
    660. 

  660. 

  661.   /// Change le parent d'une ou plusieurs catégories
    662. 

  662.   public function moveSelectedCat($ar) {
    663. 

  663.     $p=new XParam($ar, array());
    664. 

  664.     $dest=$p->get('_dest');
    665. 

  665.     if(!empty($dest) && !Kernel::isAKoid($dest)) {
    666. 

  666.       $dest=$this->getOidFromAlias($dest);
    667. 

  667.     }
    668. 

  668.     $sel=$p->get('_selected');
    669. 

  669. 

  670.     $i=-count($sel);
    671. 

  671.     foreach($sel as $oid => $bid) {
    672. 

  672.       if($oid!=$dest) {
    673. 

  673. 	updateQuery('UPDATE '.$this->table.' set linkup="'.$dest.'",corder='.$i.' where KOID="'.$oid.'"');
    674. 

  674.       }
    675. 

  675.       $i++;
    676. 

  676.     }
    677. 

  677.     $this->_reorderCat($dest);
    678. 

  678.   }
    679. 

  679. 

  680.   /// teste si une rubrique est dans la poubelle
    681. 

  681.   protected function oidInTrash($oid) {
    682. 

  682.     $oidtrash = $this->getTrashOid();
    683. 

  683.     if(empty($oidtrash)) return false;
    684. 

  684.     $pathoids=$this->_getPathOids($oid);
    685. 

  685.     return in_array($oidtrash, $pathoids);
    686. 

  686.   }
    687. 

  687. 

  688.   /// deplacement de la selection vers la poubelle, rubrique d'alias trash
    689. 

  689.   public function moveToTrash($ar) {
    690. 

  690.     $p=new XParam($ar, array());
    691. 

  691.     $oidtrash = $this->getTrashOid(true);
    692. 

  692.     $sel=$p->get('_selected');
    693. 

  693. 

  694.     // si les elements sont deja dans la poubelle on les supprime
    695. 

  695.     $delnb=0;
    696. 

  696. 

  697.     foreach($sel as $oid => $bid) {
    698. 

  698.       if($this->oidInTrash($oid)) {
    699. 

  699. 	$ar1=array();
    700. 

  700. 	$ar1['oid']=$oid;
    701. 

  701. 	$ar1['_selected']=array();
    702. 

  702. 	$ar1['_selectedok']='nok';
    703. 

  703. 	$this->delCat($ar1);
    704. 

  704. 	$delnb++;
    705. 

  705.       }
    706. 

  706.     }
    707. 

  707.     // si on a supprime tous les elements selectionnes pas la peine de
    708. 

  708.     // rentrer dans un traitement de la poubelle
    709. 

  709.     if($delnb==count($sel)) return;
    710. 

  710. 

  711.     // creation d'une rubrique liee a la date de suppression
    712. 

  712.     $ar1=array('title'=>'-- '.date('c'),
    713. 

  713. 	       'linkup'=>$oidtrash,
    714. 

  714. 	       'corder'=>'0');
    715. 

  715.     $r1=&$this->procInput($ar1);
    716. 

  716.     $dest = $r1['oid'];
    717. 

  717. 

  718.     foreach($sel as $oid => $bid) {
    719. 

  719.       if($oid!=$dest) {
    720. 

  720. 	updateQuery('UPDATE '.$this->table." set linkup='$dest' where KOID='$oid'");
    721. 

  721.       }
    722. 

  722.     }
    723. 

  723. 

  724.     // on parcourt la poubelle et on supprime dans la poubelle toutes les rubriques validees
    725. 

  725.     // ainsi que tous les alias
    726. 

  726.     $oids=$this->getSubObjects($oidtrash);
    727. 

  727.     foreach($oids as $oids1) {
    728. 

  728.       if($this->_categories->fieldExists('PUBLISH')) {
    729. 

  729. 	updateQuery('UPDATE '.$this->table." set PUBLISH='2' WHERE KOID='$oids1'");
    730. 

  730.       }
    731. 

  731.       updateQuery('UPDATE '.$this->table." set alias='' WHERE KOID='$oids1'");
    732. 

  732.     }
    733. 

  733. 

  734.     // on traite les liens internes. Ceux qui sont dans la poubelle sont supprimes
    735. 

  735.     // ceux qui vont vers la poubelle sont supprimes
    736. 

  736.     $rs=selectQuery('SELECT KOID,LANG,'.$this->linkin.' FROM '.$this->table.' WHERE '.$this->linkin.'!=\'\'');
    737. 

  737.     while($rs && ($ors=$rs->fetch())) {
    738. 

  738.       if($this->oidInTrash($ors['KOID'])) {
    739. 

  739. 	updateQuery('UPDATE '.$this->table.' SET '.$this->linkin."='',UPD=UPD WHERE KOID='".$ors['KOID']."'");
    740. 

  740.       } elseif($this->oidInTrash($ors[$this->linkin])) {
    741. 

  741. 	updateQuery('UPDATE '.$this->table.' SET '.$this->linkin."='',UPD=UPD WHERE KOID='".$ors['KOID']."' AND ".$this->linkin."='".$ors[$this->linkin]."'");
    742. 

  742.       }
    743. 

  743.     }
    744. 

  744.   }
    745. 

  745. 

  746.   /// Change l'ordre et/ou le parent d'une catégorie
    747. 

  747.   public function moveCat($ar) {
    748. 

  748.     $p=new XParam($ar, array());
    749. 

  749.     $oid=$p->get('oid');
    750. 

  750.     $dir=$p->get('dir');
    751. 

  751.     $to=$p->get('to');
    752. 

  752. 

  753.     // recherche de la rubrique mere
    754. 

  754.     $poid=$new_p=countSelectQuery('select distinct linkup from '.$this->table.' where KOID="'.$oid.'"');
    755. 

  755. 

  756.     // on verifie et corrige l'ordre
    757. 

  757.     $this->_reorderCat($poid);
    758. 

  758.     if($to){
    759. 

  759.       $new_p=($to!='root'?$to:'');
    760. 

  760.       $this->_reorderCat($new_p);
    761. 

  761.     }
    762. 

  762. 

  763.     // recherche de son ordre
    764. 

  764.     $o=countSelectQuery('select distinct corder from '.$this->table.' where KOID="'.$oid.'"');
    765. 

  765.     if($dir=='up'){
    766. 

  766.       $new_o=$o-1;
    767. 

  767.       updateQuery('UPDATE '.$this->table.' set corder='.$o.',UPD=UPD where corder='.$new_o.' and linkup="'.$poid.'"');
    768. 

  768.     }elseif($dir=='down'){
    769. 

  769.       $new_o=$o+1;
    770. 

  770.       updateQuery('UPDATE '.$this->table.' set corder='.$o.',UPD=UPD where corder='.$new_o.' and linkup="'.$poid.'"');
    771. 

  771.     }elseif(Kernel::isAKoid($dir)){
    772. 

  772.       $new_o=countSelectQuery('select distinct corder from '.$this->table.' where KOID="'.$dir.'"')+1;
    773. 

  773.       updateQuery('UPDATE '.$this->table.' set corder=corder+1,UPD=UPD where corder>='.$new_o.' and linkup="'.$new_p.'"');
    774. 

  774.     }else{
    775. 

  775.       $new_o=0;
    776. 

  776.     }
    777. 

  777.     updateQuery('UPDATE '.$this->table.' set corder='.$new_o.',linkup="'.$new_p.'" where KOID="'.$oid.'"');
    778. 

  778. 

  779.     $this->_reorderCat($poid);
    780. 

  780.     if($new_p!=$poid) $this->_reorderCat($new_p);
    781. 

  781.   }
    782. 

  782. 

  783.   /// suppression d'une rubrique et de toutes les sections associees
    784. 

  784.   function delCat($ar=NULL) {
    785. 

  785.     $p=new XParam($ar,array('_selectedok'=>'nok'));
    786. 

  786.     $lang_data=XShell::getLangData();
    787. 

  787.     if($lang_data==TZR_DEFAULT_LANG) $lang='';
    788. 

  788.     elseif(!$this->_categories->isTranslatable()) $lang='';
    789. 

  789.     else $lang="AND LANG='$lang_data'";
    790. 

  790. 

  791.     $selected =   $p->get('_selected');
    792. 

  792.     $selectedok = $p->get('_selectedok');
    793. 

  793.     if($selectedok=='ok') {
    794. 

  794.       foreach($selected as $oid => $bidon) {
    795. 

  795. 	$ar['oid']=$oid;
    796. 

  796. 	$ar['_selected']=array();
    797. 

  797. 	$ar['_selectedok']='nok';
    798. 

  798. 	$this->delCat($ar);
    799. 

  799.       }
    800. 

  800.       return;
    801. 

  801.     }
    802. 

  802.     $oid=$p->get('oid');
    803. 

  803.     $oids[$oid]=1;
    804. 

  804.     $kernel = new Kernel;
    805. 

  805. 

  806.     while(count($oids)>0) {
    807. 

  807.       unset($oids2);
    808. 

  808.       foreach($oids as $k => $v) {
    809. 

  809. 	$kernel->data_forcedDel(array('oid'=>$k,'action'=>'OK','_selectedok'=>'nok'));
    810. 

  810. 	// suppression des sections
    811. 

  811. 	$rs=selectQuery('select * from '.$this->tname." where KOIDSRC='$k'");
    812. 

  812. 	while($ors=$rs->fetch()) {
    813. 

  813. 	  $itoid = $ors['ITOID'];
    814. 

  814. 	  $koiddst = $ors['KOIDDST'];
    815. 

  815. 	  if(!empty($koiddst)) {
    816. 

  816. 	    $tabledst = Kernel::getTable($koiddst);
    817. 

  817. 	    if(!empty($tabledst)) {
    818. 

  818. 	      if($lang_data == TZR_DEFAULT_LANG) {
    819. 

  819. 		updateQuery('DELETE FROM '.$this->tname." where ITOID = '$itoid'");
    820. 

  820. 	      }
    821. 

  821. 	      $kernel->data_forcedDel(array('oid'=>$koiddst,'action'=>'OK','_selectedok'=>'nok'));
    822. 

  822. 	    }
    823. 

  823. 	  }
    824. 

  824. 	}
    825. 

  825. 	$rs->closeCursor();
    826. 

  826. 	$rs=selectQuery('select distinct KOID from '.$this->table." where linkup='$k'");
    827. 

  827. 	while($ors=$rs->fetch()) {
    828. 

  828. 	  $oids2[$ors['KOID']]=1;
    829. 

  829. 	}
    830. 

  830. 	$rs->closeCursor();
    831. 

  831.       }
    832. 

  832.       $oids=$oids2;
    833. 

  833.     }
    834. 

  834.   }
    835. 

  835. 

  836.   /// suppression d'une categorie et de toutes les sections associees
    837. 

  837.   function dupCat($ar=NULL) {
    838. 

  838.     $p=new XParam($ar,array('_selectedok'=>'nok'));
    839. 

  839.     $lang_data=XShell::getLangData();
    840. 

  840.     if($lang_data==TZR_DEFAULT_LANG) $lang='';
    841. 

  841.     elseif(!$this->_categories->isTranslatable()) $lang='';
    842. 

  842.     else $lang="AND LANG='$lang_data'";
    843. 

  843. 

  844.     $selected =   $p->get('_selected');
    845. 

  845.     $selectedok = $p->get('_selectedok');
    846. 

  846. 

  847.     if($selectedok=='ok') {
    848. 

  848.       foreach($selected as $oid => $bidon) {
    849. 

  849. 	$ar['oid']=$oid;
    850. 

  850. 	$ar['_selected']=array();
    851. 

  851. 	$ar['_selectedok']='nok';
    852. 

  852. 	$this->dupCat($ar);
    853. 

  853.       }
    854. 

  854.       return;
    855. 

  855.     }
    856. 

  856. 

  857.     // duplication de la rubrique
    858. 

  858.     $oid=$p->get('oid');
    859. 

  859.     $nkoid=$this->_categories->duplicate(array('oid'=>$oid));
    860. 

  860.     $copy_of=XLabels::getSysLabel('general.copy_of');
    861. 

  861.     updateQuery('UPDATE '.$this->_categories->getTable()." set title=CONCAT('$copy_of ', title) where KOID='$nkoid'");
    862. 

  862.     updateQuery('UPDATE '.$this->_categories->getTable()." set alias=CONCAT(alias,'1') where KOID='$nkoid' and alias !=''");
    863. 

  863.     if($this->_categories->fieldExists('PUBLISH')) {
    864. 

  864.       updateQuery('UPDATE '.$this->_categories->getTable()." set PUBLISH='2' where KOID='$nkoid'");
    865. 

  865.     }
    866. 

  866. 

  867.     // duplication des sections
    868. 

  868.     $rs=selectQuery('select * from '.$this->tname." where KOIDSRC='$oid'");
    869. 

  869.     if($rs->rowCount()>0) {
    870. 

  870.       $oids=array();
    871. 

  871.       $ors=array();
    872. 

  872.       while($ors=$rs->fetch()) {
    873. 

  873. 	$oids[]=$ors['KOIDDST'];
    874. 

  874. 	$itoids[]=$ors['ITOID'];
    875. 

  875.       }
    876. 

  876. 

  877.       // duplication de chacune des sections
    878. 

  878.       $noids=array();
    879. 

  879.       foreach($oids as $i=>$oid1) {
    880. 

  880. 	if(!empty($oid1)) {
    881. 

  881. 	  $xset = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$oid1);
    882. 

  882. 	  $noids[$i]=$xset->duplicate(array('oid'=>$oid1));
    883. 

  883. 	}
    884. 

  884.       }
    885. 

  885. 

  886.       // duplication des liens
    887. 

  887.       updateQuery('CREATE TEMPORARY TABLE tmpo SELECT * FROM '.$this->tname." where KOIDSRC='$oid'");
    888. 

  888.       updateQuery("UPDATE tmpo set KOIDSRC='$nkoid'");
    889. 

  889.       foreach($oids as $i=>$oid1) {
    890. 

  890. 	if(!empty($oid1)) {
    891. 

  891. 	  updateQuery("UPDATE tmpo set KOIDDST='".$noids[$i]."' where KOIDDST='$oid1' and KOIDSRC='$nkoid'");
    892. 

  892. 	}
    893. 

  893.       }
    894. 

  894.       $rs=selectQuery('select * from tmpo');
    895. 

  895.       $ors=array();
    896. 

  896.       while($rs && ($ors=$rs->fetch())) {
    897. 

  897. 	$olditoid=$ors['ITOID'];
    898. 

  898. 	$n=self::newItOid();
    899. 

  899. 	updateQuery("UPDATE tmpo set ITOID='$n' where ITOID='$olditoid'");
    900. 

  900.       }
    901. 

  901. 

  902.       updateQuery('INSERT INTO '.$this->tname.' select * from tmpo');
    903. 

  903.       updateQuery('DROP TABLE tmpo');
    904. 

  904.     }
    905. 

  905.     $rs=selectQuery('SELECT DISTINCT KOID FROM '.$this->table." WHERE linkup='$oid'/* 1 */");
    906. 

  906.     while($ors=$rs->fetch()) {
    907. 

  907.       $ar1=array();
    908. 

  908.       $ar1['_selected']=array();
    909. 

  909.       $ar1['_selectedok']='nok';
    910. 

  910.       $ar1['oid']=$ors['KOID'];
    911. 

  911.       $nkoid2=$this->dupCat($ar1);
    912. 

  912.       XLogs::debug("recursive duplicate {$ors['KOID']} to $nkoid2");
    913. 

  913.       updateQuery("UPDATE {$this->table} set linkup='$nkoid' where KOID='$nkoid2'");
    914. 

  914.     }
    915. 

  915.     $rs->closeCursor();
    916. 

  916.     return $nkoid;
    917. 

  917.   }
    918. 

  918. 

  919.   /// validation de sections ou de rubriques
    920. 

  920.   public function publish($ar) {
    921. 

  921.     $p = new XParam($ar,array('_pub'=>false));
    922. 

  922.     $selected = $p->get('_itoidselected');
    923. 

  923.     $pub = $p->get('_pub');
    924. 

  924. 

  925.     $selectedoid = array();
    926. 

  926.     $oidsection=$p->get("oidsection");
    927. 

  927.     if(!empty($oidsection)) {
    928. 

  928.       $selected[$oidsection]=1;
    929. 

  929.     }
    930. 

  930.     if(is_array($selected)) {
    931. 

  931.       foreach($selected as $itoid => $foo) {
    932. 

  932. 	$rs=selectQuery('select distinct KOIDDST from '.$this->tname." where ITOID='$itoid'");
    933. 

  933. 	if($o=$rs->fetch()) {
    934. 

  934. 	  if(!empty($o['KOIDDST']))
    935. 

  935. 	    $selectedoid[]=$o['KOIDDST'];
    936. 

  936. 	}
    937. 

  937.       }
    938. 

  938.     }
    939. 

  939.     $_selected=$p->get('_selected');
    940. 

  940.     if(!empty($_selected)) {
    941. 

  941.       $copy_of_selectedoid=$selectedoid;
    942. 

  942.       $selectedoid=array_merge(array_keys($_selected), $copy_of_selectedoid);
    943. 

  943.     }
    944. 

  944.     if(!empty($selectedoid)) {
    945. 

  945.       $ar['_selected']=$selectedoid;
    946. 

  946.       $ar['key']=false;
    947. 

  947.       $ar['value']=$pub;
    948. 

  948.       foreach($selectedoid as $oid) {
    949. 

  949. 	$xset = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$oid);
    950. 

  950. 	$ar1=array('oid'=>$oid, 'value'=>$pub, '_selected'=>array());
    951. 

  951. 	$xset->publish($ar1);
    952. 

  952.       }
    953. 

  953.     }
    954. 

  954.   }
    955. 

  955. 

  956.   //// validation des oid ou des rubriques
    957. 

  957.   public function publishCat($ar) {
    958. 

  958.     $p=new XParam($ar,array('_pub'=>false));
    959. 

  959.     $xset = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$this->table);
    960. 

  960.     $xset->publish($ar);
    961. 

  961.   }
    962. 

  962. 

  963. 

  964.   // Affichage de l'arboresnce
    965. 

  965.   //
    966. 

  966.   function homeedit($ar=NULL) {
    967. 

  967.     $p = new XParam($ar, array('level'=>'1','deroule'=>'1','sections'=>'1','tplentry'=>'mit','maxlevel'=>99));
    968. 

  968.     $this->home($ar);
    969. 

  969.   }
    970. 

  970. 

  971. 

  972.   // rend la liste des objets qui se trouvent en dessous de cet objet,
    973. 

  973.   // independamment des niveaux
    974. 

  974.   //
    975. 

  975.   public function &subObjects($oid) {
    976. 

  976.     return $this->getSubCats($oid, TZR_DEFAULT_LANG, 1, 20);
    977. 

  977.   }
    978. 

  978. 

  979.   // rend vrai si le noeud oidit as des fils
    980. 

  980.   //
    981. 

  981.   protected function hasChildren($oidit) {
    982. 

  982.     $cnt=countSelectQuery('select * from '.$this->table." where linkup='$oidit'");
    983. 

  983.     return $cntt;
    984. 

  984.   }
    985. 

  985. 

  986.   // rend l'url conseillee pour un noeud donné
    987. 

  987.   //
    988. 

  988.   protected function _selfUrl($oid, $alias=NULL) {
    989. 

  989.     if(!empty($alias)) {
    990. 

  990.       $html="alias=$alias";;
    991. 

  991.     } else {
    992. 

  992.       $html="oidit=$oid";
    993. 

  993.     }
    994. 

  994.     return $html;
    995. 

  995.   }
    996. 

  996. 

  997.   function &procHome($ar=NULL) {
    998. 

  998.     $p = new XParam($ar, array());
    999. 

  999.     $aliases=$p->get('alias');
    1000. 

  1000.     $allmessages = array();
    1001. 

  1001.     if(is_array($aliases)) {
    1002. 

  1002.       foreach($aliases as $oid => $alias) {
    1003. 

  1003. 	$message = '';
    1004. 

  1004. 	$this->_checkAlias($alias, '', $oid, $message, NULL);
    1005. 

  1005. 	if ($message == '')
    1006. 

  1006. 	  $this->_categories->procEdit(array('alias'=>$alias,'oid'=>$oid));
    1007. 

  1007. 	else 
    1008. 

  1008. 	  $allmessages[] = $message;
    1009. 

  1009.       }
    1010. 

  1010.     }
    1011. 

  1011.     XShell::setNextData('message', implode(', ',$allmessages));
    1012. 

  1012.   }
    1013. 

  1013.   /****m* XModInfoTree/home
    1014. 

  1014.    * NAME
    1015. 

  1015.    *   XModInfoTree::home - creation de l'arborescence
    1016. 

  1016.    * DESCRIPTION
    1017. 

  1017.    *   Preparation d'une structure de donnees pour affichage de la
    1018. 

  1018.    *   hierarchie de rubriques
    1019. 

  1019.    * INPUTS
    1020. 

  1020.    *   Passage de parametre indirect via $ar
    1021. 

  1021.    *   level - numero du premier niveau, les niveaux sont numerotes a
    1022. 

  1022.    *   partir de level, la valeur par defaut est 1 ;
    1023. 

  1023.    *   maxlevel - nombre maximum de niveaux a explorer, valeur par defaut 99 ;
    1024. 

  1024.    *   do - action a effectuer. showtree: exploration de toutes les branches ;
    1025. 

  1025.    *   oidtop - oid de l'item pere de l'arboresence ;
    1026. 

  1026.    *   aliastop - alias de l'item pere de l'arboresence ;
    1027. 

  1027.    ****/
    1028. 

  1028.   function &home($ar=NULL) {
    1029. 

  1029.     XLogs::debug('XModInfoTree::home: start');
    1030. 

  1030.     $p = new XParam($ar, array('level'=>'1','deroule'=>'1','sections'=>'1','myself'=>false,'tplentry'=>'mit','maxlevel'=>99,
    1031. 

  1031. 			       'lastupd'=>false,'optimized'=>false,'cond_categ'=>array(),'where_categ'=>false));
    1032. 

  1032.     $do = $p->get('do');
    1033. 

  1033.     $myself=$p->get('myself');
    1034. 

  1034.     $niv = $p->get('level');
    1035. 

  1035.     $linkinfollow=$p->get('linkinfollow');
    1036. 

  1036.     $optimized = $p->get('optimized');
    1037. 

  1037.     $aliastop = $p->get('aliastop');
    1038. 

  1038.     $published = $p->get('_published');
    1039. 

  1039.     if(!empty($aliastop)) {
    1040. 

  1040.       if(Kernel::isAKoid($aliastop)) $oidtop=$aliastop;
    1041. 

  1041.       else $oidtop=$this->getOidFromAlias($aliastop);
    1042. 

  1042.     }
    1043. 

  1043.     if(empty($oidtop))
    1044. 

  1044.       $oidtop = $p->get('oidtop');
    1045. 

  1045. 

  1046.     $deroule = $p->get('deroule');
    1047. 

  1047.     if(!isset($deroule)) $deroule = $p->get('unfoldall');
    1048. 

  1048.     $computesections=$p->get('sections');
    1049. 

  1049.     $norubric=$p->get('norubric');
    1050. 

  1050.     $oidselected = $p->get('oid');
    1051. 

  1051.     $tplentry=$p->get('tplentry');
    1052. 

  1052.     $LANG_DATA = XShell::getLangData($p->get('LANG_DATA'));
    1053. 

  1053.     $LANG_TRAD = XShell::getLangData($p->get('LANG_TRAD'));
    1054. 

  1054.     if(!empty($LANG_TRAD)) {
    1055. 

  1055.       $lang_tree=$LANG_TRAD;
    1056. 

  1056.       $lang_other=$LANG_DATA;
    1057. 

  1057.     }
    1058. 

  1058. 

  1059.     $maxlevel = $p->get('maxlevel');
    1060. 

  1060.     $selectedfields=$p->get('selectedfields');
    1061. 

  1061.     if(XShell::admini_mode()) setSessionVar('module_name',$this->modulename);
    1062. 

  1062. 

  1063.     if($norubric) $rubric=array();
    1064. 

  1064.     else $rubric = getSessionVar('rubric');
    1065. 

  1065.     if($do=='add') {
    1066. 

  1066.       $st1=$this->getPath($oidselected);
    1067. 

  1067.       foreach($st1['oiddown'] as $i=>$oid1) $rubric[$oid1]='1';
    1068. 

  1068.     } elseif($do=='del') {
    1069. 

  1069.       unset($rubric[$oidselected]);
    1070. 

  1070.     } elseif($do=='foldall') {
    1071. 

  1071.       clearSessionVar('rubric');
    1072. 

  1072.       $rubric=array();
    1073. 

  1073.     } elseif($do=='unfoldall') {
    1074. 

  1074.       $deroul=true;
    1075. 

  1075.     } elseif($do=='showtree') {
    1076. 

  1076.       $deroul=true;
    1077. 

  1077.       $deroule=1;
    1078. 

  1078.     }
    1079. 

  1079. 

  1080.     if(empty($this->_rbrowse)) {
    1081. 

  1081.       $options=array();
    1082. 

  1082.       if(XShell::admini_mode() || $optimized) {
    1083. 

  1083. 	$options['linkup']=array('nofollowlinks'=>1);
    1084. 

  1084.       }
    1085. 

  1085.       if(empty($selectedfields)){
    1086. 

  1086. 	if(XShell::admini_mode()) $selectedfields = array('UPD','PUBLISH','title','corder','linkup','alias','picto','descr',$this->linkin);
    1087. 

  1087. 	else $selectedfields='all';
    1088. 

  1088.       }elseif(is_array($selectedfields)){
    1089. 

  1089. 	$selectedfields=array_merge($selectedfields,array('UPD','PUBLISH','title','corder','linkup','alias','picto','descr',$this->linkin));
    1090. 

  1090.       }
    1091. 

  1091.       
    1092. 

  1092.       $cond_categ = $p->get('cond_categ');
    1093. 

  1093.       $where_categ = $p->get('where_categ');
    1094. 

  1094.       
    1095. 

  1095.       $query = $this->_categories->select_query(array('cond'=>$cond_categ,
    1096. 

  1096. 						      'where'=>$where_categ,
    1097. 

  1097. 						      'selectedfields'=>$selectedfields,
    1098. 

  1098. 						      'LANG_DATA'=>$lang_tree));
    1099. 

  1099.       $this->_rbrowse=&$this->_categories->browse(array('select'=>$query,
    1100. 

  1100. 							'pagesize'=>9999,
    1101. 

  1101. 							'selectedfields'=>$selectedfields,
    1102. 

  1102. 							'_charset'=>@$_REQUEST['_charset'],
    1103. 

  1103. 							'order'=>'corder',
    1104. 

  1104. 							'options'=>$options,
    1105. 

  1105. 							'tplentry'=>TZR_RETURN_DATA,
    1106. 

  1106. 							'last'=>'9999','nocount'=>'1',
    1107. 

  1107. 							'_options'=>array('local'=>1)));
    1108. 

  1108.       $this->_rbrowse['objects_sec']=$GLOBALS['XUSER']->getObjectsAccess($this,
    1109. 

  1109. 									 XShell::getLangData(),
    1110. 

  1110. 									 $this->_rbrowse['lines_oid']);
    1111. 

  1111.       // appliquer les droits sur les objets
    1112. 

  1112.       if ($this->object_sec) {
    1113. 

  1113.         $levelMax = $GLOBALS['XUSER']->secure8maxlevel($this, null, null, XShell::getLangData());
    1114. 

  1114.         // construction de l'arbre descendant pour l'héritage des droits
    1115. 

  1115.         foreach ($this->_rbrowse['lines_oid'] as $i => $oid) {
    1116. 

  1116.           $up = $this->_rbrowse['lines_olinkup'][$i]->raw;
    1117. 

  1117.           if (empty($this->_rbrowse['treedown'][$up]))
    1118. 

  1118.             $this->_rbrowse['treedown'][$up] = array();
    1119. 

  1119.           $this->_rbrowse['treedown'][$up][] = $oid;
    1120. 

  1120.         }
    1121. 

  1121.         $this->_rbrowse['oid_index'] = array_flip($this->_rbrowse['lines_oid']);
    1122. 

  1122.         // calcul des droits cumulés héritables et des enfants
    1123. 

  1123.         foreach ($this->_rbrowse['lines_oid'] as $i => $oid) {
    1124. 

  1124.           $this->_rbrowse['upobjects_sec'][$i] = $this->_upRights($i);
    1125. 

  1125.           $this->_rbrowse['downobjects_sec'][$i] = $this->_downRights($i, $oid);
    1126. 

  1126.         }
    1127. 

  1127.         foreach ($this->_rbrowse['lines_oid'] as $i => $oid) {
    1128. 

  1128.           // si pas de droits spécifiques sur ce noeud, hériter
    1129. 

  1129.           if (array_pop(array_keys($this->_rbrowse['objects_sec'][$i])) == $levelMax  && !empty($this->_rbrowse['upobjects_sec'][$i])) {
    1130. 

  1130.             $this->_rbrowse['objects_sec'][$i] = $this->_rbrowse['upobjects_sec'][$i];
    1131. 

  1131.           }
    1132. 

  1132.         }
    1133. 

  1133.         // suppression des noeuds non lisibles et sans enfants lisibles
    1134. 

  1134.         foreach ($this->_rbrowse['lines_oid'] as $i => $oid) {
    1135. 

  1135.           if (!isset($this->_rbrowse['objects_sec'][$i]['ro']) && !isset($this->_rbrowse['downobjects_sec'][$i]['ro'])) {
    1136. 

  1136.              unset($this->_rbrowse['lines_oid'][$i]);
    1137. 

  1137.            }
    1138. 

  1138.          }
    1139. 

  1139.        }
    1140. 

  1140.        XLogs::debug('XModInfoTree: after security sort');
    1141. 

  1141.     }
    1142. 

  1142.     $rbrowse=&$this->_rbrowse;
    1143. 

  1143.     if(!empty($published)) {
    1144. 

  1144.       foreach($this->_rbrowse['lines_oid'] as $i => $oid) {
    1145. 

  1145. 	$pub1=$this->_rbrowse['lines_published'][$i];
    1146. 

  1146. 	if(empty($pub1)||($pub1==2)) {
    1147. 

  1147. 	  unset($this->_rbrowse['lines_oid'][$i]);
    1148. 

  1148. 	}
    1149. 

  1149.       }
    1150. 

  1150.     }
    1151. 

  1151. 

  1152.     // on affiche la poubelle que si c'est l'alias qui est explicitement demandé
    1153. 

  1153.     if($aliastop!='trash') {
    1154. 

  1154.       $trashoid=$this->getTrashOid();
    1155. 

  1155.       if(!empty($trashoid)) {
    1156. 

  1156. 	foreach($this->_rbrowse['lines_oid'] as $i => $oid) {
    1157. 

  1157. 	  if($oid==$trashoid) {
    1158. 

  1158. 	    unset($this->_rbrowse['lines_oid'][$i]);
    1159. 

  1159. 	    break;
    1160. 

  1160. 	  }
    1161. 

  1161. 	}
    1162. 

  1162.       }
    1163. 

  1163.     }
    1164. 

  1164. 

  1165.     // on recherche les sommets a parcourir
    1166. 

  1166.     $stack=array();
    1167. 

  1167.     $koids=array_flip($rbrowse['lines_oid']);
    1168. 

  1168.     $koidtoprocess=array_reverse($rbrowse['lines_oid'],TRUE);
    1169. 

  1169.     $todel=array();
    1170. 

  1170.     foreach($koidtoprocess as $i => $oid) {
    1171. 

  1171.       $curi=$koids[$oid];
    1172. 

  1172.       $linkup = $rbrowse['lines_olinkup'][$curi]->raw;
    1173. 

  1173.       if($myself){
    1174. 

  1174. 	if($oid==$oidtop){
    1175. 

  1175. 	  array_push($stack, array($oid,$niv,$curi,1,$linkup));
    1176. 

  1176. 	  array_push($todel, $i);
    1177. 

  1177. 	  break;
    1178. 

  1178. 	}
    1179. 

  1179.       }else{
    1180. 

  1180. 	if((empty($oidtop) && empty($linkup)) || ($oidtop==$linkup)) {
    1181. 

  1181. 	  array_push($stack, array($oid,$niv,$curi,1,$linkup));
    1182. 

  1182. 	  array_push($todel, $i);
    1183. 

  1183. 	}
    1184. 

  1184.       }
    1185. 

  1185.     }
    1186. 

  1186.     while(count($todel)>0) unset($koidtoprocess[array_pop($todel)]);
    1187. 

  1187. 

  1188.     // recherche du nombre de sous-noeuds
    1189. 

  1189.     $section_nb = selectQuery('SELECT KOIDSRC,count(KOIDSRC) from '.$this->tname.' group by KOIDSRC')
    1190. 

  1190.                   ->fetchAll(PDO::FETCH_COLUMN|PDO::FETCH_GROUP|PDO::FETCH_UNIQUE);
    1191. 

  1191. 

  1192.     // construction de l'arbre descendant
    1193. 

  1193.     $treedown = array();
    1194. 

  1194.     foreach($rbrowse['lines_oid'] as $i => $oid) {
    1195. 

  1195.       $up=$rbrowse['lines_olinkup'][$i]->raw;
    1196. 

  1196.       if(empty($treedown[$up])) $treedown[$up]=array();
    1197. 

  1197.       $treedown[$up][]=$oid;
    1198. 

  1198.     }
    1199. 

  1199. 

  1200.     // on parcourt ce qui nous interesse
    1201. 

  1201.     $r=array();
    1202. 

  1202.     $r['aliastop']=$aliastop;
    1203. 

  1203.     $r['self']=$this->_categories->display(array('tplentry'=>TZR_RETURN_DATA,'oid'=>$oidtop,'_options'=>array('local'=>true)));
    1204. 

  1204.     $r['lines_oid']=array();
    1205. 

  1205.     $lines_oid_cnt=0;
    1206. 

  1206.     $r['lines_level']=array();
    1207. 

  1207.     $r['lines_deroule']=array();
    1208. 

  1208.     $r['lines_ssrub']=array();
    1209. 

  1209.     $r['lines_sections']=array();
    1210. 

  1210.     $r['lines_lvl1pagenum']=array();
    1211. 

  1211.     $lvl1pagenum=0;
    1212. 

  1212.     $newkoids=array();
    1213. 

  1213.     while(!empty($stack)) {
    1214. 

  1214.       // on depile l'element a traiter
    1215. 

  1215.       list($curoid,$curlevel,$curi,$curderoul,$linkup)=array_pop($stack);
    1216. 

  1216.       if($curderoul && ($curlevel<=$maxlevel || isset($rubric[$curoid]) || isset($rubric[$linkup]))) {
    1217. 

  1217. 	$r['lines_oid'][]=$curoid;
    1218. 

  1218. 	$newkoids[$curoid]=$lines_oid_cnt;
    1219. 

  1219. 	$lines_oid_cnt++;
    1220. 

  1220. 	$r['lines_level'][]=$curlevel;
    1221. 

  1221. 	$r['lines_ssrub'][]=0;
    1222. 

  1222. 	if($computesections=='1') {
    1223. 

  1223. 	  if(!empty($section_nb[$curoid])) $r['lines_sections'][]=$section_nb[$curoid];
    1224. 

  1224. 	  else $r['lines_sections'][]=0;
    1225. 

  1225. 	}
    1226. 

  1226. 	if($do=='unfoldall') {
    1227. 

  1227. 	  $rubric[$curoid]='1';
    1228. 

  1228. 	}
    1229. 

  1229. 	$deroul=($do=='showtree'?'1':'0');
    1230. 

  1230. 	$deroul=$deroul || (empty($rubric[$curoid])?'0':'1');
    1231. 

  1231. 	$r['lines_deroule'][]=$deroul;
    1232. 

  1232. 	if($curlevel>1)	$lvl1pagenum++;
    1233. 

  1233. 	else $lvl1pagenum=0;
    1234. 

  1234. 	$r['lines_lvl1pagenum'][]=$lvl1pagenum;
    1235. 

  1235.       }
    1236. 

  1236.       $tmp1=@$newkoids[$rbrowse['lines_olinkup'][$curi]->raw];
    1237. 

  1237.       if(empty($r['lines_ssrub'][$tmp1])) $r['lines_ssrub'][$tmp1]=1;
    1238. 

  1238.       else $r['lines_ssrub'][$tmp1]++;
    1239. 

  1239.       if($this->linkin && $linkinfollow && $linkin && $linkin!=$rbrowse['lines_olinkup'][$curi]->raw){
    1240. 

  1240. 	$tmp1=@$newkoids[$linkin];
    1241. 

  1241. 	if(empty($r['lines_ssrub'][$tmp1])) $r['lines_ssrub'][$tmp1]=1;
    1242. 

  1242. 	else $r['lines_ssrub'][$tmp1]++;
    1243. 

  1243.       }
    1244. 

  1244.       $ocuroid=$curoid;
    1245. 

  1245.       if($this->linkin && $linkinfollow && $rbrowse['lines_o'.$this->linkin][$curi]->raw)
    1246. 

  1246. 	$curoid=$rbrowse['lines_o'.$this->linkin][$curi]->raw;
    1247. 

  1247.       if(!empty($treedown[$curoid]) && is_array($treedown[$curoid])) {
    1248. 

  1248. 	$todel=array();
    1249. 

  1249. 	foreach(array_reverse($treedown[$curoid]) as $i => $oid) {
    1250. 

  1250. 	  $oldi=$koids[$oid];
    1251. 

  1251. 	  $stack[]=array($oid,$curlevel+1,$oldi,$deroul,$ocuroid);
    1252. 

  1252. 	  $todel[]=$i;
    1253. 

  1253. 	}
    1254. 

  1254. 	foreach($todel as $t1=>$toid) unset($koidtoprocess[$toid]);
    1255. 

  1255.       }
    1256. 

  1256.       $curoid=$ocuroid;
    1257. 

  1257.     }
    1258. 

  1258.     if(!issetSessionVar('rubric')) {
    1259. 

  1259.       if(!empty($rubric)) {
    1260. 

  1260. 	setSessionVar('rubric',$rubric);
    1261. 

  1261.       }
    1262. 

  1262.     } else {
    1263. 

  1263.       if(!empty($rubric)) {
    1264. 

  1264. 	setSessionVar('rubric',$rubric);
    1265. 

  1265.       } else {
    1266. 

  1266. 	clearSessionVar('rubric');
    1267. 

  1267.       }
    1268. 

  1268.     }
    1269. 

  1269. 

  1270.     // recopie des donnees du browse
    1271. 

  1271.     $norw=array('lines_all_labels','lines_all_codes');
    1272. 

  1272.     $rwall=array('objects_sec'=>true,'upobjects_sec'=>true);
    1273. 

  1273.     foreach($r['lines_oid'] as $i => $oid) {
    1274. 

  1274.       $oldi = $koids[$oid];
    1275. 

  1275.       foreach($rbrowse as $k => $v) {
    1276. 

  1276. 	if(((substr($k, 0,6)=='lines_')||!empty($rwall[$k])) && !in_array($k,$norw)) {
    1277. 

  1277. 	  $r[$k][$i]=(empty($v[$oldi])?NULL:$v[$oldi]);
    1278. 

  1278. 	}
    1279. 

  1279. 	if(!empty($r['lines_o'.$this->linkin][$i]->raw)){
    1280. 

  1280. 	  $r['lines_sections'][$i]=@$section_nb[$r['lines_o'.$this->linkin][$i]->raw];
    1281. 

  1281. 	}
    1282. 

  1282.       }
    1283. 

  1283.       if(!empty($r['lines_o'.$this->linkin][$i]->raw)){
    1284. 

  1284. 	$r['lines_sections'][$i]=@$section_nb[$r['lines_o'.$this->linkin][$i]->raw];
    1285. 

  1285.       }
    1286. 

  1286.     }
    1287. 

  1287.     foreach($r['lines_oid'] as $i => $oid) {
    1288. 

  1288.       $r['lines_selfurl'][$i]=$this->_selfUrl($oid,$r['lines_oalias'][$i]->toText());
    1289. 

  1289.     }
    1290. 

  1290. 

  1291.     if(!empty($this->linkin) && $this->_categories->fieldExists($this->linkin)) {
    1292. 

  1292.       $r['lines_olinkin']=&$r['lines_o'.$this->linkin];
    1293. 

  1293.     }
    1294. 

  1294.     $r['moid']=$this->_moid;
    1295. 

  1295.     if (XShell::admini_mode()) {
    1296. 

  1296.       $r['_editLevel'] = array_shift($this->secGroups('editpage'));
    1297. 

  1297.       $r['_inputLevel'] = array_shift($this->secGroups('input'));
    1298. 

  1298.       $r['_viewLevel'] = array_shift($this->secGroups('viewpage'));
    1299. 

  1299.     }
    1300. 

  1300.     XLogs::debug('XModInfoTree::home: end');
    1301. 

  1301.     return Xshell::toScreen1($tplentry,$r);
    1302. 

  1302.   }
    1303. 

  1303. 

  1304.   // calcul les droits héritables
    1305. 

  1305.   private function _upRights($i, $first=true) {
    1306. 

  1306.     if ($this->_rbrowse['lines_olinkup'][$i]->raw) {
    1307. 

  1307.       // calcul des droits du parent
    1308. 

  1308.       $upRights = $this->_upRights($this->_rbrowse['oid_index'][$this->_rbrowse['lines_olinkup'][$i]->raw], false);
    1309. 

  1309.       if ($first) {
    1310. 

  1310.         return $upRights;
    1311. 

  1311.       } else {
    1312. 

  1312.         return array_merge($this->_rbrowse['objects_sec'][$i], $upRights);
    1313. 

  1313.       }
    1314. 

  1314.     } else {
    1315. 

  1315.       return array();
    1316. 

  1316.     }
    1317. 

  1317.   }
    1318. 

  1318.   // calcul les droits sur les enfants (+ droit sur l'objet)
    1319. 

  1319.   private function _downRights($i, $oid) {
    1320. 

  1320.     $downRights = $this->_rbrowse['objects_sec'][$i];
    1321. 

  1321.     foreach ($this->_rbrowse['treedown'][$oid] as $_oid) {
    1322. 

  1322.       $_i = $this->_rbrowse['oid_index'][$_oid];
    1323. 

  1323.       if (!isset($this->_rbrowse['downobjects_sec'][$_i]))
    1324. 

  1324.         $this->_rbrowse['downobjects_sec'][$_i] = $this->_downRights($_i, $_oid);
    1325. 

  1325.       $downRights = array_merge($downRights, $this->_rbrowse['downobjects_sec'][$_i]);
    1326. 

  1326.     }
    1327. 

  1327.     return $downRights;
    1328. 

  1328.   }
    1329. 

  1329. 

  1330.   /// Rend les infos sur les rubriques mere de la rubrique oid
    1331. 

  1331.   function getPath($ar) {
    1332. 

  1332.     if(is_array($ar)){
    1333. 

  1333.       $oid=$ar['oid'];
    1334. 

  1334.       $tplentry=$ar['tplentry'];
    1335. 

  1335.       $selectedfields = $ar['selectedfields'];
    1336. 

  1336.     }else{
    1337. 

  1337.       $oid=$ar;
    1338. 

  1338.     }
    1339. 

  1339.     if(empty($selectedfields)) $selectedfields = array('title','alias','linkup','style');
    1340. 

  1340.     // Browse de la categorie
    1341. 

  1341.     $v1=array();
    1342. 

  1342.     $stack=array();
    1343. 

  1343.     $nav_alias=$nav_cat=$nav_oid=$nav_url=array();
    1344. 

  1344.     do{
    1345. 

  1345.       $categ=$this->_categories->rDisplay($oid, array(), false,'','',array('selectedfields'=>$selectedfields));
    1346. 

  1346.       if(!is_array($categ)) break;
    1347. 

  1347.       $stack[]=$categ;
    1348. 

  1348.       $nav_cat[]= $categ['otitle']->toText();
    1349. 

  1349.       $nav_oid[]= $oid;
    1350. 

  1350.       $nav_alias[]=$categ['oalias']->toText();
    1351. 

  1351.       $nav_url[]='&moid='.$this->_moid.'&function=viewpage&template=xmodinfotree/viewpage.html&oidit='.$oid.'&tplentry=it';
    1352. 

  1352.       $oid=$categ['olinkup']->raw;
    1353. 

  1353.       unset($categ);
    1354. 

  1354.     } while($oid);
    1355. 

  1355.     $v1=array('labelup'=>$nav_cat,'urlup'=>$nav_url,'oidup'=>$nav_oid,'aliasup'=>$nav_alias,
    1356. 

  1356. 	      'labeldown'=>array_reverse($nav_cat),'urldown'=>array_reverse($nav_url),
    1357. 

  1357. 	      'aliasdown'=>array_reverse($nav_alias),
    1358. 

  1358. 	      'oiddown'=>array_reverse($nav_oid),
    1359. 

  1359. 	      'stack'=>array_reverse($stack));
    1360. 

  1360.     if(!empty($tplentry)) XShell::toScreen1($tplentry,$v1);
    1361. 

  1361.     return $v1;
    1362. 

  1362.   }
    1363. 

  1363. 

  1364.   function _getPathOids($oid) {
    1365. 

  1365.     $stack=array();
    1366. 

  1366.     $ors['linkup']=$oid;
    1367. 

  1367.     do{
    1368. 

  1368.       $stack[]=$ors['linkup'];
    1369. 

  1369.       $rs = selectQuery('SELECT linkup FROM '.$this->table.' WHERE KOID="'.$ors['linkup'].'"');
    1370. 

  1370.     } while($ors=$rs->fetch());
    1371. 

  1371.     return $stack;
    1372. 

  1372.   }
    1373. 

  1373. 

  1374.   function getPathString($koid) {
    1375. 

  1375.     $nav=$this->getPath($koid);
    1376. 

  1376.     $title='';
    1377. 

  1377.     foreach($nav['labeldown'] as $t) $title.='> '.$t;
    1378. 

  1378.     return $title;
    1379. 

  1379.   }
    1380. 

  1380. 

  1381.   protected function _followLinkIn($oid) {
    1382. 

  1382.     $links=array();
    1383. 

  1383.     if($this->_categories->fieldExists($this->linkin)) {
    1384. 

  1384.       $found=false;
    1385. 

  1385.       while(!$found && !in_array($oid, $links)) {
    1386. 

  1386. 	$links[]=$oid;
    1387. 

  1387. 	$query = 'SELECT KOID,'.$this->linkin.' FROM '.$this->_categories->getTable().
    1388. 

  1388. 	  ' WHERE LANG="'.TZR_DEFAULT_LANG.'" AND KOID="'.$oid.'"';
    1389. 

  1389. 	$rs=selectQuery($query);
    1390. 

  1390. 	if(!$ors=$rs->fetch()) {
    1391. 

  1391. 	  $found=true;
    1392. 

  1392. 	} else {
    1393. 

  1393. 	  if(!Kernel::isAKoid($ors[$this->linkin])) {
    1394. 

  1394. 	    $found=true;
    1395. 

  1395. 	  } else {
    1396. 

  1396. 	    $oid=$ors[$this->linkin];
    1397. 

  1397. 	  }
    1398. 

  1398. 	  $rs->closeCursor();
    1399. 

  1399. 	}
    1400. 

  1400.       }
    1401. 

  1401.     }
    1402. 

  1402.     return $oid;
    1403. 

  1403.   }
    1404. 

  1404.   /****m* XModInfoTree/procInput
    1405. 

  1405.    * NAME
    1406. 

  1406.    *   XModInfoTree::procInput - creation d'une nouvelle rubrique
    1407. 

  1407.    * DESCRIPTION
    1408. 

  1408.    *   Fonction d'ajout d'une rubrique dans l'admin en tenant compte du chgement d'ordre d'affichage.
    1409. 

  1409.    * INPUTS
    1410. 

  1410.    ****/
    1411. 

  1411.   function &procInput($ar=NULL) {
    1412. 

  1412.     $p = new XParam($ar, array());
    1413. 

  1413.     $title = $p->get('title');
    1414. 

  1414.     $linkup = $p->get('linkup');
    1415. 

  1415.     $order = $p->get('corder');
    1416. 

  1416.     $alias = $p->get('alias');
    1417. 

  1417.     if(empty($order)) $order='0';
    1418. 

  1418.     $ar['tplentry']=TZR_RETURN_DATA;
    1419. 

  1419.     $message='';
    1420. 

  1420.     $this->_checkAlias($alias, '', NULL, $message, $title);
    1421. 

  1421.     $ar['alias']=$alias;
    1422. 

  1422.     if(!empty($message)) {
    1423. 

  1423.       XShell::setNextData('message', $message);
    1424. 

  1424.     }
    1425. 

  1425. 

  1426.     $r=$this->_categories->procInput($ar);
    1427. 

  1427. 

  1428.     // positionnement des droits
    1429. 

  1429.     if(!empty($this->object_sec)) {
    1430. 

  1430.       $GLOBALS['XUSER']->setUserAccess(get_class($this),$this->_moid,XShell::getLangData(),$r['oid'],'admin');
    1431. 

  1431.     }
    1432. 

  1432. 

  1433.     // maj de l'order d'affichage de la rubrique.
    1434. 

  1434.     $this->majUpOtherOrder($title,$linkup,$order);
    1435. 

  1435.     return $r;
    1436. 

  1436.   }
    1437. 

  1437. 

  1438.   /****m* XModInfoTree/edit
    1439. 

  1439.    * NAME
    1440. 

  1440.    *   XModInfoTree::edit - creation d'une nouvelle rubrique
    1441. 

  1441.    * DESCRIPTION
    1442. 

  1442.    *   Fonction d'edition d'une rubrique dans l'admin en tenant compte du chgement d'ordre d'affichage.
    1443. 

  1443.    * INPUTS
    1444. 

  1444.    ****/
    1445. 

  1445.   //
    1446. 

  1446.   //
    1447. 

  1447.   function edit($ar=NULL) {
    1448. 

  1448.     $this->_categories->edit($ar);
    1449. 

  1449.     $GLOBALS['XSHELL']->tpldata['']['moid']=$this->_moid;
    1450. 

  1450.   }
    1451. 

  1451.   function input($ar=NULL) {
    1452. 

  1452.     $p = new XParam($ar, array());
    1453. 

  1453.     $ar['options']['linkup']['value']=$p->get('linkup');
    1454. 

  1454.     $ar['options']['corder']['value']=$p->get('order');
    1455. 

  1455.     $this->_categories->input($ar);
    1456. 

  1456.     $GLOBALS['XSHELL']->tpldata['']['title']=$GLOBALS['XSHELL']->tpldata['']['otitle']->html;
    1457. 

  1457.     $GLOBALS['XSHELL']->tpldata['']['order']=$GLOBALS['XSHELL']->tpldata['']['ocorder']->html;
    1458. 

  1458.     $GLOBALS['XSHELL']->tpldata['']['alias']=$GLOBALS['XSHELL']->tpldata['']['oalias']->html;
    1459. 

  1459.     $GLOBALS['XSHELL']->tpldata['']['moid']=$this->_moid;
    1460. 

  1460.   }
    1461. 

  1461. 

  1462.   // mise a jour d'une rubrique
    1463. 

  1463.   //
    1464. 

  1464.   function procEdit($ar=NULL) {
    1465. 

  1465.     $p = new XParam($ar, array());
    1466. 

  1466.     $oidMere = $p->get('linkup');
    1467. 

  1467.     $oid = $p->get('oid');
    1468. 

  1468.     $alias = $p->get('alias');
    1469. 

  1469.     $title = $p->get('title');
    1470. 

  1470.     $langs = $p->get('_langs');
    1471. 

  1471.     $lang_data = XShell::getLangData();
    1472. 

  1472.     // Traitement des cas ou l'on veut sauver dans plusieurs langues
    1473. 

  1473.     $ar['_langs']=$this->getAuthorizedLangs($langs,$oid,'procEdit');
    1474. 

  1474. 

  1475.     if($lang_data == TZR_DEFAULT_LANG) {
    1476. 

  1476.       $disp_cat = $this->_categories->display(array('oid'=>$oid,'tplentry'=>TZR_RETURN_DATA));
    1477. 

  1477.       $message='';
    1478. 

  1478.       $oldalias= $disp_cat['oalias']->raw;
    1479. 

  1479.       // vérification alias
    1480. 

  1480.       $this->_checkAlias($alias, $oldalias, $oid, $message, $title);
    1481. 

  1481.       $ar['alias'] = $alias; // peut-être modifié par _checkAlias
    1482. 

  1482.       // vérification de boucle sur linkin
    1483. 

  1483.       if ($this->linkin) {
    1484. 

  1484.         $linkin = $p->get($this->linkin);
    1485. 

  1485.         if ($linkin && !$this->_checkLinkin($oid, $linkin)) {
    1486. 

  1486.           $message .= '<br>' . $this->_categories->desc[$this->linkin]->label . ' : ' . XLabels::getSysLabel('xmodinfotree.circularity');
    1487. 

  1487.         }
    1488. 

  1488.       }
    1489. 

  1489.       if (!empty($message)) {
    1490. 

  1490.           unset($_REQUEST['skip'], $_REQUEST['_skip']);
    1491. 

  1491.           XShell::changeTemplate('xmodinfotree/editcat.html');
    1492. 

  1492.           XShell::setNext();
    1493. 

  1493.           XShell::toScreen2('', 'message', $message);          
    1494. 

  1494.           $ar['options'] = $this->_categories->prepareReEdit($ar);
    1495. 

  1495.           $ar['tplentry'] = 'editcat';
    1496. 

  1496.           return $this->editcat($ar);
    1497. 

  1497.       }
    1498. 

  1498.       $oldOrder = $disp_cat['ocorder']->raw;
    1499. 

  1499.       $ar['tplentry']='addrub';
    1500. 

  1500.       $this->_categories->procEdit($ar);
    1501. 

  1501.     } else {
    1502. 

  1502.       $oldOrder = $disp_cat['ocorder']->raw;
    1503. 

  1503.       $this->_categories->procEdit($ar);
    1504. 

  1504.     }
    1505. 

  1505. 

  1506.     // maj de l'order d'affichage de la rubrique.
    1507. 

  1507.     $newOrder = $p->get('corder');
    1508. 

  1508.     $titre = $p->get('title');
    1509. 

  1509.     $oid = $p->get('linkup');
    1510. 

  1510.     $this->majOtherOrder($titre,$oid,$oldOrder,$newOrder);
    1511. 

  1511.   }
    1512. 

  1512. 

  1513.   /// Mise à jour d'une rubrique dans de toutes les langues pour lesquel l'utilisateur à les droits
    1514. 

  1514.   function procEditAllLang($ar) {
    1515. 

  1515.     $ar['_langs']='all';
    1516. 

  1516.     return $this->procEdit($ar);
    1517. 

  1517.   }
    1518. 

  1518. 

  1519.   // verification que l'alias est valide et generation eventuelle d'un alias
    1520. 

  1520.   //
    1521. 

  1521.   function _checkAlias(&$alias, $oldalias, $oid, &$message, $title=NULL) {
    1522. 

  1522. 

  1523.     if(empty($alias) && !empty($title)) {
    1524. 

  1524.       $alias=rewriteToAscii($title);
    1525. 

  1525.     }
    1526. 

  1526.     /* verification que les alias sont bien constitués de 2 à 40 chiffres, lettres _ et - */
    1527. 

  1527.     $aliasfield=&$this->_categories->getField('alias');
    1528. 

  1528.     $aliaslength=$aliasfield->get_fcount();
    1529. 

  1529.     if(!preg_match('/^([a-zA-Z0-9_-]{1,'.$aliaslength.'})$/',$alias)) {
    1530. 

  1530.       $message=XLabels::getSysLabel('xmodinfotree.aliasnotcorrect').' '.$alias;
    1531. 

  1531.       $alias=$oldalias;
    1532. 

  1532.     }
    1533. 

  1533.     /* verification de l'unicite des alias */
    1534. 

  1534.      if(!empty($alias) ) {
    1535. 

  1535.       $req = "select count(*) from ".$this->_categories->getTable()." where alias='".$alias."' ";
    1536. 

  1536.       if(!empty($oid)) $req .= "and  KOID != '".$oid."' ";
    1537. 

  1537.       $cnt=countSelectQuery($req);
    1538. 

  1538.       if($cnt>0) {
    1539. 

  1539. 	$message=XLabels::getSysLabel('xmodinfotree.aliasunique').' '.$alias;
    1540. 

  1540. 	$alias=$oldalias;
    1541. 

  1541.       }
    1542. 

  1542.     }
    1543. 

  1543.     /* verification si l'alias est protege */
    1544. 

  1544.     if(($oldalias!=$alias) && !empty($oldalias) && $this->aliasIsProtected($oldalias)) {
    1545. 

  1545.       $message=XLabels::getSysLabel('xmodinfotree.aliasprotected').' '.$alias;
    1546. 

  1546.       $alias=$oldalias;
    1547. 

  1547.       $modif = 1;
    1548. 

  1548.     }
    1549. 

  1549.   }
    1550. 

  1550. 

  1551.   // test de circularité des redirections
    1552. 

  1552.   function _checkLinkin($oid, $linkin) {
    1553. 

  1553.     $path = $this->_getPathOids($oid);
    1554. 

  1554.     array_pop($path); // le dernier élément est vide
    1555. 

  1555.     // test la cible
    1556. 

  1556.     if (in_array($linkin, $path))
    1557. 

  1557.       return false;
    1558. 

  1558.     // test le lien de la cible
    1559. 

  1559.     $target_linkin = selectQuery("select {$this->linkin} from {$this->table} where koid='$linkin'")->fetch(PDO::FETCH_COLUMN);
    1560. 

  1560.     if ($target_linkin && in_array($target_linkin, $path))
    1561. 

  1561.       return false;
    1562. 

  1562.     // test les sous-noeuds de la cible
    1563. 

  1563.     return $this->_checkLinkinChild($linkin, $path);
    1564. 

  1564.   }
    1565. 

  1565. 

  1566.   // test de circularité des redirections pour les descendants
    1567. 

  1567.   function _checkLinkinChild($oid, $path) {
    1568. 

  1568.     $children = selectQuery("select KOID, {$this->linkin} from {$this->table} where linkup='$oid'")->fetchAll();
    1569. 

  1569.     foreach ($children as $child) {
    1570. 

  1570.       if ($child[$this->linkin] && in_array($child[$this->linkin], $path))
    1571. 

  1571.         return false;
    1572. 

  1572.       if (!$this->_checkLinkinChild($child['KOID'], $path))
    1573. 

  1573.         return false;
    1574. 

  1574.     }
    1575. 

  1575.     return true;
    1576. 

  1576.   }
    1577. 

  1577.   
    1578. 

  1578.   // Fonction de mise a jour de l'ordre d'affichage d'une rubrique.
    1579. 

  1579.   //
    1580. 

  1580.   function majUpOtherOrder($titre,$oid,$forder) {
    1581. 

  1581.     if ($oid == '' ) {
    1582. 

  1582.       $requete = 'UPDATE ' . $this->table .' set '.'corder'.
    1583. 

  1583. 	"=IF(corder<9,CONCAT('0',corder+1),corder+1) where title!='" .
    1584. 

  1584. 	$titre . "' and linkup = '' and corder>=" . $forder;
    1585. 

  1585.     } else {
    1586. 

  1586.       $requete = "UPDATE " . $this->table ." set corder=IF("."corder".
    1587. 

  1587. 	"<9,CONCAT('0',corder+1),corder+1) where title!='" . $titre.
    1588. 

  1588. 	"' and linkup = '$oid' and corder>=" . $forder;
    1589. 

  1589.     }
    1590. 

  1590.     updateQuery($requete);
    1591. 

  1591.   }
    1592. 

  1592. 

  1593.   // Fonction de mise a jour de l'ordre d'affichage d'une rubrique.
    1594. 

  1594.   //
    1595. 

  1595.   function majDownOtherOrder($titre,$oid,$forder) {
    1596. 

  1596.     if ($oid == '' ) {
    1597. 

  1597.       $requete = 'UPDATE ' . $this->table .' set corder=IF('.'corder'.
    1598. 

  1598. 	"<11,CONCAT('0',corder-1),corder-1) where title!='" .
    1599. 

  1599. 	$titre . "' and linkup = '' and corder>" . $forder;
    1600. 

  1600.     } else {
    1601. 

  1601.       $requete = 'UPDATE ' . $this->table .' set corder=IF('.'corder'.
    1602. 

  1602. 	"<9,CONCAT('0',corder-1),corder-1) where title!='" . $titre .
    1603. 

  1603. 	"' and linkup = '$oid' and corder>" . $forder;
    1604. 

  1604.     }
    1605. 

  1605.     updateQuery($requete);
    1606. 

  1606.   }
    1607. 

  1607. 

  1608.   // Fonction de mise a jour de l'ordre d'affichage d'une rubrique.
    1609. 

  1609.   //
    1610. 

  1610.   function majOtherOrder($titre,$oid,$oldOrder,$newOrder) {
    1611. 

  1611.     // Si augmente, -- sur les order > old et <= new
    1612. 

  1612.     // Si diminue, ++ sur les order >= new et < old
    1613. 

  1613. 

  1614.     if ( $newOrder > $oldOrder ) {
    1615. 

  1615.       // augmentation
    1616. 

  1616.       if ($oid == '' ) {
    1617. 

  1617. 	$requete = 'UPDATE ' . $this->table .' set corder=IF('.'corder'.
    1618. 

  1618. 	  "<11,CONCAT('0',corder-1),corder-1) where title!='" .
    1619. 

  1619. 	  $titre . "' and linkup = '' and corder>" . $oldOrder . " and ".
    1620. 

  1620. 	  "corder"." <=" . $newOrder;
    1621. 

  1621.       } else {
    1622. 

  1622. 	$requete = "UPDATE " . $this->table ." set corder=IF("."corder".
    1623. 

  1623. 	  "<11,CONCAT('0',corder-1),corder-1) where title!='" . $titre .
    1624. 

  1624. 	  "' and linkup = '$oid' and corder>" . $oldOrder . " and corder <=" .
    1625. 

  1625. 	  $newOrder;
    1626. 

  1626.       }
    1627. 

  1627.     }
    1628. 

  1628.     if ( $newOrder < $oldOrder ) {
    1629. 

  1629.       // diminution
    1630. 

  1630.       if ($oid == '' ) {
    1631. 

  1631. 	$requete = 'UPDATE ' . $this->table ." set corder=IF(corder<9,CONCAT('0',".
    1632. 

  1632. 	  "corder"."+1),corder-1) where title!='" . $titre . "' and ".
    1633. 

  1633. 	  "linkup = '' and corder>=" . $newOrder . " and corder <" . $oldOrder;
    1634. 

  1634.       } else {
    1635. 

  1635. 	$requete = 'UPDATE ' . $this->table ." set corder=IF(corder<9,CONCAT('0',".
    1636. 

  1636. 	  "corder"."+1),corder-1) where title!='" . $titre . "' and ".
    1637. 

  1637. 	  "linkup = '$oid' and corder>=" . $newOrder . " and corder <" . $oldOrder;
    1638. 

  1638.       }
    1639. 

  1639.     }
    1640. 

  1640.     updateQuery($requete);
    1641. 

  1641. 

  1642.   }
    1643. 

  1643. 

  1644.   //
    1645. 

  1645.   function confirmDel($ar=NULL) {
    1646. 

  1646.     global $XSHELL;
    1647. 

  1647. 

  1648.     $p = new XParam($ar, array(	"tplentry"=>$this->table));
    1649. 

  1649.     $oid=$p->get("oid");
    1650. 

  1650.     $lang=XShell::getLangData();
    1651. 

  1651. 

  1652.     $oidContenu = array();
    1653. 

  1653.     $this->browse(array("oid"=>$oid,"level"=>$niv), $oidContenu);
    1654. 

  1654. 

  1655.     $result = array();
    1656. 

  1656.     $result["oid"] = $oid;
    1657. 

  1657.     $result["level"] = $niv;
    1658. 

  1658.     $XSHELL->tpldata["$tplentry"] = $result;
    1659. 

  1659.   }
    1660. 

  1660. 

  1661.   // rend la liste des templates avec eventuellement un selecteur sur la table destination
    1662. 

  1662.   // si subset est un ensemble de koid (tableau), seules les reponses
    1663. 

  1663.   // deja presente dans ce tableau seront retournees
    1664. 

  1664.   //
    1665. 

  1665.   protected function &_templatesList($tabledst=NULL,$filter="page",$oidit=NULL) {
    1666. 

  1666.     if(!empty($oidit) && $this->_categories->fieldExists('alayout')) {
    1667. 

  1667.       $r2= &$this->_categories->display(array("oid"=>$oidit,
    1668. 

  1668. 					      "_options"=>array("error"=>"return"),
    1669. 

  1669. 					      "tplentry"=>TZR_RETURN_DATA,
    1670. 

  1670. 					      "fallback"=>true));
    1671. 

  1671.     }
    1672. 

  1672.     if(!empty($r2['oalayout']->oidcollection)) {
    1673. 

  1673.       $subset=$r2['oalayout']->oidcollection;
    1674. 

  1674.       if(!empty($tabledst)) {
    1675. 

  1675. 	$cond = $this->_templates->select_query(array("cond"=>array('tab'=>array("=",$tabledst),
    1676. 

  1676. 								    "modid"=>array("=",array($this->_moid,'')),
    1677. 

  1677. 								    "KOID"=>array("=",$subset))));
    1678. 

  1678.       } else {
    1679. 

  1679. 	$cond = $this->_templates->select_query(array("cond"=>array("modid"=>array("=",array($this->_moid,'')),
    1680. 

  1680. 								    "gtype"=>array("=",$filter),
    1681. 

  1681. 								    "KOID"=>array("=",$subset))));
    1682. 

  1682.       }
    1683. 

  1683.     } else {
    1684. 

  1684.       if(!empty($tabledst)) {
    1685. 

  1685. 	$cond = $this->_templates->select_query(array("cond"=>array('tab'=>array("=",$tabledst),
    1686. 

  1686. 								    "modid"=>array("=",array($this->_moid,'')))));
    1687. 

  1687.       } else {
    1688. 

  1688. 	$cond = $this->_templates->select_query(array("cond"=>array("modid"=>array("=",array($this->_moid,'')),
    1689. 

  1689. 								    "gtype"=>array("=",$filter))));
    1690. 

  1690.       }
    1691. 

  1691.     }
    1692. 

  1692.     $r=&$this->_templates->browse(array("select"=>$cond,"first"=>"0","last"=>"999","pagesize"=>99,
    1693. 

  1693. 					"order"=>'title',
    1694. 

  1694. 					"tplentry"=>TZR_RETURN_DATA,
    1695. 

  1695. 					"selectedfields"=>array("title","tab",'functions', 'modidd')));
    1696. 

  1696.     return $r;
    1697. 

  1697.   }
    1698. 

  1698. 

  1699.   // rend les donnees concernant un template d'oid fourni
    1700. 

  1700.   //
    1701. 

  1701.   function &_disp2Template($oidt=NULL) {
    1702. 

  1702.     $opt=array();
    1703. 

  1703.     $opt["oid"]=$oidt;
    1704. 

  1704.     $opt["tplentry"]=TZR_RETURN_DATA;
    1705. 

  1705.     $opt["_options"]=array("error"=>"return");
    1706. 

  1706.     $opt["fallback"]="true";
    1707. 

  1707.     $opt["_cacheobject"]="disp2template";
    1708. 

  1708.     $opt["_lastupdate"]=false;
    1709. 

  1709.     $r=$this->_templates->display($opt);
    1710. 

  1710.     return $r;
    1711. 

  1711.   }
    1712. 

  1712.   function editsection($ar) {
    1713. 

  1713.     global $XSHELL;
    1714. 

  1714.     $p = new XParam($ar, array("level"=>1,"tplentry"=>"it","toc"=>"1","maxlevel"=>1));
    1715. 

  1715.     $tplentry = $p->get("tplentry");
    1716. 

  1716.     $oidit = $p->get("oidit");
    1717. 

  1717.     $lang = XShell::getLangData();
    1718. 

  1718. 

  1719.     $oidsection=$p->get("oidsection");
    1720. 

  1720.     list($oidit,$oiddest,$oidtemplate)=$this->_getOids($oidsection);
    1721. 

  1721.     $tableofoid=Kernel::getTable($oiddest);
    1722. 

  1722.     // Browse des modeles de mise en page
    1723. 

  1723.     XShell::toScreen1('tple', $this->_templatesList($tableofoid,'page', $oidit));
    1724. 

  1724. 

  1725.     // infos d'affichage du template
    1726. 

  1726.     $r1=$this->_disp2Template($oidtemplate);
    1727. 

  1727.     XShell::toScreen1('tp',$r1);
    1728. 

  1728. 

  1729.     $xst = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$tableofoid);
    1730. 

  1730.     $ar["tplentry"]=TZR_RETURN_DATA;
    1731. 

  1731.     $ar['oid']=$oiddest;
    1732. 

  1732.     $ar['fallback']=true;
    1733. 

  1733.     if(empty($ar['fmoid'])) $ar['fmoid']=$this->_moid;
    1734. 

  1734.     $r=$xst->edit($ar);
    1735. 

  1735.     $s['olines'][]=$r;
    1736. 

  1736.     $s['olines_oid'][]=$oiddest;
    1737. 

  1737.     XShell::toScreen1('it',$s);
    1738. 

  1738.     XShell::toScreen1($tplentry,$r);
    1739. 

  1739.     XShell::toScreen2('section','oidit',$oidit);
    1740. 

  1740.     XShell::toScreen2('section','oidsection',$oidsection);
    1741. 

  1741.   }
    1742. 

  1742. 

  1743. 

  1744.   // affichage des donnees d'un objet particulier d'une page
    1745. 

  1745.   //
    1746. 

  1746.   function displaysection($ar) {
    1747. 

  1747.     $p = new XParam($ar, array("level"=>1,"tplentry"=>"it",
    1748. 

  1748. 			       "toc"=>"1","maxlevel"=>1));
    1749. 

  1749.     $tplentry = $p->get("tplentry");
    1750. 

  1750.     $oidsection = $p->get("oidsection");
    1751. 

  1751. 

  1752.     $lang = XShell::getLangData();
    1753. 

  1753.     $tab= XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$oidsection);
    1754. 

  1754.     if($tplentry==TZR_RETURN_DATA)
    1755. 

  1755.       return $tab->display(array("oid"=>$oidsection, "tplentry"=>TZR_RETURN_DATA));
    1756. 

  1756.     else
    1757. 

  1757.       $tab->display(array("oid"=>$oidsection, "tplentry"=>$tplentry));
    1758. 

  1758.   }
    1759. 

  1759. 

  1760.   /// Liste les types de sections qui peuvent etre créées
    1761. 

  1761.   public function addSection($ar=NULL){
    1762. 

  1762.     $p=new XParam($ar,NULL);
    1763. 

  1763.     $tplentry=$p->get('tplentry');
    1764. 

  1764.     $oidit=$p->get('oidit');
    1765. 

  1765.     $r['page']=&$this->_templatesList(NULL, 'page', $oidit);
    1766. 

  1766.     $r['query']=&$this->_templatesList(NULL, 'query', $oidit);
    1767. 

  1767.     $r['function']=&$this->_templatesList(NULL, 'function', $oidit);
    1768. 

  1768.     $r['position'] = selectQuery('select ORDER1 from '.$this->tname.' WHERE KOIDSRC="'.$oidit.'" order by ORDER1')->fetchAll(PDO::FETCH_COLUMN);
    1769. 

  1769.     $r['oidit']=$oidit;
    1770. 

  1770.     $modlist = XModule::modlist(array('tplentry'=>TZR_RETURN_DATA, 'basic' => 1, 'withmodules'=>1));
    1771. 

  1771.     for ($i=0; $i<count($modlist['lines_oid']); $i++) {
    1772. 

  1772.       $uiFunctions = $modlist['lines_mod'][$i]->getUIFunctionList();
    1773. 

  1773.       if ($modlist['lines_mod'][$i]->available_in_display_modules && !empty($uiFunctions)) {
    1774. 

  1774.         $r['modlist']['lines_oid'][] = $modlist['lines_oid'][$i];
    1775. 

  1775.         $r['modlist']['lines_mod'][] = $modlist['lines_mod'][$i];
    1776. 

  1776.         $r['modlist']['lines_name'][] = $modlist['lines_name'][$i];
    1777. 

  1777.         $r['modlist']['lines_group'][] = $modlist['lines_group'][$i];
    1778. 

  1778.         $r['modlist']['lines_toid'][] = $modlist['lines_toid'][$i];
    1779. 

  1779.         $r['modlist']['lines_classname'][] = $modlist['lines_classname'][$i];
    1780. 

  1780.         $r['modlist']['lines_functions'][] = $uiFunctions;
    1781. 

  1781.         $class = get_class($modlist['lines_mod'][$i]);
    1782. 

  1782.         $r['modlist']['lines_classes'][] = array_merge(class_parents($modlist['lines_mod'][$i]), array($class => $class));
    1783. 

  1783.       }
    1784. 

  1784.     }
    1785. 

  1785.     return XShell::toScreen1($tplentry,$r);
    1786. 

  1786.   }
    1787. 

  1787. 

  1788.   /// preparation de l'ecran de saisie d'une nouvelle section
    1789. 

  1789.   function newsection($ar) {
    1790. 

  1790.     global $XSHELL;
    1791. 

  1791.     $p = new XParam($ar, array("level"=>1,"tplentry"=>"it","toc"=>"1","maxlevel"=>1));
    1792. 

  1792.     $tplentry = $p->get("tplentry");
    1793. 

  1793.     $oidit = $p->get("oidit");
    1794. 

  1794.     $oidtpl = $p->get("oidtpl");
    1795. 

  1795.     $lang = XShell::getLangData();
    1796. 

  1796. 

  1797.     $tabletpl=Kernel::getTable($oidtpl);
    1798. 

  1798. 

  1799.     $rs=selectQuery("select * from $tabletpl where KOID='$oidtpl' AND LANG='$lang'");
    1800. 

  1800.     if($o1=$rs->fetch()) {
    1801. 

  1801.       $tabledst = $o1['tab'];
    1802. 

  1802. 

  1803.       // Browse des modeles de mise en page
    1804. 

  1804.       XShell::toScreen1('tple', $this->_templatesList($tabledst,"page",$oidit));
    1805. 

  1805. 

  1806.       // infos d'affichage du template
    1807. 

  1807.       $r1=$this->_disp2Template($oidtpl);
    1808. 

  1808.       XShell::toScreen1('tp',$r1);
    1809. 

  1809. 

  1810.       $xst = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$tabledst);
    1811. 

  1811.       $ar["tplentry"]=TZR_RETURN_DATA;
    1812. 

  1812.       if(empty($ar['fmoid'])) $ar['fmoid']=$this->_moid;
    1813. 

  1813.       $r=$xst->input($ar);
    1814. 

  1814.       $s['position']=$p->get('position');
    1815. 

  1815.       $s['oidit']=$p->get('oidit');
    1816. 

  1816.       $s['oidtpl']=$p->get('oidtpl');
    1817. 

  1817.       $s['olines'][]=$r;
    1818. 

  1818.       $s['olines_oid'][]=$xst->getNewOID($ar);
    1819. 

  1819.       XShell::toScreen1($tplentry,$s);
    1820. 

  1820.     }
    1821. 

  1821.   }
    1822. 

  1822. 

  1823.   function editquery($ar) {
    1824. 

  1824.     $p = new XParam($ar, array("level"=>1,"tplentry"=>"it","toc"=>"1","maxlevel"=>1));
    1825. 

  1825.     $tplentry = $p->get("tplentry");
    1826. 

  1826.     $oidsection = $p->get("oidsection");
    1827. 

  1827.     list($oidsrc,$oiddest,$oidtpl)=$this->_getOids($oidsection);
    1828. 

  1828.     // recherche de l'item
    1829. 

  1829.     $rs=selectQuery("select * from ".$this->tname." where ITOID='$oidsection'");
    1830. 

  1830.     if(!$ors=$rs->fetch()) return array();
    1831. 

  1831.     $qinit = unserialize($ors['QUERY']);
    1832. 

  1832.     // table des templates
    1833. 

  1833.     $rtpl=$this->_disp2Template($oidtpl);
    1834. 

  1834.     $tabledst = $rtpl['otab']->raw;
    1835. 

  1835.     XShell::toScreen1('tple',$this->_templatesList($tabledst,'query',$oidit));
    1836. 

  1836. 

  1837.     // table dans laquelle se trouvenet les donnes
    1838. 

  1838.     $table = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$tabledst);
    1839. 

  1839.     $query=array();
    1840. 

  1840.     if(is_array($qinit)) {
    1841. 

  1841.       $query['operator']=$qinit['operator'];
    1842. 

  1842.       foreach($table->desc as $k => $v) {
    1843. 

  1843. 	if(isset($qinit[$k]) || !empty($qinit[$k.'_PAR'])) {
    1844. 

  1844. 	  if($table->fieldExists($k)) {
    1845. 

  1845. 	    $query[$k]=$qinit['options'][$k];
    1846. 

  1846. 	    $query[$k]['value']=$qinit[$k];
    1847. 

  1847. 	    $query[$k]['op']=$qinit[$k.'_op'];
    1848. 

  1848. 	    $query[$k]['par']=$qinit[$k.'_PAR'];
    1849. 

  1849. 	    $query[$k]['fmt']=(isset($qinit[$k.'_FMT'])?$qinit[$k.'_FMT']:$qinit[$k.'_HID']);
    1850. 

  1850. 	    $query[$k]['notapplyqfmt']=true;
    1851. 

  1851. 	  } else {
    1852. 

  1852. 	    $query[$k]=$qinit[$k];
    1853. 

  1853. 	  }
    1854. 

  1854. 	}
    1855. 

  1855.       }
    1856. 

  1856.     }
    1857. 

  1857.     $ar['tplentry']=TZR_RETURN_DATA;
    1858. 

  1858.     $ar['options']=$query;
    1859. 

  1859.     $ar['querymode']='pquery';
    1860. 

  1860.     if(empty($ar['fmoid'])) $ar['fmoid']=$this->_moid;
    1861. 

  1861.     $r=$table->query($ar);
    1862. 

  1862.     $r['oidit']=$oidsrc;
    1863. 

  1863.     $r['_select']=$qinit['_select'];
    1864. 

  1864.     $r['oidsection']=$oidsection;
    1865. 

  1865.     $r['pagesize']=$qinit['pagesize'];
    1866. 

  1866.     $r['setup']=$oidtpl;
    1867. 

  1867.     $r['labelin']=$qinit['labelin'];
    1868. 

  1868.     if(is_array($qinit['order'])) {
    1869. 

  1869.       foreach($qinit['order'] as $ki=>$vi){
    1870. 

  1870. 	$torder=explode(" ",$qinit['order'][$ki]);
    1871. 

  1871. 	$r['order'][$ki]=$torder[0];
    1872. 

  1872. 	$r['_order'][$ki]=$torder[1];
    1873. 

  1873.       }
    1874. 

  1874.     } else {
    1875. 

  1875.       $torder=explode(" ",$qinit['order']);
    1876. 

  1876.       $r['order'][0]=$torder[0];
    1877. 

  1877.       $r['_order'][0]=$torder[1];
    1878. 

  1878.     }
    1879. 

  1879. 

  1880.     foreach($r['order'] as $ki=>$vi){
    1881. 

  1881.       $r['fieldselector'][$ki]=$table->order_selector(array('fieldname'=>'order[]','value'=>$r['order'][$ki],'random'=>($ki==0),
    1882. 

  1882. 							    'compulsory'=>($ki==0)
    1883. 

  1883. 							    )
    1884. 

  1884. 						      );
    1885. 

  1885.     }
    1886. 

  1886.     if(empty($r['fieldselector'][0])) $r['fieldselector'][0] = $table->order_selector(array('fieldname'=>'order[]',
    1887. 

  1887. 											    'value'=>'','compulsory'=>false));
    1888. 

  1888.     $r['emptyfieldselector'] = $table->order_selector(array('fieldname'=>'order[]','value'=>'','compulsory'=>false));
    1889. 

  1889.     $r['weborderselector'] = $table->order_selector(array('fieldname'=>'weborderselector[]','value'=>$qinit['weborderselector'],
    1890. 

  1890. 							  'compulsory'=>false,'random'=>false,'multiple'=>true));
    1891. 

  1891. 

  1892.     $oidit=$oidsrc;
    1893. 

  1893.     return XShell::toScreen1('section',$r);
    1894. 

  1894.   }
    1895. 

  1895.   function savequery($ar) {
    1896. 

  1896.     $p = new XParam($ar, array('level'=>1,'tplentry'=>'it','toc'=>'1','maxlevel'=>1));
    1897. 

  1897.     $tplentry = $p->get("tplentry");
    1898. 

  1898.     $oidsection = $p->get("oidsection");
    1899. 

  1899.     $weborderselector=$p->get('weborderselector');
    1900. 

  1900.     $hasselect=$p->get('hasselect');  // true si la section utilise le mode expert et que l'on sauve sans les droits root
    1901. 

  1901.     $labelin=$p->get('labelin');
    1902. 

  1902.     // recherche de l'item
    1903. 

  1903.     list($oidsrc,$oiddest,$oidtpl)=$this->_getOids($oidsection);
    1904. 

  1904.     // table des templates
    1905. 

  1905.     $rtpl=$this->_disp2Template($oidtpl);
    1906. 

  1906.     // table dans laquelle se trouvenet les donnes
    1907. 

  1907.     $table = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$rtpl['otab']->raw);
    1908. 

  1908.     if($hasselect){
    1909. 

  1909.       $rs=selectQuery("select * from ".$this->tname." where ITOID='$oidsection'");
    1910. 

  1910.       if($ors=$rs->fetch()){
    1911. 

  1911.  	$qinit=unserialize($ors['QUERY']);
    1912. 

  1912.  	$ar['_select']=$qinit['_select'];
    1913. 

  1913. 	$rs->closeCursor();
    1914. 

  1914.       }else{
    1915. 

  1915.  	$ar['_select']='';
    1916. 

  1916.       }
    1917. 

  1917.     }
    1918. 

  1918.     $st=$table->captureQuery($ar);
    1919. 

  1919.     $st['weborderselector']=$weborderselector;
    1920. 

  1920.     $st['labelin']=$labelin;
    1921. 

  1921.     $r=addslashes(serialize($st));
    1922. 

  1922.     updateQuery("UPDATE ".$this->tname." SET QUERY='$r' where ITOID='$oidsection'");
    1923. 

  1923.     $setup=$p->get("setup");
    1924. 

  1924.     updateQuery("UPDATE ".$this->tname." set KOIDTPL='$setup' where ITOID='$oidsection'");
    1925. 

  1925.     $ar["oidit"]=$oidsrc;
    1926. 

  1926.   }
    1927. 

  1927. 

  1928.   /// insertion d'une nouvelle section
    1929. 

  1929.   function insertsection($ar=NULL) {
    1930. 

  1930.     $p = new XParam($ar, array("level"=>1,"tplentry"=>"it","toc"=>"1","maxlevel"=>1));
    1931. 

  1931.     $tplentry = $p->get("tplentry");
    1932. 

  1932.     $oidit = $p->get("oidit");
    1933. 

  1933.     $lang = XShell::getLangData();
    1934. 

  1934.     $oidtpl=$p->get("oidtpl");
    1935. 

  1935.     $tabletpl = Kernel::getTable($oidtpl);
    1936. 

  1936.     $rs=selectQuery("select * from $tabletpl where KOID='$oidtpl' AND LANG='$lang'");
    1937. 

  1937.     if($o1=$rs->fetch()) {
    1938. 

  1938.       $tabledst = $o1['tab'];
    1939. 

  1939. 

  1940.       $position = $p->get("position")+1;
    1941. 

  1941.       $xst = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$tabledst);
    1942. 

  1942.       $ar2=$ar;
    1943. 

  1943.       $ar2['tplentry']=TZR_RETURN_DATA;
    1944. 

  1944.       $ar2['LANG_DATA']=$lang;
    1945. 

  1945.       $r=$xst->procInput($ar2);
    1946. 

  1946.       $oidsection=$r["oid"];
    1947. 

  1947.       updateQuery("UPDATE ".$this->tname." SET ORDER1=ORDER1+1 where KOIDSRC='$oidit' ".
    1948. 

  1948. 		  " AND ORDER1 >= $position");
    1949. 

  1949.       $nitoid=self::newItOid();
    1950. 

  1950.       updateQuery("INSERT INTO ".$this->tname." SET KOIDSRC='$oidit', KOIDDST='$oidsection',".
    1951. 

  1951. 		  "KOIDTPL='$oidtpl', ORDER1='$position', QUERY=NULL, ITOID='$nitoid'");
    1952. 

  1952.       $this->_reorderSections($oidit);
    1953. 

  1953.       $rs=selectQuery("select * from ".$this->tname." where KOIDSRC='$oidit' ".
    1954. 

  1954. 		       "and KOIDDST='$oidsection' and KOIDTPL='$oidtpl'");
    1955. 

  1955.       $return = NULL;
    1956. 

  1956.       if($rs && $ors=$rs->fetch()) {
    1957. 

  1957. 	$return = array("oid"=>$oidsection,"itoid"=>$ors['ITOID']);
    1958. 

  1958.       }
    1959. 

  1959.       $rs->closeCursor();
    1960. 

  1960.       return $return;
    1961. 

  1961.     }
    1962. 

  1962.   }
    1963. 

  1963. 

  1964.   /// generation d'une nouvelle cle dans la table de liaison
    1965. 

  1965.   protected function newItOid() {
    1966. 

  1966.     $id= substr(md5(uniqid(rand(), true)),0,40);
    1967. 

  1967.     return $id;
    1968. 

  1968.   }
    1969. 

  1969. 

  1970.   /// insertion d'une requete dans la page
    1971. 

  1971.   function insertquery($ar) {
    1972. 

  1972.     $p = new XParam($ar, array("level"=>1,"tplentry"=>"it","toc"=>"1","maxlevel"=>1));
    1973. 

  1973.     $oidtpl = $p->get("oidtpl");
    1974. 

  1974.     $lang = XShell::getLangData();
    1975. 

  1975.     $oidit = $p->get("oidit");
    1976. 

  1976.     $rs=selectQuery("select * from TEMPLATES where KOID='$oidtpl'");
    1977. 

  1977.     if($ors=$rs->fetch()) {
    1978. 

  1978.       $tabledst=$ors['tab'];
    1979. 

  1979.       $xst = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$tabledst);
    1980. 

  1980.       $position = $p->get("position")+1;
    1981. 

  1981.       updateQuery("UPDATE ".$this->tname." SET ORDER1=ORDER1+1 where KOIDSRC='$oidit' ".
    1982. 

  1982. 		  " AND ORDER1 > $position");
    1983. 

  1983.       $val=serialize(array('pagesize'=>20,'UPD'=>'xxxx'));
    1984. 

  1984.       $nitoid=self::newItOid();
    1985. 

  1985.       updateQuery("INSERT INTO ".$this->tname." SET KOIDSRC='$oidit', KOIDDST='', KOIDTPL='$oidtpl', ORDER1='$position',QUERY='$val', ITOID='$nitoid'");
    1986. 

  1986.     }
    1987. 

  1987.     $rs->closeCursor();
    1988. 

  1988.     $this->_reorderSections($oidit);
    1989. 

  1989.     $this->editpage($ar);
    1990. 

  1990.   }
    1991. 

  1991.   function _getOids($oidsection) {
    1992. 

  1992.     $rs=selectQuery("SELECT * FROM ".$this->tname." WHERE ITOID='$oidsection'");
    1993. 

  1993.     $ors=array();
    1994. 

  1994.     if($ors=$rs->fetch()) {
    1995. 

  1995.       $oidtemplate=$ors['KOIDTPL'];
    1996. 

  1996.       $oiddest=$ors['KOIDDST'];
    1997. 

  1997.       $oidit=$ors['KOIDSRC'];
    1998. 

  1998.       return array($oidit,$oiddest,$oidtemplate);
    1999. 

  1999.     } else {
    2000. 

  2000.       return NULL;
    2001. 

  2001.     }
    2002. 

  2002.   }
    2003. 

  2003. 

  2004.   /// Change l'ordre et/ou le parent d'une section
    2005. 

  2005.   public function moveSection($ar) {
    2006. 

  2006.     $p = new XParam($ar, array());
    2007. 

  2007.     $oidsection=$p->get("oidsection");
    2008. 

  2008.     $oidit=$p->get("oidit");
    2009. 

  2009.     $dir=$p->get("dir");
    2010. 

  2010. 

  2011.     if(!isset($oidsection)) {
    2012. 

  2012.       $oidsection=$p->get("_itoidselected");
    2013. 

  2013.       foreach($oidsection as $oid => $foo) {
    2014. 

  2014. 	$ar['oidsection']=$oid;
    2015. 

  2015. 	$this->moveSection($ar);
    2016. 

  2016.       }
    2017. 

  2017.       return;
    2018. 

  2018.     }
    2019. 

  2019. 

  2020.     $new_p=$p->get("_dest");
    2021. 

  2021.     if(!empty($new_p)){
    2022. 

  2022.       if(!Kernel::isAKoid($new_p)) $new_p=$this->getOidFromAlias($new_p);
    2023. 

  2023.     }else{
    2024. 

  2024.       $new_p=$oidit;
    2025. 

  2025.     }
    2026. 

  2026.     
    2027. 

  2027. 

  2028.     // securite: dans tous les cas, si on a pas les droits d'ecriture sur la source
    2029. 

  2029.     // on ne peut ni modifier l'ordre des sections, ni changer une section de page
    2030. 

  2030.     if(!$this->secure($oidit, ':rw')) return;
    2031. 

  2031.     if(($new_p!=$oidit ) && !$this->secure($new_p, ':rw')) return;
    2032. 

  2032. 

  2033.     $this->_reorderSections($oidit);
    2034. 

  2034.     if($new_p!=$oidit) $this->_reorderSections($new_p);
    2035. 

  2035. 

  2036.     $o=countSelectQuery('select distinct ORDER1 from '.$this->tname.' where ITOID="'.$oidsection.'"');
    2037. 

  2037.     if($dir=="top") {
    2038. 

  2038.       $new_o=0;
    2039. 

  2039.     } elseif($dir=="bottom") {
    2040. 

  2040.       $new_o=999;
    2041. 

  2041.     } elseif($dir=="up") {
    2042. 

  2042.       $new_o=$o-1;
    2043. 

  2043.       updateQuery('UPDATE '.$this->tname.' set ORDER1='.$o.' where ORDER1='.$new_o.' AND KOIDSRC="'.$oidit.'"');
    2044. 

  2044.     } elseif($dir=="down") {
    2045. 

  2045.       $new_o=$o+1;
    2046. 

  2046.       updateQuery('UPDATE '.$this->tname.' set ORDER1='.$o.' where ORDER1='.$new_o.' AND KOIDSRC="'.$oidit.'"');
    2047. 

  2047.     } elseif($dir=="to") {
    2048. 

  2048.       $new_o=0;
    2049. 

  2049.     } elseif(!empty($dir)) {
    2050. 

  2050.       $new_o=countSelectQuery('select distinct ORDER1 from '.$this->tname.' where ITOID="'.$dir.'"')+1;
    2051. 

  2051.       updateQuery('UPDATE '.$this->tname.' set ORDER1=ORDER1+1 where ORDER1>='.$new_o.' AND KOIDSRC="'.$oidit.'"');
    2052. 

  2052.     } else{
    2053. 

  2053.       $new_o=0;
    2054. 

  2054.     }
    2055. 

  2055.     updateQuery('UPDATE '.$this->tname.' set ORDER1='.$new_o.',KOIDSRC="'.$new_p.'" where ITOID="'.$oidsection.'"');
    2056. 

  2056. 

  2057.     $this->_reorderSections($oidit);
    2058. 

  2058.     if($new_p!=$oidit) $this->_reorderSections($new_p);
    2059. 

  2059.   }
    2060. 

  2060. 

  2061.   public function delSection($ar) {
    2062. 

  2062.     $p = new XParam($ar, array());
    2063. 

  2063.     $oidsection=$p->get("oidsection");
    2064. 

  2064.     if(!isset($oidsection)) {
    2065. 

  2065.       $oidsection=$p->get("_itoidselected");
    2066. 

  2066.       if(is_array($oidsection)) {
    2067. 

  2067. 	foreach($oidsection as $oidit => $foo) {
    2068. 

  2068. 	  $this->delSection(array("oidsection"=>$oidit));
    2069. 

  2069. 	}
    2070. 

  2070.       }
    2071. 

  2071.       return;
    2072. 

  2072.     }
    2073. 

  2073.     list($oidit,$oiddest,$oidtemplate)=$this->_getOids($oidsection);
    2074. 

  2074.     $lang = $p->get('LANG_DATA');
    2075. 

  2075.     if(!empty($oiddest)) {
    2076. 

  2076.       $k = new Kernel;
    2077. 

  2077.       $k->data_forcedDel(array("oid"=>$oiddest, "action"=>"OK","_selectedok"=>"nok"));
    2078. 

  2078.       if($lang == TZR_DEFAULT_LANG) {
    2079. 

  2079. 	updateQuery("delete FROM ".$this->tname." WHERE ITOID='$oidsection' ");
    2080. 

  2080.       }
    2081. 

  2081.     } else {
    2082. 

  2082.       updateQuery("delete FROM ".$this->tname." WHERE ITOID='$oidsection'");
    2083. 

  2083.     }
    2084. 

  2084.     $this->_reorderSections($oidit);
    2085. 

  2085.   }
    2086. 

  2086. 

  2087.   /// sauvegarde du contenu d'une section
    2088. 

  2088.   function savesection($ar) {
    2089. 

  2089.     $p = new XParam($ar, array("level"=>1,"tplentry"=>"it","toc"=>"1","maxlevel"=>1));
    2090. 

  2090.     $langs=$p->get('_langs');
    2091. 

  2091.     $oidsection=$p->get("oidsection");
    2092. 

  2092.     list($oidit,$oiddest,$oidtemplate)=$this->_getOids($oidsection);
    2093. 

  2093. 

  2094.     // verification des droits sur la page
    2095. 

  2095.     if(!$this->secure($oidit, ':rw')) return;
    2096. 

  2096. 

  2097.     $lang = $p->get('LANG_DATA');
    2098. 

  2098.     // Traitement des cas ou l'on veut sauver dans plusieurs langues
    2099. 

  2099.     $ar['_langs']=$this->getAuthorizedLangs($langs,$oidit,'savesection');
    2100. 

  2100. 

  2101.     $tabledst = Kernel::getTable($oiddest);
    2102. 

  2102.     $xst = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$tabledst);
    2103. 

  2103. 

  2104.     $ar2=$ar;
    2105. 

  2105.     $ar2['tplentry']=TZR_RETURN_DATA;
    2106. 

  2106.     $ar2['oid']=$oiddest;
    2107. 

  2107.     $xst->procEdit($ar2);
    2108. 

  2108.     $setup=$p->get("setup");
    2109. 

  2109.     $rq="UPDATE ".$this->tname." set KOIDTPL='$setup' where ITOID='$oidsection'";
    2110. 

  2110.     updateQuery($rq);
    2111. 

  2111.   }
    2112. 

  2112. 

  2113.   function dupsection($ar) {
    2114. 

  2114.     $p = new XParam($ar, array("level"=>1,"tplentry"=>"it","toc"=>"1","maxlevel"=>1));
    2115. 

  2115.     $oidsection=$p->get("oidsection");
    2116. 

  2116.     list($oidit,$oiddest,$oidtemplate)=$this->_getOids($oidsection);
    2117. 

  2117.     $lang = $p->get('LANG_DATA');
    2118. 

  2118. 

  2119.     $tabledst = Kernel::getTable($oiddest);
    2120. 

  2120.     $xst = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$tabledst);
    2121. 

  2121.     $r=$xst->procEditDup(array("oid"=>$oiddest,"tplentry"=>TZR_RETURN_DATA));
    2122. 

  2122.     $setup=$p->get("setup");
    2123. 

  2123.     $koiddup=$r['oid'];
    2124. 

  2124.     $n=self::newItOid();
    2125. 

  2125.     $rq="INSERT INTO ".$this->tname." set KOIDTPL='$setup',KOIDSRC='$oidit',KOIDDST='$koiddup',ITOID='$n'";
    2126. 

  2126.     updateQuery($rq);
    2127. 

  2127.   }
    2128. 

  2128. 

  2129.   function editCat($ar=NULL) {
    2130. 

  2130.     $p=new XParam($ar,array());
    2131. 

  2131.     $oid=$p->get('oid');
    2132. 

  2132.     $tplentry=$p->get('tplentry');
    2133. 

  2133.     $ar['tplentry']=TZR_RETURN_DATA;
    2134. 

  2134.     if(empty($ar['fmoid'])) $ar['fmoid']=$this->_moid;
    2135. 

  2135.     $r2=$this->_categories->edit($ar);
    2136. 

  2136.     if(!empty($this->cattemplate)) {
    2137. 

  2137.       $r1=$this->_templates->display(array('tplentry'=>TZR_RETURN_DATA,'_options'=>array('error'=>'return'),'oid'=>$this->cattemplate));
    2138. 

  2138.       XShell::toScreen1('cat_mitt',$r1);
    2139. 

  2139.     }
    2140. 

  2140.     if($this->_categories->fieldExists('tpl')) XShell::toScreen1('tple',$this->_templatesList(NULL,'page_site',$oidit));
    2141. 

  2141.     if(XShell::admini_mode() && $this->object_sec) {
    2142. 

  2142.       $acl=$GLOBALS['XUSER']->listObjectAccess($this, XShell::getLangData(),$oid);
    2143. 

  2143.       $r2=array_merge($r2, $acl);
    2144. 

  2144.       $sec=$GLOBALS['XUSER']->getObjectAccess($this, XShell::getLangData(),$oid);
    2145. 

  2145.       $sec=array_flip($sec[0]);
    2146. 

  2146.       $r2['object_sec']=$sec;
    2147. 

  2147.     }
    2148. 

  2148.     if ($this->linkin)
    2149. 

  2149.       $r2['linkin']=$this->linkin;
    2150. 

  2150.     if (XShell::admini_mode()) {
    2151. 

  2151.       $r2['_publishLevel'] = array_shift($this->secGroups('publish'));
    2152. 

  2152.     }
    2153. 

  2153.     return XShell::toScreen1($tplentry, $r2);
    2154. 

  2154.   }
    2155. 

  2155. 

  2156.   function editpage($ar=NULL) {
    2157. 

  2157.     return $this->viewpage($ar);
    2158. 

  2158.   }
    2159. 

  2159. 

  2160.   /**
    2161. 

  2161.    Genère une liste des section classer par date de maj pour génération d'un rss
    2162. 

  2162.    oids : Array : tableau d'oid des rubrique a traiter
    2163. 

  2163.    return : Array :tableau d'element rss title,txt,image et date
    2164. 

  2164.   */
    2165. 

  2165.   public function &rss($ar=NULL)  {
    2166. 

  2166.     $p = new XParam($ar);
    2167. 

  2167.     $tplentry = $p->get('tplentry');
    2168. 

  2168.     if( empty($tplentry)) $tplentry = 'rss';
    2169. 

  2169.     $oids = $p->get('oids');
    2170. 

  2170.     if(!is_array($oids)){
    2171. 

  2171.       $oids = array($oids);
    2172. 

  2172.     }
    2173. 

  2173.     $res = array();
    2174. 

  2174.     $res['descr'] = '';
    2175. 

  2175.     $res['title'] = '';
    2176. 

  2176.     $res['items'] = array();
    2177. 

  2177.     foreach($oids as $k=>$v){
    2178. 

  2178.       $rub = $this->viewpage(array('oidit'=>$v,'alias'=>''));
    2179. 

  2179.       //dissocier le faite qu'il y ai 1 ou plusieurs rubriques
    2180. 

  2180.       if(count($oids) == 1) {
    2181. 

  2181. 	$res['descr'] = strip_tags($rub['cat_mit']['odescr']->html);
    2182. 

  2182. 	$res['title'] = $rub['cat_mit']['otitle']->html;
    2183. 

  2183.       }else{
    2184. 

  2184. 	$res['descr'] .= $rub['cat_mit']['title']." ";
    2185. 

  2185. 	$res['title'] = XIni::get('societe');
    2186. 

  2186.       }
    2187. 

  2187.       $res['UPD'] = '';
    2188. 

  2188.       foreach($rub['olines'] as $key => $section){
    2189. 

  2189. 	$tk = $section['oUPD']->raw.'_'.$key;
    2190. 

  2190. 

  2191. 	$res['items'][$tk] = array();
    2192. 

  2192. 	$res['items'][$tk]['pubDate'] = date("D, d M Y H:i:s O", strtotime($section['oUPD']->raw));
    2193. 

  2193. 	$res['items'][$tk]['UPD'] =  $section['UPD'];
    2194. 

  2194. 	if($section['oUPD']->raw > $res['UPD']) $res['UPD'] = $section['oUPD']->raw;
    2195. 

  2195. 	$res['items'][$tk]['oid'] = $section['oid'];
    2196. 

  2196. 	$res['items'][$tk]['rub'] = $rub['cat_mit']['oid'];
    2197. 

  2197. 	if($section['odescription']->raw){
    2198. 

  2198. 	  $res['items'][$tk]['description'] = $section['description'];
    2199. 

  2199. 	  $res['items'][$tk]['odescription'] = $section['odescription'];
    2200. 

  2200. 	}
    2201. 

  2201. 	foreach($section['fields_object'] as $obj){
    2202. 

  2202. 	  if($obj->fielddef->ftype == 'XShortTextDef' && empty($res['items'][$tk]['title']) && !empty($section['o'.$obj->field]->raw)){
    2203. 

  2203. 	    $res['items'][$tk]['title'] = $section['o'.$obj->field]->html;
    2204. 

  2204. 	    $res['items'][$tk]['otitle'] = $section['o'.$obj->field];
    2205. 

  2205. 	  }elseif(($obj->fielddef->ftype == 'XTextDef' || $obj->fielddef->ftype == 'XRichTextDef') && empty($res['items'][$tk]['description']) && !empty($section['o'.$obj->field]->raw) ){
    2206. 

  2206. 	    $res['items'][$tk]['description'] = $section['o'.$obj->field]->html;
    2207. 

  2207. 	    $res['items'][$tk]['odescription'] = $section['o'.$obj->field];
    2208. 

  2208. 	  }elseif($obj->fielddef->ftype == 'XImageDef' && empty($res['items'][$tk]['img']) && !empty($section['o'.$obj->field]->raw) ){
    2209. 

  2209. 	    $res['items'][$tk]['img'] = $section['o'.$obj->field]->html;
    2210. 

  2210. 	    $res['items'][$tk]['oimg'] = $section['o'.$obj->field];
    2211. 

  2211. 	  }
    2212. 

  2212. 	};
    2213. 

  2213.       }
    2214. 

  2214.     }
    2215. 

  2215.     rsort($res['items']);
    2216. 

  2216. 

  2217.     return XShell::toScreen1($tplentry,$res);
    2218. 

  2218.   }
    2219. 

  2219.   /** Browse les paragraphes d'une rubrique, tries selon leur numero d'ordre.
    2220. 

  2220.    Pour chaque paragraphe, display son contenu (document).
    2221. 

  2221.    Produit les structures suivantes :
    2222. 

  2222.    olines[indice paragraphe] = array produit par le display du contenu (document/thumb/photo/fichier).
    2223. 

  2223.    tlines[indice paragraphe] = template de visualisation du contenu (document/thumb/photo/fichier).
    2224. 

  2224.   */
    2225. 

  2225.   public function &viewpage($ar=NULL)  {
    2226. 

  2226.     $p = new XParam($ar, array("level"=>1,"tplentry"=>"it","toc"=>"1","maxlevel"=>1,"first"=>"0",
    2227. 

  2227. 			       "nodecontent"=>true,"_nav"=>"1","autoxhtml"=>false,'_linkin'=>true,'keepalive'=>false));
    2228. 

  2228.     $tplentry = $p->get("tplentry");
    2229. 

  2229.     $alias = $p->get("alias");
    2230. 

  2230.     $defaultalias = $p->get("defaultalias");
    2231. 

  2231.     $erroralias = $p->get("erroralias");
    2232. 

  2232.     $authalias = $p->get("authalias");
    2233. 

  2233.     if(empty($authalias)) $authalias=$erroralias;
    2234. 

  2234.     $oidit = $p->get("oidit");
    2235. 

  2235.     $linkin = $p->get("_linkin");
    2236. 

  2236.     XLogs::debug('XModInfoTree::viewpage: start '.$alias.' '.$oidit);
    2237. 

  2237.     $result = XShell::from_screen($tplentry);
    2238. 

  2238. 

  2239.     // calcul des alias et des oidit
    2240. 

  2240.     if(empty($alias) && empty($oidit)) {
    2241. 

  2241.       $alias=$defaultalias;
    2242. 

  2242.       XLogs::debug('XModInfoTree::viewpage: falling back to '.$defaultalias);
    2243. 

  2243.     }
    2244. 

  2244. 

  2245.     if(empty($alias) && !Kernel::isAKoid($oidit)) { $alias=$oidit; $oidit="";}
    2246. 

  2246. 

  2247.     if(!empty($alias)) {
    2248. 

  2248.       $oidit=$this->getOidFromAlias($alias);
    2249. 

  2249.     }
    2250. 

  2250. 

  2251.     // dans le cas ou cette rubrique est un lien, recherche du lien
    2252. 

  2252.     if ($linkin) { 
    2253. 

  2253.       $result['baseoidit'] = $oidit;
    2254. 

  2254.       $oidit=$this->_followLinkIn($oidit);
    2255. 

  2255.     }
    2256. 

  2256. 

  2257.     // verification dans le cas ou il y a un aliastop
    2258. 

  2258.     $aliastop=$p->get('pagetop');
    2259. 

  2259.     if(!empty($aliastop)) {
    2260. 

  2260.       $navig = $this->getPath($oidit); /* calcul des chemins d'acces */
    2261. 

  2261.       $aliasdown=$navig['aliasdown'];
    2262. 

  2262.       if(!in_array($aliastop, $aliasdown)) return $this->redirect404($ar);
    2263. 

  2263.     }
    2264. 

  2264. 

  2265.     $first = $p->get("first");
    2266. 

  2266.     $keepalive=$p->get('keepalive');
    2267. 

  2267. 

  2268.     // recherche des langues
    2269. 

  2269.     $LANG_DATA = XShell::getLangData($p->get("LANG_DATA"));
    2270. 

  2270.     $LANG_TRAD = XShell::getLangTrad($p->get("LANG_TRAD"),$p->get('_notrad'));
    2271. 

  2271.     // verification des droits sur la rubrique
    2272. 

  2272.     $class=get_class($this);
    2273. 

  2273.     $moid=$this->_moid;
    2274. 

  2274.     if(empty($this->object_sec) || $this->secure($oidit,'viewpage',null,$LANG_DATA)) {
    2275. 

  2275.       debug("XModinfoTree:auth:ok |".get_class($this).'|viewpage|'.$this->_moid."|$LANG_DATA|$oidit| user".XUser::get_current_user_uid());
    2276. 

  2276.     } else {
    2277. 

  2277.       XLogs::critical("XModinfoTree:auth:access denied |$class|viewpage|$moid|$LANG_DATA|$oidit| user ".XUser::get_current_user_uid());
    2278. 

  2278.       $ar['alias']=$authalias;
    2279. 

  2279.       return $this->viewpage($ar);
    2280. 

  2280.     }
    2281. 

  2281. 

  2282.     $pagesize = $p->get("pagesize");
    2283. 

  2283.     $total_estimated = $p->get("total");
    2284. 

  2284.     $toc=$p->get("toc");
    2285. 

  2285.     $maxlevel=$p->get("maxlevel");
    2286. 

  2286.     $nodecontent=$p->get("nodecontent");
    2287. 

  2287.     $_format=$p->get("_format");
    2288. 

  2288.     // Informations de la page
    2289. 

  2289.     $result['cat_mit']=$this->_categories->display(array('oid'=>$oidit,'_options'=>array('error'=>'return'),'tplentry'=>TZR_RETURN_DATA,'fallback'=>true));
    2290. 

  2290.     // Redirection 404 si la page n'existe pas
    2291. 

  2291.     if(!XShell::admini_mode() && $alias!='error404' && !is_array($result['cat_mit'])) return $this->redirect404($ar);
    2292. 

  2292. 

  2293.     // date de derniere mise a jour de la page
    2294. 

  2294.     $lastpageupdate=$result["cat_mit"]['oUPD'];
    2295. 

  2295.     if($this->_categories->fieldExists('tpl')) {
    2296. 

  2296.       $r1=&$this->_templates->rDisplay($result["cat_mit"]["otpl"]->raw, array(), false, $LANG_DATA, XShell::getLangUser(),
    2297. 

  2297. 				       array('_charset'=>$_REQUEST['_charset']));
    2298. 

  2298.       if(is_array($r1)) {
    2299. 

  2299. 	$result["cat_mit"]["otpl"]=&$r1['odisp'];
    2300. 

  2300.       }
    2301. 

  2301.     }
    2302. 

  2302.     // dans le cas ou on trouve une taille de page dans la rubrique a afficher, cette taille est prioritaire
    2303. 

  2303.     if(empty($pagesize)){
    2304. 

  2304.       if(!empty($result['cat_mit']['opgz']->raw)) $pagesize=$result['cat_mit']['opgz']->raw;
    2305. 

  2305.       else{
    2306. 

  2306.         $pagesize=XIni::get('xmodinfotree_pagesize');
    2307. 

  2307.         if(empty($pagesize)) $pagesize=99;
    2308. 

  2308.       }
    2309. 

  2309.     }
    2310. 

  2310. 

  2311.     $cond = 'KOIDSRC="'.$oidit.'" ';
    2312. 

  2312.     if(!$nodecontent) {
    2313. 

  2313.       $cond="";
    2314. 

  2314.       $oidits=$this->getSubCats($oidit, $LANG_DATA);
    2315. 

  2315.       foreach($oidits as $i=>$oid1) $cond.='KOIDSRC= "'.$oid1.'" OR ';
    2316. 

  2316.       $cond.="KOIDSRC= '$oid1'";
    2317. 

  2317.     }
    2318. 

  2318.     $rs=selectQuery('SELECT * FROM '.$this->tname.' WHERE '.$cond.' ORDER BY ORDER1');
    2319. 

  2319. 

  2320.     // On regarde si on demande un oid particulièr pour définir le first en automatique (oidsec : oid d'une fiche d'une rubrique dynamique)
    2321. 

  2321.     $oidsec=$p->get('oidsec');
    2322. 

  2322.     if(!XShell::admini_mode() && !empty($oidsec) && $rs->rowCount()>0){
    2323. 

  2323.       $myfirst = 0;
    2324. 

  2324.       $fnd = false;
    2325. 

  2325.       $tpldatas=array();
    2326. 

  2326.       while(($ors1=$rs->fetch()) && !$fnd) {
    2327. 

  2327. 	$query_1 = $ors1['QUERY'];
    2328. 

  2328. 	$oiditd_1 = $ors1['KOIDDST'];
    2329. 

  2329. 	$oidittpl_1 = $ors1['KOIDTPL'];
    2330. 

  2330. 	if(!isset($tpldatas[$oidittpl_1])) {
    2331. 

  2331. 	  $tpl=&$this->_disp2Template($oidittpl_1);
    2332. 

  2332. 	  if(is_array($tpl)) $tpldatas[$oidittpl_1]=&$tpl;
    2333. 

  2333. 	  else $tpldatas[$oidittpl_1]=NULL;
    2334. 

  2334. 	}
    2335. 

  2335. 	// on regarde si on doit generer en automatique cette section
    2336. 

  2336. 	if($tpldatas[$oidittpl_1]==NULL) continue;
    2337. 

  2337. 	$tabledst = $tpldatas[$oidittpl_1]['otab']->raw;
    2338. 

  2338. 	$moddest = $tpldatas[$oidittpl_1]['omodidd']->raw;
    2339. 

  2339. 	if(empty($xsts[$tabledst])) {
    2340. 

  2340. 	  if(XSystem::tableExists($tabledst))
    2341. 

  2341. 	    $xsts[$tabledst]=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$tabledst);
    2342. 

  2342. 	  else
    2343. 

  2343. 	    continue;
    2344. 

  2344. 	}
    2345. 

  2345. 	$xst = &$xsts[$tabledst];
    2346. 

  2346. 	$mymoddest=NULL;
    2347. 

  2347. 	if(!empty($moddest)) {
    2348. 

  2348. 	  $mymoddest=XModule::objectFactory($moddest);
    2349. 

  2349. 	}
    2350. 

  2350. 	$sessid='queryobject'.$oidit;
    2351. 

  2351. 	if(empty($oiditd_1)) {
    2352. 

  2352. 	  $query2_1['tplentry']=TZR_RETURN_DATA;
    2353. 

  2353. 	  $query2_1['LANG_DATA']=$LANG_DATA;
    2354. 

  2354. 	  $query2_1['selectedfields']=array();
    2355. 

  2355. 	  $query2_1['first']=0;
    2356. 

  2356. 	  $query2_1['searchmode']='simple';
    2357. 

  2357. 	  $query2_1=unserialize($query_1);
    2358. 

  2358. 	  // on a garde en session les parametres
    2359. 

  2359. 	  if(issetSessionVar($sessid)) {
    2360. 

  2360. 	    $query2_1=getSessionVar($sessid)+$query2_1;
    2361. 

  2361. 	  }
    2362. 

  2362. 	  $qures=&$xst->procQuery($query2_1);
    2363. 

  2363.           foreach($qures['lines_oid'] as $krs => $vrs){
    2364. 

  2364. 	    if($vrs == $oidsec){
    2365. 

  2365. 	      $first = $myfirst;
    2366. 

  2366. 	      $fnd = true;
    2367. 

  2367. 	      break;
    2368. 

  2368. 	    }else $myfirst++;
    2369. 

  2369.           }
    2370. 

  2370.         }else{
    2371. 

  2371. 	  $myfirst++;
    2372. 

  2372.         }
    2373. 

  2373.       }
    2374. 

  2374.       $rs->closeCursor();
    2375. 

  2375.       $rs=selectQuery('SELECT * FROM '.$this->tname.' WHERE '.$cond.' ORDER BY ORDER1');
    2376. 

  2376.     }
    2377. 

  2377. 

  2378.     $o=array();
    2379. 

  2379.     $itoid=array();
    2380. 

  2380.     $total = $rs->rowCount();
    2381. 

  2381.     $t=array();
    2382. 

  2382.     $order1=array();
    2383. 

  2383.     $query2=NULL;
    2384. 

  2384. 

  2385.     $xsts=array();
    2386. 

  2386.     $tpldatas=array();
    2387. 

  2387.     $ot=array();
    2388. 

  2388.     $idx = 0;
    2389. 

  2389.     $ors=array();
    2390. 

  2390.     $idx2=0;
    2391. 

  2391.     while($rs && ($ors=$rs->fetch()) && ($idx < ($first+$pagesize))) {
    2392. 

  2392.       XLogs::debug("[section] viewpage $idx");
    2393. 

  2393.       $query = $ors['QUERY'];
    2394. 

  2394.       $oiditd = $ors['KOIDDST'];
    2395. 

  2395.       $oidittpl = $ors['KOIDTPL'];
    2396. 

  2396.       if(!isset($tpldatas[$oidittpl])) {
    2397. 

  2397. 	$tpl=&$this->_disp2Template($oidittpl);
    2398. 

  2398. 	if(is_array($tpl)) $tpldatas[$oidittpl]=&$tpl;
    2399. 

  2399. 	else $tpldatas[$oidittpl]=NULL;
    2400. 

  2400.       }
    2401. 

  2401.       // on regarde si on doit generer en automatique cette section
    2402. 

  2402.       if($tpldatas[$oidittpl]==NULL) continue;
    2403. 

  2403.       $tabledst = $tpldatas[$oidittpl]['otab']->raw;
    2404. 

  2404.       $moddest = $tpldatas[$oidittpl]['omodidd']->raw;
    2405. 

  2405.       if(empty($xsts[$tabledst]) && !empty($tabledst)) {
    2406. 

  2406. 	if(XSystem::tableExists($tabledst))
    2407. 

  2407. 	  $xsts[$tabledst]=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$tabledst);
    2408. 

  2408. 	else
    2409. 

  2409. 	  continue;
    2410. 

  2410.       }
    2411. 

  2411. 

  2412.       if(!empty($tabledst)) {
    2413. 

  2413. 	$xst = &$xsts[$tabledst];
    2414. 

  2414. 	$mymoddest=NULL;
    2415. 

  2415. 	if(!empty($moddest)) {
    2416. 

  2416. 	  $mymoddest=XModule::objectFactory($moddest);
    2417. 

  2417. 	}
    2418. 

  2418.       }
    2419. 

  2419.       $sessid='queryobject'.$oidit;
    2420. 

  2420.       // Section de type fonction
    2421. 

  2421.       if(empty($oiditd) && $tpldatas[$oidittpl]['ogtype']->raw=='function'){
    2422. 

  2422. 	$ot=$this->viewFunction($oidit,$oidittpl,$ors['ITOID'],$query);
    2423. 

  2423. 	// Si pas de droit et qu'on est sur la page d'edition des sections, on remplace le template par le template affichant un message d'information
    2424. 

  2424. 	if($ot===false && $idx>=$first && XShell::admini_mode() && XShell::getTemplate()=='xmodinfotree/viewpage.html'){
    2425. 

  2425. 	  $idx++;
    2426. 

  2426. 	  $o[$idx2]=array('_functionparams'=>1);
    2427. 

  2427. 	  $itoid[$idx2]=$ors['ITOID'];
    2428. 

  2428. 	  $t[$idx2]=&$this->_disp2Template('TEMPLATES:UNAUTH');
    2429. 

  2429. 	  $order1[$idx2]=$ors['ORDER1'];
    2430. 

  2430. 	  $idx2++;
    2431. 

  2431. 	}elseif(is_array($ot) && $idx>=$first) {
    2432. 

  2432. 	  $idx++;
    2433. 

  2433. 	  $o[$idx2]=$ot;
    2434. 

  2434. 	  $itoid[$idx2]=$ors['ITOID'];
    2435. 

  2435. 	  $t[$idx2]=$tpldatas[$oidittpl];
    2436. 

  2436. 	  $order1[$idx2]=$ors['ORDER1'];
    2437. 

  2437. 	  $idx2++;
    2438. 

  2438. 	}elseif(is_array($ot)) {
    2439. 

  2439. 	  $idx++;
    2440. 

  2440. 	}
    2441. 

  2441.       }elseif(empty($oiditd)) {
    2442. 

  2442. 	// generation des infos de visualisation du paragraphe
    2443. 

  2443. 	// cas ou il s'agit d'une requete
    2444. 

  2444. 	// on realise la requete et on developpe
    2445. 

  2445. 	// Gestion de l'ordre : soit order = champ asc/desc, soit order=champ et _order=asc/desc
    2446. 

  2446. 	$qorder=NULL;
    2447. 

  2447. 	$order=$p->get('order');
    2448. 

  2448. 	$_order=$p->get('_order');
    2449. 

  2449. 	$forder=explode(' ',$order);
    2450. 

  2450. 	$forder=$forder[0];
    2451. 

  2451. 	$query2=unserialize($query);
    2452. 

  2452. 	if(!empty($forder)){
    2453. 

  2453. 	  if(in_array($forder,$query2['weborderselector'])){
    2454. 

  2454. 	    $query2['order']=$order;
    2455. 

  2455. 	    if(!empty($_order)) $query2['order'].=' '.$_order;
    2456. 

  2456. 	    $qorder=$query2['order'];
    2457. 

  2457. 	  }
    2458. 

  2458. 	}
    2459. 

  2459. 	if($first==0 && !$keepalive) clearSessionVar($sessid);
    2460. 

  2460. 	if(issetSessionVar($sessid)) {
    2461. 

  2461. 	  $query2=$query2+getSessionVar($sessid);
    2462. 

  2462. 	}
    2463. 

  2463. 	$query2['tplentry']=TZR_RETURN_DATA;
    2464. 

  2464. 	$query2['LANG_DATA']=$LANG_DATA;
    2465. 

  2465. 	$query2['selectedfields']=array('KOID');
    2466. 

  2466. 	$query2['first']=0;
    2467. 

  2467. 	$query2['searchmode']='simple';
    2468. 

  2468. 	$query2['fmoid'] = $tpldatas[$oidittpl]['omodidd']->raw;
    2469. 

  2469. 	// prepararation du formulaire interactif lorsqu'il y a une requete parametree
    2470. 

  2470. 	$dynquery=$xst->prepareQuery($query2);
    2471. 

  2471. 	$parametrized=$dynquery['parametrized'];
    2472. 

  2472. 	// on a garde en session les parametres
    2473. 

  2473. 	if(issetSessionVar($sessid)) {
    2474. 

  2474. 	  $query2=getSessionVar($sessid)+$query2;
    2475. 

  2475. 	  if(!empty($qorder)) $query2['order']=$qorder;
    2476. 

  2476. 	}
    2477. 

  2477. 	// Si l'ordre est aléatoire, on fourni un entier à rand pour que la pagination... garde le meme ordre
    2478. 

  2478. 	if(substr($query2['order'],0,6)=='RAND()') $query2['order']='RAND('.rand(1,100000).')';
    2479. 

  2479. 	// execution de la requete. query2 contient les donnees de
    2480. 

  2480. 	// requete interactive ainsi que les donnees de requete stockee
    2481. 

  2481. 	// on recupere d'abord le filtre du module si il existe
    2482. 

  2482. 	if( !empty($mymoddest) ){
    2483. 

  2483. 	  $mymodfilter = $mymoddest->getFilter();
    2484. 

  2484. 	  if($mymodfilter) $query2['_filter'] = $mymodfilter;
    2485. 

  2485. 	}
    2486. 

  2486. 	$queryres=&$xst->procQuery($query2);
    2487. 

  2487. 	if(!empty($queryres['order'])) $order=$queryres['order'];
    2488. 

  2488. 	foreach($query2['weborderselector'] as $f){
    2489. 

  2489. 	  if(!empty($f)) $dynquery['weborderselector'][]=array('field'=>$f,'label'=>&$xst->desc[$f]->label,'selected'=>($f==$order));
    2490. 

  2490. 	}
    2491. 

  2491. 

  2492. 	// on ne met quelque chose en session que si cela est necessaire
    2493. 

  2493. 	if($parametrized){
    2494. 

  2494. 	  $ok=false;
    2495. 

  2495. 	  foreach($queryres['queryobject'] as $tmp){
    2496. 

  2496. 	    if(!empty($tmp)){
    2497. 

  2497. 	      $ok=true;
    2498. 

  2498. 	      break;
    2499. 

  2499. 	    }
    2500. 

  2500. 	  }
    2501. 

  2501. 	  if($ok) setSessionVar($sessid,$queryres['queryobject']);
    2502. 

  2502. 	}
    2503. 

  2503. 	$ntmp=count($queryres['lines_oid']);
    2504. 

  2504. 	if($ntmp>0) $total+=$ntmp-1;
    2505. 

  2505. 	$boq=true;
    2506. 

  2506. 	$qdisp=1;
    2507. 

  2507. 	for($q=0;($q<$ntmp) && ($idx < ($first+$pagesize));$q++) {
    2508. 

  2508. 	  if($idx>=$first) {
    2509. 

  2509. 	    $oidt1=$queryres['lines_oid'][$q];
    2510. 

  2510. 	    if(is_object($mymoddest)) {
    2511. 

  2511. 	      $ot=$mymoddest->display(array('oid'=>$oidt1, 'tplentry'=>TZR_RETURN_DATA,'_format'=>$_format,
    2512. 

  2512. 					    '_options'=>array('error'=>'return'),'_dynquerymode'=>true,
    2513. 

  2513. 					    '_cacheobject'=>'vwp'.$this->_moid,'ssmoid'=>'all'));
    2514. 

  2514. 	    } else {
    2515. 

  2515. 	      $ot=$xst->display(array('oid'=>$oidt1, 'tplentry'=>TZR_RETURN_DATA,'_format'=>$_format,
    2516. 

  2516. 				      '_options'=>array('error'=>'return'),'_dynquerymode'=>true,
    2517. 

  2517. 				      '_cacheobject'=>'vwp'.$this->_moid));
    2518. 

  2518. 	    }
    2519. 

  2519. 	  }
    2520. 

  2520. 	  if(is_array($ot) && ($idx>=$first)) {
    2521. 

  2521. 	    if((($first+$pagesize-1)==$idx)||($q==($ntmp-1))) {
    2522. 

  2522. 	      $ot['_eoq']=true;
    2523. 

  2523. 	      $ot['_total']=$ntmp;
    2524. 

  2524. 	      $ot['_dynquery']=$dynquery;
    2525. 

  2525. 	    }
    2526. 

  2526. 	    if($boq) {
    2527. 

  2527. 	      $ot['_boq']=true;
    2528. 

  2528. 	      $ot['_dynquery']=$dynquery;
    2529. 

  2529. 	      $ot['_total']=$ntmp;
    2530. 

  2530. 	      $boq=false;
    2531. 

  2531. 	    }
    2532. 

  2532. 	    $ot['_type']='query';
    2533. 

  2533. 	    $ot['_q']="$q";
    2534. 

  2534. 	    $ot['_qdisp']=$qdisp;
    2535. 

  2535. 	    $o[$idx2]=$ot;
    2536. 

  2536. 	    if($ot['oUPD']->raw>$lastpageupdate->raw) {
    2537. 

  2537. 	      $lastpageupdate=$ot['oUPD'];
    2538. 

  2538. 	    }
    2539. 

  2539. 	    $t[$idx2]=&$tpldatas[$oidittpl];
    2540. 

  2540. 	    $itoid[$idx2] = $ors['ITOID'];
    2541. 

  2541. 	    $order1[$idx2] = $ors['ORDER1'];
    2542. 

  2542. 	    $qdisp++;
    2543. 

  2543. 	    $idx2++;
    2544. 

  2544. 	  }
    2545. 

  2545. 	  $idx++;
    2546. 

  2546. 	}
    2547. 

  2547. 	if($ntmp<=0) {
    2548. 

  2548. 	  $ot['_type']='query';
    2549. 

  2549. 	  $ot['_dynquery']=$dynquery;
    2550. 

  2550. 	  $t[$idx2]=&$tpldatas[$oidittpl];
    2551. 

  2551. 	  $ot['_q']='0';
    2552. 

  2552. 	  $ot['_empty']=true;
    2553. 

  2553. 	  $ot['_boq']='0';
    2554. 

  2554. 	  $ot['_total']='0';
    2555. 

  2555. 	  $o[$idx2]=$ot;
    2556. 

  2556. 	  if($ot['oUPD']->raw>$lastpageupdate->raw) {
    2557. 

  2557. 	    $lastpageupdate=$ot['oUPD'];
    2558. 

  2558. 	  }
    2559. 

  2559. 	  $itoid[$idx2] = $ors['ITOID'];
    2560. 

  2560. 	  $order1[$idx2] = $ors['ORDER1'];
    2561. 

  2561. 	  $idx2++;
    2562. 

  2562. 	} else {
    2563. 

  2563. 	  $o[$idx2-1]['eoq']=true;
    2564. 

  2564. 	}
    2565. 

  2565.       }
    2566. 

  2566.       // car ou il s'agit d'un paragraphe isole
    2567. 

  2567.       else {
    2568. 

  2568. 	$ot=NULL;
    2569. 

  2569. 	if(!empty($LANG_TRAD) && ($LANG_TRAD!=$LANG_DATA)) {
    2570. 

  2570. 	  $ot=&$xst->display(array('oid'=>$oiditd, 'tplentry'=>TZR_RETURN_DATA,'_format'=>$_format,
    2571. 

  2571. 				   'LANG_DATA'=>$LANG_TRAD,
    2572. 

  2572. 				   '_cacheobject'=>$this->_moid,
    2573. 

  2573. 				   '_options'=>array('error'=>'return')));
    2574. 

  2574. 	  $ot2=&$xst->display(array('oid'=>$oiditd, 'tplentry'=>TZR_RETURN_DATA,
    2575. 

  2575. 				    'LANG_TRAD'=>'',
    2576. 

  2576. 				    '_cacheobject'=>$this->_moid,
    2577. 

  2577. 				    '_options'=>array('error'=>'return')));
    2578. 

  2578. 	  $ot['_type']='section';
    2579. 

  2579. 	  $ot2['_type']='section';
    2580. 

  2580. 	} else {
    2581. 

  2581. 	  $ot=&$xst->display(array('oid'=>$oiditd, 'tplentry'=>TZR_RETURN_DATA,'_format'=>$_format,
    2582. 

  2582. 				   '_cacheobject'=>$this->_moid,
    2583. 

  2583. 				   '_options'=>array('error'=>'return')));
    2584. 

  2584. 	  $ot['_type']='section';
    2585. 

  2585. 	}
    2586. 

  2586. 	if(is_array($ot) && $idx>=$first) {
    2587. 

  2587. 	  $idx++;
    2588. 

  2588. 	  $o[$idx2]=$ot;
    2589. 

  2589. 	  if($ot['oUPD']->raw>$lastpageupdate->raw) {
    2590. 

  2590. 	    $lastpageupdate=$ot['oUPD'];
    2591. 

  2591. 	  }
    2592. 

  2592. 	  $itoid[$idx2] = $ors['ITOID'];
    2593. 

  2593. 	  $t[$idx2] = $tpldatas[$oidittpl];
    2594. 

  2594. 	  $order1[$idx2] = $ors['ORDER1'];
    2595. 

  2595. 	  $idx2++;
    2596. 

  2596. 	  if(!empty($ot2)) {
    2597. 

  2597. 	    $o[$idx2]=$ot2;
    2598. 

  2598. 	    $itoid[$idx2] = $ors['ITOID'];
    2599. 

  2599. 	    $t[$idx2] = $tpldatas[$oidittpl];
    2600. 

  2600. 	    $order1[$idx2] = $ors['ORDER1'];
    2601. 

  2601. 	    $idx2++;
    2602. 

  2602. 	  }
    2603. 

  2603. 	}elseif(is_array($ot)) {
    2604. 

  2604. 	  $idx++;
    2605. 

  2605. 	}
    2606. 

  2606.       }
    2607. 

  2607.     }
    2608. 

  2608. 

  2609.     // Ajout des packs requis par les TEMPLATES au header
    2610. 

  2610.     foreach ($t as $template) {
    2611. 

  2611.       if (empty($template['opacks']->raw)) continue;
    2612. 

  2612.       $packs_to_autoload = preg_split('/[^\w]+/', $template['opacks']->raw);
    2613. 

  2613.       foreach ($packs_to_autoload as $packname) {
    2614. 

  2614.         $GLOBALS['TZR_PACKS']->addNamedPack($packname);
    2615. 

  2615.       }
    2616. 

  2616.     }
    2617. 

  2617. 

  2618.     if(!empty($this->cattemplate)) {
    2619. 

  2619.       $r1=&$this->_templates->display(array('tplentry'=>TZR_RETURN_DATA,'fallback'=>'true',
    2620. 

  2620. 					    '_options'=>array('error'=>'return'),
    2621. 

  2621. 					    'oid'=>$this->cattemplate));
    2622. 

  2622.       if(is_array($r1)) XShell::toScreen1('cat_mitt',$r1);
    2623. 

  2623. 

  2624.     }
    2625. 

  2625.     if($toc) {
    2626. 

  2626.       $this->home(array('oidtop'=>$oidit,'tplentry'=>'ssrubs','do'=>'showtree','maxlevel'=>$maxlevel));
    2627. 

  2627.     }
    2628. 

  2628.     $result['query'] = $query2;
    2629. 

  2629.     $result['oidit']=$oidit;
    2630. 

  2630.     $result['itoid']=$itoid;
    2631. 

  2631.     $result['olines']=$o;
    2632. 

  2632.     $result['first']=$first;
    2633. 

  2633.     $result['last']=$total;
    2634. 

  2634.     $result['firstnext']=''.($first+$pagesize).'';
    2635. 

  2635.     $result['firstprev']=''.($first-$pagesize>=0?($first-$pagesize):$first).'';
    2636. 

  2636.     $result['total']=$total;
    2637. 

  2637.     $result['order']=$order1;
    2638. 

  2638.     $result['tlines']=$t;
    2639. 

  2639.     $result['pages_mode']='';
    2640. 

  2640.     $result['moid']=$this->_moid;
    2641. 

  2641.     if (XShell::admini_mode()) {
    2642. 

  2642.       $result['_editCat'] = array_shift($this->secGroups('editCat'));
    2643. 

  2643.       $result['_editLevel'] = array_shift($this->secGroups('editpage'));
    2644. 

  2644.       $result['_publishLevel'] = array_shift($this->secGroups('publish'));
    2645. 

  2645.     }
    2646. 

  2646.     if((@$_SERVER['REQUEST_METHOD']=='POST') || (@$_REQUEST['nocache']=='1')) {
    2647. 

  2647.       $result['pages_mode']='&nocache=1';
    2648. 

  2648.     }
    2649. 

  2649.     $result['lastpageupdate']=$lastpageupdate;
    2650. 

  2650.     // Met à jour la date de dernière révision si besoin
    2651. 

  2651.     if(!empty($result["cat_mit"]['olastrevision']) && $lastpageupdate->raw>$result["cat_mit"]['olastrevision']->raw){
    2652. 

  2652.       updateQuery('update '.$this->table.' set UPD=UPD,lastrevision="'.$lastpageupdate->raw.'" where KOID="'.$oidit.'" and LANG="'.$LANG_DATA.'"');
    2653. 

  2653.     }
    2654. 

  2654.     if($pagesize<$total) {
    2655. 

  2655.       $p1=0;
    2656. 

  2656.       $pages=array();
    2657. 

  2657.       for($i=0;$i<$total;$i+=$pagesize){
    2658. 

  2658. 	$pages[$p1++]=$i;
    2659. 

  2659. 	if($i==$first) $result['actpage']=$p1;
    2660. 

  2660.       }
    2661. 

  2661.       $result['pages']=$pages;
    2662. 

  2662.       $result['lastpage']=$p1;
    2663. 

  2663.       $result['firstlastpage']=$pages[$p1-1];
    2664. 

  2664.     }else{
    2665. 

  2665.       $result['actpage']=1;
    2666. 

  2666.       $result['lastpage']=1;
    2667. 

  2667.     }
    2668. 

  2668.     if($p->get('_nav')==1) $result['nav']=$this->_getNavigInfo($oidit);
    2669. 

  2669.     if($p->get('_path')==1) $result['path']=$this->getPath($oidit);
    2670. 

  2670.     XLogs::debug("XModInfoTree::viewpage: end $alias $oidit");
    2671. 

  2671.     return XShell::toScreen1($tplentry,$result);
    2672. 

  2672.   }
    2673. 

  2673. 

  2674.   /// Retourne les données d'une section dans une rubrique
    2675. 

  2675.   function viewsection($ar=NULL){
    2676. 

  2676.     $p=new XParam($ar);
    2677. 

  2677.     $tplentry=$p->get('tplentry');
    2678. 

  2678.     $oidit=$p->get('oidit');
    2679. 

  2679.     $alias=$p->get('alias');
    2680. 

  2680.     $oidsection=$p->get('oidsection');
    2681. 

  2681.     $LANG_DATA = XShell::getLangData($p->get("LANG_DATA"));
    2682. 

  2682.     if(!empty($alias)) $oidit=$this->getOidFromAlias($alias);
    2683. 

  2683.     $rs=selectQuery('select * from '.$this->tname.' WHERE ITOID="'.$oidsection.'" AND KOIDSRC="'.$oidit.'"');
    2684. 

  2684.     // Verifie que la section est bien dans la page demandée
    2685. 

  2685.     if(!$rs->rowCount()) securityWarning('XModInfoTree::viewsection: trying to display section '.$oidsection.' not in page '.$oidit);
    2686. 

  2686.     // Verifie les droits de la page
    2687. 

  2687.     if(!$this->secure($oidit,'viewsection',$u=NULL,$LANG_DATA)) {
    2688. 

  2688.       XLogs::critical('XModInfoTree::viewsection:access denied viewsection|'.$this->_moid.'|'.$LANG_DATA.'|'.$oidit.'| user '.XUser::get_current_user_uid());
    2689. 

  2689.       die();
    2690. 

  2690.     }
    2691. 

  2691. 

  2692.     $o=$itoid=$t=$result=array();
    2693. 

  2693.     // Infos de la page
    2694. 

  2694.     $result['cat_mit']=$this->_categories->display(array('oid'=>$oidit,'tplentry'=>TZR_RETURN_DATA));
    2695. 

  2695.     // Infos de la section
    2696. 

  2696.     $ors=$rs->fetch();
    2697. 

  2697.     $query=$ors['QUERY'];
    2698. 

  2698.     $oiditd=$ors['KOIDDST'];
    2699. 

  2699.     $oidittpl=$ors['KOIDTPL'];
    2700. 

  2700.     $tpl=&$this->_disp2Template($oidittpl);
    2701. 

  2701.     if(!$tpl) die();
    2702. 

  2702.     // Cas d'une section fonction
    2703. 

  2703.     if(empty($oiditd) && $tpl['ogtype']->raw=='function'){
    2704. 

  2704.       $ot=$this->viewFunction($oidit,$oidittpl,$ors['ITOID'],$query);
    2705. 

  2705.       if(empty($ot)) die();
    2706. 

  2706.       if(is_array($ot)) {
    2707. 

  2707. 	$o[]=$ot;
    2708. 

  2708. 	$itoid[]=$ors['ITOID'];
    2709. 

  2709. 	$t[]=$tpl;
    2710. 

  2710.       }
    2711. 

  2711.     }
    2712. 

  2712.     $result['oidit']=$oidit;
    2713. 

  2713.     $result['itoid']=$itoid;
    2714. 

  2714.     $result['oidsection']=$oidsection;
    2715. 

  2715.     $result['olines']=$o;
    2716. 

  2716.     $result['tlines']=$t;
    2717. 

  2717.     $result['moid']=$this->_moid;
    2718. 

  2718.     return XShell::toScreen1($tplentry,$result);
    2719. 

  2719.   }
    2720. 

  2720. 

  2721.   /// Retourne les données d'une section de type fonction
    2722. 

  2722.   function &viewFunction($oidit,$oidittpl,$itoid,$query){
    2723. 

  2723.     $query2=unserialize($query);
    2724. 

  2724.     $moid=$query2['moid'];
    2725. 

  2725.     $function=$query2['function'];
    2726. 

  2726.     $UIParam_function='UIParam_'.$function;
    2727. 

  2727.     $UIView_function='UIView_'.$function;
    2728. 

  2728.     $module=XModule::objectFactory($moid);
    2729. 

  2729.     // Test les droits sur la fonction
    2730. 

  2730.     if($query2['__oid'] && !$module->secure($query2['__oid'],$function))
    2731. 

  2731.       return false;
    2732. 

  2732.     if(method_exists($module, $UIView_function)){
    2733. 

  2733.       $query2['oidit']=$oidit;
    2734. 

  2734.       $query2['itoid']=$itoid;
    2735. 

  2735.       $query2['_options']=array('local'=>1);
    2736. 

  2736.       $query2['tplentry']=TZR_RETURN_DATA;
    2737. 

  2737.       $ot=$module->$UIView_function($query2);
    2738. 

  2738.       $params=$query2;
    2739. 

  2739.     }else{
    2740. 

  2740.       if(!method_exists($module, $function) || !method_exists($module, $UIParam_function)) return NULL;
    2741. 

  2741.       $params=array('oidit'=>$oidit, '_options'=>array('local'=>1),'tplentry'=>true);
    2742. 

  2742.       $desc=$module->$UIParam_function();
    2743. 

  2743.       foreach($desc as $fn=>&$field){
    2744. 

  2744. 	if(strpos($fn,'__')===0) $fn2=substr($fn,2);
    2745. 

  2745. 	else $fn2=$fn;
    2746. 

  2746. 	if(empty($query2[$fn])) continue;
    2747. 

  2747. 	$params[$fn2]=$query2[$fn];
    2748. 

  2748. 	if($field->multivalued && $field->get_fgender()=='Oid'){
    2749. 

  2749. 	  $params[$fn2]=explode('||',$params[$fn2]);
    2750. 

  2750. 	}
    2751. 

  2751.       }
    2752. 

  2752.       $ot=$module->$function($params);
    2753. 

  2753.     }
    2754. 

  2754. 

  2755.     // Récupère les options de mise en page liées au TEMPLATE
    2756. 

  2756.     $options_values = (object) null;
    2757. 

  2757.     $xoptions = $this->getTemplateOptions($oidittpl, $itoid, $options_values);
    2758. 

  2758.     if (!is_null($xoptions)) {
    2759. 

  2759.       $xoptions->procDialog($options_values, $params['_tploptions']);
    2760. 

  2760.       $ot['_tploptions'] = (array) $options_values;
    2761. 

  2761.     }
    2762. 

  2762. 

  2763.     $ot['_functionparams']=array('function'=>$function,'moid'=>$query2['moid'],'params'=>$params,'modulename'=>$module->modulename);
    2764. 

  2764.     $ot['_type']='function';
    2765. 

  2765.     return $ot;
    2766. 

  2766.   }
    2767. 

  2767. 

  2768.   // recherche des info rubrique prec, suivant, top, etc...
    2769. 

  2769.   //
    2770. 

  2770.   protected function &_getNavigInfo($oidit) {
    2771. 

  2771.     $result=array();
    2772. 

  2772.     $published='';
    2773. 

  2773.     if(fieldExists($this->table, 'PUBLISH') && !XShell::admini_mode()) {
    2774. 

  2774.       $published=' AND PUBLISH="1" ';
    2775. 

  2775.     }
    2776. 

  2776.     $q = 'select distinct KOID,linkup,corder from '.$this->table.' where KOID="'.$oidit.'" '.$published;
    2777. 

  2777.     $rs=selectQuery($q);
    2778. 

  2778.     if($ors=$rs->fetch()) {
    2779. 

  2779.       $linkup=$ors['linkup'];
    2780. 

  2780.       $order=$ors['corder'];
    2781. 

  2781. 

  2782.       // recherche du next au meme niveau
    2783. 

  2783.       $q = 'select distinct KOID,linkup,corder from '.$this->table.' where '.
    2784. 

  2784. 	"linkup='$linkup' and corder>'$order' $published order by corder";
    2785. 

  2785.       $rs=selectQuery($q);
    2786. 

  2786.       if($ors=$rs->fetch()) {
    2787. 

  2787. 	$koidnext=$ors['KOID'];
    2788. 

  2788. 	$r1=&$this->_categories->display(array('oid'=>$koidnext,'tplentry'=>TZR_RETURN_DATA,'_options'=>array('error'=>'return'), 'fallback'=>1));
    2789. 

  2789. 	if(is_array($r1)) $result['next']=$r1;
    2790. 

  2790.       }
    2791. 

  2791. 

  2792.       // recherche du prev au meme niveau
    2793. 

  2793.       $q = 'select distinct KOID,linkup,corder from '.$this->table.' where '.
    2794. 

  2794. 	"linkup='$linkup' and corder<'$order' $published order by corder";
    2795. 

  2795.       $rs=selectQuery($q);
    2796. 

  2796.       if($ors=$rs->fetch()) {
    2797. 

  2797. 	$koidprev=$ors['KOID'];
    2798. 

  2798. 	$r1=&$this->_categories->display(array('oid'=>$koidprev,'tplentry'=>TZR_RETURN_DATA,
    2799. 

  2799. 					       'fallback'=>1,
    2800. 

  2800. 					       '_options'=>array('error'=>'return')));
    2801. 

  2801. 	if(is_array($r1)) $result['prev']=$r1;
    2802. 

  2802.       }
    2803. 

  2803. 

  2804.       // recherche du up
    2805. 

  2805.       if(strlen($linkup)>1)
    2806. 

  2806. 	$result['up']=&$this->_categories->display(array('oid'=>$linkup,'tplentry'=>TZR_RETURN_DATA, 'fallback'=>1));
    2807. 

  2807.     }
    2808. 

  2808.     return $result;
    2809. 

  2809.   }
    2810. 

  2810. 

  2811.   // rend la liste des oid ss categories
    2812. 

  2812.   //
    2813. 

  2813.   public function &getSubObjects($oid) {
    2814. 

  2814.     $stack=array($oid);
    2815. 

  2815.     $res=array();
    2816. 

  2816.     while(!empty($stack)) {
    2817. 

  2817.       $poped=array_pop($stack);
    2818. 

  2818.       if($poped!=$oid) array_push($res, $poped);
    2819. 

  2819.       $rs=selectQuery('SELECT DISTINCT KOID,alias FROM '.$this->table." WHERE linkup='$poped'");
    2820. 

  2820.       while($ors=$rs->fetch()) {
    2821. 

  2821. 	array_push($stack, $ors['KOID']);
    2822. 

  2822.       }
    2823. 

  2823.       $rs->closeCursor();
    2824. 

  2824.     }
    2825. 

  2825.     return $res;
    2826. 

  2826.   }
    2827. 

  2827. 

  2828.   // rend la liste des ss categroies
    2829. 

  2829.   //
    2830. 

  2830.   public function getSubCats($oid, $lang, $level=1, $depth=9, $maxlevel=9) {
    2831. 

  2831.     if(!isset($oid)) {
    2832. 

  2832.       $query = $this->_categories->select_query(array('cond'=>array('linkup'=>array('=','NULL'))));
    2833. 

  2833.     } else {
    2834. 

  2834.       $query = $this->_categories->select_query(array('cond'=>array('linkup'=>array('=',$oid))));
    2835. 

  2835.     }
    2836. 

  2836.     $rcat=&$this->_categories->browse(array('selected'=>0,
    2837. 

  2837. 					    'first'=>'0',
    2838. 

  2838. 					    'select'=>$query,
    2839. 

  2839. 					    'pagesize'=>1000,
    2840. 

  2840. 					    'selectedfields'=>array('title','linkup'),
    2841. 

  2841. 					    'order'=>'corder',
    2842. 

  2842. 					    'tplentry'=>TZR_RETURN_DATA,
    2843. 

  2843. 					    'header'=>'0','nocount'=>'1'));
    2844. 

  2844.     $OID[]=$oid;
    2845. 

  2845.     foreach($rcat['lines_oid'] as $i => $o) {
    2846. 

  2846.       $OID[]=$o;
    2847. 

  2847.       if($level < $depth) {
    2848. 

  2848. 	$subOID = $this->getSubCats($o, $lang, $level+1, $depth);
    2849. 

  2849. 	$OID=array_merge($OID,$subOID);
    2850. 

  2850.       }
    2851. 

  2851.     }
    2852. 

  2852.     return $OID;
    2853. 

  2853.   }
    2854. 

  2854. 

  2855.   /// rend l'oid de la poubelle
    2856. 

  2856.   protected function getTrashOid($createit=false) {
    2857. 

  2857.     // recherche de la poubelle
    2858. 

  2858.     $all=selectQueryGetOne('SELECT KOID FROM '.$this->table.' WHERE alias = "trash" and LANG="'.TZR_DEFAULT_LANG.'" LIMIT 1');
    2859. 

  2859.     $dest=$all['KOID'];
    2860. 

  2860. 

  2861.     // si la poubelle n'existe aps il faut la rajouter
    2862. 

  2862.     if(empty($dest) && $createit) {
    2863. 

  2863.       $ar1=array('title'=>XLabels::getSysLabel('general','trash','text'),
    2864. 

  2864. 		 'alias'=>'trash',
    2865. 

  2865. 		 'linkup'=>NULL,
    2866. 

  2866. 		 'corder'=>'0');
    2867. 

  2867.       $r1=&$this->procInput($ar1);
    2868. 

  2868.       $dest=$r1['oid'];
    2869. 

  2869.     }
    2870. 

  2870.     return $dest;
    2871. 

  2871.   }
    2872. 

  2872. 

  2873.   /// rend la liste des aliases de ce module
    2874. 

  2874.   function getAliases() {
    2875. 

  2875.     $lang=XShell::getLangData();
    2876. 

  2876.     $set = selectQueryGetAll('SELECT DISTINCT KOID,alias FROM '.$this->table." WHERE LANG='$lang'");
    2877. 

  2877.     $setall=array();
    2878. 

  2878.     foreach($set as $i=>&$al) {
    2879. 

  2879.       if(!empty($al['alias'])) $setall[$al['KOID']]=$al['alias'];
    2880. 

  2880.     }
    2881. 

  2881.     return $setall;
    2882. 

  2882.   }
    2883. 

  2883. 

  2884. 

  2885.   /// rend l'oid correspondant à l'alias
    2886. 

  2886.   public function getOidFromAlias($alias) {
    2887. 

  2887.     if(Kernel::isAKoid($alias) && Kernel::objectExists($alias)) return $alias;
    2888. 

  2888.     if(isset($alias)) {
    2889. 

  2889.       $query=$this->_categories->select_query(array('cond'=>array('alias'=>array('=',$alias))));
    2890. 

  2890.       $rs=selectQuery($query);
    2891. 

  2891.       $oidit=NULL;
    2892. 

  2892.       if(!$rs) return NULL;
    2893. 

  2893.       while($ors=$rs->fetch()) {
    2894. 

  2894. 	$oidit=$ors['KOID'];
    2895. 

  2895.       }
    2896. 

  2896.       $rs->closeCursor();
    2897. 

  2897.       return $oidit;
    2898. 

  2898.     }
    2899. 

  2899.     return NULL;
    2900. 

  2900.   }
    2901. 

  2901. 

  2902.   public function usedTables(){
    2903. 

  2903.     return array($this->table,$this->tname,'TEMPLATES');
    2904. 

  2904.   }
    2905. 

  2905.   public function usedMainTables(){
    2906. 

  2906.     return array($this->table);
    2907. 

  2907.   }
    2908. 

  2908.   public function usedBoids(){
    2909. 

  2909.     return array($this->_categories->getBoid());
    2910. 

  2910.   }
    2911. 

  2911.   function goto1($ar=NULL) {
    2912. 

  2912.     $p = new XParam($ar,array());
    2913. 

  2913.     $oid=$p->get('oid');
    2914. 

  2914.     $url=$GLOBALS['TZR_SESSION_MANAGER']::admin_url(true,false);
    2915. 

  2915.     $moid=$this->_moid;
    2916. 

  2916.     header("Location: {$url}moid=$moid&template=xmodinfotree/viewpage.html&oidit=$oid&function=editpage&tplentry=it");
    2917. 

  2917.   }
    2918. 

  2918. 

  2919.   function _mkInline(&$r) {
    2920. 

  2920.   }
    2921. 

  2921. 

  2922.   /// rend vrai si l'alias pass	 en parametre est protege
    2923. 

  2923.   public function aliasIsProtected($alias) {
    2924. 

  2924.     return false;
    2925. 

  2925.   }
    2926. 

  2926. 

  2927.   public function export($ar) {
    2928. 

  2928.     $r1=&$this->home(array('tplentry'=>TZR_RETURN_DATA,'do'=>'showtree'));
    2929. 

  2929. 

  2930.     foreach($r1['lines_oid'] as $i=>$oid) {
    2931. 

  2931.       $R2=&$this->viewpage(array('tplentry'=>TZR_RETURN_DATA, 'oidit'=>$oid));
    2932. 

  2932.       $r1['lines__it'][$i]=$R2['olines'];
    2933. 

  2933.       $r1['lines__tt'][$i]=$R2['tlines'];
    2934. 

  2934.     }
    2935. 

  2935.     XShell::toScreen1('mit', $r1);
    2936. 

  2936.   }
    2937. 

  2937.   public function apply($fsection) {
    2938. 

  2938.     $r1=$this->home(array('tplentry'=>TZR_RETURN_DATA,'do'=>'showtree'));
    2939. 

  2939. 

  2940.     foreach($r1['lines_oid'] as $oid) {
    2941. 

  2941.       $R2=$this->viewpage(array('tplentry'=>TZR_RETURN_DATA, 'oidit'=>$oid));
    2942. 

  2942.       $fsection($this, $R2['cat_mit']);	/* conversion de la rubrique */
    2943. 

  2943. 

  2944.       foreach($R2['olines'] as $section) {
    2945. 

  2945. 	$fsection($this, $section);
    2946. 

  2946.       }
    2947. 

  2947.       unset($R2);
    2948. 

  2948.     }
    2949. 

  2949.   }
    2950. 

  2950. 

  2951.   /**
    2952. 

  2952.    * Exporte la page au format PDF
    2953. 

  2953.    * @param ar Options de la fonction viewpage avec un paramètre 'action' 
    2954. 

  2954.    *           supplémentaire qui vaut 'display' par défaut pour renvoyer 
    2955. 

  2955.    *           directement un fichier à l'utilisateur ou 'generate' pour 
    2956. 

  2956.    *           seulement générer le fichier et renvoyer son nom.
    2957. 

  2957.    * @return String Nom du fichier généré
    2958. 

  2958.    */
    2959. 

  2959.   public function exportPdf($ar) {
    2960. 

  2960.     $p = new XParam($ar,array(
    2961. 

  2961.       'pagesize' => 999,
    2962. 

  2962.       'action'   => 'display' // 'generate' ou 'display'
    2963. 

  2963.     ));
    2964. 

  2964.     $ar['pagesize'] = $p->get('pagesize');
    2965. 

  2965.     $ar['tplentry'] = 'it';
    2966. 

  2966.     $tpldata['it'] = $this->viewpage($ar);
    2967. 

  2967.     $xt = new XTemplate('xmodinfotree/exportPdf.html');
    2968. 

  2968.     $labels = $GLOBALS['XSHELL']->labels->get_labels(array('selectors'=>array('global'),'local'=>true));
    2969. 

  2969.     $xt->set_glob(array('labels'=>&$labels));
    2970. 

  2970.     $rawData = array('it_prop'=>$this);
    2971. 

  2971.     $content = $xt->parse($tpldata,$rawData,NULL);
    2972. 

  2972.     $pdfname = $tpldata['it']['cat_mit']['oalias']->html.'.pdf';
    2973. 

  2973.     $tmpname = princeTidyXML2PDF(null,$content);
    2974. 

  2974.     switch ($p->get('action')) {
    2975. 

  2975.       case 'generate' : 
    2976. 

  2976.         $newname = dirname($tmpname).'/'.$pdfname;
    2977. 

  2977.         return @rename($tmpname,$newname) ? $newname : $tmpname;
    2978. 

  2978.       case 'display' :
    2979. 

  2979. 	header('Content-type: application/pdf');
    2980. 

  2980. 	header('Content-disposition: attachment; filename='.$pdfname);
    2981. 

  2981. 	$size = filesize($tmpname);
    2982. 

  2982. 	header('Accept-Ranges: bytes');
    2983. 

  2983. 	header('Content-Length: '.$size);
    2984. 

  2984. 	readfile($tmpname);
    2985. 

  2985. 	unlink($tmpname);
    2986. 

  2986. 	exit(0);
    2987. 

  2987.     }
    2988. 

  2988.   }
    2989. 

  2989. 

  2990.   public function &browse($ar) {
    2991. 

  2991.     return $this->_categories->browse($ar);
    2992. 

  2992.   }
    2993. 

  2993.   public function &query($ar) {
    2994. 

  2994.     return $this->_categories->query($ar);
    2995. 

  2995.   }
    2996. 

  2996.   public function &procQuery($ar) {
    2997. 

  2997.     $p=new XParam($ar, array());
    2998. 

  2998.     $tplentry=$p->get('tplentry');
    2999. 

  2999.     $ar1=$ar;
    3000. 

  3000.     $ar1['tplentry']=TZR_RETURN_DATA;
    3001. 

  3001.     $ar1['selectedfields']=array('UPD','PUBLISH','title','alias');
    3002. 

  3002.     $r=&$this->_categories->procQuery($ar1);
    3003. 

  3003.     $r['objects_sec']=$GLOBALS['XUSER']->getObjectsAccess($this, XShell::getLangData(), $r['lines_oid']);
    3004. 

  3004.     if($tplentry!=TZR_RETURN_DATA) {
    3005. 

  3005.       $this->browse_actions($r);
    3006. 

  3006.     }
    3007. 

  3007.     return XShell::toScreen1($tplentry, $r);
    3008. 

  3008.   }
    3009. 

  3009. 

  3010.   public function browse_actions(&$r) {
    3011. 

  3011.     $self=$GLOBALS['TZR_SESSION_MANAGER']::complete_self();
    3012. 

  3012.     $self.='&moid='.$this->_moid.'&oidit=<oid>&tplentry=it&function=';
    3013. 

  3013.     if(!is_array($r['lines_oid'])) return;
    3014. 

  3014.     $approved=XLabels::getSysLabel('general','approved');
    3015. 

  3015.     $not_approved=XLabels::getSysLabel('general','not_approved');
    3016. 

  3016.     $viewico = XLabels::getSysLabel('general','view');
    3017. 

  3017.     $viewtxt = XLabels::getSysLabel('general','view','text');
    3018. 

  3018.     $editico = XLabels::getSysLabel('general','edit');
    3019. 

  3019.     $edittxt = XLabels::getSysLabel('general','edit','text');
    3020. 

  3020.     $browseico = XLabels::getSysLabel('general','browse');
    3021. 

  3021.     $browsetxt = XLabels::getSysLabel('general','browse','text');
    3022. 

  3022.     foreach($r['lines_oid'] as $i =>$oid) {
    3023. 

  3023.       $self1=str_replace('<oid>',$oid,$self);
    3024. 

  3024.       $self1=str_replace('=it','=mit',$self1);
    3025. 

  3025.       $self1=str_replace('oidit','oid',$self1);
    3026. 

  3026.       $r['actions'][$i][0]='<a class="cv8-ajaxlink" href="'.$self1.'home&'.
    3027. 

  3027. 	'template=xmodinfotree/index.html&do=add" title="'.$browsetxt.'">'.$browseico.'</a>';
    3028. 

  3028.       $r['actions_label'][$i][0]=$viewico;
    3029. 

  3029.       $r['actions_url'][$i][0]=$self1.'home&template=xmodinfotree/index.html&do=add';
    3030. 

  3030.       $self1=str_replace('<oid>',$oid,$self);
    3031. 

  3031.       $r['actions'][$i][1]='<a class="cv8-ajaxlink" href="'.$self1.'viewpage&'.
    3032. 

  3032. 	'template=xmodinfotree/viewpage.html" title="'.$viewtxt.'">'.$viewico.'</a>';
    3033. 

  3033.       $r['actions_label'][$i][1]=$viewico;
    3034. 

  3034.       $r['actions_url'][$i][1]=$self1.'viewpage&template=xmodinfotree/viewpage.html';
    3035. 

  3035.       if(!empty($r['objects_sec'][$i]['rw'])) {
    3036. 

  3036. 	$r['actions'][$i][2]='<a class="cv8-ajaxlink" href="'.$self1.'editpage&'.
    3037. 

  3037. 	  'template=xmodinfotree/viewpage.html" title="'.$edittxt.'">'.$editico.'</a>';
    3038. 

  3038. 	$r['actions_url'][$i][2]=$self1.'editpage&template=xmodinfotree/editpage.html';
    3039. 

  3039. 	$r['actions_label'][$i][2]=$editico;
    3040. 

  3040.       }
    3041. 

  3041.     }
    3042. 

  3042.   }
    3043. 

  3043. 

  3044.   /// rend la date de derniere mise a jour de la page dont l'oid est fourni
    3045. 

  3045.   protected function lastUpdate($oid) {
    3046. 

  3046.     $rs=selectQuery('SELECT UPD,KOID FROM '.$this->table.' WHERE KOID="'.$oid.'" ORDER BY UPD DESC LIMIT 1');
    3047. 

  3047.     if(!$rs || !$ors=&$rs->fetch()) return NULL;
    3048. 

  3048.     $lastupd=$ors['UPD'];
    3049. 

  3049.     $lastoid=$ors['KOID'];
    3050. 

  3050. 

  3051.     // recherche de toutes les sections de la page
    3052. 

  3052.     $all=selectQueryGetAll('SELECT KOIDDST FROM '.$this->tname.' where KOIDSRC="'.$oid.'" AND KOIDDST != ""');
    3053. 

  3053.     foreach($all as $ors) {
    3054. 

  3054.       // recherche de la derniere mise a jour pour cette section
    3055. 

  3055.       $upd=XLogs::getLastUpdate($ors['KOIDDST'], NULL, true);
    3056. 

  3056. 

  3057.       if(!empty($upd) && ($upd['dateupd']>$lastupd)) {
    3058. 

  3058. 	$lastupd=$upd['dateupd'];
    3059. 

  3059. 	$lastoid=$ors['KOIDDST'];
    3060. 

  3060.       }
    3061. 

  3061.     }
    3062. 

  3062. 

  3063.     $update=XLogs::getLastUpdate($lastoid, NULL, true);
    3064. 

  3064.     return $update;
    3065. 

  3065.   }
    3066. 

  3066. 

  3067.   protected function _lasttimestamp() {
    3068. 

  3068.     $rs=selectQuery('SELECT MAX(UPD) AS UPD FROM '.$this->table.'');
    3069. 

  3069.     $ors=&$rs->fetch();
    3070. 

  3070.     $lastupd=$ors['UPD'];
    3071. 

  3071.     $rs=selectQuery('SELECT DISTINCT KOIDDST FROM '.$this->tname.' WHERE KOIDDST != ""');
    3072. 

  3072.     $tables=array();
    3073. 

  3073.     while($rs && ($ors=&$rs->fetch())) {
    3074. 

  3074.       $tables[]=Kernel::getTable($ors['KOIDDST']);
    3075. 

  3075.     }
    3076. 

  3076.     $tables_u=array_unique($tables);
    3077. 

  3077.     foreach($tables_u as $table) {
    3078. 

  3078.       if(empty($table)) continue;
    3079. 

  3079.       $ors=selectQueryGetOne('SELECT MAX('.$table.'.UPD) AS UPD FROM '.$table.','.$this->tname.' WHERE '.
    3080. 

  3080. 			     $table.'.KOID='.$this->tname.'.KOIDDST');
    3081. 

  3081.       if(!empty($ors) && ($lastupd < $ors['UPD'])) $lastupd=$ors['UPD'];
    3082. 

  3082.     }
    3083. 

  3083.     return $lastupd;
    3084. 

  3084.   }
    3085. 

  3085. 

  3086.   /// rend la liste des rubriques modifiees depuis ts et jusqu'a timestamp
    3087. 

  3087.   protected function _whatsNew($ts,$user, $group=NULL, $specs=NULL,$timestamp=NULL) {
    3088. 

  3088.     list($koid,$subdir) = explode(';',$specs);
    3089. 

  3089. 

  3090.     // recherche dans lines_oid de la liste des rubriques concernees par l'abonnement
    3091. 

  3091.     if($subdir) $r1=&$this->home(array('tplentry'=>TZR_RETURN_DATA,'do'=>'showtree','myself'=>true,'oidtop'=>$koid));
    3092. 

  3092.     else  $r1=array('lines_oid'=>array($koid));
    3093. 

  3093.     // recherche de la date de derniere mise a jour pour cahcune des rubriques cocnernees
    3094. 

  3094.     $r1['lines_upd']=array();
    3095. 

  3095.     foreach($r1['lines_oid'] as $i=>$oid) {
    3096. 

  3096.       $r1['lines_upd'][$i]=$this->lastUpdate($oid);
    3097. 

  3097.     }
    3098. 

  3098.     $txt='';
    3099. 

  3099.     foreach($r1['lines_oid'] as $i => $oid) {
    3100. 

  3100.       if(($r1['lines_upd'][$i]['dateupd']>$ts) && ($r1['lines_upd'][$i]['dateupd']<$timestamp)) {
    3101. 

  3101. 	$url=$GLOBALS['TZR_SESSION_MANAGER']::admin_url(true,false).'&moid='.$this->_moid.'&function=goto1&oid='.$oid.'&tplentry=br&template=xmodtable/view.html&_direct=1';
    3102. 

  3102. 	$when=$r1['lines_upd'][$i]['dateupd'];
    3103. 

  3103. 	$who=$r1['lines_upd'][$i]['usernam'];
    3104. 

  3104. 	$title=$this->getPathString($oid);
    3105. 

  3105. 	$txt.='<li><a href="'.$url.'">'.$title.'</a> ('.$when.','.$who.')</li>';
    3106. 

  3106.       }
    3107. 

  3107.     }
    3108. 

  3108.     return $txt;
    3109. 

  3109.   }
    3110. 

  3110.   function preSubscribe($ar=NULL) {
    3111. 

  3111.     $p=new XParam($ar,array());
    3112. 

  3112.     $oid=$p->get("oid");
    3113. 

  3113.     $tplentry=$p->get("tplentry");
    3114. 

  3114.     $subdir=$p->get("subdir");
    3115. 

  3115.     $br=&$this->viewpage(array('tplentry'=>TZR_RETURN_DATA, 'oidit'=>$oid));
    3116. 

  3116. 

  3117.     list($acl_user, $acl_grp)=XUser::getUsersAndGroups();
    3118. 

  3118.     XShell::toScreen1('users',$acl_user);
    3119. 

  3119.     XShell::toScreen1('grps',$acl_grp);
    3120. 

  3120.     return XShell::toScreen1($tplentry, $br);
    3121. 

  3121.   }
    3122. 

  3122.   function subscribe($ar=NULL) {
    3123. 

  3123.     $p=new XParam($ar,array());
    3124. 

  3124.     $oid=$p->get("oid");
    3125. 

  3125.     $subdir=$p->get("subdir");
    3126. 

  3126.     $uid=$p->get("uid");
    3127. 

  3127. 

  3128.     if(empty($uid)) $uid=XUser::get_current_user_uid();
    3129. 

  3129.     if(empty($subdir)) $subdir="0";else $subdir="1";
    3130. 

  3130.     $xmodsub = new XModSub(array('interactive'=>false));
    3131. 

  3131.     $xmodsub->addSub(array($uid), $this->_moid, $oid.';'.$subdir);
    3132. 

  3132.   }
    3133. 

  3133. 

  3134.   // rend une chaine qui représente l'abonnement
    3135. 

  3135.   //
    3136. 

  3136.   function _getSubTitle($oid) {
    3137. 

  3137.     $rs=selectQuery("select * from OPTS where KOID='$oid'");
    3138. 

  3138.     if($rs && ($ors=$rs->fetch())) {
    3139. 

  3139.       list($koid,$subdir)=explode(';',$ors['specs']);
    3140. 

  3140.       if(Kernel::objectExists($koid)) {
    3141. 

  3141. 	// generation du libelle pour la rubrique
    3142. 

  3142. 	$title=$this->getPathString($koid);
    3143. 

  3143. 	$url=$GLOBALS['TZR_SESSION_MANAGER']::complete_self().'&moid='.$this->_moid.'&_function=goto1&oid='.$koid.'&tplentry=br';
    3144. 

  3144. 	if(!empty($subdir)) {
    3145. 

  3145. 	  $subdir=' et sous rubriques';
    3146. 

  3146. 	} else $subdir='';
    3147. 

  3147. 	return '<A HREF="'.$url.'">'.$title.'</A> '.$subdir;
    3148. 

  3148.       } else {
    3149. 

  3149. 	// l'abonnement concerne une donnee qui n'existe plus. on le supprimer
    3150. 

  3150. 	updateQuery("delete from OPTS where KOID='$oid'");
    3151. 

  3151.       }
    3152. 

  3152.     }
    3153. 

  3153.     return NULL;
    3154. 

  3154.   }
    3155. 

  3155. 

  3156.   /// Prepare l'importation d'un fichier odt
    3157. 

  3157.   function preImportFromODT($ar=NULL){
    3158. 

  3158.   }
    3159. 

  3159. 

  3160.   /// importe un fichier odt
    3161. 

  3161.   function importFromODT($ar=NULL){
    3162. 

  3162.     $p=new XParam($ar,NULL);
    3163. 

  3163.     $linkup=$p->get('linkup');
    3164. 

  3164.     $rep=TZR_TMP_DIR.'odt_'.uniqid().'/';
    3165. 

  3165.     mkdir($rep);
    3166. 

  3166.     mkdir($rep.'in/');
    3167. 

  3167.     mkdir($rep.'out/');
    3168. 

  3168.     rename($_FILES['odtfile']['tmp_name'],$rep.'in/odtfile.odt');
    3169. 

  3169.     require_once('add-ons/odt2xhtml/odt2seolan.php');
    3170. 

  3170.     $xhtml2seolan = new xhtml2seolan(
    3171. 

  3171.                           $this,
    3172. 

  3172.                           $rep, 'odtfile.odt',
    3173. 

  3173.                           array('txt' => array(
    3174. 

  3174.                                     'tploid' => $this->odttpltxt,
    3175. 

  3175.                                     'txtfield' => $this->odttxtfield,
    3176. 

  3176.                                     'titlefield' => $this->odttxttitlefield),
    3177. 

  3177.                                 'img' => array(
    3178. 

  3178.                                     'tploid' => $this->odttplimg,
    3179. 

  3179.                                     'imgfield' => $this->odtimgfield)),
    3180. 

  3180.                           $linkup);
    3181. 

  3181.     $xhtml2seolan->import();
    3182. 

  3182.     XDir::unlink($rep);
    3183. 

  3183.     XShell::toScreen2('','message',XLabels::getSysLabel('xmodinfotree','odt_importok','text'));
    3184. 

  3184.   }
    3185. 

  3185. 

  3186.   /// Définit si le cache des droits doit être activé ou pas.
    3187. 

  3187.   public function rightCacheEnabled(){
    3188. 

  3188.     if($this->object_sec) return true;
    3189. 

  3189.     return false;
    3190. 

  3190.   }
    3191. 

  3191. 

  3192.   /// Retourne le parent direct de chaque oid passé en paramètre
    3193. 

  3193.   public function getParentsOids($oids){
    3194. 

  3194.     $ret=array();
    3195. 

  3195.     foreach($oids as $oid){
    3196. 

  3196.       if(!$oid) continue;
    3197. 

  3197.       $parent=selectQueryGetOne('select linkup from '.$this->table.' WHERE KOID="'.$oid.'" limit 1');
    3198. 

  3198.       if(!$parent || !$parent['linkup']) $ret[]='';
    3199. 

  3199.       else $ret[]=$parent['linkup'];
    3200. 

  3200.     }
    3201. 

  3201.     return $ret;
    3202. 

  3202.   }
    3203. 

  3203. 

  3204.   /// Redirige vers une page d'erreur 404
    3205. 

  3205.   function redirect404($ar=NULL){
    3206. 

  3206.     $p=new XParam($ar,NULL);
    3207. 

  3207.     $erroralias=$p->get('erroralias');
    3208. 

  3208.     header("HTTP/1.1 404 Not Found");
    3209. 

  3209.     if(empty($erroralias)) {
    3210. 

  3210.       header('Location: '.$GLOBALS['HOME_ROOT_URL']);
    3211. 

  3211.       exit(0);
    3212. 

  3212.     } else {
    3213. 

  3213.       $ar['alias']=$erroralias;
    3214. 

  3214.       $ar['oidit']=NULL;
    3215. 

  3215.       return $this->viewpage($ar);
    3216. 

  3216.     }
    3217. 

  3217.   }
    3218. 

  3218. }
    3219. 

  3219. 

  3220. function xmodinfotree_procEditInPlace(){
    3221. 

  3221.   activeSec();
    3222. 

  3222.   $p=new XParam($ar,NULL);
    3223. 

  3223.   $moid=$p->get('moid');
    3224. 

  3224.   $oid=$p->get('oid');
    3225. 

  3225.   $oidit=$p->get('oidit');
    3226. 

  3226.   $field=$p->get('field');
    3227. 

  3227.   $value=$p->get('value');
    3228. 

  3228.   $GLOBALS['XSHELL']=new XShell();
    3229. 

  3229.   $GLOBALS['XSHELL']->labels=new XLabels();
    3230. 

  3230.   $mod=XModule::objectFactory($moid);
    3231. 

  3231.   if(!$mod->secure($oidit,'savesection')) die('secerror');
    3232. 

  3232.   $table=Kernel::getTable($oid);
    3233. 

  3233.   $xds=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$table);
    3234. 

  3234.   $ar2['_options']['local']=true;
    3235. 

  3235.   $ar2['tplentry']=TZR_RETURN_DATA;
    3236. 

  3236.   $ar2['oid']=$oid;
    3237. 

  3237.   $ar2[$field]=$value;
    3238. 

  3238.   $ret=$xds->procEdit($ar2);
    3239. 

  3239.   die($value);
    3240. 

  3240. }
    3241. 

  3241. ?>
    3242. 

  3242.