PHP spip_version_compare函数代码示例

function info_maj($dir, $file, $version)
{
    include_spip('inc/plugin');
    list($maj, $min, $rev) = preg_split('/\\D+/', $version);
    $nom = _DIR_CACHE_XML . _VERSIONS_LISTE;
    $page = !file_exists($nom) ? '' : file_get_contents($nom);
    $page = info_maj_cache($nom, $dir, $page);
    // reperer toutes les versions de numero majeur superieur ou egal
    // (a revoir quand on arrivera a SPIP V10 ...)
    $p = substr("0123456789", intval($maj));
    $p = ',/' . $file . '\\D+([' . $p . ']+)\\D+(\\d+)(\\D+(\\d+))?.*?[.]zip",i';
    preg_match_all($p, $page, $m, PREG_SET_ORDER);
    $page = '';
    foreach ($m as $v) {
        list(, $maj2, $min2, , $rev2) = $v;
        $version_maj = $maj2 . '.' . $min2 . '.' . $rev2;
        if (spip_version_compare($version, $version_maj, '<') and spip_version_compare($page, $version_maj, '<')) {
            $page = $version_maj;
        }
    }
    if (!$page) {
        return "";
    }
    return "<a class='info_maj_spip' href='" . _VERSIONS_SERVEUR . "{$dir}' title='{$page}'>" . _T('nouvelle_version_spip', array('version' => $page)) . '</a>';
}

function info_maj ($dir, $file, $version){
	include_spip('inc/plugin');
	
	list($maj,$min,$rev) = preg_split('/\D+/', $version);

	$nom = _DIR_CACHE_XML . _VERSIONS_LISTE;
	$page = !file_exists($nom) ? '' : file_get_contents($nom);
	$page = info_maj_cache($nom, $dir, $page);

	// reperer toutes les versions de numero majeur superieur ou egal
	// (a revoir quand on arrivera a SPIP V10 ...)
	$p = substr("0123456789", intval($maj));
	$p = ',/' . $file . '\D+([' . $p . ']+)\D+(\d+)(\D+(\d+))?.*?[.]zip",i';
	preg_match_all($p, $page, $m,  PREG_SET_ORDER);
	$page = '';
	foreach ($m as $v) {
		list(, $maj2, $min2,, $rev2) = $v;
		$version_maj = $maj2 . '.' . $min2 . '.' . $rev2;
		if ((spip_version_compare($version, $version_maj, '<'))
		AND (spip_version_compare($page, $version_maj, '<')))
			$page = $version_maj;
	}

	if (!$page) return "";

	return $page;
}

/**
 * Pour une description de plugin donnée (issue de la dtd de paquet.xml),
 * prépare les données à installer en bdd
 *
 * Les données sont parfois sérialisées, parfois compilées
 * pour tenir compte des spécificités de cette DTD et du stockage en bdd.
 *
 * @param array $plugin
 *     Description de plugin
 * @return array
 *     Couples clés => valeurs de description du paquet
 **/
function plugins_preparer_sql_paquet($plugin)
{
    include_spip('inc/svp_outiller');
    $champs = array();
    if (!$plugin) {
        return $champs;
    }
    // On initialise les champs ne necessitant aucune transformation
    foreach (array('categorie' => 'categorie', 'etat' => 'etat', 'version_base' => 'schema', 'logo' => 'logo', 'lien_doc' => 'documentation', 'lien_demo' => 'demonstration', 'lien_dev' => 'developpement') as $cle_champ => $cle_plugin) {
        $champs[$cle_champ] = (isset($plugin[$cle_plugin]) and $plugin[$cle_plugin]) ? $plugin[$cle_plugin] : '';
    }
    // on normalise la version 1.3.12 => 001.003.012
    $champs['version'] = (isset($plugin['version']) and $plugin['version']) ? normaliser_version($plugin['version']) : '';
    // On passe le prefixe en lettres majuscules comme ce qui est fait dans SPIP
    // Ainsi les valeurs dans la table spip_plugins coincideront avec celles de la meta plugin
    $champs['prefixe'] = strtoupper($plugin['prefix']);
    // Indicateurs d'etat numerique (pour simplifier la recherche des maj de STP)
    static $num = array('stable' => 4, 'test' => 3, 'dev' => 2, 'experimental' => 1);
    $champs['etatnum'] = isset($num[$plugin['etat']]) ? $num[$plugin['etat']] : 0;
    // On passe en utf-8 avec le bon charset les champs pouvant contenir des entites html
    foreach (array('nom' => 'nom', 'description' => 'description', 'slogan' => 'slogan') as $cle_champ => $cle_plugin) {
        $champs[$cle_champ] = (isset($plugin[$cle_plugin]) and $plugin[$cle_plugin]) ? entite2charset($plugin[$cle_plugin], 'utf-8') : '';
    }
    // Cles necessitant d'etre serialisees
    // Tags : liste de mots-cles
    // Traitement des auteurs, credits, licences et copyright
    foreach (array('tags' => 'tags', 'auteur' => 'auteur', 'credit' => 'credit', 'licence' => 'licence', 'copyright' => 'copyright') as $cle_champ => $cle_plugin) {
        $champs[$cle_champ] = (isset($plugin[$cle_plugin]) and $plugin[$cle_plugin]) ? serialize($plugin[$cle_plugin]) : '';
    }
    // Extraction de la compatibilite SPIP et construction de la liste des branches spip supportees
    $champs['compatibilite_spip'] = (isset($plugin['compatibilite']) and $plugin['compatibilite']) ? $plugin['compatibilite'] : '';
    $champs['branches_spip'] = (isset($plugin['compatibilite']) and $plugin['compatibilite']) ? compiler_branches_spip($plugin['compatibilite']) : '';
    // Construction du tableau des dependances necessite, lib et utilise
    $dependances['necessite'] = $plugin['necessite'];
    $dependances['librairie'] = $plugin['lib'];
    $dependances['utilise'] = $plugin['utilise'];
    $champs['dependances'] = serialize($dependances);
    // Calculer le champ 'procure' (tableau sérialisé prefixe => version)
    $champs['procure'] = '';
    if (!empty($plugin['procure'][0])) {
        $champs['procure'] = array();
        foreach ($plugin['procure'][0] as $procure) {
            $p = strtoupper($procure['nom']);
            if (!isset($champs['procure'][$p]) or spip_version_compare($procure['version'], $champs['procure'][$p], '>')) {
                $champs['procure'][$p] = $procure['version'];
            }
        }
        $champs['procure'] = serialize($champs['procure']);
    }
    return $champs;
}

/**
 * Upload de documents
 * 
 * Cette action recoit des fichiers ($_FILES)
 * et les affecte a l'objet courant ;
 * puis renvoie la liste des documents joints
 */
function action_crayons_upload()
{
    $type = preg_replace('/\\W+/', '', strval(_request('type')));
    $id = intval(_request('id'));
    // check securite :-)
    include_spip('inc/autoriser');
    if (!autoriser('joindredocument', $type, $id)) {
        echo "Erreur: upload interdit";
        return false;
    }
    // on n'accepte qu'un seul document à la fois, dans la variable 'upss'
    if ($file = $_FILES['upss'] and $file['error'] == 0) {
        $source = $file['tmp_name'];
        # /tmp/php/phpxxx
        $nom_envoye = $file['name'];
        # mon-image.jpg
        include_spip('plugins/installer');
        // spip_version_compare dans SPIP 3.x
        include_spip('inc/plugin');
        // spip_version_compare dans SPIP 2.x
        if (function_exists('spip_version_compare')) {
            // gerer son absence dans les branche precedente a SPIP 2.x
            if (spip_version_compare($GLOBALS['spip_version_branche'], '3.0.0alpha', '>=')) {
                define('_SPIP3', true);
            }
        }
        if (defined('_SPIP3')) {
            include_spip('action/ajouter_documents');
            $ajouter_un_document = charger_fonction('ajouter_un_document', 'action');
            $id = $ajouter_un_document("new", $file, $type, $id, 'document');
        } else {
            include_spip('inc/ajouter_documents');
            $id = ajouter_un_document($source, $nom_envoye, $type, $id, 'document', $id_document = 0, $documents_actifs, $titrer = true);
        }
    }
    if (!$id) {
        $erreur = "erreur !";
    }
    $a = recuperer_fond('modeles/uploader_item', array('id_document' => $id, 'erreur' => $erreur));
    echo $a;
}

function liste_webmestres($void)
{
	$webmestres = array();
	include_spip('inc/texte');
	include_spip('inc/plugin');

	// Version SPIP < 2.1 ou alors >= 2.1 mais utilisant toujours le define pour etablir la liste
	if (!function_exists('spip_version_compare') OR 
	spip_version_compare($GLOBALS['spip_version_branche'],"2.1.0-rc","<") OR
	defined('_ID_WEBMESTRES')) {
		$s = spip_query("SELECT * FROM spip_auteurs WHERE id_auteur IN (". join (',', array_filter(explode(':', _ID_WEBMESTRES), is_numeric)).")");
	}
	// Version SPIP >= 2.1 et utilisation du flag webmestre en base de donnees
	else {
		$s = spip_query("SELECT * FROM spip_auteurs WHERE webmestre='oui'");
	}

	while ($qui = sql_fetch($s)) {
		if (autoriser('webmestre','','',$qui))
			$webmestres[$qui['id_auteur']] = typo($qui['nom']);
	}
	return  join(', ', $webmestres);
}

function maj_vieille_base_charger_dist($version_cible){
	$vieilles_bases = array(
	'1.813'=>'1813',
	'1.821'=>'1821',
	'1.915'=>'1915',
	'1.917'=>'1917',
	'1.927'=>'1927',
	'10000'=>'10000',
	'12000'=>'13000',
	);
	$version = false;
	foreach($vieilles_bases as $v=>$n){
		if (!$version OR spip_version_compare($v,$version_cible,'<'))
			$version = $n;
	}

	/*
	include_spip('base/serial');
	include_spip('base/auxiliaires');
	$GLOBALS['nouvelle_base']['tables_principales'] = $GLOBALS['tables_principales'];
	$GLOBALS['nouvelle_base']['tables_auxiliaires'] = $GLOBALS['tables_auxiliaires'];*/

	unset($GLOBALS['tables_principales']);
	unset($GLOBALS['tables_auxiliaires']);
	unset($GLOBALS['tables_images']);
	unset($GLOBALS['tables_sequences']);
	unset($GLOBALS['tables_documents']);
	unset($GLOBALS['tables_mime']);

	// chargera les descriptions de table
	$create = charger_fonction('create',"maj/vieille_base/$version");
	if (!isset($GLOBALS['tables_auxiliaires']['spip_meta']['field']['impt']))
			$GLOBALS['tables_auxiliaires']['spip_meta']['field']['impt'] = "ENUM('non', 'oui') DEFAULT 'oui' NOT NULL";

	return $version;
}

 /**
  * Teste qu'un paquet (via son préfixe) sera actif directement
  * ou par l'intermediaire d'un procure
  *
  * @param string $prefixe
  *     Préfixe du paquet
  * @return bool
  *     Le paquet sera t'il actif ?
  **/
 public function sera_actif($prefixe)
 {
     if (isset($this->end['p'][$prefixe])) {
         return $this->end['p'][$prefixe];
     }
     // sinon regarder les procure
     $v = "0.0.0";
     $plugin = false;
     foreach ($this->end['p'] as $endp => $end) {
         if (isset($end['procure'][$prefixe]) and spip_version_compare($end['procure'][$prefixe], $v, ">")) {
             $v = $end['procure'][$prefixe];
             $plugin = $this->end['p'][$endp];
         }
     }
     return $plugin;
 }

/**
 * Détermine la version max de chaque plugin, c'est à dire
 * la version maxi d'un des paquets qui lui est lié.
 * 
 * @param array $plugins Liste d'identifiant de plugins
**/
function svp_corriger_vmax_plugins($plugins)
{
    // tous les plugins encore lies a des depots (hors local)...
    // la vmax est a retablir...
    if ($plugins) {
        $p = sql_allfetsel('DISTINCT(p.id_plugin)', array('spip_plugins AS p', 'spip_paquets AS pa'), array(sql_in('p.id_plugin', $plugins), 'p.id_plugin=pa.id_plugin', 'pa.id_depot>' . intval(0)));
        $p = array_map('array_shift', $p);
        // pour les autres, on la fixe correctement
        // On insere, en encapsulant pour sqlite...
        if (sql_preferer_transaction()) {
            sql_demarrer_transaction();
        }
        foreach ($p as $id_plugin) {
            $vmax = '';
            if ($pa = sql_allfetsel('version', 'spip_paquets', array('id_plugin=' . $id_plugin, 'id_depot>' . intval(0)))) {
                foreach ($pa as $v) {
                    if (spip_version_compare($v['version'], $vmax, '>')) {
                        $vmax = $v['version'];
                    }
                }
            }
            sql_updateq('spip_plugins', array('vmax' => $vmax), 'id_plugin=' . intval($id_plugin));
        }
        if (sql_preferer_transaction()) {
            sql_terminer_transaction();
        }
    }
}

/**
 * Test du statut d'install
 *
 * @param string $action
 * @param string $prefix
 * @param string $version_cible
 * @return bool
 */
function bank_install($action, $prefix, $version_cible)
{
    $version_base = $GLOBALS[$prefix . "_base_version"];
    switch ($action) {
        case 'test':
            $ok = (isset($GLOBALS['meta'][$prefix . "_base_version"]) and spip_version_compare($GLOBALS['meta'][$prefix . "_base_version"], $version_cible, ">="));
            if ($ok) {
                // verifier/maj des fichiers de config
                bank_presta_install();
            }
            return $ok;
            break;
        case 'install':
            bank_upgrade($prefix . "_base_version", $version_cible);
            break;
        case 'uninstall':
            bank_vider_tables($prefix . "_base_version");
            break;
    }
}

/**
 * Vérifier si une nouvelle version de SPIP est disponible
 *
 * Repérer aussi si cette version est une version majeure de SPIP.
 *
 * @param string $dir
 * @param string $file
 * @param string $version
 *      La version reçue ici est sous la forme x.y.z
 *      On la transforme par la suite pour avoir des integer ($maj, $min, $rev)
 *      et ainsi pouvoir mieux les comparer
 *
 * @return string
 */
function info_maj($dir, $file, $version)
{
    include_spip('inc/plugin');
    list($maj, $min, $rev) = preg_split('/\\D+/', $version);
    $nom = _DIR_CACHE_XML . _VERSIONS_LISTE;
    $page = !file_exists($nom) ? '' : file_get_contents($nom);
    $page = info_maj_cache($nom, $dir, $page);
    // reperer toutes les versions de numero majeur superieur ou egal
    // (a revoir quand on arrivera a SPIP V10 ...)
    $p = substr("0123456789", intval($maj));
    $p = ',/' . $file . '\\D+([' . $p . ']+)\\D+(\\d+)(\\D+(\\d+))?.*?[.]zip",i';
    preg_match_all($p, $page, $m, PREG_SET_ORDER);
    $page = $page_majeure = '';
    // branche en cours d'utilisation
    $branche = implode('.', array_slice(explode('.', $version, 3), 0, 2));
    foreach ($m as $v) {
        list(, $maj2, $min2, , $rev2) = $v;
        $branche_maj = $maj2 . '.' . $min2;
        $version_maj = $maj2 . '.' . $min2 . '.' . $rev2;
        // d'abord les mises à jour de la même branche
        if (spip_version_compare($version, $version_maj, '<') and spip_version_compare($page, $version_maj, '<') and spip_version_compare($branche, $branche_maj, '=')) {
            $page = $version_maj;
        }
        // puis les mises à jours majeures
        if (spip_version_compare($version, $version_maj, '<') and spip_version_compare($page, $version_maj, '<') and spip_version_compare($branche, $branche_maj, '<')) {
            $page_majeure = $version_maj;
        }
    }
    if (!$page and !$page_majeure) {
        return "";
    }
    $message = $page ? _T('nouvelle_version_spip', array('version' => $page)) . ($page_majeure ? ' | ' : '') : '';
    $message .= $page_majeure ? _T('nouvelle_version_spip_majeure', array('version' => $page_majeure)) : '';
    return "<a class='info_maj_spip' href='http://www.spip.net/fr_update' title='{$page}'>" . $message . '</a>';
}

function plugin_message_incompatibilite($intervalle, $version, $nom, $balise)
{
    if (preg_match(_EXTRAIRE_INTERVALLE, $intervalle, $regs)) {
        $minimum = $regs[1];
        $maximum = $regs[2];
        $minimum_inclus = $intervalle[0] == "[";
        $maximum_inclus = substr($intervalle, -1) == "]";
        if (strlen($minimum)) {
            if ($minimum_inclus and spip_version_compare($version, $minimum, '<')) {
                return _T("plugin_{$balise}_plugin", array('plugin' => $nom, 'version' => ' &ge; ' . $minimum));
            }
            if (!$minimum_inclus and spip_version_compare($version, $minimum, '<=')) {
                return _T("plugin_{$balise}_plugin", array('plugin' => $nom, 'version' => ' &gt; ' . $minimum));
            }
        }
        if (strlen($maximum)) {
            if ($maximum_inclus and spip_version_compare($version, $maximum, '>')) {
                return _T("plugin_{$balise}_plugin", array('plugin' => $nom, 'version' => ' &le; ' . $maximum));
            }
            if (!$maximum_inclus and spip_version_compare($version, $maximum, '>=')) {
                return _T("plugin_{$balise}_plugin", array('plugin' => $nom, 'version' => ' &lt; ' . $maximum));
            }
        }
    }
    return _T("plugin_necessite_plugin_sans_version", array('plugin' => $nom));
}

/**
 * Pour une description de plugin donnée (issue de la dtd de plugin.xml),
 * prépare les données à installer en bdd
 *
 * Les données sont parfois sérialisées, parfois transcodées, parfois compilées
 * pour tenir compte des spécificités de cette DTD et du stockage en bdd.
 *
 * @uses  compiler_branches_spip()
 * @param array $plugin
 *     Description de plugin
 * @return array
 *     Couples clés => valeurs de description du paquet
 **/
function plugins_preparer_sql_plugin($plugin)
{
    include_spip('inc/svp_outiller');
    $champs = array();
    if (!$plugin) {
        return $champs;
    }
    // On initialise les champs ne necessitant aucune transformation
    $champs['categorie'] = (isset($plugin['categorie']) and $plugin['categorie']) ? $plugin['categorie'] : '';
    $champs['etat'] = (isset($plugin['etat']) and $plugin['etat']) ? $plugin['etat'] : '';
    $champs['version'] = $plugin['version'] ? normaliser_version($plugin['version']) : '';
    $champs['version_base'] = (isset($plugin['schema']) and $plugin['schema']) ? $plugin['schema'] : '';
    // Renommage de certains champs
    $champs['logo'] = (isset($plugin['logo']) and $plugin['logo']) ? $plugin['logo'] : '';
    $champs['lien_doc'] = (isset($plugin['documentation']) and $plugin['documentation']) ? normaliser_lien($plugin['documentation']) : '';
    // On passe le prefixe en lettres majuscules comme ce qui est fait dans SPIP
    // Ainsi les valeurs dans la table spip_plugins coincideront avec celles de la meta plugin
    $champs['prefixe'] = strtoupper($plugin['prefix']);
    // Indicateurs d'etat numerique (pour simplifier la recherche des maj de STP)
    static $num = array('stable' => 4, 'test' => 3, 'dev' => 2, 'experimental' => 1);
    $champs['etatnum'] = (isset($plugin['etat']) and isset($num[$plugin['etat']])) ? $num[$plugin['etat']] : 0;
    // Tags : liste de mots-cles
    $champs['tags'] = (isset($plugin['tags']) and $plugin['tags']) ? serialize($plugin['tags']) : '';
    // On passe en utf-8 avec le bon charset les champs pouvant contenir des entites html
    $champs['description'] = entite2charset($plugin['description'], 'utf-8');
    // Traitement des auteurs, credits, licences et copyright
    // -- on extrait les auteurs, licences et copyrights sous forme de tableaux
    // -- depuis le commit 18294 du core la balise auteur est renvoyee sous forme de tableau mais
    //    contient toujours qu'un seul index
    $balise_auteur = entite2charset($plugin['auteur'][0], 'utf-8');
    $auteurs = normaliser_auteur_licence($balise_auteur, 'auteur');
    $balise_licence = isset($plugin['licence'][0]) ? entite2charset($plugin['licence'][0], 'utf-8') : '';
    $licences = normaliser_auteur_licence($balise_licence, 'licence');
    // -- on merge les tableaux recuperes dans auteur et licence
    $champs['auteur'] = $champs['licence'] = $champs['copyright'] = '';
    if ($t = array_merge($auteurs['auteur'], $licences['auteur'])) {
        $champs['auteur'] = serialize($t);
    }
    if ($t = array_merge($auteurs['licence'], $licences['licence'])) {
        $champs['licence'] = serialize($t);
    }
    if ($t = array_merge($auteurs['copyright'], $licences['copyright'])) {
        $champs['copyright'] = serialize($t);
    }
    // Extrait d'un nom et un slogan normalises
    // Slogan : si vide on ne fait plus rien de special, on traitera ça a l'affichage
    $champs['slogan'] = $plugin['slogan'] ? entite2charset($plugin['slogan'], 'utf-8') : '';
    // Nom :	on repere dans le nom du plugin un chiffre en fin de nom
    //			et on l'ampute de ce numero pour le normaliser
    //			et on passe tout en unicode avec le charset du site
    $champs['nom'] = trim(entite2charset($plugin['nom'], 'utf-8'));
    // Extraction de la compatibilite SPIP et construction de la liste des branches spip supportees
    $champs['compatibilite_spip'] = $plugin['compatibilite'] ? $plugin['compatibilite'] : '';
    $champs['branches_spip'] = $plugin['compatibilite'] ? compiler_branches_spip($plugin['compatibilite']) : '';
    // Construction du tableau des dependances necessite, lib et utilise
    $dependances['necessite'] = $plugin['necessite'];
    $dependances['librairie'] = $plugin['lib'];
    $dependances['utilise'] = $plugin['utilise'];
    $champs['dependances'] = serialize($dependances);
    // Calculer le champ 'procure' (tableau sérialisé prefixe => version)
    $champs['procure'] = '';
    if (!empty($plugin['procure'][0])) {
        $champs['procure'] = array();
        foreach ($plugin['procure'][0] as $procure) {
            $p = strtoupper($procure['nom']);
            if (!isset($champs['procure'][$p]) or spip_version_compare($procure['version'], $champs['procure'][$p], '>')) {
                $champs['procure'][$p] = $procure['version'];
            }
        }
        $champs['procure'] = serialize($champs['procure']);
    }
    // Champs non supportes par la DTD plugin et ne pouvant etre deduits d'autres balises
    $champs['lien_demo'] = '';
    $champs['lien_dev'] = '';
    $champs['credit'] = '';
    return $champs;
}

function article_import_k2($mon_article)
{
    include_spip('joomla2spip_fonctions');
    include_spip('plugins/installer');
    $err = '';
    // chercher si l'article n'a pas deja ete importe
    $ancien_id = $mon_article['id_article'];
    $result = sql_fetsel('id_article', 'spip_articles', 'id_article=' . intval($ancien_id));
    if ($result) {
        return;
    }
    // chercher la rubrique
    $titre_rub = $mon_article['rubrique'];
    $result = sql_fetsel('id_rubrique', 'spip_rubriques', 'titre=' . sql_quote($titre_rub));
    if ($result) {
        $id_rubrique = $result['id_rubrique'];
    }
    // creer article vide
    include_spip('action/editer_article');
    $id_article = insert_article($id_rubrique);
    $sql = "UPDATE spip_articles SET id_article = '{$ancien_id}' WHERE id_article = '{$id_article}'";
    spip_query($sql);
    if (spip_version_compare($GLOBALS['spip_version_branche'], '3.0.0', '>=')) {
        include_spip('action/editer_article');
        $sql = "UPDATE spip_auteurs_liens SET id_objet = '{$ancien_id}' WHERE id_objet = '{$id_article}' AND objet = 'article'";
    } else {
        include_spip('inc/modifier');
        $sql = "UPDATE spip_auteurs_articles SET id_article = '{$ancien_id}' WHERE id_article = '{$id_article}'";
    }
    spip_query($sql);
    $id_article = $ancien_id;
    // le remplir
    $c = array();
    foreach (array('surtitre', 'titre', 'soustitre', 'descriptif', 'nom_site', 'url_site', 'chapo', 'texte', 'maj', 'ps', 'visites') as $champ) {
        $c[$champ] = $mon_article[$champ];
    }
    revisions_articles($id_article, $c);
    // Modification de statut, changement de rubrique ?
    $c = array();
    foreach (array('date', 'statut', 'id_parent') as $champ) {
        $c[$champ] = $mon_article[$champ];
    }
    $c['id_parent'] = $id_rubrique;
    $err .= instituer_article($id_article, $c);
    // Un lien de trad a prendre en compte
    if (!spip_version_compare($GLOBALS['spip_version_branche'], '3.0.0', '>=')) {
        $err .= article_referent($id_article, array('lier_trad' => _request('lier_trad')));
    }
    // ajouter les extras
    // les documents attachées
    if (isset($mon_article['document']) and count($mon_article['document']) > 0) {
        $ajouter_documents = charger_fonction('ajouter_documents', 'action');
        $copie_local = charger_fonction('copier_local', 'action');
        include_spip('inc/joindre_document');
        include_spip('formulaires/joindre_document');
        foreach ($mon_article['document'] as $document) {
            $file = url_absolue('media/k2/attachments/' . $document['fichier']);
            spip_log($file, 'teste');
            set_request('joindre_distant', true);
            set_request('url', $file);
            $files = joindre_trouver_fichier_envoye();
            $mode = joindre_determiner_mode('auto', 'new', 'article');
            $nouveaux_doc = $ajouter_documents('new', $files, 'article', $id_article, $mode);
            spip_log($nouveaux_doc, 'teste');
            $id_document = $nouveaux_doc[0];
            $copie_local($id_document);
            $titre = isset($document['titre']) ? $document['titre'] : '';
            sql_updateq('spip_documents', array('titre' => $titre), 'id_document=' . $id_document);
        }
    }
    return $err;
}

 /**
  * Vérifie qu'un plugin plus récent existe pour un préfixe et une version donnée
  *
  * @param string $prefixe
  *     Préfixe du plugin
  * @param string $version
  *     Compatibilité à comparer, exemple '[1.0;]'
  * @return bool|array
  *     false si pas de plugin plus récent trouvé
  *     tableau de description du paquet le plus récent sinon
  */
 function chercher_plugin_recent($prefixe, $version)
 {
     $news = $this->infos_courtes(array('pl.prefixe=' . sql_quote($prefixe), 'pa.obsolete=' . sql_quote('non'), 'pa.id_depot > ' . sql_quote(0)), true);
     $res = false;
     if ($news and count($news['p'][$prefixe]) > 0) {
         foreach ($news['p'][$prefixe] as $new) {
             if (spip_version_compare($new['v'], $version, '>')) {
                 if (!$res or version_compare($new['v'], $res['v'], '>')) {
                     $res = $new;
                 }
             }
         }
     }
     return $res;
 }

function plugin_valide_resume(&$liste, $plug, $infos, $dir)
{
    $i = $infos[$dir][$plug];
    if (isset($i['erreur']) and $i['erreur']) {
        return;
    }
    if (!plugin_version_compatible($i['compatibilite'], $GLOBALS['spip_version_branche'], 'spip')) {
        return;
    }
    $p = strtoupper($i['prefix']);
    if (!isset($liste[$p]) or spip_version_compare($i['version'], $liste[$p]['version'], '>')) {
        $liste[$p] = array('nom' => $i['nom'], 'etat' => $i['etat'], 'version' => $i['version'], 'dir' => $plug, 'dir_type' => $dir);
    }
}