PHP lister_tables_objets_sql函数代码示例

function inc_profils_fusionner_dist($id_auteur, $id_import)
{
    spip_log($s = "Fusion auteur #{$id_import} => #{$id_auteur}", "profils" . _LOG_INFO_IMPORTANTE);
    // dupliquer les liens
    include_spip('action/editer_liens');
    objet_dupliquer_liens('auteur', $id_import, $id_auteur);
    // supprimer les liens
    objet_dissocier(array('auteur' => $id_import), '*');
    objet_dissocier('*', array('auteur' => $id_import));
    // changer le id_auteur dans toutes les tables qui en ont un
    $tables = lister_tables_objets_sql();
    foreach ($tables as $table_sql => $desc) {
        if (isset($desc['field']['id_auteur'])) {
            spip_log("{$table_sql} : id_auteur #{$id_import} => #{$id_auteur}", "profils" . _LOG_INFO_IMPORTANTE);
            sql_updateq($table_sql, array('id_auteur' => $id_auteur), 'id_auteur=' . intval($id_import));
        }
    }
    // log/poubelle sur l'import
    $log = date('Y-m-d H:i:s') . ' par #' . $GLOBALS['visiteur_session']['id_auteur'] . ' : ' . $s . "\n";
    $auteur = sql_fetsel('*', 'spip_auteurs', 'id_auteur=' . intval($id_import));
    $set = array("statut" => "5poubelle", "email" => $auteur['email'] . "-xxdoublon", "login" => $auteur['login'] . "-xxdoublon", 'log' => $auteur['log'] . $log);
    sql_updateq("spip_auteurs", $set, "id_auteur=" . intval($auteur['id_auteur']));
    // log sur le nouveau
    $auteur = sql_fetsel('*', 'spip_auteurs', 'id_auteur=' . intval($id_auteur));
    $set = array('log' => $auteur['log'] . $log);
    sql_updateq("spip_auteurs", $set, "id_auteur=" . intval($auteur['id_auteur']));
}

/**
 * Déclaration des alias de tables et filtres automatiques de champs
 *
 * @pipeline declarer_tables_interfaces
 * @param array $interfaces
 *	   Déclarations d'interface pour le compilateur
 * @return array
 *	   Déclarations d'interface pour le compilateur
 */
function massicot_declarer_tables_interfaces($interfaces)
{
    $interfaces = ajouter_traitement_automatique($interfaces, 'massicoter_document(%s)', 'FICHIER', 'documents');
    $interfaces = ajouter_traitement_automatique($interfaces, 'massicoter_logo_document(%s, $Pile[1])', 'LOGO_DOCUMENT');
    $interfaces = ajouter_traitement_automatique($interfaces, 'massicoter_document(%s)', 'URL_DOCUMENT', 'documents');
    /* On traîte aussi les balises #HAUTEUR et #LARGEUR des documents */
    $interfaces = ajouter_traitement_automatique($interfaces, 'massicoter_largeur(%s, $Pile[1])', 'LARGEUR', 'documents');
    $interfaces = ajouter_traitement_automatique($interfaces, 'massicoter_largeur(%s, $Pile[1])', 'HAUTEUR', 'documents');
    /* Pour chaque objet éditorial existant, ajouter un traitement sur
       les logos */
    if (isset($GLOBALS['spip_connect_version'])) {
        foreach (lister_tables_objets_sql() as $table => $valeurs) {
            if ($table !== 'spip_documents') {
                $interfaces = ajouter_traitement_automatique($interfaces, 'massicoter_logo(%s, ' . objet_type($table) . ', $Pile[1][\'' . id_table_objet($table) . '\'])', strtoupper('LOGO_' . objet_type($table)));
                $interfaces = ajouter_traitement_automatique($interfaces, 'massicoter_logo(%s, ' . objet_type($table) . ', $Pile[1][\'' . id_table_objet($table) . '\'])', strtoupper('LOGO_' . objet_type($table)) . '_NORMAL');
                $interfaces = ajouter_traitement_automatique($interfaces, 'massicoter_logo(%s, ' . objet_type($table) . ', $Pile[1][\'' . id_table_objet($table) . '\'], \'logo_survol\')', strtoupper('LOGO_' . objet_type($table)) . '_SURVOL');
            }
        }
    }
    /* sans oublier #LOGO_ARTICLE_RUBRIQUE… */
    $interfaces = ajouter_traitement_automatique($interfaces, 'massicoter_logo(%s,null,null,null,$Pile[0])', 'LOGO_ARTICLE_RUBRIQUE');
    /* …ni les #LOGO_SITE_SPIP ! */
    $interfaces = ajouter_traitement_automatique($interfaces, 'massicoter_logo(%s,"site","0","",$Pile[0])', 'LOGO_SITE_SPIP');
    $interfaces = ajouter_traitement_automatique($interfaces, 'massicoter_logo(%s,"site","0","logo_survol",$Pile[0])', 'LOGO_SITE_SPIP_SURVOL');
    return $interfaces;
}

/**
 * Lister les objets éditoriaux disponibles pour peupler une saisie
 *
 * @return array : un tableau qu'on peut utiliser comme paramètre
 *                 "datas" dans une saisie
 */
function lister_datas_objets_editoriaux()
{
    include_spip('base/objets');
    return array_map(function ($el) {
        return _T($el['texte_objets']);
    }, lister_tables_objets_sql());
}

/**
 * Ajouter les saisies SQL et de recherche
 * sur les options de config d'une saisie (de champs extras)
 *
 * @param array
 * @return array
**/
function iextras_saisies_construire_formulaire_config($flux)
{
    if (strpos($flux['args']['identifiant'], 'constructeur_formulaire_champs_extras_') === 0) {
        $table = substr($flux['args']['identifiant'], strlen('constructeur_formulaire_champs_extras_'));
        $name = $flux['args']['nom'];
        $formulaire_actuel = $flux['data'];
        $type_saisie = $flux['args']['saisie']['saisie'];
        // on ajoute le fieldset de restrictions de champs
        // (des autorisations pre-reglées en quelque sorte)
        $saisies_restrictions = array();
        // les restrictions de X ne peuvent apparaître que
        // si l'objet possede un Y.
        // secteurs -> id_secteur
        // branches -> id_rubrique
        // groupes -> id_groupe
        $desc = lister_tables_objets_sql($table);
        $types = array('secteurs' => 'id_secteur', 'branches' => 'id_rubrique', 'groupes' => 'id_groupe');
        foreach ($types as $type => $champ) {
            if (isset($desc['field'][$champ])) {
                $saisies_restrictions[] = array('saisie' => 'input', 'options' => array('nom' => "saisie_modifiee_{$name}[options][restrictions][{$type}]", 'label' => _T('iextras:label_restrictions_' . $type), 'explication' => _T('iextras:precisions_pour_restrictions_' . $type), 'defaut' => ''));
            }
        }
        // ajout des restrictions voir | modifier par auteur
        $actions = array('voir', 'modifier');
        foreach ($actions as $action) {
            $saisies_restrictions[] = array('saisie' => 'fieldset', 'options' => array('nom' => "saisie_modifiee_{$name}[options][restrictions][{$action}]", 'label' => _T('iextras:legend_restrictions_' . $action)), 'saisies' => array(array('saisie' => 'radio', 'options' => array('nom' => "saisie_modifiee_{$name}[options][restrictions][{$action}][auteur]", 'label' => _T('iextras:label_restrictions_auteur'), 'defaut' => '', 'datas' => array('' => _T('iextras:radio_restrictions_auteur_aucune'), 'admin' => _T('iextras:radio_restrictions_auteur_admin'), 'admin_complet' => _T('iextras:radio_restrictions_auteur_admin_complet'), 'webmestre' => _T('iextras:radio_restrictions_auteur_webmestre'))))));
        }
        $flux['data'] = saisies_inserer($flux['data'], array('saisie' => 'fieldset', 'options' => array('nom' => "saisie_modifiee_{$name}[options][restrictions]", 'label' => _T('iextras:legend_restriction')), 'saisies' => $saisies_restrictions));
        // On récupère les informations de la saisie
        // pour savoir si c'est un champs éditable (il a une ligne SQL)
        // et dans ce cas :
        //
        // - on modifie le type de vérification du nom du champ (regexp > nom_champ_extra)
        //   Cette vérification crée une erreur si le nom est déjà utilisé par SPIP ou un plugin, et si c'est un mot clé SQL
        //
        // - on ajoute les options techniques
        $saisies_sql = saisies_lister_disponibles_sql();
        if (isset($saisies_sql[$type_saisie])) {
            // Modification du type de vérification
            // Normalement le premier champ du premier onglet
            if ($flux['data'][0]['saisies'][0]['verifier']['type'] == 'regex') {
                $flux['data'][0]['saisies'][0]['verifier']['type'] = 'nom_champ_extra';
                $flux['data'][0]['saisies'][0]['verifier']['options']['table'] = $table;
            }
            // Ajout de l'onglet Technique
            // liste 'type_de_saisie' => 'Titre de la saisie'
            $liste_saisies = array();
            foreach ($saisies_sql as $s => $d) {
                $liste_saisies[$s] = $d['titre'];
            }
            $sql = $saisies_sql[$type_saisie]['defaut']['options']['sql'];
            $flux['data'] = saisies_inserer($flux['data'], array('saisie' => 'fieldset', 'options' => array('nom' => "saisie_modifiee_{$name}[options][options_techniques]", 'label' => _T('iextras:legend_options_techniques')), 'saisies' => array(array('saisie' => 'input', 'options' => array('nom' => "saisie_modifiee_{$name}[options][sql]", 'label' => _T('iextras:label_sql'), 'obligatoire' => 'oui', 'size' => 50, 'defaut' => $sql)), array('saisie' => 'oui_non', 'options' => array('nom' => "saisie_modifiee_{$name}[options][rechercher]", 'label' => _T('iextras:label_rechercher'), 'explication' => _T('iextras:precisions_pour_rechercher'), 'defaut' => '')), array('saisie' => 'input', 'options' => array('nom' => "saisie_modifiee_{$name}[options][rechercher_ponderation]", 'label' => _T('iextras:label_rechercher_ponderation'), 'explication' => _T('iextras:precisions_pour_rechercher_ponderation'), 'defaut' => 2, 'afficher_si' => "@saisie_modifiee_{$name}[options][rechercher]@ != ''")), array('saisie' => 'radio', 'options' => array('nom' => "saisie_modifiee_{$name}[options][traitements]", 'label' => _T('iextras:label_traitements'), 'explication' => _T('iextras:precisions_pour_traitements'), 'defaut' => '', 'datas' => array('' => _T('iextras:radio_traitements_aucun'), '_TRAITEMENT_TYPO' => _T('iextras:radio_traitements_typo'), '_TRAITEMENT_RACCOURCIS' => _T('iextras:radio_traitements_raccourcis')))), array('saisie' => 'oui_non', 'options' => array('nom' => "saisie_modifiee_{$name}[options][versionner]", 'label' => _T('iextras:label_versionner'), 'explication' => _T('iextras:precisions_pour_versionner'), 'defaut' => '')), array('saisie' => 'selection', 'options' => array('nom' => "saisie_modifiee_{$name}[options][nouveau_type_saisie]", 'label' => _T('iextras:label_saisie'), 'explication' => _T('iextras:precisions_pour_nouvelle_saisie'), 'attention' => _T('iextras:precisions_pour_nouvelle_saisie_attention'), 'defaut' => $type_saisie, 'datas' => $liste_saisies)))));
        }
    }
    return $flux;
}

/**
 * Retourne tous les champs extras par table SQL
**/
function iextras_exporter_tous() {
	include_spip('inc/iextras');
	$tables = lister_tables_objets_sql();
	$champs = array();
	foreach ($tables as $table => $desc) {
		if ($liste = iextras_champs_extras_definis($table)) {
			$champs[$table] = $liste;
		}
	}
	return $champs;
}

function inc_marquer_doublons_doc_dist($champs, $id, $type, $id_table_objet, $table_objet, $spip_table_objet, $desc = array(), $serveur = '')
{
    $champs_selection = array();
    foreach ($GLOBALS['medias_liste_champs'] as $champs_choisis) {
        if (isset($champs[$champs_choisis])) {
            array_push($champs_selection, $champs_choisis);
        }
    }
    if (count($champs_selection) == 0) {
        return;
    }
    if (!$desc) {
        $trouver_table = charger_fonction('trouver_table', 'base');
        $desc = $trouver_table($table_objet, $serveur);
    }
    $load = "";
    // charger le champ manquant en cas de modif partielle de l	'objet
    // seulement si le champ existe dans la table demande
    $champs_a_traiter = "";
    foreach ($champs_selection as $champs_a_parcourir) {
        if (isset($desc['field'][$champs_a_parcourir])) {
            $load = $champs_a_parcourir;
            $champs_a_traiter .= $champs[$champs_a_parcourir];
        }
    }
    if ($load) {
        $champs[$load] = "";
        $row = sql_fetsel($load, $spip_table_objet, "{$id_table_objet}=" . sql_quote($id));
        if ($row and isset($row[$load])) {
            $champs[$load] = $row[$load];
        }
    }
    include_spip('inc/texte');
    include_spip('base/abstract_sql');
    include_spip('action/editer_liens');
    include_spip('base/objets');
    $modeles = lister_tables_objets_sql('spip_documents');
    $modeles = $modeles['modeles'];
    $GLOBALS['doublons_documents_inclus'] = array();
    $env = array('objet' => $type, 'id_objet' => $id, $id_table_objet => $id);
    traiter_modeles($champs_a_traiter, array('documents' => $modeles), '', '', null, $env);
    // detecter les doublons
    objet_qualifier_liens(array('document' => '*'), array($type => $id), array('vu' => 'non'));
    if (count($GLOBALS['doublons_documents_inclus'])) {
        // on repasse par une requete sur spip_documents pour verifier que les documents existent bien !
        $in_liste = sql_in('id_document', $GLOBALS['doublons_documents_inclus']);
        $res = sql_allfetsel("id_document", "spip_documents", $in_liste);
        $res = array_map('reset', $res);
        // Creer le lien s'il n'existe pas deja
        objet_associer(array('document' => $res), array($type => $id), array('vu' => 'oui'));
        objet_qualifier_liens(array('document' => $res), array($type => $id), array('vu' => 'oui'));
    }
}

/**
 * Desinstallation
 *
 * @param string $nom_meta_base_version
 */
function compositions_vider_tables($nom_meta_base_version) {
	include_spip('inc/meta');
	include_spip('base/abstract_sql');

	include_spip('base/objets');
	$tables_objets = array_keys(lister_tables_objets_sql());
	foreach($tables_objets as $table){
		sql_alter("TABLE $table DROP composition");
		sql_alter("TABLE $table DROP composition_lock");
	}
	sql_alter("TABLE spip_rubriques DROP composition_branche_lock");

	effacer_meta('compositions');
	effacer_meta($nom_meta_base_version);
}

/**
 * Traitement de l'affichage ajax des puces d'action rapide
 *
 * Appelle la fonction de traitement des puces statuts
 * après avoir retrouvé le statut en cours de l'objet
 * et son parent (une rubrique)
 * 
 * @param int $id
 *     Identifiant de l'objet
 * @param string $type
 *     Type d'objet
 * @return string Code HTML
**/
function exec_puce_statut_args($id, $type)
{
    if ($table_objet_sql = table_objet_sql($type) and $d = lister_tables_objets_sql($table_objet_sql) and isset($d['statut_textes_instituer']) and $d['statut_textes_instituer']) {
        $prim = id_table_objet($type);
        $id = intval($id);
        $r = sql_fetsel("id_rubrique,statut", $table_objet_sql, "{$prim}={$id}");
        $statut = $r['statut'];
        $id_rubrique = $r['id_rubrique'];
    } else {
        $id_rubrique = intval($id);
        $statut = 'prop';
        // arbitraire
    }
    $puce_statut = charger_fonction('puce_statut', 'inc');
    ajax_retour($puce_statut($id, $statut, $id_rubrique, $type, true));
}

function liste_des_jointures()
{
    static $liste = null;
    if (is_null($liste)) {
        $liste = array();
        // recuperer les tables_objets_sql declarees
        include_spip('base/objets');
        $tables_objets = lister_tables_objets_sql();
        foreach ($tables_objets as $t => $infos) {
            if ($infos['rechercher_jointures']) {
                $liste[$infos['type']] = $infos['rechercher_jointures'];
            }
        }
        // puis passer dans le pipeline
        $liste = pipeline('rechercher_liste_des_jointures', $liste);
    }
    return $liste;
}

/**
 * Vérifie qu'un objet dispose de rôles fonctionnels
 *
 * Retourne une description des rôles si c'est le cas
 *
 * @param string $objet
 *     Objet source qui possède la table de liaison
 * @param string $objet_destination
 *     Objet sur quoi on veut lier
 *     Si défini, le retour ne contient que les roles possibles pour cet objet
 *     Sinon retourne tous les roles possibles quelque soit l'objet
 * @return bool|array
 *     false si rôles indisponibles on non déclarés
 *     array : description des roles applicables dans 3 index : colonne, titres, roles
 **/
function roles_presents($objet, $objet_destination = '')
{
    $desc = lister_tables_objets_sql(table_objet_sql($objet));
    // pas de liste de roles, on sort
    if (!isset($desc['roles_titres']) or !($titres = $desc['roles_titres'])) {
        return false;
    }
    // on vérifie que la table de liaison existe
    include_spip('action/editer_liens');
    if (!($lien = objet_associable($objet))) {
        return false;
    }
    // on cherche ensuite si la colonne existe bien dans la table de liaison (par défaut 'role')
    $colonne = isset($desc['roles_colonne']) ? $desc['roles_colonne'] : 'role';
    $trouver_table = charger_fonction('trouver_table', 'base');
    list(, $table_lien) = $lien;
    $desc_lien = $trouver_table($table_lien);
    if (!isset($desc_lien['field'][$colonne])) {
        return false;
    }
    // sur quoi peuvent s'appliquer nos rôles
    if (!($application = $desc['roles_objets'])) {
        return false;
    }
    // destination presente, on restreint si possible
    if ($objet_destination) {
        $objet_destination = table_objet($objet_destination);
        // pour l'objet
        if (isset($application[$objet_destination])) {
            $application = $application[$objet_destination];
            // sinon pour tous les objets
        } elseif (isset($application['*'])) {
            $application = $application['*'];
        } else {
            return false;
        }
    }
    // tout est ok
    return array('titres' => $titres, 'roles' => $application, 'colonne' => $colonne);
}

  function inc_chercher_logo($id, $_id_objet, $mode = 'on') {
    include_spip('inc/chercher_logo');
    global $formats_logos;
    # attention au cas $id = '0' pour LOGO_SITE_SPIP : utiliser intval()

    $type = type_du_logo($_id_objet);

    $objet = str_replace('id_', '', $_id_objet);
    $tables = lister_tables_objets_sql();
    $table = 'spip_' . $objet . 's';

    foreach ($formats_logos as $format) {
      $nom = $type . $mode . intval($id);
      if (@file_exists($d = (_DIR_LOGOS . $nom . '.' . $format))) {
        return array(
          $d,
          _DIR_LOGOS,
          $nom,
          $format,
          @filemtime($d)
        );
      }
      //si pas de logo on cherche si l'article d'origine en a un
      elseif ($tables[$table]['field']['id_trad'] AND $id_trad = sql_getfetsel('id_trad', $table, $_id_objet . '=' . intval($id)) AND _request('exec') != $objet) {
        $nom = $type . $mode . intval($id_trad);
        if (@file_exists($d = (_DIR_LOGOS . $nom . '.' . $format))) {
          return array(
            $d,
            _DIR_LOGOS,
            $nom,
            $format,
            @filemtime($d)
          );
        };
      }
    }
    # coherence de type pour servir comme filtre (formulaire_login)
    return array();
  }

/**
 * Calculer les nombres d'elements (articles, etc.) lies a chaque mot
 *
 * @param int $id_groupe
 * @return array
 */
function calculer_utilisations_mots($id_groupe)
{
    $retour = array();
    $objets = sql_allfetsel('DISTINCT objet', array('spip_mots_liens AS L', 'spip_mots AS M'), array('L.id_mot=M.id_mot', 'M.id_groupe=' . intval($id_groupe)));
    foreach ($objets as $o) {
        $objet = $o['objet'];
        $_id_objet = id_table_objet($objet);
        $table_objet_sql = table_objet_sql($objet);
        $infos = lister_tables_objets_sql($table_objet_sql);
        if (isset($infos['field']) and $infos['field']) {
            // uniquement certains statut d'objet,
            // et uniquement si la table dispose du champ statut.
            $statuts = "";
            if (isset($infos['field']['statut']) or isset($infos['statut'][0]['champ'])) {
                // on s'approche au mieux de la declaration de l'objet.
                // il faudrait ameliorer ce point.
                $c_statut = isset($infos['statut'][0]['champ']) ? $infos['statut'][0]['champ'] : 'statut';
                // bricoler les statuts d'apres la declaration de l'objet (champ previsu a defaut de mieux)
                if (array_key_exists('previsu', $infos['statut'][0]) and strlen($infos['statut'][0]['previsu']) > 1) {
                    $str_statuts = $infos['statut'][0]['previsu'];
                    if ($GLOBALS['connect_statut'] != "0minirezo") {
                        $str_statuts = str_replace('prepa', '', $str_statuts);
                    }
                    $not = substr($str_statuts, 0, 1) == '!' ? 'NOT' : '';
                    $str_statuts = str_replace('!', '', $str_statuts);
                    $Tstatuts = array_filter(explode(',', $str_statuts));
                    $statuts = " AND " . sql_in("O.{$c_statut}", $Tstatuts, $not);
                } else {
                    $statuts = " AND " . sql_in("O.{$c_statut}", $GLOBALS['connect_statut'] == "0minirezo" ? array('prepa', 'prop', 'publie') : array('prop', 'publie'));
                }
            }
            $res = sql_allfetsel("COUNT(*) AS cnt, L.id_mot", "spip_mots_liens AS L\n\t\t\t\t\tLEFT JOIN spip_mots AS M ON L.id_mot=M.id_mot\n\t\t\t\t\t\tAND L.objet=" . sql_quote($objet) . "\n\t\t\t\t\tLEFT JOIN " . $table_objet_sql . " AS O ON L.id_objet=O.{$_id_objet}", "M.id_groupe={$id_groupe}{$statuts}", "L.id_mot");
            foreach ($res as $row) {
                $retour[$table_objet_sql][$row['id_mot']] = $row['cnt'];
            }
        }
    }
    return $retour;
}

/**
 * Vérifié une valeur comme devant être un nom de champ extra
 * 
 * Ce champ ne doit pas être utilisé par SPIP ou un plugin,
 * et ne doit pas être un mot clé de mysql.
 * 
 * Si c'est bon, doit aussi vérifier une expression régulière donnée
 * 
 * Options :
 * - modele : chaine représentant l'expression régulière tolérée
 *
 * @param string $valeur
 *   La valeur à vérifier.
 * @param array $options
 *   Contient une chaine représentant l'expression.
 * @return string
 *   Retourne une chaine vide si c'est valide, sinon une chaine expliquant l'erreur.
 */
function verifier_nom_champ_extra_dist($valeur, $options = array())
{
    include_spip('base/objets');
    include_spip('inc/iextras');
    include_spip('inc/saisies');
    $erreur = '';
    $table = $options['table'];
    $valeur = strtolower($valeur);
    // Champs extras (interface) / Saisies gérent déjà l'unicité des champs extras
    // déclarés dans une table : on ne peut créer 2 champs extras de même nom.
    // Ici on vérifie en plus que ce champ n'existe pas hors de champs extras.
    $tables_spip = lister_tables_objets_sql($table);
    $champs_declares = array_keys($tables_spip['field']);
    $champs_declares = array_filter($champs_declares, 'strtolower');
    // precaution
    $champs_iextras = iextras_champs_extras_definis($table);
    $champs_iextras = array_keys(saisies_lister_avec_sql($champs_iextras));
    $champs_iextras = array_filter($champs_iextras, 'strtolower');
    // precaution
    // les champs utilisés en dehors de champs extras, sont la différence
    $champs_utilises = array_diff($champs_declares, $champs_iextras);
    if (in_array($valeur, $champs_utilises)) {
        $erreur = _T('iextras:erreur_nom_champ_utilise');
    }
    // vérifier que le champ n'est pas un mot clé sql
    if (!$erreur) {
        if (in_array(strtoupper($valeur), iextras_sql_reserved_keywords())) {
            $erreur = _T('iextras:erreur_nom_champ_mysql_keyword');
        }
    }
    // vérifier que le champ est bien formaté  (expression régulière)
    if (!$erreur) {
        $verifier = charger_fonction('verifier', 'inc');
        $options += array('modele' => '/^[\\w]+$/');
        $erreur = $verifier($valeur, 'regex', $options);
    }
    return $erreur;
}

function styliser_par_objets($flux)
{
    if (test_espace_prive() and !($squelette = $flux['data']) and strncmp($flux['args']['fond'], 'prive/objets/', 13) == 0 and $echafauder = charger_fonction('echafauder', 'prive', true)) {
        if (strncmp($flux['args']['fond'], 'prive/objets/liste/', 19) == 0) {
            $table = table_objet(substr($flux['args']['fond'], 19));
            $table_sql = table_objet_sql($table);
            $objets = lister_tables_objets_sql();
            if (isset($objets[$table_sql])) {
                $flux['data'] = $echafauder($table, $table, $table_sql, "prive/objets/liste/objets", $flux['args']['ext']);
            }
        }
        if (strncmp($flux['args']['fond'], 'prive/objets/contenu/', 21) == 0) {
            $type = substr($flux['args']['fond'], 21);
            $table = table_objet($type);
            $table_sql = table_objet_sql($table);
            $objets = lister_tables_objets_sql();
            if (isset($objets[$table_sql])) {
                $flux['data'] = $echafauder($type, $table, $table_sql, "prive/objets/contenu/objet", $flux['args']['ext']);
            }
        }
    }
    return $flux;
}

/**
 * construction de la liste des tables pour le dump :
 * toutes les tables principales
 * + toutes les tables auxiliaires hors relations
 * + les tables relations dont les deux tables liees sont dans la liste
 *
 * @param array $exclude_tables
 * @return array
 */
function base_liste_table_for_dump($exclude_tables = array())
{
    $tables_for_dump = array();
    $tables_pointees = array();
    $tables = array();
    $tables_principales = $GLOBALS['tables_principales'];
    $tables_auxiliaires = $GLOBALS['tables_auxiliaires'];
    $tables_jointures = $GLOBALS['tables_jointures'];
    if (include_spip('base/objets') and function_exists('lister_tables_objets_sql')) {
        $tables = lister_tables_objets_sql();
        foreach ($tables as $t => $infos) {
            if ($infos['principale'] and !isset($tables_principales[$t])) {
                $tables_principales[$t] = true;
            }
            if (!$infos['principale'] and !isset($tables_auxiliaires[$t])) {
                $tables_auxiliaires[$t] = true;
            }
            if (count($infos['tables_jointures'])) {
                $tables_jointures[$t] = array_merge(isset($tables_jointures[$t]) ? $tables_jointures[$t] : array(), $infos['tables_jointures']);
            }
        }
    }
    // on construit un index des tables de liens
    // pour les ajouter SI les deux tables qu'ils connectent sont sauvegardees
    $tables_for_link = array();
    foreach ($tables_jointures as $table => $liste_relations) {
        if (is_array($liste_relations)) {
            $nom = $table;
            if (!isset($tables_auxiliaires[$nom]) && !isset($tables_principales[$nom])) {
                $nom = "spip_{$table}";
            }
            if (isset($tables_auxiliaires[$nom]) || isset($tables_principales[$nom])) {
                foreach ($liste_relations as $link_table) {
                    if (isset($tables_auxiliaires[$link_table])) {
                        $tables_for_link[$link_table][] = $nom;
                    } else {
                        if (isset($tables_auxiliaires["spip_{$link_table}"])) {
                            $tables_for_link["spip_{$link_table}"][] = $nom;
                        }
                    }
                }
            }
        }
    }
    $liste_tables = array_merge(array_keys($tables_principales), array_keys($tables_auxiliaires), array_keys($tables));
    foreach ($liste_tables as $table) {
        //		$name = preg_replace("{^spip_}","",$table);
        if (!isset($tables_pointees[$table]) && !in_array($table, $exclude_tables) && !isset($tables_for_link[$table])) {
            $tables_for_dump[] = $table;
            $tables_pointees[$table] = 1;
        }
    }
    foreach ($tables_for_link as $link_table => $liste) {
        $connecte = true;
        foreach ($liste as $connect_table) {
            if (!in_array($connect_table, $tables_for_dump)) {
                $connecte = false;
            }
        }
        if ($connecte) {
            # on ajoute les liaisons en premier
            # si une restauration est interrompue,
            # cela se verra mieux si il manque des objets
            # que des liens
            array_unshift($tables_for_dump, $link_table);
        }
    }
    return array($tables_for_dump, $tables_for_link);
}