PageRenderTime 95ms CodeModel.GetById 19ms RepoModel.GetById 1ms app.codeStats 1ms

/class.xmodtable.inc

https://github.com/jcplat/console-seolan
PHP | 4658 lines | 4000 code | 247 blank | 411 comment | 778 complexity | 55424be8b9a6697202b4b2a0f9d9c4c8 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* tzr-5/XModTable
    3. 

  3.  * NAME
    4. 

  4.  *   XModTable -- gestion d'un ensemble de fiches
    5. 

  5.  * DESCRIPTION
    6. 

  6.  *   Affichage edition et manipulations diverses sur une ensemble de fiches.
    7. 

  7.  * SYNOPSIS
    8. 

  8.  *   La creation d'un module est realisee par utilisation de la methode de classe XModule::objectFactory.
    9. 

  9.  * PARAMETERS
    10. 

  10.  ****/
    11. 

  11. /// Module de gestion de fiches, base sur une simple table SQL
    12. 

  12. class XModTable extends XModule implements XModuleContainerInterface, XCalInterface {
    13. 

  13.   static $_templates;
    14. 

  14.   public $xset=NULL;
    15. 

  15.   public $fieldssec=array();
    16. 

  16.   public $boid;
    17. 

  17.   public $table='T001';
    18. 

  18.   public $multipleedit=true;
    19. 

  19.   public $owner_sec=true;
    20. 

  20.   public $filter='';
    21. 

  21.   public $order='UPD DESC';
    22. 

  22.   public $quickquery=true;
    23. 

  23.   public $stored_query=false;
    24. 

  24.   public $pagesize=TZR_XMODTABLE_BROWSE_PAGESIZE;
    25. 

  25.   public $templates='';
    26. 

  26.   public $btemplates='';
    27. 

  27.   public $captcha=false;
    28. 

  28.   public $savenext='standard';
    29. 

  29.   public $showsystprop='show';
    30. 

  30.   public $persistentquery=false;
    31. 

  31.   public $trackaccess=false;
    32. 

  32.   public $trackchanges=true;
    33. 

  33.   public $archive=false;
    34. 

  34.   public $searchtemplate='xmodtable/searchResult.html';
    35. 

  35.   public $submodsearch=false;
    36. 

  36.   private $secOids_cache;
    37. 

  37.   private $navActions = NULL;
    38. 

  38. 

  39.   function __construct($ar=NULL) {
    40. 

  40.     parent::__construct($ar);
    41. 

  41.     XLabels::loadLabels('xmodtable');
    42. 

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

  43.     if (!is_object($this->xset)) {
    44. 

  44.       throw new Exception('Non existent table: "'.$this->table.'"');
    45. 

  45.     }
    46. 

  46.     $this->boid=$this->xset->getBoid();
    47. 

  47.     if(XShell::admini_mode() && empty($this->_templates) && (!empty($this->templates) || !empty($this->btemplates)))
    48. 

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

  49. 

  50.     if(!XShell::isRoot() && !empty($GLOBALS['XUSER'])) $this->loadFieldsSec($this->fieldssec);
    51. 

  51.   }
    52. 

  52. 

  53. 

  54.   /// Duplication d'un module, méthode interne
    55. 

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

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

  57.   function _duplicateModule($newmoid,&$params,$prefix) {
    58. 

  58.     if(!is_array($params['tables'])) $params['tables']=array();
    59. 

  59.     if(!$params['noduplicatetable']){
    60. 

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

  61. 	$ar['newtable']=XDSTable::newTableNumber();
    62. 

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

  63. 	else $ar['mtxt']=$prefix.':'.$this->xset->getLabel();
    64. 

  64. 	$ar['data']=true;
    65. 

  65. 	$ar['_options']=array('local'=>1);
    66. 

  66. 	$xset2=$this->xset->procDuplicateDataSource($ar);
    67. 

  67. 	$params['table']=$ar['newtable'];
    68. 

  68.       }else{
    69. 

  69. 	$params['table']=$params['tables'][$this->table];
    70. 

  70.       }
    71. 

  71.     }
    72. 

  72.     unset($params['noduplicatetable']);
    73. 

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

  74.   }
    75. 

  75. 

  76.   /// securite des fonctions accessibles par le web
    77. 

  77.   function secGroups($function, $group=NULL) {
    78. 

  78.     $g=array();
    79. 

  79.     $g['browse']=array('list','ro','rw','rwv','admin');
    80. 

  80.     $g['browseFiles']=array('list','ro','rw','rwv','admin');
    81. 

  81.     $g['del']=array('rw','rwv','admin');
    82. 

  82.     $g['delAll']=array('rw','rwv','admin');
    83. 

  83.     $g['delStoredQuery']=array('rw','rwv','admin');
    84. 

  84.     $g['display']=array('ro','rw','rwv','admin');
    85. 

  85.     $g['XMCdisplay']=array('ro','rw','rwv','admin');
    86. 

  86.     $g['edit']=array('rw','rwv','admin');
    87. 

  87.     $g['editSelection']=array('rw','rwv','admin');
    88. 

  88.     $g['editAll']=array('rw','rwv','admin');
    89. 

  89.     $g['export']=array('list','ro','rw','rwv','admin');
    90. 

  90.     $g['exportDisplay']=array('ro','rw','rwv','admin');
    91. 

  91.     $g['exportFilesBatch']=array('ro','rw','rwv','admin');
    92. 

  92.     $g['gDisplay']=array('admin');
    93. 

  93.     $g['insert']=array('rw','rwv','admin');
    94. 

  94.     $g['journal']=array('ro','rw','rwv','admin');
    95. 

  95.     $g['prePrintBrowse']=array('list','ro','rw','rwv','admin');
    96. 

  96.     $g['prePrintDisplay']=array('list','ro','rw','rwv','admin');
    97. 

  97.     $g['preExportBrowse']=array('list','ro','rw','rwv','admin');
    98. 

  98.     $g['preExportDisplay']=array('list','ro','rw','rwv','admin');
    99. 

  99.     $g['printBrowse']=array('list','ro','rw','rwv','admin');
    100. 

  100.     $g['printDisplay']=array('ro','rw','rwv','admin');
    101. 

  101.     $g['procEdit']=array('rw','rwv','admin');
    102. 

  102.     $g['procEditDup']=array('rw','rwv','admin');
    103. 

  103.     $g['procEditAllLang']=array('rw','rwv','admin');
    104. 

  104.     $g['procEditSelection']=array('rw','rwv','admin');
    105. 

  105.     $g['procInsert']=array('rw','rwv','admin');
    106. 

  106.     $g['procQuery']=array('list','ro','rw','rwv','admin');
    107. 

  107.     $g['procQueryFiles']=array('list','ro','rw','rwv','admin');
    108. 

  108.     $g['publish']=array('rwv','admin');
    109. 

  109.     $g['query']=array('list', 'ro','rw','rwv','admin');
    110. 

  110.     $g['quickquery']=array('list','ro','rw','rwv','admin');
    111. 

  111.     $g['adminSubscribe']=array('admin');
    112. 

  112.     $g['getUnread']=array('list','ro','rw','rwv','admin');
    113. 

  113.     $g['markAsRead']=array('list','ro','rw','rwv','admin');
    114. 

  114.     self::getGetAdminSecGroups($g);
    115. 

  115.     if(isset($g[$function])) {
    116. 

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

  117.       return $g[$function];
    118. 

  118.     }
    119. 

  119.     return parent::secGroups($function,$group);
    120. 

  120.   }
    121. 

  121. 

  122.   /// Complete le tableau des focntion du module avec les fonction d'administration
    123. 

  123.   function getGetAdminSecGroups(&$g){
    124. 

  124.     $g['adminBrowseFields']=array('admin');
    125. 

  125.     $g['adminPrint']=array('admin');
    126. 

  126.     $g['adminClear']=array('admin');
    127. 

  127.     $g['adminDuplicate']=array('admin');
    128. 

  128.     $g['adminProcDuplicate']=array('admin');
    129. 

  129.     $g['adminChk']=array('admin');
    130. 

  130.     $g['adminEditSourceProperties']=array('admin');
    131. 

  131.     $g['adminProcEditSourceProperties']=array('admin');
    132. 

  132.     $g['adminNewField']=array('admin');
    133. 

  133.     $g['adminProcNewField']=array('admin');
    134. 

  134.     $g['adminEditField']=array('admin');
    135. 

  135.     $g['adminProcEditField']=array('admin');
    136. 

  136.     $g['adminProcEditFields']=array('admin');
    137. 

  137.     $g['adminDelField']=array('admin');
    138. 

  138.     $g['adminBrowseStrings']=array('admin');
    139. 

  139.     $g['adminNewString']=array('admin');
    140. 

  140.     $g['adminProcNewString']=array('admin');
    141. 

  141.     $g['adminEditString']=array('admin');
    142. 

  142.     $g['adminProcEditString']=array('admin');
    143. 

  143.     $g['adminDelString']=array('admin');
    144. 

  144.     $g['adminSortStrings']=array('admin');
    145. 

  145.     $g['adminClearStrings']=array('admin');
    146. 

  146.     $g['adminPreImportFieldsSec']=array('admin');
    147. 

  147.     $g['adminImportFieldsSec']=array('admin');
    148. 

  148.     $g['adminResetChrono']=array('admin');
    149. 

  149.   }
    150. 

  150. 

  151.   /* Webservice du module */
    152. 

  152.   /// Sous fonction chargée d'ajouter les types necessaires
    153. 

  153.   function _SOAPWSDLTypes(&$wsdl){
    154. 

  154.     $fields=array(array('minOccurs'=>1,'maxOccurs'=>1,'name'=>'oid','type'=>'xsd:string'));
    155. 

  155.     foreach($this->xset->desc as $n=>&$f){
    156. 

  156.       $type=$f->getSoapType();
    157. 

  157.       $fields[]=array('minOccurs'=>0,'maxOccurs'=>1,'name'=>$n,'type'=>$type['name']);
    158. 

  158.       if(!empty($type['descr'])) $this->_SOAPAddTypes($wsdl,$type['descr']);
    159. 

  159.     }
    160. 

  160.     $this->_SOAPAddTypes($wsdl,array('browseParam'=>array(array('name'=>'filter','minOccurs'=>0,'maxOccurs'=>1,'type'=>'xsd:string'),
    161. 

  161. 							  array('name'=>'fields','minOccurs'=>0,'maxOccurs'=>1,'type'=>'xsd:string')),
    162. 

  162.                                      'displayParam'=>array(array('name'=>'oid','minOccurs'=>1,'maxOccurs'=>1,'type'=>'xsd:string')),
    163. 

  163. 				     'displayResult'=>$fields,
    164. 

  164. 				     'browseResult'=>array(array('name'=>'line','minOccurs'=>0,'maxOccurs'=>'unbounded','type'=>'tns:displayResult'))));
    165. 

  165.     return;
    166. 

  166.   }
    167. 

  167.   /// Sous fonction chargée d'ajouter les messages necessaires
    168. 

  168.   function _SOAPWSDLMessages(&$wsdl){
    169. 

  169.     $wsdl->addMessage('browseIn',array('context'=>'tns:contextParam','param'=>'tns:browseParam'));
    170. 

  170.     $wsdl->addMessage('browseOut',array('return'=>'tns:browseResult'));
    171. 

  171.     $wsdl->addMessage('displayIn',array('context'=>'tns:contextParam','param'=>'tns:displayParam'));
    172. 

  172.     $wsdl->addMessage('displayOut',array('return'=>'tns:displayResult'));
    173. 

  173.     return;
    174. 

  174.   }
    175. 

  175.   /// Sous fonction chargée d'ajouter les ports necessaires
    176. 

  176.   function _SOAPWSDLPortOps(&$wsdl,&$pt){
    177. 

  177.     $wsdl->addPortOperation($pt,'browse','tns:browseIn','tns:browseOut');
    178. 

  178.     $wsdl->addPortOperation($pt,'display','tns:displayIn','tns:displayOut');
    179. 

  179.     return;
    180. 

  180.   }
    181. 

  181.   /// Sous fonction chargée d'ajouter les operations necessaires
    182. 

  182.   function _SOAPWSDLBindingOps(&$wsdl,&$b){
    183. 

  183.     $bo=$wsdl->addBindingOperation($b,'browse',array('use'=>'literal'),array('use'=>'literal'));
    184. 

  184.     $o=$wsdl->addSoapOperation($bo,'');
    185. 

  185.     $o->setAttribute('style','rpc');
    186. 

  186.     $bo=$wsdl->addBindingOperation($b,'display',array('use'=>'literal'),array('use'=>'literal'));
    187. 

  187.     $o=$wsdl->addSoapOperation($bo,'');
    188. 

  188.     $o->setAttribute('style','rpc');
    189. 

  189.     return;
    190. 

  190.   }
    191. 

  191.   /// Sous fonction declarant les fonctions du module
    192. 

  192.   function _SOAPRequestFunctions(&$server) {
    193. 

  193.     function browse($context,$params){
    194. 

  194.       global $soapmod;
    195. 

  195.       $LANG_DATA = XShell::getLangData();
    196. 

  196.       XLogs::debug("SOAPRequest function browse LANG:$LANG_DATA filter:".$params->filter." fields:".$params->fields);
    197. 

  197.       $soapmod->SOAPContext($context,'browse');
    198. 

  198.       $ar=array('tplentry'=>TZR_RETURN_DATA,'pagesize'=>999999);
    199. 

  199.       if(!empty($params->fields)){
    200. 

  200. 	if($params->fields=='all' || $params->fields=='*') $ar['selectedfields']='all';
    201. 

  201. 	else $ar['selectedfields']=explode(',',$params->fields);
    202. 

  202.       }
    203. 

  203.       if(!empty($params->filter)){
    204. 

  204. 	$translatable = $soapmod->xset->getTranslatable();
    205. 

  205. 

  206. 	if(!$translatable) $LANG_DATA=TZR_DEFAULT_LANG;
    207. 

  207. 	$ar['select']='select * from '.$soapmod->table.' where LANG="'.$LANG_DATA.'" AND ('.str_ireplace(' select ','',$params->filter).')';
    208. 

  208.       }
    209. 

  209.       $ar['nocount'] = 1;
    210. 

  210.       foreach($ar['selectedfields'] as $fieldname){
    211. 

  211. 	$ar['options'][$fieldname]['nofollowlinks']=1;
    212. 

  212.       }
    213. 

  213.       $br=$soapmod->browse($ar);
    214. 

  214.       $lines=array();
    215. 

  215.       foreach($br['lines_oid'] as $i=>$oid){
    216. 

  216. 	$line=array('oid'=>$oid);
    217. 

  217. 	foreach($br['header_fields'] as $j=>&$f){
    218. 

  218. 	  $line[$f->field]=$br['lines_o'.$f->field][$i]->getSoapValue();
    219. 

  219. 	}
    220. 

  220. 	$lines[]=$line;
    221. 

  221.       }
    222. 

  222.       return array('line'=>$lines);
    223. 

  223.     }
    224. 

  224.     function display($context,$params){
    225. 

  225.       global $soapmod;
    226. 

  226.       XLogs::debug("SOAPRequest function display oid:".$params->oid);
    227. 

  227.       $soapmod->SOAPContext($context,'display',$params->oid);
    228. 

  228.       $ar=array('tplentry'=>TZR_RETURN_DATA,'oid'=>$params->oid);
    229. 

  229.       $br=$soapmod->display($ar);
    230. 

  230.       $ret=array('oid'=>$br['oid']);
    231. 

  231.       foreach($br['fields_object'] as $j=>&$f){
    232. 

  232. 	$ret[$f->field]=$br['o'.$f->field]->getSoapValue();
    233. 

  233.       }
    234. 

  234.       return $ret;
    235. 

  235.     }
    236. 

  236.     $server->addFunction(array('browse','display'));
    237. 

  237.   }
    238. 

  238. 

  239.   /// Rend la liste des fonctions utilisables dans le gestionnaire de rubriques en mode fonction (tableau de paires fonction=>label)
    240. 

  240.   function getUIFunctionList() {
    241. 

  241.     return array('display'=>XLabels::getSysLabel('xmodtable','uidisplay','text'),
    242. 

  242. 		 'procQuery'=>XLabels::getSysLabel('xmodtable','uiquery','text'),
    243. 

  243. 		 'insert'=>XLabels::getSysLabel('xmodtable','uiinsert','text'));
    244. 

  244.   }
    245. 

  245. 

  246.   /// Suppression du module
    247. 

  247.   function delete($ar=NULL) {
    248. 

  248.     return parent::delete($ar);
    249. 

  249.   }
    250. 

  250. 

  251.   /// Initialisation des propriétés
    252. 

  252.   public function initOptions() {
    253. 

  253.     parent::initOptions();
    254. 

  254.     $genlabel=XLabels::getSysLabel('xmodule.general');
    255. 

  255.     $this->_options->setOpt(XLabels::getSysLabel('xmodtable','multipleedit'),'multipleedit','boolean',NULL,NULL,$genlabel);
    256. 

  256.     $slabel=XLabels::getSysLabel('general','security','text');
    257. 

  257.     $this->_options->setOpt(XLabels::getSysLabel('xmodtable','owner_sec'),'owner_sec','boolean',NULL,NULL,$slabel);
    258. 

  258.     $alabel = XLabels::getSysLabel('xmodtable.modulename');
    259. 

  259.     $this->_options->setOpt(XLabels::getSysLabel('xmodtable','table'),'table','table',array('validate'=>true),NULL,$alabel);
    260. 

  260.     $this->_options->setOpt(XLabels::getSysLabel('xmodtable','filter'),'filter','text',NULL,NULL,$alabel);
    261. 

  261.     $this->_options->setOpt(XLabels::getSysLabel('xmodtable.order'),'order','text',NULL,NULL,$alabel);
    262. 

  262.     $this->_options->setOpt(XLabels::getSysLabel('xmodtable.quickquery'),'quickquery','boolean',NULL,NULL,$alabel);
    263. 

  263.     $this->_options->setOpt(XLabels::getSysLabel('xmodtable.stored_query'),'stored_query','boolean',NULL,NULL,$alabel);
    264. 

  264.     $this->_options->setOpt(XLabels::getSysLabel('xmodtable.pagesize'),'pagesize','text',NULL,NULL,$alabel);
    265. 

  265.     $this->_options->setOpt(XLabels::getSysLabel('xmodtable.templates'),'templates','template',array('moid'=>$this->_moid, 'cond'=>"(gtype like '%')"),
    266. 

  266. 			    NULL,$alabel);
    267. 

  267.     $this->_options->setOpt(XLabels::getSysLabel('xmodtable.btemplates'),'btemplates','template',array('moid'=>$this->_moid, 'cond'=>"(gtype like '%')"),
    268. 

  268. 			    NULL,$alabel);
    269. 

  269.     $this->_options->setOpt(XLabels::getSysLabel('xmodtable.captcha'),'captcha','boolean',NULL,NULL,$alabel);
    270. 

  270.     $this->_options->setOpt(XLabels::getSysLabel('xmodtable.savenext'),'savenext','list',
    271. 

  271. 			    array('values'=>array('standard','display','edit'),
    272. 

  272. 				  'labels'=>array(XLabels::getSysLabel('xmodtable.savenext_std'),
    273. 

  273. 						  XLabels::getSysLabel('xmodtable.savenext_display'),
    274. 

  274. 						  XLabels::getSysLabel('xmodtable.savenext_edit'))),
    275. 

  275. 			    NULL, $alabel);
    276. 

  276.     $this->_options->setOpt(XLabels::getSysLabel('general.systemproperties'),'showsystprop','list',
    277. 

  277. 			    array('values'=>array('show','hide'),
    278. 

  278. 				  'labels'=>array(XLabels::getSysLabel('general.yes'),
    279. 

  279. 						  XLabels::getSysLabel('general.no'))),
    280. 

  280. 			    NULL,$alabel);
    281. 

  281.     $this->_options->setOpt(XLabels::getSysLabel('xmodtable.persistentquery'),'persistentquery','boolean',NULL,NULL,$alabel);
    282. 

  282.     $slabel=XLabels::getSysLabel('xmodule.ssmod');
    283. 

  283.     $tlabel=XLabels::getSysLabel('general','title','text');
    284. 

  284.     $flabel=XLabels::getSysLabel('general','field','text');
    285. 

  285.     $ilabel=XLabels::getSysLabel('xmodtable','activate_additem');
    286. 

  286.     $dlabel=XLabels::getSysLabel('xmodtable','dependentfiles');
    287. 

  287.     $this->_options->setOpt(XLabels::getSysLabel('xmodtable','submodmax'),'submodmax','text',NULL,NULL,$slabel);
    288. 

  288.     $this->_options->setOpt(XLabels::getSysLabel('xmodtable','submodsearch'),'submodsearch','boolean',NULL,NULL,$slabel);
    289. 

  289.     if(!empty(XModule::$_mcache[$this->_moid]['MPARAM']['submodmax']))
    290. 

  290.       $this->_options->set($this,'submodmax',XModule::$_mcache[$this->_moid]['MPARAM']['submodmax']);
    291. 

  291.     for($i=1;$i<=$this->submodmax;$i++) {
    292. 

  292.       $this->_options->setOpt($tlabel.' '.$i,'ssmodtitle'.$i,'text',NULL,'',$slabel);
    293. 

  293.       $this->_options->setOpt($flabel.' '.$i,'ssmodfield'.$i,'text',NULL,'',$slabel);
    294. 

  294.       $this->_options->setOpt($slabel.' '.$i,'ssmod'.$i,'module',array('validate'=>true),'', $slabel);
    295. 

  295.       $this->_options->setOpt($ilabel.' '.$i,'ssmodactivate_additem'.$i,'boolean',NULL,true,$slabel);
    296. 

  296.       $this->_options->setOpt($dlabel.' '.$i,'ssmoddependent'.$i,'boolean',NULL,false,$slabel);
    297. 

  297.     }
    298. 

  298.     $tlabel=XLabels::getSysLabel('xmodule.tracking');
    299. 

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

  300.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','trackaccess'),'trackaccess','boolean',NULL,NULL,$tlabel);
    301. 

  301.     $this->_options->setOpt(XLabels::getSysLabel('xfielddef','archive'),'archive','boolean',NULL,NULL,$tlabel);
    302. 

  302.   }
    303. 

  303. 

  304.   /// Cette fonction est appliquee pour afficher l'ensemble des methodes de ce module
    305. 

  305.   protected function _actionlist(&$my) {
    306. 

  306.     parent::_actionlist($my);
    307. 

  307.     $myclass=get_class($this);
    308. 

  308.     $moid=$this->_moid;
    309. 

  309.     $myoid=@$_REQUEST['oid'];
    310. 

  310.     $user=&XUser::get_user();
    311. 

  311.     $f=XShell::_function();
    312. 

  312.     $uniqid='v'.XShell::uniqid();
    313. 

  313.     $submodcontext=NULL;
    314. 

  314. 

  315.     // Parcourir
    316. 

  316.     if($this->secure('','browse')){
    317. 

  317.       // recupération du contexte sous module
    318. 

  318.       $submodcontext = $this->subModuleContext(array(), true);
    319. 

  319.       // en sous fiche, le browse est un retour à la fiche parent
    320. 

  320.       if($this->dependant_module && $submodcontext) { 
    321. 

  321.         $o1=new XModuleAction($this,'browse',XLabels::getSysLabel('general','browse','text'),
    322. 

  322.                                 '&moid='.$this->dependant_module.'&_function=display&template=xmodtable/view.html&tplentry=br&oid='.
    323. 

  323.                                 $submodcontext['_parentoids'][0].$submodcontext['urlparms'],'display');
    324. 

  324.       } else {
    325. 

  325. 	$o1=new XModuleAction($this,'browse',XLabels::getSysLabel('general','browse','text'),
    326. 

  326. 			      '&moid='.$moid.'&_function=browse&template=xmodtable/browse.html&tplentry=br','display');
    327. 

  327.       }
    328. 

  328.       $o1->containable=true;
    329. 

  329.       $o1->setToolbar('general','browse');
    330. 

  330.       $my['browse']=$o1;
    331. 

  331.     }
    332. 

  332. 

  333.     // Recherche
    334. 

  334.     if((!$this->dependant_module || !$submodcontext) && $this->secure('','query')) {
    335. 

  335.       $o1=new XModuleAction($this,'query',XLabels::getSysLabel('general','query','text'),
    336. 

  336. 			    '&moid='.$moid.'&_function=query&template=xmodtable/query2.html&tplentry=br&querymode=query2','display');
    337. 

  337.       $o1->containable=true;
    338. 

  338.       $o1->setToolbar('general','query');
    339. 

  339.       $my['query']=$o1;
    340. 

  340.     }
    341. 

  341. 

  342.     // Recherche en cours
    343. 

  343.     if($this->isThereAQueryActive()) {
    344. 

  344.       $o1=new XModuleAction($this,'procQuery',XLabels::getSysLabel('general','currentquery','text'),
    345. 

  345. 			    '&moid='.$moid.'&_function=procQuery&template=xmodtable/browse.html&tplentry=br','display');
    346. 

  346.       $o1->setToolbar('general','currentquery');
    347. 

  347.       $my['procquery']=$o1;
    348. 

  348.     }
    349. 

  349. 

  350.     // Insert
    351. 

  351.     $lang_data=XShell::getLangData();
    352. 

  352.     $foo=NULL;
    353. 

  353.     if($this->xset->getTranslatable()==3) $sec=$this->secure($myoid,'insert',$foo,$lang_data);
    354. 

  354.     else $sec=$this->secure($myoid,'insert');
    355. 

  355.     if($sec && (!$this->dependant_module || !$submodcontext)) {
    356. 

  356.       $o1=new XModuleAction($this,'insert',XLabels::getSysLabel('general','new','text'),
    357. 

  357. 			    '&moid='.$moid.'&_function=insert&template=xmodtable/new.html&tplentry=br','edit');
    358. 

  358.       $o1->setToolbar('general','new');
    359. 

  359.       $o1->order=1;
    360. 

  360.       $my['insert']=$o1;
    361. 

  361.     }
    362. 

  362. 

  363.     // Actions de navigation de fiche en fiche : nous ne sommes pas en sous module
    364. 

  364.     if(!empty($this->navActions) && !$submodcontext){
    365. 

  365.       foreach($this->navActions as $ak=>$o){
    366. 

  366. 	$my[$ak] = $o;
    367. 

  367.       }
    368. 

  368.     }
    369. 

  369. 

  370.     // Avertir
    371. 

  371.     $oid=@$_REQUEST['oid'];
    372. 

  372.     if ($this->secure('', 'sendACopyTo')){
    373. 

  373.       if(!empty($oid)) {
    374. 

  374. 	$o1=new XModuleAction($this,'sendACopy',XLabels::getSysLabel('xmodule','sendacopyto','text'),
    375. 

  375. 			      '&moid='.$moid.'&tplentry=br&oid='.$oid.'&_function=sendACopyTo&template=xmodule/sendacopyto.html&tplentry=br');
    376. 

  376.       }else{
    377. 

  377. 	$o1=new XModuleAction($this,'sendACopy',XLabels::getSysLabel('xmodule','sendacopyto','text'),
    378. 

  378. 			      'javascript:'.$uniqid.'.applyfunction("sendACopyTo","",{template:"xmodule/sendacopyto.html"},true,true);');
    379. 

  379.       }
    380. 

  380.       $o1->menuable=true;
    381. 

  381.       $o1->group='more';
    382. 

  382.       $my['sendacopy']=$o1;
    383. 

  383.     }
    384. 

  384. 

  385.     // Impression
    386. 

  386.     if(in_array(XShell::_function(),array('display','edit'))) $printfct='printDisplay';
    387. 

  387.     else $printfct='printBrowse';
    388. 

  388.     if(XShell::_function()!='insert' && $this->secure($myoid,$printfct)){
    389. 

  389.       $o1=new XModuleAction($this,'print',XLabels::getSysLabel('general','print','text'),
    390. 

  390. 			    'javascript:'.$uniqid.'.printselected();','display');
    391. 

  391.       $o1->setToolbar('general','print');
    392. 

  392.       $my['print']=$o1;
    393. 

  393.     }
    394. 

  394. 

  395.     // Export
    396. 

  396.     if(in_array(XShell::_function(),array('display','edit'))) $expfct='exportDisplay';
    397. 

  397.     else $expfct='export';
    398. 

  398.     if(XShell::_function()!='insert' && $this->secure($myoid,$expfct)){
    399. 

  399.       $o1=new XModuleAction($this,'export',XLabels::getSysLabel('general','export','text'),'javascript:'.$uniqid.'.exportselected();',
    400. 

  400. 			    'edit');
    401. 

  401.       $o1->menuable=true;
    402. 

  402.       $my['sexport']=$o1;
    403. 

  403.     }
    404. 

  404. 

  405.     //Import
    406. 

  406.     if($this->secure('','manage')){
    407. 

  407.       $o1=new XModuleAction($this,'manage',XLabels::getSysLabel('general','import','text'),
    408. 

  408. 			    $GLOBALS['TZR_SESSION_MANAGER']::complete_self().'&moid='.$this->_moid.'&function=manage&template=xmodule/manage.html','edit');
    409. 

  409.       $o1->menuable=true;
    410. 

  410.       $my['import']=$o1;
    411. 

  411.     }
    412. 

  412. 

  413.     // Voir les documents non lus
    414. 

  414.     if($this->trackaccess && $this->secure('','getUnread')){
    415. 

  415.       $o1=new XModuleAction($this,'lastdoc',XLabels::getSysLabel('xmodule','unread','text'),
    416. 

  416. 			    '&moid='.$this->_moid.'&_function=getUnread&tplentry=br&template=xmodtable/getUnread.html','more');
    417. 

  417.       $o1->menuable=true;
    418. 

  418.       $my['unread']=$o1;
    419. 

  419.     }
    420. 

  420. 

  421.     // Abonnements
    422. 

  422.     $modsubmoid=XModule::getMoid(XMODSUB_TOID);
    423. 

  423.     if(!empty($modsubmoid)){
    424. 

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

  425. 			    '&amoid='.$this->_moid.'&moid='.$modsubmoid.
    426. 

  426. 			    '&_function=preSubscribe&tplentry=br&template=xmodsub/sub.html&aoid='.$myoid);
    427. 

  427.       $o1->menuable=true;
    428. 

  428.       $o1->group='more';
    429. 

  429.       $my['subscribe']=$o1;
    430. 

  430.     }
    431. 

  431. 

  432.     // Regles workflow
    433. 

  433.     if($this->stored_query){
    434. 

  434.       $modrulemoid=XModule::getMoid(XMODRULE_TOID);
    435. 

  435.       if(!empty($modrulemoid)){
    436. 

  436. 	$o1=new XModuleAction($this, 'rule', XLabels::getSysLabel('xmodrule','addrule','text'),
    437. 

  437. 			      '&amoid='.$this->_moid.'&moid='.$modrulemoid.
    438. 

  438. 			      '&_function=insertRule&tplentry=br&template=xmodrule/newRule.html&atemplate=xmodtable/editSelection.html');
    439. 

  439. 	$o1->menuable=true;
    440. 

  440. 	$o1->group='more';
    441. 

  441. 	$my['rule']=$o1;
    442. 

  442.       }
    443. 

  443.     }
    444. 

  444. 

  445.     // Mode conception et administration
    446. 

  446.     if($this->secure('','adminBrowseFields')){
    447. 

  447.       $o1=new XModuleAction($this, 'administration', XLabels::getSysLabel('general', 'administration', 'text'),
    448. 

  448. 			    '&moid='.$this->_moid.'&function=adminBrowseFields&template=xmodule/admin/browseFields.html','admin');
    449. 

  449.       $o1->setToolBar('general', 'administration');
    450. 

  450.       $my['administration']=$o1;
    451. 

  451.     }
    452. 

  452. 

  453.     // Chemin
    454. 

  454.     if($this->interactive) {
    455. 

  455.       if($this->dependant_module && $submodcontext) {
    456. 

  456. 	$mod1=XModule::objectFactory($this->dependant_module);
    457. 

  457. 	$o1=new XModuleAction($this,'browse',$mod1->modulename,
    458. 

  458. 			      '&moid='.$this->dependant_module.'&_function=browse&template=xmodtable/browse.html&tplentry=br');
    459. 

  459. 	$my['stack'][]=$o1;
    460. 

  460. 	$d1=&$mod1->xset->rDisplayText($submodcontext['_parentoids'][0], array());
    461. 

  461. 	$o1=new XModuleAction($this,'d1',$d1['link'],
    462. 

  462. 			      '&moid='.$this->dependant_module.'&_function=display&template=xmodtable/view.html&tplentry=br&oid='.
    463. 

  463. 			      $submodcontext['_parentoids'][0]);
    464. 

  464. 	$my['stack'][]=$o1;
    465. 

  465.       } else {
    466. 

  466. 	$o1=new XModuleAction($this,'browse',$this->modulename,
    467. 

  467. 			      '&moid='.$moid.'&_function=browse&template=xmodtable/browse.html&tplentry=br','display');
    468. 

  468. 	$my['stack'][]=$o1;
    469. 

  469. 	$f=XShell::_function();
    470. 

  470. 	if(strpos($f,'admin')===0){
    471. 

  471. 	  $o1=new XModuleAction($this,'adminBrowseFields',XLabels::getSysLabel('xmodule','browsefields','text').' ('.$this->xset->getTable().')',
    472. 

  472. 				'&moid='.$moid.'&_function=adminBrowseFields&template=xmodule/admin/browseFields.html','display');
    473. 

  473. 	  $my['stack'][]=$o1;
    474. 

  474. 	}
    475. 

  475.       }
    476. 

  476. 

  477.       if(!empty($oid) && !is_array($oid)) {
    478. 

  478. 	$br=&XShell::from_screen('br');
    479. 

  479. 	$br=&$this->xset->rDisplayText($oid, array());
    480. 

  480. 	if($submodcontext) {
    481. 

  481. 	  $o1=new XModuleAction($this,'browse',$br['link'],
    482. 

  482. 				'&moid='.$moid.$submodcontext['urlparms'].
    483. 

  483. 				'&_function=display&template=xmodtable/view.html&tplentry=br&oid='.$oid,'display');
    484. 

  484. 	} else {
    485. 

  485. 	  $o1=new XModuleAction($this,'browse',$br['link'],
    486. 

  486. 				'&moid='.$moid.'&_function=display&template=xmodtable/view.html&tplentry=br&oid='.$oid,'display');
    487. 

  487. 	}
    488. 

  488. 	$my['stack'][]=$o1;
    489. 

  489.       }
    490. 

  490.     }
    491. 

  491.   }
    492. 

  492. 

  493.   /// Action principale du menu
    494. 

  494.   public function getMainAction(){
    495. 

  495.     return $GLOBALS['TZR_SESSION_MANAGER']::complete_self().'moid='.$this->_moid.'&function=browse&tplentry=br&template=xmodtable/browse.html&_persistent=1';
    496. 

  496.   }
    497. 

  497. 

  498.   /**
    499. 

  499.    * Contruit la liste des actions relatives aux sous-modules
    500. 

  500.    * @param &$my array() Liste de XModuleAction
    501. 

  501.    */
    502. 

  502.   function getSSMAl(&$my){
    503. 

  503.     $uniqid='v'.XShell::uniqid();
    504. 

  504.     $myoid=@$_REQUEST['oid'];
    505. 

  505.     $ssmmenu=array();
    506. 

  506.     for($i=1;$i<=$this->submodmax;$i++) {
    507. 

  507.       $f='ssmod'.$i;
    508. 

  508.       $ff='ssmodfield'.$i;
    509. 

  509.       $fa='ssmodactivate_additem'.$i;
    510. 

  510.       if(!$this->$fa || !$this->$f) continue;
    511. 

  511.       if(empty($this->$ff)){
    512. 

  512. 	$smod=XModule::objectFactory($this->$f);
    513. 

  513. 	$links=$smod->xset->getXLinkDefs(NULL,$this->table);
    514. 

  514. 	if(!empty($links)) list($foo,$linkfield)=each($links);
    515. 

  515.       } else {
    516. 

  516. 	$linkfield = $this->$ff;
    517. 

  517.       }
    518. 

  518.       $ssm=XModule::objectFactory($this->$f);
    519. 

  519.       if(!$ssm->secure('','insert')) continue;
    520. 

  520.       $submodcontext=$this->subModuleContext($ar); // ???? sert pas
    521. 

  521.       $o1=new XModuleAction($this,$f,$ssm->modulename,
    522. 

  522. 			    'javascript:'.$uniqid.'.addTabs("'.$this->$f.'","'.$GLOBALS['TZR_SESSION_MANAGER']::complete_self().'&moid='.$this->$f.'&function=insert&template=xmodtable/new.html&tplentry=br&_linkedfields[]='.$linkfield.
    523. 

  523. 			    '&_parentoids[]='.$myoid.'&_parentoid='.$myoid.'&_linkedfield='.$linkfield.'&_raw=1&_ajax=1&skip=1'.			
    524. 

  524. 			    '&tabsmode=1","'.XLabels::getSysLabel('general','add','text').' : '.addslashes($ssm->modulename).'");');
    525. 

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

  526.       $ssmmenu[]=$o1;
    527. 

  527.     }
    528. 

  528.     if(count($ssmmenu)>1){
    529. 

  529.       $o1=new XModuleAction($this,'alladd',XLabels::getSysLabel('general','add','text'),'#');
    530. 

  530.       $o1->menuable=true;
    531. 

  531.       $o1->newgroup='ssm';
    532. 

  532.       $my['ssm']=$o1;
    533. 

  533.       foreach($ssmmenu as &$o1){
    534. 

  534. 	$o1->group='ssm';
    535. 

  535. 	$my[$o1->xfunction]=$o1;
    536. 

  536.       }
    537. 

  537.     }else{
    538. 

  538.       foreach($ssmmenu as &$o1){
    539. 

  539. 	$o1->name=XLabels::getSysLabel('general','add','text').' : '.$o1->name;
    540. 

  540. 	$my[$o1->xfunction]=$o1;
    541. 

  541.       }
    542. 

  542.     }
    543. 

  543.   }
    544. 

  544. 

  545.   /**
    546. 

  546.    * Construit la liste des actions à rendre disponible lors de l'affichage d'une fiche (display)
    547. 

  547.    * @param &$my array() Liste de XModuleAction
    548. 

  548.    */
    549. 

  549.   function al_display(&$my){
    550. 

  550.     $uniqid='v'.XShell::uniqid();
    551. 

  551.     $moid=$this->_moid;
    552. 

  552.     $myoid=@$_REQUEST['oid'];
    553. 

  553.     $sec=$this->secure($myoid,'edit');
    554. 

  554.     if($sec) {
    555. 

  555.       // recuperation contexte sous module
    556. 

  556.       $submodcontext=$this->subModuleContext();
    557. 

  557.       $o1=new XModuleAction($this,'edit',XLabels::getSysLabel('general','edit','text'),
    558. 

  558. 			    '&function=edit&moid='.$moid.'&template=xmodtable/edit.html&tplentry=br&oid='.$myoid.$submodcontext['urlparms'],'edit');
    559. 

  559.       $o1->order=2;
    560. 

  560.       $o1->setToolbar('general','edit');
    561. 

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

  562.     }
    563. 

  563.     $sec=$this->secure($myoid,'del');
    564. 

  564.     if($sec){
    565. 

  565.       $o1=new XModuleAction($this,'del',XLabels::getSysLabel('general','delete','text'),'javascript:'.$uniqid.'.deleterecord();','edit');
    566. 

  566.       $o1->order=3;
    567. 

  567.       $o1->setToolbar('general','delete');
    568. 

  568.       $my['del']=$o1;
    569. 

  569.     }
    570. 

  570.     $this->getSSMAl($my);
    571. 

  571.   }
    572. 

  572. 

  573.   /**
    574. 

  574.    * Construit la liste des actions à rendre disponible lors de la préparation à l'édition d'une fiche (edit)
    575. 

  575.    * @param &$my array() Liste de XModuleAction
    576. 

  576.    */
    577. 

  577.   function al_edit(&$my){
    578. 

  578.     $uniqid='v'.XShell::uniqid();
    579. 

  579.     $myoid=@$_REQUEST['oid'];
    580. 

  580.     $o1=new XModuleAction($this,'save',XLabels::getSysLabel('general','save','text'),'javascript:'.$uniqid.'.saverecord();','edit');
    581. 

  581.     $o1->order=1;
    582. 

  582.     $o1->setToolbar('general','save');
    583. 

  583.     $my['save']=$o1;
    584. 

  584.     // recuperation contexte sous module
    585. 

  585.     $submodcontext=$this->subModuleContext();
    586. 

  586.     $o1=new XModuleAction($this,'display',XLabels::getSysLabel('general','display','text'),
    587. 

  587. 			  '&function=display&moid='.$this->_moid.'&template=xmodtable/view.html&tplentry=br&oid='.$myoid.$submodcontext['urlparms'],
    588. 

  588. 			  'edit');
    589. 

  589.     $o1->order=2;
    590. 

  590.     $o1->setToolbar('general','display');
    591. 

  591.     $my['display']=$o1;
    592. 

  592.     $sec=$this->secure($myoid,'del');
    593. 

  593.     if($sec){
    594. 

  594.       $o1=new XModuleAction($this,'del',XLabels::getSysLabel('general','delete','text'),'javascript:'.$uniqid.'.deleterecord();','edit');
    595. 

  595.       $o1->order=3;
    596. 

  596.       $o1->setToolbar('general','delete');
    597. 

  597.       $my['del']=$o1;
    598. 

  598.     }
    599. 

  599.     $this->getSSMAl($my);
    600. 

  600.   }
    601. 

  601. 

  602.   /**
    603. 

  603.    * Construit la liste des actions à rendre disponible lors de l'édition d'une fiche (procEdit)
    604. 

  604.    * @param &$my array() Liste de XModuleAction
    605. 

  605.    */
    606. 

  606.   function al_procEdit(&$my){
    607. 

  607.     $this->al_edit($my);
    608. 

  608.   }
    609. 

  609. 

  610.   /**
    611. 

  611.    * Construit la liste des actions à rendre disponible lors de la duplication d'une fiche (procEditDup)
    612. 

  612.    * @param &$my array() Liste de XModuleAction
    613. 

  613.    */
    614. 

  614.   function al_procEditDup(&$my){
    615. 

  615.     $this->al_insert($my);
    616. 

  616.   }
    617. 

  617. 

  618.   /**
    619. 

  619.    * Construit la liste des actions à rendre disponible lors de la préparation à l'insertion d'une fiche (insert)
    620. 

  620.    * @param &$my array() Liste de XModuleAction
    621. 

  621.    */
    622. 

  622.   function al_insert(&$my){
    623. 

  623.     $uniqid='v'.XShell::uniqid();
    624. 

  624.     $o1=new XModuleAction($this,'save',XLabels::getSysLabel('general','save','text'),'javascript:'.$uniqid.'.saverecord();','edit');
    625. 

  625.     $o1->order=1;
    626. 

  626.     $o1->setToolbar('general','save');
    627. 

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

  628.   }
    629. 

  629. 

  630.   /**
    631. 

  631.    * Construit la liste des actions à rendre disponible lors de l'insertion d'une fiche (procInsert)
    632. 

  632.    * @param &$my array() Liste de XModuleAction
    633. 

  633.    */
    634. 

  634.   function al_procInsert(&$my){
    635. 

  635.     $this->al_insert($my);
    636. 

  636.   }
    637. 

  637. 

  638.   /**
    639. 

  639.    * Construit la liste des actions à rendre disponible lors du listing des fiches du module (browse)
    640. 

  640.    * @param &$my array() Liste de XModuleAction
    641. 

  641.    */
    642. 

  642.   function al_browse(&$my){
    643. 

  643.     $uniqid='v'.XShell::uniqid();
    644. 

  644.     $moid=$this->_moid;
    645. 

  645.     $myoid=@$_REQUEST['oid'];
    646. 

  646.     if($this->secure($myoid,'del')){
    647. 

  647.       $o1=new XModuleAction($this,'del',XLabels::getSysLabel('general','delete','text'),'javascript:'.$uniqid.'.deleteselected();','edit');
    648. 

  648.       $o1->setToolbar('general','delete');
    649. 

  649.       $o1->order=3;
    650. 

  650.       $my['del']=$o1;
    651. 

  651.     }
    652. 

  652. 

  653.     if($this->objectSecurityEnabled() && $this->secure($myoid,'secEditSimple')){
    654. 

  654.       $o1=new XModuleAction($this,'seceditsimple',XLabels::getSysLabel('general','security','text'),
    655. 

  655. 			    'javascript:TZR.editSec("'.$GLOBALS['TZR_SESSION_MANAGER']::complete_self(true).'","'.$this->_moid.'","",'.$uniqid.');','edit');
    656. 

  656.       $o1->setToolbar('general','security');
    657. 

  657.       $o1->order=4;
    658. 

  658.       $my['secEditSimple']=$o1;
    659. 

  659.     }
    660. 

  660. 

  661.     if(isset($this->xset->desc['PUBLISH'])){
    662. 

  662.       if($this->secure($myoid,'publish')){
    663. 

  663. 	$o1=new XModuleAction($this,'approve',XLabels::getSysLabel('general','approve','text'),
    664. 

  664. 			      'javascript:'.$uniqid.".applyfunction('publish','',{value:1});",'edit');
    665. 

  665. 	$o1->menuable=true;
    666. 

  666. 	$my['approve']=$o1;
    667. 

  667. 	$o1=new XModuleAction($this,'unapprove',XLabels::getSysLabel('general','unapprove','text'),
    668. 

  668. 			      'javascript:'.$uniqid.".applyfunction('publish','',{value:2});",'edit');
    669. 

  669. 	$o1->menuable=true;
    670. 

  670. 	$my['unapprove']=$o1;
    671. 

  671.       }
    672. 

  672.     }
    673. 

  673. 

  674.     // Affichage (changement taille page, ajout de champ...)
    675. 

  675.     $o1=new XModuleAction($this,'fieldgrp',XLabels::getSysLabel('xmodtable','field_label','text'),'#','display');
    676. 

  676.     $o1->menuable=true;
    677. 

  677.     $o1->newgroup='fieldgrp';
    678. 

  678.     $my['fieldgrp']=$o1;
    679. 

  679.     foreach($this->xset->orddesc as $i=>$fn){
    680. 

  680.       $f=$this->xset->getField($fn);
    681. 

  681.       $o1=new XModuleAction($this,'field'.$fn,$f->label,'javascript:'.$uniqid.'.add_field(\''.$fn.'\');'.$uniqid.'.go_browse(\'\',0);','fieldgrp');
    682. 

  682.       $o1->menuable=true;
    683. 

  683.       $my['field'.$fn]=$o1;
    684. 

  684.     }
    685. 

  685.     $o1=new XModuleAction($this,'pgmore',XLabels::getSysLabel('xmodtable','page_size','text').' * 2',
    686. 

  686. 			  'javascript:'.$uniqid.'.go_browse("start","*2");','display');
    687. 

  687.     $o1->menuable=true;
    688. 

  688.     $my['pgmore']=$o1;
    689. 

  689.     $o1=new XModuleAction($this,'pgless',XLabels::getSysLabel('xmodtable','page_size','text').' / 2',
    690. 

  690. 			  'javascript:'.$uniqid.'.go_browse("start","/2");','display');
    691. 

  691.     $o1->menuable=true;
    692. 

  692.     $my['pgless']=$o1;
    693. 

  693. 

  694.     if($this->multipleedit && $this->secure('','editSelection')){
    695. 

  695.       $o1=new XModuleAction($this,'editselection',XLabels::getSysLabel('xmodmedia','editselection','text'),
    696. 

  696. 			    'javascript:'.$uniqid.'.applyfunction("editSelection","",{template:"xmodtable/editSelection.html"},true,true);','edit');
    697. 

  697.       $o1->order=2;
    698. 

  698.       $o1->setToolbar('general','edit');
    699. 

  699.       $my['editselection']=$o1;
    700. 

  700.     }
    701. 

  701. 

  702.     // Edition/suppression sur le resultat d'une recherche
    703. 

  703.     if($this->isThereAQueryActive()){
    704. 

  704.       if($this->secure('','editAll')){
    705. 

  705. 	$o1=new XModuleAction($this,'editall',XLabels::getSysLabel('general','editall','text'),
    706. 

  706. 			      'javascript:'.$uniqid.'.applyfunction("editAll","",{template:"xmodmedia/editSelection.html"},false,true);','edit');
    707. 

  707. 	$o1->order=2;
    708. 

  708. 	$o1->menuable=true;
    709. 

  709. 	$my['editall']=$o1;
    710. 

  710.       }
    711. 

  711.       if($this->secure('','delAll')){
    712. 

  712. 	$o1=new XModuleAction($this,'delall',XLabels::getSysLabel('general','delall','text'),
    713. 

  713. 			      'javascript:'.$uniqid.'.applyfunction("delAll","'.XLabels::getSysLabel('general','confirm_delete_object','text').'","");','edit');
    714. 

  714. 	$o1->order=3;
    715. 

  715. 	$o1->menuable=true;
    716. 

  716. 	$my['delall']=$o1;
    717. 

  717.       }
    718. 

  718.     }
    719. 

  719.   }
    720. 

  720. 

  721.   /**
    722. 

  722.    * Construit la liste des actions à rendre disponible lors d'une recherche sur les fiches du module (procQuery)
    723. 

  723.    * @param &$my array() Liste de XModuleAction
    724. 

  724.    */
    725. 

  725.   function al_procQuery(&$my){
    726. 

  726.     $this->al_browse($my);
    727. 

  727.   }
    728. 

  728. 

  729.   /// Fonctions sur gestion des champs
    730. 

  730.   function al_adminBrowseFields(&$my){
    731. 

  731.     $uniqid='v'.XShell::uniqid();
    732. 

  732.     $o1=new XModuleAction($this,'importfieldssec',XLabels::getSysLabel('xmodule','importfieldssec','text'),
    733. 

  733. 			  '&moid='.$this->_moid.'&_function=adminPreImportFieldsSec&template=xmodule/admin/preimportfieldssec.html&tplentry=br','more');
    734. 

  734.     $o1->menuable=true;
    735. 

  735.     $my['importfieldssec']=$o1;
    736. 

  736.     $o1=new XModuleAction($this,'newfield',XLabels::getSysLabel('xdatasource','new_field','text'),
    737. 

  737. 			  '&moid='.$this->_moid.'&function=adminNewField&template=xmodule/admin/newField.html');
    738. 

  738.     $o1->menuable=true;
    739. 

  739.     $my['newfield']=$o1;
    740. 

  740.     $o1=new XModuleAction($this,'emptydata',XLabels::getSysLabel('xdatasource','empty_data','text'),
    741. 

  741. 			  'javascript:'.$uniqid.'.emptybase();','more');
    742. 

  742.     $o1->menuable=true;
    743. 

  743.     $my['emptydata']=$o1;
    744. 

  744.     $o1=new XModuleAction($this,'clonebase',XLabels::getSysLabel('general','clone','text'),
    745. 

  745. 			  '&moid='.$this->_moid.'&function=adminDuplicate&template=xmodule/admin/duplicate.html&tplentry=br','more');
    746. 

  746.     $o1->menuable=true;
    747. 

  747.     $my['clonebase']=$o1;
    748. 

  748.     $o1=new XModuleAction($this,'checkbase',XLabels::getSysLabel('general','check','text'),
    749. 

  749. 			  '&moid='.$this->_moid.'&function=adminChk&skip=1&_next='.rawurlencode($GLOBALS['XSHELL']->get_back_url(0)),'more');
    750. 

  750.     $o1->menuable=true;
    751. 

  751.     $my['checkbase']=$o1;
    752. 

  752.     $o1=new XModuleAction($this,'checkrbase',XLabels::getSysLabel('general','check_and_repair','text'),
    753. 

  753. 			  '&moid='.$this->_moid.'&function=adminChk&skip=1&repair=1&_next='.rawurlencode($GLOBALS['XSHELL']->get_back_url(0)),'more');
    754. 

  754.     $o1->menuable=true;
    755. 

  755.     $my['checkrbase']=$o1;
    756. 

  756.     $o1=new XModuleAction($this,'propbase',XLabels::getSysLabel('general','properties','text'),
    757. 

  757. 			  '&moid='.$this->_moid.'&function=adminEditSourceProperties&template=xmodule/admin/editSource.html','more');
    758. 

  758.     $o1->menuable=true;
    759. 

  759.     $my['propbase']=$o1;
    760. 

  760.     $o1=new XModuleAction($this,'printbase',XLabels::getSysLabel('general','print','text'),
    761. 

  761. 			  'javascript:'.$uniqid.'.printselected();');
    762. 

  762.     $o1->menuable=true;
    763. 

  763.     $my['printbase']=$o1;
    764. 

  764.   }
    765. 

  765. 

  766.   /// Fonctions sur gestion des champs
    767. 

  767.   function al_adminBrowseStrings(&$my){
    768. 

  768.     $uniqid='v'.XShell::uniqid();
    769. 

  769.     $o1=new XModuleAction($this,'alphasort',XLabels::getSysLabel('general','alpha_sort','text'),
    770. 

  770. 			  '&moid='.$this->_moid.'&function=adminSortStrings&skip=1&field='.$_REQUEST['field'].'&_next='.rawurlencode($GLOBALS['XSHELL']->get_back_url(0)));
    771. 

  771.     $o1->menuable=true;
    772. 

  772.     $my['alphasort']=$o1;
    773. 

  773.     $o1=new XModuleAction($this,'deletebase',XLabels::getSysLabel('general','delete_all','text'),
    774. 

  774. 			  'javascript:'.$uniqid.'.deleteall();');
    775. 

  775.     $o1->menuable=true;
    776. 

  776.     $my['deleteall']=$o1;
    777. 

  777.     $o1=new XModuleAction($this,'newstring',XLabels::getSysLabel('general','new','text'),
    778. 

  778. 			  '&moid='.$this->_moid.'&function=adminNewString&template=xmodule/admin/newString.html&field='.$_REQUEST['field']);
    779. 

  779.     $o1->menuable=true;
    780. 

  780.     $my['newstring']=$o1;
    781. 

  781.   }
    782. 

  782. 

  783.   /// Fonctions sur gestion des champs
    784. 

  784.   function al_adminEditField(&$my){
    785. 

  785.     $uniqid='v'.XShell::uniqid();
    786. 

  786.     $br=&XShell::from_screen('');
    787. 

  787.     $o1=new XModuleAction($this,'resetchrono','Reset',
    788. 

  788. 			  '&moid='.$this->_moid.'&_function=adminResetChrono&field='.$br['field'].'&boid='.$br['boid'].'&skip=1&_next='.
    789. 

  789. 			  rawurlencode($GLOBALS['XSHELL']->get_back_url(0)),'more');
    790. 

  790.     $o1->menuable=true;
    791. 

  791.     $my['resetchrono']=$o1;
    792. 

  792.   }
    793. 

  793. 

  794.   function nav($ar=NULL){
    795. 

  795.     parent::nav($ar);
    796. 

  796.     if(substr(XShell::_function(),0,5)=='admin') {
    797. 

  797.       $this->pushNav(XLabels::getSysLabel('general','administration','text'),
    798. 

  798. 		     '&function=adminBrowseFields&moid='.$this->_moid.'&template=xmodule/admin/browseFields.html&boid='.$this->boid);
    799. 

  799.     }
    800. 

  800.   }
    801. 

  801. 

  802. 

  803.   function isDependant() {
    804. 

  804.     return XDbIni::get('dependant:'.$this->_moid,'val');
    805. 

  805.   }
    806. 

  806. 

  807.   /// Preparartion des donnees pour ecran de parametrage d'impression
    808. 

  808.   public function prePrintBrowse($ar) {
    809. 

  809.     $p=new XParam($ar,array());
    810. 

  810.     $order=$p->get('order');
    811. 

  811.     $tplentry=$p->get('tplentry');
    812. 

  812.     if(empty($order)) $order=$this->order;
    813. 

  813.     $ar['order']=$order;
    814. 

  814.     $ar['table']=$this->table;
    815. 

  815.     // Recherche des templates d'impression
    816. 

  816.     if(empty($this->_templates)) $this->_templates=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS=TEMPLATES');
    817. 

  817.     if(!empty($this->_templates)) {
    818. 

  818.       $q1=$this->_templates->select_query(array('cond'=>array('modid'=>array('=',$this->_moid),
    819. 

  819. 							      'gtype'=>array('=','xmodtable_browse_print'))));
    820. 

  820.       $r=&$this->_templates->browse(array('select'=>$q1,'pagesize'=>100,'tplentry'=>TZR_RETURN_DATA));
    821. 

  821.       XShell::toScreen1($tplentry.'t',$r);
    822. 

  822.     }
    823. 

  823.     // recherche des donnees
    824. 

  824.     $ar['_filter']=$this->getFilter(true,$ar);
    825. 

  825.     $ar['tplentry']=TZR_RETURN_DATA;
    826. 

  826.     $ar['fieldssec']=$this->getFieldsSec($ar);
    827. 

  827.     $ar['selectedfields']='all';
    828. 

  828.     $ar['pagesize']=1;
    829. 

  829.     $ar['ssmoid']='all';
    830. 

  830.     for($i=1;$i<=$this->submodmax;$i++) {
    831. 

  831.       $f='ssmod'.$i;
    832. 

  832.       $ar['options'][$this->$f]['selectedfields']='all';
    833. 

  833.     }
    834. 

  834. 

  835.     // cas module ayant lui meme en sous modules
    836. 

  836.     $mycurrentquery = NULL;
    837. 

  837.     if($this->isThereAQueryActive())
    838. 

  838.       $mycurrentquery = $this->_getSession('query');
    839. 

  839. 

  840.     $r=&$this->xset->browse($ar);
    841. 

  841.     $this->setSubModules($ar,$r);
    842. 

  842. 

  843.     if ($mycurrentquery != NULL)
    844. 

  844.        $this->_setSession('query', $mycurrentquery);
    845. 

  845. 

  846.     // calcul du nombre d'enregistrements impactes (passage d'oid, browseSelection ou browse/query classique)
    847. 

  847.     $r['_selected']=$p->get('_selected');
    848. 

  848.     if(is_array($r['_selected'])) {
    849. 

  849.       $r['record_count']=count($r['_selected']);
    850. 

  850.     }elseif($p->get('fromfunction')=='browseSelection') {
    851. 

  851.       $selection=getSessionVar('selection');
    852. 

  852.       $r['_selected']=$selection[$this->_moid];
    853. 

  853.       $r['record_count']=count($r['_selected']);
    854. 

  854.     }else{
    855. 

  855.       $context=$this->getContextQuery($ar,false);
    856. 

  856.       $ar['select']=$context['query'];
    857. 

  857.       $q=$this->xset->getSelectQuery($ar);
    858. 

  858.       $r['record_count']=countSelectQuery($q[1],true);
    859. 

  859.       $r['queryfields']=$context['all']['queryfields'];
    860. 

  860.     }
    861. 

  861.     return XShell::toScreen1($tplentry,$r);
    862. 

  862.   }
    863. 

  863. 

  864.   /// Retourne la requete permattant de recuperer tous les objets suivant le contexte (selection, recherche en cours...)
    865. 

  865.   function getContextQuery($ar,$queryonly=true){
    866. 

  866.     $p=new XParam($ar,array());
    867. 

  867.     $oidsel=$p->get('_selected');
    868. 

  868.     $noreg=$p->get('noreg');
    869. 

  869.     $from=$p->get('fromfunction');
    870. 

  870.     if(is_array($oidsel)) {
    871. 

  871.       $oid=array_keys($oidsel);
    872. 

  872.       $q=$this->xset->select_query(array('cond'=>array('KOID'=>array('=',$oid))));
    873. 

  873.     }elseif($this->isThereAQueryActive() && ($from=='procQuery')) {
    874. 

  874.       $_storedquery=$this->_getSession('query');
    875. 

  875.       $ar1=array_merge($_storedquery,$ar);
    876. 

  876.       if($queryonly){
    877. 

  877. 	$ar1['getselectonly']=true;
    878. 

  878. 	$q=$this->xset->procQuery($ar1);
    879. 

  879.       }else{
    880. 

  880. 	$ar1['getselectonly']=false;
    881. 

  881. 	$ar1['pagesize']=1;
    882. 

  882. 	$r=$this->xset->procQuery($ar1);
    883. 

  883. 	$q=$r['select'];
    884. 

  884. 	$params=array('queryobject'=>$r['queryobject']);
    885. 

  885.       }
    886. 

  886.       if(!$noreg) $q=preg_replace('@select (.*) from (.*)$@i','select '.$this->table.'.* from $2',$q);
    887. 

  887.     }else{
    888. 

  888.       $q=$this->xset->select_query(array("cond"=>array()));
    889. 

  889.     }
    890. 

  890.     if($queryonly) return $q;
    891. 

  891.     else return array('query'=>$q,'all'=>$r);
    892. 

  892.   }
    893. 

  893. 

  894.   /// Impression sur un browse
    895. 

  895.   public function printBrowse($ar) {
    896. 

  896.     $p=new XParam($ar,array());
    897. 

  897.     $title=$p->get('title');
    898. 

  898.     $email=$p->get('dest');
    899. 

  899.     $target=$p->get('_target');
    900. 

  900.     $linkedfield=$p->get('_linkedfield');
    901. 

  901.     $fmt=$p->get('fmt');
    902. 

  902.     $context=$this->getContextQuery($ar,false);
    903. 

  903.     $q=$context['query'];
    904. 

  904.     $ar['selected']='0';
    905. 

  905.     $ar['pagesize']='100000';
    906. 

  906.     $ar['select']=$q;
    907. 

  907.     $ar['_format']='text/html';
    908. 

  908.     $ar['tplentry']=TZR_RETURN_DATA;
    909. 

  909.     $tpldata['param']=array('title'=>$title,'queryfields'=>$context['all']['queryfields']);
    910. 

  910.     $oldinteractive=$this->interactive;
    911. 

  911.     $this->interactive=false;
    912. 

  912.     if(!empty($target) && $target!=$this->_moid){
    913. 

  913.       $mod=XModule::objectFactory($target);
    914. 

  914.       if($mod->secure('','export')){
    915. 

  915. 	$ar2=$ar;
    916. 

  916. 	$ar['selectedfields']=array('xx');
    917. 

  917. 	$ar['order']=$this->order;
    918. 

  918. 	$b=$this->browse($ar);
    919. 

  919. 	$q='select * from '.$mod->table.' where '.$linkedfield.' in ("'.implode('","',$b['lines_oid']).'")';
    920. 

  920. 	$ar2['select']=$q;
    921. 

  921. 	$ar2['tplentry']=$tplentry;
    922. 

  922. 	if($fmt=='pdf')	$ar2['_format']='application/prince';
    923. 

  923. 	$res=$mod->browse($ar2);
    924. 

  924.       }
    925. 

  925.     }else{
    926. 

  926.       if($fmt=='pdf') $ar['_format']='application/prince';
    927. 

  927.       $res=$this->browse($ar);
    928. 

  928.       $mod=&$this;
    929. 

  929.     }
    930. 

  930.     $this->interactive=$oldinteractive;
    931. 

  931.     if($fmt=='pdf') {
    932. 

  932.       // Impression PDF par defaut
    933. 

  933.       if(!empty($this->_templates) && !empty($this->btemplates)) {
    934. 

  934.         $r=&$this->_templates->display(array('oid'=>$this->btemplates,'_options'=>array('error'=>'return'),'tplentry'=>TZR_RETURN_DATA));
    935. 

  935.         if(!empty($r['oprintp']->filename)) $filename=$r['oprintp']->filename;
    936. 

  936.       }
    937. 

  937.       $this->_printBrowsePDF($ar,$filename);
    938. 

  938.     }elseif(Kernel::isAKoid($fmt)) {
    939. 

  939.       // Impression via un template d'impressions
    940. 

  940.       $t=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$fmt);
    941. 

  941.       $dispfmt=$t->rDisplay($fmt);
    942. 

  942.       $displayformats=explode(',',$dispfmt['odfmt']->raw);
    943. 

  943.       if(in_array('text/html',$displayformats) || empty($dispfmt['odfmt']->raw)) $this->_printBrowseHTML($ar,$dispfmt['oprint']->filename);
    944. 

  944.       elseif(in_array('application/prince',$displayformats)) $this->_printBrowsePDF($ar,$dispfmt['oprint']->filename);
    945. 

  945.     }else{
    946. 

  946.       // Impression HTML par defaut
    947. 

  947.       $template=$p->get('template');
    948. 

  948.       $this->_printBrowseHTML($ar,$template);
    949. 

  949.     }
    950. 

  950.   }
    951. 

  951.   /// Sous fonction d'impression au format HTML
    952. 

  952.   function _printBrowseHTML($ar=NULL,$filename=NULL){
    953. 

  953.     $p=new XParam($ar,NULL);
    954. 

  954.     $email=$p->get('dest');
    955. 

  955.     if(empty($filename)) $filename='xmodtable/print.html';
    956. 

  956.     $content=$this->_printGetContent($ar,$filename,'browse');
    957. 

  957.     if(!empty($email)) $this->sendMail2User('print','',$email,NULL,false,NULL,'report.html',$content);
    958. 

  958.     echo $content;
    959. 

  959.     exit(0);
    960. 

  960.   }
    961. 

  961.   /// Sous fonction d'impression au format PDF
    962. 

  962.   function _printBrowsePDF($ar=NULL,$filename=NULL){
    963. 

  963.     $p=new XParam($ar,array('pdfname'=>'browse.pdf'));
    964. 

  964.     $email=$p->get('dest');
    965. 

  965.     if(empty($filename)) $filename='xmodtable/print.xml';
    966. 

  966.     $ar['_format']='application/prince';
    967. 

  967.     $content=$this->_printGetContent($ar,$filename,'browse');
    968. 

  968.     $tmpname=princeTidyXML2PDF(NULL,$content);
    969. 

  969.     if(!empty($email) && !empty($tmpname)) {
    970. 

  970.       $content=file_get_contents($tmpname);
    971. 

  971.       $this->sendMail2User('print','',$email,NULL,false,NULL,'browse.pdf',$content,'application/pdf');
    972. 

  972.     }
    973. 

  973.     $pdfname=$p->get('pdfname');
    974. 

  974.     header('Content-type: application/pdf');
    975. 

  975.     header('Content-disposition: attachment; filename='.$pdfname);
    976. 

  976.     $size=filesize($tmpname);
    977. 

  977.     header('Accept-Ranges: bytes');
    978. 

  978.     header('Content-Length: '.$size);
    979. 

  979.     readfile($tmpname);
    980. 

  980.     unlink($tmpname);
    981. 

  981.     exit(0);
    982. 

  982.   }
    983. 

  983.   /// Impression d'une fiche
    984. 

  984.   public function printDisplay($ar) {
    985. 

  985.     $p=new XParam($ar,array('pdfname'=>'view.pdf'));
    986. 

  986.     $tplentry=$p->get('tplentry');
    987. 

  987.     $ar['tplentry']=TZR_RETURN_DATA;
    988. 

  988.     $ar['ssmoid']='all';
    989. 

  989.     $fmt=$p->get('fmt');
    990. 

  990.     if($fmt=='pdf') {
    991. 

  991.       // Impression PDF par defaut
    992. 

  992.       if(!empty($this->_templates) && !empty($this->templates)) {
    993. 

  993. 	$r=&$this->_templates->display(array('oid'=>$this->templates,'_options'=>array('error'=>'return'),'tplentry'=>TZR_RETURN_DATA));
    994. 

  994. 	if(!empty($r['oprintp']->filename)) $filename=$r['oprintp']->filename;
    995. 

  995.       }
    996. 

  996.       $this->_printDisplayPDF($ar,$filename);
    997. 

  997.     }elseif(Kernel::isAKoid($fmt)) {
    998. 

  998.       // Impression via un template d'impressions
    999. 

  999.       $t=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$fmt);
    1000. 

  1000.       $dispfmt=$t->display(array('oid'=>$fmt,'tplentry'=>TZR_RETURN_DATA));
    1001. 

  1001.       $displayformats=explode(',',$dispfmt['odfmt']->raw);
    1002. 

  1002.       if(in_array('text/html',$displayformats) || empty($dispfmt['odfmt']->raw)) $this->_printDisplayHTML($ar,$dispfmt['oprint']->filename);
    1003. 

  1003.       elseif(in_array('application/prince',$displayformats)) $this->_printDisplayPDF($ar,$dispfmt['oprint']->filename);
    1004. 

  1004.     }else{
    1005. 

  1005.       // Impression HTML par defaut
    1006. 

  1006.       $template=$p->get('template');
    1007. 

  1007.       $this->_printDisplayHTML($ar,$template);
    1008. 

  1008.     }
    1009. 

  1009.   }
    1010. 

  1010.   /// Sous fonction d'impression au format HTML
    1011. 

  1011.   function _printDisplayHTML($ar=NULL,$filename=NULL){
    1012. 

  1012.     $p=new XParam($ar,NULL);
    1013. 

  1013.     $email=$p->get('dest');
    1014. 

  1014.     if(empty($filename)) $filename='xmodtable/printdisplay.html';
    1015. 

  1015.     $content=$this->_printGetContent($ar,$filename,'display');
    1016. 

  1016.     if(!empty($email)) $this->sendMail2User('print','',$email,NULL,false,NULL,'report.html',$content);
    1017. 

  1017.     echo $content;
    1018. 

  1018.     exit(0);
    1019. 

  1019.   }
    1020. 

  1020.   /// Sous fonction d'impression au format PDF
    1021. 

  1021.   function _printDisplayPDF($ar=NULL,$filename=NULL){
    1022. 

  1022.     $p=new XParam($ar,array('pdfname'=>'view.pdf'));
    1023. 

  1023.     $email=$p->get('dest');
    1024. 

  1024.     if(empty($filename)) $filename='xmodtable/print-view.xml';
    1025. 

  1025.     $ar['_format']='application/prince';
    1026. 

  1026.     $content=$this->_printGetContent($ar,$filename,'display');
    1027. 

  1027.     $tmpname=princeTidyXML2PDF(NULL,$content);
    1028. 

  1028.     if(!empty($email) && !empty($tmpname)) {
    1029. 

  1029.       $content=file_get_contents($tmpname);
    1030. 

  1030.       $this->sendMail2User('print','',$email,NULL,false,NULL,'view.pdf',$content,'application/pdf');
    1031. 

  1031.     }
    1032. 

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

  1033.     header('Content-type: application/pdf');
    1034. 

  1034.     header('Content-disposition: attachment; filename='.$pdfname);
    1035. 

  1035.     $size=filesize($tmpname);
    1036. 

  1036.     header('Accept-Ranges: bytes');
    1037. 

  1037.     header('Content-Length: '.$size);
    1038. 

  1038.     readfile($tmpname);
    1039. 

  1039.     unlink($tmpname);
    1040. 

  1040.     exit(0);
    1041. 

  1041.   }
    1042. 

  1042.   /// Recupere le contenu pour une impression
    1043. 

  1043.   function &_printGetContent($ar,$filename,$f,$tpldata=array()){
    1044. 

  1044.     $p=new XParam($ar,NULL);
    1045. 

  1045.     $title=$p->get('title');
    1046. 

  1046.     $res=&$this->$f($ar);
    1047. 

  1047.     $xt=new XTemplate('file:'.$filename);
    1048. 

  1048.     $labels=&$GLOBALS['XSHELL']->labels->get_labels(array('selectors'=>array('global'),'local'=>true));
    1049. 

  1049.     $xt->set_glob(array('labels'=>&$labels));
    1050. 

  1050.     $r3=array();
    1051. 

  1051.     $tpldata['param']=array('title'=>$title);
    1052. 

  1052.     $tpldata['br']=$res;
    1053. 

  1053.     $tpldata['imod']=&XShell::from_screen('imod');
    1054. 

  1054.     $content=$xt->parse($tpldata,$r3,NULL);
    1055. 

  1055.     return $content;
    1056. 

  1056.   }
    1057. 

  1057. 

  1058.   /// Exporte une fiche
    1059. 

  1059.   public function exportDisplay($ar=NULL){
    1060. 

  1060.     $p= new XParam($ar,array());
    1061. 

  1061.     $fmt=$p->get('fmt');
    1062. 

  1062.     $ar['norow']=1;
    1063. 

  1063.     $ar['nodef']=1;
    1064. 

  1064.     $ar['ssmoid']='all';
    1065. 

  1065.     $ar['_options']=array('genpublishtag'=>false);
    1066. 

  1066.     if($fmt=='xl' || $fmt=='xl07') $ar['_format']='application/excel';
    1067. 

  1067.     $this->display($ar);
    1068. 

  1068.     if($fmt=='xl' || $fmt=='xl07')  $this->_exportXLSDisplay($ar);
    1069. 

  1069.     if($fmt=='html')  $this->printDisplay($ar);
    1070. 

  1070.     if($fmt=='csv')  $this->_exportCSVDisplay($ar);
    1071. 

  1071.   }
    1072. 

  1072. 

  1073.   /// Exporte une fiche au format excel
    1074. 

  1074.   public function _exportXLSDisplay($ar){
    1075. 

  1075.     require_once('add-ons/PHPExcel/PHPExcel.php');
    1076. 

  1076. 

  1077.     $p=new XParam($ar,NULL);
    1078. 

  1078.     $fmt=$p->get('fmt');
    1079. 

  1079.     $br=&XShell::from_screen('br');
    1080. 

  1080.     $ss=new PHPExcel();
    1081. 

  1081.     $ss->setActiveSheetIndex(0);
    1082. 

  1082.     $ws=$ss->getActiveSheet();
    1083. 

  1083.     $ws->setTitle('Main');
    1084. 

  1084.     $ws->SetCellValue('A1','OID');
    1085. 

  1085.     $ws->SetCellValue('B1',$br['oid']);
    1086. 

  1086.     $row=2;
    1087. 

  1087.     foreach($br['fields_object'] as $j => &$f) {
    1088. 

  1088.       if(!$f->sys){
    1089. 

  1089. 	$l=$f->fielddef->label;
    1090. 

  1090. 	$c=$f->field;
    1091. 

  1091. 	convert_charset($l,TZR_INTERNAL_CHARSET,'UTF-8');
    1092. 

  1092. 	$ws->setCellValueByColumnAndRow(0,$row,$l);
    1093. 

  1093. 	$f1=&$this->xset->getField($c);
    1094. 

  1094. 	$f1->writeXLS($ws,$row++,1,$br['o'.$c],0,$ss);
    1095. 

  1095.       }
    1096. 

  1096.     }
    1097. 

  1097.     $ws->getStyle('A1:A'.($row-1))->getFont()->setBold(true);
    1098. 

  1098. 

  1099.     foreach($br['__ssmod'] as $i=>&$ssr){
    1100. 

  1100.       $ssmod=XModule::objectFactory($br['__ssprops'][$i]['_moid']);
    1101. 

  1101.       $l=$br['__ssprops'][$i]['modulename'];
    1102. 

  1102.       convert_charset($l,TZR_INTERNAL_CHARSET,'UTF-8');
    1103. 

  1103.       $ss->createSheet($i+1);
    1104. 

  1104.       $ss->setActiveSheetIndex($i+1);
    1105. 

  1105.       $ws=$ss->getActiveSheet();
    1106. 

  1106.       $ws->setTitle($l);
    1107. 

  1107.       foreach($ssr['header_fields'] as $j => &$f) {
    1108. 

  1108. 	$l=$ssr['header_fields'][$j]->label;
    1109. 

  1109. 	convert_charset($l,TZR_INTERNAL_CHARSET,'UTF-8');
    1110. 

  1110. 	$ws->setCellValueByColumnAndRow($j,1,$l);
    1111. 

  1111.       }
    1112. 

  1112.       foreach($ssr['lines_oid'] as $j=>$oid){
    1113. 

  1113. 	foreach($ssr['header_fields'] as $k=>&$f) {
    1114. 

  1114. 	  $f->writeXLS($ws,$j+2,$k,$ssr['lines_o'.$f->field][$j],0,$ss);
    1115. 

  1115. 	}
    1116. 

  1116.       }
    1117. 

  1117.       $ws->getStyle('A1:'.PHPExcel_Cell::stringFromColumnIndex($k).'1')->getFont()->setBold(true);
    1118. 

  1118.     }
    1119. 

  1119.     $ss->setActiveSheetIndex(0);
    1120. 

  1120.     sendPHPExcelFile($ss,$fmt,'export');
    1121. 

  1121.   }
    1122. 

  1122.   /// Exporte une fiche et ses sous fiches au format csv (si sous fiches, un fichier csv par sous modules, le tout dans un zip)
    1123. 

  1123.   public function _exportCSVDisplay($ar=NULL){
    1124. 

  1124.     $p= new XParam($ar,array('fname'=>'Export'));
    1125. 

  1125.     $fsep=$p->get('csvfsep');
    1126. 

  1126.     $textsep=stripslashes($p->get('csvtextsep'));
    1127. 

  1127.     $charset=stripslashes($p->get('csvcharset'));
    1128. 

  1128.     $fname=$p->get('fname');
    1129. 

  1129.     $br=&XShell::from_screen('br');
    1130. 

  1130. 

  1131.     $csv=$headers=$row=array();
    1132. 

  1132.     foreach($br['fields_object'] as $j => &$f) {
    1133. 

  1133.       if(!$f->sys){
    1134. 

  1134. 	$f1=&$this->xset->getField($f->field);
    1135. 

  1135. 	$headers[]=$textsep.$f->fielddef->label.$textsep;
    1136. 

  1136. 	$row[]=$f1->writeCSV($br['o'.$f->field],$textsep);
    1137. 

  1137.       }
    1138. 

  1138.     }
    1139. 

  1139.     $csv[]=implode($fsep,$headers);
    1140. 

  1140.     $csv[]=implode($fsep,$row);
    1141. 

  1141.     $csv=implode("\r\n",$csv);
    1142. 

  1142.     convert_charset($csv,TZR_INTERNAL_CHARSET,$charset);
    1143. 

  1143.     if(empty($br['__ssmod'])){
    1144. 

  1144.       ob_clean();
    1145. 

  1145.       header('Content-Type: text/csv; charset='.$charset);
    1146. 

  1146.       header('Content-Transfer-Encoding:'.$charset);
    1147. 

  1147.       header('Content-disposition: attachment; filename='.str_replace(' ','_',removeaccents($fname)).'.csv');
    1148. 

  1148.       header('Content-Length: '.strlen($csv));
    1149. 

  1149.       echo $csv;
    1150. 

  1150.       exit(0);
    1151. 

  1151.     }else{
    1152. 

  1152.       $dir=TZR_TMP_DIR.'exportdisp'.uniqid();
    1153. 

  1153.       @mkdir($dir);
    1154. 

  1154.       file_put_contents($dir.'/Main.csv',$csv);
    1155. 

  1155.       foreach($br['__ssmod'] as $i=>&$ssr){
    1156. 

  1156. 	$csv=$headers=$row=array();
    1157. 

  1157. 	$ssmod=XModule::objectFactory($br['__ssprops'][$i]['_moid']);
    1158. 

  1158. 	$l=$br['__ssprops'][$i]['modulename'];
    1159. 

  1159. 	$fields=array();
    1160. 

  1160. 	foreach($ssr['header_fields'] as $j=>&$f) {
    1161. 

  1161. 	  $headers[]=$textsep.$f->label.$textsep;
    1162. 

  1162. 	}
    1163. 

  1163. 	$csv[]=implode($fsep,$headers);
    1164. 

  1164. 	foreach($ssr['lines_oid'] as $j=>$oid){
    1165. 

  1165. 	  $row=array();
    1166. 

  1166. 	  foreach($ssr['header_fields'] as $k=>&$f) {
    1167. 

  1167. 	    $row[]=$f->writeCSV($ssr['lines_o'.$f->field][$j],$textsep);
    1168. 

  1168. 	  }
    1169. 

  1169. 	  $csv[]=implode($fsep,$row);
    1170. 

  1170. 	}
    1171. 

  1171. 	$csv=implode("\r\n",$csv);
    1172. 

  1172. 	convert_charset($csv,TZR_INTERNAL_CHARSET,$charset);
    1173. 

  1173. 	file_put_contents($dir.'/'.removeaccents($l).'.csv',$csv);
    1174. 

  1174.       }
    1175. 

  1175.       exec('(cd '.$dir.'; zip -r '.$dir.'.zip .)2>&1 > '.TZR_TMP_DIR.'errorlog');
    1176. 

  1176.       $size=filesize($dir.'.zip');
    1177. 

  1177.       header('Content-type: application/zip');
    1178. 

  1178.       header('Content-disposition: attachment; filename='.str_replace(' ','_',removeaccents($fname)).'.zip');
    1179. 

  1179.       header('Accept-Ranges: bytes');
    1180. 

  1180.       header('Content-Length: '.$size);
    1181. 

  1181.       @readfile($dir.'.zip');
    1182. 

  1182.       XDir::unlink($dir);
    1183. 

  1183.       unlink($dir.'.zip');
    1184. 

  1184.       exit(0);
    1185. 

  1185.     }
    1186. 

  1186.   }
    1187. 

  1187. 

  1188.   /// Suppression de toutes les entrées correspondant à la recherche en cours
    1189. 

  1189.   function delAll($ar) {
    1190. 

  1190.     $p=new XParam($ar,NULL);
    1191. 

  1191.     $tplentry=$p->get('tplentry');
    1192. 

  1192.     if($this->isThereAQueryActive() && empty($clearrequest)) {
    1193. 

  1193.       $_storedquery=$this->_getSession('query');
    1194. 

  1194.       $ar=array_merge($_storedquery,$ar);
    1195. 

  1195.       $ar['fmoid']=$this->_moid;
    1196. 

  1196.       $ar['tplentry']=TZR_RETURN_DATA;
    1197. 

  1197.       $ar['selectedfields']=array('KOID');
    1198. 

  1198.       $ar['pagesize']=999999;
    1199. 

  1199.       $r1=$this->xset->procQuery($ar);
    1200. 

  1200.       if(count($r1['lines_oid'])){
    1201. 

  1201. 	$this->del(array('oid'=>$r1['lines_oid']));
    1202. 

  1202.       }
    1203. 

  1203.     }
    1204. 

  1204.   }
    1205. 

  1205. 

  1206.   /// Suppression d'un objet ou d'une ensemble d'objet
    1207. 

  1207.   function del($ar) {
    1208. 

  1208.     $p=new XParam($ar,array('onlyssm'=>false,'ssmnottodel'=>array()));
    1209. 

  1209.     $nolog=$p->get('_nolog','local');
    1210. 

  1210.     $onlyssm=$p->get('onlyssm');
    1211. 

  1211.     $noworkflow=$p->get('_noworkflow');
    1212. 

  1212.     $ssmnottodel=$p->get('ssmnottodel');
    1213. 

  1213.     $ar['table']=$this->table;
    1214. 

  1214.     $ar['action']='OK';
    1215. 

  1215. 

  1216.     // traitement du contexte sous module
    1217. 

  1217.     $subMods = $this->getSubModules();
    1218. 

  1218.     $p=new XParam($ar,array());
    1219. 

  1219.     // faire une requete de delete pour chacun des sous modules sur chaque oid
    1220. 

  1220.     $oids=Kernel::getSelectedOids($p);
    1221. 

  1221.     foreach($oids as $parentoid){
    1222. 

  1222.       /// application du workflow
    1223. 

  1223.       if(empty($noworkflow) && XModule::getMoid(XMODWORKFLOW_TOID)) {
    1224. 

  1224. 	$umod=XModule::singletonFactory(XMODWORKFLOW_TOID);
    1225. 

  1225. 	$umod->checkAndRun($this, $this, $parentoid, 'delete');
    1226. 

  1226.       }
    1227. 

  1227.       foreach($subMods as $i=>$subMod) {
    1228. 

  1228. 	// si sous module dépendant, on supprime toutes les sous-fiches en relation avec cette fiche
    1229. 

  1229. 	// si sous module avec lien obl et multiple (donc pas considéré comme dependant), on edite ou supprime toutes les sous-fiches
    1230. 

  1230. 	if(in_array($subMod['moid'],$ssmnottodel)) continue;
    1231. 

  1231. 	if(!empty($subMod['mod']->dependant_module) || $this->{'ssmoddependent'.$i}) {
    1232. 

  1232. 	  $sel=$subMod['xset']->select_query(array('cond'=>array($subMod['linkfield']=>array('=',$parentoid))));
    1233. 

  1233. 	  $ssRecords=$subMod['xset']->browse(array('select'=>$sel, 'tplentry'=>TZR_RETURN_DATA,
    1234. 

  1234. 						   'selected'=>'0','selectedfields'=>$subMod['linkfield']));
    1235. 

  1235. 	  if(!empty($ssRecords)) {
    1236. 

  1236. 	    foreach($ssRecords['lines_oid'] as $i=>$ssoid){
    1237. 

  1237. 	      $subMod['mod']->del(array('tplentry'=>TZR_RETURN_DATA, 'oid'=>$ssoid,'_selectedok'=>'','_selected'=>''));
    1238. 

  1238. 	    }
    1239. 

  1239. 	  }
    1240. 

  1240. 	}else{
    1241. 

  1241. 	  $sel=$subMod['xset']->select_query(array('cond'=>array($subMod['linkfield']=>array('LIKE','%'.$parentoid.'%'))));
    1242. 

  1242. 	  $ssRecords=$subMod['xset']->browse(array('select'=>$sel,'tplentry'=>TZR_RETURN_DATA,
    1243. 

  1243. 						   'selected'=>'0','selectedfields'=>$subMod['linkfield']));
    1244. 

  1244. 	  if(!empty($ssRecords)) {
    1245. 

  1245. 	    foreach($ssRecords['lines_oid'] as $i=>$ssoid){
    1246. 

  1246. 	      $links=$ssRecords['lines_o'.$subMod['linkfield']][$i]->raw;
    1247. 

  1247. 	      if($subMod['xset']->desc[$subMod['linkfield']]->compulsory && preg_match("/^\|*".$parentoid."\|*$/",$links)){
    1248. 

  1248. 		$subMod['mod']->del(array('tplentry'=>TZR_RETURN_DATA, 'oid'=>$ssoid,'_selectedok'=>'','_selected'=>'','_nolog'=>$nolog));
    1249. 

  1249. 	      }else{
    1250. 

  1250. 		$subMod['mod']->procEdit(array('tplentry'=>TZR_RETURN_DATA,'oid'=>$ssoid,'_nolog'=>$nolog,
    1251. 

  1251. 					       $subMod['linkfield']=>str_replace($parentoid,'',$links)));
    1252. 

  1252. 	      }
    1253. 

  1253. 	    }
    1254. 

  1254. 	  }
    1255. 

  1255. 	}
    1256. 

  1256.       }
    1257. 

  1257.     }
    1258. 

  1258.     if (!$onlyssm) 
    1259. 

  1259.       $this->xset->del($ar);
    1260. 

  1260.     return true;
    1261. 

  1261.   }
    1262. 

  1262. 

  1263.   /// Positinne si necessaire l'oid dans le tri pour dedoublonner
    1264. 

  1264.   function checkOrderFields(&$order){
    1265. 

  1265.     $t=$this->xset->getTable();
    1266. 

  1266.     if(empty($order)) $order=$this->order;
    1267. 

  1267.     $decorder=explode(',',$order);
    1268. 

  1268.     $allDesc = true;
    1269. 

  1269.     $koidFound = false;
    1270. 

  1270.     foreach ($decorder as $_order) {
    1271. 

  1271.       $allDesc &= (bool)strripos($_order, ' DESC'); // permet d'utiliser les index
    1272. 

  1272.       $koidFound |= (stripos($_order, 'KOID') !== false);
    1273. 

  1273.     }
    1274. 

  1274.     if (!$koidFound)
    1275. 

  1275.       $decorder[] = $t.'.KOID' . ($allDesc?' DESC':'');
    1276. 

  1276.     $order=implode(',',$decorder);
    1277. 

  1277.   }
    1278. 

  1278. 

  1279.   /// Contruction des actions de navigation
    1280. 

  1280.   function setNavActions($myoid,$navfunction,$navtemplate){
    1281. 

  1281.     $moid=$this->_moid;
    1282. 

  1282.     $o1=new XModuleAction($this,'navprev',XLabels::getSysLabel('general','previous','text'),
    1283. 

  1283. 			  '&moid='.$moid.'&_function='.$navfunction.'&template='.$navtemplate.'&tplentry=br&oid='.$myoid.'&navdir=prev',
    1284. 

  1284. 			  'display');
    1285. 

  1285.     $o1->setToolBar('general', 'previous');
    1286. 

  1286.     $this->navActions['prev']=$o1;
    1287. 

  1287. 

  1288.     $o1=new XModuleAction($this,'navnext',XLabels::getSysLabel('general','next','text'),
    1289. 

  1289. 			  '&moid='.$moid.'&_function='.$navfunction.'&template='.$navtemplate.'&tplentry=br&oid='.$myoid.'&navdir=next',
    1290. 

  1290. 			  'display');
    1291. 

  1291.     $o1->setToolBar('general', 'next');
    1292. 

  1292.     $this->navActions['next']=$o1;
    1293. 

  1293.   }
    1294. 

  1294. 

  1295.   /// Recherche des infos sur la position d'un oid dans un browse. Retourn : array(oid precedent,oid suivant, oid actuel, prec le premier, suiv le dernier)
    1296. 

  1296.   function mkNavParms($ar){
    1297. 

  1297.     $p=new XParam($ar, array());
    1298. 

  1298.     $oid=$p->get('oid');
    1299. 

  1299.     // Lecture de l'ordre en cour
    1300. 

  1300.     if($this->_issetSession('lastorder')) $order=$this->_getSession('lastorder');
    1301. 

  1301.     if(empty($order)) $order=$this->order;
    1302. 

  1302. 

  1303.     $ar['order']=$order;
    1304. 

  1304.     $ar['table']=$this->table;
    1305. 

  1305.     $ar['_filter']=$this->getFilter(true,$ar);
    1306. 

  1306.     // Cas ou on a une requete
    1307. 

  1307.     if($this->isThereAQueryActive()){
    1308. 

  1308.       $_storedquery=$this->_getSession('query');
    1309. 

  1309.       $ar2=array();
    1310. 

  1310.       $ar2=array_merge($ar, $_storedquery);
    1311. 

  1311.       $ar2['getselectonly']=true;
    1312. 

  1312.       $q=$this->xset->procQuery($ar2);
    1313. 

  1313.       $ar['select']=str_replace('*','KOID',$q);
    1314. 

  1314.     }
    1315. 

  1315.     $this->checkOrderFields($order);
    1316. 

  1316.     $oids=$this->xset->browseOids($ar);
    1317. 

  1317.     // Appliquer les droits si necessaire
    1318. 

  1318.     if($this->object_sec) {
    1319. 

  1319.       $lang_data=XShell::getLangData();
    1320. 

  1320.       $oidsrights=$GLOBALS['XUSER']->getObjectsAccess($this,$lang_data,$oids);
    1321. 

  1321.       foreach($oidsrights as $i=>&$rights) {
    1322. 

  1322.         if(!array_key_exists('ro',$rights)) unset($oids[$i]);
    1323. 

  1323.       }
    1324. 

  1324.     }
    1325. 

  1325.     if($oid) $myi=array_search($oid,$oids);
    1326. 

  1326.     else $myi=0;
    1327. 

  1327.     $mylst=count($oids)-1;
    1328. 

  1328.     if($myi==0) $navprev=$oids[$mylst];
    1329. 

  1329.     else $navprev=$oids[$myi-1];
    1330. 

  1330.     if($myi==$mylst) $navnext=$oids[0];
    1331. 

  1331.     else $navnext = $oids[$myi+1];
    1332. 

  1332.     $navact=$oids[$myi];
    1333. 

  1333.     return array($navprev,$navnext,$navact,$myi-1==0,$myi+1==$mylst);
    1334. 

  1334.   }
    1335. 

  1335. 

  1336.   /// Prépare l'ensemble des éléments d'affichage des fiches
    1337. 

  1337.   public function &browse($ar) {
    1338. 

  1338.     $p=new XParam($ar,array());
    1339. 

  1339.     $order=$p->get('order');
    1340. 

  1340.     $select=$p->get('select');
    1341. 

  1341.     $tplentry=$p->get('tplentry');
    1342. 

  1342.     $editfields=$p->get('editfields');
    1343. 

  1343.     $persistent=$p->get('_persistent');
    1344. 

  1344.     $assubmodule=$p->get('assubmodule');
    1345. 

  1345.     $this->checkOrderFields($order);
    1346. 

  1346. 

  1347.     if($this->persistentquery && $persistent) clearSessionVar('filterquery'.$this->_moid);
    1348. 

  1348.     // pour gestion de la navigation de page/page en display et edit
    1349. 

  1349.     if($this->interactive){
    1350. 

  1350.       $this->_setSession('lastorder',$order);
    1351. 

  1351.       if($this->isThereAQueryActive()) $this->_clearSession('query');
    1352. 

  1352.     }
    1353. 

  1353. 

  1354.     $ar['order']=$order;
    1355. 

  1355.     $ar['table']=$this->table;
    1356. 

  1356.     $pagesize=$p->get('pagesize');
    1357. 

  1357.     if(empty($pagesize)) $pagesize=$this->pagesize;
    1358. 

  1358.     if(empty($pagesize)) $pagesize=TZR_XMODTABLE_BROWSE_MAXPAGESIZE;
    1359. 

  1359.     $ar['pagesize']=$pagesize;
    1360. 

  1360. 

  1361.     if(!empty($this->_templates) && !empty($this->btemplates)) {
    1362. 

  1362.       $r=&$this->_templates->display(array('oid'=>$this->btemplates,'_options'=>array('error'=>'return'),'tplentry'=>TZR_RETURN_DATA));
    1363. 

  1363.       XShell::toScreen1($tplentry.'t',$r);
    1364. 

  1364.     }
    1365. 

  1365. 

  1366.     // recherche des donnees
    1367. 

  1367.     $ar['_filter']=$this->getFilter(true,$ar);
    1368. 

  1368. 

  1369.     if($this->object_sec) {
    1370. 

  1370.       $oids=$this->xset->browseOids($ar);
    1371. 

  1371.       // calcul des droits sur les objets retournés
    1372. 

  1372.       $lang_data = XShell::getLangData();
    1373. 

  1373.       $oidsrights=$GLOBALS['XUSER']->getObjectsAccess($this, $lang_data, $oids);
    1374. 

  1374.       $oidsrigths2=$noeditoids=array();
    1375. 

  1375.       foreach($oidsrights as $i => $rights) {
    1376. 

  1376. 	if(!array_key_exists('ro',$rights)) unset($oids[$i]);
    1377. 

  1377. 	else{
    1378. 

  1378. 	  $oidsrights2[$oids[$i]]=$rights;
    1379. 

  1379. 	  if(!empty($editfields) && !array_key_exists('rw',$rights)) $noeditoids[]=$oids[$i];
    1380. 

  1380. 	}
    1381. 

  1381.       }
    1382. 

  1382.       if(!empty($oids)){
    1383. 

  1383. 	if(preg_match('/order[ ]+by/i',$select)) $order='field(KOID,"'.implode('","',$oids).'")';
    1384. 

  1384. 	else $order=$ar['order'];
    1385. 

  1385. 	$ar['select']=$this->xset->select_query(array('order'=>$order, 'cond'=>array('KOID'=>array('=',$oids))));
    1386. 

  1386. 	$ar['noeditoids']=$noeditoids;
    1387. 

  1387.       }
    1388. 

  1388.     }
    1389. 

  1389. 

  1390.     $ar['tplentry']=TZR_RETURN_DATA;
    1391. 

  1391.     if(empty($ar['fmoid'])) $ar['fmoid']=$this->_moid;
    1392. 

  1392.     $ar['fieldssec']=$this->getFieldsSec($ar);
    1393. 

  1393.     $r=&$this->xset->browse($ar);
    1394. 

  1394.     $r['function']='browse';
    1395. 

  1395.     $r['_fieldssec']=$ar['fieldssec'];
    1396. 

  1396. 

  1397.     if($this->object_sec){
    1398. 

  1398.       $r['objects_sec']=array();
    1399. 

  1399.       foreach($r['lines_oid'] as $i=>$oid){
    1400. 

  1400. 	$r['objects_sec'][$i]=$oidsrights2[$oid];
    1401. 

  1401.       }
    1402. 

  1402.     }else{
    1403. 

  1403.       $lang_data = XShell::getLangData();
    1404. 

  1404.       $r['objects_sec']=$GLOBALS['XUSER']->getObjectsAccess($this, $lang_data, $r['lines_oid']);
    1405. 

  1405.     }
    1406. 

  1406.     if(XShell::admini_mode()) {
    1407. 

  1407.       // passage du contexte sous module
    1408. 

  1408.       $submodcontext = $this->subModuleContext($ar);
    1409. 

  1409.       $r['urlparms'] = @$submodcontext['urlparms'];
    1410. 

  1410.       if (!$p->get('without_actions')) $this->browse_actions($r, false, $ar);
    1411. 

  1411.       if ($this->quickquery && !$assubmodule) {
    1412. 

  1412.         $ar['tplentry']=TZR_RETURN_DATA;
    1413. 

  1413.         $r['_qq']=$this->quickquery($ar);
    1414. 

  1414.       }
    1415. 

  1415.     }
    1416. 

  1416.     $this->browseSumFields($ar, $r, true);
    1417. 

  1417.     return XShell::toScreen1($tplentry,$r);
    1418. 

  1418.   }
    1419. 

  1419. 

  1420.   /// Parcours le module pour la selection d'un fichier
    1421. 

  1421.   public function &browseFiles($ar) {
    1422. 

  1422.     $fields = array();
    1423. 

  1423.     //cinq champ publié max et les champ fichier
    1424. 

  1424.     foreach($this->xset->desc as $fname=>$fdef){
    1425. 

  1425.       if( (count($fields) < 5 && $fdef->get_published()) || ($fdef->get_ftype() == 'XFileDef' || $fdef->get_ftype() == 'XImageDef')){
    1426. 

  1426. 	$fields[]=$fname;
    1427. 

  1427.       }	
    1428. 

  1428.     }
    1429. 

  1429.     $ar['selectedfields']=$fields;
    1430. 

  1430.     return $this->browse($ar);
    1431. 

  1431.   }
    1432. 

  1432.   
    1433. 

  1433.   /// Preparartion des donnees pour ecran de parametrage d'impression
    1434. 

  1434.   public function prePrintDisplay($ar) {
    1435. 

  1435.     $p = new XParam($ar,array());
    1436. 

  1436.     $order=$p->get('order');
    1437. 

  1437.     $tplentry=$p->get('tplentry');
    1438. 

  1438.     if(empty($order)) $order=$this->order;
    1439. 

  1439.     $ar['order']=$order;
    1440. 

  1440.     $ar['table']=$this->table;
    1441. 

  1441. 

  1442.     // recherche des templates d'impression
    1443. 

  1443.     if(empty($this->_templates)) $this->_templates=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS=TEMPLATES');
    1444. 

  1444.     if(!empty($this->_templates)) {
    1445. 

  1445.       $q1=$this->_templates->select_query(array('cond'=>array('modid'=>array('=',$this->_moid),
    1446. 

  1446. 							      'gtype'=>array('=','xmodtable_display_print'))));
    1447. 

  1447.       $r=&$this->_templates->browse(array('select'=>$q1,'pagesize'=>100,'tplentry'=>TZR_RETURN_DATA));
    1448. 

  1448.       XShell::toScreen1($tplentry.'t',$r);
    1449. 

  1449.     }
    1450. 

  1450.     $ar['ssmoid']='all';
    1451. 

  1451.     for($i=1;$i<=$this->submodmax;$i++) {
    1452. 

  1452.       $f='ssmod'.$i;
    1453. 

  1453.       $ar['options'][$this->$f]['selectedfields']='all';
    1454. 

  1454.     }
    1455. 

  1455.     return $this->display($ar);
    1456. 

  1456.   }
    1457. 

  1457. 

  1458.   function preExportBrowse($ar=NULL){
    1459. 

  1459.     $this->prePrintBrowse($ar);
    1460. 

  1460.   }
    1461. 

  1461. 

  1462.   function preExportDisplay($ar=NULL){
    1463. 

  1463.     $this->prePrintDisplay($ar);
    1464. 

  1464.   }
    1465. 

  1465. 

  1466.   function browse_actions(&$r, $assubmodule=false, $ar=null) {
    1467. 

  1467.     $p = new XParam($ar);
    1468. 

  1468.     $noeditoids = $p->get('noeditoids');
    1469. 

  1469.     if(!is_array($noeditoids)) $noeditoids=array();
    1470. 

  1470.     $self=$GLOBALS['TZR_SESSION_MANAGER']::complete_self().'&moid='.$this->_moid.'&oid=<oid>&tplentry=br&function=';
    1471. 

  1471.     if(!is_array($r['lines_oid'])) return;
    1472. 

  1472.     $approved=XLabels::getSysLabel('general','approved');
    1473. 

  1473.     $not_approved=XLabels::getSysLabel('general','not_approved');
    1474. 

  1474.     $viewico = XLabels::getSysLabel('general','view');
    1475. 

  1475.     $viewtxt = XLabels::getSysLabel('general','view','text');
    1476. 

  1476.     $editico = XLabels::getSysLabel('general','edit');
    1477. 

  1477.     $edittxt = XLabels::getSysLabel('general','edit','text');
    1478. 

  1478.     $delico = XLabels::getSysLabel('general','delete');
    1479. 

  1479.     $deltxt = XLabels::getSysLabel('general','delete','text');
    1480. 

  1480.     $secico = XLabels::getSysLabel('general','security');
    1481. 

  1481.     $sectxt = XLabels::getSysLabel('general','security','text');
    1482. 

  1482.     $editlvl=$this->secGroups('edit');
    1483. 

  1483.     $dellvl=$this->secGroups('del');
    1484. 

  1484.     $hassubmodules=$this->hasSubModules();
    1485. 

  1485.     foreach($r['lines_oid'] as $i =>$oid) {
    1486. 

  1486.       $oidlvl=array_keys($r['objects_sec'][$i]);
    1487. 

  1487.       $self1=str_replace('<oid>',$oid,$self);
    1488. 

  1488.       $url=$self1.'display&template=xmodtable/view.html'.$r['urlparms'];
    1489. 

  1489.       $r['actions'][$i][0]='<a class="cv8-ajaxlink cv8-dispaction" href="'.$url.'" title="'.$viewtxt.'">'.$viewico.'</a>';
    1490. 

  1490.       $r['actions_url'][$i][0]=$url;
    1491. 

  1491.       $r['actions_label'][$i][0]=$viewico;
    1492. 

  1492.       // edition
    1493. 

  1493.       $inter=array_intersect($editlvl,$oidlvl);
    1494. 

  1494.       if(!empty($inter) && !in_array($oid, $noeditoids)){
    1495. 

  1495. 	$url=$self1.'edit&template=xmodtable/edit.html'.$r['urlparms'];
    1496. 

  1496. 	$r['actions'][$i][1]='<a class="cv8-ajaxlink cv8-editaction" href="'.$url.'" title="'.$edittxt.'">'.$editico.'</a>';
    1497. 

  1497. 	$r['actions_url'][$i][1]=$url;
    1498. 

  1498. 	$r['actions_label'][$i][1]=$editico;
    1499. 

  1499.       }
    1500. 

  1500.       // suppression
    1501. 

  1501.       $inter=array_intersect($dellvl,$oidlvl);
    1502. 

  1502.       if(!empty($inter) && !in_array($oid, $noeditoids)){
    1503. 

  1503. 	$url=$self1.'del&template=basic/message.html&skip=1';
    1504. 

  1504. 	$r['actions'][$i][2]='<a class="cv8-delaction" href="'.$url.'" title="'.$deltxt.'">'.$delico.'</a>';
    1505. 

  1505. 	$r['actions_url'][$i][2]=$url;
    1506. 

  1506. 	$r['actions_label'][$i][2]=$deltxt;
    1507. 

  1507.       }
    1508. 

  1508.       // securité
    1509. 

  1509.       if($this->object_sec && !empty($r['objects_sec'][$i]['admin'])) {
    1510. 

  1510. 	$url='TZR.editSec(\''.$GLOBALS['TZR_SESSION_MANAGER']::complete_self(true).'\',\''.$this->_moid.'\',\''.$oid.'\')';
    1511. 

  1511. 	$r['actions'][$i][9]='<a href="#" onclick="'.$url.'; return false;" title="'.$sectxt.'">'.
    1512. 

  1512. 	  $secico.'</a>';
    1513. 

  1513. 	$r['actions_url'][$i][9]=$self1.'secEditSimple&template=xmodule/edit-sec.html';
    1514. 

  1514. 	$r['actions_label'][$i][9]=$sectxt;
    1515. 

  1515.       }
    1516. 

  1516.     }
    1517. 

  1517.   }
    1518. 

  1518. 

  1519.   /// Edition d'une fiche
    1520. 

  1520.   function edit($ar) {
    1521. 

  1521.     $p=new XParam($ar,array());
    1522. 

  1522.     $tplentry=$p->get('tplentry');
    1523. 

  1523.     $navdir=$p->get('navdir');
    1524. 

  1524.     $ar['table']=$this->table;
    1525. 

  1525.     $ar['tplentry']=TZR_RETURN_DATA;
    1526. 

  1526.     if(empty($ar['fmoid'])) $ar['fmoid']=$this->_moid;
    1527. 

  1527.     $ar['fieldssec']=$this->getFieldsSec($ar);
    1528. 

  1528.     if($this->interactive){
    1529. 

  1529.       if($this->trackaccess) $ar['accesslog']=1;
    1530. 

  1530.       // Gestion de la nav page/page
    1531. 

  1531.       if(!empty($navdir)){
    1532. 

  1532. 	list($navprev,$navnext,$foo,$isfirst,$islast)=$this->mkNavParms($ar);
    1533. 

  1533. 	if($navdir=='next') $_REQUEST['oid']=$navnext;
    1534. 

  1534. 	else $_REQUEST['oid']=$navprev;
    1535. 

  1535.       }
    1536. 

  1536.     }
    1537. 

  1537.     $r2=$this->xset->edit($ar);
    1538. 

  1538.     if(!empty($navdir)){
    1539. 

  1539.       $r2['_isfirst']=$isfirst;
    1540. 

  1540.       $r2['_islast']=$islast;
    1541. 

  1541.     }
    1542. 

  1542.     // Choix du templates d'affichage s'il existe
    1543. 

  1543.     if(!empty($this->_templates) && !empty($this->templates)) {
    1544. 

  1544.       $this->_templates->display(array('oid'=>$this->templates,'_options'=>array('error'=>'return'),'tplentry'=>$tplentry.'t'));
    1545. 

  1545.     }
    1546. 

  1546.     $this->setSubModules($ar, $r2);
    1547. 

  1547.     if(XShell::admini_mode()) {
    1548. 

  1548.       // calcul des droits
    1549. 

  1549.       if ($this->object_sec) {
    1550. 

  1550.         $acl=$GLOBALS['XUSER']->listObjectAccess($this, XShell::getLangData(), $p->get('oid'));
    1551. 

  1551.         $r3=array_merge($r2, $acl);
    1552. 

  1552.         $sec=$GLOBALS['XUSER']->getObjectAccess($this, XShell::getLangData(), $r2['oid']);
    1553. 

  1553.         $sec=array_flip($sec[0]);
    1554. 

  1554.         $r2['object_sec']=$sec;
    1555. 

  1555.       }
    1556. 

  1556.       // passage du context sous module
    1557. 

  1557.       $submodcontext = $this->subModuleContext($ar);
    1558. 

  1558.       $r2['urlparms'] = @$submodcontext['urlparms'];
    1559. 

  1559.     }
    1560. 

  1560.     if($this->captcha && (!XShell::admini_mode() || XUser::isNobody())) $r2['captcha']=$this->createCaptcha($ar);
    1561. 

  1561.     if($tplentry!=TZR_RETURN_DATA) XShell::toScreen1('iacl',$r3);
    1562. 

  1562.     return XShell::toScreen1($tplentry,$r2);
    1563. 

  1563.   }
    1564. 

  1564. 

  1565.   /// Prepare l'edition par lot
    1566. 

  1566.   function &editSelection($ar=NULL){
    1567. 

  1567.     $p=new XParam($ar,NULL);
    1568. 

  1568.     $tplentry=$p->get('tplentry');
    1569. 

  1569.     $oids=Kernel::getSelectedOids($p);
    1570. 

  1570.     $ar['editbatch']=true;
    1571. 

  1571.     $ar['fmoid']=$this->_moid;
    1572. 

  1572.     $result=$this->xset->input($ar);
    1573. 

  1573.     $result['oids']=$oids;
    1574. 

  1574.     return XShell::toScreen1($tplentry,$result);
    1575. 

  1575.   }
    1576. 

  1576. 

  1577.   /// Prepare l'edition par lot de tout le resultat de la recherche active
    1578. 

  1578.   function &editAll($ar=NULL){
    1579. 

  1579.     $p=new XParam($ar,NULL);
    1580. 

  1580.     $tplentry=$p->get('tplentry');
    1581. 

  1581.     if($this->isThereAQueryActive() && empty($clearrequest)) {
    1582. 

  1582.       $_storedquery=$this->_getSession('query');
    1583. 

  1583.       $ar=array_merge($_storedquery,$ar);
    1584. 

  1584.       $ar['editbatch']=true;
    1585. 

  1585.       $ar['fmoid']=$this->_moid;
    1586. 

  1586.       $ar['tplentry']=TZR_RETURN_DATA;
    1587. 

  1587.       $ar['selectedfields']=array('KOID');
    1588. 

  1588.       $ar['pagesize']=10000;
    1589. 

  1589.       $r1=$this->xset->procQuery($ar);
    1590. 

  1590.       $result=$this->editSelection(array('oid'=>$r1['lines_oid']));
    1591. 

  1591.     }
    1592. 

  1592.     return XShell::toScreen1($tplentry,$result);
    1593. 

  1593.   }
    1594. 

  1594. 

  1595.   /// Fonction de controle du formulaire
    1596. 

  1596.   function procEditCtrl($ar) {
    1597. 

  1597.     $p = new XParam($ar,array());
    1598. 

  1598.     $captcha_ok = $p->get('captcha_ok','local');
    1599. 

  1599.     if($this->captcha && (!XShell::admini_mode() || XUser::isNobody()) && !$captcha_ok){
    1600. 

  1600.       $captcha_key = md5($p->get('captcha_key'));
    1601. 

  1601.       $captcha_id = $p->get('captcha_id');
    1602. 

  1602.       $cnt=countSelectQuery('SELECT COUNT(*) FROM _VARS WHERE name = "CAPTCHA_'.$captcha_id.'" AND value = "'.$captcha_key.'" ');
    1603. 

  1603.       updateQuery('DELETE FROM _VARS WHERE name="CAPTCHA_'.$captcha_id.'" or (UPD<"'.date('YmdHis',strtotime('- 20 minutes')).'" AND '.
    1604. 

  1604. 		  'name LIKE "CAPTCHA_%")');
    1605. 

  1605.       if($cnt) {
    1606. 

  1606.         return true;
    1607. 

  1607.       }else{
    1608. 

  1608.         $onerror=$p->get('onerror');
    1609. 

  1609.         if(!empty($onerror)) {
    1610. 

  1610. 	  if(!preg_match('@(^http://|^/)@',$onerror)) $onerror=$GLOBALS['TZR_SESSION_MANAGER']::complete_self().$onerror;
    1611. 

  1611.           header('Location: '.$onerror);
    1612. 

  1612.           die();
    1613. 

  1613.         }
    1614. 

  1614.         return false;
    1615. 

  1615.       }
    1616. 

  1616.     }
    1617. 

  1617.     return true;
    1618. 

  1618.   }
    1619. 

  1619. 

  1620.   /// Fonction de controle du formulaire avant insertion
    1621. 

  1621.   function procInsertCtrl($ar) {
    1622. 

  1622.     return $this->procEditCtrl($ar);
    1623. 

  1623.   }
    1624. 

  1624.   /// Fonction de controle du formulaire avant duplication
    1625. 

  1625.   function procEditDupCtrl($ar) {
    1626. 

  1626.     return $this->procEditCtrl($ar);
    1627. 

  1627.   }
    1628. 

  1628.   /****m* XModTable/procEdit
    1629. 

  1629.    * NAME
    1630. 

  1630.    *   XModTable::procEdit - traitement d'une formulaire préparé avec la méthode edit.
    1631. 

  1631.    * DESCRIPTION
    1632. 

  1632.    *   Traitement d'une formulaire préparé avec la méthode edit. Les données sont modifiées
    1633. 

  1633.    *   en base de donnée
    1634. 

  1634.    * INPUTS
    1635. 

  1635.    *   Passage de paramètre indirect via $ar
    1636. 

  1636.    ****/
    1637. 

  1637.   function procEdit($ar) {
    1638. 

  1638.     $p=new XParam($ar,array('applyrules'=>true));
    1639. 

  1639.     $ar['table']=$this->table;
    1640. 

  1640.     $ar['_track']=$this->trackchanges;
    1641. 

  1641.     $ar['_archive']=$this->archive;
    1642. 

  1642.     $ar['fieldssec']=$this->getFieldsSec($ar);
    1643. 

  1643.     $oid = $p->get('oid');
    1644. 

  1644.     $tplentry = $p->get('tplentry');
    1645. 

  1645.     $applyrules=$p->get('applyrules');
    1646. 

  1646.     $noworkflow=$p->get('_noworkflow');
    1647. 

  1647.     $langs=$p->get('_langs');
    1648. 

  1648.     if (isset($this->xset->desc['PUBLISH']) && !$this->secure('', ':rwv'))
    1649. 

  1649.       unset($_REQUEST['PUBLISH'], $_REQUEST['PUBLISH_HID']);
    1650. 

  1650.     if(is_array($oid)) {
    1651. 

  1651.       $P1=array();
    1652. 

  1652.       $reeditone=$p->get('reeditone');
    1653. 

  1653.       $editfields = $p->get('editfields');
    1654. 

  1654.       $editbatch=$p->get('editbatch');
    1655. 

  1655.       foreach($this->xset->desc as $f => $o) {
    1656. 

  1656. 	if(($editfields=='all') || in_array($f,$editfields)){
    1657. 

  1657. 	  $P1[$f]=$p->get($f);
    1658. 

  1658. 	  $P1[$f.'_HID']=$p->get($f.'_HID');
    1659. 

  1659. 	}
    1660. 

  1660.       }
    1661. 

  1661.       foreach($oid as $i=>$oid1) {
    1662. 

  1662. 	$ar1=array();
    1663. 

  1663. 	if(!$editbatch){
    1664. 

  1664. 	  foreach($this->xset->desc as $f => $o) {
    1665. 

  1665. 	    if(($editfields=='all') || in_array($f,$editfields)){
    1666. 

  1666. 	      if(isset($P1[$f][$i]) || isset($P1[$f.'_HID'][$i])) {
    1667. 

  1667. 		$ar1[$f]=$P1[$f][$i];
    1668. 

  1668. 		$ar1[$f.'_HID']=$P1[$f.'_HID'][$i];
    1669. 

  1669. 	      }
    1670. 

  1670. 	    }
    1671. 

  1671. 	  }
    1672. 

  1672. 	}else{
    1673. 

  1673. 	  $ar1=$P1;
    1674. 

  1674. 	}
    1675. 

  1675. 	$ar1['_options'] = array('local'=>true);
    1676. 

  1676. 	$ar1['oid']=$oid1;
    1677. 

  1677. 	$ar1['editfields']=$editfields;
    1678. 

  1678. 	$ar1['editbatch']=$editbatch;
    1679. 

  1679. 	$ar1['applyrules']=$applyrules;
    1680. 

  1680. 	$this->procEdit($ar1);
    1681. 

  1681.       }
    1682. 

  1682.       if($reeditone){
    1683. 

  1683. 	$_storedquery=$this->xset->captureQuery(array('_options'=>array('local'=>true),'oids'=>$oid,'order'=>'KOID'));
    1684. 

  1684. 	$this->_setSession('query',$_storedquery);
    1685. 

  1685. 	$this->_setSession('lastorder','KOID');
    1686. 

  1686. 	list($p,$n,$a)=$this->mkNavParms(array('_options'=>array('local'=>true)));
    1687. 

  1687. 	XShell::setNext('moid='.$this->_moid.'&function=edit&template=xmodtable/edit.html&tplentry=br&oid='.$a.'&usenav=1');
    1688. 

  1688.       }
    1689. 

  1689.       return;
    1690. 

  1690.     }
    1691. 

  1691.     if($this->procEditCtrl($ar)) {
    1692. 

  1692.       // Traitement des cas ou l'on veut sauver dans plusieurs langues
    1693. 

  1693.       $ar['_langs']=$this->getAuthorizedLangs($langs,$oid,'procEdit');
    1694. 

  1694.       if(empty($ar['fmoid'])) $ar['fmoid']=$this->_moid;
    1695. 

  1695.       $r=$this->xset->procEdit($ar);
    1696. 

  1696.       if($applyrules) {
    1697. 

  1697. 	XModRule::applyRules($this,$oid);
    1698. 

  1698.       }
    1699. 

  1699.       /// application du workflow
    1700. 

  1700.       if(empty($noworkflow) && XModule::getMoid(XMODWORKFLOW_TOID)) {
    1701. 

  1701. 	$umod=XModule::singletonFactory(XMODWORKFLOW_TOID);
    1702. 

  1702. 	$umod->checkAndRun($this, $this, $oid, 'edit');
    1703. 

  1703.       }
    1704. 

  1704.       if($this->savenext && in_array($this->savenext,array('display','edit')) && $tplentry!=TZR_RETURN_DATA){
    1705. 

  1705. 	$editfields=$p->get('editfields');
    1706. 

  1706. 	if(empty($editfields) || count($editfields)==0){
    1707. 

  1707. 	  $submodcontext=$this->subModuleContext($ar);
    1708. 

  1708. 	  XShell::setnext($GLOBALS['TZR_SESSION_MANAGER']::complete_self(true, true).'&moid='.$this->_moid.
    1709. 

  1709. 			  '&function='.$this->savenext.'&template=xmodtable/'.($this->savenext == 'display' ? 'view' : 'edit').'.html&tplentry=br&oid='.
    1710. 

  1710. 			  $oid.@$submodcontext['urlparms']);
    1711. 

  1711. 	}
    1712. 

  1712.       }
    1713. 

  1713.     } else {
    1714. 

  1714.       if (XShell::admini_mode()) {
    1715. 

  1715.         unset($_REQUEST['skip'], $_REQUEST['_skip']);
    1716. 

  1716.         XShell::changeTemplate('xmodtable/edit.html');
    1717. 

  1717.         XShell::setNext();
    1718. 

  1718.       }
    1719. 

  1719.       $ar['options']=$this->xset->prepareReEdit($ar);
    1720. 

  1720.       $ar['tplentry']= 'br';
    1721. 

  1721.       return $this->edit($ar);
    1722. 

  1722.     }
    1723. 

  1723.     return $r;
    1724. 

  1724.   }
    1725. 

  1725. 

  1726.   /// Mise à jour de toutes les langues pour lesquel l'utilisateur à les droits
    1727. 

  1727.   function procEditAllLang($ar) {
    1728. 

  1728.     $ar['_langs']='all';
    1729. 

  1729.     return $this->procEdit($ar);
    1730. 

  1730.   }
    1731. 

  1731. 

  1732.   /// Duplique une fiche à partir d'une edition
    1733. 

  1733.   function procEditDup($ar) {
    1734. 

  1734.     $p = new XParam($ar, NULL);
    1735. 

  1735.     $tplentry = $p->get('tplentry');
    1736. 

  1736.     $oid=$p->get('oid');
    1737. 

  1737.     $ar['table']=$this->table;
    1738. 

  1738.     if($this->procEditDupCtrl($ar)) {
    1739. 

  1739.       $ret=$this->xset->procEditDup($ar);
    1740. 

  1740.       $this->duplicateSubModules($oid,$ret['oid']);
    1741. 

  1741.       if ($this->savenext && in_array($this->savenext,array('display','edit'))  && $tplentry!=TZR_RETURN_DATA){
    1742. 

  1742. 	$oid = $ret['oid'];
    1743. 

  1743. 	$submodcontext = $this->subModuleContext($ar);
    1744. 

  1744. 	XShell::setnext($GLOBALS['TZR_SESSION_MANAGER']::complete_self(true, true).'&class='.get_class($this).'&moid='.$this->_moid.'&function='.$this->savenext.'&template=xmodtable/'.($this->savenext == 'display' ? 'view' : 'edit').'.html&tplentry=br&oid='.$oid.@$submodcontext['urlparms']/* vide si pas  sous module */);
    1745. 

  1745.       }
    1746. 

  1746.     } else {
    1747. 

  1747.       $options=&$this->xset->prepareReInput($ar);
    1748. 

  1748.       $t='xmodtable/new.html';
    1749. 

  1749.       XShell::changeTemplate($t);
    1750. 

  1750.       XShell::setNext();
    1751. 

  1751.       $ar['options']=$options;
    1752. 

  1752.       $ar['tplentry']= 'br';
    1753. 

  1753.       $this->insert($ar);
    1754. 

  1754.       unset($_REQUEST['_skip'],$_REQUEST['skip']);
    1755. 

  1755.       return;
    1756. 

  1756.     }
    1757. 

  1757.     return XShell::toScreen1($tplentry, $ret);
    1758. 

  1758.   }
    1759. 

  1759. 

  1760.   /// Traitement d'une edition par lot
    1761. 

  1761.   function procEditSelection($ar){
    1762. 

  1762.     $ar['editbatch']=true;
    1763. 

  1763.     return $this->procEdit($ar);
    1764. 

  1764.   }
    1765. 

  1765. 

  1766.   /// Duplique une fiche
    1767. 

  1767.   function duplicate($ar=NULL){
    1768. 

  1768.     $p=new XParam($ar);
    1769. 

  1769.     $oid=$p->get('oid');
    1770. 

  1770.     $ar['oid']=$oid;
    1771. 

  1771.     $noid=$this->xset->duplicate($ar);
    1772. 

  1772.     $this->duplicateSubModules($oid,$noid);
    1773. 

  1773.     return $noid;
    1774. 

  1774.   }
    1775. 

  1775. 

  1776.   /// Duplication des sous fiches d'une fiche
    1777. 

  1777.   function duplicateSubModules($oid,$oiddst) {
    1778. 

  1778.     $oids=array();
    1779. 

  1779.     $subMods=$this->getSubModules(true);
    1780. 

  1780.     foreach($subMods as $subMod) {
    1781. 

  1781.       $sel=$subMod['xset']->select_query(array('cond'=>array($subMod['linkfield']=>array('LIKE','%'.$oid.'%'))));
    1782. 

  1782.       $ssRecords=$subMod['xset']->browse(array('select'=>$sel,'tplentry'=>TZR_RETURN_DATA,
    1783. 

  1783. 					       'selected'=>'0','selectedfields'=>$subMod['linkfield']));
    1784. 

  1784.       foreach($ssRecords['lines_oid'] as $i=>$ssoid){
    1785. 

  1785. 	$oids[]=$n=$subMod['mod']->duplicate(array('oid'=>$ssoid,'_options'=>array('local')));
    1786. 

  1786. 	updateQuery('update '.$subMod['mod']->table.' set '.$subMod['linkfield'].'="'.$oiddst.'" where KOID="'.$n.'"');
    1787. 

  1787.       }
    1788. 

  1788.     }
    1789. 

  1789.     return $oids;
    1790. 

  1790.   }
    1791. 

  1791. 

  1792.   /****m* XModTable/query
    1793. 

  1793.    * NAME
    1794. 

  1794.    *   XModTable::query - génération du formulaire de requête
    1795. 

  1795.    * DESCRIPTION
    1796. 

  1796.    *   Calcul des éléments du formalaire de requête pour l'ensemble de fichier. Le traitement
    1797. 

  1797.    *   du formulaire est ensuite assuré par XModTable::procQuery ()
    1798. 

  1798.    * INPUTS
    1799. 

  1799.    *   Passage de paramètre indirect via $ar
    1800. 

  1800.    ****/
    1801. 

  1801.   function query($ar) {
    1802. 

  1802.     $p = new XParam($ar,array());
    1803. 

  1803.     $tplentry=$p->get('tplentry');
    1804. 

  1804.     $ar['table']=$this->table;
    1805. 

  1805.     $ar['fieldssec']=$this->getFieldsSec($ar);
    1806. 

  1806.     if($this->interactive && $this->_issetSession('query')) $this->_clearSession('query');
    1807. 

  1807.     if($this->interactive && !$this->stored_query) $ar['searchmode']='simple';
    1808. 

  1808.     if(empty($ar['fmoid'])) $ar['fmoid']=$this->_moid;
    1809. 

  1809.     $ar['module_filter']=$this->getFilter(true,$ar);  // filtre pour les SelectBox
    1810. 

  1810.     $r=$this->xset->query($ar);
    1811. 

  1811.     if($tplentry!=TZR_RETURN_DATA && XShell::admini_mode() && $this->interactive && XDataSource::sourceExists('QUERIES')) {
    1812. 

  1812.       $r1=$this->storedQueries();
    1813. 

  1813.       XShell::toScreen1('queries',$r1);
    1814. 

  1814.     }
    1815. 

  1815.     return XShell::toScreen1($tplentry,$r);
    1816. 

  1816.   }
    1817. 

  1817. 

  1818.   /// Recherches sauvegardées
    1819. 

  1819.   function storedQueries() {
    1820. 

  1820.     $queries = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS=QUERIES');
    1821. 

  1821.     $q=$queries->select_query(array('order'=>'grp',
    1822. 

  1822. 				    'cond'=>array('modid'=>array('=',$this->_moid),'rtype'=>array('=','table'))));
    1823. 

  1823.     $r1=&$queries->browse(array('select'=>$q,'selected'=>0,'tplentry'=>TZR_RETURN_DATA,'pagesize'=>'100'));
    1824. 

  1824.     return $r1;
    1825. 

  1825.   }
    1826. 

  1826. 

  1827.   /****m* XModTable/quickquery
    1828. 

  1828.    * NAME
    1829. 

  1829.    *   XModTable::quickquery - génération du formulaire de requête
    1830. 

  1830.    * DESCRIPTION
    1831. 

  1831.    *   Calcul des éléments du formalaire de requête pour l'ensemble de fichier. Le traitement
    1832. 

  1832.    *   du formulaire est ensuite assuré par XModTable::procQuery ()
    1833. 

  1833.    * INPUTS
    1834. 

  1834.    *   Passage de paramètre indirect via $ar
    1835. 

  1835.    ****/
    1836. 

  1836.   function &quickquery($ar) {
    1837. 

  1837.     $p = new XParam($ar,array());
    1838. 

  1838.     $ar['table']=$this->table;
    1839. 

  1839.     if(empty($ar['fmoid'])) $ar['fmoid']=$this->_moid;
    1840. 

  1840.     $r=&$this->xset->quickquery($ar);
    1841. 

  1841.     
    1842. 

  1842.     // recherche sur les sous-fiches
    1843. 

  1843.     if ($this->submodsearch) {
    1844. 

  1844.       // liste id/title
    1845. 

  1845.       for($i=1; $i<=$this->submodmax; $i++) {
    1846. 

  1846.         $ssmod = 'ssmod'.$i;
    1847. 

  1847.         $ssmoid = $this->$ssmod;
    1848. 

  1848.         if ($ssmoid) {
    1849. 

  1849.           $mod = XModule::objectFactory($ssmoid);
    1850. 

  1850.           $sec = $mod->getAccess();
    1851. 

  1851.           if (isset($sec['list'])) {
    1852. 

  1852.             $title = 'ssmodtitle'.$i;
    1853. 

  1853.             $ssmod_title = $this->$title;
    1854. 

  1854.             if (empty($ssmod_title))
    1855. 

  1855.               $ssmod_title = $mod->modulename;
    1856. 

  1856.             $r['submodules'][$i] = $ssmod_title;
    1857. 

  1857.           }
    1858. 

  1858.         }
    1859. 

  1859.       }
    1860. 

  1860.       // les criteres retenus dans la recherche
    1861. 

  1861.       $r['submodules_searchselected'] = $this->_submodules_searchselected;
    1862. 

  1862.     }
    1863. 

  1863.     return $r;
    1864. 

  1864.   }
    1865. 

  1865. 

  1866.   /// Supprime une requete sauvegardée
    1867. 

  1867.   function delStoredQuery($ar=NULL) {
    1868. 

  1868.     $p=new XParam($ar,array());
    1869. 

  1869.     if(XDataSource::sourceExists('QUERIES')) {
    1870. 

  1870.       $storename=$p->get('oidr');
    1871. 

  1871.       if(!empty($storename)) {
    1872. 

  1872. 	$queries=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.'QUERIES');
    1873. 

  1873. 	$queries->del(array('oid'=>$storename));
    1874. 

  1874.       }
    1875. 

  1875.     }
    1876. 

  1876.   }
    1877. 

  1877. 

  1878.   /**
    1879. 

  1879.    * Affiche le formulaire d'édition des sections fonction de type "Liste"
    1880. 

  1880.    * @param $ar array Paramètres de la section précédemment sauvegardés
    1881. 

  1881.    * @return $ret array Ensemble des champs d'édition des paramètres de la section fonction
    1882. 

  1882.    */
    1883. 

  1883.   public function &UIEdit_procQuery($ar=NULL){
    1884. 

  1884.     // Récupération des champs de filtrage et ajout dans le groupe "Filtre"
    1885. 

  1885.     $ret = $this->query($ar);
    1886. 

  1886.     foreach ($ret['fields_object'] as $f) {
    1887. 

  1887.       $ret['o'.$f->field]->fielddef->fgroup = $f->fgroup = XLabels::getSysLabel('general','filter','text');
    1888. 

  1888.     }
    1889. 

  1889. 

  1890.     // Construction des options génériques d'affichage de la liste
    1891. 

  1891.     $grp=XLabels::getSysLabel('general','result','text');
    1892. 

  1892.     $fs['___storedquery']=XFieldDef::objectFactory((object)array('FIELD'=>'___storedquery','FTYPE'=>'XLinkDef','MULTIVALUED'=>0,
    1893. 

  1893. 								 'COMPULSORY'=>false,'TARGET'=>'QUERIES',
    1894. 

  1894. 								 'LABEL'=>XLabels::getSysLabel('xmodtable','stored_query','text')));
    1895. 

  1895.     $fs['___storedquery']->filter='modid="'.$this->_moid.'"';
    1896. 

  1896.     $fs['___storedquery']->fgroup=$grp;
    1897. 

  1897. 

  1898.     $fs['__viewheader']=XFieldDef::objectFactory((object)array('FIELD'=>'__viewheader','FTYPE'=>'XBoolDef','MULTIVALUED'=>0,
    1899. 

  1899. 							       'COMPULSORY'=>false,
    1900. 

  1900. 							       'LABEL'=>XLabels::getSysLabel('xmodtable','viewheader','text')));
    1901. 

  1901.     $fs['__viewheader']->default=1;
    1902. 

  1902.     $fs['__viewheader']->fgroup=$grp;
    1903. 

  1903. 

  1904.     $fs['__selectedfields']=XFieldDef::objectFactory((object)array('FIELD'=>'__selectedfields','FTYPE'=>'XTableFieldDef','MULTIVALUED'=>1,
    1905. 

  1905. 								   'COMPULSORY'=>false,'TARGET'=>$this->table,
    1906. 

  1906. 								   'LABEL'=>XLabels::getSysLabel('general','fields','text')));
    1907. 

  1907.     $fs['__selectedfields']->doublebox=true;
    1908. 

  1908.     $fs['__selectedfields']->fgroup=$grp;
    1909. 

  1909. 

  1910.     $fs['__order']=XFieldDef::objectFactory((object)array('FIELD'=>'__order','FTYPE'=>'XTableFieldDef','MULTIVALUED'=>1,
    1911. 

  1911. 							  'COMPULSORY'=>false,'TARGET'=>$this->table,
    1912. 

  1912. 							  'LABEL'=>XLabels::getSysLabel('general','order','text')));
    1913. 

  1913.     $fs['__order']->doublebox=$fs['__order']->withorder=$fs['__order']->allowrandom=true;
    1914. 

  1914.     $fs['__order']->fgroup=$grp;
    1915. 

  1915. 

  1916.     $fs['__filterfields']=XFieldDef::objectFactory((object)array('FIELD'=>'__filterfields','FTYPE'=>'XTableFieldDef','MULTIVALUED'=>1,
    1917. 

  1917.                                                           'COMPULSORY'=>false,'TARGET'=>$this->table,
    1918. 

  1918.                                                           'LABEL'=>XLabels::getSysLabel('xmodinfotree','filterfields','text')));
    1919. 

  1919.     $fs['__filterfields']->doublebox=$fs['__filterfields']->onlyqueryable=true;
    1920. 

  1920.     $fs['__filterfields']->fgroup=$grp;
    1921. 

  1921. 

  1922.     $fs['__filterlabelin']=XFieldDef::objectFactory((object)array('FIELD'=>'__filterlabelin','FTYPE'=>'XBoolDef','MULTIVALUED'=>0,
    1923. 

  1923.                                                                    'COMPULSORY'=>false,
    1924. 

  1924.                                                                    'LABEL'=>XLabels::getSysLabel('general','filter','text') .' : '. XLabels::getSysLabel('xfielddef','label_in','text')));
    1925. 

  1925.     $fs['__filterlabelin']->default=2;
    1926. 

  1926.     $fs['__filterlabelin']->fgroup=$grp;
    1927. 

  1927. 

  1928.     $fs['__sortfields']=XFieldDef::objectFactory((object)array('FIELD'=>'__sortfields','FTYPE'=>'XTableFieldDef','MULTIVALUED'=>1,
    1929. 

  1929.                                                           'COMPULSORY'=>false,'TARGET'=>$this->table,
    1930. 

  1930.                                                           'LABEL'=>XLabels::getSysLabel('xmodinfotree','weborderselector','text')));
    1931. 

  1931.     $fs['__sortfields']->doublebox=true;
    1932. 

  1932.     $fs['__sortfields']->fgroup=$grp;
    1933. 

  1933.     
    1934. 

  1934.     $fs['__sortAscDesc']=XFieldDef::objectFactory((object)array('FIELD'=>'__sortAscDesc','FTYPE'=>'XBoolDef','MULTIVALUED'=>0,
    1935. 

  1935.                                                           'COMPULSORY'=>false,'TARGET'=>$this->table,
    1936. 

  1936.                                                           'LABEL'=>XLabels::getSysLabel('xmodinfotree','sortascdesc','text')));
    1937. 

  1937.     $fs['__sortAscDesc']->default=2;
    1938. 

  1938.     $fs['__sortAscDesc']->fgroup=$grp;
    1939. 

  1939.     
    1940. 

  1940.     $fs['__groupfields']=XFieldDef::objectFactory((object)array('FIELD'=>'__groupfields','FTYPE'=>'XTableFieldDef','MULTIVALUED'=>1,
    1941. 

  1941.                                                           'COMPULSORY'=>false,'TARGET'=>$this->table,
    1942. 

  1942.                                                           'LABEL'=>XLabels::getSysLabel('xmodinfotree','groupfields','text')));
    1943. 

  1943.     $fs['__groupfields']->doublebox=true;
    1944. 

  1944.     $fs['__groupfields']->fgroup=$grp;
    1945. 

  1945.     
    1946. 

  1946.     $fs['__pagesize']=XFieldDef::objectFactory((object)array('FIELD'=>'__pagesize','FTYPE'=>'XShortTextDef','COMPULSORY'=>false,
    1947. 

  1947.                                                              'LABEL'=>XLabels::getSysLabel('xmodinfotree','max_nb','text')));
    1948. 

  1948.     $fs['__pagesize']->default=$this->pagesize;
    1949. 

  1949.     $fs['__pagesize']->listbox=false;
    1950. 

  1950.     $fs['__pagesize']->fgroup=$grp;
    1951. 

  1951. 

  1952.     $fs['__linktodetail']=XFieldDef::objectFactory((object)array('FIELD'=>'__linktodetail','FTYPE'=>'XShortTextDef','COMPULSORY'=>false,
    1953. 

  1953. 							   'FCOUNT'=>255, 'LABEL'=>XLabels::getSysLabel('xmodinfotree','linktodetail','text')));
    1954. 

  1954.     $fs['__linktodetail']->fgroup=$grp;
    1955. 

  1955.     $fs['__linktodetail']->listbox=false;
    1956. 

  1956. 

  1957.     $fs['__linktodetaillabel']=XFieldDef::objectFactory((object)array('FIELD'=>'__linktodetaillabel','FTYPE'=>'XShortTextDef','COMPULSORY'=>false,
    1958. 

  1958.                                                           'FCOUNT'=>255, 'LABEL'=>XLabels::getSysLabel('xmodinfotree','linktodetaillabel','text')));
    1959. 

  1959.     $fs['__linktodetaillabel']->fgroup=$grp;
    1960. 

  1960.     $fs['__linktodetaillabel']->listbox=false;
    1961. 

  1961. 

  1962.     $fs['__viewpagination']=XFieldDef::objectFactory((object)array('FIELD'=>'__viewpagination','FTYPE'=>'XBoolDef','MULTIVALUED'=>0,
    1963. 

  1963.                                                                    'COMPULSORY'=>false,
    1964. 

  1964.                                                                    'LABEL'=>XLabels::getSysLabel('xmodtable','viewpagination','text')));
    1965. 

  1965.     $fs['__viewpagination']->default=2;
    1966. 

  1966.     $fs['__viewpagination']->fgroup=$grp;
    1967. 

  1967.     
    1968. 

  1968.     foreach($fs as $fn=>&$f){
    1969. 

  1969.       if( empty($ar[$fn]) ){
    1970. 

  1970.         $value = $f->default;
    1971. 

  1971.       }elseif(is_array($ar[$fn])){
    1972. 

  1972.         $value = implode('||',$ar[$fn]);
    1973. 

  1973.       }else{
    1974. 

  1974.         $value = $ar[$fn];
    1975. 

  1975.       }
    1976. 

  1976.       $o = $f->edit($value);
    1977. 

  1977.       $ret['o'.$fn] = $ret['fields_object'][] = $o;
    1978. 

  1978.     }
    1979. 

  1979. 

  1980.     // Définit les champs disponibles uniquement en mode expert (caché par défaut aux non admin)
    1981. 

  1981.     $ret['__advancedfields'] = array(
    1982. 

  1982.       '__viewheader',
    1983. 

  1983.       '__filterfields',
    1984. 

  1984.       '__filterlabelin',
    1985. 

  1985.       '__sortfields',
    1986. 

  1986.       '__sortAscDesc',
    1987. 

  1987.       '__sortAscDesc',
    1988. 

  1988.       '__groupfields',
    1989. 

  1989.       '__viewpagination',
    1990. 

  1990.       '__linktodetail',
    1991. 

  1991.       '__linktodetaillabel',
    1992. 

  1992.       '___storedquery',
    1993. 

  1993.       '__selectedfields',
    1994. 

  1994.     );
    1995. 

  1995. 

  1996.     return $ret;
    1997. 

  1997.   }
    1998. 

  1998. 

  1999.   /**
    2000. 

  2000.    * Enregistre les paramètres des sections fonction de type "Liste"
    2001. 

  2001.    * @param $ar array Récupère les paramètres par défaut
    2002. 

  2002.    * @return $params array Liste des paramètres transformés à enregistrer
    2003. 

  2003.    */
    2004. 

  2004.   public function &UIProcEdit_procQuery($ar=NULL){
    2005. 

  2005.     $p=new XParam($ar,NULL);
    2006. 

  2006.     $xbool=new XBoolDef();
    2007. 

  2007.     $params=$this->xset->captureQuery($ar);
    2008. 

  2008.     $params['___storedquery']=$p->get('___storedquery');
    2009. 

  2009.     $params['__selectedfields']=implode('||',$p->get('__selectedfields'));
    2010. 

  2010.     $params['__order']=implode('||',$p->get('__order'));
    2011. 

  2011.     $params['__filterfields']=implode('||',$p->get('__filterfields'));
    2012. 

  2012.     $xbool->field='__filterlabelin';
    2013. 

  2013.     $tmp=$xbool->post_edit($p->get('__filterlabelin'),$opt=array('__filterlabelin_HID'=>$p->get('__filterlabelin_HID')));
    2014. 

  2014.     $params['__filterlabelin']=$tmp->raw;
    2015. 

  2015.     $params['__sortfields']=implode('||',$p->get('__sortfields'));
    2016. 

  2016.     $xbool->field='__sortAscDesc';
    2017. 

  2017.     $tmp=$xbool->post_edit($p->get('__sortAscDesc'),$opt=array('__sortAscDesc_HID'=>$p->get('__sortAscDesc_HID')));
    2018. 

  2018.     $params['__sortAscDesc']=$tmp->raw;
    2019. 

  2019.     $params['__groupfields']=implode('||',$p->get('__groupfields'));
    2020. 

  2020.     $params['__pagesize']=$p->get('__pagesize');
    2021. 

  2021.     $params['__linktodetail']=$p->get('__linktodetail');
    2022. 

  2022.     // si on a un alias détail, stoker l'oid correspondant
    2023. 

  2023.     if ($params['__linktodetail']) {
    2024. 

  2024.       list($ittable) = preg_split('/:/', $p->get('oidit'));
    2025. 

  2025.       $params['__linktodetail_oidit'] = selectQuery('select koid from '.$ittable.' where alias="'.$params['__linktodetail'].'"')->fetch(PDO::FETCH_COLUMN);
    2026. 

  2026.       // si alias incorect, supprimer
    2027. 

  2027.       if (!$params['__linktodetail_oidit'])
    2028. 

  2028.         $params['__linktodetail'] = '';
    2029. 

  2029.     }
    2030. 

  2030.     $params['__linktodetaillabel']=$p->get('__linktodetaillabel');
    2031. 

  2031.     $xbool->field='__viewheader';
    2032. 

  2032.     $tmp=$xbool->post_edit($p->get('__viewheader'),$opt=array('__viewheader_HID'=>$p->get('__viewheader_HID')));
    2033. 

  2033.     $params['__viewheader']=$tmp->raw;
    2034. 

  2034.     $xbool->field='__viewpagination';
    2035. 

  2035.     $tmp=$xbool->post_edit($p->get('__viewpagination'),$opt=array('__viewpagination_HID'=>$p->get('__viewpagination_HID')));
    2036. 

  2036.     $params['__viewpagination']=$tmp->raw;
    2037. 

  2037.     return $params;
    2038. 

  2038.   }
    2039. 

  2039. 

  2040.   /**
    2041. 

  2041.    * Affiche une section fonction de type "Liste" dans un gestionnaire de rubriques
    2042. 

  2042.    * @param $ar array Récupère les paramètres de la section
    2043. 

  2043.    * @return $result array Liste des résultats
    2044. 

  2044.    */
    2045. 

  2045.   public function &UIView_procQuery($ar=NULL){
    2046. 

  2046.     $params = $_REQUEST['sectionopts'][$ar['itoid']];
    2047. 

  2047.     $ar['_storedquery'] = $ar['___storedquery'];
    2048. 

  2048.     if(!empty($ar['__selectedfields']))
    2049. 

  2049.       $selectedfields = explode('||',$ar['__selectedfields']);
    2050. 

  2050.     else
    2051. 

  2051.       $selectedfields = $this->xset->browsableFields();
    2052. 

  2052.     $groupfields = preg_split('/\|\|/', $ar['__groupfields'], 0, PREG_SPLIT_NO_EMPTY); 
    2053. 

  2053.     $sortfields = preg_split('/\|\|/', $ar['__sortfields'], 0, PREG_SPLIT_NO_EMPTY); 
    2054. 

  2054.     $orderfields = preg_split('/\|\|/', $ar['__order'], 0, PREG_SPLIT_NO_EMPTY);
    2055. 

  2055.     $ar['order'] = implode(',', $orderfields);
    2056. 

  2056. 

  2057.     // nb de réponses
    2058. 

  2058.     $pagesizes = explode(',', $ar['__pagesize']);
    2059. 

  2059.     if ($params['pagesize']) {
    2060. 

  2060.       $pagesize = $params['pagesize'];
    2061. 

  2061.       $_SESSION['pagesize_'.$ar['itoid']] = $pagesize;
    2062. 

  2062.     } else {
    2063. 

  2063.       if (issetSessionVar('pagesize_'.$ar['itoid']))
    2064. 

  2064.         $pagesize = getSessionVar('pagesize_'.$ar['itoid']);
    2065. 

  2065.       elseif($pagesizes[0])
    2066. 

  2066.         $pagesize = $pagesizes[0];
    2067. 

  2067.     }
    2068. 

  2068.     if (!isset($pagesize))
    2069. 

  2069.       $pagesize = TZR_XMODTABLE_BROWSE_PAGESIZE;
    2070. 

  2070.     // recupération des parametres postés (pagination, ordre, )
    2071. 

  2071.     if ($params)
    2072. 

  2072.       $ar = array_merge($ar, $params);
    2073. 

  2073.       
    2074. 

  2074.     // ajouter les champs de groupage en premier dans l'ordre
    2075. 

  2075.     // permettre de trier sur ces champs
    2076. 

  2076.     $sqlorder = $ar['order'];
    2077. 

  2077.     if ($groupfields) {
    2078. 

  2078.       $grpfields = $groupfields;
    2079. 

  2079.       $sqlorderfields = preg_split('/\|\|/', $sqlorder, 0, PREG_SPLIT_NO_EMPTY);
    2080. 

  2080.       foreach ($sqlorderfields as $i => $orderfield) {
    2081. 

  2081.         $field = preg_replace('/( ASC| DESC)/i', '', $orderfield);
    2082. 

  2082.         if (($index = array_search($field, $grpfields)) !== false) {
    2083. 

  2083.           $grpfields[$index] = $orderfield;
    2084. 

  2084.           unset($sqlorderfields[$i]);
    2085. 

  2085.         }
    2086. 

  2086.       }
    2087. 

  2087.       $ar['order'] = implode(',', array_merge($grpfields, $sqlorderfields));
    2088. 

  2088.     }
    2089. 

  2089.     
    2090. 

  2090.     // retour depuis une fiche
    2091. 

  2091.     if (!isset($_SESSION['oids_'.$ar['itoid']])) {
    2092. 

  2092.       $do_select = true;
    2093. 

  2093.       $first = 0;
    2094. 

  2094.     } else {
    2095. 

  2095.       // les oids
    2096. 

  2096.       $oids = $_SESSION['oids_'.$ar['itoid']];
    2097. 

  2097.     
    2098. 

  2098.       if ($params['oid'] 
    2099. 

  2099.           && ($index = array_search($params['oid'], $oids)) !== false) {
    2100. 

  2100.         $do_select = false;
    2101. 

  2101.         $first = floor($index/$pagesize) * $pagesize;
    2102. 

  2102.       }
    2103. 

  2103.       // on ne poste pas le filtre (pagination)
    2104. 

  2104.       elseif($params && !$params['insidefilter']) {
    2105. 

  2105.         $do_select = false;
    2106. 

  2106.         $storedfilter = $_SESSION['filter_'.$ar['itoid']];
    2107. 

  2107.         $first = $params['first'];
    2108. 

  2108.       } else {
    2109. 

  2109.         $do_select = true;
    2110. 

  2110.         $first = 0;
    2111. 

  2111.       }
    2112. 

  2112.     }
    2113. 

  2113.     
    2114. 

  2114.     // calcul des filtres et récupération des valeurs
    2115. 

  2115.     if(!empty($ar['__filterfields'])) {
    2116. 

  2116.       $filterfields = preg_split('/\|\|/', $ar['__filterfields'], 0, PREG_SPLIT_NO_EMPTY);
    2117. 

  2117. 

  2118.       $filter = array('_preparedquery' => $ar, 'tplentry' => TZR_RETURN_DATA);
    2119. 

  2119.       $filter['searchmode'] = 'simple';
    2120. 

  2120.       if ($params['insidefilter']) {
    2121. 

  2121.         foreach ($filterfields as $field) {
    2122. 

  2122.           if ($_REQUEST[$field] && $_REQUEST[$field] != array('0' => '') 
    2123. 

  2123.                                 && $_REQUEST[$field]!= array('0' => 'Foo')) {
    2124. 

  2124.             $filter[$field] = $_REQUEST[$field];
    2125. 

  2125.             $filter[$field.'_empty'] = $_REQUEST[$field.'_empty'];
    2126. 

  2126.             $filter[$field.'_op']  = $_REQUEST[$field.'_op'];
    2127. 

  2127.             $filter[$field.'_HID'] = $_REQUEST[$field.'_HID'];
    2128. 

  2128.             $filter[$field.'_FMT'] = $_REQUEST[$field.'_FMT'];
    2129. 

  2129.             $filter[$field.'_PAR'] = $_REQUEST[$field.'_PAR'];
    2130. 

  2130.           } 
    2131. 

  2131.         }
    2132. 

  2132.         $ar = array_merge($ar, $filter);
    2133. 

  2133.       }
    2134. 

  2134.       // pagination
    2135. 

  2135.       elseif ($storedfilter) {
    2136. 

  2136.         $filter = array_merge($filter, $storedfilter);
    2137. 

  2137.         $ar = array_merge($ar, $storedfilter);
    2138. 

  2138.       }
    2139. 

  2139.       // préparation des inputs
    2140. 

  2140.       $filter['selectedfields'] = $filterfields;
    2141. 

  2141.       if ($ar['__filterlabelin'] == 1)
    2142. 

  2142.         foreach ($filterfields as $field)
    2143. 

  2143.           $filter['options'][$field]['labelin'] = true;
    2144. 

  2144.       $queryfields = $this->query($filter);
    2145. 

  2145.       // mise dans l'ordre du select
    2146. 

  2146.       $ordered_filterfields = array_flip($filterfields);
    2147. 

  2147.       foreach ($queryfields as $ofield) {
    2148. 

  2148.         if ($ofield->field)
    2149. 

  2149.           $ordered_filterfields[$ofield->field] = $ofield;
    2150. 

  2150.       }
    2151. 

  2151.     }
    2152. 

  2152. 

  2153.     if ($do_select) {
    2154. 

  2154.       // calcul du select
    2155. 

  2155.       $quickquery_value = $this->quickquery;
    2156. 

  2156.       $this->quickquery = false;
    2157. 

  2157.       $ar['getselectonly'] = true;
    2158. 

  2158.       $select = $this->procQuery($ar);
    2159. 

  2159.       $this->quickquery = $quickquery_value;
    2160. 

  2160.       // calcul des oids
    2161. 

  2161.       $select = preg_replace('/^select .* from '.$this->table.'/', 'select '.$this->table.'.KOID from '.$this->table, $select);
    2162. 

  2162.       if ($rs = selectQuery($select))
    2163. 

  2163.         $oids = $rs->fetchAll(PDO::FETCH_COLUMN);
    2164. 

  2164.       // verification des droits sur les enregistrements
    2165. 

  2165.       if($this->object_sec) {
    2166. 

  2166.         $tmp = array('lines_oid' => $oids);
    2167. 

  2167.         $this->applyObjectsSec($tmp);
    2168. 

  2168.         $oids = $tmp['lines_oid'];
    2169. 

  2169.       }
    2170. 

  2170.       // sauvegarde des oids en session
    2171. 

  2171.       $_SESSION['oids_'.$ar['itoid']] = $oids;
    2172. 

  2172.     }
    2173. 

  2173. 

  2174.     $result = $this->xset->browse(array(
    2175. 

  2175.       'tplentry' => TZR_RETURN_DATA,
    2176. 

  2176.       'selectedfields' => array_merge($selectedfields, $groupfields),
    2177. 

  2177.       'nocount' => 1,
    2178. 

  2178.       'tlink' => 1,
    2179. 

  2179.       'pagesize' => $pagesize,
    2180. 

  2180.       'where' => 'KOID in ("'.implode('","', array_slice($oids, $first, $pagesize)).'")',
    2181. 

  2181.       'order' => 'field(koid, "'.implode('","', array_slice($oids, $first, $pagesize)).'")',
    2182. 

  2182.       'options' => $ar['options'],
    2183. 

  2183.       '_options' => array('genpublishtag' => false)
    2184. 

  2184.     ));
    2185. 

  2185.     // calcul de la pagination
    2186. 

  2186.     $result['pagesize'] = $pagesize;
    2187. 

  2187.     $result['first'] = $first;
    2188. 

  2188.     $result['last'] = count($oids);
    2189. 

  2189.     if ($pagesize < $result['last']) {
    2190. 

  2190.       for ($p=0, $i=0; ($i<$result['last']); $p++, $i+=$pagesize) 
    2191. 

  2191.         $result['pages'][$p] = $i;
    2192. 

  2192.     }
    2193. 

  2193.     
    2194. 

  2194.     // asciify keywords (url detail)
    2195. 

  2195.     for ($i=0; $i<count($result['lines_tlink']); $i++)
    2196. 

  2196.       $result['lines_tlink'][$i] = rewriteToAscii(trim($result['lines_tlink'][$i]));
    2197. 

  2197.     
    2198. 

  2198.     // passer le filtre au résultat
    2199. 

  2199.     $result['filterfields'] = $ordered_filterfields;
    2200. 

  2200.     // trie
    2201. 

  2201.     $result['defaultOrder'] = implode(',', $orderfields);
    2202. 

  2202.     foreach ($sortfields as $field) {
    2203. 

  2203.       if ($ar['__sortAscDesc'] == 1) {
    2204. 

  2204.         $result['sortfields'][$field] = array(
    2205. 

  2205.           'label' => $this->xset->desc[$field]->label . ' +', 
    2206. 

  2206.           'selected' => $field == $sqlorder ? 'selected="selected"' : '');
    2207. 

  2207.         $result['sortfields']["$field DESC"] = array(
    2208. 

  2208.           'label' => $this->xset->desc[$field]->label . ' -', 
    2209. 

  2209.           'selected' => "$field DESC" == $sqlorder ? 'selected="selected"' : '');
    2210. 

  2210.       } else
    2211. 

  2211.         $result['sortfields'][$field] = array(
    2212. 

  2212.           'label' => $this->xset->desc[$field]->label, 
    2213. 

  2213.           'selected' => $field == $sqlorder ? 'selected="selected"' : '');
    2214. 

  2214.     }
    2215. 

  2215.     if (count($pagesizes) > 1)
    2216. 

  2216.       $result['pagesizes'] = $pagesizes;
    2217. 

  2217. 

  2218.     // grouper 
    2219. 

  2219.     if ($groupfields) {
    2220. 

  2220.       $result['groups'] = $this->group($groupfields, $selectedfields, $result);
    2221. 

  2221.       // supprimer les champs de groupage (dans le header)
    2222. 

  2222.       for ($i=count($result['header_fields'])-1; $i>=0; $i--) {
    2223. 

  2223.         if (in_array($result['header_fields'][$i]->field, $groupfields))
    2224. 

  2224.           unset($result['header_fields'][$i]);
    2225. 

  2225.       }
    2226. 

  2226.       $result['header_fields'] = array_values($result['header_fields']);
    2227. 

  2227.     }
    2228. 

  2228.     
    2229. 

  2229.     // stocker le filtre pour la pagination
    2230. 

  2230.     if($params['insidefilter']) {
    2231. 

  2231.       $filter['order'] = $ar['order'];
    2232. 

  2232.       unset($filter['selectedfields']);
    2233. 

  2233.       $_SESSION['filter_'.$ar['itoid']] = $filter;
    2234. 

  2234.     }
    2235. 

  2235. 

  2236.     // la page ne peut pas être mise en cache
    2237. 

  2237.     $GLOBALS['XSHELL']->_cache = false;
    2238. 

  2238. 

  2239.     return $result;
    2240. 

  2240.   }
    2241. 

  2241.   // groupe le résultat d'un browse
    2242. 

  2242.   function group($groupfields, $selectedfields, $browse, $limit_characters = 0) {
    2243. 

  2243.     $groupfield =  array_shift($groupfields);
    2244. 

  2244.     $neededfields = array_unique(array_merge($selectedfields, $groupfields));
    2245. 

  2245.     foreach ($browse['lines_oid'] as $i => $oid) {
    2246. 

  2246.       $line_groupfield = $browse['lines_o'.$groupfield][$i];
    2247. 

  2247.       // Dans le cas d'un champ multivalué
    2248. 

  2248.       if ($line_groupfield->collection) {
    2249. 

  2249.         foreach ($line_groupfield->oidcollection as $j => $oidgroup) {
    2250. 

  2250.           $group_label = $line_groupfield->collection[$j]->html;
    2251. 

  2251.           if ($limit_characters) $group_label = substr($group_label, 0, $limit_characters);
    2252. 

  2252.           if (in_array($oid, $groups[$group_label]['lines_oid'])) continue;
    2253. 

  2253.           $groups[$group_label]['lines_oid'][] = $oid;
    2254. 

  2254.           $groups[$group_label]['olabel'] = $line_groupfield->collection[$j];
    2255. 

  2255.           foreach ($neededfields as $field) {
    2256. 

  2256.             $groups[$group_label]['lines_o'.$field][] = &$browse['lines_o'.$field][$i];
    2257. 

  2257.           }
    2258. 

  2258.         }
    2259. 

  2259.       // Champ non multivalué
    2260. 

  2260.       } else {
    2261. 

  2261.         $group_label = $line_groupfield->html;
    2262. 

  2262.         if ($limit_characters) $group_label = substr($group_label, 0, $limit_characters);
    2263. 

  2263.         if (in_array($oid, $groups[$group_label]['lines_oid'])) continue;
    2264. 

  2264.         $groups[$group_label]['lines_oid'][] = $oid;
    2265. 

  2265.         $groups[$group_label]['olabel'] = $browse['lines_o'.$groupfield][$i];
    2266. 

  2266.         foreach ($neededfields as $field) {
    2267. 

  2267.           $groups[$group_label]['lines_o'.$field][] = &$browse['lines_o'.$field][$i];
    2268. 

  2268.         }
    2269. 

  2269.       }
    2270. 

  2270.     }
    2271. 

  2271.     // appel recursif
    2272. 

  2272.     if (count($groupfields)) {
    2273. 

  2273.       foreach ($groups as $group_label => $group)
    2274. 

  2274.         $groups[$group_label] = $this->group($groupfields, $selectedfields, $group);
    2275. 

  2275.     }
    2276. 

  2276.     ksort($groups);
    2277. 

  2277.     return $groups;
    2278. 

  2278.   }
    2279. 

  2279.   /// Traitement d'une recherche
    2280. 

  2280.   function procQuery($ar) {
    2281. 

  2281.     $p=new XParam($ar,array('_FIELDS'=>array(),'first'=>0));
    2282. 

  2282.     $tplentry=$p->get('tplentry');
    2283. 

  2283.     $clearrequest=$p->get('clearrequest');
    2284. 

  2284.     $storedquery=$p->get('_storedquery');
    2285. 

  2285.     if(!empty($storedquery)) $clearrequest=1;
    2286. 

  2286.     $first=$p->get('first');
    2287. 

  2287.     $getselectonly=$p->get('getselectonly');
    2288. 

  2288.     $persistent=$p->get('_persistent');
    2289. 

  2289.     // traitement de la taille des pages
    2290. 

  2290.     $pagesize=$p->get('pagesize');
    2291. 

  2291.     if(empty($pagesize)) $pagesize=$this->pagesize;
    2292. 

  2292.     if(empty($pagesize)) $pagesize=TZR_XMODTABLE_BROWSE_MAXPAGESIZE;
    2293. 

  2293.     $ar['pagesize']=$pagesize;
    2294. 

  2294.     // Ordre
    2295. 

  2295.     $order=$p->get('order');
    2296. 

  2296.     $this->checkOrderFields($order);
    2297. 

  2297.     $ar['order']=$order;
    2298. 

  2298.     $ar['table']=$this->table;
    2299. 

  2299.     $ar['tplentry']=TZR_RETURN_DATA;
    2300. 

  2300.     if(empty($ar['fmoid'])) $ar['fmoid']=$this->_moid;
    2301. 

  2301.     // Filtre
    2302. 

  2302.     if($this->persistentquery && $persistent) clearSessionVar('filterquery'.$this->_moid);
    2303. 

  2303.     $ar['_filter']=$this->getFilter(true,$ar);
    2304. 

  2304.     $ar['fieldssec']=$this->getFieldsSec($ar);
    2305. 

  2305.     // Pour gestion de la navigation page/page en display et edit
    2306. 

  2306.     if($this->interactive) $this->_setSession('lastorder',$p->get('order'));
    2307. 

  2307.     // Stockage des requêtes nommées
    2308. 

  2308.     if(XDataSource::sourceExists('QUERIES')) {
    2309. 

  2309.       $storename=$p->get('_storename');
    2310. 

  2310.       $storegroup=$p->get('_storegroup');
    2311. 

  2311.       // Sauvegarde éventuelle de la requête
    2312. 

  2312.       if(!empty($storename)) {
    2313. 

  2313. 	$st=$this->xset->captureQuery($ar);
    2314. 

  2314. 	$queries = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS=QUERIES');
    2315. 

  2315. 	$queries->procInput(array('title'=>$storename, 'rtype'=>'table', 'modid'=>$this->_moid,'grp'=>$storegroup,
    2316. 

  2316. 				  'query'=>addslashes(serialize($st))));
    2317. 

  2317.       }
    2318. 

  2318.     }
    2319. 

  2319.     // recherche sous fiches
    2320. 

  2320.     if ($this->submodsearch)
    2321. 

  2321.       $this->checkSSmodFilter($ar);
    2322. 

  2322. 

  2323.     // Mode de recherche
    2324. 

  2324.     if($this->isThereAQueryActive() && empty($clearrequest) && $this->interactive) {
    2325. 

  2325.       // Recuperation de la requete active s'il y en a une
    2326. 

  2326.       $_storedquery=$this->_getSession('query');
    2327. 

  2327.       $ar=array_merge($_storedquery,$ar);
    2328. 

  2328.     } elseif (!empty($storedquery)){
    2329. 

  2329.       // Recherche sauvegardée
    2330. 

  2330.       $_storedquery = $this->xset->prepareQuery($ar, $storedquery);
    2331. 

  2331.       $_storedquery=$this->xset->captureQuery($ar);
    2332. 

  2332.       $this->_setSession('query',$_storedquery);
    2333. 

  2333.       $ar=array_merge($_storedquery,$ar);
    2334. 

  2334.       $ar['_storedquery']='';
    2335. 

  2335.     } elseif($this->interactive && sessionActive()) {
    2336. 

  2336.       $_storedquery=$this->xset->captureQuery($ar);
    2337. 

  2337.       // Mode affinage
    2338. 

  2338.       if((int)$clearrequest=='2'){
    2339. 

  2339. 	$_storedquery2=$this->_getSession('query');
    2340. 

  2340. 	$_storedquery['_FIELDS']=array_merge($_storedquery2['_FIELDS'],$_storedquery['_FIELDS']);
    2341. 

  2341. 	$_storedquery=array_merge($_storedquery2,$_storedquery);
    2342. 

  2342.       }
    2343. 

  2343.       $this->_setSession('query',$_storedquery);
    2344. 

  2344.       $ar=array_merge($_storedquery,$ar);
    2345. 

  2345.     }
    2346. 

  2346.     $r=$this->xset->procQuery($ar);
    2347. 

  2347.     if(!empty($getselectonly)) return $r;
    2348. 

  2348.     elseif($this->persistentquery && $persistent) setSessionVar('filterquery'.$this->_moid,$r['select']);
    2349. 

  2349.     if($this->object_sec) $this->applyObjectsSec($r);
    2350. 

  2350.     else $r['objects_sec']=$GLOBALS['XUSER']->getObjectsAccess($this, XShell::getLangData(), $r['lines_oid']);
    2351. 

  2351.     $r['function']='procQuery';
    2352. 

  2352.     if(!empty($this->_templates) && !empty($this->btemplates)) {
    2353. 

  2353.       $r=&$this->_templates->display(array('oid'=>$this->btemplates,'_options'=>array('error'=>'return'),'tplentry'=>TZR_RETURN_DATA));
    2354. 

  2354.       XShell::toScreen1($tplentry.'t',$r);
    2355. 

  2355.     }
    2356. 

  2356.     if(XShell::admini_mode()) {
    2357. 

  2357.       // passage du contexte sous module
    2358. 

  2358.       $submodcontext = $this->subModuleContext($ar);
    2359. 

  2359.       $r['urlparms'] = @$submodcontext['urlparms'];
    2360. 

  2360.       $this->browse_actions($r, false, $ar);
    2361. 

  2361.       if ($this->quickquery && !$assubmodule) {
    2362. 

  2362.         $ar['tplentry']=TZR_RETURN_DATA;
    2363. 

  2363.         $r['_qq']=$this->quickquery($ar);
    2364. 

  2364.       }
    2365. 

  2365.     }
    2366. 

  2366.     $this->browseSumFields($ar,$r,!$this->object_sec);
    2367. 

  2367.     return XShell::toScreen1($tplentry, $r);
    2368. 

  2368.   }
    2369. 

  2369.   /// Parcours le module pour la selection d'un fichier
    2370. 

  2370.   public function &procQueryFiles($ar) {
    2371. 

  2371.     return $this->procQuery($ar);
    2372. 

  2372.   }
    2373. 

  2373. 

  2374.   /// traite les filtres sur les sous fiches (présence/absence)
    2375. 

  2375.   /// disponible dans le qquery uniquement
    2376. 

  2376.   /// complète $ar['_select']
    2377. 

  2377.   function checkSSmodFilter(&$ar) {
    2378. 

  2378.     $p = new XParam($ar);
    2379. 

  2379.     $ssmods_search = $p->get('ssmods_search');
    2380. 

  2380.     for ($i=1; $i<=$this->submodmax; $i++) {
    2381. 

  2381.       if (in_array("$i", $ssmods_search)) {
    2382. 

  2382.         $op = 'in';
    2383. 

  2383.         $this->_submodules_searchselected[$i] = $i;
    2384. 

  2384.       } elseif (in_array("$i:not", $ssmods_search)) {
    2385. 

  2385.         $op = 'not in';
    2386. 

  2386.         $this->_submodules_searchselected["$i:not"] = "$i:not";
    2387. 

  2387.       } else
    2388. 

  2388.         continue;
    2389. 

  2389.       $moid = $this->{'ssmod'.$i};
    2390. 

  2390.       $linkfield = $this->{'ssmodfield'.$i};
    2391. 

  2391.       $ssmod = XModule::objectFactory($moid);
    2392. 

  2392.       $table = $ssmod->table;
    2393. 

  2393.       // recherche des liens qui pointent vers moi
    2394. 

  2394.       if (empty($linkfield)){
    2395. 

  2395.         $links = $ssmod->xset->getXLinkDefs(NULL, $this->table);
    2396. 

  2396.         if (!empty($links))
    2397. 

  2397.           list($foo, $linkfield) = each($links);
    2398. 

  2398.         else
    2399. 

  2399.           continue;
    2400. 

  2400.       }
    2401. 

  2401.       if ($ssmod->xset->isTranslatable()) 
    2402. 

  2402.         $cond[] = 'LANG="'.XShell::getLangData().'"';
    2403. 

  2403.       $filter = $ssmod->getFilter(true,$ar);
    2404. 

  2404.       if (!empty($filter))
    2405. 

  2405.         $cond[] = $filter;
    2406. 

  2406.       if (!XShell::admini_mode() && $this->xset->fieldExists('PUBLISH'))
    2407. 

  2407.         $cond[] = 'PUBLISH=1';
    2408. 

  2408.       if (!empty($cond))
    2409. 

  2409.         $cond = ' where ' . implode(' and ', $cond);
    2410. 

  2410.       else
    2411. 

  2411.         $cond = '';
    2412. 

  2412.       $ar['_select'][] = "KOID $op (select distinct $linkfield from $table $cond)";
    2413. 

  2413.     }
    2414. 

  2414.   }
    2415. 

  2415. 

  2416.   function UIParam_insert(){
    2417. 

  2417.     $ret['__selectedfields']=XFieldDef::objectFactory((object)array('FIELD'=>'__selectedfields','FTYPE'=>'XTableFieldDef','MULTIVALUED'=>1,
    2418. 

  2418. 								    'TARGET'=>$this->table,
    2419. 

  2419. 								    'LABEL'=>XLabels::getSysLabel('general','fields','text')));
    2420. 

  2420.     $ret['__selectedfields']->doublebox=true;
    2421. 

  2421.     $ret['__dispfgroup']=XFieldDef::objectFactory((object)array('FIELD'=>'__dispfgroup','FTYPE'=>'XBoolDef','COMPULSORY'=>1,
    2422. 

  2422. 								'LABEL'=>XLabels::getSysLabel('xmodtable','uiinsert_dispfgroup','text')));
    2423. 

  2423.     $ret['__labelvalidate']=XFieldDef::objectFactory((object)array('FIELD'=>'__labelvalidate','FTYPE'=>'XShortTextDef','COMPULSORY'=>0,
    2424. 

  2424. 							       'LABEL'=>XLabels::getSysLabel('xmodtable','uiinsert_btvalidate','text')));
    2425. 

  2425.     $ret['__labelvalidate']->listbox=false;
    2426. 

  2426.     $ret['__nextalias']=XFieldDef::objectFactory((object)array('FIELD'=>'__nextalias','FTYPE'=>'XShortTextDef','COMPULSORY'=>1,
    2427. 

  2427. 							       'LABEL'=>XLabels::getSysLabel('xmodtable','uiinsert_okalias','text')));
    2428. 

  2428.     $ret['__nextalias']->listbox=false;
    2429. 

  2429.     return $ret;
    2430. 

  2430.   }
    2431. 

  2431. 

  2432.   /// Prepare l'insertion d'une fiche
    2433. 

  2433.   function insert($ar) {
    2434. 

  2434.     $p=new XParam($ar,array());
    2435. 

  2435.     $ar['table']=$this->table;
    2436. 

  2436.     $options=$p->get('options');
    2437. 

  2437.     $options['PUBLISH']['value']=($this->defaultispublished?'1':'2');
    2438. 

  2438.     $ar['options']=$options;
    2439. 

  2439.     $tplentry=$p->get('tplentry');
    2440. 

  2440.     $ar['tplentry']=TZR_RETURN_DATA;
    2441. 

  2441.     $ar['fieldssec']=$this->getFieldsSec($ar);
    2442. 

  2442.     $ar['module_filter']=$this->getFilter(true,$ar);  // filtre pour les SelectBox
    2443. 

  2443.     if(empty($ar['fmoid'])) $ar['fmoid']=$this->_moid;
    2444. 

  2444.     $submodcontext=$this->subModuleContext($ar);
    2445. 

  2445.     // insertion en sous fiche, remplir le lien
    2446. 

  2446.     if($submodcontext)
    2447. 

  2447.       $ar['options'][$submodcontext['_linkedfields'][0]]['value']=$submodcontext['_parentoids'][0];
    2448. 

  2448.     $r2=$this->xset->input($ar);
    2449. 

  2449.     // choix du templates d'affichage s'il existe
    2450. 

  2450.     if(!empty($this->_templates) && !empty($this->templates)) {
    2451. 

  2451.       $r=$this->_templates->display(array('oid'=>$this->templates,'_options'=>array('error'=>'return'),'tplentry'=>TZR_RETURN_DATA));
    2452. 

  2452.       XShell::toScreen1($tplentry.'t',$r);
    2453. 

  2453.     }
    2454. 

  2454.     if($this->captcha) $r2['captcha']=$this->createCaptcha($ar);
    2455. 

  2455.     return XShell::toScreen1($tplentry,$r2);
    2456. 

  2456.   }
    2457. 

  2457. 

  2458.   /// Insere une nouvelle fiche
    2459. 

  2459.   function procInsert($ar) {
    2460. 

  2460.     $p=new XParam($ar,array('_applyrules'=>true));
    2461. 

  2461.     $tplentry=$p->get('tplentry');
    2462. 

  2462.     $noworkflow=$p->get('_noworkflow');
    2463. 

  2463.     $applyrules=$p->get('_applyrules');
    2464. 

  2464.     if($this->procInsertCtrl($ar)) {
    2465. 

  2465.       $ar['table']=$this->table;
    2466. 

  2466.       $ar['tplentry']=TZR_RETURN_DATA;
    2467. 

  2467.       $ar['fieldssec']=$this->getFieldsSec($ar);
    2468. 

  2468.       if(empty($ar['fmoid'])) $ar['fmoid']=$this->_moid;
    2469. 

  2469.       // recuperation du contexte sous module
    2470. 

  2470.       $submodcontext=$this->subModuleContext($ar);
    2471. 

  2471.       if($submodcontext) // insertion en sous fiche, autoriser le champ lien
    2472. 

  2472.         $ar['fieldssec'][$submodcontext['_linkedfield'][0]]='rw';
    2473. 

  2473.       if(!$p->is_set('PUBLISH')) $ar['PUBLISH']=($this->defaultispublished?1:2);
    2474. 

  2474.       $r=$this->xset->procInput($ar);
    2475. 

  2475.       if(empty($noworkflow) && XModule::getMoid(XMODWORKFLOW_TOID)) {
    2476. 

  2476. 	$umod=XModule::singletonFactory(XMODWORKFLOW_TOID);
    2477. 

  2477. 	$umod->checkAndRun($this, $this, $r['oid'], 'new');
    2478. 

  2478.       }
    2479. 

  2479.       if($applyrules) {
    2480. 

  2480. 	XModRule::applyRules($this,$r['oid']);
    2481. 

  2481.       }
    2482. 

  2482.       if($this->object_sec && $this->owner_sec)
    2483. 

  2483. 	$GLOBALS['XUSER']->setUserAccess(get_class($this),$this->_moid,XShell::getLangData(),$r['oid'],'admin');
    2484. 

  2484.       if(in_array($this->savenext,array('display','edit')) && $tplentry!=TZR_RETURN_DATA){
    2485. 

  2485. 	XShell::setnext($GLOBALS['TZR_SESSION_MANAGER']::complete_self(true, true).'&moid='.$this->_moid.'&function='.$this->savenext.'&'.
    2486. 

  2486. 			'template=xmodtable/'.($this->savenext == 'display' ? 'view' : 'edit').'.html&tplentry=br&oid='.
    2487. 

  2487.                         $r['oid'].@$submodcontext['urlparms']/* vide si pas sous module */);
    2488. 

  2488.       }elseif($p->get('_nextmode')=='edit') {
    2489. 

  2489. 	if(XShell::admini_mode()) {
    2490. 

  2490. 	  XShell::setNext('&moid='.$this->_moid.'&function=edit&template=xmodtable/edit.html&tplentry=br&oid='.$r['oid'].@$submodcontext['urlparms']/* vide si pas sous module */);
    2491. 

  2491. 	}else{
    2492. 

  2492. 	  XShell::setTemplates('xmodtable/edit.html');
    2493. 

  2493. 	  XShell::setNext('');
    2494. 

  2494. 	  return $this->edit(array('oid'=>$r['oid'],'tplentry'=>'br','_parentoids'=>$subModuleContext['_parentoids'],
    2495. 

  2495. 				   '_linkedfields'=>$subModuleContext['_linkedfields']));
    2496. 

  2496. 	}
    2497. 

  2497.       }
    2498. 

  2498.     }else{
    2499. 

  2499.       if (XShell::admini_mode()) {
    2500. 

  2500.         unset($_REQUEST['skip'], $_REQUEST['_skip']);
    2501. 

  2501.         XShell::changeTemplate('xmodtable/new.html');
    2502. 

  2502.         XShell::setNext();
    2503. 

  2503.       }
    2504. 

  2504.       $ar['options']=$this->xset->prepareReEdit($ar);
    2505. 

  2505.       $ar['tplentry']='br';
    2506. 

  2506.       return $this->insert($ar);
    2507. 

  2507.     }
    2508. 

  2508.     return XShell::toScreen1($tplentry, $r);
    2509. 

  2509.   }
    2510. 

  2510. 

  2511.   public function UIEdit_display($ar) {
    2512. 

  2512.     $fs['__oid']=XFieldDef::objectFactory((object)array(
    2513. 

  2513.       'FIELD'=>'__oid', 'FTYPE'=>'XLinkDef', 'COMPULSORY'=>1, 'TARGET'=>$this->table,
    2514. 

  2514.       'LABEL'=>XLabels::getSysLabel('xmodtable','record','text')));
    2515. 

  2515.     $fs['__oid']->autocomplete=0;
    2516. 

  2516.     $fs['__selectedfields']=XFieldDef::objectFactory((object)array(
    2517. 

  2517.       'FIELD'=>'__selectedfields', 'FTYPE'=>'XTableFieldDef', 'MULTIVALUED'=>1, 
    2518. 

  2518.       'TARGET'=>$this->table,
    2519. 

  2519.       'LABEL'=>XLabels::getSysLabel('general','fields','text')));
    2520. 

  2520.     $fs['__selectedfields']->doublebox=1;
    2521. 

  2521.     $fs['__usegroup']=XFieldDef::objectFactory((object)array(
    2522. 

  2522.       'FIELD'=>'__usegroup', 'FTYPE'=>'XBoolDef', 'MULTIVALUED'=>0, 'COMPULSORY'=>false,
    2523. 

  2523.       'LABEL'=>XLabels::getSysLabel('xmodtable','uiinsert_dispfgroup','text')));
    2524. 

  2524.     $fs['__usegroup']->default = 2;
    2525. 

  2525.         
    2526. 

  2526.     // choix des sous-modules et de leurs champs
    2527. 

  2527.     $ssmod_grp = XLabels::getSysLabel('xmodule','ssmod','text');
    2528. 

  2528.     for($i=1; $i<=$this->submodmax; $i++) {
    2529. 

  2529.       if ($this->{'ssmod'.$i}) {
    2530. 

  2530.         $mod = XModule::objectFactory($this->{'ssmod'.$i});
    2531. 

  2531.         $fs['__view_'.$this->{'ssmod'.$i}]=XFieldDef::objectFactory((object)array(
    2532. 

  2532.           'FIELD'=>'__view_'.$this->{'ssmod'.$i}, 'FTYPE'=>'XBoolDef', 'MULTIVALUED'=>0,
    2533. 

  2533.           'COMPULSORY'=>false,
    2534. 

  2534.           'LABEL'=>XLabels::getSysLabel('general','view','text').' '.$mod->modulename));
    2535. 

  2535.         $fs['__view_'.$this->{'ssmod'.$i}]->default = 2;
    2536. 

  2536.         $fs['__view_'.$this->{'ssmod'.$i}]->fgroup = $ssmod_grp;
    2537. 

  2537.         
    2538. 

  2538.         $fs['__selectedfields_'.$this->{'ssmod'.$i}]=XFieldDef::objectFactory((object)array(
    2539. 

  2539.           'FIELD'=>'__selectedfields_'.$this->{'ssmod'.$i}, 'FTYPE'=>'XTableFieldDef','MULTIVALUED'=>1,
    2540. 

  2540.           'TARGET'=>$mod->table,
    2541. 

  2541.           'LABEL'=>XLabels::getSysLabel('general','fields','text').' '.$mod->modulename));
    2542. 

  2542.         $fs['__selectedfields_'.$this->{'ssmod'.$i}]->doublebox = 1;
    2543. 

  2543.         $fs['__selectedfields_'.$this->{'ssmod'.$i}]->fgroup = $ssmod_grp;
    2544. 

  2544.       }
    2545. 

  2545.     }
    2546. 

  2546.     foreach($fs as $fn=>&$f){
    2547. 

  2547.       $value=(is_array($ar[$fn])?implode('||',$ar[$fn]):$ar[$fn]);
    2548. 

  2548.       $o=$f->edit($ar[$fn]);
    2549. 

  2549.       $ret['o'.$fn]=$ret['fields_object'][]=$o;
    2550. 

  2550.     }
    2551. 

  2551.     return $ret;
    2552. 

  2552.   }
    2553. 

  2553.   public function UIProcEdit_display($ar) {
    2554. 

  2554.     $p = new XParam($ar);
    2555. 

  2555.     $params['__oid'] = $p->get('__oid');
    2556. 

  2556.     if(is_array($p->get('__selectedfields'))) $params['__selectedfields'] = implode('||', $p->get('__selectedfields'));
    2557. 

  2557.     else $params['__selectedfields']=$p->get('__selectedfields');
    2558. 

  2558.     $xbool=new XBoolDef();
    2559. 

  2559.     $xbool->field='__usegroup';
    2560. 

  2560.     $tmp=$xbool->post_edit($p->get('__usegroup'),$opt=array('__usegroup_HID'=>$p->get('__usegroup_HID')));
    2561. 

  2561.     $params['__usegroup']=$tmp->raw;
    2562. 

  2562.     for($i=1; $i<=$this->submodmax; $i++) {
    2563. 

  2563.       if ($this->{'ssmod'.$i}) {
    2564. 

  2564.         $xbool->field = '__view_'.$this->{'ssmod'.$i};
    2565. 

  2565.         $tmp = $xbool->post_edit($p->get('__view_'.$this->{'ssmod'.$i}), $opt = array('__view_'.$this->{'ssmod'.$i}.'_HID' => $p->get('__view_'.$this->{'ssmod'.$i}.'_HID')));
    2566. 

  2566.         $params['__view_'.$this->{'ssmod'.$i}] = $tmp->raw;
    2567. 

  2567.         $params['__selectedfields_'.$this->{'ssmod'.$i}] = implode('||', $p->get('__selectedfields_'.$this->{'ssmod'.$i}));
    2568. 

  2568.       }
    2569. 

  2569.     }
    2570. 

  2570.     return $params;
    2571. 

  2571.   }
    2572. 

  2572.   public function UIView_display($params) {
    2573. 

  2573.     $p = new XParam($params);
    2574. 

  2574.     $showsubmodules = 0	;
    2575. 

  2575.     $requested_submodules=array();
    2576. 

  2576.     $options=array();
    2577. 

  2577.     $oid = $p->get('__oid');
    2578. 

  2578.     if (!empty($_REQUEST['oid'])) {
    2579. 

  2579.       $oid = $_REQUEST['oid'];
    2580. 

  2580.     }
    2581. 

  2581.     // controle des droits
    2582. 

  2582.     if (!$this->secure($oid, 'display'))
    2583. 

  2583.       return false;
    2584. 

  2584.     
    2585. 

  2585.     // gestion des sous-modules
    2586. 

  2586.     for($i=1; $i<=$this->submodmax; $i++) {
    2587. 

  2587.       if ($this->{'ssmod'.$i} && $params['__view_'.$this->{'ssmod'.$i}] == 1) {
    2588. 

  2588.         $requested_submodules[] = $this->{'ssmod'.$i};
    2589. 

  2589.         $options[$this->{'ssmod'.$i}]['selectedfields'] = explode('||', $params['__selectedfields_'.$this->{'ssmod'.$i}]);
    2590. 

  2590.         $showsubmodules = 1;
    2591. 

  2591.       }
    2592. 

  2592.     }
    2593. 

  2593.     
    2594. 

  2594.     $result = $this->display(array(
    2595. 

  2595.       'tplentry' => TZR_RETURN_DATA,
    2596. 

  2596.       'oid' => $oid,
    2597. 

  2597.       'selectedfields' => explode('||',$params['__selectedfields']),
    2598. 

  2598.       'ssmoid' => 'all',
    2599. 

  2599.       'requested_submodules' => $requested_submodules,
    2600. 

  2600.       'options' => $options,
    2601. 

  2601.       '_options' => array('genpublishtag' => false, 'error'=>'return')
    2602. 

  2602.     ));
    2603. 

  2603.     if(!is_array($result))
    2604. 

  2604.       $result = array('message'=>$result);
    2605. 

  2605.     // canonical link
    2606. 

  2606.     if (!empty($_REQUEST['alias'])) 
    2607. 

  2607.       header('Link: <'.$GLOBALS['HOME_ROOT_URL'].$_REQUEST['alias'].'.html?oid='.$oid.'&keywords='.rewriteToAscii($result['link']).'>; rel="canonical"');
    2608. 

  2608.     
    2609. 

  2609.     // si on vient d'une liste
    2610. 

  2610.     if (!empty($_REQUEST['from']) && !empty($_REQUEST['oid'])) {
    2611. 

  2611.       // test que l'oid appartient à une liste
    2612. 

  2612.       $oids = $_SESSION['oids_'.$_REQUEST['from']['itoid']];
    2613. 

  2613.       if (($current_index = array_search($oid, $oids)) !== false) {
    2614. 

  2614.         $result['_from']['alias'] = $_REQUEST['from']['alias'];
    2615. 

  2615.         $result['_from']['oidit'] = $_REQUEST['from']['oidit'];
    2616. 

  2616.         $result['_from']['itoid'] = $_REQUEST['from']['itoid'];
    2617. 

  2617.         $result['_prev_oid'] = $oids[$current_index-1];
    2618. 

  2618.         $result['_next_oid'] = $oids[$current_index+1];
    2619. 

  2619.       }
    2620. 

  2620.     }
    2621. 

  2621.     // indiquer au template d'afficher les sous-modules
    2622. 

  2622.     $result['_showsubmodules'] = $showsubmodules;
    2623. 

  2623.     return $result;
    2624. 

  2624.   }
    2625. 

  2625.   
    2626. 

  2626.   public function &display($ar) {
    2627. 

  2627.     $p=new XParam($ar,array());
    2628. 

  2628.     $oid=$p->get('oid');
    2629. 

  2629.     $tplentry=$p->get('tplentry');
    2630. 

  2630.     $ssmoid=$p->get('ssmoid');
    2631. 

  2631.     // On demande l'affiche d'un sous module d'une fiche seulement
    2632. 

  2632.     if(!empty($ssmoid) || $ssmoid=='all'){
    2633. 

  2633.       $ssmods=array();
    2634. 

  2634.       for($i=1;$i<=$this->submodmax;$i++) {
    2635. 

  2635. 	$f='ssmod'.$i;
    2636. 

  2636. 	$ssmods[$i]=$this->$f;
    2637. 

  2637.       }
    2638. 

  2638.       if($ssmoid!='all' && !in_array($ssmoid,$ssmods)) return;
    2639. 

  2639.       $r2=array('oid'=>$oid);
    2640. 

  2640.     }
    2641. 

  2641.     if(empty($ssmoid) || $ssmoid=='all'){
    2642. 

  2642.       // Gestion de la nav page/page
    2643. 

  2643.       if($this->interactive){
    2644. 

  2644. 	if($p->is_set('navdir')){
    2645. 

  2645. 	  list($navprev, $navnext)=$this->mkNavParms($ar);
    2646. 

  2646. 	  if($p->get('navdir')=='next') $_REQUEST['oid']=$navnext;
    2647. 

  2647. 	  else $_REQUEST['oid']=$navprev;
    2648. 

  2648. 	}
    2649. 

  2649. 	$this->setNavActions($p->get('oid'), 'display', 'xmodtable/view.html');
    2650. 

  2650. 	if($this->trackaccess) $ar['accesslog']=1;
    2651. 

  2651.       }
    2652. 

  2652.       $oid=$p->get('oid');
    2653. 

  2653.       $ar['table']=$this->table;
    2654. 

  2654.       $ar['tplentry']=TZR_RETURN_DATA;
    2655. 

  2655.       if(empty($ar['fmoid'])) $ar['fmoid']=$this->_moid;
    2656. 

  2656.       $ar['fieldssec']=$this->getFieldsSec($ar);
    2657. 

  2657.       $ar['_filter'] = $this->getFilter(true,$ar);
    2658. 

  2658.       $r2=$this->xset->display($ar);
    2659. 

  2659.       // choix du templates d'affichage s'il existe
    2660. 

  2660.       if(!empty($this->_templates) && !empty($this->templates)) {
    2661. 

  2661. 	$r=&$this->_templates->display(array('oid'=>$this->templates,'_options'=>array('error'=>'return'),'tplentry'=>TZR_RETURN_DATA));
    2662. 

  2662. 	XShell::toScreen1($tplentry.'t',$r);
    2663. 

  2663.       }
    2664. 

  2664.       if(XShell::admini_mode() && $this->object_sec) {
    2665. 

  2665. 	$acl=$GLOBALS['XUSER']->listObjectAccess($this, XShell::getLangData(),$oid);
    2666. 

  2666. 	$r2=array_merge($r2, $acl);
    2667. 

  2667. 	$sec=$GLOBALS['XUSER']->getObjectAccess($this, XShell::getLangData(),$oid);
    2668. 

  2668. 	$sec=array_flip($sec[0]);
    2669. 

  2669. 	$r2['object_sec']=$sec;
    2670. 

  2670.       }
    2671. 

  2671.     }
    2672. 

  2672.     // passage du context sous module
    2673. 

  2673.     if (XShell::admini_mode()) {
    2674. 

  2674.       $submodcontext = $this->subModuleContext($ar);
    2675. 

  2675.       $r2['urlparms'] = @$submodcontext['urlparms'];
    2676. 

  2676.     }
    2677. 

  2677.     if(is_array($r2)) $this->setSubModules($ar, $r2);
    2678. 

  2678.     return XShell::toScreen1($tplentry,$r2);
    2679. 

  2679.   }
    2680. 

  2680. 

  2681.   /// Recupere la securité des champs
    2682. 

  2682.   function getFieldsSec($ar){
    2683. 

  2683.     if(!empty($ar['fieldssec']) && is_array($ar['fieldssec'])) return array_merge($this->fieldssec,$ar['fieldssec']);
    2684. 

  2684.     else return $this->fieldssec;
    2685. 

  2685.   }
    2686. 

  2686. 

  2687.   /// Recherche les data (browse) des sous modules
    2688. 

  2688.   function getSubModules($dependentOnly = false) {
    2689. 

  2689.     $ssmods=array();
    2690. 

  2690.     for($i=1;$i<=$this->submodmax;$i++) {
    2691. 

  2691.       if ($dependentOnly && !$this->{'ssmoddependent'.$i})
    2692. 

  2692.         continue;
    2693. 

  2693.       $f='ssmod'.$i;
    2694. 

  2694.       $ssmods[$i]=$this->$f;
    2695. 

  2695.     }
    2696. 

  2696.     $r = array();
    2697. 

  2697.     foreach($ssmods as $i=>$mymoid) {
    2698. 

  2698.       if(!empty($mymoid)) {
    2699. 

  2699. 	$mod1=XModule::objectFactory($mymoid);
    2700. 

  2700. 	if(!is_object($mod1)) continue;
    2701. 

  2701. 	$tab1=&$mod1->xset;
    2702. 

  2702. 	// recherche des liens qui pointent vers moi
    2703. 

  2703. 	unset($linkfield);
    2704. 

  2704. 	unset($fieldname);
    2705. 

  2705. 	$fieldname=$this->{'ssmodfield'.$i};
    2706. 

  2706. 	if(!empty($fieldname)) {
    2707. 

  2707. 	  $o=$tab1->getField($fieldname);
    2708. 

  2708. 	  if(!empty($o)) {
    2709. 

  2709. 	    $linkfield = $fieldname;
    2710. 

  2710. 	  }
    2711. 

  2711. 	}
    2712. 

  2712. 	if(empty($linkfield)) {
    2713. 

  2713. 	  $links1=$tab1->getXLinkDefs();
    2714. 

  2714. 	  foreach($links1 as $j=>$field) {
    2715. 

  2715. 	    $o=$tab1->getField($field);
    2716. 

  2716. 	    if($o->get_target()==$this->table)
    2717. 

  2717. 	      $linkfield = $field;
    2718. 

  2718. 	  }
    2719. 

  2719. 	}
    2720. 

  2720. 	if (!empty($linkfield)) {
    2721. 

  2721. 	  $r[]= array('moid'=>$mymoid, 'xset'=>$tab1, 'linkfield'=>$linkfield, 'mod'=>$mod1);
    2722. 

  2722. 	}
    2723. 

  2723.       }
    2724. 

  2724.     }
    2725. 

  2725.     return $r;
    2726. 

  2726.   }
    2727. 

  2727. 

  2728.   function hasSubModules($moid=NULL){
    2729. 

  2729.     for($i=1;$i<=$this->submodmax;$i++) {
    2730. 

  2730.       $f='ssmod'.$i;
    2731. 

  2731.       $tmoid=$this->$f;
    2732. 

  2732.       if(!empty($tmoid) && (empty($moid) || $tmoid==$moid)) return true;
    2733. 

  2733.     }
    2734. 

  2734.     return false;
    2735. 

  2735.   }
    2736. 

  2736. 

  2737.   /// Recherche des données dans les sous-modules, en lecture
    2738. 

  2738.   /// ssmoid => all pour calculer tous les sous-modules, 
    2739. 

  2739.   ///           ou moid du sous-module demandé
    2740. 

  2740.   /// requested_submodules => tableau des moid des sous-modules à calculer (défaut tous)
    2741. 

  2741.   ///                         l'ordre des sous-modules est conservé
    2742. 

  2742.   function setSubModules($ar, &$r) {
    2743. 

  2743.     $p=new XParam($ar,array());
    2744. 

  2744.     $options=$p->get('options');
    2745. 

  2745.     $ssmoid=$p->get('ssmoid');
    2746. 

  2746.     // traitement des sous modules
    2747. 

  2747.     $ssmods=array();
    2748. 

  2748.     for($i=1;$i<=$this->submodmax;$i++) {
    2749. 

  2749.       $f='ssmod'.$i;
    2750. 

  2750.       $moid=$this->$f;
    2751. 

  2751.       if(!empty($ssmoid) && $ssmoid!='all' && $moid!=$ssmoid) continue;
    2752. 

  2752.       $ssmods[$i]=$moid;
    2753. 

  2753.     }
    2754. 

  2754.     $requested_submodules = $p->get('requested_submodules');
    2755. 

  2755.     $ssfield=array();
    2756. 

  2756.     foreach($ssmods as $i=>$mymoid) {
    2757. 

  2757.       if (isset($requested_submodules) && !in_array($mymoid, $requested_submodules)) {
    2758. 

  2758.         $r['__ssmod'][]=array();
    2759. 

  2759.         $r['__ssaccess'][]=array();
    2760. 

  2760.         $r['__ssinsert'][]=false;
    2761. 

  2761.         $r['__ssprops'][]=array();
    2762. 

  2762.         continue;
    2763. 

  2763.       }
    2764. 

  2764.       if(!empty($mymoid)) {
    2765. 

  2765. 	// recherche du module concerné par la sous-fiche
    2766. 

  2766. 	$mod1=XModule::objectFactory($mymoid);
    2767. 

  2767. 	if(!is_object($mod1)) continue;
    2768. 

  2768. 	$sec=$mod1->getAccess();
    2769. 

  2769. 	$ins=$mod1->secure(NULL,'insert');
    2770. 

  2770. 	if(isset($sec['ro']) || (isset($sec['list']) && $mod1->object_sec)){
    2771. 

  2771. 	  // recherche de la table qui contient les données
    2772. 

  2772. 	  $tab1=&$mod1->xset;
    2773. 

  2773. 

  2774. 	  // on change le titre si nécessaire
    2775. 

  2775. 	  if(!empty($this->{'ssmodtitle'.$i})) $mod1->modulename=$this->{'ssmodtitle'.$i};
    2776. 

  2776. 	  // on regarde si le champ a ete fixe
    2777. 

  2777. 	  $linkfield=$this->{'ssmodfield'.$i};
    2778. 

  2778. 	  if(!$tab1->fieldExists($linkfield)) $linkfield=NULL;
    2779. 

  2779. 

  2780. 	  // recherche des liens qui pointent vers moi
    2781. 

  2781. 	  if(empty($linkfield)) $links1=&$tab1->getXLinkDefs(NULL,$this->table);
    2782. 

  2782. 	  if(!empty($links1)) list($foo,$linkfield)=each($links1);
    2783. 

  2783. 

  2784. 	  // on fait le browse si on a trouve le champ
    2785. 

  2785. 	  if(!empty($linkfield)) {
    2786. 

  2786. 	    $order1=$p->get('_order');
    2787. 

  2787. 	    $order1=$order1[$mod1->_moid];
    2788. 

  2788. 	    if(empty($order1)) $order1=$mod1->order;
    2789. 

  2789. 	    if(!empty($ssmoid) || !XShell::admini_mode()){
    2790. 

  2790. 	      if(!empty($options[$mymoid]['selectedfields'])){
    2791. 

  2791. 		if($listfield=$options[$mymoid]['selectedfields']=='all') $listfield=$tab1->getFieldsList();
    2792. 

  2792. 		else $listfield=$options[$mymoid]['selectedfields'];
    2793. 

  2793. 	      } else {
    2794. 

  2794.                 $listfield=$tab1->browsableFields();
    2795. 

  2795.               }
    2796. 

  2796. 	    }else{
    2797. 

  2797. 	      $listfield=array('KOID');
    2798. 

  2798. 	    }
    2799. 

  2799. 	    $tmp1=array_flip($listfield);
    2800. 

  2800. 	    if(isset($tmp1[$linkfield])) unset($tmp1[$linkfield]);
    2801. 

  2801. 	    $tmp2=array_flip($tmp1);
    2802. 

  2802. 	    // donneer une chance a une classe fille d'étendre le browse des sous fiches
    2803. 

  2803. 	    if (isset($options[$mymoid]['cond'])) {
    2804. 

  2804.               $cond = $options[$mymoid]['cond'];
    2805. 

  2805.               $cond[$linkfield] = array('=',$r['oid']);
    2806. 

  2806.             } else
    2807. 

  2807.               $cond = array($linkfield=>array('=',$r['oid']));
    2808. 

  2808. 	    if(!empty($r['oid'])){
    2809. 

  2809. 	      $select=$tab1->select_query(array('order'=>$order1, 'cond'=>$cond, 'where' => $options[$mymoid]['where']));
    2810. 

  2810. 	      $params=array('ssmodule'=>&$mod1,
    2811. 

  2811. 			    'issmodule'=>$i,
    2812. 

  2812. 			    'parentoid'=>$r['oid'],
    2813. 

  2813. 			    'linkedfield'=>$linkfield,
    2814. 

  2814. 			    'select'=>$select,
    2815. 

  2815. 			    'selectedfields'=>$tmp2,
    2816. 

  2816. 			    'selectedtypes'=>array(),
    2817. 

  2817. 			    'selectedprops'=>array(),
    2818. 

  2818. 			    'options' => $options[$mymoid]);
    2819. 

  2819. 	      $b1 = &$this->browseSubModule($ar, $params, $r);
    2820. 

  2820. 	    }else{
    2821. 

  2821. 	      $params=array('ssmodule'=>&$mod1,
    2822. 

  2822. 			    'issmodule'=>$i,
    2823. 

  2823. 			    'parentoid'=>'',
    2824. 

  2824. 			    'linkedfield'=>$linkfield,
    2825. 

  2825. 			    'select'=>'select KOID from '.$mod1->table.' order by KOID limit 1',
    2826. 

  2826. 			    'selectedfields'=>$tmp2,
    2827. 

  2827. 			    'selectedtypes'=>array(),
    2828. 

  2828. 			    'selectedprops'=>array(),
    2829. 

  2829.                             'options' => $options[$mymoid]);
    2830. 

  2830. 	      $b1 = &$this->browseSubModule($ar, $params, $r);
    2831. 

  2831. 	    }
    2832. 

  2832. 

  2833. 	    // preparation des données pour affichage
    2834. 

  2834. 	    $r['__ssmod'][]=$b1;
    2835. 

  2835. 	    $r['__ssaccess'][]=$sec;
    2836. 

  2836. 	    $r['__ssinsert'][]=$ins;
    2837. 

  2837. 	    $r['__ssprops'][]=get_object_vars($mod1);
    2838. 

  2838. 	    $r['__ssprops'][count($r['__ssprops'])-1]['linkedfield']= $linkfield;
    2839. 

  2839. 	    $r['__ssprops'][count($r['__ssprops'])-1]['activate_additem']= $this->{'ssmodactivate_additem'.$i};
    2840. 

  2840. 	  }
    2841. 

  2841. 	}else{
    2842. 

  2842. 	  $r['__ssmod'][]=array();
    2843. 

  2843. 	  $r['__ssaccess'][]=$sec;
    2844. 

  2844. 	  $r['__ssinsert'][]=$ins;
    2845. 

  2845. 	  $r['__ssprops'][]=get_object_vars($mod1);
    2846. 

  2846. 	  $r['__ssprops'][count($r['__ssprops'])-1]['linkedfield']= $linkfield;
    2847. 

  2847. 	  $r['__ssprops'][count($r['__ssprops'])-1]['activate_additem']= $this->{'ssmodactivate_additem'.$i};
    2848. 

  2848. 	}
    2849. 

  2849.       }
    2850. 

  2850.     }
    2851. 

  2851.   }
    2852. 

  2852. 

  2853.   /// Appel au browse d'un module dans le cadre de l'edition ou de la visualisation de la fiche parente
    2854. 

  2854.   function &browseSubModule(&$ar, &$browseparm, &$result){
    2855. 

  2855.     $p = new XParam($ar, array());
    2856. 

  2856.     // champ de tri
    2857. 

  2857.     $orderfield = $p->get('orderfield');
    2858. 

  2858.     // module trie
    2859. 

  2859.     $ordermoid = $p->get('ssmodorder');
    2860. 

  2860.     // champ en edition demande(s)
    2861. 

  2861.     $editfield = $p->get('editfield');
    2862. 

  2862.     // module en edition
    2863. 

  2863.     $editmoid = $p->get('ssmoidedit');
    2864. 

  2864.     // module en enregistrement
    2865. 

  2865.     $savemoid = $p->get('ssmoidsave');
    2866. 

  2866.     // faudrait extaire les champs du champ editer pour pas avoir de conflits ...
    2867. 

  2867.     $editfields = false;
    2868. 

  2868.     $select = $browseparm['select'];
    2869. 

  2869.     $selectedfields = $browseparm['selectedfields'];
    2870. 

  2870.     $ssmodule = &$browseparm['ssmodule'];
    2871. 

  2871.     $filter = $browseparm['filter'];
    2872. 

  2872.     $order = '';
    2873. 

  2873.     $editfields = '';
    2874. 

  2874.     // traitement de la mise   jour des sous fiches
    2875. 

  2875.     if (!empty($editfield) && $savemoid == $browseparm['ssmodule']->_moid) {
    2876. 

  2876.       if ($editfield != 'all')
    2877. 

  2877. 	$editfieldsname = array($editfield);
    2878. 

  2878.       else
    2879. 

  2879. 	$editfieldsname = $browseparm['selectedfields'];
    2880. 

  2880. 

  2881.       $lar = array();
    2882. 

  2882.       // on construit toutes les valeurs dans un contexte qui sera local
    2883. 

  2883.       foreach($editfieldsname as $foo=>$fn){
    2884. 

  2884. 	$lar[$fn] = $p->get($fn);
    2885. 

  2885. 	$lar[$fn.'_HID'] = $p->get($fn.'_HID');
    2886. 

  2886. 	// a completer pour les champs complexes etc ?
    2887. 

  2887. 	// semble ok texte, oui/non, date, liens liste de valeurs
    2888. 

  2888.       }
    2889. 

  2889.       $lar['tplentry']=TZR_RETURN_DATA;
    2890. 

  2890.       $lar['editfields']=$editfieldsname;
    2891. 

  2891.       // Selection des oid uniquement du module concerné
    2892. 

  2892.       $lar['oid']=$p->get('ssoid'.$savemoid);
    2893. 

  2893.       $lar['_options']=array('local'=>true);
    2894. 

  2894.       if($browseparm['ssmodule']->object_sec){
    2895. 

  2895.         foreach($lar['oid'] as $i=>$foo){
    2896. 

  2896.           $sec=$browseparm['ssmodule']->secure($foo,'procEdit');
    2897. 

  2897.           if(!$sec) unset($lar['oid'][$i]);
    2898. 

  2898.         }
    2899. 

  2899.       }else{
    2900. 

  2900.         $sec=$browseparm['ssmodule']->secure('','procEdit');
    2901. 

  2901.         if(!$sec) $lar['oid']=array();
    2902. 

  2902.       }
    2903. 

  2903.       if(!empty($lar['oid'])){
    2904. 

  2904.         $browseparm['ssmodule']->procEdit($lar);
    2905. 

  2905.       }
    2906. 

  2906.       // ajout des prop pour focus
    2907. 

  2907.       $browseparm['ssmodule']->focused=true;
    2908. 

  2908.     }
    2909. 

  2909. 

  2910.     // traitement du passage en mode edit
    2911. 

  2911.     if (!empty($editfield) && $editmoid == $browseparm['ssmodule']->_moid) {
    2912. 

  2912.       if ($editfield == 'all')
    2913. 

  2913. 	$editfields = $browseparm['selectedfields'];
    2914. 

  2914.       else
    2915. 

  2915. 	$editfields = array($editfield);
    2916. 

  2916.       // ajout des prop
    2917. 

  2917.       $browseparm['ssmodule']->focused=true;
    2918. 

  2918.       $browseparm['ssmodule']->edited=true;
    2919. 

  2919.       $browseparm['ssmodule']->editfield=$editfield;
    2920. 

  2920.     }
    2921. 

  2921.     // traitement du tri
    2922. 

  2922.     if (!empty($orderfield) && $ordermoid == $browseparm['ssmodule']->_moid){
    2923. 

  2923.       $order = $orderfield;
    2924. 

  2924.       $browseparm['ssmodule']->focused=true;
    2925. 

  2925.     }
    2926. 

  2926. 

  2927.     // traitement du contexte sous module
    2928. 

  2928.     if ($submodcontext = $this->subModuleContext($ar)) {
    2929. 

  2929.       $parentoids = $submodcontext['_parentoids'];
    2930. 

  2930.       array_unshift($parentoids, $browseparm['parentoid']);
    2931. 

  2931.       $linkedfields = $submodcontext['_linkedfields'];
    2932. 

  2932.       array_unshift($linkedfields, $browseparm['linkedfield']);
    2933. 

  2933.     } else {
    2934. 

  2934.       $parentoids = array($browseparm['parentoid']);
    2935. 

  2935.       $linkedfields = array($browseparm['linkedfield']);
    2936. 

  2936.     }
    2937. 

  2937.     // browse std du sous module avec les editfields et order
    2938. 

  2938.     return $ssmodule->browse(array('_options'=>array('local'=>true),
    2939. 

  2939.                                   'select'=>$select,
    2940. 

  2940.                                   'tplentry'=>TZR_RETURN_DATA,
    2941. 

  2941.                                   'selected'=>'0',
    2942. 

  2942.                                   'selectedfields'=>$selectedfields,
    2943. 

  2943.                                   'pagesize'=>'200',
    2944. 

  2944.                                   'editfields'=>$editfields,
    2945. 

  2945.                                   'order'=>$order,
    2946. 

  2946.                                   'assubmodule'=>true,
    2947. 

  2947.                                   'selectedfields'=>$selectedfields,
    2948. 

  2948.                                   'options'=>$browseparm['options'],
    2949. 

  2949.                                   'nocount'=>$browseparm['options']['nocount'],
    2950. 

  2950.                                   '_parentoids'=>$parentoids,
    2951. 

  2951.                                   '_linkedfields'=>$linkedfields
    2952. 

  2952.                                   )
    2953. 

  2953.                             );
    2954. 

  2954.   }
    2955. 

  2955. 

  2956.   function status($ar=NULL) {
    2957. 

  2957.     parent::status($ar);
    2958. 

  2958.     $b1=&XShell::from_screen('br');
    2959. 

  2959.     $nb=0;
    2960. 

  2960.     if(!empty($b1['lines_oid']))
    2961. 

  2961.       $nb=max(count($b1['lines_oid']),$b1['last']);
    2962. 

  2962.     if($nb==1)
    2963. 

  2963.       $msg=$nb.' '.XLabels::getSysLabel('xmodtable','record','text');
    2964. 

  2964.     elseif($nb>1)
    2965. 

  2965.       $msg=$nb.' '.XLabels::getSysLabel('xmodtable','records','text');
    2966. 

  2966.     $msg1=XShell::from_screen('imod','status');
    2967. 

  2967.     if(empty($msg)) $msg1=array();
    2968. 

  2968.     if(!empty($msg)) $msg1[]=$msg;
    2969. 

  2969.     XShell::toScreen2('imod','status',$msg1);
    2970. 

  2970.   }
    2971. 

  2971. 

  2972.   /// Liste des tables utilisé par le module
    2973. 

  2973.   public function usedTables() {
    2974. 

  2974.     return array($this->table);
    2975. 

  2975.   }
    2976. 

  2976.   /// Liste des tables dont les objects sont consultables dans le module
    2977. 

  2977.   public function usedMainTables() {
    2978. 

  2978.     return array($this->table);
    2979. 

  2979.   }
    2980. 

  2980.   /// Liste des boid utilisés par le module
    2981. 

  2981.   function usedBoids() {
    2982. 

  2982.     return array($this->xset->getBoid());
    2983. 

  2983.   }
    2984. 

  2984. 

  2985.   protected function _exportXLS(&$ar) {
    2986. 

  2986.     require_once('add-ons/PHPExcel/PHPExcel.php');
    2987. 

  2987. 

  2988.     $p=new XParam($ar);
    2989. 

  2989.     $fmt=$p->get('fmt');
    2990. 

  2990.     $tplentry=$p->get('tplentry');
    2991. 

  2991.     $oidisvisible=$p->get('oidisvisible');
    2992. 

  2992.     $fname=$p->get('fname');
    2993. 

  2993.     if(empty($fname)){
    2994. 

  2994.       if(!empty($this->modulename)) $fname='Export '.$this->modulename;
    2995. 

  2995.       else $fname='Export '.$this->xset->table_title;
    2996. 

  2996.       $fname = rewriteToAscii($fname);
    2997. 

  2997.     }
    2998. 

  2998.     $fname=str_replace(' ','_',removeaccents($fname));
    2999. 

  2999.     $br=&XShell::from_screen('br');
    3000. 

  3000.     $ss=new PHPExcel();
    3001. 

  3001.     $ss->setActiveSheetIndex(0);
    3002. 

  3002.     $ws=$ss->getActiveSheet();
    3003. 

  3003.     $ws->setTitle('Main');
    3004. 

  3004. 

  3005.     if (isset($oidisvisible)) {
    3006. 

  3006.       $ws->SetCellValue('A1','OID');
    3007. 

  3007.       $pad = 1;
    3008. 

  3008.     } else
    3009. 

  3009.       $pad = 0;
    3010. 

  3010.     foreach($br['header_fields'] as $j => &$f1) {
    3011. 

  3011.       $l=$f1->get_label();
    3012. 

  3012.       convert_charset($l,TZR_INTERNAL_CHARSET,'UTF-8');
    3013. 

  3013.       $ws->setCellValueByColumnAndRow($j+$pad,1,$l);
    3014. 

  3014.     }
    3015. 

  3015.     $ws->getStyle('A1:'.PHPExcel_Cell::stringFromColumnIndex($j+$pad).'1')->getFont()->setBold(true);
    3016. 

  3016.     foreach($br['lines_oid'] as $i=>$oid) {
    3017. 

  3017.       if($pad == 1) $ws->SetCellValue('A'.($i+2),$oid);
    3018. 

  3018.       foreach($br['header_fields'] as $j => &$f1) {
    3019. 

  3019. 	$f1->writeXLS($ws,$i+2,$j+$pad,$br['lines_o'.$f1->field][$i],0,$ss);
    3020. 

  3020.       }
    3021. 

  3021.     }
    3022. 

  3022.     if($fmt=='xl07'){
    3023. 

  3023.       require_once('add-ons/PHPExcel/PHPExcel/Writer/Excel2007.php');
    3024. 

  3024.       $objWriter=new PHPExcel_Writer_Excel2007($ss);
    3025. 

  3025.     }else{
    3026. 

  3026.       require_once('add-ons/PHPExcel/PHPExcel/Writer/Excel5.php');
    3027. 

  3027.       $objWriter=new PHPExcel_Writer_Excel5($ss);
    3028. 

  3028.     }
    3029. 

  3029.     if($tplentry==TZR_RETURN_DATA) {
    3030. 

  3030.       $fname=TZR_TMP_DIR.uniqid().'-'.$fname;
    3031. 

  3031.       if($fmt=='xl07')
    3032. 

  3032.         $fname .= '.xlsx';
    3033. 

  3033.       else
    3034. 

  3034.         $fname .= '.xls';
    3035. 

  3035.       $objWriter->save($fname);
    3036. 

  3036.       return $fname;
    3037. 

  3037.     }else{
    3038. 

  3038.       ob_clean();
    3039. 

  3039.       if($fmt=='xl07'){
    3040. 

  3040. 	header('Content-Disposition: attachment;filename="'.$fname.'.xlsx"');
    3041. 

  3041. 	header('Cache-Control: max-age=0');
    3042. 

  3042. 	header('Content-Type: application/vnd.openxmlformats-officedocument.spreadsheetml.sheet');
    3043. 

  3043. 	$objWriter->save('php://output');
    3044. 

  3044.       }else{
    3045. 

  3045. 	header('Content-Disposition: attachment;filename="'.$fname.'.xls"');
    3046. 

  3046. 	header('Cache-Control: max-age=0');
    3047. 

  3047. 	header('Content-Type: application/vnd.ms-excel');
    3048. 

  3048. 	$objWriter->save('php://output');
    3049. 

  3049.       }
    3050. 

  3050.       die();
    3051. 

  3051.     }
    3052. 

  3052.   }
    3053. 

  3053. 

  3054.   protected function _exportHTML(&$ar) {
    3055. 

  3055.     $p=new XParam($ar,array());
    3056. 

  3056.     $tplentry=$p->get('tplentry');
    3057. 

  3057.     $fname=$p->get('fname');
    3058. 

  3058.     if(empty($fname)){
    3059. 

  3059.       if(!empty($this->modulename)) $fname='Export '.$this->modulename;
    3060. 

  3060.       else $fname='Export '.$this->xset->table_title;
    3061. 

  3061.     }
    3062. 

  3062.     $fname=str_replace(' ','_',removeaccents($fname)).'.html';
    3063. 

  3063. 

  3064.     $txt='<html>';
    3065. 

  3065.     $txt.='<style type="text/css">';
    3066. 

  3066.     $txt.='TH {text-align: right;vertical-align:top;}';
    3067. 

  3067.     $txt.='</style>';
    3068. 

  3068.     $txt.='<body>';
    3069. 

  3069. 

  3070.     $br=&XShell::from_screen('br');
    3071. 

  3071.     $table = $p->get('table');
    3072. 

  3072.     $oidisvisible = $p->get('oidisvisible');
    3073. 

  3073.     if($table=='table') {
    3074. 

  3074.       $txt.='<table>';
    3075. 

  3075.       if($oidisvisible) $ext='OID';
    3076. 

  3076.       $txt.='<tr><th><!-- OID -->'.$ext.'</th>';
    3077. 

  3077.       foreach($br['header_fields'] as $j => &$f1) {
    3078. 

  3078. 	$l=$f1->get_label();
    3079. 

  3079. 	$txt.='<th class="tzr-exp-header">'.$l.'<!-- Field:'.$j.' --></th>';
    3080. 

  3080.       }
    3081. 

  3081.       $txt.='</tr>'."\n";
    3082. 

  3082.       for($i=0;$i<count($br['lines_oid']);$i++) {
    3083. 

  3083. 	$oid=$br['lines_oid'][$i];
    3084. 

  3084. 	if($oidisvisible) $ext=$oid;
    3085. 

  3085. 	$txt.='<tr><td><!-- '.$oid.' -->'.$ext.'</td>';
    3086. 

  3086. 	foreach($br['header_fields'] as $j => &$f1) {
    3087. 

  3087. 	  $c=$f1->field;
    3088. 

  3088. 	  $txt.='<td class="export-'.$c.'">';
    3089. 

  3089. 	  if(!empty($br['lines_o'.$c][$i]->url)) {
    3090. 

  3090. 	    $lab=$br['lines_o'.$c][$i]->text;
    3091. 

  3091. 	    if(empty($lab)) $lab='Link';
    3092. 

  3092. 	    $txt2='<a href="'.$GLOBALS['HOME_ROOT_URL'].$br['lines_o'.$c][$i]->url.'">'.$lab.'</a>';
    3093. 

  3093. 	    $txt.=$br['lines_o'.$c][$i]->html;
    3094. 

  3094. 	  }else{
    3095. 

  3095. 	    $txt.=$br['lines_o'.$c][$i]->html;
    3096. 

  3096. 	  }
    3097. 

  3097. 	  $txt.='</td>';
    3098. 

  3098. 	}
    3099. 

  3099. 	$txt.='</tr>'."\n";
    3100. 

  3100.       }
    3101. 

  3101.       $txt.='</table></body></html>';
    3102. 

  3102.     }elseif($table=='file') {
    3103. 

  3103.       for($i=0;$i<count($br['lines_oid']);$i++) {
    3104. 

  3104. 	$txt.='<table border="0" bgcolor="#DDDDDD" width="100%"><tr><td>Page #'.$i.'</td></tr></table>';
    3105. 

  3105. 	$txt.='<table id="'.$br['lines_oid'][$i].'">';
    3106. 

  3106. 	$txt.='<tr><th><label id="label-KOID">Object ID</label></th><td ID="content-KOID">'.$br['lines_oid'][$i].'</td></tr>';
    3107. 

  3107. 	foreach($br['header_fields'] as $j => &$f1) {
    3108. 

  3108. 	  $c=$f1->field;
    3109. 

  3109. 	  $txt.='<tr><th><label id="label-'.$c.'">'.$f1->label.'</label></th>';
    3110. 

  3110. 	  $txt.='<td ID="content-'.$c.'">'.$br['lines_o'.$c][$i]->html.'</td></tr>'."\n";
    3111. 

  3111. 	}
    3112. 

  3112. 	$txt.='</table>'."\n";
    3113. 

  3113.       }
    3114. 

  3114.       $txt.='</body></html>';
    3115. 

  3115.     }
    3116. 

  3116.     if($tplentry==TZR_RETURN_DATA){
    3117. 

  3117.       $fname=TZR_TMP_DIR.uniqid().'-'.$fname;
    3118. 

  3118.       file_put_contents($fname,$txt);
    3119. 

  3119.       return $fname;
    3120. 

  3120.     }else{
    3121. 

  3121.       die($txt);
    3122. 

  3122.     }
    3123. 

  3123.   }
    3124. 

  3124. 

  3125.   // Export d'un browse au format csv
    3126. 

  3126.   public function _exportCSV(&$ar) {
    3127. 

  3127.     $p= new XParam($ar,array());
    3128. 

  3128.     $tplentry=$p->get('tplentry');
    3129. 

  3129.     $fsep=$p->get('csvfsep');
    3130. 

  3130.     $textsep=$p->get('csvtextsep');
    3131. 

  3131.     $charset=stripslashes($p->get('csvcharset'));
    3132. 

  3132.     $oidisvisible=$p->get('oidisvisible');
    3133. 

  3133.     $exportfiles=$p->get('exportfiles');
    3134. 

  3134.     $selectedfields=$p->get('selectedfields');
    3135. 

  3135.     $fname=$p->get('fname');
    3136. 

  3136.     if(empty($fname)){
    3137. 

  3137.       if(!empty($this->modulename)) $fname='Export '.$this->modulename;
    3138. 

  3138.       else $fname='Export '.$this->xset->table_title;
    3139. 

  3139.     }
    3140. 

  3140.     $fname=str_replace(' ','_',removeaccents($fname)).'.csv';
    3141. 

  3141. 

  3142.     $br=&XShell::from_screen('br');
    3143. 

  3143.     $csv=$headers=array();
    3144. 

  3144.     if($oidisvisible) $headers[]='OID';
    3145. 

  3145.     foreach($br['header_fields'] as $j => &$f1) {
    3146. 

  3146.       $headers[]=$textsep.$f1->get_label().$textsep;
    3147. 

  3147.     }
    3148. 

  3148.     $csv[]=implode($fsep,$headers);
    3149. 

  3149.     foreach($br['lines_oid'] as $i=>$oid){
    3150. 

  3150.       $row=array();
    3151. 

  3151.       if($oidisvisible) $row[]=$br['lines_oid'][$i];
    3152. 

  3152.       foreach($br['header_fields'] as $j => &$f1) {
    3153. 

  3153. 	$row[]=$f1->writeCSV($br['lines_o'.$f1->field][$i],$textsep);
    3154. 

  3154.       }
    3155. 

  3155.       $csv[]=implode($fsep,$row);
    3156. 

  3156.     }
    3157. 

  3157.     $csv=implode("\r\n",$csv);
    3158. 

  3158.     convert_charset($csv,TZR_INTERNAL_CHARSET,$charset);
    3159. 

  3159. 

  3160.     if($tplentry==TZR_RETURN_DATA){
    3161. 

  3161.       $fname=TZR_TMP_DIR.uniqid().'-'.$fname;
    3162. 

  3162.       file_put_contents($fname,$txt);
    3163. 

  3163.       return $fname;
    3164. 

  3164.     }else{
    3165. 

  3165.       ob_clean();
    3166. 

  3166.       header('Content-Type: text/csv; charset='.$charset);
    3167. 

  3167.       header('Content-Transfer-Encoding:'.$charset);
    3168. 

  3168.       header('Content-disposition: attachment; filename='.$fname);
    3169. 

  3169.       header('Content-Length: '.strlen($csv));
    3170. 

  3170.       echo $csv;
    3171. 

  3171.       exit(0);
    3172. 

  3172.     }
    3173. 

  3173.   }
    3174. 

  3174. 

  3175.   public function export($ar) {
    3176. 

  3176.     $p=new XParam($ar,array());
    3177. 

  3177.     $fmt=$p->get('fmt');
    3178. 

  3178.     $target=$p->get('_target');
    3179. 

  3179.     $linkedfield=$p->get('_linkedfield');
    3180. 

  3180.     $tplentry=$p->get('tplentry');
    3181. 

  3181.     $exportfiles=$p->get('exportfiles');
    3182. 

  3182.     $exportftp=$p->get('exportftp');
    3183. 

  3183.     $selectedfields=$p->get('selectedfields');
    3184. 

  3184.     $ar['selected']='0';
    3185. 

  3185.     $ar['pagesize']='100000';
    3186. 

  3186.     $ar['norow']=1;
    3187. 

  3187.     $ar['nodef']=1;
    3188. 

  3188.     $ar['_options']=array('genpublishtag'=>false);
    3189. 

  3189.     if($fmt=='xl' || $fmt=='xl07') $ar['_format']='application/excel';
    3190. 

  3190.     $oldinteractive=$this->interactive;
    3191. 

  3191.     $this->interactive=false;
    3192. 

  3192.     $query = $this->getContextQuery($ar);
    3193. 

  3193.     if(!empty($target) && ($target!=$this->_moid)){
    3194. 

  3194.       $mod=XModule::objectFactory($target);
    3195. 

  3195.       if($mod->secure('','export')){
    3196. 

  3196.         $oids = $this->xset->browseOids(array('select' => $query, 'local' => true));
    3197. 

  3197.         $rs = selectQuery('select KOID from '.$mod->table.' where '.$linkedfield.' in ("'.implode('","',$oids).'")');
    3198. 

  3198.         unset( $ar['_selected']);
    3199. 

  3199.         while($ors=$rs->fetch()) {
    3200. 

  3200.           $ar['_selected'][$ors['KOID']] = 'on';
    3201. 

  3201.         }
    3202. 

  3202.         return $mod->export($ar);
    3203. 

  3203.       } else {
    3204. 

  3204.         XShell::redirect2auth();
    3205. 

  3205.       }
    3206. 

  3206.     }
    3207. 

  3207.     $ar['select']=$query;
    3208. 

  3208.     $browse = $this->browse($ar);
    3209. 

  3209.     $this->interactive=$oldinteractive;
    3210. 

  3210.     if($exportfiles || $exportftp) $ar['tplentry']=TZR_RETURN_DATA;
    3211. 

  3211.     if($fmt=='xl' || $fmt=='xl07') $file_name=$this->_exportXLS($ar);
    3212. 

  3212.     if($fmt=='html') $file_name=$this->_exportHTML($ar);
    3213. 

  3213.     if($fmt=='csv') $file_name=$this->_exportCSV($ar);
    3214. 

  3214.     if($exportftp){
    3215. 

  3215.       $scheduler=new XModScheduler();
    3216. 

  3216.       $o=array();
    3217. 

  3217.       $o['function']='exportFilesBatch';
    3218. 

  3218.       $o['uid']=getSessionVar('UID');
    3219. 

  3219.       $o['ftpserver']=$p->get('ftpserver');
    3220. 

  3220.       $o['ftplogin']=$p->get('ftplogin');
    3221. 

  3221.       $o['ftppassword']=$p->get('ftppassword');
    3222. 

  3222.       $o['select']=$query;
    3223. 

  3223.       $o['selectedfields']=$selectedfields;
    3224. 

  3224.       $o['fname']=$file_name;
    3225. 

  3225.       $roid=$scheduler->createJob($this->_moid,date('Y-m-d H:i:s'),'Export with files',$o,'',$file_name,NULL);
    3226. 

  3226.       XShell::setNext('template=basic/message-popup.html&message='.rawurlencode(XLabels::getSysLabel('xmodtable','exportfilescreated')).'&popupmode=1');
    3227. 

  3227.     }
    3228. 

  3228.     elseif($exportfiles) {
    3229. 

  3229.       $zip = $this->exportToZip($file_name, $browse);
    3230. 

  3230.       if ($zip['error']) {
    3231. 

  3231.         XShell::setNext('template=basic/message-popup.html&message='.rawurlencode($zip['message']).'&popupmode=1');
    3232. 

  3232.         return;
    3233. 

  3233.       }
    3234. 

  3234.       $zipsize = filesize(TZR_TMP_DIR.$zip['zipname']);
    3235. 

  3235.       if (!empty($GLOBALS['TZR_DLSTATS'][$this->table])
    3236. 

  3236.         && $GLOBALS['TZR_DLSTATS'][$this->table] == '_all')
    3237. 

  3237.         XModDLStats::trace($GLOBALS['XUSER']->_curoid, $this->_moid, $zip['zipname'], $zipsize);
    3238. 

  3238. 

  3239.       header('Content-type: application/zip');
    3240. 

  3240.       header('Content-Disposition: attachment; filename="' . $zip['zipname'] . '"');
    3241. 

  3241.       header('Content-length: ' . $zipsize);
    3242. 

  3242.       readfile(TZR_TMP_DIR.$zip['zipname']);
    3243. 

  3243.       unlink(TZR_TMP_DIR.$zip['zipname']);
    3244. 

  3244.     }
    3245. 

  3245.   }
    3246. 

  3246. 

  3247.   /// Permet d'exporter les fichiers via scheduler (est appelé suite à un export browse avec export des fichiers)
    3248. 

  3248.   function exportFilesBatch(XModScheduler &$scheduler,&$o,&$more){
    3249. 

  3249.     $ar=(array)$more;
    3250. 

  3250.     $ftpserver=$ar['ftpserver'];
    3251. 

  3251.     $ftplogin=$ar['ftplogin'];
    3252. 

  3252.     $ftppass=$ar['ftppassword'];
    3253. 

  3253.     $ftp=ftp_connect($ftpserver);
    3254. 

  3254.     if(!$ftp) $msg='Unable to connect to '.$ftpserver;
    3255. 

  3255.     else{
    3256. 

  3256.       $ftpl=ftp_login($ftp,$ftplogin,$ftppass);
    3257. 

  3257.       if(!$ftpl) $msg='Error logging into '.$ftpserver;
    3258. 

  3258.       else{
    3259. 

  3259.         $browse = $this->browse($ar);
    3260. 

  3260. 	$zip = $this->exportToZip($ar['fname'], $browse);
    3261. 

  3261. 	if($ret['error']){
    3262. 

  3262. 	  $msg=$ret['message'];
    3263. 

  3263. 	}else{
    3264. 

  3264. 	  $dir=$ret['dir'];
    3265. 

  3265.           $ftpp=ftp_put($ftp,$zip['zipname'],TZR_TMP_DIR.$zip['zipname'],FTP_BINARY);
    3266. 

  3266. 	  if(!$ftpp)
    3267. 

  3267.             $msg='Unable to send file '.$zip['zipname'].' on the ftp server '.$ftpserver;
    3268. 

  3268.           elseif (!empty($GLOBALS['TZR_DLSTATS'][$this->table])
    3269. 

  3269.                   && $GLOBALS['TZR_DLSTATS'][$this->table] == '_all')
    3270. 

  3270.             XModDLStats::trace($GLOBALS['XUSER']->_curoid, $this->_moid, $zip['zipname'], filesize($zip['zipname']));
    3271. 

  3271. 

  3272. 	}
    3273. 

  3273.       }
    3274. 

  3274.     }
    3275. 

  3275.     ftp_close($ftp);
    3276. 

  3276.     unlink(TZR_TMP_DIR.$zip['zipname']);
    3277. 

  3277.     if(!empty($msg))
    3278. 

  3278.       $msg=sprintf(XLabels::getSysLabel('xmodtable','exportfileserror'),$msg);
    3279. 

  3279.     else
    3280. 

  3280.       $msg=sprintf(XLabels::getSysLabel('xmodtable','exportfilesok'),$zip['zipname']);
    3281. 

  3281.     $GLOBALS['XUSER']->sendMail2User(sprintf(XLabels::getSysLabel('xmodtable','exportfilessub'),$this->modulename),$msg,$GLOBALS['XUSER']->email());
    3282. 

  3282.     return $msg;
    3283. 

  3283.   }
    3284. 

  3284. 

  3285.   /// Cree une archive zip avec le fichier d'export et les fichiers du module
    3286. 

  3286.   /// @param $file fichier exporte
    3287. 

  3287.   /// @param $browse browse des fiches a exporter
    3288. 

  3288.   /// @return array
    3289. 

  3289.   function exportToZip($file, &$browse){
    3290. 

  3290.     $ret = $this->exportFiles($browse);
    3291. 

  3291.     if($ret['error'])
    3292. 

  3292.       return $ret;
    3293. 

  3293.     $dir = $ret['dir'];
    3294. 

  3294.     $file_name = basename($file);
    3295. 

  3295.     $file_name = substr($file_name,strpos($file_name,'-')+1);
    3296. 

  3296.     $file_name = str_replace('.', '_'.date('Y-m-d_H-i-s').'.', $file_name);
    3297. 

  3297.     rename($file, TZR_TMP_DIR.$dir.'/'.$file_name);
    3298. 

  3298.     $zipname = $file_name.'.zip';
    3299. 

  3299.     exec('(cd '.TZR_TMP_DIR.$dir.';zip -rm ../'.$zipname.' . )2>&1 > /dev/null');
    3300. 

  3300.     rmdir(TZR_TMP_DIR.$dir);
    3301. 

  3301.     return  array('zipname'=>$zipname,'error'=>false);
    3302. 

  3302.   }
    3303. 

  3303. 

  3304.   /// Exporte les fichiers du module (copie dans un repertoire)
    3305. 

  3305.   /// @param $browse browse des fiches a exporter
    3306. 

  3306.   function exportFiles(&$browse){
    3307. 

  3307.     ini_set('max_execution_time', 600);
    3308. 

  3308.     $dirname = uniqid('exportfiles').'/';
    3309. 

  3309.     $dir=TZR_TMP_DIR.$dirname;
    3310. 

  3310.     $ret=mkdir($dir);
    3311. 

  3311.     if(!$ret){
    3312. 

  3312.       XDir::unlink($dir);
    3313. 

  3313.       return array('error'=>true,'message'=>'Can\'t create export dir');
    3314. 

  3314.     }
    3315. 

  3315.     $fields=array();
    3316. 

  3316.     foreach($browse['header_fields'] as $j=>$f) {
    3317. 

  3317.       if(in_array($f->ftype,array('XImageDef','XFileDef','XFolderDef'))){
    3318. 

  3318. 	$fields[$f->field]=$f->ftype;
    3319. 

  3319. 	$ret=mkdir($dir.$f->field.'/');
    3320. 

  3320. 	if(!$ret){
    3321. 

  3321. 	  XDir::unlink($dir);
    3322. 

  3322. 	  return array('error'=>true,'message'=>'Can\'t create export dir');
    3323. 

  3323. 	}
    3324. 

  3324.       }
    3325. 

  3325.     }
    3326. 

  3326.     foreach($browse['lines_oid'] as $i=>$oid) {
    3327. 

  3327.       foreach($fields as $field_name => $field_type) {
    3328. 

  3328.         $ofile = $browse['lines_o'.$field_name][$i];
    3329. 

  3329. 	if($field_type=='XImageDef' || $field_type=='XFileDef'){
    3330. 

  3330. 	  if(empty($ofile->filename)) continue;
    3331. 

  3331. // a voir, nom du fichier dans le zip
    3332. 

  3332. // 	  $ext=substr($ofile->originalname,strrpos($ofile->originalname,'.'));
    3333. 

  3333. // 	  $fn=basename($ofile->filename).$ext;
    3334. 

  3334.           $fn = $ofile->originalname;
    3335. 

  3335.           if ($ofile->filedef->gzipped == 1) {
    3336. 

  3336.               $fh = gzopen($ofile->filename, 'r');
    3337. 

  3337.               $content = gzread($fh, 100000000);
    3338. 

  3338.               gzclose($fh);
    3339. 

  3339.               $ret = file_put_contents($dir.$field_name.'/'.$fn, $content);
    3340. 

  3340.           } else
    3341. 

  3341.             $ret=copy($ofile->filename,$dir.$field_name.'/'.$fn);
    3342. 

  3342. 	  if(!$ret){
    3343. 

  3343. 	    XDir::unlink($dir);
    3344. 

  3344. 	    return array('error'=>true,'message'=>'Can\'t copy '.$ofile->filename);
    3345. 

  3345. 	  }
    3346. 

  3346. 	}elseif($field_type=='XFolderDef'){
    3347. 

  3347. 	  if(empty($ofile->catalog[0])) continue;
    3348. 

  3348. 	  $_ofile=$ofile->catalog[0];
    3349. 

  3349. 	  $dir2=basename(dirname($_ofile->filename)).'/';
    3350. 

  3350. 	  $ret=mkdir($dir.$dir2);
    3351. 

  3351. 	  if(!$ret){
    3352. 

  3352. 	    XDir::unlink($dir);
    3353. 

  3353. 	    return array('error'=>true,'message'=>'Can\'t copy '.$ofile->filename);
    3354. 

  3354. 	  }
    3355. 

  3355. 

  3356. 

  3357. 	  foreach($ofile->catalog as $k => $ofile_inside){
    3358. 

  3358. // a voir, nom du fichier dans le zip
    3359. 

  3359. // 	    $ext=substr($ofile_inside->originalname,strrpos($ofile_inside->originalname,'.'));
    3360. 

  3360. // 	    $fn=basename($ofile_inside->filename).$ext;
    3361. 

  3361.             $fn = $ofile_inside->originalname;
    3362. 

  3362.             if ($ofile_inside->filedef->gzipped == 1) {
    3363. 

  3363.               $fh = gzopen($ofile_inside->filename, 'r');
    3364. 

  3364.               $content = gzread($fh, 100000000);
    3365. 

  3365.               gzclose($fh);
    3366. 

  3366.               $ret = file_put_contents($dir.$dir2.$fn, $content);
    3367. 

  3367.             } else{
    3368. 

  3368. 		if (file_exists($ofile_inside->filename))
    3369. 

  3369.         	      $ret=copy($ofile_inside->filename,$dir.$dir2.$fn);
    3370. 

  3370. 	    }
    3371. 

  3371. 	    if(!$ret){
    3372. 

  3372. 	      XDir::unlink($dir);
    3373. 

  3373. 	      return array('error'=>true,'message'=>'Can\'t copy '.$ofile_inside->filename);
    3374. 

  3374. 	    }
    3375. 

  3375. 	  }
    3376. 

  3376. 	}
    3377. 

  3377.       }
    3378. 

  3378.     }
    3379. 

  3379.     return array('dir'=>$dirname,'error'=>false);
    3380. 

  3380.   }
    3381. 

  3381. 

  3382.   /// Fonction d'import automatisé des données
    3383. 

  3383.   function import($ar=NULL) {
    3384. 

  3384.     $p=new XParam($ar, array());
    3385. 

  3385.     $linestoskip=$p->get('linestoskip');
    3386. 

  3386.     $spec=$p->get('spec');
    3387. 

  3387.     $fieldsname=$p->get('fieldsname');
    3388. 

  3388.     if($spec=='default'){
    3389. 

  3389.       $infos=pathinfo($_FILES['file']['name']);
    3390. 

  3390.       if($infos['extension']=='xls') $format='xl';
    3391. 

  3391.       elseif($infos['extension']=='xlsx') $format='xl07';
    3392. 

  3392.       else $format='csv';
    3393. 

  3393.       $sxml='<?xml version="1.0"?><import><general format="'.$format.'" fieldsinheader="true"><linestoskip value="'.$linestoskip.'"></linestoskip><location></location><quote>"</quote><separator>;</separator><endofline></endofline><strategy clearbefore="false" updateifexists="true"></strategy><key></key></general><catalog><field tzr="KOID" name="KOID"></field><field tzr="KOID" name="OID"></field><field tzr="LANG" name="LANG"></field>';
    3394. 

  3394.       foreach($this->xset->desc as $fn=>&$f){
    3395. 

  3395. 	if($fieldsname=='label') $sxml.='<field tzr="'.$fn.'" name="'.$f->label.'"></field>';
    3396. 

  3396. 	else $sxml.='<field tzr="'.$fn.'" name="'.$fn.'"></field>';
    3397. 

  3397.       }
    3398. 

  3398.       $sxml.='</catalog></import>';
    3399. 

  3399.       $xml=simplexml_load_string($sxml);
    3400. 

  3400.       $file=$_FILES['file']['tmp_name'];
    3401. 

  3401.       $this->_import(array('spec'=>$xml,'file'=>$file));
    3402. 

  3402.     }else{
    3403. 

  3403.       return parent::import($ar);
    3404. 

  3404.     }
    3405. 

  3405.   }
    3406. 

  3406. 

  3407.   /// Sous fonction pour l'import automatisé
    3408. 

  3408.   function _import($ar=NULL) {
    3409. 

  3409.     $p=new XParam($ar, array());
    3410. 

  3410.     $spec=$p->get('spec');
    3411. 

  3411.     $imported=false;
    3412. 

  3412.     $dirpath=(string)$p->get('dir');
    3413. 

  3413.     if(empty($dirpath)) $dirpath=(string)$spec->general[0]->location;
    3414. 

  3414.     $file=$p->get('file');
    3415. 

  3415.     $lockfile=NULL;
    3416. 

  3416.     if(empty($file)) {
    3417. 

  3417.       $file=(string)$spec->general[0]->file;
    3418. 

  3418.       $lockfile=$file.'.ok';
    3419. 

  3419.     }
    3420. 

  3420.     // Manage actionbefore here
    3421. 

  3421.     if(property_exists($spec,'action') && property_exists($spec->action,'before')){
    3422. 

  3422.       $moidBefore = property_exists($spec->action->before,'moid')?(string)$spec->action->before->moid:false;
    3423. 

  3423.       $functionBefore = property_exists($spec->action->before,'function')?(string)$spec->action->before->function:false;
    3424. 

  3424.       if($moidBefore && $functionBefore){
    3425. 

  3425. 	XLogs::notice('XModTable::_import','Try to execute moid: '.$moidBefore.' function:'.$functionBefore);
    3426. 

  3426. 	$mod = XModule::objectFactory($moidBefore);
    3427. 

  3427. 	$mod->$functionBefore($ar);
    3428. 

  3428.       }
    3429. 

  3429.     }
    3430. 

  3430. 

  3431.     // Import d'un fichier
    3432. 

  3432.     if(!empty($file) && (empty($lockfile) || file_exists($lockfile))) {
    3433. 

  3433.       $ar['spec']=$spec;
    3434. 

  3434.       $ar['file']=$file;
    3435. 

  3435.       $imported=$this->_import_data($ar);
    3436. 

  3436.       if(!empty($lockfile)) @unlink($lockfile);
    3437. 

  3437.     }elseif(in_array($spec->general[0]['format'],array('csv','xl','xl07'))){
    3438. 

  3438.       // Import de csv depuis un repertoire
    3439. 

  3439.       XLogs::notice('XModTable::_import','module '.$this->_moid." $dirpath");
    3440. 

  3440.       $dir=opendir($dirpath);
    3441. 

  3441.       while($dir!==false && ($file=readdir($dir))!==false) {
    3442. 

  3442. 	if(preg_match('/(.*).(txt|csv|xml)/i',$file)) {
    3443. 

  3443. 	  $ar['file']=$dirpath.$file;
    3444. 

  3444. 	  $ar['spec']=$spec;
    3445. 

  3445. 	  $imported = $this->_import_data($ar);
    3446. 

  3446. 	}
    3447. 

  3447.       }
    3448. 

  3448.     }elseif($spec->general[0]['format']=='files'){
    3449. 

  3449.       // Import de fichier
    3450. 

  3450.       $ar['spec']=$spec;
    3451. 

  3451.       $imported=$this->_import_files($ar);
    3452. 

  3452.     }
    3453. 

  3453. 

  3454.     // Manage actionafter here
    3455. 

  3455.     if($imported){
    3456. 

  3456.       if(property_exists($spec,'action') && property_exists($spec->action,'after')){
    3457. 

  3457. 	$moidAfter = property_exists($spec->action->after,'moid')?(string)$spec->action->after->moid:false;
    3458. 

  3458. 	$functionAfter = property_exists($spec->action->after,'function')?(string)$spec->action->after->function:false;
    3459. 

  3459. 	if($moidAfter && $functionAfter){
    3460. 

  3460. 	  XLogs::notice('XModTable::_import','Try to execute After function moid: '.$moidAfter.' function:'.$functionAfter);
    3461. 

  3461. 	  $mod = XModule::objectFactory($moidAfter);
    3462. 

  3462. 	  $mod->$functionAfter($ar);
    3463. 

  3463. 	}
    3464. 

  3464.       }
    3465. 

  3465.     }
    3466. 

  3466.   }
    3467. 

  3467. 

  3468.   /// Import des fichiers d'un dossier et ses sous dossiers (retourne true si au moins un fichier est importé)
    3469. 

  3469.   function _import_files($ar=NULL) {
    3470. 

  3470.     ini_set('max_execution_time', 600);
    3471. 

  3471.     $p=new XParam($ar, array());
    3472. 

  3472.     $found=false;
    3473. 

  3473.     $specs=$p->get('spec');
    3474. 

  3474.     $location=(string)$specs->general->location;
    3475. 

  3475.     @$filefield=(string)$specs->general->filefield;
    3476. 

  3476.     if(empty($filefield)){
    3477. 

  3477.       $flist=$this->xset->getFieldsList(array('XImageDef'));
    3478. 

  3478.       if(!empty($flist)) $filefield=$flist[0];
    3479. 

  3479.       else return false;
    3480. 

  3480.     }
    3481. 

  3481.     if(!empty($specs->general->authext)){
    3482. 

  3482.       $authext=explode(',',$specs->general->authext);
    3483. 

  3483.       foreach($authext as $i=>$ext) $authext[$i]=strtolower($ext);
    3484. 

  3484.     }
    3485. 

  3485.     @$titlefield=(string)$specs->general->titlefield;
    3486. 

  3486.     @$importedfield=(string)$specs->general->importedfield;
    3487. 

  3487.     @$unique=(string)$specs->general[0]->strategy[0]['unique'];
    3488. 

  3488.     @$updateifexist=(boolean)$specs->general[0]->strategy[0]['updateifexists'];
    3489. 

  3489.     @$notdel=(string)$specs->general[0]->strategy[0]['notdeletefiles'];
    3490. 

  3490.     if($unique && $unique!='false') $unique=true;
    3491. 

  3491.     else $unique=false;
    3492. 

  3492.     if($updateifexist && $updateifexist!='false') $updateifexist=true;
    3493. 

  3493.     else $updateifexist=false;
    3494. 

  3494.     if($notdel && $notdel!='false') $notdel=true;
    3495. 

  3495.     else $notdel=false;
    3496. 

  3496.     $return=false;
    3497. 

  3497.     $xmime=XMimeTypes::getInstance();
    3498. 

  3498.     $files=XDir::scan($location);
    3499. 

  3499.     foreach($files as $i=>$file) {
    3500. 

  3500.       $filename=$file;
    3501. 

  3501.       $info=pathinfo($filename);
    3502. 

  3502.       if(!empty($authext)){
    3503. 

  3503.  	if(!in_array(strtolower($info['extension']),$authext)) continue;
    3504. 

  3504.       }
    3505. 

  3505.       if(filetype($filename)=='file') {
    3506. 

  3506.  	$return=true;
    3507. 

  3507.  	$ar1=array();
    3508. 

  3508.  	$value=array('tmp_name'=>$filename,'type'=>$xmime->getValidMime('',$filename,$filename),'name'=>$info['basename'],'title'=>'',
    3509. 

  3509.  		     'size'=>filesize($filename));
    3510. 

  3510.  	$ar1[$filefield]=$value;
    3511. 

  3511.  	if(!empty($titlefield)){
    3512. 

  3512.  	  $ar1[$titlefield]=$info['filename'];
    3513. 

  3513.  	  if($unique) $ar1['_unique']=array($titlefield);
    3514. 

  3514.  	  if($updateifexist) $ar1['_updateifexists']=1;
    3515. 

  3515.  	}
    3516. 

  3516.  	if($importedfield){
    3517. 

  3517. 	  $f1=&$this->xset->getField($importedfield);
    3518. 

  3518.  	  if($f1->get_ftype()=='XBoolDef') $ar1[$importedfield]=1;
    3519. 

  3519.  	  else $ar1[$importedfield]=date('Y-m-d H:i:s');
    3520. 

  3520.  	}
    3521. 

  3521.  	if($notdel) $ar1['options'][$filefield]['del']=false;
    3522. 

  3522.  	$ar1['_allfields']=true;
    3523. 

  3523.   	$ret=$this->xset->procInput($ar1);
    3524. 

  3524.       }
    3525. 

  3525.     }
    3526. 

  3526.     return $return;
    3527. 

  3527.   }
    3528. 

  3528. 

  3529.   /// Importe un fichier (csv/xls/xlsx) dans la base. Renvoie true si au moins une ligne est importée
    3530. 

  3530.   function _import_data($ar=NULL) {
    3531. 

  3531.     $p=new XParam($ar, array());
    3532. 

  3532.     $found=false;
    3533. 

  3533.     $file=$p->get('file');
    3534. 

  3534.     XLogs::notice('XModTable::_import_data','module '.$this->_moid.' file='.$file);
    3535. 

  3535.     $specs=$p->get('spec');
    3536. 

  3536.     $data=@file_get_contents($file);
    3537. 

  3537.     if(file_exists($file)) {
    3538. 

  3538.       $format=(string)$specs->general[0]['format'];
    3539. 

  3539.       if($format=='csv'){
    3540. 

  3540. 	$charset=(string)$specs->general[0]['charset'];
    3541. 

  3541. 	if($charset) convert_charset($data,$charset,TZR_INTERNAL_CHARSET);
    3542. 

  3542. 	$data=_getCSVData($data,$specs);
    3543. 

  3543.       }elseif($format=='xl'){
    3544. 

  3544. 	$data=_getXLSData($file,'Excel5');
    3545. 

  3545.       }elseif($format=='xl07'){
    3546. 

  3546. 	$data=_getXLSData($file,'Excel2007');
    3547. 

  3547.       }
    3548. 

  3548.       if(!empty($data)) $found = $this->_doImportData($data, $specs);
    3549. 

  3549.       @unlink($file);
    3550. 

  3550.     }
    3551. 

  3551.     return $found;
    3552. 

  3552.   }
    3553. 

  3553. 

  3554.   ///effective import data from array ($data) returned by getXXXdata
    3555. 

  3555.   protected function _doImportData(&$data, &$specs) {
    3556. 

  3556.     $unique=array();
    3557. 

  3557.     $found=false;
    3558. 

  3558.     $koid=(string)$specs->general[0]->koid[0];
    3559. 

  3559.     $updateifexists=(string)$specs->general[0]->strategy[0]['updateifexists'];
    3560. 

  3560.     if(!empty($updateifexists) && $updateifexists!='false') $updateifexists=true;
    3561. 

  3561.     else $updateifexists=false;
    3562. 

  3562.     $keys=$specs->general[0]->key;
    3563. 

  3563.     $unique=array();
    3564. 

  3564.     foreach($specs->general->key as $i=>$u){
    3565. 

  3565.       if(!empty($u)) $unique[]=(string)$u;
    3566. 

  3566.     }
    3567. 

  3567.     if(!empty($unique)) $unique[]='LANG';
    3568. 

  3568.     // Vide la table si demandé
    3569. 

  3569.     $clearbefore=(string)$specs->general[0]->strategy[0]['clearbefore'];
    3570. 

  3570.     if(!empty($clearbefore) && ($clearbefore!='false')) {
    3571. 

  3571.       XLogs::notice('XModTable::_import_data','clearing before importing');
    3572. 

  3572.       $deleterequest=(string)$specs->general[0]->strategy[0]->clearrequest[0];
    3573. 

  3573.       if(!empty($deleterequest)) $this->xset->clear($deleterequest);
    3574. 

  3574.       else $this->xset->clear();
    3575. 

  3575.     }
    3576. 

  3576. 

  3577.     // Creation des entetes
    3578. 

  3578.     $head=array();
    3579. 

  3579.     $fieldsinheader=(string)$specs->general[0]['fieldsinheader'];
    3580. 

  3580.     if(!empty($fieldsinheader) && $fieldsinheader!='false') $fieldsinheader=true;
    3581. 

  3581.     else $fieldsinheader=false;
    3582. 

  3582.     if($fieldsinheader){
    3583. 

  3583.       $line=$data[0];
    3584. 

  3584.       foreach($line as $i=>$field){
    3585. 

  3585.  	if($field) $head[mb_strtoupper($field,TZR_INTERNAL_CHARSET)]=$i;
    3586. 

  3586.       }
    3587. 

  3587.       unset($data[0]);
    3588. 

  3588.     }else{
    3589. 

  3589.       $j=0;
    3590. 

  3590.       foreach($specs->catalog->field as $i=>$field){
    3591. 

  3591. 	$head[(string)$field['tzr']]=$j;
    3592. 

  3592. 	$j++;
    3593. 

  3593.       }
    3594. 

  3594.     }
    3595. 

  3595.     // Supprime les lignes à ne pas importer
    3596. 

  3596.     $linestoskip=(string)$specs->general[0]->linestoskip[0]['value'];
    3597. 

  3597.     if(!empty($linestoskip)) {
    3598. 

  3598.       for($i=0;$i<$linestoskip;$i++) unset($data[$i]);
    3599. 

  3599.     }
    3600. 

  3600. 

  3601.     $message='<dl>';
    3602. 

  3602.     $tot=$ok=$nok=$update=0;
    3603. 

  3603.     $incompletelines=$emptylines=array();
    3604. 

  3604.     foreach($data as $line=>&$tuple) {
    3605. 

  3605.       $tot++;
    3606. 

  3606.       $message.='<dt><strong>- Line '.($line+1).'</strong></dt>';
    3607. 

  3607.       if(count($tuple)<count($head)){
    3608. 

  3608. 	$message.='<dd>Incomplete line</dd>';
    3609. 

  3609. 	$incompletelines[]=$line+1;
    3610. 

  3610. 	continue;
    3611. 

  3611.       }
    3612. 

  3612.       $isempty=true;
    3613. 

  3613.       foreach($tuple as $i=>$value){
    3614. 

  3614. 	if(!empty($value)){
    3615. 

  3615. 	  $isempty=false;
    3616. 

  3616. 	  break;
    3617. 

  3617. 	}
    3618. 

  3618.       }
    3619. 

  3619.       if($isempty){
    3620. 

  3620. 	$message.='<dd>Empty line</dd>';
    3621. 

  3621. 	$emptylines[]=$linet+1;
    3622. 

  3622. 	continue;
    3623. 

  3623.       }
    3624. 

  3624.       $input=array();
    3625. 

  3625.       $refsql= array();
    3626. 

  3626.       $input['_unique']=$unique;
    3627. 

  3627.       // Specifie la langue par defaut de l'entrée
    3628. 

  3628.       if($specs->general[0]->lang[0]) $input['LANG']=$specs->general[0]->lang[0];
    3629. 

  3629.       else $input['LANG']=TZR_DEFAULT_LANG;
    3630. 

  3630.       foreach($specs->catalog->field as $i=>$field) {
    3631. 

  3631. 	$tzrfield=(string)$field['tzr'];
    3632. 

  3632. 	$namefield=(string)$field['name'];
    3633. 

  3633. 	$skip=(string)$field['skip'];
    3634. 

  3634. 	if(!empty($skip) && $skip!='false') continue;
    3635. 

  3635. 	if($fieldsinheader && $namefield) $value=$tuple[$head[mb_strtoupper($namefield, TZR_INTERNAL_CHARSET)]];
    3636. 

  3636. 	else $value=$tuple[$head[$tzrfield]];
    3637. 

  3637. 	if($tzrfield != 'LANG' AND in_array($tzrfield,$unique)){
    3638. 

  3638.             $refsql[] = "$tzrfield like '".trim($value)."'";
    3639. 

  3639.         }
    3640. 

  3640.  	// On passe les champs du catalogue qui ne sont pas dans le fichier
    3641. 

  3641. 	if($value===NULL) continue;
    3642. 

  3642. 	$defaultvalue=(string)$field->default[0];
    3643. 

  3643. 	if(!empty($tzrfield)) {
    3644. 

  3644.  	  if($tzrfield=='KOID'){
    3645. 

  3645.  	    if(empty($value)) break;
    3646. 

  3646.  	    if(strpos($value,$this->table.':')===0) $input[$tzrfield]=$value;
    3647. 

  3647.  	    else $input[$tzrfield]=$this->table.':'.$value;
    3648. 

  3648.  	  }elseif($tzrfield=='LANG') $input[$tzrfield]=$value;
    3649. 

  3649. 	  else{
    3650. 

  3650. 	    $v=$this->xset->getField($tzrfield);
    3651. 

  3651. 	    if(!is_object($v)){
    3652. 

  3652. 	      $message='Error : field "'.$tzrfield.'" doesn\'t exists<br>';
    3653. 

  3653. 	      break 2;
    3654. 

  3654. 	    }
    3655. 

  3655. 	    $ret=$v->import($value,$field);
    3656. 

  3656. 	    $input[$tzrfield]=$ret['value'];
    3657. 

  3657. 	    if(empty($input[$tzrfield]) && !empty($defaultvalue)) $input[$tzrfield]=$defaultvalue;
    3658. 

  3658. 	    if(!empty($ret['message'])) $message.='<dd>'.$ret['message'].'</dd>';
    3659. 

  3659. 	  }
    3660. 

  3660. 	}
    3661. 

  3661.       }
    3662. 

  3662.       // Recupere un eventuel oid
    3663. 

  3663.       if(!empty($koid)){
    3664. 

  3664. 	if(strpos($input[$koid],':')) $input['newoid']=$input[$koid];
    3665. 

  3665. 	else $input['newoid']=$this->table.':'.rewriteToAscii($input[$koid]);
    3666. 

  3666.       }elseif(!empty($input['KOID'])){
    3667. 

  3667. 	if(strpos($input['KOID'],':')) $input['newoid']=$input['KOID'];
    3668. 

  3668. 	else $input['newoid']=$this->table.':'.rewriteToAscii($input['KOID']);
    3669. 

  3669.       }elseif(!empty($refsql) && !empty($updateifexists)){
    3670. 

  3670. 	$sele = 'SELECT KOID FROM '.$this->table.' WHERE LANG = \''.TZR_DEFAULT_LANG.'\' AND '.implode(' AND ',$refsql);
    3671. 

  3671. 	$rsk = &selectQuery($sele);
    3672. 

  3672. 	$Koid ='';
    3673. 

  3673. 	if($rsk && $rsk->rowCount()==1 && $orsk = $rsk->fetch(PDO::FETCH_ASSOC)){
    3674. 

  3674. 	  $input['newoid'] = $orsk['KOID'];
    3675. 

  3675. 	}
    3676. 

  3676.       }
    3677. 

  3677.       $input['_updateifexists']=$updateifexists;
    3678. 

  3678.       $input['_delayed']=false;
    3679. 

  3679.       $input['_nolog']=true;
    3680. 

  3680.       $input['tplentry']=TZR_RETURN_DATA;
    3681. 

  3681. 

  3682.       if(empty($input['LANG']) || $input['LANG']==TZR_DEFAULT_LANG || $this->xset->getTranslatable()==3){
    3683. 

  3683. 	if(!empty($input['LANG']) && $input['LANG']!=TZR_DEFAULT_LANG && !$this->secure('','procInsert',$u=NULL,$input['LANG'])){
    3684. 

  3684. 	  $message.='<dd>Write in '.$input['LANG'].' is not allowed</dd>';
    3685. 

  3685. 	  $nok++;
    3686. 

  3686. 	}else{
    3687. 

  3687. 	  $input['LANG_DATA']=$input['LANG'];
    3688. 

  3688. 	  $r=&$this->xset->procInput($input);
    3689. 

  3689. 	  if(!empty($r['oid'])){
    3690. 

  3690. 	    if(!$found) $found=true;
    3691. 

  3691. 	    $message.='<dd>Insert : success -> '.$r['oid'].'</dd>';
    3692. 

  3692. 	    $ok++;
    3693. 

  3693. 	  }elseif(empty($r['error'])){
    3694. 

  3694. 	    $message.='<dd>Insert : update an existing entry</dd>';
    3695. 

  3695. 	    $update++;
    3696. 

  3696. 	  }else{
    3697. 

  3697. 	    $message.='<dd>Insert : error ('.$r['message'].')</dd>';
    3698. 

  3698. 	    $nok++;
    3699. 

  3699. 	  }
    3700. 

  3700. 	}
    3701. 

  3701.       }elseif(!empty($input['newoid']) ){
    3702. 

  3702. 	if(!array_key_exists($input['LANG'],$GLOBALS['TZR_LANGUAGES'])){
    3703. 

  3703. 	  $message.='<dd>Lang '.$input['LANG'].' does not exist</dd>';
    3704. 

  3704. 	  $nok++;
    3705. 

  3705. 	}elseif($this->secure('','procEdit',$u=NULL,$input['LANG'])){
    3706. 

  3706. 	  $input['LANG_DATA']=$input['LANG'];
    3707. 

  3707.    	  if(!empty($input['newoid']))  $input['oid']=$input['newoid'];
    3708. 

  3708. 	  $r=&$this->xset->procEdit($input);
    3709. 

  3709. 	  $message.='<dd>Update '.$input['oid'].' in '.$input['LANG'].'</dd>';
    3710. 

  3710. 	  $update++;
    3711. 

  3711. 	}else{
    3712. 

  3712. 	  $message.='<dd>Write in '.$input['LANG'].' is not allowed</dd>';
    3713. 

  3713. 	  $nok++;
    3714. 

  3714. 	}
    3715. 

  3715.       }else{
    3716. 

  3716. 	$message.='<dd>Not default lang and no KOID</dd>';
    3717. 

  3717. 	$nok++;
    3718. 

  3718.       }
    3719. 

  3719.       unset($input);
    3720. 

  3720.     }
    3721. 

  3721.     $message.='</dl>';
    3722. 

  3722.     $message='Total : '.$tot.'<br>Insert : '.$ok.'<br>Update : '.$update.'<br>Error : '.$nok.'<br>'.
    3723. 

  3723.       'Empty lines : '.count($emptylines).' ('.implode(', ',$emptylines).')<br>'.
    3724. 

  3724.       'Incomplete line : '.count($incompletelines).' ('.implode(', ',$incompletelines).')<br>'.$message;
    3725. 

  3725.     XShell::toScreen2('','message',$message);
    3726. 

  3726.     return $found;
    3727. 

  3727.   }
    3728. 

  3728. 

  3729.   function sub($ar) {
    3730. 

  3730.     return parent::sub($ar);
    3731. 

  3731.   }
    3732. 

  3732.   protected function _lasttimestamp() {
    3733. 

  3733.     $upd=countSelectQuery('select ifnull(MAX(UPD),0) from '.$this->table);
    3734. 

  3734.     if($this->trackchanges && !$this->getFilter() && !$this->object_sec)
    3735. 

  3735.       $upd2=countSelectQuery('select ifnull(MAX(UPD),0) from LOGS where etype="delete" and comment like "%('.$this->table.':%"');
    3736. 

  3736.     else
    3737. 

  3737.       $upd2=0;
    3738. 

  3738.     return max($upd,$upd2);
    3739. 

  3739.   }
    3740. 

  3740. 

  3741. 

  3742.   /// rend la liste des fiches modifiees depuis ts et jusqu'a timestamp
    3743. 

  3743.   protected function _whatsNew($ts,$user, $group=NULL, $specs=NULL,$timestamp=NULL) {
    3744. 

  3744.     @list($oid,$details)=explode(';',$specs);
    3745. 

  3745.     $query='select KOID from '.$this->table.' where UPD >= "'.$ts. '" and UPD<"'.$timestamp.'"';
    3746. 

  3746.     $oids = $this->xset->browseOids(array('select'=>$query, 'pagesize'=>'99', 'tplentry'=>TZR_RETURN_DATA, '_filter'=>$this->getFilter()));
    3747. 

  3747.     $txt='';
    3748. 

  3748.     foreach ($oids as $oid) {
    3749. 

  3749.       $d1=$this->xset->display(array('_lastupdate'=>true,'tplentry'=>TZR_RETURN_DATA,'tlink'=>true,'oid'=>$oid,'_options'=>array('error'=>'return')));
    3750. 

  3750.       $url=$GLOBALS['TZR_SESSION_MANAGER']::admin_url(true,false).'&moid='.$this->_moid.'&function=display&oid='.$oid.'&tplentry=br&template=xmodtable/view.html&_direct=1';
    3751. 

  3751.       if(is_array($d1) && ($d1['lst_upd']['user']!=$user)) {
    3752. 

  3752. 	$when=$d1['oUPD']->html;
    3753. 

  3753. 	$who=$d1['lst_upd']['usernam'];
    3754. 

  3754. 	$what=XLabels::getSysLabel('general',$d1['lst_upd']['etype'],'text');;
    3755. 

  3755. 	$j=XLogs::getJournal($oid,NULL,$ts,$timestamp,$this->xset);
    3756. 

  3756. 	$modifs="<br/>";
    3757. 

  3757. 	$whoarray=array();
    3758. 

  3758. 	foreach($j['lines_journal'] as $entry=>$log) {
    3759. 

  3759. 	  if(!in_array($j['lines_ousernam'][$entry]->text, $whoarray)) 
    3760. 

  3760. 	    $whoarray[]=$j['lines_ousernam'][$entry]->text;
    3761. 

  3761. 	  $modifs.=implode('<br/>',$log);
    3762. 

  3762. 	  $modifs.='<br/>';
    3763. 

  3763. 	}
    3764. 

  3764. 	// construction du texte
    3765. 

  3765. 	$who=implode(', ',$whoarray);
    3766. 

  3766. 	$txt.='<li><a href="'.$url.'">'.$d1['tlink'].'</a> ('.$when.
    3767. 

  3767. 	  ($this->trackchanges?(', '.$who.', '.$what):'').')';
    3768. 

  3768. 	// on ajoute le detail des logs si abonnement avec detail
    3769. 

  3769. 	if($details && $this->trackchanges) {
    3770. 

  3770. 	  $txt.=$modifs;
    3771. 

  3771. 	}
    3772. 

  3772. 	$txt.='</li>';
    3773. 

  3773.       }
    3774. 

  3774.     }
    3775. 

  3775.     if($this->trackchanges && !$this->getFilter() && !$this->object_sec){
    3776. 

  3776.       $x=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS=LOGS');
    3777. 

  3777.       $rs=selectQuery('select * from LOGS where UPD>="'.$ts. '" and UPD<"'.$timestamp.'" and etype="delete" and comment like "%('.$this->table.':%)"');
    3778. 

  3778.       while($rs && $ors=$rs->fetch()){
    3779. 

  3779. 	$d=$x->rDisplay($ors['KOID'],$ors,false);
    3780. 

  3780. 	$txt.='<li>'.$d['ocomment']->text.' ('.$d['oUPD']->html.', '.$d['ousernam']->html.', '.$d['oetype']->html.')</li>';
    3781. 

  3781.       }
    3782. 

  3782.     }
    3783. 

  3783.     return $txt;
    3784. 

  3784.   }
    3785. 

  3785.   function goto1($ar=NULL) {
    3786. 

  3786.     $p=new XParam($ar,array());
    3787. 

  3787.     $oid=$p->get('oid');
    3788. 

  3788.     $url=$GLOBALS['TZR_SESSION_MANAGER']::admin_url(false,true);
    3789. 

  3789.     $moid=$this->_moid;
    3790. 

  3790.     $right= $this->secure($oid, 'display');
    3791. 

  3791.     if(!$right) securityWarning('XModTable::goto1: could not access to objet '.$oid.' in module '.$moid);
    3792. 

  3792.     header("Location: {$url}&moid=$moid&template=xmodtable/view.html&oid=$oid&function=display&tplentry=br");
    3793. 

  3793.   }
    3794. 

  3794.   function gDisplay($ar=NULL) {
    3795. 

  3795.     self::developer($ar);
    3796. 

  3796.     $p=new XParam($ar,array());
    3797. 

  3797.     $tplentry=$p->get('tplentry');
    3798. 

  3798.   }
    3799. 

  3799.   function developer($ar=NULL) {
    3800. 

  3800.     parent::developer($ar);
    3801. 

  3801.     $r['lines_title'][]='Display template';
    3802. 

  3802.     $r['lines_url'][]='&function=gDisplay';
    3803. 

  3803.     XShell::toScreen1('dev',$r);
    3804. 

  3804.   }
    3805. 

  3805. 

  3806.   // rend le journal des modifs d'un objet
    3807. 

  3807.   //
    3808. 

  3808.   public function &journal($ar) {
    3809. 

  3809.     $p = new XParam($ar, array());
    3810. 

  3810.     $tplentry=$p->get('tplentry');
    3811. 

  3811.     $oid=$p->get('oid');
    3812. 

  3812.     $r=&XLogs::getJournal($oid,array('etype'=>array('=',array('create','update','rule'))),NULL,NULL,$this->xset, $this->fieldssec);
    3813. 

  3813.     $this->browseSumFields($ar, $r, true);
    3814. 

  3814.     return XShell::toScreen1($tplentry,$r);
    3815. 

  3815.   }
    3816. 

  3816. 

  3817.   /// Validation des oid ou des rubriques
    3818. 

  3818.   public function publish($ar) {
    3819. 

  3819.     $p=new XParam($ar,array());
    3820. 

  3820.     $oids=Kernel::getSelectedOids($p);
    3821. 

  3821.     foreach($oids as $oid) {
    3822. 

  3822.       if($this->secure($oid,'publish')){
    3823. 

  3823. 	$ar1['_selected'] = array();
    3824. 

  3824. 	$ar1['value'] = $p->get('value');
    3825. 

  3825. 	$ar1['_local'] = true;
    3826. 

  3826. 	$ar1['oid']= $oid;
    3827. 

  3827. 	$this->xset->publish($ar1);
    3828. 

  3828.       }
    3829. 

  3829.     }
    3830. 

  3830.   }
    3831. 

  3831.  
    3832. 

  3832.   
    3833. 

  3833.   /// Retourne le filtre du module
    3834. 

  3834.   public function getFilter($instanciate=true,$ar=array()) {
    3835. 

  3835.     $q=getSessionVar('filterquery'.$this->_moid);
    3836. 

  3836.     // Pas très beau,  mais afin de contourner le filtre dans les actions venant de la selection, si on est dans l'admin et ques des oids sont fournis, alors on ne l'applique pas.
    3837. 

  3837.     if(XShell::admini_mode()){
    3838. 

  3838.       $oids=Kernel::getSelectedOids($ar);
    3839. 

  3839.       if(!empty($oids) && Kernel::getTable($oids[0])==$this->table){
    3840. 

  3840. 	$q=null;
    3841. 

  3841.       }
    3842. 

  3842.     }
    3843. 

  3843.     if(!empty($q)){
    3844. 

  3844.       // si pas de jointure on renvoie un filtre simple
    3845. 

  3845.       if (preg_match('/select .* from (.*) where (.*)/i', $q, $matches) && $matches[1] == $this->table) {
    3846. 

  3846.         $q=preg_replace('/order by .*$/i','',$matches[2]);
    3847. 

  3847.         $filter='('.$q.')';
    3848. 

  3848.       } else { // sinon un subselect
    3849. 

  3849.         $q=preg_replace('/select .* from/i','select '.$this->table.'.KOID from',$q);
    3850. 

  3850.         $q=preg_replace('/order by .*$/i','',$q);
    3851. 

  3851.         $filter=$this->table.'.KOID in ('.$q.')';
    3852. 

  3852.       }
    3853. 

  3853.     }else{
    3854. 

  3854.       $filter=$this->filter;
    3855. 

  3855.       if($instanciate) {
    3856. 

  3856. 	$context=array();
    3857. 

  3857. 	$u=XUser::get_user();
    3858. 

  3858. 	$context['/(\$\(user\))/']=XUser::get_current_user_uid();
    3859. 

  3859. 	if(!empty($u->_cur['alias'])) $context['/(\$\(user\.alias\))/']=$u->_cur['alias'];
    3860. 

  3860. 	$filter=preg_replace(array_keys($context),array_values($context),$filter);
    3861. 

  3861.       }
    3862. 

  3862.     }
    3863. 

  3863.     if(!empty($ar['_filter'])){
    3864. 

  3864.       if($filter) $filter='('.$filter.') AND ('.$ar['_filter'].')';
    3865. 

  3865.       else $filter=$ar['_filter'];
    3866. 

  3866.     }
    3867. 

  3867.     return $filter?'('.$filter.')':'';
    3868. 

  3868.   }
    3869. 

  3869. 

  3870.   /// Filtre sql utilisé par les xfielddef pour filtrer les valeurs utilisées
    3871. 

  3871.   function getUsedValuesFilter(){
    3872. 

  3872.     return $this->getFilter();
    3873. 

  3873.   }
    3874. 

  3874. 

  3875.   public function isThereAQueryActive() {
    3876. 

  3876.     if(sessionActive()) {
    3877. 

  3877.       $_storedquery=$this->_getSession('query');
    3878. 

  3878.       if($_storedquery['_table']==$this->table) {
    3879. 

  3879. 	return true;
    3880. 

  3880.       }
    3881. 

  3881.     }
    3882. 

  3882.     return false;
    3883. 

  3883.   }
    3884. 

  3884.   /// gestion du contexte sous module
    3885. 

  3885.   /// $shift dépile le premier élément dans l'url, pour un retour à la fiche parente
    3886. 

  3886.   protected function subModuleContext($ar=array(), $shift=false){
    3887. 

  3887.     $p = new XParam($ar, array());
    3888. 

  3888.     $_parentoids = $p->get('_parentoids');
    3889. 

  3889.     $_linkedfields = $p->get('_linkedfields');
    3890. 

  3890. 

  3891.     $ret = false;
    3892. 

  3892.     if (!empty($_parentoids) && !empty($_linkedfields)) {
    3893. 

  3893.       $urlparms = '';
    3894. 

  3894.       foreach ($_parentoids as $i => $parentoid) {
    3895. 

  3895.         if (!$i && $shift)
    3896. 

  3896.           continue;
    3897. 

  3897.         $urlparms .= '&_parentoids[]='.$parentoid;
    3898. 

  3898.       }
    3899. 

  3899.       foreach ($_linkedfields as $i => $linkedfield) {
    3900. 

  3900.         if (!$i && $shift)
    3901. 

  3901.           continue;
    3902. 

  3902.         $urlparms .= '&_linkedfields[]='.$linkedfield;
    3903. 

  3903.       }
    3904. 

  3904.       // deprecated, backward compatibility
    3905. 

  3905.       $urlparms .= '&_parentoid='.$_parentoids[0].'&_linkedfield='.$_linkedfields[0];
    3906. 

  3906.       $ret = array('_parentoids' => $_parentoids,
    3907. 

  3907.                    '_linkedfields' => $_linkedfields,
    3908. 

  3908.                    'urlparms' => $urlparms);
    3909. 

  3909.     }
    3910. 

  3910.     return $ret;
    3911. 

  3911.   }
    3912. 

  3912. 

  3913.   /// Prepare le HTML pour l'affichage d'un captcha dans un formulaire
    3914. 

  3914.   function createCaptcha($ar,$force=false){
    3915. 

  3915.     $p=new XParam($ar,NULL);
    3916. 

  3916.     $tplentry=$p->get('tplentry');
    3917. 

  3917.     if($this->captcha || $force){
    3918. 

  3918.       XLogs::notice('XModTable::_createcaptcha','module '.$this->_moid." ");
    3919. 

  3919.       $varid=uniqid('c');
    3920. 

  3920.       $color = XIni::get('error_color');
    3921. 

  3921.       $captcha['html']='<div class="tzrDivCaptcha"><img id="cimg'.$varid.'"/>'.
    3922. 

  3922. 	'<a id="ca'.$varid.'" href="#" onclick="TZR.actualizeCaptcha(\''.TZR_CAPTCHA.'\',\''.$varid.'\'); return false;">'.
    3923. 

  3923. 	XLabels::getSysLabel('xmodtable','captcha_reload').'</a>'.
    3924. 

  3924. 	'<input type="text" id="'.$varid.'" name="captcha_key" maxlength="'.TZR_CAPTCHA_LENGTH.'" size="'.TZR_CAPTCHA_LENGTH.'" />'.
    3925. 

  3925. 	'<input type="hidden" name="captcha_id" value="'.$varid.'" />'.
    3926. 

  3926. 	"<script type=\"text/javascript\">TZR.actualizeCaptcha('".TZR_CAPTCHA."','$varid'); ".
    3927. 

  3927. 	"TZR.addValidator(['$varid','','Captcha','$color','Captcha']);</script></div>";
    3928. 

  3928.       $captcha['label'] = XLabels::getSysLabel('xmodtable','captcha_label');
    3929. 

  3929.       return XShell::toScreen1($tplentry,$captcha);
    3930. 

  3930.     }
    3931. 

  3931.   }
    3932. 

  3932. 

  3933.   // implementation de l'interface des documents
    3934. 

  3934.   function &XMCinput($ar) {
    3935. 

  3935.     return $this->insert($ar);
    3936. 

  3936.   }
    3937. 

  3937.   function &XMCprocInput($ar) {
    3938. 

  3938.     return $this->procInsert($ar);
    3939. 

  3939.   }
    3940. 

  3940.   function &XMCedit($ar) {
    3941. 

  3941.     return $this->edit($ar);
    3942. 

  3942.   }
    3943. 

  3943.   function &XMCprocEdit($ar) {
    3944. 

  3944.     $e = &$this->procEdit($ar);
    3945. 

  3945.     return $e;
    3946. 

  3946.   }
    3947. 

  3947.   function &XMCprocEditDup($ar) {
    3948. 

  3948.     return $this->procEditDup($ar);
    3949. 

  3949.   }
    3950. 

  3950.   function &XMCdisplay($ar) {
    3951. 

  3951.     return $this->display($ar);
    3952. 

  3952.   }
    3953. 

  3953.   function &XMCdel($ar) {
    3954. 

  3954.     return $this->del($ar);
    3955. 

  3955.   }
    3956. 

  3956.   function &XMCduplicate($oidsrc){
    3957. 

  3957.     if(!is_array($oidsrc)) $oidsrc=array('oid'=>$oidsrc);
    3958. 

  3958.     return $this->duplicate($oidsrc);
    3959. 

  3959.   }
    3960. 

  3960.   function &XMCquery($ar){
    3961. 

  3961.     return $this->query($ar);
    3962. 

  3962.   }
    3963. 

  3963.   function &XMCprocQuery($ar){
    3964. 

  3964.     return $this->procQuery($ar);
    3965. 

  3965.   }
    3966. 

  3966.   function tablesToTrack() {
    3967. 

  3967.     if($this->trackchanges) return array($this->table);
    3968. 

  3968.   }
    3969. 

  3969.   function apply($f) {
    3970. 

  3970.     $rs=selectQuery('SELECT DISTINCT KOID FROM '.$this->table);
    3971. 

  3971.     while($ors=$rs->fetch()) {
    3972. 

  3972.       $d=&$this->xset->rDisplay($ors['KOID']);
    3973. 

  3973.       $f($this, $d);
    3974. 

  3974.     }
    3975. 

  3975.     $rs->closeCursor();
    3976. 

  3976.   }
    3977. 

  3977. 

  3978.   // verification qu'un module est bien installé. Si le parametre
    3979. 

  3979.   // repair est a oui, on fait les reparations si possible.
    3980. 

  3980.   //
    3981. 

  3981.   public function chk($ar=NULL) {
    3982. 

  3982.     parent::chk($ar);
    3983. 

  3983.     // Créer des index sur tous les champs servant de lien dans des sous fiches
    3984. 

  3984.     for($i=1;$i<=$this->submodmax;$i++) {
    3985. 

  3985.       $l='ssmod'.$i;
    3986. 

  3986.       $moid=$this->$l;
    3987. 

  3987.       $l='ssmodfield'.$i;
    3988. 

  3988.       $f=$this->$l;
    3989. 

  3989.       if(!empty($moid) && !empty($f)){
    3990. 

  3990.         $mod=XModule::objectFactory($moid);
    3991. 

  3991.         $l=$mod->xset->desc[$f]->multivalued?300:40;
    3992. 

  3992.         updateQuery('CREATE INDEX '.$f.' ON '.$mod->table.' ('.$f.'('.$l.'))');
    3993. 

  3993.       }
    3994. 

  3994.     }
    3995. 

  3995.     return true;
    3996. 

  3996.   }
    3997. 

  3997. 

  3998.   /// recherche si on oid est autorise dans le module
    3999. 

  3999.   protected function secOidOk($oid) {
    4000. 

  4000.     if(substr($oid,0,7)=='_field-') return true;
    4001. 

  4001.     if(isset($this->secOids_cache[$oid])) return $this->secOids_cache[$oid];
    4002. 

  4002.     
    4003. 

  4003.     // Vérifie que l'oid est dans la selection. Si oui, c'est que l'utilisateur a accès à celui ci
    4004. 

  4004.     $selection=$this->getSelectionFromSession();
    4005. 

  4005.     if($selection && array_key_exists($oid,$selection)) return true;
    4006. 

  4006. 

  4007.     // Applique le filtre du module pour vérifier sir l'oid est accessible
    4008. 

  4008.     $filter=$this->getFilter(true);
    4009. 

  4009.     if(!empty($filter)) {
    4010. 

  4010.       // dans le cas d'un filtre, on verifie si on appartient au filtre
    4011. 

  4011.       $rs=selectQuery('select KOID from '.$this->table.' where KOID="'.$oid.'" AND '.$filter);
    4012. 

  4012.       if($rs && ($ors=$rs->fetch())) {
    4013. 

  4013.         $this->secOids_cache[$oid] = !empty($ors['KOID']);
    4014. 

  4014.         return $this->secOids_cache[$oid];
    4015. 

  4015.       }
    4016. 

  4016.     } else {
    4017. 

  4017.       return true;
    4018. 

  4018.     }
    4019. 

  4019.   }
    4020. 

  4020. 

  4021.   /// Calcul des champs totalisés suite à un browse
    4022. 

  4022.   function browseSumFields($ar, &$r, $withtotal){
    4023. 

  4023.     $p = new XParam($ar, array());
    4024. 

  4024.     $tpl = $p->get('tplentry');
    4025. 

  4025. 

  4026.     // totalisation des champs numériques listés
    4027. 

  4027.     $numfields = array();
    4028. 

  4028.     $fsums = ""; $sep = '';
    4029. 

  4029.     foreach($r['header_fields'] as $if=>$fd){
    4030. 

  4030.       if (!$fd->is_summable()) continue;
    4031. 

  4031.       $numfield = (object)array('if'=>$if,
    4032. 

  4032. 				'fc'=>$fd->field,
    4033. 

  4033. 				'ffc'=>$this->table . '.' . $fd->field,
    4034. 

  4034. 				'ffa'=>'sumof_'.$this->table . '_' . $fd->field,
    4035. 

  4035. 				);
    4036. 

  4036.       $numfields[$fd->field] = $numfield;
    4037. 

  4037.       $fsums = $fsums . $sep . 'ifnull('.$fd->sqlsumfunction().', 0) as '.$numfield->ffa;
    4038. 

  4038.       $sep = ',';
    4039. 

  4039.     }
    4040. 

  4040.     if (count($numfields) == 0)
    4041. 

  4041.       return;
    4042. 

  4042.     // requete de base
    4043. 

  4043.     $selectsum = preg_replace('/select (.*) from (.*)$/Ui','select '.$fsums.' from $2',$r['select']);
    4044. 

  4044. 

  4045.     // total de la selection en cours
    4046. 

  4046.     if ($withtotal){
    4047. 

  4047.       $srs = selectQuery($selectsum);
    4048. 

  4048.       $osrs = $srs->fetch();
    4049. 

  4049.     } else {
    4050. 

  4050.       $osrs = NULL;
    4051. 

  4051.     }
    4052. 

  4052. 

  4053.     // total de la page en cours
    4054. 

  4054.     // -> liste des oid de la page
    4055. 

  4055.     // -> l'ordre n'a pas d'importance
    4056. 

  4056.     $pagesize=$p->get('pagesize');
    4057. 

  4057.     if(empty($pagesize)) {
    4058. 

  4058.       $pagesize=$this->pagesize;
    4059. 

  4059.     }
    4060. 

  4060.     if(empty($pagesize))
    4061. 

  4061.       $pagesize=TZR_XMODTABLE_BROWSE_MAXPAGESIZE;
    4062. 

  4062.     $ar['pagesize']=$pagesize;
    4063. 

  4063. 

  4064.     $last = $p->get('last');
    4065. 

  4065.     if (empty($last)){
    4066. 

  4066.       $last = $r['last'];
    4067. 

  4067.     }
    4068. 

  4068. 

  4069.     if ($last > $pagesize || !$withtotal){
    4070. 

  4070.       // calcul du total page par iteration sur les lignes
    4071. 

  4071.       $osprs = array();
    4072. 

  4072.       foreach($r['header_fields'] as $foo=>&$fd){
    4073. 

  4073. 	if (isset($numfields[$fd->field])){
    4074. 

  4074. 	  $osprs[$fd->field]=0;
    4075. 

  4075. 	  foreach($r['lines_o'.$fd->field] as $il=>&$fv){
    4076. 

  4076. 	    $osprs[$numfields[$fd->field]->ffa]+=$fv->raw;
    4077. 

  4077. 	  }
    4078. 

  4078. 	}
    4079. 

  4079.       }
    4080. 

  4080.       unset($foo);
    4081. 

  4081.     }
    4082. 

  4082.     // mise en forme des totaux
    4083. 

  4083.     $linetot = $linepage = '';
    4084. 

  4084.     foreach($r['header_fields'] as $foo=>&$fd){
    4085. 

  4085.       if (isset($numfields[$fd->field])){
    4086. 

  4086. 	if ($withtotal)
    4087. 

  4087. 	  $linetot.='<td style="text-align:'.$fd->align.';">'.$fd->my_display($osrs[$numfields[$fd->field]->ffa])->html.'</td>';
    4088. 

  4088. 	if ($last > $pagesize || !$withtotal)
    4089. 

  4089. 	  $linepage.='<td style="text-align:'.$fd->align.';">'.$fd->my_display($osprs[$numfields[$fd->field]->ffa])->html.'</td>';
    4090. 

  4090. 	else
    4091. 

  4091. 	  $linepage.='<td></td>';
    4092. 

  4092.       } else {
    4093. 

  4093. 	if ($withtotal)
    4094. 

  4094. 	  $linetot.='<td></td>';
    4095. 

  4095. 	$linepage.='<td></td>';
    4096. 

  4096.       }
    4097. 

  4097.     }
    4098. 

  4098.     if (!$withtotal)
    4099. 

  4099.       $linetot = NULL;
    4100. 

  4100.     if ($last <= $pagesize && $withtotal)
    4101. 

  4101.       $linepage = NULL;
    4102. 

  4102.     $sums = array();
    4103. 

  4103.     $sums['line_tot'] = $linetot;
    4104. 

  4104.     $sums['line_page'] = $linepage;
    4105. 

  4105.     if ($tpl != TZR_RETURN_DATA){
    4106. 

  4106.       XShell::toScreen2($tpl, 'sums', $sums);
    4107. 

  4107.     } else {
    4108. 

  4108.       $r['sums']['line_tot'] = $linetot;
    4109. 

  4109.       $r['sums']['line_page'] = $linepage;
    4110. 

  4110.     }
    4111. 

  4111.   }
    4112. 

  4112. 

  4113.   /// Sous fonctions de parcours de la selection
    4114. 

  4114.   function &_browseUserSelection($oid,&$data){
    4115. 

  4115.     if(!$this->object_sec || $this->secure($oid,'display')){
    4116. 

  4116.       return $this->xset->rDisplay($oid,array(),true,'','',array('fmoid'=>$this->_moid));
    4117. 

  4117.     }
    4118. 

  4118.     return false;
    4119. 

  4119.   }
    4120. 

  4120. 

  4121.   /// Liste des fonctions utilisable sur la selection du module
    4122. 

  4122.   function userSelectionActions(){
    4123. 

  4123.     $actions=array();
    4124. 

  4124.     if($this->secure('','procQuery')){
    4125. 

  4125.       $viewtxt=XLabels::getSysLabel('general','view','text');
    4126. 

  4126.       $actions['view']='<a href="#" onclick="TZR.SELECTION.viewselected'.$this->_moid.'(); return false;">'.$viewtxt.'</a>';
    4127. 

  4127.     }
    4128. 

  4128.     if($this->secure('','editSelection')) {
    4129. 

  4129.       $editalltxt=XLabels::getSysLabel('xmodtable','editselection','text');
    4130. 

  4130.       $actions['editselection']='<a href="#" onclick="TZR.SELECTION.applyToInContentDiv('.$this->_moid.',\'editSelection\',false,{template:\'xmodtable/editSelection.html\',tplentry:\'br\'}); return false;">'.$editalltxt.'</a>';
    4131. 

  4131.     }
    4132. 

  4132.     if($this->secure('','del')) {
    4133. 

  4133.       $deltxt=XLabels::getSysLabel('general','delete','text');
    4134. 

  4134.       $actions['del']='<a href="#" onclick="TZR.SELECTION.applyTo('.$this->_moid.',\'del\',null,null,TZR.confirmDelete); return false;">'.$deltxt.'</a>';
    4135. 

  4135.     }
    4136. 

  4136.     if($this->secure('','sendACopyTo')){
    4137. 

  4137.       $sendtxt=XLabels::getSysLabel('xmodule','sendacopyto','text');
    4138. 

  4138.       $actions['sendacopy']='<a href="#" onclick="TZR.SELECTION.applyToInContentDiv('.$this->_moid.',\'sendACopyTo\',false,{template:\'xmodule/sendacopyto.html\'}); return false;">'.$sendtxt.'</a>';
    4139. 

  4139.     }
    4140. 

  4140.     if($this->secure('','export')) {
    4141. 

  4141.       $exportselectiontext = XLabels::getSysLabel('xmodtable','exportselection','text');
    4142. 

  4142.       $actions['exportSelection'] = '<a href="#" onclick="TZR.SELECTION.exportSelection('.$this->_moid.');return false;">'.$exportselectiontext.'</a>';
    4143. 

  4143.     }
    4144. 

  4144.     if($this->object_sec && $this->secure('','secEditSimple')) {
    4145. 

  4145.       $sectxt=XLabels::getSysLabel('general','security','text');
    4146. 

  4146.       $actions['secselection']='<a href="#" onclick="TZR.editSec(\''.$GLOBALS['TZR_SESSION_MANAGER']::complete_self(true).'\',\''.$this->_moid.'\',\'\',\'selectionform'.$this->_moid.'\'); return false;">'.$sectxt.'</a>';
    4147. 

  4147.     }
    4148. 

  4148.     return $actions;
    4149. 

  4149.   }
    4150. 

  4150. 

  4151.   /// Indexation du module dans le moteur de recherche
    4152. 

  4152.   public function _buildSearchIndex(&$searchEngine,$checkbefore=true,$limit=NULL,$cond=NULL){
    4153. 

  4153.     $done=0;
    4154. 

  4154.     if(!empty($cond)){
    4155. 

  4155.       if($cond=='UPD'){
    4156. 

  4156. 	$last=XDbIni::get('lastindexation_'.$this->_moid,'val');
    4157. 

  4157. 	if(empty($last)) $last=date('2000-01-01 00:00:00');
    4158. 

  4158. 	XDbIni::set('lastindexation_'.$this->_moid,date('Y-m-d H:i:s'));
    4159. 

  4159. 	$cond='UPD>="'.$last.'"';
    4160. 

  4160.       }
    4161. 

  4161.       $cond=' where '.$cond;
    4162. 

  4162.     }else{
    4163. 

  4163.       $cond=' where 1';
    4164. 

  4164.     }
    4165. 

  4165.     $filter=$this->getFilter(true);
    4166. 

  4166.     if($filter) $cond.=' AND '.$filter;
    4167. 

  4167.     $rs=selectQuery('SELECT * FROM '.$this->table.' '.$cond);
    4168. 

  4168.     while($rs && ($ors=$rs->fetch())) {
    4169. 

  4169.       XLogs::debug('XModTable'.$this->_moid.'::buildSearchIndex: testing '.$ors['KOID']);
    4170. 

  4170.       if($checkbefore && $searchEngine->docExists($ors['KOID'],$this->_moid,NULL)) continue;
    4171. 

  4171.       XLogs::debug('XModTable'.$this->_moid.'::buildSearchIndex: adding '.$ors['KOID']);
    4172. 

  4172.       $this->addToSearchEngine($searchEngine,$ors['KOID']);
    4173. 

  4173.       $done++;
    4174. 

  4174.       if($done%30==0){
    4175. 

  4175.  	XLogs::debug('XModTable'.$this->_moid.'::buildSearchIndex: commit');
    4176. 

  4176.         $searchEngine->index->commit();
    4177. 

  4177.       }
    4178. 

  4178.       if($limit && $done>$limit){
    4179. 

  4179.  	XLogs::debug('XModTable'.$this->_moid.'::buildSearchIndex: break at '.$done);
    4180. 

  4180. 	break;
    4181. 

  4181.       }
    4182. 

  4182.     }
    4183. 

  4183.     $searchEngine->commit();
    4184. 

  4184.     return true;
    4185. 

  4185.   }
    4186. 

  4186.   /// Recupere les infos d'un objet par l'affichage du résultat d'une recherche
    4187. 

  4187.   public function getSearchResult($oid,$filter=NULL){
    4188. 

  4188.     return parent::getSearchResult($oid,$filter);
    4189. 

  4189. 

  4190.   }
    4191. 

  4191. 

  4192.   /// presentation d'un resultat de recherche dans le module
    4193. 

  4193.   public function showSearchResult($oids) {
    4194. 

  4194.     $_REQUEST = array(
    4195. 

  4195.       'function' => 'procQuery',
    4196. 

  4196.       'template' => 'xmodtable/browse.html',
    4197. 

  4197.       'moid' => $this->_moid,
    4198. 

  4198.       'tplentry' => 'br',
    4199. 

  4199.       'clearrequest' => 1,
    4200. 

  4200.       'oids' => $oids
    4201. 

  4201.     );
    4202. 

  4202.     $GLOBALS['XSHELL']->run();
    4203. 

  4203.     exit;
    4204. 

  4204.   }
    4205. 

  4205. 

  4206.   /// Ajout d'une fiche au moteur de recherche : données
    4207. 

  4207.   function &getSearchEngineData($oid) {
    4208. 

  4208.     // selected fields = published + indexables
    4209. 

  4209.     $indexables = $this->xset->getIndexablesFields();
    4210. 

  4210.     $publisheds = $this->xset->getPublished(true);
    4211. 

  4211.     $selecteds = array_merge($indexables, $publisheds);
    4212. 

  4212.     $d=$this->xset->display(array('tplentry'=>TZR_RETURN_DATA,'oid'=>$oid,'tlink'=>true, 'selectedfields'=>$selecteds));
    4213. 

  4213.     // filtrer les indexables ?
    4214. 

  4214.     $text=getFilesContent($d, $indexables);
    4215. 

  4215.     $files = getFilesDetails($d);
    4216. 

  4216.     $notice = NULL;
    4217. 

  4217.     foreach($indexables as $f){
    4218. 

  4218.       if (!$this->xset->desc[$f]->get_published()
    4219. 

  4219. 	  && !($this->xset->desc[$f] instanceof XFileDef)
    4220. 

  4220. 	  && !($this->xset->desc[$f] instanceof XFolderDef)
    4221. 

  4221. 	  ) {
    4222. 

  4222. 	$notice .= ' '.$d['o'.$f]->toText();
    4223. 

  4223.       }
    4224. 

  4224.     }
    4225. 

  4225.     foreach($files as $afile){
    4226. 

  4226.       if (in_array($afile['field'], $indexables)){
    4227. 

  4227. 	$notice .= ' '.$afile['title'];
    4228. 

  4228. 	if ($afile['name'] != $afile['title'])
    4229. 

  4229. 	  	$notice .= ' '.$afile['name'];
    4230. 

  4230.       }
    4231. 

  4231.     }
    4232. 

  4232.     $fields = array('title'=>$d['tlink'], 'notice'=>$notice, 'contents'=>&$text);
    4233. 

  4233.     return $fields;
    4234. 

  4234.   }
    4235. 

  4235.   /// Ajout d'une fiche au moteur de recherche
    4236. 

  4236.   function addToSearchEngine(&$searchEngine,$oid) {
    4237. 

  4237.     $fields = $this->getSearchEngineData($oid);
    4238. 

  4238.     $searchEngine->addItem($oid,$fields,$this->_moid, NULL);
    4239. 

  4239.     unset($fields);
    4240. 

  4240.     XLogs::notice(get_class($this),get_class($this).'::addToSearchEngine lucene');
    4241. 

  4241.   }
    4242. 

  4242. 

  4243.   /// Action effectuée à chaque suppression d'un oid de la base
    4244. 

  4244.   function _removeRegisteredOid($oid) {
    4245. 

  4245.     // Suppression du moteur de recherche
    4246. 

  4246.     if($this->insearchengine && Kernel::getTable($oid)==$this->table){
    4247. 

  4247.       $se=&XSearch::objectFactory();
    4248. 

  4248.       $se->deleteItem($oid,$this->_moid);
    4249. 

  4249.     }
    4250. 

  4250.   }
    4251. 

  4251. 

  4252. 

  4253.   ////////////////////////////////////
    4254. 

  4254.   // FONCTIONS INTERFACE XCAL       //
    4255. 

  4255.   ////////////////////////////////////
    4256. 

  4256.   /// Retourne la liste des champs pouvant servir à la consolidation
    4257. 

  4257.   function XCalParamsConsolidation($ar){
    4258. 

  4258.     $ar1=$ar2=array();
    4259. 

  4259.     $p=new XParam($ar,array());
    4260. 

  4260.     $tplentry=$p->get('tplentry');
    4261. 

  4261.     $datefields=$this->xset->getFieldsList(array('XDateDef','XDateTimeDef','XTimestampDef'));
    4262. 

  4262.     $stextfields=$this->xset->getFieldsList(array('XShortTextDef','XLinkDef'));
    4263. 

  4263.     $textfields=$this->xset->getFieldsList();
    4264. 

  4264.     foreach($datefields as $opt){
    4265. 

  4265.       $info=$this->xset->getField($opt);
    4266. 

  4266.       $ar1[$opt]=$info->label;
    4267. 

  4267.     }
    4268. 

  4268.     foreach($stextfields as $opt){
    4269. 

  4269.       $info=$this->xset->getField($opt);
    4270. 

  4270.       $ar2[$opt]=$info->label;
    4271. 

  4271.     }
    4272. 

  4272.     foreach($textfields as $opt){
    4273. 

  4273.       $info=$this->xset->getField($opt);
    4274. 

  4274.       $ar3[$opt]=$info->label;
    4275. 

  4275.     }
    4276. 

  4276.     XShell::toScreen2($tplentry,'date',$ar1);
    4277. 

  4277.     XShell::toScreen2($tplentry,'stexte',$ar2);
    4278. 

  4278.     XShell::toScreen2($tplentry,'texte',$ar3);
    4279. 

  4279.   }
    4280. 

  4280. 

  4281.   function XCalGetConsolidationQuery(&$diary,$params,$fields,$begin,$end,$type='all'){
    4282. 

  4282.     $vals=array('visib'=>'PU','DKOID'=>$this->_moid,'DNAME'=>$this->modulename);
    4283. 

  4283.     if($this->xset->desc[$params['begin']]->ftype=="XDateDef" || $this->xset->desc[$params['end']]->ftype=="XDateDef"){
    4284. 

  4284.       if($type=='event') return NULL;
    4285. 

  4285.       $vals['allday']=1;
    4286. 

  4286.     }else{
    4287. 

  4287.       $datetime=true;
    4288. 

  4288.       if($type=='event'){
    4289. 

  4289. 	$vals['allday']=0;
    4290. 

  4290. 	$begin=date('Y-m-d H:i:s',strtotime($begin.' GMT'));
    4291. 

  4291. 	$end=date('Y-m-d H:i:s',strtotime($end.' GMT'));
    4292. 

  4292.       }elseif($type=='note'){
    4293. 

  4293. 	$vals['allday']=1;
    4294. 

  4294.       }
    4295. 

  4295.     }
    4296. 

  4296.     $filter=$this->getFilter(true);
    4297. 

  4297.     if(!empty($filter)) $filter=' AND '.$filter;
    4298. 

  4298.     $filter.=' AND (date_format('.$params['begin'].',"%Y-%m-%d %H:%i:%s") BETWEEN "'.$begin.'" AND "'.$end.'" OR '.
    4299. 

  4299.       '"'.$begin.'" BETWEEN date_format('.$params['begin'].',"%Y-%m-%d %H:%i:%s") AND '.
    4300. 

  4300.       'date_format('.$params['end'].',"%Y-%m-%d %H:%i:%s"))';
    4301. 

  4301.     if($datetime){
    4302. 

  4302.       if($type=='event'){
    4303. 

  4303. 	$filter.=' AND (date_format('.$params['begin'].',"%H:%i")!="00:00" OR date_format('.$params['end'].',"%H:%i")!="00:00")';
    4304. 

  4304.       }elseif($type=='note'){
    4305. 

  4305. 	$filter.=' AND date_format('.$params['begin'].',"%H:%i")="00:00" AND date_format('.$params['end'].',"%H:%i")="00:00"';
    4306. 

  4306.       }
    4307. 

  4307.     }
    4308. 

  4308.     $rq=$this->xset->select_query(array('local'=>true,'getselectonly'=>true)).$filter;
    4309. 

  4309.     if($this->object_sec){
    4310. 

  4310.       $oids=$this->xset->browseOids(array('select'=>$rq,'local'=>true));
    4311. 

  4311.       $lang_data=XShell::getLangData();
    4312. 

  4312.       $oidsrights=$GLOBALS['XUSER']->getObjectsAccess($this,$lang_data,$oids);
    4313. 

  4313.       foreach($oidsrights as $i=>$rights) {
    4314. 

  4314. 	if(!array_key_exists('ro',$rights)) unset($oids[$i]);
    4315. 

  4315.       }
    4316. 

  4316.       $rq.=' AND KOID IN("'.implode('","',$oid).'")';
    4317. 

  4317.     }
    4318. 

  4318. 

  4319.     $select='select KOID,LANG';
    4320. 

  4320.     foreach($fields as $f){
    4321. 

  4321.       if($f=='begin' || $f=='end'){
    4322. 

  4322. 	if($vals['allday']!=1) $select.=',convert_tz(date_format('.$params[$f].',"%Y-%m-%d %H:%i:%s"),"'.date("P").'","+00:00") as '.$f;
    4323. 

  4323. 	else $select.=',date_format('.$params[$f].',"%Y-%m-%d %H:%i:%s") as '.$f;
    4324. 

  4324.       }
    4325. 

  4325.       elseif(isset($vals[$f])) $select.=',"'.$vals[$f].'" as '.$f;
    4326. 

  4326.       elseif(!empty($params[$f])) $select.=','.$params[$f].' as '.$f;
    4327. 

  4327.       else $select.=', NULL as '.$f;
    4328. 

  4328.     }
    4329. 

  4329.     $select.=',"'.$this->_moid.'" as MOID';
    4330. 

  4330.     $rq=preg_replace('/select .+ from /i',$select.' from ',$rq);
    4331. 

  4331.     return $rq;
    4332. 

  4332.   }
    4333. 

  4333. 

  4334.   function XCalGetUrl($type){
    4335. 

  4335.     if($type=='display') return $GLOBALS['TZR_SESSION_MANAGER']::complete_self().'moid='.$this->_moid.'&oid=%s&function=display&tplentry=br&template=xmodtable/view.html';
    4336. 

  4336.     else return $GLOBALS['TZR_SESSION_MANAGER']::complete_self().'moid='.$this->_moid.'&function=browse&tplentry=br&template=xmodtable/browse.html';
    4337. 

  4337.   }
    4338. 

  4338. 

  4339.   function XCalRDisplay($oid,$params){
    4340. 

  4340.     $opts['selectedfields']=array_values($params);
    4341. 

  4341.     $d=$this->xset->rDisplay($oid,array(),false,'','',$opts);
    4342. 

  4342.     foreach($params as $evf=>$f){
    4343. 

  4343.       if(isset($d['o'.$f])){
    4344. 

  4344. 	$d['o'.$evf]=&$d['o'.$f];
    4345. 

  4345.       }
    4346. 

  4346.     }
    4347. 

  4347.     return $d;
    4348. 

  4348.   }
    4349. 

  4349. 

  4350.   /// Rend les documents qui n'ont jamais été consultés
    4351. 

  4351.   function getUnread($ar=NULL){
    4352. 

  4352.     $p=new XParam($ar,array('nb'=>20));
    4353. 

  4353.     $tplentry=$p->get('tplentry');
    4354. 

  4354.     $docs=array();
    4355. 

  4355.     $rs=selectQuery('select '.$this->table.'.* from '.$this->table.' left outer join LOGS on '.$this->table.'.KOID=LOGS.object and LOGS.etype="access" and LOGS.user="'.XUser::get_current_user_uid().'" and LOGS.UPD>'.$this->table.'.UPD where LOGS.KOID is null order by '.$this->table.'.UPD');
    4356. 

  4356.     while($rs && $ors=$rs->fetch()){
    4357. 

  4357.       $oid=$ors['KOID'];
    4358. 

  4358.       if(!$this->secure($oid,'display')) continue;
    4359. 

  4359.       $docs[]=$this->xset->rDisplay($oid,array(),false,'','');
    4360. 

  4360.     }
    4361. 

  4361.     return XShell::toScreen2($tplentry,'docs',$docs);
    4362. 

  4362.   }
    4363. 

  4363. 

  4364.   /// Marque des documents comme lu
    4365. 

  4365.   function markAsRead($ar=NULL){
    4366. 

  4366.     Kernel::getSelectedOids($ar);
    4367. 

  4367.     foreach($oids as $i=>$oid){
    4368. 

  4368.       XLogs::uniqueUpdate('access',$oid);
    4369. 

  4369.     }
    4370. 

  4370.   }
    4371. 

  4371. 

  4372.   /// Recupere des infos sur le module
    4373. 

  4373.   function getInfos($ar=NULL){
    4374. 

  4374.     $p=new XParam($ar,array('tplentry'=>TZR_RETURN_DATA));
    4375. 

  4375.     $tplentry=$p->get('tplentry');
    4376. 

  4376.     $ar['tplentry']=TZR_RETURN_DATA;
    4377. 

  4377.     $ret=parent::getInfos($ar);
    4378. 

  4378.     // Nombre d'enregistrement dans la table
    4379. 

  4379.     $filter=$this->getFilter(true,$ar);
    4380. 

  4380.     $ret['infos']['cnt']=(object)array('label'=>XLabels::getSysLabel('xmodtable','records','text'),
    4381. 

  4381. 				       'html'=>countSelectQuery('select count(distinct KOID) from '.$this->table.($filter?' where '.$filter:'')));
    4382. 

  4382.     // Place occupé sur le disque par les data : Appliquer le filtre au calcul...
    4383. 

  4383.     $s=XDbIni::get('xmodadmin:workspacesize_'.$this->table,'val');
    4384. 

  4384.     $ret['infos']['size']->label=XLabels::getSysLabel('xmodule','workspace','text');
    4385. 

  4385.     if($s!==NULL) $ret['infos']['size']->html=getStringBytes($s*1024);
    4386. 

  4386.     else $ret['infos']['size']->html=XLabels::getSysLabel('xmodule','infonotcalculate','text');
    4387. 

  4387.     return XShell::toScreen1($tplentry,$ret);
    4388. 

  4388.   }
    4389. 

  4389. 

  4390. 

  4391.   ////////////////////////////////////
    4392. 

  4392.   // FONCTIONS D'ADMINISTRATION     //
    4393. 

  4393.   ////////////////////////////////////
    4394. 

  4394.   /// Liste des champs d'une table du module
    4395. 

  4395.   public function adminBrowseFields($ar=NULL) {
    4396. 

  4396.     $p=new XParam($ar, array());
    4397. 

  4397.     $tplentry=$p->get('tplentry');
    4398. 

  4398.     $r1=$this->xset->browseFields($ar);
    4399. 

  4399.     $tablesec=array();
    4400. 

  4400.     $this->anyFieldsSec($tablesec);
    4401. 

  4401.     $r1['tableSec']=$tablesec;
    4402. 

  4402.     XShell::toScreen1($tplentry, $r1);
    4403. 

  4403.   }
    4404. 

  4404. 

  4405.   /// Imprime la liste des champs d'une table
    4406. 

  4406.   public function adminPrint($ar=NULL) {
    4407. 

  4407.     $p = new XParam($ar, array());
    4408. 

  4408.     $tplentry=$p->get('tplentry');
    4409. 

  4409.     $r1=$this->xset->browseFields($ar);
    4410. 

  4410.     XShell::toScreen1($tplentry, $r1);
    4411. 

  4411.   }
    4412. 

  4412. 

  4413.   /// Ecran de generation d'un nouveau champ
    4414. 

  4414.   public function adminNewField($ar=NULL) {
    4415. 

  4415.     $p=new XParam($ar,NULL);
    4416. 

  4416.     $tplentry=$p->get('tplentry');
    4417. 

  4417.     $r1=$this->xset->newField($ar);
    4418. 

  4418.     XShell::toScreen1($tplentry,$r1);
    4419. 

  4419.   }
    4420. 

  4420. 

  4421.   /// Créér un nouveau champ
    4422. 

  4422.   public function adminProcNewField($ar=NULL) {
    4423. 

  4423.     $p=new XParam($ar,NULL);
    4424. 

  4424.     $tplentry=$p->get('tplentry');
    4425. 

  4425.     $r1=$this->xset->procNewField($ar);
    4426. 

  4426.     XShell::toScreen1($tplentry, $r1);
    4427. 

  4427.   }
    4428. 

  4428. 

  4429.   /// Ecran edition d'un champ
    4430. 

  4430.   public function adminEditField($ar=NULL) {
    4431. 

  4431.     $p=new XParam($ar,NULL);
    4432. 

  4432.     $tplentry=$p->get('tplentry');
    4433. 

  4433.     $r1=$this->xset->editField($ar);
    4434. 

  4434.     XShell::toScreen1($tplentry,$r1);
    4435. 

  4435.   }
    4436. 

  4436. 

  4437.   /// Enregistre les modification sur un champ
    4438. 

  4438.   public function adminProcEditField($ar=NULL) {
    4439. 

  4439.     $p=new XParam($ar,NULL);
    4440. 

  4440.     $tplentry=$p->get('tplentry');
    4441. 

  4441.     $r1=$this->xset->procEditField($ar);
    4442. 

  4442.     XShell::toScreen1($tplentry,$r1);
    4443. 

  4443.   }
    4444. 

  4444. 

  4445.   /// Edition des champs multiple à partir du browse
    4446. 

  4446.   public function adminProcEditFields($ar=NULL) {
    4447. 

  4447.     $p=new XParam($ar,NULL);
    4448. 

  4448.     $tplentry=$p->get('tplentry');
    4449. 

  4449.     $r1=$this->xset->procEditFields($ar);
    4450. 

  4450.     XShell::toScreen1($tplentry,$r1);
    4451. 

  4451.   }
    4452. 

  4452. 

  4453.   /// Supprime un champ
    4454. 

  4454.   public function adminDelField($ar=NULL) {
    4455. 

  4455.     $p=new XParam($ar,NULL);
    4456. 

  4456.     $tplentry=$p->get('tplentry');
    4457. 

  4457.     $r1=$this->xset->delField($ar);
    4458. 

  4458.     XShell::toScreen1($tplentry,$r1);
    4459. 

  4459.   }
    4460. 

  4460. 

  4461.   /// Vide la table
    4462. 

  4462.   public function adminClear($ar=NULL){
    4463. 

  4463.     $p=new XParam($ar,NULL);
    4464. 

  4464.     $tplentry=$p->get('tplentry');
    4465. 

  4465.     $ret=$this->xset->clear(array('tplentry'=>TZR_RETURN_DATA));
    4466. 

  4466.     if(XShell::hasNext()) setSessionVar('message',$ret['message']);
    4467. 

  4467.     return XShell::toScreen1($tplentry,$ret);
    4468. 

  4468.   }
    4469. 

  4469. 

  4470.   /// Prepare la duplication d'une source
    4471. 

  4471.   public function adminDuplicate($ar=NULL){
    4472. 

  4472.     $p=new XParam($ar,NULL);
    4473. 

  4473.     $tplentry=$p->get('tplentry');
    4474. 

  4474.     $ret=$this->xset->duplicateDataSource($ar);
    4475. 

  4475.     return XShell::toScreen1($tplentry, $ret);
    4476. 

  4476.   }
    4477. 

  4477. 

  4478.   /// Duplique une table du module
    4479. 

  4479.   public function adminProcDuplicate($ar=NULL){
    4480. 

  4480.     $p=new XParam($ar,NULL);
    4481. 

  4481.     $tplentry=$p->get('tplentry');
    4482. 

  4482.     $ret=$this->xset->procDuplicateDataSource($ar);
    4483. 

  4483.     if(XShell::hasNext()) setSessionVar('message',$ret['message']);
    4484. 

  4484.     return XShell::toScreen1($tplentry, $ret);
    4485. 

  4485.   }
    4486. 

  4486. 

  4487.   /// Check/repare une table du module
    4488. 

  4488.   public function adminChk($ar=NULL){
    4489. 

  4489.     $p=new XParam($ar,NULL);
    4490. 

  4490.     $tplentry=$p->get('tplentry');
    4491. 

  4491.     $ret=$this->xset->chk($ar);
    4492. 

  4492.     if(XShell::hasNext()) setSessionVar('message',$ret['message']);
    4493. 

  4493.     return XShell::toScreen1($tplentry, $ret);
    4494. 

  4494.   }
    4495. 

  4495. 

  4496.   /// Prepare l'edition des propriétés d'une source du module
    4497. 

  4497.   public function adminEditSourceProperties($ar=NULL){
    4498. 

  4498.     $p=new XParam($ar,NULL);
    4499. 

  4499.     $tplentry=$p->get('tplentry');
    4500. 

  4500.     $ret=$this->xset->editProperties($ar);
    4501. 

  4501.     return XShell::toScreen1($tplentry, $ret);
    4502. 

  4502.   }
    4503. 

  4503. 

  4504.   /// Enregistre les modifications des propriétés d'une source du module
    4505. 

  4505.   public function adminProcEditSourceProperties($ar=NULL){
    4506. 

  4506.     $p=new XParam($ar,NULL);
    4507. 

  4507.     $tplentry=$p->get('tplentry');
    4508. 

  4508.     $ret=$this->xset->procEditProperties($ar);
    4509. 

  4509.     return XShell::toScreen1($tplentry, $ret);
    4510. 

  4510.   }
    4511. 

  4511. 

  4512.   /// Parcours les valeurs d'un XStringSetDef
    4513. 

  4513.   public function adminBrowseStrings($ar=NULL) {
    4514. 

  4514.     $p=new XParam($ar,NULL);
    4515. 

  4515.     $tset=new XTSet(array('boid'=>$this->boid,'field'=>$field));
    4516. 

  4516.     $tset->browse($ar);
    4517. 

  4517.   }
    4518. 

  4518. 

  4519.   /// Prepare l'ajout d'une valeur à un XStringSetDef
    4520. 

  4520.   public function adminNewString($ar=NULL) {
    4521. 

  4521.     $p=new XParam($ar,NULL);
    4522. 

  4522.     $tset=new XTSet(array('boid'=>$this->boid,'_options'=>array('local'=>true)));
    4523. 

  4523.     $tset->newString($ar);
    4524. 

  4524.   }
    4525. 

  4525. 

  4526.   /// Ajout d'une valeur à un XStringSetDe
    4527. 

  4527.   public function adminProcNewString($ar=NULL) {
    4528. 

  4528.     $p=new XParam($ar,NULL);
    4529. 

  4529.     $tset=new XTSet(array('boid'=>$this->boid,'_options'=>array('local'=>true)));
    4530. 

  4530.     $tset->procNewString($ar);
    4531. 

  4531.     if($ret['error']) setSessionVar('message',$ret['message']);
    4532. 

  4532.   }
    4533. 

  4533. 

  4534.   /// Prepare l'edition d'une valeur d'un XStringSetDef
    4535. 

  4535.   public function adminEditString($ar=NULL) {
    4536. 

  4536.     $p=new XParam($ar,NULL);
    4537. 

  4537.     $tset=new XTSet(array('boid'=>$this->boid,'_options'=>array('local'=>true)));
    4538. 

  4538.     $tset->editString($ar);
    4539. 

  4539.   }
    4540. 

  4540. 

  4541.   /// Enregistre les modification d'une valeur d'un XStringSetDef
    4542. 

  4542.   public function adminProcEditString($ar=NULL) {
    4543. 

  4543.     $p=new XParam($ar,NULL);
    4544. 

  4544.     $tset=new XTSet(array('boid'=>$this->boid,'_options'=>array('local'=>true)));
    4545. 

  4545.     $ret=$tset->procEditString($ar);
    4546. 

  4546.     if($ret['error']) setSessionVar('message',$ret['message']);
    4547. 

  4547.   }
    4548. 

  4548. 

  4549.   /// Supprime une valeur d'un XStringSetDef
    4550. 

  4550.   public function adminDelString($ar=NULL) {
    4551. 

  4551.     $p=new XParam($ar,NULL);
    4552. 

  4552.     $tset=new XTSet(array('boid'=>$this->boid,'_options'=>array('local'=>true)));
    4553. 

  4553.     $tset->delString($ar);
    4554. 

  4554.   }
    4555. 

  4555. 

  4556.   /// Supprime toutes les valeurs d'un XStringSetDef
    4557. 

  4557.   public function adminClearStrings($ar=NULL) {
    4558. 

  4558.     $p=new XParam($ar,NULL);
    4559. 

  4559.     $tset=new XTSet(array('boid'=>$this->boid,'_options'=>array('local'=>true)));
    4560. 

  4560.     $tset->clearStrings($ar);
    4561. 

  4561.   }
    4562. 

  4562. 

  4563.   /// Reoordonne les valeurs d'un XStringSetDef par ordre alphabétique
    4564. 

  4564.   public function adminSortStrings($ar=NULL) {
    4565. 

  4565.     $p=new XParam($ar,NULL);
    4566. 

  4566.     $boid=$p->get('boid');
    4567. 

  4567.     $tset=new XTSet(array('boid'=>$this->boid,'_options'=>array('local'=>true)));
    4568. 

  4568.     $tset->sortStrings($ar);
    4569. 

  4569.   }
    4570. 

  4570. 

  4571.   /// Réinitialise un chrono
    4572. 

  4572.   public function adminResetChrono($ar=NULL){
    4573. 

  4573.     $p=new XParam($ar, array());
    4574. 

  4574.     $table=$this->table;
    4575. 

  4575.     $field=$p->get('field');
    4576. 

  4576.     XDBIni::clear('Chrono::'.$table.'::'.$field);
    4577. 

  4577.   }
    4578. 

  4578. 

  4579.   /// Prepare l'importation d'un csv contenant les regles de securité sur les champs
    4580. 

  4580.   public function adminPreImportFieldsSec($ar=NULL){
    4581. 

  4581.   }
    4582. 

  4582. 

  4583.   /// Importe d'un csv contenant les regles de securité sur les champs
    4584. 

  4584.   /// Colonne en entete : AKOID => nom sql du champ, AFUNCTION => niveau de droit, AGRP => uid ou gid ou chaine de ugrpnames (voir param)
    4585. 

  4585.   public function adminImportFieldsSec($ar=NULL){
    4586. 

  4586.     $p=new XParam($ar,array('delallfields'=>0,'delotherfields'=>0,'file'=>$_FILES['file']['tmp_name'],
    4587. 

  4587. 			    'endofline'=>"\r\n",'separator'=>';','quote'=>"\"",
    4588. 

  4588. 			    'ugrpnames'=>array('AUTH'=>TZR_GROUPID_AUTH,'ALL'=>TZR_USERID_NOBODY)));
    4589. 

  4589.     $ugrpnames=$p->get('ugrpnames');
    4590. 

  4590.     $delbefore=$p->get('delbefore');
    4591. 

  4591.     if(!empty($delbefore)){
    4592. 

  4592.       updateQuery('delete from ACL4 where AMOID="'.$this->_moid.'" and AKOID like "_field-%"');
    4593. 

  4593.       XLogs::update('security', XUser::get_current_user_uid(), 'Delete all fields security rules for '.$this->_moid);
    4594. 

  4594.     }
    4595. 

  4595.     $file=$p->get('file');
    4596. 

  4596. 

  4597.     $message='';
    4598. 

  4598.     $spec->general->endofline=$p->get('endofline');
    4599. 

  4599.     $spec->general->separator=$p->get('separator');
    4600. 

  4600.     $spec->general->quote=$p->get('quote');
    4601. 

  4601.     $rawdata=@file_get_contents($file);
    4602. 

  4602.     $data=_getCSVData($rawdata,$spec);
    4603. 

  4603.     $head=$data[0];
    4604. 

  4604.     $l=count($data);
    4605. 

  4605.     $tot=0;
    4606. 

  4606.     for($i=1;$i<$l;$i++){
    4607. 

  4607.       $row=array();
    4608. 

  4608.       foreach($head as $j=>$h){
    4609. 

  4609.         if($data[$i][$j]==='') continue;
    4610. 

  4610.         $pos=strpos($h,'[');
    4611. 

  4611.         if($pos) $tmp='['.substr($h,0,$pos).']'.substr($h,$pos);
    4612. 

  4612.         else $tmp='['.$h.']';
    4613. 

  4613.         $tmp=str_replace(array('[',']'),array("['","']"),$tmp);
    4614. 

  4614.         $data[$i][$j]=addslashes($data[$i][$j]);
    4615. 

  4615. 	eval('$row'.$tmp.'="'.str_replace('"','\"',$data[$i][$j]).'";');
    4616. 

  4616.       }
    4617. 

  4617.       if(empty($row['AKOID']) || empty($row['AFUNCTION']) || empty($row['AGRP'])){
    4618. 

  4618. 	$message.='AKOID, AFUNCTION ou AGRP manquant ligne '.($i+1).'<br>';
    4619. 

  4619. 	continue;
    4620. 

  4620.       }
    4621. 

  4621.       if(empty($this->xset->desc[$row['AKOID']])){
    4622. 

  4622. 	$message.='Le champ '.$row['AKOID'].' n\'existe pas à la ligne '.($i+1).'<br>';
    4623. 

  4623. 	continue;
    4624. 

  4624.       }
    4625. 

  4625.       if(!in_array($row['AFUNCTION'],array('none','ro','rw'))){
    4626. 

  4626. 	$message.='Les droits doivent être none, ro ou rw à la ligne '.($i+1).'<br>';
    4627. 

  4627. 	continue;
    4628. 

  4628.       }
    4629. 

  4629.       if(!empty($ugrpnames[$row['AGRP']])) $row['AGRP']=$ugrpnames[$row['AGRP']];
    4630. 

  4630.       if(in_array(Kernel::getTable($row['AGRP']),array('USERS','GRP'))){
    4631. 

  4631. 	$rs=selectQuery('select KOID from '.Kernel::getTable($row['AGRP']).' where KOID="'.$row['AGRP'].'"');
    4632. 

  4632. 	if($rs->rowCount()!=1){
    4633. 

  4633. 	  $message.='La cible des droits n\'existe pas à la ligne '.($i+1).'<br>';
    4634. 

  4634. 	  continue;
    4635. 

  4635. 	}
    4636. 

  4636.       }else{
    4637. 

  4637. 	$message.='La cible des droits n\'est ni un USERS ni un GRP à la ligne '.($i+1).'<br>';
    4638. 

  4638. 	continue;
    4639. 

  4639.       }
    4640. 

  4640. 

  4641.       $tot++;
    4642. 

  4642.       $this->procSecEdit(array('oid'=>'_field-'.$row['AKOID'],'level'=>$row['AFUNCTION'],'uid'=>$row['AGRP']));
    4643. 

  4643.     }
    4644. 

  4644.     $message.='Nombre de règle importée : '.$tot.'<br>';
    4645. 

  4645.     XShell::toScreen2('','message',$message);
    4646. 

  4646.   }
    4647. 

  4647. }
    4648. 

  4648. 

  4649. /// Verifie la validité d'un captcha
    4650. 

  4650. function xmodtable_captcha(){
    4651. 

  4651.   $value=$_REQUEST['value'];
    4652. 

  4652.   $id=$_REQUEST['id'];
    4653. 

  4653.   if(!preg_match('/^[a-z0-9A-Z]+$/', $value)) die('0');
    4654. 

  4654.   if(!preg_match('/^[a-z0-9A-Z]+$/', $id)) die('0');
    4655. 

  4655.   $cnt=countSelectQuery('SELECT COUNT(*) from _VARS where name="CAPTCHA_'.$id.'" and value="'.md5($value).'"');
    4656. 

  4656.   if($cnt) die('1');
    4657. 

  4657.   else die('0');
    4658. 

  4658. }
    4659. 

  4659.