PageRenderTime 58ms CodeModel.GetById 22ms RepoModel.GetById 0ms app.codeStats 0ms

/class.xdstable.inc

https://github.com/jcplat/console-seolan
PHP | 1096 lines | 948 code | 60 blank | 88 comment | 186 complexity | 3aa0d5120c4201877aa3d7a327819cb6 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. 

  3. /// Gestion d'une source de donnees de type 'table SQL'
    4. 

  4. class XDSTable extends XDataSource {
    5. 

  5.   public $desc = array();
    6. 

  6.   public $orddesc = array();
    7. 

  7.   public $published_fields_in_admin=2;
    8. 

  8.   public $sendacopytofields=array();
    9. 

  9. 

  10.   function __construct($boid=0) {
    11. 

  11.     XLogs::debug(get_class($this).'::construct: start '.$boid);
    12. 

  12.     $p= new XParam(array(),array());
    13. 

  13.     parent::__construct($boid);
    14. 

  14.     $this->title=XDataSource::$_boid[$boid]->MTXT;
    15. 

  15.     if(!isset(XDataSource::$_boid[$boid]))
    16. 

  16.       XShell::quit($boid.' unknown table ');
    17. 

  17.     else {
    18. 

  18.       $this->translatable = XDataSource::$_boid[$boid]->TRANSLATABLE;
    19. 

  19.       $this->log = XDataSource::$_boid[$boid]->LOG;
    20. 

  20.       $this->autotranslate = XDataSource::$_boid[$boid]->AUTO_TRANSLATE;
    21. 

  21.     }
    22. 

  22.     $this->_getDesc();
    23. 

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

  24.     $verb='xdatasource('.$this->boid.')';
    25. 

  25.     XAudit::plusplus($verb);
    26. 

  26.     XLogs::debug(get_class($this).'::construct: end '.$boid.', '.$this->title);
    27. 

  27.   }
    28. 

  28. 

  29.   /// Initialise les options de la source
    30. 

  30.   public function initOptions() {
    31. 

  31.     parent::initOptions();
    32. 

  32.     $group=XLabels::getSysLabel('xdstable','oidstruct');
    33. 

  33.     $this->_options->setOpt(XLabels::getSysLabel('xdstable','oidstruct1'),'oidstruct1','field',array('table'=>$this->base,'compulsory'=>false),null,$group);
    34. 

  34.     $this->_options->setOpt(XLabels::getSysLabel('xdstable','oidstruct2'),'oidstruct2','field',array('table'=>$this->base,'compulsory'=>false),null,$group);
    35. 

  35.     $this->_options->setOpt(XLabels::getSysLabel('xdstable','oidstruct3'),'oidstruct3','field',array('table'=>$this->base,'compulsory'=>false),null,$group);
    36. 

  36.     $this->_options->setGroupComment(XLabels::getSysLabel('xdstable','oidstructcomment'),'oidstruct1');
    37. 

  37.   }
    38. 

  38. 

  39.   /// Vide la table
    40. 

  40.   public function clear($rq=NULL) {
    41. 

  41.     if(empty($rq) || is_array($rq)) updateQuery('truncate '.$this->base);
    42. 

  42.     else updateQuery('delete from '.$this->base.' where '.$rq);
    43. 

  43.     return array('message'=>XLabels::getSysLabel('xdatasource.update_ok'));
    44. 

  44.   }
    45. 

  45. 

  46.   function make_cond($def, $v) {
    47. 

  47.     $cond='';
    48. 

  48.     if (!is_array($v)) {
    49. 

  49.       throw new Exception('Parameter must be an array with an operator (index 0) and values (index 1)');
    50. 

  50.     }
    51. 

  51.     $op=$v[0];
    52. 

  52.     if(is_array($op)){
    53. 

  53.       $opfield=$op[0];
    54. 

  54.       $opmultiple=$op[1];
    55. 

  55.     }else{
    56. 

  56.       $opfield=$op;
    57. 

  57.       $opmultiple='or';
    58. 

  58.     }
    59. 

  59.     $k=$def->get_field();
    60. 

  60. 

  61.     if(count($v)>2) {
    62. 

  62.       array_shift($v);
    63. 

  63.       foreach($v as $v1=>&$v2) {
    64. 

  64.         if($cond!='') $cond.=' '.$opmultiple.' ';
    65. 

  65. 	$cond.=$this->make_cond($def,array($v[0],$v1));
    66. 

  66.       }
    67. 

  67.       return '('.$cond.')';
    68. 

  68.     }
    69. 

  69.     if(is_array($v[1])) {
    70. 

  70.       foreach($v[1] as $v1=>$v2) {
    71. 

  71. 	if($cond!='') $cond.=' '.$opmultiple.' ';
    72. 

  72. 	$cond.=$this->make_cond($def,array($v[0],$v2));
    73. 

  73.       }
    74. 

  74.       return '('.$cond.')';
    75. 

  75.     }
    76. 

  76.     // dans le cas ou le parametre d'un link n'est pas un link on rajoute la table en tete
    77. 

  77.     if($def->isObjectLink() && !empty($v[1]) && ($v[1]!='NULL') && !Kernel::isAKoid($v[1]) && strstr($v[1],'%')==false) {
    78. 

  78.       $v[1]=$def->get_target().':'.$v[1];
    79. 

  79.     }
    80. 

  80. 

  81.     // traitement sur oid vide
    82. 

  82.     if($def->get_fgender()=='Oid' && $opfield=='=' && ($v[1]=='NULL' || empty($v[1])))
    83. 

  83.       $cond=' ('.$this->base.'.'.$k.'="" or '.$this->base.'.'.$k.' is NULL) ';
    84. 

  84.     // traitement sur oid non vide
    85. 

  85.     elseif($def->get_fgender()=='Oid' && $opfield=='!=' && ($v[1]=='NULL' || empty($v[1])))
    86. 

  86.       $cond=' ('.$this->base.'.'.$k.'!="" and '.$this->base.'.'.$k.' is not NULL) ';
    87. 

  87.     // traitement des valeurs multiples et operateur =
    88. 

  88.     elseif($def->get_multivalued() && $def->get_fgender()=='Oid' && $v[0]=='=')
    89. 

  89.       $cond=' ('.$this->base.'.'.$k.'="'.$v[1].'" or INSTR('.$this->base.'.'.$k.',"||'.$v[1].'||")) ';
    90. 

  90.     // traitement des valeurs avec operateur ==
    91. 

  91.     elseif($def->get_fgender()=='Oid' && $v[0]=='==') {
    92. 

  92.       $v1=$def->get_soid_from_set($v[1]);
    93. 

  93.       $cond=' ('.$this->base.'.'.$k.'="'.$v1.'" or INSTR('.$this->base.'.'.$k.',"||'.$v1.'||")) ';
    94. 

  94.     // traitement des valeurs multiples et operateur !==
    95. 

  95.     } elseif($def->get_multivalued() && $def->get_fgender()=='Oid' && $v[0]=='!==') {
    96. 

  96.       $v1=$def->get_soid_from_set($v[1]);
    97. 

  97.       $cond=' (not('.$this->base.'.'.$k.'="'.$v1.'" or INSTR('.$this->base.'.'.$k.',"||'.$v1.'||"))) ';
    98. 

  98.     // traitement des valeurs non oid
    99. 

  99.     }else{
    100. 

  100.       if($v[1][0]=='=') $cond=' '.$this->base.'.'.$k.' '.$opfield.' '.substr($v[1],1).' ';
    101. 

  101.       else $cond=' '.$this->base.'.'.$k.' '.$opfield.' "'.$v[1].'"';
    102. 

  102.     }
    103. 

  103.     return $cond;
    104. 

  104.   }
    105. 

  105. 

  106.   function make_simple_cond($k,$v) {
    107. 

  107.     $cond='';
    108. 

  108.     $op=$v[0];
    109. 

  109.     if(is_array($op)){
    110. 

  110.       $opfield=$op[0];
    111. 

  111.       $opmultiple=$op[1];
    112. 

  112.     }else{
    113. 

  113.       $opfield=$op;
    114. 

  114.       $opmultiple='or';
    115. 

  115.     }
    116. 

  116.     if(count($v)>2) {
    117. 

  117.       array_shift($v);
    118. 

  118.       foreach($v as $v1=>&$v2) {
    119. 

  119. 	if($cond!='') $cond.=' '.$opmultiple.' ';
    120. 

  120. 	$cond.=$this->make_simple_cond($k,array($op,$v2));
    121. 

  121.       }
    122. 

  122.       return '('.$cond.')';
    123. 

  123.     }
    124. 

  124.     if(is_array($v[1])) {
    125. 

  125.       foreach($v[1] as $v1=>$v2) {
    126. 

  126. 	if($cond!='') $cond.=' '.$opmultiple.' ';
    127. 

  127. 	$cond.=$this->make_simple_cond($k,array($op,$v2));
    128. 

  128.       }
    129. 

  129.       return '('.$cond.')';
    130. 

  130.     }
    131. 

  131.     return ' '.$this->base.'.'.$k.' '.$opfield.' "'.$v[1].'" ';
    132. 

  132.   }
    133. 

  133. 

  134.   /// generation d'une condition utilisable sur le container
    135. 

  135.   function select_query($args=NULL) {
    136. 

  136.     $params=new XParam($args, array('cond'=>array()));
    137. 

  137.     $LANG_DATA = XShell::getLangData($params->get('LANG_DATA'));
    138. 

  138.     $cond = $args['cond'];
    139. 

  139.     if(empty($cond)) $cond=array();
    140. 

  140.     $selectedfields = @$args['selectedfields'];
    141. 

  141.     if(empty($selectedfields)||($selectedfields=='all')) $selectedfields=array('*');
    142. 

  142.     $where = @$args['where'];
    143. 

  143.     $tr=$this->getTranslatable();
    144. 

  144.     if($tr==TZR_LANG_BASEDLANG) {
    145. 

  145.       $txt="{$this->base}.LANG = '".$LANG_DATA."' ";
    146. 

  146.     } elseif($tr==TZR_LANG_FREELANG) {
    147. 

  147.       $txt="{$this->base}.LANG = '".$LANG_DATA."' ";
    148. 

  148.     } else
    149. 

  149.       $txt="{$this->base}.LANG = '".TZR_DEFAULT_LANG."' ";
    150. 

  150. 

  151.     if(!empty($where)) $txt.=' AND ('.$where.') ';
    152. 

  152. 

  153.     $pu=$this->publishedMode($params);
    154. 

  154.     if($pu=='public') {
    155. 

  155.       $txt .= " and {$this->base}.PUBLISH = '1' ";
    156. 

  156.     }
    157. 

  157.     foreach($cond as $k => $v) {
    158. 

  158.       $k1 = trim($k);
    159. 

  159.       if(!empty($this->desc[$k1])) {
    160. 

  160. 	$def = $this->desc[$k1];
    161. 

  161. 	$txt = $txt.' and '.$this->make_cond($def, $v);
    162. 

  162.       } else {
    163. 

  163. 	$txt = $txt.' and '.$this->make_simple_cond($k1, $v);
    164. 

  164.       }
    165. 

  165.     }
    166. 

  166.     $jointcond = NULL;
    167. 

  167.     $order=@$args['order'];
    168. 

  168.     if(!empty($order)) {
    169. 

  169.       $torder=explode(',',$order);
    170. 

  170.       $order=array();
    171. 

  171.       $order=$this->makeOrder($torder,$order,$jointcond);
    172. 

  172.       if(!empty($order)) $txt.=' order by '.$order;
    173. 

  173.     }
    174. 

  174.     if(isset($args['groupby'])) $txt.=' group by '.$args['groupby'];
    175. 

  175.     if(!empty($jointcond))  $query = 'select '.$this->base.'.* from '.$this->base.' '.$jointcond.' where '.$txt;
    176. 

  176.     else $query = 'select '.$this->base.'.* from '.$this->base.' where '.$txt;
    177. 

  177.     return $query;
    178. 

  178.   }
    179. 

  179. 

  180.   function random_select_query($args=NULL) {
    181. 

  181.     $args['order']='RAND(RAND()*20)';
    182. 

  182.     return $this->select_query($args);
    183. 

  183.   }
    184. 

  184. 

  185.   function count_query($args=NULL) {
    186. 

  186.     $params=new XParam($args, array('cond'=>array()));
    187. 

  187.     $LANG_DATA = XShell::getLangData();
    188. 

  188.     $cond = $params->get('cond');
    189. 

  189.     $txt="LANG = '$LANG_DATA' ";
    190. 

  190.     foreach($cond as $k=>$v) {
    191. 

  191.       if(!isset($this->desc[$k])) XShell::quit('XDataSource->select_query: field '.$k.' unknown in table '.$this->base);
    192. 

  192.       $def=&$this->desc[$k];
    193. 

  193.       if($def->get_multivalued() && ($def->get_fgender() == 'Oid')
    194. 

  194. 	 && ($v[0]=='=')) {
    195. 

  195. 	$txt=$txt." and (($k = '$v[1]') or  ($k like '%||$v[1]||%'))";
    196. 

  196.       } else {
    197. 

  197. 	$txt=$txt." and $k $v[0] '$v[1]'  ";
    198. 

  198.       }
    199. 

  199.     }
    200. 

  200.     $query = 'select count(KOID) from '.$this->base.' where '.$txt;
    201. 

  201.     return $query;
    202. 

  202.   }
    203. 

  203. 

  204.   protected function _getDesc($refresh=false) {
    205. 

  205.     $this->desc = array();
    206. 

  206.     $this->orddesc = array();
    207. 

  207.     $orderby=' FORDER '	;
    208. 

  208.     $lang = XShell::getLangUser();
    209. 

  209.     if($lang!=TZR_DEFAULT_LANG) $lang_cond='(MLANG="'.$lang.'" or MLANG="'.TZR_DEFAULT_LANG.'")';
    210. 

  210.     else $lang_cond="MLANG='".$lang."'";
    211. 

  211.     $rs=selectQuery('select * from DICT,MSGS where DTAB = "'.$this->base.'" and MTAB="'.$this->base.'"'.
    212. 

  212. 		     ' and '.$lang_cond.' and DICT.FIELD=MSGS.FIELD order by FORDER');
    213. 

  213.     $i=0;
    214. 

  214.     $ors=array();
    215. 

  215.     while($rs && $ors=$rs->fetch()) {
    216. 

  216.       $field = $ors['FIELD'];
    217. 

  217.       if(empty($this->desc[$field]) || (!empty($this->desc[$field]) && ($ors['MLANG']==$lang))) {
    218. 

  218. 	$o = (object) $ors;
    219. 

  219. 	// si la table n'est pas traduisible, aucun champ ne peut etre traduisible, donc on force cette propriete
    220. 

  220. 	if(empty($this->translatable)) $o->TRANSLATABLE=0;
    221. 

  221. 	$this->desc[$field] = & XFieldDef::objectFactory($o);
    222. 

  222. 	if(!in_array($field, $this->orddesc)) {
    223. 

  223. 	  $this->orddesc[$i]=$field;
    224. 

  224. 	  $i++;
    225. 

  225. 	}
    226. 

  226.       }
    227. 

  227.     }
    228. 

  228.     $rs->closeCursor();
    229. 

  229.   }
    230. 

  230. 

  231.   /// verification que la table des archive existe et construction si elle n'existe pas.
    232. 

  232.   protected function checkArchiveTable($createifneeded=true) {
    233. 

  233.     if(XSystem::tableExists('A_'.$this->base)) return true;
    234. 

  234. 

  235.     updateQuery('CREATE TABLE A_'.$this->base.' AS SELECT * FROM '.$this->base);
    236. 

  236.     return true;
    237. 

  237.   }
    238. 

  238. 

  239.   /// Insere une nouvelle table SQL
    240. 

  240.   static function procNewSource($ar=NULL) {
    241. 

  241.     global $XSHELL;
    242. 

  242.     global $XLANG;
    243. 

  243.     $error=false;
    244. 

  244.     $p=new XParam($ar,array('user_base'=>1,'translatable'=>0,'auto_translate'=>0,'publish'=>1,'own'=>1),'local');
    245. 

  245.     $bname=$p->get('bname');
    246. 

  246.     $btab=$p->get('btab');
    247. 

  247.     $user_base=$p->get('user_base');
    248. 

  248.     $translatable=$p->get('translatable');
    249. 

  249.     $auto_translate=$p->get('auto_translate');
    250. 

  250.     $publish=$p->get('publish');
    251. 

  251.     $own=$p->get('own');
    252. 

  252.     $bparam=$p->get('bparam');
    253. 

  253.     $classname=$p->get('classname');
    254. 

  254.     if(!empty($auto_translate)) $translate=1;
    255. 

  255.     if(empty($classname)) $classname='XDSTable';
    256. 

  256. 

  257.     // Controle des donnees obligatoires
    258. 

  258.     if(isSQLKeyword($btab)) {
    259. 

  259.       $message=$btab.' is a SQL keyword';
    260. 

  260.       $error=true;
    261. 

  261.       XLogs::notice('xbaseadm',$message);
    262. 

  262.     } elseif (empty($bname[TZR_DEFAULT_LANG])) {
    263. 

  263.       $message='Table Name is compulsory in default language ! Try again ...';
    264. 

  264.       $error=true;
    265. 

  265.       XLogs::notice('xbaseadm',$message);
    266. 

  266.     } elseif(empty($btab)) {
    267. 

  267.       $message='SQL Table Name is compulsory ! Try again ...';
    268. 

  268.       $error=true;
    269. 

  269.       XLogs::notice('xbaseadm',$message);
    270. 

  270.     } elseif(rewriteToAscii($btab,false)!=$btab) {
    271. 

  271.       $message='SQL Table Name not [A-Za-z0-9_-] checked ! Try again ...';
    272. 

  272.       $error=true;
    273. 

  273.       XLogs::notice('xbaseadm',$message);
    274. 

  274.     } else{
    275. 

  275.       if(self::createTable($btab,$publish,$own)) {
    276. 

  276. 	$boid=XDataSourceWd::getNewBoid();
    277. 

  277. 	$xml=XOptions::rawToXML($bparam,TZR_ADMINI_CHARSET);
    278. 

  278. 	preparedUpdateQuery('INSERT INTO BASEBASE(BOID,BNAME,BTAB,AUTO_TRANSLATE,TRANSLATABLE,BCLASS,BPARAM) '.
    279. 

  279. 		    'values(?,?,?,?,?,?,?)', array($boid,$bname[TZR_DEFAULT_LANG],$btab,$auto_translate,
    280. 

  280. 						   $translatable,$classname,$xml));
    281. 

  281. 	$XLANG->getCodes();
    282. 

  282. 	for($i=0;$i<$XLANG->nbLang;$i++) {
    283. 

  283. 	  $code=$XLANG->codes[$i];
    284. 

  284. 	  $txt=$bname[$code];
    285. 

  285. 	  if($txt!="") preparedUpdateQuery('INSERT INTO AMSG(MOID,MLANG,MTXT) values (?,?,?)',array($boid,$code,$txt));
    286. 

  286. 	}
    287. 

  287. 	$message='New table '.$bname[TZR_DEFAULT_LANG].' ('.$btab.') created.';
    288. 

  288.       } else {
    289. 

  289. 	$error=true;
    290. 

  290. 	$message='Could not create '.$bname[TZR_DEFAULT_LANG].' ('.$btab.').';
    291. 

  291.       }
    292. 

  292.     }
    293. 

  293.     return array('message'=>$message,'error'=>$error);
    294. 

  294.   }
    295. 

  295. 

  296.   /// Créé une table SQL et son dictionnaire
    297. 

  297.   static function createTable($table,$valid=true,$own=true) {
    298. 

  298.     if(XSystem::tableExists($table)) return false;
    299. 

  299. 

  300.     $q='CREATE TABLE '.$table.' (KOID varchar(40) DEFAULT \'0\' NOT NULL, LANG char(2) NOT NULL, UPD TIMESTAMP,'.
    301. 

  301.       ($own  ?'OWN varchar(40),':'').
    302. 

  302.       ($valid?'PUBLISH tinyint(4) default 1,':'').' PRIMARY KEY (KOID, LANG))';
    303. 

  303.     updateQuery($q);
    304. 

  304.     if(!XSystem::tableExists($table, true)) return false;
    305. 

  305.     // Creation du dictionnaire et de msgs
    306. 

  306.     $order=0;
    307. 

  307.     updateQuery("INSERT INTO DICT values('$table','UPD','XTimestampDef',0,0,0,0,0,1,0,0,'%','')");
    308. 

  308.     updateQuery("INSERT INTO MSGS values('$table','UPD','".TZR_DEFAULT_LANG."','".XLabels::getSysLabel('general','last_update','text')."')");
    309. 

  309.     $order++;
    310. 

  310.     if($own) {
    311. 

  311.       updateQuery("INSERT INTO DICT values('$table','OWN','XLinkDef',0,$order,0,1,0,1,0,0,'USERS','')");
    312. 

  312.       updateQuery("INSERT INTO MSGS values('$table','OWN','".TZR_DEFAULT_LANG."','".XLabels::getSysLabel('general','owner','text')."' )");
    313. 

  313.       $order++;
    314. 

  314.     }
    315. 

  315.     if($valid) {
    316. 

  316.       updateQuery("INSERT INTO DICT values ('$table','PUBLISH','XBoolDef',0,$order,0,0,0,1,0,0,'%','')");
    317. 

  317.       updateQuery("INSERT INTO MSGS values ('$table','PUBLISH','".TZR_DEFAULT_LANG."','".XLabels::getSysLabel('general','approved','text')."')");
    318. 

  318.       $order++;
    319. 

  319.     }
    320. 

  320.     return true;
    321. 

  321.   }
    322. 

  322. 

  323.   /// Parcours les champs de la table
    324. 

  324.   function browseFields($ar=NULL){
    325. 

  325.     $p=new XParam($ar,NULL);
    326. 

  326.     $refresh=$p->get('refresh');
    327. 

  327.     $addOption = substr($p->get('addOption'), 2); //option additionelle prefixée par __
    328. 

  328.     $this->_getDesc($refresh);
    329. 

  329.     $groups=array();
    330. 

  330.     $allOpts = array();
    331. 

  331.     if(is_array($this->orddesc)) {
    332. 

  332.       foreach($this->orddesc as $o => $field) {
    333. 

  333.         $v=&$this->desc[$field];
    334. 

  334.         $i=array_search($v->fgroup,$groups);
    335. 

  335.         if($i===false){
    336. 

  336.           $i=array_push($groups,$v->fgroup)-1;
    337. 

  337.         }
    338. 

  338.         $tableGroup[$field]='group_'.$i;
    339. 

  339.         //option additionelle
    340. 

  340.         $optUI = '';
    341. 

  341. 	foreach ($v->getOptions('addOptions') as $opt) {
    342. 

  342. 	  $allOpts[$opt['field']] = $opt['label'];
    343. 

  343.           if ($opt['field'] == $addOption) {
    344. 

  344.             $optUI = $opt['edit'];
    345. 

  345.           }
    346. 

  346.         }
    347. 

  347.         $tableAddOption[$field] = $optUI;
    348. 

  348.       }
    349. 

  349.     }    
    350. 

  350.     $result=array();
    351. 

  351.     $result['tableObject']=$this->desc;
    352. 

  352.     $result['tableGroup']=$tableGroup;
    353. 

  353.     $result['groups']=$groups;
    354. 

  354.     $result['table']=$this->base;
    355. 

  355.     $result['boid']=$this->boid;
    356. 

  356.     asort($allOpts);
    357. 

  357.     $result['allOpts']=$allOpts;
    358. 

  358.     $result['addOption']=$tableAddOption;
    359. 

  359.     list($types, $labels)=XFieldDef::getTypes();
    360. 

  360.     foreach ($types as $i => $type)
    361. 

  361.       $type_labels[$type] = $labels[$i];
    362. 

  362.     $result['type_labels']=$type_labels;
    363. 

  363.     return $result;
    364. 

  364.   }
    365. 

  365. 

  366.   /// Prepare la création d'un nouveau champ
    367. 

  367.   function newField($ar=NULL) {
    368. 

  368.     $p=new XParam($ar,NULL);
    369. 

  369.     $fnumber=$this->newFieldName();
    370. 

  370.     $types=XFieldDef::getTypes();
    371. 

  371.     $type=$types[0];
    372. 

  372.     $type_labels=$types[1];
    373. 

  373.     $btranslatable=$this->isTranslatable();
    374. 

  374.     $liste=$this->getBaseList();
    375. 

  375.     reset($liste);
    376. 

  376.     $target_key=array(TZR_DEFAULT_TARGET);
    377. 

  377.     $target_val=array("---");
    378. 

  378.     foreach($liste as $k=>$my) {
    379. 

  379.       $my_xst=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$k);
    380. 

  380.       if($my_xst->isTherePublishedField()) {
    381. 

  381. 	$target_key[]=$k;
    382. 

  382. 	$target_val[]=$my;
    383. 

  383.       }
    384. 

  384.     }
    385. 

  385.     $forder=$this->newFieldOrder();
    386. 

  386.     $result=array();
    387. 

  387.     $result['table']=$this->base;
    388. 

  388.     $result['boid']=$this->boid;
    389. 

  389.     $result['fnumber']=$fnumber;
    390. 

  390.     $result['type']=$type;
    391. 

  391.     $result['type_labels']=$type_labels;
    392. 

  392.     $result['type_default']='XShortTextDef';
    393. 

  393.     $result['btranslatable']=$btranslatable;
    394. 

  394.     $result['target_key']=$target_key;
    395. 

  395.     $result['target_val']=$target_val;
    396. 

  396.     $result['forder']=$forder;
    397. 

  397.     return $result;
    398. 

  398.   }
    399. 

  399. 

  400.   /// Enregistre un nouveau champ
    401. 

  401.   public function procNewField($ar=NULL) {
    402. 

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

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

  404.     $ftype=$p->get('ftype');
    405. 

  405.     $fcount=$p->get('fcount');
    406. 

  406.     $forder=$p->get('forder');
    407. 

  407.     $compulsory=$p->get('compulsory');
    408. 

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

  409.     $browsable=$p->get('browsable');
    410. 

  410.     $translatable=$p->get('translatable');
    411. 

  411.     $multivalued=$p->get('multivalued');
    412. 

  412.     $published=$p->get('published');
    413. 

  413.     $label=$p->get('label');
    414. 

  414.     $target=$p->get('target');
    415. 

  415.     $options=$p->get('options');
    416. 

  416.     $options=array_stripslashes($options);
    417. 

  417.     $error=false;
    418. 

  418.     $table=$this->getTable();
    419. 

  419.     // Controle des donnees obligatoires
    420. 

  420.     if(!$this->newFieldDescIsCorrect($field,$ftype,$fcount,$forder,$compulsory,$queryable,$browsable,$translatable,$multivalued,
    421. 

  421. 				     $published,$target,$label) ) {
    422. 

  422.       $message='Incorrect description for field '.$label[TZR_DEFAULT_LANG].' ! Try again.<br/>';
    423. 

  423.       $error=true;
    424. 

  424.     }elseif($this->fieldExists($field)){
    425. 

  425.       $message='Field '.$label[TZR_DEFAULT_LANG].' already exists ! Try again ...<br/>';
    426. 

  426.       $error=true;
    427. 

  427.     }else{
    428. 

  428.       $this->newDesc($field,$ftype,$fcount,$forder,$compulsory,$queryable,$browsable,$translatable,$multivalued,$published,$target,$label,
    429. 

  429. 		     $options);
    430. 

  430.       $this->sql_newFieldDesc($field);
    431. 

  431.       $this->majUpOtherFieldOrder($field,$forder);
    432. 

  432.       $this->sql_newField($field);
    433. 

  433.       $message='Field '.$label[TZR_DEFAULT_LANG].' created<br/>';
    434. 

  434.     }
    435. 

  435.     XLogs::update('newfield',NULL,$table.':'.$field.' '.$message);
    436. 

  436.     $result=array('message'=>$message,'error'=>$error);
    437. 

  437.     return $result;
    438. 

  438.   }
    439. 

  439. 

  440.   /// Ajoute un champ du desc dans le dictionnaire
    441. 

  441.   function sql_newFieldDesc($field) {
    442. 

  442.     if(!is_array($this->desc)) return false;
    443. 

  443.     if(empty($this->desc[$field])) return false;
    444. 

  444. 

  445.     // Insertion dans DICT
    446. 

  446.     $def=$this->desc[$field];
    447. 

  447.     $ftype=$def->get_ftype();
    448. 

  448.     $fcount=$def->get_fcount();
    449. 

  449.     $forder=$def->get_forder();
    450. 

  450.     $compulsory=($def->get_compulsory()?"1":"0");
    451. 

  451.     $queryable=($def->get_queryable()?"1":"0");
    452. 

  452.     $browsable=$def->get_browsable();
    453. 

  453.     $translatable=$def->get_translatable();
    454. 

  454.     $multivalued=$def->get_multivalued();
    455. 

  455.     $published=$def->get_published();
    456. 

  456.     $target=$def->get_target();
    457. 

  457.     $t1=$def->_options->toXML($def);
    458. 

  458.     $dparam=addslashes($t1);
    459. 

  459.     updateQuery('INSERT INTO DICT (DTAB,FIELD,FTYPE,FCOUNT,FORDER,COMPULSORY,QUERYABLE,BROWSABLE,TRANSLATABLE,MULTIVALUED,PUBLISHED,'.
    460. 

  460. 		'TARGET,DPARAM) values ("'.$this->base.'","'.$field.'","'.$ftype.'","'.$fcount.'","'.$forder.'","'.$compulsory.'",'.
    461. 

  461. 		'"'.$queryable.'","'.$browsable.'","'.$translatable.'","'.$multivalued.'","'.$published.'","'.$target.'","'.$dparam.'")');
    462. 

  462. 

  463.     // Insertion des labels dans MSGS
    464. 

  464.     $msg=$def->get_labels();
    465. 

  465.     foreach($msg as $lg=>$m) {
    466. 

  466.       updateQuery('INSERT INTO MSGS (MTAB,FIELD,MLANG,MTXT) values ("'.$this->base.'","'.$field.'","'.$lg.'","'.$m.'")');;
    467. 

  467.     }
    468. 

  468.     return true;
    469. 

  469.   }
    470. 

  470. 

  471.   /// Ajout du champ dans la table SQL
    472. 

  472.   function sql_newField($field) {
    473. 

  473.     if(!is_array($this->desc)) return false;
    474. 

  474.     if(empty($this->desc[$field])) return false;
    475. 

  475.     $def=$this->desc[$field];
    476. 

  476.     $sqltype=$def->sqltype();
    477. 

  477.     updateQuery('alter table '.$this->base.' add '.$field.' '.$sqltype);
    478. 

  478.     // Ajoute le champ à la table des archives si elle existe
    479. 

  479.     if(XSystem::tableExists('A_'.$this->base)) updateQuery('alter table A_'.$this->base.' add '.$field.' '.$sqltype);
    480. 

  480.   }
    481. 

  481. 

  482.   /// Prepare la création / l'édition d'un champ
    483. 

  483.   public function editField($ar=NULL) {
    484. 

  484.     GLOBAL $XLANG;
    485. 

  485.     $p=new XParam($ar,NULL);
    486. 

  486.     $LANG_USER=XShell::getLangUser();
    487. 

  487.     $LANG_DATA=XShell::getLangData();
    488. 

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

  489.     $XLANG->getCodes();
    490. 

  490.     if(is_array($XLANG->codes) && is_array($this->desc)) {
    491. 

  491.       $v=$this->desc[$field];
    492. 

  492.       // Labels
    493. 

  493.       $labels=$v->get_labels();
    494. 

  494.       for($myi=0;$myi<$XLANG->nbLang;$myi++) $fnames[$myi]=$labels[$XLANG->codes[$myi]];
    495. 

  495.       // Number
    496. 

  496.       $fnumber=$field;
    497. 

  497.       // Type
    498. 

  498.       $types=XFieldDef::getTypes();
    499. 

  499.       $type=$types[0];// liste des types
    500. 

  500.       $type_labels=$types[1];// liste des libelles
    501. 

  501.       foreach($type as $i=>$ft) {
    502. 

  502. 	if($v->get_ftype()==$ft ) $type_selectionFlag[]='selected';
    503. 

  503. 	else $type_selectionFlag[]='';
    504. 

  504.       }
    505. 

  505.       $fcount=$v->get_fcount();
    506. 

  506.       $compulsory=$v->get_compulsory();
    507. 

  507.       $queryable=$v->get_queryable();
    508. 

  508.       $browsable=$v->get_browsable();
    509. 

  509.       $btranslatable=$this->isTranslatable();
    510. 

  510.       $translatable=$v->get_translatable();
    511. 

  511.       $multivalued=$v->get_multivalued();
    512. 

  512.       $published=$v->get_published();
    513. 

  513.       $liste=$this->getBaseList();
    514. 

  514.       reset($liste);
    515. 

  515.       $target_key=array(TZR_DEFAULT_TARGET);
    516. 

  516.       $target_val=array('---');
    517. 

  517.       $target_selectionFlag=array('');
    518. 

  518.       foreach($liste as $k=>$my) {
    519. 

  519.         $my_xst=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$k);
    520. 

  520.         if($my_xst->isTherePublishedField()) {
    521. 

  521. 	  $target_key[]=$k;
    522. 

  522. 	  $target_val[]=$my;
    523. 

  523. 	  if($v->get_target()==$k ) $target_selectionFlag[]="selected";
    524. 

  524. 	  else $target_selectionFlag[]="";
    525. 

  525.         }
    526. 

  526.       }
    527. 

  527.       $forder=$v->get_forder();
    528. 

  528.       $opts=$v->getOptions('options');
    529. 

  529.       $result['options']=$opts;
    530. 

  530.     }
    531. 

  531.     $result['table']=$this->base;
    532. 

  532.     $result['boid']=$this->boid;
    533. 

  533.     $result['field']=$field;
    534. 

  534.     $result['fnames']=$fnames;
    535. 

  535.     $result['fnumber']=$fnumber;
    536. 

  536.     $result['type_selectionFlag']=$type_selectionFlag;
    537. 

  537.     $result['type']=$type;
    538. 

  538.     $result['type_labels']=$type_labels;
    539. 

  539.     $result['fcount']=$fcount;
    540. 

  540.     $result['ftype']=$v->get_ftype();
    541. 

  541.     $result['compulsory']=$compulsory;
    542. 

  542.     $result['queryable']=$queryable;
    543. 

  543.     $result['browsable']=$browsable;
    544. 

  544.     $result['btranslatable']=$btranslatable;
    545. 

  545.     $result['translatable']=$translatable;
    546. 

  546.     $result['multivalued']=$multivalued;
    547. 

  547.     $result['published']=$published;
    548. 

  548.     $result['target_key']=$target_key;
    549. 

  549.     $result['target_val']=$target_val;
    550. 

  550.     $result['target_selectionFlag']=$target_selectionFlag;
    551. 

  551.     $result['forder']=$forder;
    552. 

  552.     return $result;
    553. 

  553.   }
    554. 

  554. 

  555.   /// Enregistre les modifications sur un champ
    556. 

  556.   function procEditField($ar) {
    557. 

  557.     global $XLANG;
    558. 

  558.     $XLANG->getCodes();
    559. 

  559.     $p=new XParam($ar,array('batch'=>'0','options'=>NULL));
    560. 

  560.     $field=$p->get('field');
    561. 

  561.     $def=$this->desc[$field];
    562. 

  562.     // Pour chaque parametre, on verifie si une nouvelle valeur est spécifiée, sinon on garde l'ancienne
    563. 

  563.     $ftype=$p->get('ftype');
    564. 

  564.     if(!$ftype) $ftype=$def->get_ftype();
    565. 

  565.     $fcount=$p->get('fcount');
    566. 

  566.     if(!$fcount) $fcount=$def->get_fcount();
    567. 

  567.     $forder=$p->get('forder');
    568. 

  568.     if(!empty($forder)) {
    569. 

  569.       $forder = $this->_guessFieldOrder($forder);
    570. 

  570.     } else {
    571. 

  571.       $forder = $def->get_forder();
    572. 

  572.     }
    573. 

  573.     $compulsory=$p->get('compulsory');
    574. 

  574.     $compulsory_hid=$p->get('compulsory_HID');
    575. 

  575.     if(!$compulsory && $compulsory!==false && $compulsory_hid!=2) $compulsory=$def->get_compulsory();
    576. 

  576.     else $compulsory=($compulsory=='on'?1:0);
    577. 

  577.     $queryable=$p->get('queryable');
    578. 

  578.     $queryable_hid=$p->get('queryable_HID');
    579. 

  579.     if(!$queryable && $queryable!==false && $queryable_hid!=2) $queryable=$def->get_queryable();
    580. 

  580.     else $queryable=($queryable=='on'?1:0);
    581. 

  581.     $browsable=$p->get('browsable');
    582. 

  582.     $browsable_hid=$p->get('browsable_HID');
    583. 

  583.     if(!$browsable && $browsable!==false && $browsable_hid!=2) $browsable=$def->get_browsable();
    584. 

  584.     else $browsable=($browsable=='on'?1:0);
    585. 

  585.     $translatable=$p->get('translatable');
    586. 

  586.     $translatable_hid=$p->get('translatable_HID');
    587. 

  587.     if(!$translatable && $translatable!==false && $translatable_hid!=2) $translatable=$def->get_translatable();
    588. 

  588.     else $translatable=($translatable=='on'?1:0);
    589. 

  589.     $multivalued=$p->get('multivalued');
    590. 

  590.     $multivalued_hid=$p->get('multivalued_HID');
    591. 

  591.     if(!$multivalued && $multivalued!==false && $multivalued_hid!=2) $multivalued=$def->get_multivalued();
    592. 

  592.     else $multivalued=($multivalued=='on'?1:0);
    593. 

  593.     $published=$p->get('published');
    594. 

  594.     $published_hid=$p->get('published_HID');
    595. 

  595.     if(!$published && $published!==false && $published_hid!=2) $published=$def->get_published();
    596. 

  596.     else $published=($published=='on'?1:0);
    597. 

  597.     $label=$p->get('label');
    598. 

  598.     $target=$p->get('target');
    599. 

  599.     if(empty($target)) $target=$def->get_target();
    600. 

  600.     $batch=$p->get('batch');
    601. 

  601.     $options=$p->get('options');
    602. 

  602.     $error=false;
    603. 

  603. 

  604.     // Remplissage des options non definit
    605. 

  605.     $def->_options->procDialog($def,$options);
    606. 

  606.     if(!$this->fieldDescIsCorrect($field,$ftype,$fcount,$forder,$compulsory,$queryable,$browsable,$translatable,$multivalued,$published,
    607. 

  607. 				  $target,$label)) {
    608. 

  608.       $message='Incorrect description ! Try again.<br/>';
    609. 

  609.       $error=true;
    610. 

  610.     }else{
    611. 

  611.       $this->sql_changeFieldDesc($field,$ftype,$fcount,$forder,$compulsory,$queryable,$browsable,$translatable,$multivalued,$published,
    612. 

  612. 				 $target,$label,$XLANG->codes,$options);
    613. 

  613.       $this->majOtherFieldOrder($field,$def->get_forder(),$forder);
    614. 

  614.       $this->sql_changeField($field,$ftype,$fcount);
    615. 

  615.       $this->changeDesc($field,$ftype,$fcount,$forder,$compulsory,$queryable,$browsable,$translatable,$multivalued,$published,$target,
    616. 

  616. 			$label);
    617. 

  617.       $message.='Field '.$field.' modified.<br/>';
    618. 

  618.     }
    619. 

  619.     // Convertit les données présentes en base si necessaire
    620. 

  620.     $this->desc[$field]->convertValues($def->get_ftype());
    621. 

  621. 

  622.     // Efface le cache
    623. 

  623.     XDbIni::clear('modules'.$this->base);
    624. 

  624.     // efface le cache des chronos
    625. 

  625.     XDbIni::clear('Chrono%'.$this->base.'%');
    626. 

  626.     return array('message'=>$message,'error'=>$error);
    627. 

  627.   }
    628. 

  628. 

  629.   /// Modifie un champ du desc dans le dictionnaire
    630. 

  630.   function sql_changeFieldDesc($field,$ftype,$fcount,$forder,$compulsory,$queryable,$browsable,$translatable,$multivalued,$published,
    631. 

  631. 			       $target,$label,$langs,$options=NULL) {
    632. 

  632.     $def=$this->desc[$field];
    633. 

  633.     $t1=$def->_options->toXML($def);
    634. 

  634. 

  635.     preparedUpdateQuery('UPDATE DICT set FTYPE="'.$ftype.'",FCOUNT='.$fcount.',FORDER='.$forder.',COMPULSORY='.$compulsory.','.
    636. 

  636. 			'QUERYABLE='.$queryable.',BROWSABLE='.$browsable.',TRANSLATABLE='.$translatable.',MULTIVALUED='.$multivalued.','.
    637. 

  637. 			'PUBLISHED='.$published.',TARGET="'.$target.'",DPARAM=? where FIELD="'.$field.'" and DTAB="'.$this->base.'"',
    638. 

  638. 			array($t1));
    639. 

  639. 

  640.     $oldlabel=$def->get_labels();
    641. 

  641.     reset($langs);
    642. 

  642.     while(list($k,$l)=each($langs)) {
    643. 

  643.       if($label[$l]!=$oldlabel[$l]){
    644. 

  644. 	if($label[$l]!=''){
    645. 

  645. 	  if(isset($oldlabel[$l]))
    646. 

  646. 	    preparedUpdateQuery('UPDATE MSGS set MTXT=? where MTAB="'.$this->base.'" and FIELD="'.$field.'" and MLANG="'.$l.'"', array($label[$l]));
    647. 

  647. 	  else
    648. 

  648. 	    preparedUpdateQuery('INSERT INTO MSGS (MTAB,FIELD,MLANG,MTXT) values ("'.$this->base.'","'.$field.'","'.$l.'",?)', array($label[$l]));
    649. 

  649. 	}else{
    650. 

  650. 	  updateQuery('DELETE FROM MSGS where MTAB="'.$this->base.'" and FIELD="'.$field.'" and MLANG="'.$l.'"');
    651. 

  651. 	}
    652. 

  652.       }
    653. 

  653.     }
    654. 

  654.   }
    655. 

  655. 

  656.   /// Modifie un champ dans la table SQL
    657. 

  657.   function sql_changeField($field,$ftype,$fcount) {
    658. 

  658.     $def=$this->desc[$field];
    659. 

  659.     if($def->get_ftype()!=$ftype || $def->get_fcount()!=$fcount) {
    660. 

  660.       $t['FTYPE']=$ftype;
    661. 

  661.       $t['FCOUNT']=$fcount;
    662. 

  662.       $t['FIELD']='bidon';
    663. 

  663.       $obj=(object)$t;
    664. 

  664.       $new=&XFieldDef::objectFactory($obj);
    665. 

  665.       $new->set_fcount($fcount);
    666. 

  666.       $sqltype=$new->sqltype();
    667. 

  667.       updateQuery('alter table '.$this->base.' modify '.$field.' '.$sqltype);
    668. 

  668.       // Modifie la table des archives si elle existe
    669. 

  669.       if(XSystem::tableExists('A_'.$this->base)) updateQuery('alter table A_'.$this->base.' modify '.$field.' '.$sqltype);
    670. 

  670.     }
    671. 

  671.   }
    672. 

  672. 

  673.   /// Suppression d'un champ
    674. 

  674.   function delField($ar=NULL) {
    675. 

  675.     $p=new XParam($ar,NULL);
    676. 

  676.     $field=$p->get('field');
    677. 

  677.     $message='';
    678. 

  678.     $error=false;
    679. 

  679.     if(!$this->deleteIsSafe($message,$field)) {
    680. 

  680.       $message.='<br/>Field $field not deleted. <br/>';
    681. 

  681.       $error=true;
    682. 

  682.     }else{
    683. 

  683.       $def=$this->desc[$field];
    684. 

  684.       // Action specifique sur suppression d'un champ, par exemple suppression des fichier
    685. 

  685.       $def->delfield();
    686. 

  686.       // Suppression du tuple dans les tables
    687. 

  687.       updateQuery('DELETE FROM SETS WHERE STAB="'.$this->base.'" AND FIELD="'.$field.'"');
    688. 

  688.       $this->sql_delFieldDesc($field);
    689. 

  689.       $this->majDownOtherFieldOrder($field,$def->get_forder());
    690. 

  690.       $this->sql_delField($field);
    691. 

  691.       $this->delDesc($field);
    692. 

  692.       // Suppression des droits sur le champ
    693. 

  693.       $mods=XModule::modulesUsingTable($this->base,true,false,false);
    694. 

  694.       if(!empty($mods)) {
    695. 

  695. 	foreach($mods as $moid => $name) {
    696. 

  696. 	  updateQuery('delete from ACL4 where AMOID="'.$moid.'" and AKOID="_field-'.$field.'"');
    697. 

  697. 	}
    698. 

  698.       }
    699. 

  699.       // Il n'y a plus de champ de description. Suppression des tuples de data dans Txxx et Kernel et les annexes
    700. 

  700.       if(!count($this->desc)) $this->clear();
    701. 

  701.       $message.='Field '.$field.' '.XLabels::getSysLabel('general.deleted').'.<br/>';
    702. 

  702.     }
    703. 

  703.     XLogs::update('delfield', NULL, $this->base.':'.$field.' '.$message);
    704. 

  704.     XDbIni::clear('modules'.$this->base);
    705. 

  705.     return array('message'=>$message,'error'=>$error);
    706. 

  706.   }
    707. 

  707. 

  708.   /// Verifie si un champ peut etre supprimé
    709. 

  709.   function deleteIsSafe(&$out,$field) {
    710. 

  710.     // Verifie que ce n'est pas un champ systeme
    711. 

  711.     if(in_array($field,array('UPD','KOID','LANG'))) {
    712. 

  712.       $out='Champ obligatoire : impossible de supprimer';
    713. 

  713.       return false;
    714. 

  714.     }
    715. 

  715.     $def=$this->desc[$field];
    716. 

  716.     $fieldLabel=$def->get_label();
    717. 

  717.     // Le champ est publié
    718. 

  718.     if($def->get_published()) {
    719. 

  719.       // Comptage du nombre de champs published sur la table
    720. 

  720.       if($this->getPublishedFieldCount()==1) {
    721. 

  721. 	$links=XDSTable::fieldsUsingTable($this->base);
    722. 

  722. 	// Des champs utilisent cette table comme source de données
    723. 

  723.         if(count($links)) {
    724. 

  724.           if(count($this->desc)==1) {
    725. 

  725. 	    // Le champ est le dernier de la table, il ne peut etre supprimé
    726. 

  726.             $out.='Field '.$fieldLabel.' ('.$field.') is the only published field !<br/>';
    727. 

  727. 	    $out.='No other field can be set published instead ...<br/>';
    728. 

  728. 	    $out.='Delete is not safe.<br/>';
    729. 

  729. 	    return false;
    730. 

  730.           }else{
    731. 

  731. 	    // Le champ n'est pas le dernier de la table, on met d'office le premier field a published
    732. 

  732.             $rs=selectQuery('select FIELD from DICT where DTAB="'.$this->base.'" and FORDER!='.$def->get_forder().' order by FORDER');
    733. 

  733. 	    if($ors=$rs->fetch()){
    734. 

  734. 	      $f=$ors['FIELD'];
    735. 

  735.               $fdef=$this->desc[$f];
    736. 

  736.               $fLabel=$fdef->get_label();
    737. 

  737. 	      $fdef->set_published(true);
    738. 

  738. 	      updateQuery('UPDATE DICT set DTAB="'.$this->base.'" and PUBLISHED=1 where FIELD="'.$f.'"');
    739. 

  739.               $out.='Field '.$fieldLabel.' ('.$field.') was the only published field !<br/>';
    740. 

  740.               $out.='Field '.$fLabel.' ('.$f.') is automatically set published instead ...<br/>';
    741. 

  741. 	    }
    742. 

  742. 	    $out.='Delete is now safe.<br/>';
    743. 

  743.           }
    744. 

  744.         }
    745. 

  745.       }
    746. 

  746.     }
    747. 

  747.     return true;
    748. 

  748.   }
    749. 

  749. 

  750.   /// Supprime un champ du desc du dictionnaire
    751. 

  751.   function sql_delFieldDesc($field) {
    752. 

  752.     updateQuery('DELETE FROM DICT where FIELD="'.$field.'" and DTAB="'.$this->base.'"');
    753. 

  753.     updateQuery('DELETE FROM MSGS where MTAB="'.$this->base.'" and FIELD="'.$field.'"');
    754. 

  754.     updateQuery('DELETE FROM AMSG where MOID LIKE "'.$this->base.':'.$field.':%"');
    755. 

  755.   }
    756. 

  756. 

  757.   // maj des la structure de la table Txxx pour suppression de la colonne Fxxxx
    758. 

  758.   //
    759. 

  759.   function sql_delField($field) {
    760. 

  760.     $def=$this->desc[$field];
    761. 

  761.     // drop column col_name
    762. 

  762.     $requete = "alter table " . $this->base . " drop $field";
    763. 

  763.     updateQuery($requete);
    764. 

  764.     if(XSystem::tableExists('A_'.$this->base)) {
    765. 

  765.       $requete = "alter table A_" . $this->base . " drop $field";
    766. 

  766.       updateQuery($requete);
    767. 

  767.     }
    768. 

  768.   }
    769. 

  769. 

  770.   /// Met à jour l'ordre des champs dans DICT par le haut
    771. 

  771.   function majUpOtherFieldOrder($field,$forder) {
    772. 

  772.     updateQuery('UPDATE DICT SET FORDER=FORDER+1 where DTAB="'.$this->base.'" and FIELD!="'.$field.'" and FORDER>="'.$forder.'"');
    773. 

  773.   }
    774. 

  774. 

  775.   /// Met à jour l'ordre des champs dans DICT par le bas
    776. 

  776.   function majDownOtherFieldOrder($field,$forder) {
    777. 

  777.     updateQuery('UPDATE DICT SET FORDER=FORDER-1 where DTAB="'.$this->base.'" and FIELD!="'.$field.'" and FORDER>"'.$forder.'"');
    778. 

  778.   }
    779. 

  779. 

  780.   /// Met à jour l'ordre des champs dans DICT
    781. 

  781.   function majOtherFieldOrder($field,$oldOrder,$newOrder) {
    782. 

  782.     // Si augmente, -- sur les order > old et <= new
    783. 

  783.     if($newOrder>$oldOrder ){
    784. 

  784.       updateQuery('UPDATE DICT set FORDER=FORDER-1 where DTAB="'.$this->base.'" and FIELD!="'.$field.'" and FORDER>'.$oldOrder.' and '.
    785. 

  785. 		  'FORDER<='.$newOrder);
    786. 

  786.     }
    787. 

  787.     // Si diminue, ++ sur les order >= new et < old
    788. 

  788.     if($newOrder<$oldOrder) {
    789. 

  789.       updateQuery('UPDATE DICT set FORDER=FORDER+1 where DTAB="'.$this->base.'" and FIELD!="'.$field.'" and FORDER>='.$newOrder.' and '.
    790. 

  790. 		  'FORDER<'.$oldOrder);
    791. 

  791.     }
    792. 

  792.   }
    793. 

  793. 

  794.   /// Récupère le nombre de champ publié
    795. 

  795.   function getPublishedFieldCount() {
    796. 

  796.     $c = 0;
    797. 

  797.     $requete = "select count(*) from DICT where DTAB='$this->base' and PUBLISHED=".true;
    798. 

  798.     $rs=selectQueryByNum($requete);
    799. 

  799.     $ors=array();
    800. 

  800.     if ( $ors=$rs->fetch() ) $c = $ors[0];
    801. 

  801.     $rs->closeCursor();
    802. 

  802.     return $c;
    803. 

  803.   }
    804. 

  804. 

  805.   /// Genere un nouveau nom de table
    806. 

  806.   static function newTableNumber($prefix='T',$add=0) {
    807. 

  807.     $tmax=$prefix.'001';
    808. 

  808.     while(1){
    809. 

  809.       if(XSystem::tableExists($tmax,true) || XDataSource::sourceExists($tmax)) $tmax++;
    810. 

  810.       elseif($add){
    811. 

  811. 	$tmax++;
    812. 

  812. 	$add--;
    813. 

  813.       } else break;
    814. 

  814.     }
    815. 

  815.     return $tmax;
    816. 

  816.   }
    817. 

  817. 

  818.   /// Prepare la duplication d'une source
    819. 

  819.   public function duplicateDataSource($ar=NULL){
    820. 

  820.     return array('newtable'=>XDSTable::newTableNumber(),'mtxt'=>'- '.$this->getSourceName(),'boid'=>$this->boid);
    821. 

  821.   }
    822. 

  822. 

  823.   /// Duplique la source
    824. 

  824.   public function procDuplicateDataSource($ar=NULL){
    825. 

  825.     $p=new XParam($ar,array('tplentry'=>''));
    826. 

  826.     $tplentry = $p->get('tplentry');
    827. 

  827.     $bnewtab=$p->get('newtable');
    828. 

  828.     $bnewoid=XDataSourceWd::getNewBoid();
    829. 

  829.     $bnewlib=$p->get('mtxt');
    830. 

  830.     $data=$p->get('data');
    831. 

  831.     $btab=$this->base;
    832. 

  832.     $boid=$this->boid;
    833. 

  833.     if(empty($bnewtab) || (!empty($bnewtab) && XSystem::tableExists($bnewtab))) $bnewtab = XDSTable::newTableNumber();
    834. 

  834.     if(empty($bnewlib)){
    835. 

  835.       $ors=selectQueryGetOne('SELECT * FROM AMSG WHERE MOID="'.$boid.'" LIMIT 0,1');
    836. 

  836.       $bnewlib='- '.$ors['MTXT'];
    837. 

  837.     }
    838. 

  838. 

  839.     // Duplication du dictionnaire
    840. 

  840.     preparedUpdateQuery("CREATE TEMPORARY TABLE tmpdict AS SELECT * FROM DICT where DTAB=?",array($btab));
    841. 

  841.     preparedUpdateQuery("UPDATE tmpdict set DTAB=?",array($bnewtab));
    842. 

  842.     // Duplication du nom de la table et des commentaires de champ
    843. 

  843.     updateQuery('CREATE TEMPORARY TABLE tmpmsg as select * from AMSG where MOID="'.$boid.'" or MOID REGEXP "^'.$btab.':.+$"');
    844. 

  844.     preparedUpdateQuery('UPDATE tmpmsg set MOID=?,MTXT=? where MOID=?',array($bnewoid,$bnewlib,$boid));
    845. 

  845.     updateQuery('UPDATE tmpmsg set MOID=REPLACE(MOID,"'.$btab.'","'.$bnewtab.'") where MOID REGEXP "^'.$btab.':.+$"');
    846. 

  846.     // Duplications des libelles des champs
    847. 

  847.     updateQuery("CREATE TEMPORARY TABLE tmpmsgs AS SELECT * FROM MSGS WHERE MTAB='$btab'");
    848. 

  848.     updateQuery("UPDATE tmpmsgs SET MTAB='".$bnewtab."'");
    849. 

  849.     updateQuery("CREATE TEMPORARY TABLE tmpsets AS SELECT * FROM SETS WHERE STAB='$btab'");
    850. 

  850.     updateQuery("UPDATE tmpsets set STAB='".$bnewtab."'");
    851. 

  851.     // Duplication de l'entree dans basebase
    852. 

  852.     preparedUpdateQuery('CREATE TEMPORARY TABLE tmpbase AS SELECT * FROM BASEBASE where BOID=?',array($boid));
    853. 

  853.     updateQuery("UPDATE tmpbase set BTAB='".$bnewtab."',BOID='$bnewoid'");
    854. 

  854.     // Create de la table
    855. 

  855.     updateQuery('INSERT INTO DICT select * from tmpdict');
    856. 

  856.     updateQuery('INSERT INTO AMSG select * from tmpmsg');
    857. 

  857.     updateQuery('INSERT INTO MSGS select * from tmpmsgs');
    858. 

  858.     updateQuery("INSERT INTO SETS select SOID, STAB, FIELD, SLANG, STXT, SORDER from tmpsets");
    859. 

  859.     updateQuery('INSERT INTO BASEBASE select * from tmpbase');
    860. 

  860.     updateQuery('CREATE TABLE '.$bnewtab.' like '.$btab);
    861. 

  861.     if($data){
    862. 

  862.       updateQuery('INSERT INTO '.$bnewtab.' (select * from '.$btab.')');
    863. 

  863.       updateQuery('UPDATE '.$bnewtab.' SET UPD=UPD,KOID=replace(KOID,"'.$btab.':","'.$bnewtab.':")');
    864. 

  864.       // copie des donnees
    865. 

  865.       Global $DATA_DIR;
    866. 

  866.       XDir::copy($DATA_DIR.$btab, $DATA_DIR.$bnewtab, true);
    867. 

  867.     }
    868. 

  868.     updateQuery('DROP TEMPORARY TABLE tmpbase');
    869. 

  869.     updateQuery('DROP TEMPORARY TABLE tmpdict');
    870. 

  870.     updateQuery('DROP TEMPORARY TABLE tmpmsg');
    871. 

  871.     updateQuery('DROP TEMPORARY TABLE tmpmsgs');
    872. 

  872.     updateQuery('DROP TEMPORARY TABLE tmpsets');
    873. 

  873.     return array('message'=>'Duplication finished','boid'=>$bnewoid,'table'=>$bnewtab);
    874. 

  874.   }
    875. 

  875. 

  876.   /// Check/repare la source de donnée
    877. 

  877.   public function chk($ar=NULL) {
    878. 

  878.     $p=new XParam($ar, array("repair"=>false));
    879. 

  879.     $repair=$p->get("repair");
    880. 

  880.     $msg='';
    881. 

  881. 

  882.     // Verification des index déjà dans XIntegrity::chkDatabases et mieux fait
    883. 

  883.     //updateQuery('alter table '.$this->base.' add primary key(KOID,LANG);');
    884. 

  884. 

  885.     // Verification des champs
    886. 

  886.     foreach($this->desc as $k=>$v) {
    887. 

  887.       if(!fieldExists($this->base, $k)) $msg.=$this->base.':'.$k.' fields exist in catalog not in table<br>';
    888. 

  888.       else $v->chk($msg);
    889. 

  889.     }
    890. 

  890. 

  891.     // Verification des langues
    892. 

  892.     $translatable=$this->getTranslatable();
    893. 

  893.     if(!$translatable) {
    894. 

  894.       updateQuery('delete from '.$this->base.' where LANG!="'.TZR_DEFAULT_LANG.'"');
    895. 

  895.     }elseif($translatable!=TZR_LANG_FREELANG) {
    896. 

  896.       $rs=selectQuery('select * from '.$this->base.' where LANG="'.TZR_DEFAULT_LANG.'"');
    897. 

  897.       $ors=array();
    898. 

  898.       while($ors=$rs->fetch()) {
    899. 

  899. 	$oid=$ors['KOID'];
    900. 

  900. 	$this->propagateOnOtherLangs($oid);
    901. 

  901.       }
    902. 

  902.     }
    903. 

  903. 

  904.     // Verification des donnnees
    905. 

  905.     $rs=selectQuery('SELECT * FROM '.$this->base);
    906. 

  906.     $ors=array();
    907. 

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

  908.       $oid=$ors['KOID'];
    909. 

  909.       $lang=$ors['LANG'];
    910. 

  910.       if(empty($GLOBALS['TZR_LANGUAGES'][$lang])) {
    911. 

  911. 	$msg.=$oid.' '.$lang.' '.XLabels::getSysLabel('general.deleted').'<br>';
    912. 

  912. 	updateQuery('delete from '.$this->base.' where LANG="'.$lang.'" and KOID="'.$oid.'"');
    913. 

  913.       }
    914. 

  914.     }
    915. 

  915.     return array('message'=>$msg);
    916. 

  916.   }
    917. 

  917. 

  918.   /// Exporte les champs de la source dans une feuille d'un objet PHPExcel
    919. 

  919.   function exportSpec(&$sheet){
    920. 

  920.     $headers=array('table','forder');
    921. 

  921.     $langs=array_keys($GLOBALS['TZR_LANGUAGES']);
    922. 

  922.     foreach($langs as $lg) $headers[]='label['.$lg.']';
    923. 

  923.     $headers=array_merge($headers,array('field','ftype','fcount','compulsory','queryable','translatable','browsable','multivalued','published','target'));
    924. 

  924.     $rows=array();
    925. 

  925.     $table=$this->getTable();
    926. 

  926.     foreach($this->desc as $fn=>&$f){
    927. 

  927.       $row=array();
    928. 

  928.       $row['table']=$table;
    929. 

  929.       $row['forder']=$f->forder;
    930. 

  930.       $labels=array();
    931. 

  931.       $rs=&selectQuery('select * from MSGS where MTAB="'.$table.'" and FIELD="'.$fn.'" and MLANG in ("'.implode('","',$langs).'")');
    932. 

  932.       while($rs && $ors=$rs->fetch()) $labels[$ors['MLANG']]=$ors['MTXT'];
    933. 

  933.       foreach($langs as $lg) $row['label['.$lg.']']=$labels[$lg];
    934. 

  934.       $row['field']=$f->field;
    935. 

  935.       $row['ftype']=$f->ftype;
    936. 

  936.       $row['fcount']=$f->fcount;
    937. 

  937.       $row['compulsory']=$f->compulsory;
    938. 

  938.       $row['queryable']=$f->queryable;
    939. 

  939.       $row['translatable']=$f->translatable;
    940. 

  940.       $row['browsable']=$f->browsable;
    941. 

  941.       $row['multivalued']=$f->multivalued;
    942. 

  942.       $row['published']=$f->published;
    943. 

  943.       $row['target']=$f->target;
    944. 

  944.       if($row['target']=='%') $row['target']='';
    945. 

  945.       $opts=$f->_options->getAllValues($f, array('for_export' => 1));
    946. 

  946.       $row=array_merge($row,$opts);
    947. 

  947.       foreach($opts as $optn=>$opt) if(!in_array($optn,$headers)) $headers[]=$optn;
    948. 

  948.       $rows[]=$row;
    949. 

  949.     }
    950. 

  950.     foreach($headers as $i=>$h) {
    951. 

  951.       $sheet->setCellValueByColumnAndRow($i, 1, $h);
    952. 

  952.     }
    953. 

  953.     $line=1;
    954. 

  954.     foreach($rows as $row){
    955. 

  955.       $line++;
    956. 

  956.       foreach($headers as $i=>$h){
    957. 

  957. 	if(array_key_exists($h,$row)) $sheet->setCellValueByColumnAndRow($i, $line, $row[$h]);
    958. 

  958.       }
    959. 

  959.     }
    960. 

  960.   }
    961. 

  961. 

  962.   /// Importe les champs de la source via une feuille d'un objet PHPExcel
    963. 

  963.   function importSpec(&$sheet,&$log,$param=array()){
    964. 

  964.     $tables=array();
    965. 

  965.     $reorder=array();
    966. 

  966.     $table=$this->getTable();
    967. 

  967.     $fields=array();
    968. 

  968.     $prefixSQL=($param['prefixSQL']?$param['prefixSQL']:'');
    969. 

  969.     $delallfields=$param['delallfields'];
    970. 

  970.     $delotherfields=$param['delotherfields'];
    971. 

  971.     $oo=array('compulsory','queryable','browsable','translatable','multivalued','published'); // Champs booleen de base
    972. 

  972. 

  973.     // Suppression de tous les champs non systeme
    974. 

  974.     if(!empty($delallfields)){
    975. 

  975.       foreach($this->desc as $fn=>&$f){
    976. 

  976. 	if(!$this->sys) $this->delField(array('field'=>$fn,'action'=>'OK'));
    977. 

  977.       }
    978. 

  978.       $log.='<dd>Suppression de tous les champs non système de la table.</dd>';
    979. 

  979.     }
    980. 

  980. 

  981.     // Recherche de l'entete
    982. 

  982.     $col=0;
    983. 

  983.     $h=$sheet->getCellByColumnAndRow($col,1)->getValue();
    984. 

  984.     while(!empty($h)) {
    985. 

  985.       $head[$col]=$h;
    986. 

  986.       $col++;
    987. 

  987.       $h=$sheet->getCellByColumnAndRow($col,1)->getValue();
    988. 

  988.     }
    989. 

  989.     unset($h);
    990. 

  990.     $it=$sheet->getRowIterator();
    991. 

  991.     foreach ($it as $ii) {
    992. 

  992.       $i=$ii->getRowIndex();
    993. 

  993.       if($i==1) continue;
    994. 

  994.       $row=array();
    995. 

  995.       foreach($head as $j=>$h) {
    996. 

  996. 	$value = $sheet->getCellByColumnAndRow($j,$i)->getValue();
    997. 

  997.         if($value==='') continue;
    998. 

  998.         $pos=strpos($h,'[');
    999. 

  999.         if($pos) $tmp='['.substr($h,0,$pos).']'.substr($h,$pos);
    1000. 

  1000.         else $tmp='['.$h.']';
    1001. 

  1001.         $tmp=str_replace(array('[',']'),array("['","']"),$tmp);
    1002. 

  1002. 	utf8_cp1252_replace($value);
    1003. 

  1003.         if($value==='_empty_') eval('$row'.$tmp.'="";');
    1004. 

  1004.         else eval('$row'.$tmp.'="'.str_replace('"','\\"',trim($value)).'";');
    1005. 

  1005.       }
    1006. 

  1006.       if(empty($row['field'])){
    1007. 

  1007. 	$log.='<dd>Ligne '.$i.' : champ manquant</dd>';
    1008. 

  1008. 	continue;
    1009. 

  1009.       }
    1010. 

  1010.       if(!empty($row['table']) && $table!=$prefixSQL.$row['table']) {
    1011. 

  1011. 	continue;
    1012. 

  1012.       }
    1013. 

  1013.       $field=$row['field'];
    1014. 

  1014.       $fields[]=$field;
    1015. 

  1015.       // Création du champ si il n'existe pas
    1016. 

  1016.       $row['target']=str_replace('tzrprefix_',$prefixSQL,$row['target']);
    1017. 

  1017.       if(!fieldExists($table,$field)) {
    1018. 

  1018.         foreach($oo as $o)
    1019. 

  1019.           if(empty($row[$o])) $row[$o]=0;
    1020. 

  1020.         $this->createField($field,'Tmpname',$row['ftype'],$row['fcount'],$row['forder'],$row['compulsory'],$row['queryable'],
    1021. 

  1021. 			   $row['browsable'],$row['translatable'],$row['multivalued'],$row['published'],$row['target']);
    1022. 

  1022. 	$log.='<dd>Création du champ/Creating field "'.$field.'"</dd>';
    1023. 

  1023.       }
    1024. 

  1024. 

  1025.       // Traitement pour l'edition des différentes options
    1026. 

  1026.       foreach($row['options'] as $n=>$o){
    1027. 

  1027. 	if($o=='O') $row['options'][$n]=1;
    1028. 

  1028. 	elseif($o=='N') $row['options'][$n]=0;
    1029. 

  1029.       }
    1030. 

  1030.       foreach($oo as $o){
    1031. 

  1031.         if(!empty($row[$o]) && ($row[$o]==1 || $row[$o]=='O')) $row[$o]='on';
    1032. 

  1032.         else $row[$o]='off';
    1033. 

  1033.       }
    1034. 

  1034.       $row['_todo']='save';
    1035. 

  1035.       if(empty($row['label'][TZR_DEFAULT_LANG])){
    1036. 

  1036. 	$t1=reset($row['label']);
    1037. 

  1037. 	$row['label'][TZR_DEFAULT_LANG]=$t1;
    1038. 

  1038.       }
    1039. 

  1039.       $this->procEditField($row);
    1040. 

  1040.       $reorder[]=array('table'=>$table,'field'=>$field,'order'=>$row['forder']);
    1041. 

  1041.       $log.='<dd>Modification du champ/Updating field "'.$field.'"</dd>';
    1042. 

  1042.     }
    1043. 

  1043.     // Suppression des champs qui ne sont dans la feuille
    1044. 

  1044.     if(!empty($delotherfields)){
    1045. 

  1045.       foreach($this->desc as $fn=>&$f){
    1046. 

  1046. 	if(!in_array($fn,$fields) && !$f->sys){
    1047. 

  1047. 	  $this->delField(array('field'=>$fn,'action'=>'OK'));
    1048. 

  1048. 	  $log.='<dd>Suppression du champ "'.$fn.'"</dd>';
    1049. 

  1049. 	}
    1050. 

  1050.       }
    1051. 

  1051.     }
    1052. 

  1052. 

  1053.     // Reordonne
    1054. 

  1054.     foreach($reorder as $info){
    1055. 

  1055.       updateQuery('UPDATE DICT set FORDER='.$info['order'].' where DTAB="'.$info['table'].'" and FIELD="'.$info['field'].'"');
    1056. 

  1056.     }
    1057. 

  1057.   }
    1058. 

  1058. 

  1059.   /// Ensemble d'actions à effectuer après qu'une modification de donnée ait eu lieu
    1060. 

  1060.   protected function updateTasks(&$ar,$oid) {
    1061. 

  1061.     if(parent::updateTasks($ar,$oid)){
    1062. 

  1062.       if($this->base=='LOGS') return true;
    1063. 

  1063.       XDbIni::clear('%|'.$this->base.':usedValues:%');      
    1064. 

  1064.       XDbIni::clear($this->base.'|%:usedValues:%');      
    1065. 

  1065.       XDbIni::clear($this->base.':usedValues:%');      
    1066. 

  1066.     }
    1067. 

  1067.     return true;
    1068. 

  1068.   }
    1069. 

  1069. 

  1070.   /// Génère un oid pour la source
    1071. 

  1071.   function getNewOID($ar=NULL){
    1072. 

  1072.     // Si l'oid doit être généré à partir des infos d'autres champs
    1073. 

  1073.     if($this->oidstruct1){
    1074. 

  1074.       $p=new XParam($ar);
    1075. 

  1075.       $oid=$p->get($this->oidstruct1);
    1076. 

  1076.       if($this->oidstruct2) $oid.='-'.$p->get($this->oidstruct2);
    1077. 

  1077.       if($this->oidstruct3) $oid.='-'.$p->get($this->oidstruct3);
    1078. 

  1078.       if($oid){
    1079. 

  1079. 	$oid=substr($this->base.':'.rewriteToAscii($oid),0,40);
    1080. 

  1080. 	$cnt=countSelectQuery('select COUNT(KOID) from '.$this->base.' where KOID="'.$oid.'"');
    1081. 

  1081. 	if($cnt){
    1082. 

  1082. 	  $i=0;
    1083. 

  1083. 	  do{
    1084. 

  1084. 	    $i++;
    1085. 

  1085. 	    $tmpoid=substr($oid,0,37).'-'.$i;
    1086. 

  1086. 	    $cnt=countSelectQuery('select COUNT(KOID) from '.$this->base.' where KOID="'.$tmpoid.'"');
    1087. 

  1087. 	  }while($cnt>0);
    1088. 

  1088. 	  $oid=$tmpoid;
    1089. 

  1089. 	}
    1090. 

  1090. 	return $oid;
    1091. 

  1091.       }
    1092. 

  1092.     }
    1093. 

  1093.     return parent::getNewOID($ar);
    1094. 

  1094.   }
    1095. 

  1095. }
    1096. 

  1096. ?>
    1097. 

  1097.