/class.xdatasource.inc

<?php
/// Classe de base pour la gestion des sources de donnees
class XDataSource implements XModuleContainerInterface {
  static $_sources;
  protected $base = NULL;
  protected $boid = NULL;
  protected $title=NULL;
  protected $translatable=false;
  protected $log=1;
  public $desc = array();
  public $orddesc = array();
  private static $_factory=array();
  private static $_factory_by_sourcepath=array();
  protected static $_basebase=NULL;
  protected static $_boid=array();
  public $published_fields_in_admin=2;
  public $sendacopytofields=array();

  /// construction d'une source de donnee avec un nom de table (legacy) ou un boid
  function __construct($boid=0) {
    XDataSource::preLoadBaseBase();
    if(!empty($boid)) {
      $this->boid=$boid;
      $this->base=XDataSource::$_boid[$boid]->BTAB;
      $this->initOptions();
      $param=XOptions::rawFromXML(XDataSource::$_boid[$this->boid]->BPARAM);
      $this->_options->setValues($this,$param);
    } else {
      XLogs::critical('XDataSource::construct', '<'.$boid.'> is empty');
      return NULL;
    }
  }

  /// Initialise les options de la source
  public function initOptions() {
    if(empty($this->_options)) $this->_options=new XOptions();
    $this->_options->setId($this->boid);
  }

  /// Supprime le cache des datasources
  static public function clearCache(){
    XDataSource::preLoadBaseBase(true);
    XDataSource::$_factory=array();
    XDataSource::$_factory_by_sourcepath=array();
  }

  /// chargement en mémoire de la liste des tables et les libellés associés
  static function preLoadBaseBase($refresh=false) {
    if(empty(XDataSource::$_basebase) || $refresh) {
      XLogs::debug('XShell::loadBaseBase: start');
      $lang = XShell::getLangUser();
      $rs=selectQueryGetAll('select BASEBASE.*,AMSG.* from BASEBASE,AMSG where BASEBASE.BOID=AMSG.MOID and MLANG="'.$lang.'" AND MTXT != ""');
      XDataSource::$_basebase=array();
      XDataSource::$_boid=array();
      foreach($rs as $idx => $o1) {
	XDataSource::$_basebase[$o1['BTAB']]=(object)$o1;
	XDataSource::$_boid[$o1['BOID']]=&XDataSource::$_basebase[$o1['BTAB']];
      }
      // Chargement des tables qui ne sont pas traduites
      if($lang!=TZR_DEFAULT_LANG) {
	$rs=selectQuery('select BASEBASE.*,AMSG.* from BASEBASE,AMSG where BASEBASE.BOID=AMSG.MOID and MLANG="'.TZR_DEFAULT_LANG.'"');
	$ors=array();
	while($ors=$rs->fetch() ) {
	  if(empty(XDataSource::$_basebase[$ors['BTAB']])) {
	    XDataSource::$_basebase[$ors['BTAB']]=(object)$ors;
	    XDataSource::$_boid[$ors['BOID']]=&XDataSource::$_basebase[$ors['BTAB']];
	  }
	}
	$rs->closeCursor();
      }
      XLogs::debug('XShell::loadBaseBase: end');
    }
  }

  /// Creation d'un objet de type xdatasource via le boid
  public static function objectFactory8($boid) {
    XLogs::debug('XDataSource::objectfactory8 boid='.$boid);
    if(!preg_match('/^[0-9a-f]+$/',$boid)) securityWarning('XDataSource::objectFactory8: Trying to get unauthorized <'.$boid.'>');

    XDataSource::preLoadBaseBase();
    if(empty(XDataSource::$_boid[$boid])) XDataSource::preLoadBaseBase(true);
    $c=XDataSource::$_boid[$boid]->BCLASS;

    if(!class_exists($c)) {
      XLogs::notice('XDataSource::objectfactory8','class '.$c.' doesn\'t exist');
      $c='XDSTable';
    }
    if(empty(XDataSource::$_factory[$boid])) {
      XLogs::debug($c.'::objectFactory8 creating '.$boid);
      XDataSource::$_factory[$boid]=new $c($boid);
    }
    return XDataSource::$_factory[$boid];
  }

  /// Creation d'un objet de type xdatasource via ses caratéristiques
  /// Ex de sourcepath : BCLASS=XDSTable&SPECS=_MLOGS pour recuperer la source de type XDSTable sur la table _MLOGS
  public static function objectFactoryHelper8($sourcepath) {
    XLogs::debug('XDataSource::objectfactoryHelper8 source='.$sourcepath);
    if(isset(XDataSource::$_factory_by_sourcepath[$sourcepath]))
      return XDataSource::$_factory_by_sourcepath[$sourcepath];
    XDataSource::preLoadBaseBase();
    parse_str($sourcepath,$output);
    $c=@$output['BCLASS'];
    $specs=@$output['SPECS'];
    if(Kernel::isAKoid($specs)) $specs=Kernel::getTable($specs);

    $boid=XDataSource::getBoidFromSpecs($c, $specs);
    if(empty($boid)) return NULL;
    return XDataSource::$_factory_by_sourcepath[$sourcepath] = XDataSource::objectFactory8($boid);
  }
  static function getBoidFromSpecs($class, $spec) {
    if(empty(XDataSource::$_basebase[$spec])) XDataSource::preLoadBaseBase(true);
    if(empty(XDataSource::$_basebase[$spec])) return NULL;
    return XDataSource::$_basebase[$spec]->BOID;
  }
  static function sysTable($table) {
    return in_array($table,array('USERS','GRP','TEMPLATES','LOGS','TASKS','LETTERS','REPLI','JOURNAL','OPTS','_MLOGS','_MLOGSD'));
  }
  static function notToReplicate($table) {
    return in_array($table,array('TASKS','REPLI','JOURNAL'));
  }


  static function tablesLogStatus() {
    XDataSource::preLoadBaseBase(true);
    $tablesLogStatus = array();
    foreach (XDataSource::$_basebase as $tableName => $tableObject)
      $tablesLogStatus[$tableName] = ($tableObject->LOG == 1 && $tableName != 'LOGS');
    return $tablesLogStatus;
  }

  public function &actionlist1() {
    $actions = array();
    $this->_actionlist($actions);
    return $actions;
  }

  // rend la liste des champs browsables
  //
  function browsableFields($selectedfields=NULL) {
    $fields=array();
    foreach($this->desc as $k => &$v) {
      if($v->get_browsable() || ($selectedfields=='all')) {
	$fields[]=$k;
      }
    }
    return $fields;
  }

  /// Transforme le résultat d'un formulaire en object requête
  function captureQuery($ar=NULL) {
    $p=new XParam($ar, array());
    $options=$p->get('options');
    $_FIELDS=$p->get('_FIELDS');
    $st=array();
    $st['_date']=mktime();
    $st['_table']=$this->base;
    $st['options']=$p->get('options');
    $st['oids']=$p->get('oids');
    $st['operator']=$p->get('operator');
    $st['_select']=$p->get('_select');
    $st['pagesize']=$p->get('pagesize');
    $st['order']=array();
    if(!empty($_FIELDS)) {
      $st['_querymode']='query2';
      $st['_FIELDS']=$_FIELDS;
    }else{
      $st['_FIELDS']=array();
      foreach($this->desc as $k=>&$v) $_FIELDS[$k]=$k;
    }
    foreach($_FIELDS as $field=>$k) {
      $v=&$this->desc[$k];
      if(is_object($v)) {
	if(!$v->get_queryable()) continue;
	$v1=$p->get($field);
	$st[$field]=$v1;
	$st[$field.'_op']=$p->get($field.'_op');
	$st[$field.'_HID']=$p->get($field.'_HID');
	$st[$field.'_FMT']=$p->get($field.'_FMT');
	$st[$field.'_PAR']=$p->get($field.'_PAR');
	$st[$field.'_empty']=$p->get($field.'_empty');
      }
    }
    $order=$p->get('order');
    $_order=$p->get('_order');
    if(is_array($order)) {
      foreach($order as $i=>$f) {
	if(!empty($f)) $st['order'][]=trim($order[$i].' '.$_order[$i]);
      }
    }
    return $st;
  }

  /// prend en entrée une requête stockée ($qinit) et génére les paramètres d'entrée
  public function prepareQuery(&$qinit, $storedname=NULL) {
    // table dans laquelle se trouvenet les donnees
    if(!empty($storedname)) {
      $rs=& selectQuery("select * from QUERIES where KOID = '$storedname' and LANG='".TZR_DEFAULT_LANG."'");
      $ors=array();
      if($ors=$rs->fetch()) {
	// fusion du contenu de la recherche sauevardee et de la recherche en cours.
	// on prend en priorite le contenu de la requete sauvegardee, qinit sinon
	$q1 = unserialize(stripslashes($ors['query']));
	$q2=$q1;
	foreach($qinit as $k=>$v) {
	  if(!empty($qinit[$k])) $q2[$k]=$v;
	}
	$qinit=$q2;
      }
    }
    $selectedfields=array();
    $r=NULL;
    $r['operator']=@$qinit['operator'];
    if(empty($r['operator'])) $r['operator']='and';
    $parametrized=false;
    $labelin=@$qinit['labelin'];
    if(is_array($qinit)) {
      foreach($this->desc as $k => &$v) {
	if(!empty($qinit[$k.'_PAR'])) {
	  $parametrized=true;
	  $selectedfields[]=$k;
	  unset($qinit[$k]);
	  unset($qinit[$k.'_op']);
	  unset($qinit[$k.'_HID']);
	  unset($qinit[$k.'_PAR']);
	  unset($qinit[$k.'_FMT']);
	  if(!empty($labelin)) $qinit['options'][$k]['labelin']=true;
	}
      }

      if(!empty($selectedfields)) {
	$r=$this->query(array('tplentry'=>TZR_RETURN_DATA,'selectedfields'=>$selectedfields,
			      'searchmode'=>'simple','_preparedquery'=>$qinit, 'fmoid' => $qinit['fmoid']));
      }
    }
    $r['parametrized']=$parametrized;
    return $r;
  }



  /// rend vrai si la base existe
  public static function sourceExists($t) {
    XDataSource::preLoadBaseBase();
    return isset( XDataSource::$_basebase[$t] );
  }

  /// rend le libelle de la table
  public function getLabel() {
    return $this->title;
  }

  /// Rend la table de la source
  public function getTable() {
    return $this->base;
  }
  /// Rend le boid de la source
  function getBoid(){
    return $this->boid;
  }
  /// Rend le nom de la source
  function getSourceName(){
    return XDataSource::$_boid[$this->boid]->MTXT;
  }
  /// Rend un propriété d'une source via la BOID
  static function getBoidProp($boid,$prop){
    return XDataSource::$_boid[$boid]->$prop;
  }
  /// Rend un propriété d'une source via le nom de la table
  static function getTableProp($table,$prop) {
    return XDataSource::$_basebase[$table]->$prop;
  }


  public function &getPublished($field=true) {
    $links=array();
    foreach($this->desc as $i => &$v) {
      if(is_object($v)) {
	$f=$v->get_field();
	if($v->get_published()){
	  if($field) $links[]=$f;
	  else $links[]=$i;
	}
      }
    }
    return $links;
  }
  public function isTranslatable() {
    return ($this->translatable>0);
  }
  public function getTranslatable() {
    return $this->translatable;
  }
  public function toLog() {
    return ($this->base!='LOGS' && $this->log==1);
  }

  public function getAutoTranslate() {
    return $this->autotranslate;
  }

  /// genere les traductions dans toutes les langues
  function autoTranslate() {
    if($this->isTranslatable()) {
      $xk=new Kernel;
      $requete='select distinct KOID from '.$this->base.' where LANG="'.TZR_DEFAULT_LANG.'"';
      $rs=selectQuery($requete);
      while($rs && ($ors=$rs->fetch())) {
	$koid=$ors['KOID'];
	$xk->data_autoTranslate($koid);
      }
      $rs->closeCursor();
    }else{
      updateQuery('delete from '.$this->base.' where LANG!="'.TZR_DEFAULT_LANG.'"');
    }
  }

  public static function &getBaseList($myselfIncluded=true,$refresh=false) {
    XDataSource::preLoadBaseBase($refresh);
    $liste = array();
    foreach(XDataSource::$_basebase as $b=>&$o) {
      $liste[$b]=$o->MTXT;
    }
    asort($liste);
    return $liste;
  }

  public static function &getBaseList8($myself=true){
    XDataSource::preLoadBaseBase();
    $liste=array();
    foreach(XDataSource::$_boid as $b=>&$o){
      if($myself || (!$myself && (empty($this) || $this->boid!=$b)))
        $liste[$b]=$o->MTXT;
    }
    asort($liste);
    return $liste;
  }

  /// Créer une boite de selection de champ
  function fieldSelector($ar=NULL) {
    $p=new XParam($ar, array('tplentry'=>'','compulsory'=>true,'filter'=>array()));
    $tplentry=$p->get('tplentry');
    $fieldname=$p->get('fieldname');
    $value=$p->get('value');
    $type=$p->get('type');
    if(!is_array($type) && !empty($type)) $type=array($type);
    $compulsory=$p->get('compulsory');
    $multivalued=$p->get('multivalued');
    $filter=$p->get('filter','local');
    if($multivalued) $retval='<select name="'.$fieldname.'[]" size="6" multiple>';
    else $retval='<select name="'.$fieldname.'">';
    if(!$compulsory) $retval.='<option value="">----</option>';
    foreach($this->desc as $k => &$v) {
      if(empty($type) || in_array($v->get_ftype(),$type)){
        $ok=true;
        foreach($filter as $prop=>$val){
	  if(is_array($val)){
	    if(!eval('return (\''.$val[1].'\''.$val[0].'\''.$v->$prop.'\');' ) ){
              $ok=false;
              break;
            }
          }else{
            if($v->$prop!=$val){
              $ok=false;
              break;
            }
          }
        }
        if($ok) $retval.='<option value="'.$k.'" '.(isset($value) && ($value==$k || is_array($value) && in_array($k,$value))?'selected':'')." >". $v->get_label().'</option>';
      }
    }
    $retval.='</select>';
    return $retval;
  }

  function order_selector($ar=NULL) {
    $p = new XParam($ar, array('tplentry'=>'','compulsory'=>true,'random'=>true,'multiple'=>false));
    $tplentry = $p->get('tplentry');
    $LANG_USER = XShell::getLangUser();
    $LANG_DATA = XShell::getLangData();
    $fieldname=$p->get('fieldname');
    $value=$p->get('value');
    if(isset($value) && !is_array($value)) $value=array($value);
    $random=$p->get('random');
    $compulsory=$p->get('compulsory');
    $multiple=$p->get('multiple');
    $retval='<select name="'.$fieldname.'"'.($multiple?' multiple size="6"':'').'>';
    if(!$compulsory) $retval.='<option value="">---</option>';
    if($random) $retval.='<option value="RAND()">'.XLabels::getSysLabel('xdatasource.random').'</option>';

    foreach($this->desc as $k => $v) {
      $retval.='<option value="'.$k.'" '.(isset($value) && in_array($k,$value)?'selected':'').
	' >'. $v->get_label().'</option>';
    }
    $retval.='</select>';
    return $retval;
  }

  /// rend le descriptif d'un champ
  public function getField($f) {
    return $this->desc[$f];
  }

  /// Rend la liste des champs de la table filtres par type et par propriétés
  public function &getFieldsList($type=NULL,$browsable=false,$published=false,$queryable=false,$compulsory=false,$translatable=false,
				 $multivalued=false,$fields=null,$op='AND') {
    if(!is_array($fields) || empty($fields)) $fields=$this->orddesc;
    $list=array();
    $checktype=is_array($type) && !empty($type);
    foreach($fields as $i=>$f) {
      if(empty($this->desc[$f])) continue;
      $v=&$this->desc[$f];
      if($op=='AND' && (!$checktype || in_array($v->get_ftype(),$type)) && (!$browsable || $v->get_browsable()) && (!$published || $v->get_published()) && (!$queryable || $v->get_queryable()) && (!$compulsory || $v->get_compulsory()) && (!$translatable || $v->get_translatable()) && (!$multivalued || $v->get_multivalued()))
	$list[]=$f;
      elseif($op=='OR' && (($checktype && in_array($v->get_ftype(),$type)) || ($browsable && $v->get_browsable()) || ($published && $v->get_published()) || ($queryable && $v->get_queryable()) || ($compulsory && $v->get_compulsory()) || ($translatable && $v->get_translatable()) || ($multivalued && $v->get_multivalued())))
	$list[]=$f;
    }
    return $list;
  }
  /// Rend les champs indexables
  function getIndexablesFields($fields=NULL){
    if(!is_array($fields) || empty($fields)) $fields=$this->orddesc;
    $list=array();
    foreach($fields as $i=>$f) {
      if(!isset($this->desc[$f])) continue;
      if (isset($this->desc[$f]->indexable) && $this->desc[$f]->indexable == 1)
	$list[] = $f;
    }
    return $list;
  }
  /// Rend le nombre de champ non traduisible
  function getNonTranslatableFieldCount() {
    if (!isset($this->_NonTranslatableFieldCount))
      $this->_NonTranslatableFieldCount = countSelectQuery("select count(*) from DICT where DTAB='$this->base' and TRANSLATABLE!=1");
    return $this->_NonTranslatableFieldCount;
  }

  /// Fabrique une condition pour une recherche
  function make_cond($def, $v){
    return '';
  }
  function make_simple_cond($k, $v) {
    return '';
  }

  /// generation d'une condition utilisable sur le container
  function select_query($args=NULL) {
    return '';
  }

  /// Retourne une requete pour retourner des objets aléatoires
  function random_select_query($args=NULL) {
    return '';
  }

  /// Retourne une requete pour compter des objects
  function count_query($args=NULL) {
    return '';
  }

  // Fonction reservee a la creation d'une data pour la langue par defaut.
  // La creation d'une data dans tout autre code langue se fait par Kernel::data_edit() et Kernel::proc_data_edit()
  // apres avoir cree une data en l'initialisant avec la data correspondante dans le code langue par defaut.
  //
  public function input($ar=NULL) {
    $p = new XParam($ar, array(	'tplentry'=>$this->base,'hiddenfields'=>array(),'options'=>array(),'fieldssec'=>array()));
    $tplentry = $p->get('tplentry');
    $options = $p->get('options');
    $translatable= $this->getTranslatable();
    $fieldssec=$p->get('fieldssec','local');
    $module_filter=$p->get('module_filter','local');
    $moid=$p->get('fmoid','local');
    $selectedfields=$p->get('selectedfields');
    $editbatch=$p->get('editbatch');
    if(empty($selectedfields) || (is_string($selectedfields) && ($selectedfields=='all'))) $all=true;
    else $all=false;
    if(empty($selectedfields)) $selectedfields=array();

    $lang=XShell::getLangData($p->get('LANG_DATA'));
    if(($translatable!=3) && $this->isTranslatable() && ($lang!=TZR_DEFAULT_LANG)) {
      if($tplentry!=TZR_RETURN_DATA) 
        XShell::redirect2error(array('message'=>'Security violation'));
      return;
    }

    $LANG_USER = XShell::getLangUser();

    $myi=0;
    $ofieldvalue=array();
    $osysvalue=array();
    foreach($this->orddesc as $i => $k) {
      if(!empty($fieldssec[$k]) && $fieldssec[$k]!='rw') continue;
      if(!($all || in_array($k,$selectedfields))) continue;
      $v=&$this->desc[$k];
      $options[$k]['fmoid']=$moid;
      $options[$k]['editbatch']=$editbatch;
      $options[$k]['module_filter']=$module_filter;
      if(!$v->sys) {
	$ofieldvalue[$myi]=$v->edit($v->default_value(),$options[$k]);
	$result['o'.$k]=$ofieldvalue[$myi];
	$myi++;
      } else {
	$value=$v->edit($v->default_value(),$options[$k]);
	$osysvalue[]=$value;
	if($k=='PUBLISH' || $k=='PRP') $result['o'.$k]=$value;
      }
    }
    $result['fields_object']= $ofieldvalue;
    $result['sysfields_object']= $osysvalue;
    $result['newoid']=$this->getNewOID($ar);
    $result['tablelabel']=$this->getLabel();

    // recherche des groupes de champs
    $groups=array();
    foreach($this->orddesc as $foo => $k) {
      if(!empty($fieldssec[$k]) && $fieldssec[$k]!='rw') continue;
      if(!($all || in_array($k,$selectedfields))) continue;
      $v=&$this->desc[$k];
      if(!$v->sysField()) {
	if(empty($v->fgroup)) $v->fgroup='General';
	if(!empty($v->fgroup)) {
	  $groups[$v->fgroup][]=&$result['o'.$k];
	}
      }
    }
    ksort($groups);
    if(count($groups)>1) $result['_groups']=$groups;

    // Information sur le caractere 'translatable' ou non de toute la table
    $result['translatable'] = $this->isTranslatable();

    return XShell::toScreen1($tplentry, $result);
  }

  /// génération de l'écran de recherche
  public function query($ar=NULL) {
    $p = new XParam($ar, array(	'tplentry'=>$this->base,'selectedfields'=>'','searchmode'=>'advanced','querymode'=>'query',
				'operator'=>'AND','genoptions'=>array(),'fieldssec'=>array()));
    $LANG_USER = XShell::getLangUser();
    $LANG_DATA = XShell::getLangData();
    $tplentry = $p->get('tplentry');
    $fieldssec=$p->get('fieldssec','local');
    $module_filter=$p->get('module_filter','local');
    $fmoid = $p->get('fmoid','local');
    $persistent=$p->get('_persistent');
    $selectedfields=$p->get('selectedfields');
    if(empty($selectedfields) || (is_string($selectedfields) && ($selectedfields=='all'))) $all=true;
    else $all=false;
    if(empty($selectedfields)) $selectedfields=array();
    $genoptions=array();
    $selectquery='';

    // on a une requete preparee qui contraint le formulaire
    $preparedquery=$p->get('_preparedquery');
    if(!empty($preparedquery)) {
      $preparedquery['getselectonly']=true;
      $preparedquery['_options']=array('local'=>1);
      // on construit la requete sql contraignante
      $selectquery=self::procQuery($preparedquery);
      if (isset($preparedquery['options'])) 
        $genoptions=$preparedquery['options'];
      elseif (isset($preparedquery['genoptions'])) 
        $genoptions=$preparedquery['genoptions'];
    }
    if ($p->is_set('options')) 
      $genoptions=array_merge($genoptions,$p->get('options'));
    elseif ($p->is_set('genoptions')) 
      $genoptions=array_merge($genoptions,$p->get('genoptions'));
    $searchmode=$p->get('searchmode');
    $mode=$p->get('querymode');
    $myi=0;
    $result=array();
    foreach($this->orddesc as $field){
      if(!empty($fieldssec[$field]) && $fieldssec[$field]=='none') continue;
      $v=&$this->desc[$field];
      if(!($v->get_queryable() && ($all || in_array($field,$selectedfields)))) continue;
      if(!$persistent){
	if(!empty($genoptions[$field]['value'])) {
	  $initval=$genoptions[$field]['value'];
	  if(!is_array($initval)) $initval=array($initval);
	} else {
	  $initval=$p->get($field);
	  if(!is_array($initval)){
	    $initval=trim($initval);
	    if(!empty($initval)) $initval=array($initval);
	  }
	}
      }else{
	$initval=null;
      }
      if(!empty($genoptions[$field])) $opts1=$genoptions[$field];
      else $opts1=array();
      $opts1['searchmode']=$searchmode;
      // requete contrainte
      $opts1['select']=$selectquery;
      $opts1['fmoid']=$fmoid;
      $opts1['module_filter']=$module_filter;
      if(empty($opts1['op'])) $opts1['op']=$p->get($field.'_op');
      if($mode=='query2') $opts1['fieldname']='fieldxidxid';
      if($mode=='pquery') $ofieldvalue[$myi]=$v->pquery($initval, $opts1);
      else $ofieldvalue[$myi]=$v->query($initval, $opts1);
      if($mode=='query2') $ofieldvalue[$myi]->html.='<input type="hidden" name="_FIELDS[fieldxidxid]" value="'.$field.'">';
      $result['o'.$field]=&$ofieldvalue[$myi];
      $fieldpar[$myi]=@$genoptions[$field]['par'];
      $fieldname[$myi]=$v->get_label();
      $myi++;
    }
    if($mode=='query2') array_multisort($fieldname,SORT_STRING,$fieldpar,$ofieldvalue);
    $result['operator']=$p->get('operator');
    $result['fields_object']=&$ofieldvalue;
    $result['fields_par']=$fieldpar;
    return XShell::toScreen1($tplentry, $result);
  }

  /// Génération de l'écran de recherche rapide
  public function quickquery($ar=NULL) {
    $p=new XParam($ar,array('tplentry'=>$this->base,'selectedfields'=>'','genoptions'=>array()));
    $tplentry=$p->get('tplentry');
    $fields=$p->get('selectedfields');
    $fmoid=$p->get('fmoid','local');
    $persistent=$p->get('_persistent');
    if(!empty($fields) && is_array($fields)) $selectedfields=$fields;
    else $selectedfields=self::browsableFields($fields);
    $genoptions=$p->get('genoptions');
    if($p->is_set('options')) $genoptions=$p->get('options');
    $myi=0;
    $result=array();
    $ofieldvalue=array();
    $fieldpar=array();
    foreach($this->orddesc as $i => $field){
      $v=$this->desc[$field];
      if($v->get_queryable() && in_array($field,$selectedfields)) {
	$fieldname[$myi]=$v->get_label();
	if(!$persistent){
	  if(!empty($genoptions[$field]['value'])) {
	    $initval=$genoptions[$field]['value'];
	    if(!is_array($initval)) $initval=array($initval);
	  } else {
	    $initval=$p->get($field);
	    if(!is_array($initval)){
	      $initval=trim($initval);
	      if(!empty($initval)) $initval=array($initval);
	    }
	  }
	}else{
	  $initval=NULL;
	}
	if(empty($genoptions[$field])) $genoptions[$field]=array();
	$genoptions[$field]['fmoid']=$fmoid;
	$genoptions[$field]['op']=$p->get($field.'_op');
	$genoptions[$field]['fields_complement'] = $ar;
	$ofieldvalue[$myi]=$v->quickquery($initval, $genoptions[$field]);
	$result['o'.$field]=$ofieldvalue[$myi];
	$ftable['o'.$field]=$ofieldvalue[$myi];
	$fieldpar[$myi]=@$genoptions[$field]['par'];
	$myi++;
      }
    }
    $result['operator']=$p->get('operator');
    $result['fields_object']=$ofieldvalue;
    $result['fields_par']=$fieldpar;
    if(!empty($ftable)) $result['fields_ftable']=$ftable;
    return XShell::toScreen1($tplentry,$result);
  }

  /// Verifie si l'oid peut etre traité par la source
  function checkOID($oid,&$ar,$f,$return=false){
    if(Kernel::getTable($oid)!=$this->base){
      if($return) return false;
      else securityWarning('XDataSource::'.$f.': Trying to use '.$oid.' with wrong XDataSource <'.$this->base.'>');
    }
    return true;
  }

  /// Génère un oid pour la source
  function getNewOID($ar=NULL){
    return self::getNewBasicOID($this->base);
  }
  /// Génère un oid au format par defaut pour une table donnée (généré à partir du timestamp avec les µs et d'un nombre aléatoire, chacun converti en base 36)
  static function getNewBasicOID($t){
    $addr=str_replace('.','', base_convert(microtime(true),10,36));
    $addr.=base_convert(rand(1,32000),10,36);
    $newoid=substr($t.':'.$addr,0,40);
    /* on verifie si le koid n'existe pas deja */
    $cnt=countSelectQuery('select COUNT(KOID) from '.$t.' where KOID="'.$newoid.'"');
    if(!$cnt) return $newoid;
    else return self::getNewBasicOID($t);
  }
  /// Génère un oid au format spécifique pour une table donnée (simple raccourci pour ne pas instancier soit meme la source pour générer un oid)
  static function getNewSpecificOID($t,$ar=NULL){
    $xset=XDataSource::objectFactoryHelper8('SPECS='.$t);
    return $xset->getNewOID($ar);
  }

  /// Generation d'un ecran d'edition
  function edit($ar=NULL) {
    $p=new XParam($ar,array('tplentry'=>$this->base,'options'=>array(),'selectedfields'=>array(),'fieldssec'=>array(),'accesslog'=>0));
    $accesslog=$p->get('accesslog');
    $tplentry = $p->get('tplentry');
    $fieldssec = $p->get('fieldssec','local');
    $moid=$p->get('fmoid','local');
    $oid=$p->get('oid');
    XLogs::debug('XDataSource::edit('.$oid.')');
    $this->checkOID($oid,$ar,'edit');
    $options=$p->get('options');
    if(!empty($GLOBALS['XLOCK'])) {
      $mode=$p->get('_mode');
      if($mode=='lock') {
	$GLOBALS['XLOCK']->lock($oid, TZR_DEFAULT_LANG, XUser::get_current_user_uid());
	$GLOBALS['XLOCK']->initLocks();
      }
    }
    $selectedfields=$p->get('selectedfields');
    if(!is_array($selectedfields)) {
      unset($selectedfields);
      $selectedfields=array();
    }
    $translatable=$this->getTranslatable();
    $LANG_DATA=$p->get('LANG_DATA');
    if(!$translatable) $LANG_DATA=TZR_DEFAULT_LANG;
    else $LANG_DATA=XShell::getLangData($LANG_DATA,true);
    $LANG_TRAD = XShell::getLangTrad($p->get('LANG_TRAD'));
    $LANG_USER = XShell::getLangUser();
    if(($translatable!=TZR_LANG_FREELANG) && !empty($LANG_TRAD) && ($LANG_TRAD!=$LANG_DATA)) {
      $ar1=$ar;
      $ar1['LANG_DATA']=$LANG_TRAD;
      $ar1['tplentry']=TZR_RETURN_DATA;
      $result=array();
      $result['d']=self::display($ar1);
    }
    $rs=selectQuery('select * from '.$this->base.
		     " where KOID='$oid' and LANG='$LANG_DATA'");
    // si on ne trouve pas dans la langue en cours on regarde dans la langue de base
    if(!$ors=$rs->fetch()) {
      $rs->closeCursor();
      $rs=selectQuery('select * from '.$this->base.
		      " where KOID='$oid' and LANG='".TZR_DEFAULT_LANG."'");
      $ors=$rs->fetch();
    }
    $rs->closeCursor();

    $myi=0;
    foreach($this->desc as $k=>$v) {
      if(!empty($selectedfields) && !in_array($k, $selectedfields)) continue;
      $options[$k]['oid']=$oid;
      $options[$k]['fmoid']=$moid;
      if(empty($fieldssec[$k]) || $fieldssec[$k]=='rw') $f='edit';
      elseif($fieldssec[$k]=='ro') $f='display';
      else continue;
      if($LANG_DATA!=TZR_DEFAULT_LANG && $translatable!=TZR_LANG_FREELANG && !$v->get_translatable() && $this->isTranslatable()) $f='display';
      $ofieldvalue[$myi]=&$v->$f($ors[$k],$options[$k],$ors);
      $fieldequiv[$myi] = $k;
      $result['o'.$k]=&$ofieldvalue[$myi];
      $myi++;
    }
    $rs->closeCursor();

    $result['oid']= $oid;
    $result['fields_object']=&$ofieldvalue;
    $result['tablelabel']=$this->getLabel();
    if(!empty($GLOBALS['XLOCK'])) {
      $result['_lock']=$GLOBALS['XLOCK']->locked($oid, TZR_DEFAULT_LANG);
      if(!empty($result['_lock'])) {
	$result['_lock_editable']=(empty($result['_lock'])||
				   (XUser::get_current_user_uid()==$result['_lock']['OWN']));
      }
    }

    // recherche des groupes de champs
    $groups=array();
    foreach($fieldequiv as $foo => $k) {
      $v=&$this->desc[$k];
      if(!$v->sysField()) {
	if(empty($v->fgroup)) $v->fgroup='General';
	if(!empty($v->fgroup)) {
	  $groups[$v->fgroup][]=&$result['o'.$k];
	}
      }
    }
    ksort($groups);
    if(count($groups)>1) $result['_groups']=$groups;
    // Log
    if($accesslog) XLogs::uniqueUpdate('access',$oid);
    // Information sur le caractere 'translatable' ou non de toute la table
    $result['translatable'] = $this->isTranslatable();
    return XShell::toScreen1($tplentry,$result);
  }

  /// publication d'une donnée (oid) ou d'un ensemble de données (_selected)
  public function publish($ar) {
    $p=new XParam($ar, array('value'=>1, '_selected'=>NULL,'key'=>true));
    $oid=$p->get('oid');
    $value=$p->get('value');
    $lang=$p->get('LANG_DATA');
    $sel = $p->get('_selected');
    $key=$p->get('key');

    if(is_array($sel) && !$key) $sel=array_flip($sel);
    if(empty($sel) && !empty($oid)) $sel=array($oid=>$value);
    // traitement de la valeur pour se ramener à 1 (oui) ou 2 (non)
    if(empty($value)) $value=2;
    if(empty($sel)) return;
    foreach($sel as $oid => $val) {
      if(Kernel::objectExists($oid)) {
	$this->procEdit(array('oid'=>$oid, 'LANG_DATA'=>$lang, 'PUBLISH'=>$value, '_options'=>array('local'=>true)));
      }
    }
  }

  /// Affichage d'un objet
  public function &display($ar) {
    $p=new XParam($ar,array('tplentry'=>$this->base,'_lastupdate'=>XShell::admini_mode(),'genempty'=>1,'selectedfields'=>array(),
			    'fieldssec'=>array(),'accesslog'=>0,'tlink'=>false));
    $tplentry = $p->get('tplentry');
    $fallback = $p->get('fallback');
    $publishedonly = $p->get('_publishedonly');
    $selectedfields=$p->get('selectedfields');
    if(!is_array($selectedfields)) {
      unset($selectedfields);
      $selectedfields=array();
    }
    $genempty = $p->get('genempty');
    $moid = $p->get('fmoid','local');
    $fieldssec = $p->get('fieldssec','local');
    $archive = $p->get('_archive');
    $accesslog=$p->get('accesslog');
    $tlink=$p->get('tlink');
    // dans le cas ou la data d'archive est codee en 9999-99-99 99:99:99
    // on enleve tous les caracteres non chiffres
    if(!empty($archive) && !preg_match('/^([0-9]+)$/',$archive)) $archive=preg_replace('/([^0-9])/','',$archive);
    $charset = $p->get('_charset');
    $table = $this->base;
    $filter='';
    $_filter = $p->get('_filter', 'local');
    if (!empty($_filter))
      $filter = ' AND '.$_filter;
    if(!empty($archive)) {
      $table='A_'.$this->base;
      $filter=" AND UPD='$archive'";
    }
    $LANG_USER = XShell::getLangUser();
    $LANG_DATA = XShell::getLangData($p->get('LANG_DATA','local'));
    if(!$this->isTranslatable()) $LANG_DATA=TZR_DEFAULT_LANG;
    $LANG_TRAD = XShell::getLangTrad($p->get('LANG_TRAD'));
    $oid = $p->get('oid');
    if(empty($oid)) {
      $r= 'XDataSource::display: no oid';
      return $r;
    }
    $this->checkOID($oid,$ar,'display');
    XLogs::debug('XDataSource::display('.$oid.')');
    $options = $p->get('options');
    $_format=$p->get('_format');
    $_options = $p->get('_options');
    $lastupdate = $p->get('_lastupdate');
    $genpublishtag= @$_options['genpublishtag'];
    $error = @$_options['error'];
    $published=$this->publishedMode($p);
    if(!isset($genpublishtag)) $genpublishtag=true;
    XAudit::plusplus('display('.$table.')');
    // Recherche de l'objet en base et génération d'une erreur si introuvable
    $rs=selectQuery('SELECT * FROM '.$table.' WHERE KOID="'.$oid.'" AND LANG="'.$LANG_DATA.'" '.$filter);
    if(!$ors=$rs->fetch()) {
      if($this->isTranslatable() || $fallback) {
	$rs->closeCursor();
	$rs=selectQuery('SELECT * FROM '.$table.' WHERE KOID="'.$oid.'" AND LANG="'.$LANG_TRAD.'" '.$filter);
	if(!$ors=$rs->fetch()) {
	  if($error=='return') return $r='XDataSource('.$table.')->display: could not find object with oid='.$oid.' and lang='.$LANG_DATA.'<br/>';
	  else XShell::quit('XDataSource('.$table.')->display: could not find object with oid='.$oid.' and lang='.$LANG_DATA.'<br/>');
	}
      } else {
	if($error=='return') return $r='XDataSource('.$table.')->display: could not find object with oid='.$oid.' and lang='.$LANG_DATA.'<br/>';
	else XShell::quit('XDataSource('.$table.')->display: could not find object with oid='.$oid.' and lang='.$LANG_DATA.'<br/>');
      }
    }
    $rs->closeCursor();
    // Fiche non publié
    if($published=='public' && $ors['PUBLISH']!=1) {
      if($error=='return') return $r='XDataSource('.$table.')->display: data '.$oid.' has not been published has public<br/>';
      else XShell::quit('XDataSource('.$table.')->display: data '.$oid.' has not been published has public<br/>');
    }
    $result=array();
    // Si on est dans l'admin, vérification de la génération du champ publié ou non
    if($genpublishtag && XShell::admini_mode() && ($published=='marked')) {
      $mark=$ors['PUBLISH'];
      if($mark=='1') $pubval='checked';
      else $pubval='';
      $result['_PUBLISH_tag']='<input type="checkbox" class="checkbox" name="_PUBLISH['.$oid.']" '.$pubval.'/>';
      $result['_PUBLISH_tag'].='<input type="hidden" name="_PUBLISH_H['.$oid.']" value="'.$mark.'"/>';
    }
    // Display sur chaque champ
    $result['fields_object']=array();
    $result['link']='';
    if($tlink) $result['tlink']='';
    foreach($this->desc as $k => &$v) {
      if((!empty($selectedfields) && !in_array($k, $selectedfields)) || (!empty($fieldssec[$k]) && $fieldssec[$k]=='none')) continue;
      if(($v->get_published() && $publishedonly) || !isset($publishedonly)) {
	$val=$ors[$k];
	// Calcul des options d'affichage
	$opt=@$options[$k];
	if(!empty($moid)) $opt['fmoid']=$moid;
	if($published=='marked' && $ors['PUBLISH']=='2') $opt['_published']=false;
	else $opt['_published']=true;
	if(!empty($archive)) $opt['_archive']=$archive;
 	if(!empty($charset)) $opt['_charset']=$charset;
	$opt['_format']=$_format;
	// Nouvel objet d'affichage
	$o=&$v->display($val,$opt);
	$result['o'.$k]=$o;
	// Construction de fields_object et du lien avec les champs publié
	if($genempty || $o->html!='') {
	  $result['fields_object'][]=$o;
	  if($v->get_published()) {
	    if(!empty($result['link'])) $result['link'].=' ';
	    $result['link'].=$o->html;
	    if($tlink){
	      if(!empty($result['tlink'])) $result['tlink'].=' ';
	      $result['tlink'].=$o->text;
	    }
	  }
	}
      }
    }
    $result['oid']= $oid;

    // Information sur le caractere 'translatable' ou non de toute la table
    $result['translatable']=$this->isTranslatable();
    if($result['translatable'] && isset($LANG_TRAD)) {
      $cnt=countSelectQuery("select COUNT(KOID) from $table where KOID='$oid' and LANG='$LANG_TRAD' $filter");
      if($cnt<=0) $result['_translation_ok']='0';
      else $result['_translation_ok']='1';
    }

    // information sur la langue générée
    $result['_lang_data']=$LANG_DATA;
    if(!empty($LANG_TRAD) && ($LANG_TRAD!=$LANG_DATA)) {
      $ar['tplentry']=TZR_RETURN_DATA;
      $ar['LANG_DATA']=$LANG_TRAD;
      $r2=self::display($ar);
      $result['d']=$r2;
    }
    // Etat du verouillage de la fiche
    if(!empty($GLOBALS['XLOCK'])) {
      $result['_lock']=$GLOBALS['XLOCK']->locked($oid,$LANG_DATA);
      $result['_lock_user'] = $GLOBALS['XLOCK']->getUser($oid,$LANG_DATA);
      $result['_lock_editable']=(empty($result['_lock']) || (XUser::get_current_user_uid()==$result['_lock']['OWN']));
    }
    // Derniere mise à jour
    if(!empty($lastupdate)) $result['lst_upd']=XLogs::getLastUpdate($oid,(!empty($result['oUPD'])?$result['oUPD']->raw:NULL));
    // Recherche des groupes de champs
    $groups=array();
    foreach($this->orddesc as $foo => $k) {
      $v=&$this->desc[$k];
      if(!$v->sysField()) {
	if(empty($v->fgroup)) $v->fgroup='General';
	if(!empty($v->fgroup) && !empty($result['o'.$k])) $groups[$v->fgroup][]=&$result['o'.$k];
      }
    }
    ksort($groups);
    if(count($groups)>1) $result['_groups']=$groups;
    // Log
    if($accesslog) XLogs::uniqueUpdate('access',$oid);
    return XShell::toScreen1($tplentry,$result);
  }

  /// affichage d'une objet
  public function &display2($ar) {
    $p = new XParam($ar, array('_lastupdate'=>XShell::admini_mode(),
			       'genempty'=>1));
    $publishedonly = $p->get('_publishedonly');
    $genempty = $p->get('genempty');
    $archive = $p->get('_archive');
    // dans le cas ou la data d'archive est codee en 9999-99-99 99:99:99
    // on enleve tous les caracteres non chiffres
    if(!empty($archive) && !preg_match('/^([0-9]+)$/',$archive)) $archive=preg_replace('/([^0-9]+)/','',$archive);
    $charset = $p->get('_charset');
    $table = $this->base;
    $filter='';
    if(!empty($archive)) {
      $table='A_'.$this->base;
      $filter=" AND UPD='$archive' ";
    }
    $LANG_USER = XShell::getLangUser();
    $LANG_DATA = XShell::getLangData($p->get('LANG_DATA','local'));
    if(!$this->isTranslatable()) $LANG_DATA=TZR_DEFAULT_LANG;
    $oid = $p->get('oid');
    XLogs::debug('XDataSource::display2('.$oid.')');
    $r=array();
    if(empty($oid)) return $r;
    $this->checkOID($oid,$ar,'display2');
    $options = $p->get('options');
    $_format=$p->get('_format');
    $_options = $p->get('_options');
    $lastupdate = $p->get('_lastupdate');
    $genpublishtag=@$_options['genpublishtag'];
    $published=$this->publishedMode($p);
    if(!isset($genpublishtag)) $genpublishtag=true;
    $verb='display2('.$table.')';
    XAudit::plusplus($verb);
    $rs=selectQuery("SELECT * FROM $table WHERE KOID='$oid' AND LANG='$LANG_DATA' $filter");
    if(!$ors=$rs->fetch()) {
      return $r;
    }
    $rs->closeCursor();
    if(($published=='public') && ($ors['PUBLISH']!=1)) {
      return $r;
    }

    $result=array();
    // si on est dans l'admin, vérification de la génération du champ publié ou non
    if($genpublishtag && XShell::admini_mode() && ($published=='marked')) {
      $mark=$ors['PUBLISH'];
      if($mark=='1') $pubval='checked';
      else $pubval='';
      $result['_PUBLISH_tag']='<input type="checkbox" class="checkbox" name="_PUBLISH['.$oid.']" '.$pubval.'/>';
      $result['_PUBLISH_tag'].='<input type="hidden" name="_PUBLISH_H['.$oid.']" value="'.$mark.'"/>';
    }

    $myi=0;
    $link='';
    $tlink='';
    foreach($this->desc as $k => &$v) {
      if(($v->get_published() && $publishedonly)||!isset($publishedonly)) {
	$val = $ors[$k];

	// calcul des options d'affichage
	$opt = $options[$k];
	if(($published=='marked') && ($ors['PUBLISH']=='2'))
	  $opt['_published']=false;
	else
	  $opt['_published']=true;
	if(!empty($archive))
	  $opt['_archive']=$archive;
	$opt['_format']=$_format;
 	if(!empty($charset)) {
 	  $opt['_charset']=$charset;
 	}

	// nouvel objet d'affichage
	$o=&$v->display($val,$opt);

	$result['o'.$k]=$o;
	if($genempty || ($o->html!='')) {
	  $result['fields_object'][$myi]=$o;
	  $result[$k]=$o->html;
	  $result['fields_field'][$myi]=$k;
	  $myi++;
	  if($v->get_published()) {
	    if(!empty($link)) {
	      $link.=' ';
	      $tlink.=' ';
	    }
	    $link.=$o->html;
	    $tlink.=$o->text;
	  }
	}
      }
    }
    $result['link']=$link;
    $result['tlink']=$tlink;
    $result['oid']= $oid;

    if(!empty($lastupdate)) {
      $result['lst_upd']=XLogs::getLastUpdate($oid);
    }

    XLogs::debug('XDataSource::display2: end '.$oid);
    return $result;
  }


  public function &rDisplayText($oid, $LANG_DATA='', $LANG_USER='', $opts=array()) {
    if(empty($LANG_USER)) $LANG_USER=XShell::getLangUser();
    if(empty($LANG_DATA)) $LANG_DATA=XShell::getLangData();
    $fallback = true;
    $table = $this->base;
    $charset=@$opts['_charset'];
    $_format=@$opts['_format'];
    $fmoid=@$opts['fmoid'];
    $selectedfields=@$opts['selectedfields'];

    if(!$this->isTranslatable()) $LANG_DATA=TZR_DEFAULT_LANG;
    $verb='rDisplayText('.$table.')';
    XAudit::plusplus($verb);
    if(is_array($oid)) {
      $ors=$oid;
      $oid=$ors['KOID'];
    } else {
      $p=new XParam(array(),NULL);
      $rs=&selectQuery('SELECT * FROM '.$table.' WHERE KOID="'.$oid.'" AND LANG="'.$LANG_DATA.'"');
      if(!$ors=$rs->fetch()) {
	$ret='XDataSource('.$table.')::rDisplayText: could not find object with oid='.$oid.' and lang='.$LANG_DATA.'<br/>';
	XLogs::critical('rDisplayText',$ret);
	return $ret;
      }elseif($this->publishedMode($p)=='public' && array_key_exists('PUBLISH',$ors) && $ors['PUBLISH']!=1){
	XLogs::critical('rDisplayText', 'XDataSource('.$table.')::rDisplayText: Unpublished object with oid='.$oid.' and lang='.$LANG_DATA);
	return $ret='UNPUBLISHED';
      }
      $rs->closeCursor();
    }

    $result=array();
    $myi=0;
    $tlink='';
    foreach($this->desc as $k => &$v) {
      if($selectedfields == 'all' || $v->get_published() || (!empty($selectedfields) && in_array($k,$selectedfields))) {
	$val = $ors[$k];

	// calcul des options d'affichage
	if(isset($options[$k])) $opt = $options[$k];
	else $opt=array();
	if(!empty($fmoid)) $opt['fmoid']=$fmoid;
	$opt['_published']=true;
	$opt['_format']=$_format;
 	if(!empty($charset)) {
 	  $opt['_charset']=$charset;
 	}
	// nouvel objet d'affichage
	$o=&$v->display($val,$opt);

	if(!empty($tlink)) $tlink.=" ";
	$tlink.=$o->toText();
      }
    }
    $result['link']=$tlink;
    $result['oid']= $oid;
    return $result;
  }

 /**
  * generation d'infos d'affichage simplifiees a partir d'un oid
  * utilisé en particulier pour le display des champs liens
  * @param KOID          $oid
  * @param PDO_STATEMENT $ors si renseigné écrase l'oid par $ors['KOID'], (utilisé ?)
  * @param bool          $publishedonly retourner uniquement les champs publiés
  * @param string        $LANG_DATA
  * @param string        $LANG_USER
  * @param $opts [       tableau d'options indirectes
  *    selectedfields : tableau des champs sql à calculer (ou 'all')
  *    ...
  * ]
  * @return array [
  *    array fields_object : array of XFieldVal Object, integer key
  *    XFieldVal Object ofield : pour chaque champ retourné
  *    string link : représentation html
  *    KOID oid
  *    bool translatable
  * ]
  */
  public function &rDisplay($oid,$ors=array(),$publishedonly=false,$LANG_DATA='',$LANG_USER='',$opts=array()) {
    if(empty($LANG_USER)) $LANG_USER=XShell::getLangUser();
    if(empty($LANG_DATA)) $LANG_DATA=XShell::getLangData();
    $table=$this->base;
    $charset=@$opts['_charset'];
    $_format=@$opts['_format'];
    $fmoid=@$opts['fmoid'];
    $lastupdate=@$opts['_lastupdate'];
    $selectedfields=@$opts['selectedfields'];

    if(!$this->isTranslatable()) $LANG_DATA=TZR_DEFAULT_LANG;
    XLogs::debug('XDataSource::rDisplay('.$oid.')');
    XAudit::plusplus('rDisplay('.$table.')');
    if(!empty($ors)) {
      $oid=$ors['KOID'];
    } else {
      $ar=array();
      $p=new XParam($ar,NULL);
      $rs=selectQuery('SELECT * FROM '.$table.' WHERE KOID="'.$oid.'" AND LANG="'.$LANG_DATA.'"');
      if(!$rs || !$ors=$rs->fetch()){
	$ret='XDataSource('.$table.')::rDisplay: could not find object with oid='.$oid.' and lang='.$LANG_DATA.'<br/>';
	XLogs::critical('rDisplay',$ret);
	return $ret;
      }elseif($this->publishedMode($p)=='public' && array_key_exists('PUBLISH',$ors) && $ors['PUBLISH']!=1){
	XLogs::critical('rDisplay', 'XDataSource('.$table.')::rDisplay: Unpublished object with oid='.$oid.' and lang='.$LANG_DATA);
        return $ret='UNPUBLISHED';
      }
      $rs->closeCursor();
    }
    $link='';
    $result=array('fields_object'=>array());
    foreach($this->desc as $k => &$v) {
      if($selectedfields == 'all' || (($v->get_published() && $publishedonly) || !$publishedonly) && (empty($selectedfields) || in_array($k,$selectedfields))) {
	$val = $ors[$k];
	// calcul des options d'affichage
	if(isset($opts[$k])) $opt = $opts[$k];
	else $opt=array();
	if(!empty($fmoid)) $opt['fmoid']=$fmoid;
        if (empty($opt['selectedfields']))
          $opt['_published']=true;
	$opt['_format']=$_format;
 	if(!empty($charset)) $opt['_charset']=$charset;
	// Nouvel objet d'affichage
	$o=&$v->display($val,$opt);
	$result['o'.$k]=$o;
	$result['fields_object'][]=$o;
	if($v->get_published()) {
	  if(!empty($link)) $link.=' ';
	  $link.=$o->html;
	}
      }
    }
    $result['link']=$link;
    $result['oid']=$oid;
    // Derniere mise à jour
    if(!empty($lastupdate)) $result['lst_upd']=XLogs::getLastUpdate($oid,$result['oUPD']->raw);
    // Information sur le caractere 'translatable' ou non de toute la table
    $result['translatable']=$this->isTranslatable();
    return $result;
  }

  /// Affichage d'une donnee dont l'oid est $oid, via la methode rdisplay
  public static function objectDisplayHelper($oid) {
    $x=XDataSource::objectFactoryHelper8('SPECS='.$oid);
    if(!empty($x) && Kernel::objectExists($oid)) return $x->display(array('oid'=>$oid));
    else return NULL;
  }

  /****m* XDataSource/fdisplay
   * NAME
   *   XDataSource::fdisplay - affichage detaille d'un champ
   * DESCRIPTION
   *   Permet d'afficher le contenu detaille d'un champ, fonction utilisée
   *   principalement pour l'affichage detaille.
   ****/
  public function fdisplay($ar) {
    $p = new XParam($ar, array('tplentry'=>$this->base,
			       // liste des champs qui seront affichés sur des liens
			       // si on ne veut pas prendre les published par defaut
			       'genempty'=>1));
    $tplentry = $p->get('tplentry');
    $field = $p->get('field');
    $LANG_USER = XShell::getLangUser();
    $LANG_DATA = XShell::getLangData($p->get('LANG_DATA'));
    if(!$this->isTranslatable()) $LANG_DATA=TZR_DEFAULT_LANG;
    $verb='fdisplay('.$this->base.')';
    XAudit::plusplus($verb);
    $ar['tplentry']=TZR_RETURN_DATA;
    $r=self::display($ar);
    XShell::toScreen2($tplentry, 'field', $r['o'.$field]);
  }
  /*****
	Fonction : XDataSource::gen_random_display_mask()
	Description : Display d'1 tuple pris aléatoirement.
  *****/
  function gen_random_display_mask($ar=NULL) {
    $query = $this->random_select_query($ar);
    $rs=selectQuery($query);
    $ors=array();
    if ( $ors=$rs->fetch()) $oid = $ors['KOID'];
    $ar['oid'] = $oid;
    $this->display($ar);
    $rs->closeCursor();
  }

  // Fonction reservee a la creation d'une data pour la langue par defaut.
  // La creation d'une data dans tout autre code langue se fait par Kernel::data_edit() et Kernel::proc_data_edit()
  // apres avoir cree une data en l'initialisant avec la data correspondante dans le code langue par defaut.
  //
  public function procInput($ar=NULL) {
    $this->preUpdateTasks($ar);

    $p=new XParam($ar, array('tplentry'=>$this->base,'_inputs'=>array(),'options'=>array()));
    $tplentry = $p->get('tplentry');
    $j=$p->get('_nojournal');
    $journal=empty($j);
    $moid=$p->get('fmoid','local');
    $nolog=$p->get('_nolog','local');
    $all=$p->get('_allfields');
    $fieldssec=$p->get('fieldssec','local');
    $delayed=$p->get('_delayed');
    if(!empty($delayed)) $delayed='LOW_PRIORITY ';
    else $delayed='';
    $options=$p->get('options');
    // Si option est un champ
    if(is_string($options)) $options=array();
    $unique=$p->get('_unique');
    $updateifexists = $p->get('_updateifexists');
    $unique_val = array();
    $insert = true;
    $jn='';
    // Nouvel oid puisqu'on cree une nouvelle data en langue par defaut
    $oid=$p->get('newoid'); // permet d'imposer le KOID
    if(!empty($oid) && empty($updateifexists)) {
      $cnt=countSelectQuery("select COUNT(KOID) from {$this->base} where KOID='$oid' limit 1");
      if($cnt) {
        XLogs::notice('XDataSource::procInput', $oid.' already exist');
        return array('error'=>true,'message'=>$oid.' already exist');
      }
    }
    if(empty($oid)) $oid=$this->getNewOID($ar);
    else $this->checkOID($oid,$ar,'procInput');

    // traitement des langues
    $translatable = $this->getTranslatable();
    if(!$this->isTranslatable()) $lang=TZR_DEFAULT_LANG;
    elseif($translatable==3)
      $lang=XShell::getLangData($p->get('LANG_DATA'));
    else {
      $lang=XShell::getLangData($p->get('LANG_DATA'));
      if($lang!=TZR_DEFAULT_LANG) return array('error'=>true,'message'=>'Lang error');
    }

    $query = $jn."INSERT {$delayed}INTO ".$this->base.'(';
    $fields='KOID,LANG';
    $values="'$oid','".$lang."'";
    $nottorepeat=array('UPD');
    if($this->fieldExists('OWN') && !$p->get('OWN')) {
      $fields.=',OWN';
      $values.=",'".XUser::get_current_user_uid()."'";
      $nottorepeat[]='OWN';
    }
    if($this->fieldExists('CREAD')) {
      $fields.=',CREAD';
      $values.=",'".date('Y-m-d H:i:s')."'";
      $nottorepeat[]='CREAD';
    }
    if($this->fieldExists('PUBLISH') && !$p->is_set('PUBLISH')) {
      $fields.=',PUBLISH';
      $values.=",'2'";
      $nottorepeat[]='PUBLISH';
    }
    $inputs=$p->get('_inputs','local');
    $inputvalues=array();
    foreach($this->desc as $k => &$v) {
      if(!empty($fieldssec[$k]) && $fieldssec[$k]!='rw') continue;
      if(($p->is_set($k) || $p->is_set($k.'_HID') || !empty($all)) && !in_array($k, $nottorepeat)) {
	$value = $p->get($k);
	$value_hid = $p->get($k.'_HID');
	// traitement en post edit dans les cas simples
	if(!is_object($v)) XShell::quit(array('message'=>'XDataSource::procInput: '.$this->base.':'.$k.' is not a valid field'));
        $options[$k]['oid']=$oid;
        $options[$k][$k.'_HID']=$value_hid;
        $options[$k][$k.'_title']=$p->get($k.'_title');
	$options[$k]['fmoid']=$moid;
        $r1=$v->post_edit($value,$options[$k],$inputs);
	$inputs[$k]=$r1;
	$nvalue=$r1->raw;
	$fields .= ','.$k;
	if(!empty($unique) && in_array($k, $unique)) $unique_val[]="$k like '$nvalue'";
	// cas ou on garde la valeur
	$value=$nvalue;
	if(is_array($value) && (count($value)>1))  {
	  $finalval='||';
	  foreach($value as $o1=>$o2)
	    $finalval.=$o2.'||';
	  $values.=",'".$finalval."'";
	} elseif(is_array($value))  {
	  list($o1,$o2)=each($value);
	  $values.=',?';
	  $inputvalues[]=$o2;
	} else {
	  if(!empty($r1->forcenull)) {
	    $values.=",NULL";
	  } else {
	    $values.=',?';
	    $inputvalues[]=$value;
	  }
	}
      }
    }
    $query.=$fields.') values ('.$values.')';
    // verification que l'enregistrement n'est pas existant dans le cas où on gère l'unicité
    if(!empty($unique) || !empty($updateifexists)) {
      if(!empty($unique) && !empty($unique_val)) $rs=selectQuery("select * from {$this->base} where ".implode(' and ',$unique_val));
      else $rs=selectQuery("select * from {$this->base} where KOID='$oid'");
      if($rs && ($ors=$rs->fetch())) {
	$rs->closeCursor();
	$insert = false;
	if(!empty($updateifexists)) {
	  $oid=$ors['KOID'];
	  $ar['oid']=$oid;
          $ar['_langs'] = 'all';
	  return $this->procEdit($ar);
	}
      }
    }
    if(!$insert) {
      XLogs::notice('XDataSource::procInput', $values.' rejeté');
      return array('error'=>true,'message'=>'Values not unique');
    }
    preparedUpdateQuery($query,$inputvalues,$journal);

    // Tag les metas des champs xfile
    $ar['oid']=$oid;
    $this->setFilesMeta($ar);

    // Propagation dans toutes les langues
    if($this->isTranslatable() && $this->getAutoTranslate()) {
      $xk=new Kernel;
      $xk->data_autoTranslate($oid);
    }

    // On met une ligne dans les logs pour dire qu'il y a eu modification de cet objet
    if($this->toLog() && empty($nolog)) XLogs::update('create',$oid);
    // Actions annexes
    $this->updateTasks($ar,$oid);

    // Préparation des retours de résultats
    $result=array();
    $result['oid']=$oid;
    $result['inputs']=$inputs;
    $result['message']=XLabels::getSysLabel('xdatasource','update_ok');
    return XShell::toScreen1($tplentry, $result);
  }

  public function &prepareReInput($ar=NULL) {
    return $this->prepareReEdit($ar);
  }

  public function &prepareReEdit($ar=NULL) {
    $p = new XParam($ar);
    $journal=empty($j);
    $all = $p->get('_allfields');

    $options=array();
    foreach($this->desc as $k => $v) {
      if ((isset($_REQUEST[$k]) || isset($_REQUEST[$k.'_HID'])) && empty($all))
        $_REQUEST['selectedfields'][] = $k;
      if(($p->is_set($k)||$p->is_set($k.'_HID')||!empty($all))) {
	$value = $p->get($k);
	$value_hid = $p->get($k.'_HID');
	// traitement en post edit dans les cas simples
	if(!is_object($v)) {
	  XShell::quit(array('message'=>'XDataSource::prepareReEdit: '.$this->base.":$k is not a valid field"));
	}
	$r1=$v->post_edit($value,array('oid'=>$oid,$k.'_HID'=>$value_hid),$inputs);
	$nvalue=$r1->raw;
	// cas ou on garde la valeur
	$value=$nvalue;
	if(is_array($value) && (count($value)>1))  {
	  $finalval='||';
	  foreach($value as $o1=>$o2)
	    $finalval=$finalval.$o2.'||';
	  $options[$k]['value']=$finalval;
	} elseif(is_array($value))  {
	  list($o1,$o2)=each($value);
	  $options[$k]['value']=$o2;
	} else {
	  $options[$k]['value']=$value;
	}
      }
    }
    return $options;
  }

  /// Recherche sur la source
  public function &procQuery($ar=NULL) {
    $p=new XParam($ar, array('tplentry'=>$this->base,'_storedquery'=>NULL,'getselectonly'=>false,'fieldssec'=>array()));
    $tplentry=$p->get('tplentry');
    $storedquery=$p->get('_storedquery');
    $fieldssec=$p->get('fieldssec','local');
    $persistent=$p->get('_persistent');
    $fmoid=$p->get('fmoid');
    if(!empty($storedquery)) {
      if(empty($ar)) $ar=array();
      self::prepareQuery($ar, $storedquery);
      $p=new XParam($ar,array('tplentry'=>$this->base,'_storedquery'=>NULL,'operator'=>'AND','getselectonly'=>false));
    }
    $getselectonly=$p->get('getselectonly');
    $fulltext=$p->get('fulltext');
    $filter=$p->get('_filter','norequest');
    $_select=$p->get('_select');
    if(!is_array($_select) && !empty($_select)) $_select=array($_select);
    $operator=$p->get('operator');
    if(empty($operator)) $operator='AND';
    $queryobject=$queryfields=array();
    if($fulltext=='1') {
      $query=$this->fulltext_query($ar);
      $ar['select']=$query;
      $rq='';
      $queryobject['fulltext']=1;
      $queryobject['keyword']=$p->get('keyword');
    } else {
      if(!empty($filter)) $rq=$filter;
      else $rq='1';
      if(!empty($_select)) {
	foreach($_select as $c1=>$c2) {
	  if(empty($c2)) unset($_select[$c1]);
	}
	if(!empty($_select)) $rq.=' AND (('.implode(') '.$operator.' (',$_select).'))';
      }

      // Recherche de la liste des champs
      $first=true;
      $_FIELDS=$p->get('_FIELDS');
      if(empty($_FIELDS)) {
	foreach($this->desc as $k => &$v) $_FIELDS[$k]=$k;
      }
      foreach($_FIELDS as $field => $k) {
	if(!empty($fieldssec) && $fieldssec[$k]=='none' || !$this->desc[$k]) continue;
	$v=&$this->desc[$k];
	$v1 = $p->get($field);
	$queryobject[$field]=$v1;
	$o=$v->_newXFieldQuery();
	$o->value=$v1;
	$o->empty=$p->get($field.'_empty');
	$o->op = $p->get($field.'_op');
	$o->hid=$p->get($field.'_HID');
	$o->fmt=$p->get($field.'_FMT');
	$o->par=$p->get($field.'_PAR');
	$v->post_query($o,$ar);
	if(!empty($o->empty)) $queryobject[$field.'_empty']=$o->empty;
	if(!empty($o->op)) $queryobject[$field.'_op']=$o->op;
	if(!empty($o->hid)) $queryobject[$field.'_HID']=$o->hid;
	if(!empty($o->fmt)) $queryobject[$field.'_FMT']=$o->fmt;
	if(!empty($o->par)) $queryobject[$field.'_PAR']=$o->par;
	if(!empty($o->rq)) {
	  if(!$persistent) $queryfields[$field]=$o;
	  if($first) {
	    $rq.=' AND ( '.$o->rq;
	    $first=false;
	  }else{
	    $rq.=' '.$operator.' '.$o->rq;
	  }
	}
      }
      if(!$first) $rq.=')';
    }
    $oids=$p->get('oids');
    if(!empty($oids)){
      // Si les clés sont les oids
      if(empty($oids[0])) $oids=array_keys($oids);
      $rq.=' AND '.$this->base.'.KOID in ("'.implode($oids,'","').'")';
    }
    $ar['_filter']=$rq;
    $ar['fields']=$this->base.'.*';
    list($select,$query)=$this->getSelectQuery($ar);
    if(empty($getselectonly)) {
      if($ar==NULL) $ar=array();
      $ar['queryobject']=$queryobject;
      $ar['selected']=0;
      $ar['_filter']='';
      $ar['select']=$query;
      $ar['fmoid']=$fmoid;
      $r=&$this->browse($ar);
      $r['operator']=$operator;
      $r['queryfields']=$queryfields;
      return $r;
    }else{
      return $query;
    }
  }

  /// Verification que la table des archive existe et construction si elle n'existe pas.
  protected function checkArchiveTable($createifneeded=true) {
    return true;
  }

  /// Modification d'une donnée ou d'un ensemble de données
  public function procEdit($ar=NULL) {
    global $value;
    $this->preUpdateTasks($ar);

    $p = new XParam($ar, array('tplentry'=>$this->base,'_inputs'=>array(),'fieldssec'=>array(),'options'=>array(),'_logname'=>'update'));
    $LANG_USER = XShell::getLangUser();
    if(!$this->isTranslatable()) $LANG_DATA=TZR_DEFAULT_LANG;
    else $LANG_DATA=XShell::getLangData(@$ar['LANG_DATA']);
    $tplentry = $p->get('tplentry');
    $fieldssec = $p->get('fieldssec','local');
    $delayed = $p->get('_delayed');
    $nolog = $p->get('_nolog','local');
    $track = $this->toLog();
    $options = $p->get('options');
    $langs = $p->get('_langs','local'); // En local car le module doit vérifier les droits auparavent
    // Si option est un champ
    if(is_string($options)) $options=array();

    $moid=$p->get('fmoid','local');
    if(!empty($delayed)) $delayed='LOW_PRIORITY ';
    else $delayed='';
    $oid=$p->get('oid');
    $editfields=$p->get('editfields');
    $editbatch=$p->get('editbatch');
    if(is_array($oid)) {
      $P1=array();
      $oids = array();
      foreach($this->desc as $f => $o) {
	if(($editfields=='all') || in_array($f,$editfields)){
	  $P1[$f]=$p->get($f);
	  $P1[$f.'_HID']=$p->get($f.'_HID');
	}
      }
      foreach($oid as $i => $oid1) {
	if(!$editbatch){
	  $ar1=array();
	  foreach($this->desc as $f => $o) {
	    if(($editfields=='all') || in_array($f,$editfields)){
	      if(isset($P1[$f][$i]) || isset($P1[$f.'_HID'][$i])) {
		$ar1[$f]=$P1[$f][$i];
		$ar1[$f.'_HID']=$P1[$f.'_HID'][$i];
	      }
	    }
	  }
	}else{
	  $ar1=$P1;
	}
	$ar1['editfields']=$editfields;
	$ar1['editbatch']=$editbatch;
	$ar1['fieldssec']=$fieldssec;
	$ar1['oid']=$oid1;
	$ar1['options']=$options;
	$ret = $this->procEdit($ar1);
	$oids[] = $ret['oid'];
      }
      return array('oid' => $oids);
    }
    if(!empty($GLOBALS['XLOCK'])) {
      $mode = $p->get('_mode');
      $locked=$GLOBALS['XLOCK']->locked($oid, TZR_DEFAULT_LANG);
      $procok=(empty($locked) ||
	       XShell::admini_mode()||
	       ($locked && (XUser::get_current_user_uid()==$locked['OWN'])));
    }

    $this->checkOID($oid,$ar,'procEdit');

    // Si la donnée n'existe pas dans la langue voulue, on la crée
    if(!$this->objectExists($oid, $LANG_DATA)) {
      $k = new Kernel;
      $k->data_autoTranslate($oid, $LANG_DATA);
    }

    // on genere la donnee en affichage pour calculer les differences
    if($track && empty($nolog) || $editbatch) $disp=$this->display(array('oid'=>$oid,'lang'=>$LANG_DATA,'tplentry'=>TZR_RETURN_DATA,'_lastupdate'=>0));

    // archivage de l'ancienne donnée si nécessaire
    $archive = $p->get('_archive');
    $aupd=NULL;
    if($archive && $this->checkArchiveTable(true)) {
      $this->duplicate(array('oid'=>$oid,'changeown'=>false,'lastonly'=>true,'nolog'=>true),'A_'.$this->base,$aupd);
    }

    // Sauver dans toutes les langues
    if($langs=='all'){
      $langs=array();
      foreach($GLOBALS['TZR_LANGUAGES'] as $l=>&$v) $langs[]=$l;
    }

    $logname=$p->get('_logname');
    $rq='UPD=NULL,KOID="'.$oid.'",LANG="'.$LANG_DATA.'"';
    $inputs=$p->get('_inputs','local');
    $inputvalues=array();
    $trace=array();
    foreach($this->orddesc as $foo => $k) {
      // Cerification des droits sur le champ
      if(!empty($fieldssec[$k]) && $fieldssec[$k]!='rw') continue;
      // Si on est dans une edition par lot, ne traiter que les champs concernés
      if(!empty($editbatch) && !in_array($k,$editfields)) continue;
      $v=&$this->desc[$k];
      if($LANG_DATA!=TZR_DEFAULT_LANG && !$v->get_translatable()) continue;
      if($p->is_set($k)||$p->is_set($k.'_HID')) {
	$value=$p->get($k);
	$value_hid=$p->get($k.'_HID');
        $options[$k]['oid']=$oid;
        $options[$k][$k.'_HID']=$value_hid;
        $options[$k][$k.'_title']=$p->get($k.'_title');
        $options[$k]['old']=@$disp['o'.$k];
        $options[$k]['_track']=$track;
	$options[$k]['fmoid']=$moid;
	$options[$k]['editbatch']=$editbatch;
	// Si on sauve dans plusieurs langues, les fichiers ne doivent pas etre effacés
	if($langs!==NULL && $v->get_translatable() && ($v->get_ftype()=='XFileDef' || $v->get_ftype()=='XImageDef')) $options[$k]['del']=false;
	$r1=$v->post_edit($value,$options[$k],$inputs);
	// Si on sauve dans plusieurs langues, on recupere les dates au format internationnal
	if($langs!==NULL && $v->get_translatable() && $v->get_ftype()=='XDateDef' && $LANG_DATA==TZR_DEFAULT_LANG) $ar[$k]=$r1->raw;
	$nvalue=$r1->raw;
	$inputs[$k]=$r1;
	if($track && !empty($r1->trace)) {
	  $trace=array_merge($trace,$r1->trace);
	}

	// cas ou on garde la valeur
	if ( $nvalue !== TZR_UNCHANGED ) {
	  if(is_array($nvalue) || ($nvalue!==NULL)) {
	    $value=$nvalue;
	    if(is_array($value) && (count($value)>1))  {
	      $finalval='||';
	      foreach($value as $o1 => $o2)
		$finalval=$finalval.$o2.'||';
	      $rq.=' ,'.$k."= ?";
	      $inputvalues[]=$finalval;
	    } elseif(is_array($value))  {
	      list($o1,$o2)=each($value);
	      $rq.=' ,'.$k."= ?";
	      $inputvalues[]=$o2;
	    } else {
	      $rq.=' ,'.$k."= ?";
	      $inputvalues[]=$value;
	    }
	  }
	  else {
	    if(!empty($r1->forcenull)) $rq.=' ,'.$k."=NULL";
	    else $rq.=' ,'.$k."= ''";
	  }
	}
      }
    }
    preparedUpdateQuery('UPDATE '.$delayed.$this->base.' set '.$rq.' where KOID="'.$oid.'" and LANG="'.$LANG_DATA.'"',$inputvalues);

    // Debloquage de l'objet
    if(!empty($GLOBALS['XLOCK']) && $mode=='unlock') $GLOBALS['XLOCK']->unlock($oid, TZR_DEFAULT_LANG);
    // Propagation dans toutes les langues
    if($LANG_DATA==TZR_DEFAULT_LANG){
      $this->propagateOnOtherLangs($oid);
      if(!empty($langs)){
	$ar1=$ar;
	$ar1['_nolog']=true;
	$ar1['_langs']=array();
	foreach($langs as $l){
	  if($l==TZR_DEFAULT_LANG) continue;
	  $_REQUEST['LANG_DATA']=$l;
	  XShell::getLangData(NULL,true);
	  $this->procEdit($ar1);
	}
	$_REQUEST['LANG_DATA']=$LANG_DATA;
	XShell::getLangData(NULL,true);
      }
    }
    // Tag les metas des champs xfile
    $this->setFilesMeta($ar);
    // On met une ligne dans les logs pour dire qu'il y a eu modification de cet objet
    if($track && empty($nolog)) XLogs::update($logname,$oid,$trace,$aupd);
    // Actions annexes
    $this->updateTasks($ar,$oid);

    // Message OK
    if(!empty($GLOBALS['XSHELL']->labels)){
      $label=$GLOBALS['XSHELL']->labels->get_label(array('variable'=>'update_success'));
      $result['message']=$label['update_success'];
    }
    $result['oid']=$oid;
    $result['inputs']=$inputs;
    return XShell::toScreen1($tplentry, $result);
  }

  /// Duplication d'un objet (toar=>table d'archivage)
  public function duplicate($ar=NULL,$toar='',&$upd='') {
    $p=new XParam($ar,array('changeown'=>true,'lastonly'=>false));
    $oid=$p->get('oid');
    $nolog=$p->get('nolog');
    $lastonly=$p->get('lastonly');
    $changeown=$p->get('changeown');
    $tdest=(empty($toar)?$this->base:$toar);
    $nkoid=$p->get('newoid');
    if(empty($nkoid)) $nkoid=(($tdest==$this->base)?$this->getNewOID($ar):$oid);

    $upd=XTimestampDef::default_timestamp();
    updateQuery('CREATE TEMPORARY TABLE tmp1 AS SELECT * FROM '.$this->base.' WHERE KOID="'.$oid.'"');
    updateQuery('UPDATE tmp1 SET KOID="'.$nkoid.'",UPD="'.$upd.'"'.
		($changeown && $this->fieldExists('OWN')?',OWN="'.XUser::get_current_user_uid().'"':''));
    updateQuery('INSERT INTO '.$tdest.' SELECT * FROM tmp1');
    updateQuery('DROP TEMPORARY TABLE tmp1');

    $inputvalues=array();
    $sql='UPD=UPD';
    foreach($this->desc as $f=>$v) {
      if($v->hasExternals()) $sql.=','.$f.'=:'.$f;
    }
    $rs=selectQuery('SELECT * FROM '.$this->base.' WHERE KOID="'.$oid.'" order by '.($lastonly?'UPD DESC,':'').'field(LANG,"'.TZR_DEFAULT_LANG.'") desc');
    while($ors=$rs->fetch()){
      if($lastonly && !empty($oupd) && $oupd!=$ors['UPD']) break;
      $oupd=$ors['UPD'];
      $lang=$ors['LANG'];
      foreach($this->desc as $f=>$v) {
	if($v->hasExternals() && ($lastonly || $lang==TZR_DEFAULT_LANG || $v->get_translatable())) {
	  if($tdest!=$this->base) $nv=$v->copyExternalsTo($ors[$f],$oid,$nkoid,preg_replace('/([^0-9])/','',$upd));
	  else $nv=$v->copyExternalsTo($ors[$f],$oid,$nkoid,'');
	  $inputvalues[$f]=$nv;
	}
      }
      if(!empty($inputvalues)) preparedUpdateQuery('UPDATE '.$tdest.' SET '.$sql.' where KOID="'.$nkoid.'" and LANG="'.$lang.'" AND UPD="'.$upd.'"',$inputvalues,true);
    }
    if(!$nolog && $this->toLog()) XLogs::update('create',$nkoid);
    return $nkoid;
  }

  /// Duplication d'un enregistrement a partir d'une page ecran
  public function procEditDup($ar=NULL) {
    $p = new XParam($ar, array('tplentry'=>$this->base));
    $LANG_USER = XShell::getLangUser();
    if(!$this->isTranslatable()) $LANG_DATA=TZR_DEFAULT_LANG;
    else $LANG_DATA=XShell::getLangData(@$ar['LANG_DATA']);
    $tplentry=$p->get('tplentry');
    $oidsrc=$p->get('oid');
    $oiddst=$this->getNewOID($ar);
    $nottorepeat=array();
    $rq = "UPD=NULL, KOID='$oiddst', LANG= '$LANG_DATA'";
    if($this->fieldExists('CREAD')) {
      $rq.=', CREAD="'.date('Y-m-d H:i:s').'"';
      $nottorepeat[]='CREAD';
    }
    if($this->fieldExists('OWN') && !($p->is_set('OWN') || $p->is_set('OWN_HID'))) {
      $rq .= ", OWN='".XUser::get_current_user_uid()."'";
    }
    // champ publish ?
    if ($this->fieldExists('PUBLISH')){
      $rq .= ", PUBLISH=2";
      $nottorepeat[]='PUBLISH';
    }

    $inputvalues=array();
    foreach($this->desc as $k => $v) {
      if(($p->is_set($k) || $p->is_set($k.'_HID')) && (!$p->is_set($k.'_del') || is_array($p->get($k.'_del'))) && !in_array($k,$nottorepeat)) {
	$value = $p->get($k);
	$value_hid = $p->get($k.'_HID');
	// traitement en post edit dans les cas simples
	$nvalue=$v->post_edit_dup($value,array('oidsrc'=>$oidsrc, 'oiddst'=>$oiddst,
					       $k.'_HID'=>$value_hid));
	// cas ou on garde la valeur
	if ( $nvalue != TZR_UNCHANGED ) {
	  if(is_array($nvalue) || ($nvalue!=NULL)) {
	    $value=$nvalue;
	    if(is_array($value) && (count($value)>1))  {
	      $finalval='||';
	      foreach($value as $o1 => $o2)
		$finalval=$finalval.$o2.'||';
	      $rq=$rq.' ,'.$k.'= ?';
	      $inputvalues[]=$finalval;
	    } elseif(is_array($value))  {
	      list($o1,$o2)=each($value);
	      $rq=$rq.' ,'.$k.'= ?';
	      $inputvalues[]=$o2;
	    } else {
	      $rq=$rq.' ,'.$k.'= ?';
	      $inputvalues[]=$value;
	    }
	  }
	  else {
	    $rq=$rq.' ,'.$k."= ''";
	  }
	}
      }
    }

    preparedUpdateQuery('INSERT INTO '.$this->base.' set '.$rq, $inputvalues);
    // Creation automatique des tuples dans les autres langues (si translation automatique)
    // (ou si pas de translation - provisoire - )
    if ( $this->isTranslatable() && $this->getAutoTranslate()) {
      $xk = new Kernel;
      $xk->data_autoTranslate($oiddst);
    }

    // on met une ligne dans les logs pour dire qu'il y a eu modification de cet objet
    if($this->toLog()) XLogs::update('create',$oiddst);

    // message ok
    $result = array('message'=>"Mise &agrave; jour r&eacute;ussie.",'oid'=>$oiddst);

    $result['oid']=$oiddst;
    return XShell::toScreen1($tplentry, $result);
  }

  // les valeurs de retour possible sont
  // all, marked, public
  // all = le champ pulished n'existe pas
  // marked = le champs published exiete et on est en mode authentife
  // public = le champs existe et on ne montre que ce qui est valide
  function publishedMode(XParam $p) {
    if(!isset($this->desc['PUBLISH'])) {
      return 'all';
    }
    if(XShell::admini_mode()){
      $published = $p->get('_published');
      if(!isset($published) || $published!==false) $published='marked';
    } else {
      $published = $p->get('_published');
      if(!isset($published) || $published!==false) $published='public';
    }
    return $published;
  }

  /// Parcours la source
  public function &browse($ar=NULL) {
    $params = new XParam
      ($ar,array('tplentry'=>$this->base,
		 // la requete qui va servir a faire le select en base
		 'select'=>'',
		 // tableau des champs qu'on veut browser. Par defaut on prend l'attribut browsable dans la base
		 'selectedfields'=>'*',
		 // tableau de type de champ qu'on veut browser.
		 'selectedtypes'=>array(),
		 // tableau propriété=>true/false (browsable, queryable...) qu'on veut browser (ex : array('browsable'=>true))
		 'selectedprops'=>array(),
		 // opératuer à appliquer entre les critères de sélection
		 'selectedop'=>'AND',
		 // complément pour la requete de selection : ordre de tri des data selectionnees
		 'order'=>'',
		 // nombre de lignes par page
		 'pagesize'=>TZR_XMODTABLE_BROWSE_PAGESIZE,
		 // cas des affichages en plusieurs pages (next/previous),
		 //    pour savoir quel est le first de la page
		 'first'=>'0', 'nocount'=>'0', 'editfields'=>array(), 'fieldssec'=>array(), 'noeditoids'=>array()
		 ));
    XLogs::debug('XDataSource::browse('.$this->base.')');
    XLabels::loadLabels('browse');
    $tplentry = $params->get('tplentry');
    $selectedop = $params->get('selectedop');
    $limit = $params->get('limit');
    $selectedfields = $params->get('selectedfields');
    $selectedtypes = $params->get('selectedtypes');
    $selectedprops = $params->get('selectedprops');
    $options = $params->get('options');
    $fieldssec = $params->get('fieldssec','local');
    $fmoid = $params->get('fmoid');
    $first = $params->get('first');
    $_format = $params->get('_format');
    $charset = $params->get('_charset');
    $last = $params->get('last');
    $pagesize = $params->get('pagesize');
    if(!isInteger($pagesize) || empty($pagesize)) $pagesize=TZR_XMODTABLE_BROWSE_PAGESIZE;
    $nocount=$params->get('nocount');
    $tlink=$params->get('tlink');
    $published=$this->publishedMode($params);
    $translatable = $this->getTranslatable();
    $_options = $params->get('_options');
    $genpublishtag=@$_options['genpublishtag'];
    $editfields = $params->get('editfields');
    $noeditoids = $params->get('noeditoids');
    if(!isset($genpublishtag)) $genpublishtag=true;

    XAudit::plusplus('browse('.$this->base.')');
    $LANG_TRAD=XShell::getLangTrad($params->get('LANG_TRAD'));
    $LANG_DATA=XShell::getLangData($params->get('LANG_DATA'));
    if(!$translatable) $LANG_DATA=TZR_DEFAULT_LANG;
    if(!empty($LANG_TRAD) && ($LANG_DATA!=$LANG_TRAD) && ($translatable!=TZR_LANG_FREELANG)) $lang_other=$LANG_DATA;

    $result=array();
    $result['header_fields']=array();
    $result['lines_oid']=array();
    $result['lines_published']=array();

    // Construction des titres des colonnes
    // - Demande les champs d'un certain type (on prend aussi les champs publié et browsable)
    // - Demande des champs prédéfinies
    // - Demande tout
    // - Demande les champs browsable (defaut)
    $fields = '';
    if($selectedfields=='all'){
      $fieldlist=$this->orddesc;
    }else{
      if(!is_array($selectedfields) && empty($selectedprops) && empty($selectedtypes)) $selectedprops['browsable']=true;
      $fieldlist=$this->getFieldsList($selectedtypes,@$selectedprops['browsable'],@$selectedprops['published'],@$selectedprops['queryable'],@$selectedprops['compulsory'],@$selectedprops['translatable'],@$selectedprops['multivalued'],$selectedfields,$selectedop);
    }
    $result['header_fields']=array();
    foreach($fieldlist as $my1 => $my2) {
      if(!empty($fieldssec[$my2]) && $fieldssec[$my2]=='none') continue;
      if(isset($this->desc[$my2])) {
	$v=&$this->desc[$my2];
	$result['header_fields'][]=$v;
	$fields.=','.$this->base.'.'.$my2;
      }
    }
    if($published!='all') $fields.=','.$this->base.'.PUBLISH';

    $ar['fields']=$fields;
    list($select,$requete,$order,$oorder)=$this->getSelectQuery($ar);

    // Calcul des pages
    if($nocount!='1') $last=countSelectQuery($select.' LIMIT 1000',true);
    if($pagesize<$last) {
      for($p=0,$i=0;($i<$last);$i+=$pagesize) $pages[$p++]=$i;
    }
    // Execution de la requete
    if(!empty($pagesize)) $rs=selectQuery($requete.' limit '.$first.', '.$pagesize);
    else $rs=selectQuery($requete);

    // Création du resultat
    $myi=0;
    $anyedit=false;
    $adminmode=XShell::admin_mode();
    $editfieldsres=array();
    // Construction des data
    $ors=array();
    $pub=NULL;
    while($rs && ($ors=$rs->fetch())) {
      $oid=$ors['KOID'];
      $result['lines_oid'][$myi]=$oid;
      if($tlink) $result['lines_tlink'][$myi]='';
      if($genpublishtag && ($published=='marked')) {
	$mark=$ors['PUBLISH'];
	if($mark=='1') $pubval='checked';
	else $pubval='';
	$pub[$myi]='<input type="checkbox" class="checkbox" name="_PUBLISH['.$oid.']" '.$pubval.'/>';
	$pub[$myi].='<input type="hidden" name="_PUBLISH_H['.$oid.']" value="'.$mark.'"/>';
      }
      // on regarde si l'info existe dans le cas ou il y a une langue de traduction
      if($translatable && !empty($lang_other)) {
	if($this->objectExists($oid, $lang_other)) {
	  $result['lines_translation_ok'][$myi]='1';
	} else {
	  $result['lines_translation_ok'][$myi]='0';
	}
      }

      $tabindex = 1;
      foreach($result['header_fields'] as $i => $def) {
	$k=$def->get_field();
	$value = $ors[$k];
	$opt=@$options[$k];

	$opt['_format']=$_format;
	if(empty($opt)) $opt=array();
	$opt['_published']=true;
	if($published=='marked') {
	  if($ors['PUBLISH']=='2')
	    $opt['_published']=false;
	}
 	if(!empty($charset)) {
 	  $opt['_charset']=$charset;
 	}
	if(($editfields=='all' || is_array($editfields) && in_array($k,$editfields)) && (empty($fieldssec[$k]) || $fieldssec[$k]=='rw') &&
	   !in_array($oid,$noeditoids)) {
	  if(!in_array($k,$editfieldsres)) $editfieldsres[]=$k;
	  $method='edit';
	  $opt['intable']="$myi";
	  $anyedit=true;
	} else $method='browse';
	$k1=trim($k);
	$opt['fmoid']=$fmoid;
	$opt['admin']=$adminmode;
	$opt['tabindex']=$tabindex++;
	$result['lines_o'.$k][$myi]=$def->$method($value,$opt,$ors);
	if($published=='marked') $result['lines_published'][$myi]=$ors['PUBLISH'];
	if($tlink && $def->get_published()) $result['lines_tlink'][$myi].=$result['lines_o'.$k][$myi]->text.' ';
      }
      $myi++;
    }

    $result['pagesize']=$pagesize;
    if($published=='marked') $result['lines_PUBLISH_tag']=$pub;
    if(isset($editfields)) $result['editfields']=$editfieldsres;
    $result['table']=$this->base;
    $result['first']=$first;
    $result['last']=$last;
    $result['firstlastpage']=(($last-$pagesize<=0)?'0':($last-$pagesize));
    $result['firstnext']=($first+$pagesize);
    $result['firstprev']=($first-$pagesize>=0?($first-$pagesize):$first);
    $result['select']=$select;
    $result['order']=$oorder;
    if(isset($pages)) $result['pages']=$pages;

    // Information sur le caractere "translatable" ou non de toute la table
    $result['translatable'] = $translatable;
    $result['anyedit'] = $anyedit;
    $result['queryobject']=$params->get('queryobject');
    return XShell::toScreen1($tplentry, $result);
  }

  /// Retourne les oids correspondant à une requête
  public function &browseOids($ar=NULL) {
    list($select,$requete,$order)=$this->getSelectQuery($ar);
    $rs=selectQuery($requete);
    $ors=array();
    $result=array();
    while($rs && ($ors=$rs->fetch())) {
      $result[]=$ors['KOID'];
    }
    return $result;
  }

  /// Construit une requete select selon les parametres fournis
  public function getSelectQuery($ar){
    $p=new XParam($ar,array('select'=>'','fields'=>'','order'=>'','cond'=>null));
    $select=$p->get('select','norequest');
    $order=$p->get('order');
    if(is_array($order)) $order=implode(',',$order);
    $oorder=$order;
    if(!empty($order)) $ar['order']=$order;

    if (!$select && ($p->is_set('cond') || $p->is_set('where')))
      $select = $this->select_query($ar);

    $fields=$p->get('fields');
    if(empty($fields)) $fields=$this->base.'.KOID';
    elseif($fields!='*' && $fields!=$this->base.'.*') $fields=$this->base.'.KOID'.$fields;

    // Langue
    $translatable=$this->getTranslatable();
    $LANG_USER=XShell::getLangUser();
    $LANG_TRAD=XShell::getLangTrad($p->get('LANG_TRAD'));
    $LANG_DATA=XShell::getLangData($p->get('LANG_DATA'));
    if(!$translatable) $LANG_DATA=TZR_DEFAULT_LANG;
    $lang_list=$LANG_DATA;
    if(!empty($LANG_TRAD) && ($LANG_DATA!=$LANG_TRAD) && ($translatable!=TZR_LANG_FREELANG)) {
      $lang_list=$LANG_TRAD;
      $lang_other=$LANG_DATA;
    }
    if($this->getTranslatable())
      $cond=$this->base.'.LANG="'.$lang_list.'"';
    else $cond='1';

    // Filtre
    $filter=$p->get('_filter','norequest');
    if(!empty($filter)) {
      $context=array();
      $context['/(\$\(user\))/']=XUser::get_current_user_uid();
      $filter=preg_replace(array_keys($context),array_values($context),$filter);
      $cond.=' AND '.$filter;
      if(!empty($select) && preg_match('/(where)/i',$select)) $select=preg_replace('/(where)/i','where '.$filter.' and ',$select);
      elseif(!empty($select)) $select=preg_replace('/(from [a-z0-1]+ )/i','$1 where '.$filter, $select);
    }

    // Publication
    $published=$this->publishedMode($p);
    if($published!='all' && $fields!='*' && $fields!=$this->base.'.*') $fields.=','.$this->base.'.PUBLISH';
    if($published=='public') $cond.=' AND '.$this->base.'.PUBLISH="1" ';

    // Ordre
    $jointcond = NULL;
    if(!empty($order) && empty($select)) {
      $torder=explode(',',$order);
      $order=array();
      $order=$this->makeOrder($torder,$order,$jointcond);
    }
    // Construction de la requete de selection des data
    if(!empty($select) && !empty($order) && !preg_match('/(order[ ]+by)/i',$select)) $requete=$select.' order by '.$order;
    elseif(!empty($select)) $requete=$select;
    else{
      if(!empty($jointcond)) $select='select '.$fields.' from '.$this->base.' '.$jointcond.' where '.$cond;
      else $select='select '.$fields.' from '.$this->base.' where '.$cond;
      if(!empty($order)) $requete=$select.' order by '.$order;
      else $requete=$select;
    }
    return array($select,$requete,$order,$oorder);
  }

  /// Construction de l'ordre
  function makeOrder($torder,&$order,&$jointcond){
    $tmp=implode(',',$torder);
    if(!preg_match("/^[ a-z0-9_,;.\[\]-]+$/i",$tmp)){
      $order=$tmp;
      return $order;
    }
    foreach($torder as $i=>$actorder){
      $decorder=explode(' ',trim($actorder));
      $orderfield=$decorder[0];
      if(($pos=strpos($orderfield,'['))!==false){
        $ssorderfields=explode(';',substr($orderfield,$pos+1,-1));
        $orderfield=substr($orderfield,0,$pos);
      }else{
        $ssorderfields=NULL;
      }
      if(!empty($orderfield) && isset($this->desc[$orderfield])) {
        $ftype=$this->desc[$orderfield]->get_ftype();
        if (XFieldDef::isObjectLink($ftype) || $ftype=='XDocumentDef') {
          $grouporder=array();
          $sens = $decorder[1];
          // comme on veut tout on fait un left outer join
          if (XFieldDef::isObjectLink($ftype)) {
            $rtables[0]['t'] = $this->desc[$orderfield]->get_target();
	    if($rtables[0]['t']=='%'){
	      $order[]=implode(' ',$decorder);
	      continue;
	    }
	  }else{
            $rtables=selectQueryGetAll('select DISTINCT SUBSTRING_INDEX('.$orderfield.',":",1) as t from '.$this->base);
          }

          foreach($rtables as $z){
            $rtable=$z['t'];
            $xt=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$rtable);
	    $jointcond.=' left outer join '.$rtable.' as '.$rtable.'_'.$i.' on '.$this->base.'.'.$orderfield.'='.$rtable.'_'.$i.'.KOID and '.
	      $rtable.'_'.$i.'.LANG="'.($xt->isTranslatable()?XShell::getLangData():TZR_DEFAULT_LANG).'"';
            if(!empty($ssorderfields)) $links=$ssorderfields;
            else $links=$xt->getPublished();
            foreach($links as $kl=>$vl){
	      if(fieldExists($rtable,$vl)) $grouporder[$rtable][]='ifnull('.$rtable.'_'.$i.'.'.$vl.',"")';
            }
          }

          foreach($grouporder as $kl=>$vl){
            $decorder[0]='CONCAT('.implode(',',$vl).')';
            $decorder[1]=$sens;
            $order[]=implode(' ',$decorder);
          }
        } else {
          $decorder[0] = $this->base.'.'.$decorder[0];
          $order[]=implode(' ',$decorder);
        }
      }else{
       $order[]=implode(' ',$decorder);
      }
    }
    $order=implode(',',$order);
    return $order;
  }


  function getFirstFieldName() {
    // Fisrt field = selon FORDER

    // Dans orddesc, on a les fields tries par FORDER
    $f=$this->orddesc[0];
    $od = $this->desc[$f];
    if(!is_object($od)) {
      XShell::quit('could not find published field in table '.$this->base);
    }
    $of = $od->sqlfields();
    return $of;
  }


  /// Propage le contenu des champs non traduits de la langue maitre sur toutes les autres langues
  function propagateOnOtherLangs($oid) {
    if(!$this->isTranslatable() || $this->getNonTranslatableFieldCount()==0) return;
    // Recuperation des valeurs de la langue maitre
    $rq1 = 'select * from '.$this->base." where KOID='".$oid."' and LANG='".TZR_DEFAULT_LANG."'";
    $rs=selectQuery($rq1);
    $ors=array();
    if ($ors=$rs->fetch()) {
      // Update des champs non translatables uniquement
      $rq2 = 'UPDATE '.$this->base." set KOID='".$oid."'";
      $inputvalues=array();
      foreach ($this->desc as $k => $v) {
	if(!$v->get_translatable()) {
	  $rq2 .= ', ' . $k . ' = ?';
	  $inputvalues[]=$ors[$k];
	}
      }
      $rq2 .= " where KOID='".$oid."' and LANG!='".TZR_DEFAULT_LANG."'";
      preparedUpdateQuery($rq2,$inputvalues);
    }
  }

  /// Recherche fulltext sur la source
  function fulltext_query($ar=NULL) {
    $p=new XParam($ar,array('keyseparator'=>','));
    $published=$this->publishedMode($p);
    $keys=$p->get('keyword');
    $fields=$p->get('keyfields');
    $sep=$p->get('keyseparator');
    $options=$p->get('options');
    if(empty($fields)) $fields=array_keys($this->desc);
    if($this->isTranslatable()) $lang=XShell::getLangData();
    else $lang=TZR_DEFAULT_LANG;
    if(!is_array($keys)) $keys=array($keys);
    foreach($keys as $i => $str) {
      $ks=explode($sep,$str);
      foreach($ks as $j=>$kt) {
	if($kt!='') $keywords[]=trim($kt);
      }
    }
    $cond='';
    foreach($keywords as $i=>$keyword) {
      if($cond!='') $cond.=' AND ';
      $scond='';
      foreach($fields as $k) {
	$def=$this->desc[$k];
	$s1=$def->search($keyword,$options[$k]);
	if($scond!='' && $s1!='') $scond.=' OR ';
	if($s1!='') $scond.=$s1;
      }
      if($scond!='') $cond.='('.$scond.')';
    }
    if($published=='public') {
      if(empty($cond)) $cond=' PUBLISH="1" ';
      else $cond.=' AND PUBLISH="1" ';
    }
    return 'select * from '.$this->base.' where LANG="'.$lang.'" AND '.$cond;
  }

  function del($ar) {
    $this->preUpdateTasks($ar);
    $p=new XParam($ar,array('_selectedok'=>'nok'));
    $oid=$p->get('oid');
    $lang=XShell::getLangData();
    $selected=$p->get('_selected');
    $selectedok=$p->get('_selectedok');
    $k=new Kernel();
    return $k->data_forcedDel(array('oid'=>$oid,'tplentry'=>TZR_RETURN_DATA,'action'=>'OK',
			     '_selected'=>$selected,'_selectedok'=>$selectedok, '_mytable'=>$this->base));

    // Actions annexes
    $this->updateTasks($ar,$oid);
  }

  /// rend la liste des emails dans un enregistrement en explorant tous les champs
  public function emails(&$ors) {
    $emails=array();
    $options=array();
    foreach($this->desc as $k => $v) {
      $o=&$v->display($ors[$k],$options);
      if(!empty($o->emails)) {
	if(is_string($o->emails))
	  $emails[]=$o->emails;
	else {
	  foreach($o->emails as $i=>$email) {
	    $emails[]=$email;
	  }
	}
      }
    }
    return $emails;
  }

  /// rend la liste des emails dans un enregistrement
  public function emailsFromDisplay(&$disp) {
    $emails=array();
    $options=array();
    foreach($this->desc as $k => $v) {
      $o=&$disp['o'.$k];
      if(!empty($o->emails)) {
	if(is_string($o->emails))
	  $emails[]=$o->emails;
	else {
	  foreach($o->emails as $i=>$email) {
	    $emails[]=$email;
	  }
	}
      }
    }
    return $emails;
  }

  /// rend vrai s'il y a au moins un champ publie
  function isTherePublishedField() {
    $requete = "select count(*) from DICT where DTAB='".$this->base."' and PUBLISHED=1";
    return (countSelectQuery($requete)>0);
  }

  /// recherche du premier ordre de champ disponible
  function newFieldOrder() {
    // Determine le prochain ordre pour Fxxxx
    $forder = 1;
    $rs=selectQueryByNum("select max(FORDER)+1 from DICT where DTAB='$this->base'");
    $ors=array();
    if ( $ors=$rs->fetch() ) {
      if ( $ors[0] >= 1 ) $forder=$ors[0];
    }
    $rs->closeCursor();
    return $forder;
  }


  function objectExists($koid,$lang=NULL) {
    if(empty($lang)) $lang=XShell::getLangData();
    $requete = "select count(*) from ".$this->base." where KOID='".$koid."' and LANG='".$lang."'";
    $cnt=countSelectQuery($requete);
    return ($cnt>0);
  }

  function gen_export($ar=NULL) {
    global $XSHELL;
    $params = new XParam
      ($ar,array(
		 "tplentry"=>$this->base,
		 // est ce que les donnees ont deja ete selectionnees
		 "selected"=>0,
		 // la requete qui va servir a faire le select en base
		 "select"=>"",
		 // tableau des champs qu'on veut browser. Par defaut on prend l'attribut browsable dans le base
		 // complement pour la requete de selection : ordre de tri des data selectionnees
		 "order"=>$this->getFirstFieldName(),
		 // liste des champs qui seront affiches sur des liens, si on ne veut pas prendre les published par defaut
		 "published"=>array(),
		 // taille de la ligne en nombre de cellules
		 "linesize"=>0,
		 // nombre de lignes par page
		 // genere ou pas un lien HTML sur les champs de type "lien"
		 "genlinks"=>1,
		 // on utilise ou pas le {brow1_header}
		 "header"=>1
		 ));
    $tplentry = $params->get("tplentry");
    $selectedfields = $params->get("selectedfields");
    $selected = $params->get("selected");
    $published = $params->get("published");
    $select = stripslashes($params->get("select"));
    $options = $params->get("options");
    $genlinks = $params->get("genlinks");
    $order = $params->get("order");
    $linesize=$params->get("linesize");
    $LANG_USER = $params->get("LANG_USER");
    $LANG_DATA = $params->get("LANG_DATA");
    $genlinks="0";
    $fields = "";
    $col = 0;
    $libelles=array();
    $fieldcode=array();
    // Construction des titres des colonnes
    // cas ou les champs sont browsable si indique dans la base
    reset($this->desc);
    while(list($k,$v)=each($this->desc)) {
      $libelles[$col] = $v->get_label();
      $k = $v->get_field();
      $result[$k."_label"]=$v->get_label();
      $fieldcode[$col] = $k;
      $fields.=$k;
      $f[$k]=$k;
      $col++;
    }

    // Construction de la requete de selection des data
    if ($selected==0) {
      if($select!="") {
	$requete = $select ." order by $order ";
      }
      else {
	$select = "select KOID$fields from ".$this->base." where LANG='".$LANG_DATA."'";
	$requete = $select ." order by $order ";
      }
      $rs=selectQuery($requete);
    }
    $nblines=$rs->rowCount();
    $myi=0;
    $linesoid=array();
    $linesrow=array();
    $varoid=array();
    if($linesize>0) {
      $column=0;
      $linenum=0;
    }

    // Construction des data
    $ors=array();
    while($ors=$rs->fetch()) {
      reset($f);
      $linesoid[$myi]=$ors['KOID'];
      $oid=$ors['KOID'];

      $linesrow[$myi]="";
      if($linesize>0)  $linesrowcol[$linenum][$column]["oid"] = $oid;
      while(list($k,$n)=each($f)) {
	$def = $this->desc[$k];
	$value = $ors['$k'];
	$opt=$options[$k];
	if(!isset($opt["links"])) $opt["links"]=$genlinks;
	$o=$def->display2($value,$opt);
	$val=preg_replace('@<br/>@i',"",$o->html);
	$linesrow[$myi] = $linesrow[$myi].$def->get_label()." : ".$val."\n";
	${$k}[$myi]=$val;
	if($linesize>0) $linesrowcol[$linenum][$column][$k] = $val;
      }
      if($linesize>0) {
	$column++;
	if($column >= $linesize) {
	  $linenum++;
	  $column=0;
	}
      }
      $myi++;
    }
    if($params->get("header")) {
      $result["header_fieldname"]=$libelles;
      $result["header_fieldcode"]=$fieldcode;
      $result["header_equiv"]=array();
    }
    $result["lines_oid"]=$linesoid;
    $result["lines_equiv"]=array();
    reset($f);
    while(list($k,$n)=each($f)) {
      $result["lines_".$k]=${$k};
      $result["lines_".$k."_url"]=${$k."_url"};
      $result["lines_".$k."_oid"]=${$k."_raw"};
      $result["lines_".$k."_raw"]=${$k."_oid"};
      $result["lines_".$k."_file"]=${$k."_file"};
    }
    echo "Table: ".$result["tablelabel"]."\n----\n";
    for($i=0;$i<$myi;$i++)
      echo $linesrow[$i]."\n---\n";
    $result["select"]="$select";
    $result["order"]="$order";
    echo "\n";
    $XSHELL->tpldata["$tplentry"] = $result;
  }
  function export($ar=NULL) {
    global $XSHELL;
    $params = new XParam
      ($ar,array("tplentry"=>$this->base,
		 // est ce que les donnees ont deja ete selectionnees
		 "selected"=>0,
		 // la requete qui va servir a faire le select en base
		 "select"=>"",
		 // tableau des champs qu'on veut browser. Par defaut on prend l'attribut browsable dans le base
		 // complement pour la requete de selection : ordre de tri des data selectionnees
		 "order"=>$this->getFirstFieldName(),
		 // liste des champs qui seront affiches sur des liens, si on ne veut pas prendre les published par defaut
		 "published"=>array(),
		 // taille de la ligne en nombre de cellules
		 "linesize"=>0,
		 // nombre de lignes par page
		 // genere ou pas un lien HTML sur les champs de type "lien"
		 "genlinks"=>1,
		 // on utilise ou pas le {brow1_header}
		 "header"=>1
		 ));
    $tplentry = $params->get("tplentry");
    $selectedfields = $params->get("selectedfields");
    $published = $params->get("published");
    $options = $params->get("options");
    $genlinks = $params->get("genlinks");
    $LANG_USER = $params->get("LANG_USER");
    $LANG_DATA = $params->get("LANG_DATA");
    $included = $params->get("included");
    $fields = "";
    $col = 0;
    $libelles=array();
    $fieldcode=array();

    if(!isset($included)) {
      $name = uniqid("ex").".xml";
      $tmpfname = $GLOBALS[DATA_DIR].$name;
      $fp = fopen($tmpfname, "w");
      fputs($fp, "<?xml version='1.0'  encoding=\"utf-8\"?>");
      fputs($fp, "<".$this->base."_set>");
    } else {
      $fp=$included;
    }
    // Construction des titres des colonnes
    // cas ou les champs sont browsable si indique dans la base
    reset($this->desc);
    while(list($k,$v)=each($this->desc)) {
      $libelles[$col] = $v->get_label();
      $k = $v->get_field();
      $label[$k]=$v->get_label();
      $fieldcode[$col] = $k;
      $fields.=$k;
      $f[$k]=$k;
      $col++;
    }

    $select = "select KOID$fields from ".$this->base." where LANG='".$LANG_DATA."'";
    $rs=selectQuery($select);

    $nblines=$rs->rowCount();
    $myi=0;

    // Construction des data
    $ors=array();
    while($ors=$rs->fetch()) {
      reset($f);
      $oid=$ors['KOID'];

      fputs($fp, "<".$this->base." id=\"$oid\" xml:lang=\"$LANG_DATA\">");
      while(list($k,$n)=each($f)) {
	$def = $this->desc[$k];
	$value = $ors['$k'];
	$opt=$options[$k];
	fputs($fp, $def->export($value));
      }
      fputs($fp, "</".$this->base.">");
      if($linesize>0) {
	$column++;
	if($column >= $linesize) {
	  $linenum++;
	  $column=0;
	}
      }
      $myi++;
    }
    fputs($fp, "</".$this->base."_set>");
    if(isset($included))  fclose($fp);
    $XSHELL->tpldata["$tplentry"] = array("message"=>"OK","url"=>$GLOBALS[DATA_URL].$name);

  }


  function gen_translate($ar=NULL) {
    global $XSHELL;
    global $XLANG;

    $p = new XParam($ar,array(	"tplentry"=>"",
		 		"order"=>$this->getFirstFieldName(),
    				"first"=>0,
		 		"pagesize"=>20	// nombre de lignes par page
				));
    $tplentry = $p->get("tplentry");
    $LANG_USER = XShell::getLangUser();
    $first = $p->get("first");
    $last = $p->get("last");
    $order = $p->get("order");
    $pagesize = $p->get("pagesize");
    $oid = $p->get("oid");

    $XLANG->getCodes();

    $fields = "";
    $col = 0;
    $libelles=array();
    $fieldcode=array();
    reset($this->desc);
    while(list($k,$v)=each($this->desc)) {
      if($v->get_published()) {
	$libelles[$col] = $v->get_label();
	$fieldcode[$col] = $k;
	$fields.=$k;
	$f[$k]=$k;
	$col++;
      }
    }

    if(count($f)<=0) {
      XShell::quit("XDataSource->translate: no published field in table $this->base<br/>\n");
    }


    $cond = "LANG = \"" . $LANG_USER . "\"";
    if ($oid && ($oid!="") ) $cond .= " and KOID='$oid' ";

    if ( !isset($last) ) {
      $requete = "select count(*) from ".$this->base." where ".$cond;
      $rs=selectQueryByNum($requete);
      $t1=array();
      if ($t1=$rs->fetch()) $last = $t1[0];
    }

    $requete = "select KOID$fields from ".$this->base." where ".$cond." order by ".$order." limit ".$first.", ".$pagesize;
    $rs2=selectQuery($requete);

    $myi=0;
    $ors=array();
    while($ors=$rs2->fetch()) {
      reset($f);
      $linesoid[$myi]=$ors['KOID'];
      $linesrow[$myi]="<a name=\"".$linesoid[$myi]."\"/>";
      $linesaction[$myi]="";
      while(list($k,$n)=each($f)) {
	$value = $ors['$k'];
	$def=$this->desc[$k];
	$o=$def->display2($value);
	$val=$o->html;
	$linesrow[$myi] = $linesrow[$myi]."<td>".$val."</td>\n";
	${$k}[$myi]=$val;
      }
      for ($myj=0; $myj<$XLANG->nbLang; $myj++) {
	$LANG_DATA = $XLANG->codes[$myj];
        if ( $this->objectExists( $linesoid[$myi], $LANG_DATA ) ) {
          $theUrl = sprintf(  "<A HREF=\"".$GLOBALS['TZR_SESSION_MANAGER']::complete_self()."&class=XDataSource&function=edit&table=".$this->base.
			      "&template=edit.html&oid=%s&LANG_DATA=%s&skip=1\">".XLabels::getSysLabel("general","edit")."</A>",
			      $linesoid[$myi],
			      $LANG_DATA
		              );
	  if ( $LANG_DATA != TZR_DEFAULT_LANG ) {
	    $theUrl .= ' ';
            $theUrl .= sprintf( "<A HREF=\"".$GLOBALS['TZR_SESSION_MANAGER']::complete_self()."&class=Kernel&function=data_confirmDel&table=".$this->base.
				"&template=generic_confirm.html&oid=%s&LANG_DATA=%s&skip=1\">".
				XLabels::getSysLabel("general","delete")."</A>",
                                $linesoid[$myi],
		                $LANG_DATA
		                );
	  }
          $linesaction[$myi] .= "<td>".$theUrl."</td>";
        }
        else {
	  $theUrl = sprintf( "<A HREF=\"".$GLOBALS['TZR_SESSION_MANAGER']::complete_self()."&class=Kernel&function=data_translate&table=".$this->base.
			     "&template=edit.html&oid=%s&LANG_DATA=%s&skip=1\">".
			     XLabels::getSysLabel("general","edit")."</A>",
			     $linesoid[$myi],
			     $LANG_DATA
			     );
          $linesaction[$myi] .= "<td>".$theUrl."</td>";
        }
      }
      $myi++;
    }

    $result['first']=$first;
    $result['last']=$last;
    $result['order']=$order;
    $result['firstnext']=''.($first+$pagesize).'';
    $result['firstprev']=''.($first-$pagesize>=0?($first-$pagesize):$first).'';
    $result['pagesize']= $pagesize;
    $result['header_fieldname']=$libelles;
    $result['header_fieldcode']=$fieldcode;
    $result['lang_header_code']=$XLANG->codes;
    //    $result['lines_row']=$linesrow;
    $result['lines_action']=$linesaction;
    $result['lines_oid']=$linesoid;
    foreach($f as $k=>$n) {
      $result['lines_'.$k]=${$k};
    }

    $XSHELL->tpldata["$tplentry"] = $result;
  }

  /// Suppression d'une source de donnees
  function procDeleteDataSource($ar=NULL) {
    if(empty($this->base)) securityWarning('XDataSource::procDeleteDataSource: trying to procDeleteBase with empty table');
    // on verifie si c'est une table syteme
    if($this->sysTable($this->base)) {
      $txt=$this->base.' : '.XLabels::getSysLabel('xdatasource','cannot_delete').'</br>';
      return array('message'=>$txt,'error'=>true);
    }
    // on verifie s'il y a des modules qui utilisent cette table
    $mods=XModule::modulesUsingTable($this->base,true,false,false);
    if(!empty($mods)) {
      $txt=$this->base.' : '.XLabels::getSysLabel('xdatasource.table_in_use')."<br/><ul>";
      foreach($mods as $moid => $name) {
	$txt.="<li>$name ($moid)</li>";
      }
      $txt.='</ul><br/>'.XLabels::getSysLabel('xdatasource.cannot_delete').'</br>';
      return array('message'=>$txt,'error'=>true);
    }

    // suppression des tuples dans Txxx
    $table = $this->base;
    $requete = "TRUNCATE $table";
    updateQuery($requete);
    if(XSystem::tableExists('A_'.$table)) {
      $requete = "TRUNCATE A_$table";
      updateQuery($requete);
    }

    // suppression des repertoires de donnees
    XDir::unlink($GLOBALS['DATA_DIR'].$table,true,true);

    // suppression dans BASEBASE et AMSG - recuperation du MOID
    $requete = "delete AMSG from AMSG,BASEBASE where AMSG.MOID=BASEBASE.BOID and BTAB='$table'";
    updateQuery($requete);
    $requete = "DELETE FROM BASEBASE where BTAB = '$table'";
    updateQuery($requete);

    // suppression de l'ensemble de tables Txxx
    // Drop table TXXX
    $requete =  "DROP TABLE $table";
    updateQuery($requete);
    if(XSystem::tableExists('A_'.$table)) {
      $requete =  "DROP TABLE A_$table";
      updateQuery($requete);
    }

    // suppression de tous les champs de la table desc
    $requete =	"DELETE FROM DICT where DTAB='$table'";
    updateQuery($requete);

    // suppression de tous les libelles qui concernant cette table
    $requete =	"DELETE FROM MSGS where MTAB='$table'";
    updateQuery($requete);

    // suppression de tous les messages qui concernant cette table
    $requete =	"DELETE FROM SETS where STAB='$table';";
    updateQuery($requete);

    // suppression de toutes les options texte long des champs (commentaires...) de la table
    $requete = 'DELETE FROM AMSG where MOID LIKE "'.$table.':%"';
    $rs=&updateQuery($requete);

    $txt=$this->base.' : '.XLabels::getSysLabel('xdatasource','update_ok').'</br>';
    return array('message'=>$txt,'error'=>false);
  }

  static function createLetters() {
    if(XSystem::tableExists('LETTERS')) {
      return;
    }
    $lg = TZR_DEFAULT_LANG;
    $ar1["translatable"]="1";
    $ar1["auto_translate"]="1";
    $ar1["btab"]='LETTERS';
    $ar1["bname"][$lg]='System - '.XLabels::getSysLabel('general.letters');
    XDSTable::procNewSource($ar1);
    $x=XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS=LETTERS');
    //                                                    ord obl que bro tra mul pub tar
    $x->createField('subject','Sujet','XShortTextDef','120','3','1','1','1','1','0','0');
    $x->createField('name','Nom','XTextDef',      '40','4','1','1','1','0','0','1');
    $x->createField('modid','Module','XModuleDef',         '','5','1','1','1','0','0','0');
    $x->createField('letter','Corps','XTextDef',        '60','6','0','0','0','1','0','0');
    $x->createField('disp','Mise en page','XLinkDef',      '','8','0','1','1','0','0','0','TEMPLATES');
  }
  function genImport($ar=NULL) {
    global $XSHELL;
    global $XLANG;
    global $FILE_LINE_TERMINATOR_HTML;
    global $TEXT_LINE_TERMINATOR_HTML;
    global $FIELD_SEPARATOR_HTML;
    global $FIELD_ENCLOSED_BY_HTML;
    global $ESCAPE_CHAR_HTML;

    $p = new XParam($ar, array("tplentry"=>""));
    $tplentry = $p->get("tplentry");
    $LANG_USER = XShell::getLangUser();
    $LANG_DATA = XShell::getLangData();

    // Recuperation des codes langue, pour le choix de la langue dans le fichier import
    $XLANG->getCodes();
    $lang = array();
    $langSelectionFlag = array();
    for ( $myi=0; $myi<$XLANG->nbLang; $myi++ ) {
      $lang[$myi] = $XLANG->codes[$myi];
      if ( $XLANG->codes[$myi] == $LANG_DATA ) $langSelectionFlag[$myi] = "selected";
      else $langSelectionFlag[$myi] = "";
    }

    // Liste des champs de la table, pour le choix des champs a importer et leur valeur par defaut
    $xsd = XDataSource::objectFactoryHelper8('BCLASS=XDSTable&SPECS='.$this->base);
    if ( is_array($xsd->desc) ) {
      $i = 0;
      $order = 2;
      foreach($xsd->desc as $k => $v) {
	$fieldCodes[$i] = $k;
	$fieldLabels[$i] = $v->get_label();
	$fieldTypes[$i] = $v->get_ftype();
	$fieldOrders[$i] = $order;
	$fieldDefaults[$i] = $v->edit(array());
	$i++;
      }
    }

    $result = array();
    $result["langs"] = $lang;
    $result["langSelectionFlags"] = $langSelectionFlag;
    $result["fieldCodes"]=$fieldCodes;
    $result["fieldLabels"]=$fieldLabels;
    $result["fieldTypes"]=$fieldTypes;
    $result["fieldOrders"]=$fieldOrders;
    $result["fieldDefaults"]=$fieldDefaults;
    $result["fileLineTerminator"] = $FILE_LINE_TERMINATOR_HTML;
    $result["textLineTerminator"] = $TEXT_LINE_TERMINATOR_HTML;
    $result["fieldSeparator"] = $FIELD_SEPARATOR_HTML;
    $result["fieldEnclosedBy"] = $FIELD_ENCLOSED_BY_HTML;
    $result["escapeChar"] = $ESCAPE_CHAR_HTML;

    $XSHELL->tpldata["$tplentry"] = $result;
  }

  /// Ensemble d'actions à effectuer avant qu'une modification de donnée ait lieu
  protected function preUpdateTasks(&$ar) {
    if(!empty($ar['noupdatetasks'])) return false;
    if(array_key_exists('fmoid',$ar)){
      $mod=XModule::objectFactory($ar['fmoid']);
      $mod->preUpdateTasks($ar);
    }
    return true;
  }

  /// Ensemble d'actions à effectuer après qu'une modification de donnée ait eu lieu
  protected function updateTasks(&$ar,$oid) {
    if(!empty($ar['noupdatetasks'])) return false;
    if(array_key_exists('fmoid',$ar)){
      $mod=XModule::objectFactory($ar['fmoid']);
      $mod->updateTasks($ar,$oid);
    }
    return true;
  }

  /// Tague les metas des champs fichiers à partir des données de la fiche
  function setFilesMeta($ar){
    $p=new XParam($ar);
    $oid=$p->get('oid');
    if(is_array($oid)){
      foreach($oid as $tmpoid){
	$ar1=$ar;
	$ar1['oid']=$tmpoid;
	$this->setFilesMeta($ar1);
      }
      return;
    }

    if(!$this->isTranslatable()) $LANG_DATA=TZR_DEFAULT_LANG;
    else $LANG_DATA=XShell::getLangData(@$ar['LANG_DATA']);
    $langs=$p->get('_langs');
    if($LANG_DATA==TZR_DEFAULT_LANG && !empty($langs)){
      // Si langue par defaut et langs spécifié, on ne tague que la langue par defaut, les autres langues le seront via le procEdit qui sera executé pour chaque langue
      $langs=array($LANG_DATA);
    }elseif($LANG_DATA==TZR_DEFAULT_LANG){
      // Si langue par defaut et langs non spécifié, on tague toutes les langues
      $langs=XLang::getCodes('code');
    }else{
      // SI pas langue par défaut, on ne tague que la langue en cours
      $langs=array($LANG_DATA);
    }
    $xfiles=$this->getFieldsList(array('XFileDef','XImageDef'));
    if(empty($xfiles)) return;
    foreach($langs as $lang){
      $d=null;
      foreach($xfiles as $fname){
	$field=$this->desc[$fname];
	if($field->auto_write_meta && ($lang==TZR_DEFAULT_LANG || $this->isTranslatable() && $field->get_translatable())){
	  if(empty($d)) $d=$this->display(array('tplentry'=>TZR_RETURN_DATA,'LANG_DATA'=>$lang,'oid'=>$oid,'_lastupdate'=>0));
	  $this->_setFilesMeta($field,$d);
	}
      }
    }
  }
  // Sous méthode de setFilesMeta pour enrichissement simple des données à taguer
  function _setFilesMeta($field,$d){
    XFileDef::setFileMetaWithDisplay($d,$d['o'.$field->field]->filename);
  }
  
  // implementation de l'interface des documents
  function &XMCinput($ar) {
    return $this->input($ar);
  }
  function &XMCprocInput($ar) {
    return $this->procInput($ar);
  }
  function &XMCedit($ar) {
    return $this->edit($ar);
  }
  function &XMCprocEdit($ar) {
    return $this->procEdit($ar);
  }
  function &XMCprocEditDup($ar) {
    return $this->procEditDup($ar);
  }
  function &XMCdisplay($ar,$rdisplay=true) {
    if($rdisplay) return $this->rDisplay($ar['oid'],array(),false,'','',$ar);
    else return $this->display($ar);
  }
  function &XMCdel($ar) {
    return $this->del($ar);
  }
  function &XMCduplicate($oidsrc){
    if(!is_array($oidsrc)) $oidsrc=array('oid'=>$oidsrc);
    return $this->duplicate($oidsrc);
  }
  function &XMCquery($ar){
    return $this->query($ar);
  }
  function &XMCprocQuery($ar){
    return $this->procQuery($ar);
  }

  /// Debut v8
  /// Fonction checker pour v8
  static function procNewSource($ar){
    return array('message'=>'','error'=>false);
  }
  function browseFields($ar=NULL){
  }
  function newField($ar=NULL){
  }
  function procNewField($ar=NULL){
  }

  /// imaginer le nouvel ordre a partir du parametre forder, numero ou nom de champ
  protected function _guessFieldOrder($forder) {
    // cas ou forder est le nom du champ apres lequel on veut se placer
    if(!is_numeric($forder) && !empty($forder)) {
      $max=selectQueryGetOne('select FORDER FROM DICT WHERE DTAB="'.$this->base.'" AND FIELD="'.$forder.'"');
      if(!empty($max)) $forder=$max['FORDER']+1;
    }
    // on sait pas ou se placer on se met a la fin
    if(empty($forder)) {
      $max=selectQueryGetOne('select FORDER FROM DICT WHERE DTAB="'.$this->base.'" ORDER BY FORDER DESC');
      $forder=$max['FORDER']+1;
    } 
    return $forder;
  }


  /// publication de certains fields seulement
  // on depublie tous les champs sauf ceux qui sont dans le tableau en parametre
  function publishOnlyFields($fieldsarray) {
    $fields=implode('","',$fieldsarray);
    updateQuery('UPDATE DICT SET PUBLISHED=0 WHERE DTAB="'.$this->base.'"');
    updateQuery('UPDATE DICT SET PUBLISHED=1 WHERE DTAB="'.$this->base.'" AND FIELD IN ("'.$fields.'")');
  }

  /// Creation d'un champ avec les parameteres en liste pluttot que dans un tableau
  function createField($field,$label,$ftype,$fcount,$forder,$compulsory,$queryable=true,$browsable=true,$translatable=true,$multi=false,
		       $published=false,$target='',$options=array()) {
    $ar=array();
    $ar['field']=$field;
    $ar['ftype']=$ftype;
    $ar['fcount']=$fcount;

    $ar['forder'] = $this->_guessFieldOrder($forder);

    $ar['compulsory']=$compulsory;
    $ar['queryable']=$queryable;
    $ar['browsable']=$browsable;
    $ar['translatable']=$translatable;
    $ar['multivalued']=$multi;
    $ar['published']=$published;
    if(empty($label)) $label=$field;
    $ar['label'][TZR_DEFAULT_LANG]=$label;
    $ar['target']=$target;
    $ar['options']=$options;
    return $this->procNewField($ar);
  }

  function editField($ar=NULL){
  }

  function procEditField($ar=NULL){
  }

  /// sauvegarde des changements sur la liste des champs
  function procEditFields($ar=NULL) {
    $p=new XParam($ar,array('batch'=>0));
    $message='';
    $error=false;
    $fields=$p->get('field');
    $compulsory=$p->get('compulsory');
    $queryable=$p->get('queryable');
    $browsable=$p->get('browsable');
    $translatable=$p->get('translatable');
    $multivalued=$p->get('multivalued');
    $published=$p->get('published');
    $tplentry=$p->get('tplentry');
    $forder=$p->get('forder');
    $fcount=$p->get('fcount');
    $addOption=substr($p->get('addOption'), 2); // option additionnelle prefixée par __
    $addOptions=$p->get('addOptions'); // valeurs de l'option additionnelle
    foreach($fields as $field=>$v) {
      $label=$this->desc[$field]->get_labels();
      $ar=array('field'=>$field,
		'ftype'=>$this->desc[$field]->get_ftype(),
		'forder'=>$this->desc[$field]->get_forder(),
		'browsable'=>($browsable[$field]?$browsable[$field]:false),
		'fcount'=>($fcount[$field]?$fcount[$field]:false),
		'forder'=>($forder[$field]?$forder[$field]:0),
		'queryable'=>($queryable[$field]?$queryable[$field]:false),
		'compulsory'=>($compulsory[$field]?$compulsory[$field]:false),
		'translatable'=>($translatable[$field]?$translatable[$field]:false),
		'multivalued'=>($multivalued[$field]?$multivalued[$field]:false),
		'published'=>($published[$field]?$published[$field]:false),
		'label'=>$label,
		'target'=>$this->desc[$field]->get_target(),
		'options'=>(isset($addOptions[$field][$addOption])?array($addOption=>$addOptions[$field][$addOption]):null));
      $tmp=$this->procEditField($ar);
      $message.=$tmp['message'];
      if($tmp['error']) $error=true;
    }
    return array('message'=>$message,'error'=>$error);
  }

  /// Supprime un champ
  function delField($ar=NULL){
  }

  /// Cherche le premier nom de champo automatique disponible
  function newFieldName() {
    $no=1;
    $found=false;
    while(!$found) {
      $fname=sprintf('F%04d',$no);
      if(!$this->fieldExists($fname)) $found=true;
      else $no++;
    }
    return $fname;
  }

  /// Verifie la présence des infos obligatoires avant création d'un champ et les renseigne si necessaire
  function newFieldDescIsCorrect(&$field,&$ftype,&$fcount,&$forder,&$compulsory,&$queryable,&$browsable,$translatable,&$multivalued,
				 &$published,&$target,&$label) {
    if(empty($field)) $field=$this->newFieldName();
    if(isSQLKeyword($field)) return false;
    if(isTZRKeyword($field)) return false;
    if(is_numeric($field)) return false;
    $field=str_replace(' ','',$field);
    if($label[TZR_DEFAULT_LANG]=='') $label[TZR_DEFAULT_LANG]=$field;
    if(XFieldDef::getFCount($ftype)){
      if($fcount<=0 ) $fcount=1;
    } else $fcount=0;
    if(!is_numeric($forder) || $forder<=0) $forder=$this->newFieldOrder();
    if(!XFieldDef::getUseTarget($ftype)) $target=TZR_DEFAULT_TARGET;
    if(!XFieldDef::typeExists($ftype)) return false;
    return true;
  }

  /// Ajoute un champ dans le desc
  function newDesc($field,$ftype,$fcount,$forder,$compulsory,$queryable,$browsable,$translatable,$multivalued,$published,$target,$labels,$options=array()) {
    $r1=array('FIELD'=>$field,'FTYPE'=>$ftype,'DTAB'=>$this->base,'FCOUNT'=>$fcount,'FORDER'=>$forder);
    $obj=(object)$r1;
    $def=XFieldDef::objectFactory($obj);
    $def->set_compulsory($compulsory);
    $def->set_queryable($queryable);
    $def->set_browsable($browsable);
    $def->set_translatable($translatable);
    $def->set_multivalued($multivalued);
    $def->set_published($published);
    $def->set_labels($labels);
    $def->set_target($target);
    $def->_options->procDialog($def,$options);
    $this->desc[$field]=$def;
  }

  /// Modifie un champ dans le desc
  function changeDesc($field, $ftype,$fcount,$forder,$compulsory,$queryable,$browsable,$translatable,$multivalued,$published,$target,$label) {
    $this->delDesc($field);
    $this->newDesc($field,$ftype,$fcount,$forder,$compulsory,$queryable,$browsable,$translatable,$multivalued,$published,$target,$label);
  }

  /// Supprime un champ du desc
  function delDesc($field) {
    unset($this->desc[$field]);
  }

  /// Check la validité d'un champ dans le desc
  function fieldDescIsCorrect($field,&$ftype,&$fcount,&$forder,&$compulsory,&$queryable,&$browsable,&$translatable,&$multivalued,&$published,&$target,&$label) {
    $def=$this->desc[$field];
    if($label[TZR_DEFAULT_LANG]=='') $label[TZR_DEFAULT_LANG]=$def->get_label();
    if(XFieldDef::getFCount($ftype)) {
      if($fcount<1) {
	if($ftype==$def->get_ftype()) $fcount=$def->get_fcount();
	else $fcount=1;
      }
    }else $fcount=0;
    if(!is_numeric($forder) || $forder<1) $forder=$def->get_forder();
    if(!XFieldDef::getUseTarget($ftype)) $target=TZR_DEFAULT_TARGET;
    return true;
  }

  /// Test d'existence d'un champ
  public function fieldExists($f) {
    return isset($this->desc[$f]);
  }

  /// Retourne la liste de champ de type XLinkDef
  public function &getXLinkDefs($limits=NULL,$target=NULL) {
    $links=array();
    foreach($this->desc as $i => &$v) {
      if($v->isObjectLink() && ($target == $v->get_target() || empty($target))) {
        $f=$v->get_field();
	if(empty($limits) || in_array($f,$limits)) $links[]=$f;
      }
    }
    return $links;
  }

  /// Retourne la liste des champs de type oid utilisant la table
  static function fieldsUsingTable($table,$oid=NULL) {
    $ret=array();
    $rs=selectQuery('select * from DICT where FTYPE IN ("'.implode('","',XFieldDef::getObjectLinkTypes()).'") AND TARGET="'.$table.'"');
    while($rs && ($ors=$rs->fetch())){
      $ret[]=$ors['DTAB'].' '.$ors['FIELD'];
    }
    return $ret;
  }

  /// Vide la table
  public function clear($rq=NULL) {
  }

  /// Duplique la source (sans les données)
  public function procDuplicateDataSource($ar=NULL){
  }

  /// Check/repare la source de donnée
  public function chk($ar=NULL) {
  }

  /// Edition des proprietes d'une source
  function editProperties($ar=NULL) {
    $p=new XParam($ar, array('tplentry'=>''));
    $tplentry=$p->get('tplentry');
    $values=(object)array('translate'=>$this->getTranslatable(),'auto_translate'=>$this->getAutoTranslate(),'classname'=>get_class($this));
    $rs=selectQuery('select * from AMSG where MOID="'.$this->boid.'"');
    while($rs && ($ors=$rs->fetch())) $values->bname[$ors['MLANG']]=$ors['MTXT'];
    $options=new XOptions();
    $options->setId($this->boid);
    $options->setOpt(XLabels::getSysLabel('xdatasource','table_name'),'bname','ttext');
    $options->setOpt(XLabels::getSysLabel('xdatasource','translatable'),'translate','list',
		     array('values'=>array('1','0',TZR_LANG_FREELANG),
			   'labels'=>array(XLabels::getSysLabel('general','yes','text'),
					   XLabels::getSysLabel('general','no','text'),
					   XLabels::getSysLabel('xdatasource','freelang','text'))));
    $options->setOpt(XLabels::getSysLabel('xdatasource','automatic_translation'),'auto_translate','boolean');
    $options->setOpt(XLabels::getSysLabel('general','theclass'),'classname','text');
    $optsglob=$options->getDialog($values,NULL,'options');
    $opts=$this->_options->getDialog($this,NULL,'options');
    $result=array('options'=>$opts,'optionsglob'=>$optsglob,'boid'=>$this->boid,'table'=>$this->base);
    return XShell::toScreen1($tplentry,$result);
  }

  /// Sauvegarde des proprietes d'une datasource
  function procEditProperties($ar=NULL) {
    $p=new XParam($ar,array('tplentry'=>''));
    $options=$p->get('options');
    $bname=$options['bname'];
    $translate=$options['translate'];
    $auto_translate=$options['auto_translate'];
    $class=$options['classname'];
    if(!empty($auto_translate)) $translate=1;
    if(empty($class)) $class='XDSTable';
    $this->_options->procDialog($this,$options);
    $xml=$this->_options->toXML($this);
    if ($class == 'XDSTableView') {
      XDSTableView::updateView($this->base, $this->query);
    }
    preparedUpdateQuery('update BASEBASE set TRANSLATABLE=?, AUTO_TRANSLATE=?, BCLASS=?,BPARAM=? where BOID=?',
	array($translate,$auto_translate,$class,$xml,$this->boid));
    XLabels::updateAMsg($this->boid,$bname);
  }

  /// generation du fichier source
  function exportSpec(&$sheet){
  }
  function importSpec(&$sheet,&$message){
  }

  /// Fin v8
}

XDataSource::$_sources=array();
XDataSource::$_sources['XDSTable']=array('SOURCE'=>'Table SQL','CLASSNAME'=>'XDSTable');
XDataSource::$_sources['XDSTableView']=array('SOURCE'=>'Vue SQL','CLASSNAME'=>'XDSTableView');
?>