Esempio n. 1
0
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']));
}
Esempio n. 2
0
/**
 * 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());
}
Esempio n. 4
0
/**
 * 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;
}
Esempio n. 5
0
/**
 * 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;
}
Esempio n. 6
0
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);
}
Esempio n. 8
0
/**
 * 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));
}
Esempio n. 9
0
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;
}
Esempio n. 10
0
/**
 * 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();
  }
Esempio n. 12
0
/**
 * 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;
}
Esempio n. 14
0
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;
}
Esempio n. 15
0
/**
 * 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);
}
Esempio n. 16
0
/**
 * Ajouter les saisies SQL et de recherche
 * sur les options de config d'une saisie (de champs extras)
 *
 * @param array
 * @return array
**/
function iextras_formulaire_verifier($flux) {
	if ($flux['args']['form'] == 'construire_formulaire'
	AND strpos($flux['args']['args'][0], 'champs_extras_')===0
	AND $nom_ou_id = _request('configurer_saisie') ) {

		// On ajoute le préfixe devant l'identifiant
		$identifiant = 'constructeur_formulaire_'.$flux['args']['args'][0];
		// On récupère le formulaire à son état actuel
		$formulaire_actuel = session_get($identifiant);

		if ($nom_ou_id[0] == '@') {
			$saisies_actuelles = saisies_lister_par_identifiant($formulaire_actuel);
			$name = $saisies_actuelles[$nom_ou_id]['options']['nom'];
		} else {
			$saisies_actuelles = saisies_lister_par_nom($formulaire_actuel);
			$name = $nom_ou_id;
		}

		// saisie inexistante => on sort
		if (!isset($saisies_actuelles[$nom_ou_id])) {
			return $flux;
		}

		$nom = 'configurer_' . $name;
		$table = substr($flux['args']['args'][0], strlen('champs_extras_'));


		// 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'][$nom] = saisies_inserer($flux['data'][$nom], 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 ajoute les options techniques
		$type_saisie = $saisies_actuelles[$nom_ou_id]['saisie'];
		$saisies_sql = saisies_lister_disponibles_sql();

		if (isset($saisies_sql[$type_saisie])) {

			// 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'][$nom] = saisies_inserer($flux['data'][$nom], 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;
}
Esempio n. 17
0
/**
 * Liste les champs anormaux par rapport aux définitions de SPIP
 *
 * @note
 *     Aucune garantie que $connect autre que la connexion principale fasse quelque chose
 *
 * @param string $connect
 *     Nom du connecteur de base de données
 * @return array
 *     Tableau (table => couples(colonne => description SQL))
 */
function extras_champs_anormaux($connect = '')
{
    static $tout = false;
    if ($tout !== false) {
        return $tout;
    }
    // recuperer les tables et champs de la base de donnees
    // les vrais de vrai dans la base sql...
    $tout = extras_base($connect);
    // recuperer les champs SPIP connus
    // si certains ne sont pas declares alors qu'ils sont presents
    // dans la base sql, on pourra proposer de les utiliser comme champs
    // extras (plugin interface).
    include_spip('base/objets');
    $tables_spip = lister_tables_objets_sql();
    // chercher ce qui est different
    $ntables = array();
    $nchamps = array();
    // la table doit être un objet editorial
    $tout = array_intersect_key($tout, $tables_spip);
    foreach ($tout as $table => $champs) {
        // la table doit être un objet editorial principal
        if ($tables_spip[$table]['principale'] == 'oui') {
            // pour chaque champ absent de la déclaration, on le note dans $nchamps.
            foreach ($champs as $champ => $desc) {
                if (!isset($tables_spip[$table]['field'][$champ])) {
                    if (!isset($nchamps[$table])) {
                        $nchamps[$table] = array();
                    }
                    $nchamps[$table][$champ] = $desc;
                }
            }
        }
    }
    if ($nchamps) {
        $tout = $nchamps;
    } else {
        $tout = array();
    }
    return $tout;
}
Esempio n. 18
0
/**
 * Liste les champs versionnés d'une table objet.
 * 
 * @param string $table
 *     Nom complet de sa table sql. Exemple 'spip_articles'
 * @return array
 *     Liste des champs versionnés
 */
function liste_champs_versionnes($table)
{
    $liste_objets_versionnees = is_array(unserialize($GLOBALS['meta']['objets_versions'])) ? unserialize($GLOBALS['meta']['objets_versions']) : array();
    if (!in_array($table, $liste_objets_versionnees)) {
        return array();
    }
    include_spip('base/objets');
    if ($infos = lister_tables_objets_sql($table) and isset($infos['champs_versionnes'])) {
        return $infos['champs_versionnes'];
    }
    return array();
}
Esempio n. 19
0
/**
 * Récupère les valeurs d'une traduction de référence pour la création
 * d'un objet (préremplissage du formulaire). 
 *
 * @param string $type
 *     Type d'objet (article, breve...)
 * @param string|int $id_objet
 *     Identifiant de l'objet, ou "new" pour une création
 * @param int $id_rubrique
 *     Identifiant éventuel de la rubrique parente
 * @param int $lier_trad
 *     Identifiant éventuel de la traduction de référence
 * @param string $champ_titre
 *     Nom de la colonne SQL de l'objet donnant le titre
 * @return array
 *     Couples clés / valeurs des champs du formulaire à charger
**/
function precharger_traduction_objet($type, $id_objet, $id_rubrique = 0, $lier_trad = 0, $champ_titre = 'titre')
{
    $table = table_objet_sql($type);
    $_id_objet = id_table_objet($table);
    // Recuperer les donnees de l'objet original
    $row = sql_fetsel("*", $table, "{$_id_objet}={$lier_trad}");
    if ($row) {
        $row[$champ_titre] = filtrer_entites(_T('info_nouvelle_traduction')) . ' ' . $row[$champ_titre];
    } else {
        $row = array();
    }
    // on met l'objet dans une rubrique si l'objet le peut
    $desc = lister_tables_objets_sql($table);
    $is_rubrique = isset($desc['field']['id_rubrique']);
    if ($is_rubrique) {
        if ($id_rubrique) {
            $row['id_rubrique'] = $id_rubrique;
            return $row;
        }
        $id_rubrique = $row['id_rubrique'];
        // Regler la langue, si possible, sur celle du redacteur
        // Cela implique souvent de choisir une rubrique ou un secteur
        if (in_array($GLOBALS['spip_lang'], explode(',', $GLOBALS['meta']['langues_multilingue']))) {
            // Si le menu de langues est autorise sur l'objet,
            // on peut changer la langue quelle que soit la rubrique
            // donc on reste dans la meme rubrique
            if (in_array($table, explode(',', $GLOBALS['meta']['multi_objets']))) {
                $row['id_rubrique'] = $row['id_rubrique'];
                # explicite :-)
                // Sinon, chercher la rubrique la plus adaptee pour
                // accueillir l'objet dans la langue du traducteur
            } elseif ($is_rubrique and $GLOBALS['meta']['multi_rubriques'] == 'oui') {
                if ($GLOBALS['meta']['multi_secteurs'] == 'oui') {
                    $id_parent = 0;
                } else {
                    // on cherche une rubrique soeur dans la bonne langue
                    $row_rub = sql_fetsel("id_parent", "spip_rubriques", "id_rubrique={$id_rubrique}");
                    $id_parent = $row_rub['id_parent'];
                }
                $row_rub = sql_fetsel("id_rubrique", "spip_rubriques", "lang='" . $GLOBALS['spip_lang'] . "' AND id_parent={$id_parent}");
                if ($row_rub) {
                    $row['id_rubrique'] = $row_rub['id_rubrique'];
                }
            }
        }
    }
    return $row;
}
Esempio n. 20
0
/**
 * Lister les objets pris en compte dans les URLs
 * c'est à dire suceptibles d'avoir une URL propre
 *
 * @param bool $preg
 *  Permet de définir si la fonction retourne une chaine avec `|` comme séparateur
 *  pour utiliser en preg, ou un array()
 * @return string|array
 */
function urls_liste_objets($preg = true)
{
    static $url_objets = null;
    if (is_null($url_objets)) {
        $url_objets = array();
        // recuperer les tables_objets_sql declarees
        $tables_objets = lister_tables_objets_sql();
        foreach ($tables_objets as $t => $infos) {
            if ($infos['page']) {
                $url_objets[] = $infos['type'];
                $url_objets = array_merge($url_objets, $infos['type_surnoms']);
            }
        }
        $url_objets = pipeline('declarer_url_objets', $url_objets);
    }
    if (!$preg) {
        return $url_objets;
    }
    return implode('|', array_map('preg_quote', $url_objets));
}
Esempio n. 21
0
/**
 * Calcule la liste des langues reellement utilisees dans le site public
 *
 * La recherche de langue est effectuée en recréant une boucle pour chaque
 * objet éditorial gérant des langues de sorte que les éléments non publiés
 * ne sont pas pris en compte.
 * 
 * @param string $serveur
 *    Nom du connecteur à la base de données
 * @return string
 *    Liste des langues utilisées séparées par des virgules
**/
function calculer_langues_utilisees($serveur = '')
{
    include_spip('public/interfaces');
    include_spip('public/compiler');
    include_spip('public/composer');
    $langues = array();
    $langues[$GLOBALS['meta']['langue_site']] = 1;
    include_spip('base/objets');
    $tables = lister_tables_objets_sql();
    $trouver_table = charger_fonction('trouver_table', 'base');
    foreach (array_keys($tables) as $t) {
        $desc = $trouver_table($t, $serveur);
        // c'est une table avec des langues
        if ($desc['exist'] and isset($desc['field']['lang']) and isset($desc['field']['langue_choisie'])) {
            $boucle = new Boucle();
            $boucle->show = $desc;
            $boucle->nom = 'calculer_langues_utilisees';
            $boucle->id_boucle = $desc['table_objet'];
            $boucle->id_table = $desc['table_objet'];
            $boucle->sql_serveur = $serveur;
            $boucle->select[] = "DISTINCT lang";
            $boucle->from[$desc['table_objet']] = $t;
            $boucle = pipeline('pre_boucle', $boucle);
            if (isset($desc['statut']) and $desc['statut']) {
                instituer_boucle($boucle, false);
                $res = calculer_select($boucle->select, $boucle->from, $boucle->from_type, $boucle->where, $boucle->join, $boucle->group, $boucle->order, $boucle->limit, $boucle->having, $desc['table_objet'], $desc['table_objet'], $serveur);
            } else {
                $res = sql_select(implode(',', $boucle->select), $boucle->from);
            }
            while ($row = sql_fetch($res)) {
                $langues[$row['lang']] = 1;
            }
        }
    }
    $langues = array_filter(array_keys($langues));
    sort($langues);
    $langues = join(',', $langues);
    spip_log("langues utilisees: {$langues}");
    return $langues;
}
Esempio n. 22
0
/**
 * Renvoyer l'info d'un objet
 * telles que definies dans declarer_tables_objets_sql
 *
 * @param string $objet
 * @param string $info
 * @return string
 */
function objet_info($objet, $info)
{
    $table = table_objet_sql($objet);
    $infos = lister_tables_objets_sql($table);
    return isset($infos[$info]) ? $infos[$info] : '';
}
/**
 * Trouver les documents utilisés dans le texte d'un objet et enregistrer cette liaison comme vue.
 *
 * La liste des champs susceptibles de contenir des documents ou images est indiquée
 * par la globale `medias_liste_champs` (un tableau).
 *
 * Le contenu de ces champs (du moins ceux qui existent pour l'objet demandé) est récupéré et analysé.
 * La présence d'un modèle de document dans ces contenus, tel que imgXX, docXX ou embXX
 * indique que le document est utilisé et doit être lié à l'objet, avec le champ `vu=oui`
 *
 * S'il y avait des anciens liens avec vu=oui qui n'ont plus lieu d'être, ils passent à non.
 *
 * @note
 *     La fonction pourrait avoir bien moins d'arguments : seuls $champs, $id, $type ou $objet, $desc, $serveur
 *     sont nécessaires. On calcule $desc s'il est absent, et il contient toutes les infos…
 *
 * @param array $champs
 *     Couples [champ => valeur] connus de l'objet
 * @param int $id
 *     Identifiant de l'objet
 * @param string $type
 *     Type d'objet éditorial (ex: article)
 * @param string $id_table_objet
 *     Nom de la clé primaire sur la table sql de l'objet
 * @param string $table_objet
 *     Nom de l'objet éditorial (ex: articles)
 * @param string $spip_table_objet
 *     Nom de la table sql de l'objet
 * @param array $desc
 *     Description de l'objet, si déjà calculé
 * @param string $serveur
 *     Serveur sql utilisé.
 * @return void|null
 **/
function inc_marquer_doublons_doc_dist($champs, $id, $type, $id_table_objet, $table_objet, $spip_table_objet, $desc = array(), $serveur = '')
{
    // On conserve uniquement les champs qui modifient le calcul des doublons de documents
    // S'il n'il en a aucun, les doublons ne sont pas impactés, donc rien à faire d'autre..
    if (!($champs = array_intersect_key($champs, array_flip($GLOBALS['medias_liste_champs'])))) {
        return;
    }
    if (!$desc) {
        $trouver_table = charger_fonction('trouver_table', 'base');
        $desc = $trouver_table($table_objet, $serveur);
    }
    // Il faut récupérer toutes les données qui impactent les liens de documents vus
    // afin de savoir lesquels sont présents dans les textes, et pouvoir actualiser avec
    // les liens actuellement enregistrés.
    $absents = array();
    // Récupérer chaque champ impactant qui existe dans la table de l'objet et qui nous manque
    foreach ($GLOBALS['medias_liste_champs'] as $champ) {
        if (isset($desc['field'][$champ]) and !isset($champs[$champ])) {
            $absents[] = $champ;
        }
    }
    // Retrouver les textes des champs manquants
    if ($absents) {
        $row = sql_fetsel($absents, $spip_table_objet, "{$id_table_objet}=" . sql_quote($id));
        if ($row) {
            $champs = array_merge($row, $champs);
        }
    }
    include_spip('inc/texte');
    include_spip('base/abstract_sql');
    include_spip('action/editer_liens');
    include_spip('base/objets');
    // récupérer la liste des modèles qui considèrent un document comme vu s'ils sont utilisés dans un texte
    $modeles = lister_tables_objets_sql('spip_documents');
    $modeles = $modeles['modeles'];
    // liste d'id_documents trouvés dans les textes
    $GLOBALS['doublons_documents_inclus'] = array();
    // detecter les doublons dans ces textes
    traiter_modeles(implode(" ", $champs), array('documents' => $modeles), '', '', null, array('objet' => $type, 'id_objet' => $id, $id_table_objet => $id));
    $texte_documents_vus = $GLOBALS['doublons_documents_inclus'];
    // on ne modifie les liaisons que si c'est nécessaire
    $bdd_documents_vus = array('oui' => array(), 'non' => array());
    $liaisons = objet_trouver_liens(array('document' => '*'), array($type => $id));
    foreach ($liaisons as $l) {
        $bdd_documents_vus[$l['vu']][] = $l['id_document'];
    }
    // il y a des nouveaux documents vus dans le texte
    $nouveaux = array_diff($texte_documents_vus, $bdd_documents_vus['oui']);
    // il y a des anciens documents vus dans la bdd
    $anciens = array_diff($bdd_documents_vus['oui'], $texte_documents_vus);
    if ($nouveaux) {
        // on vérifie que les documents indiqués vus existent réellement tout de même (en cas d'erreur de saisie)
        $ids = sql_allfetsel("id_document", "spip_documents", sql_in('id_document', $nouveaux));
        $ids = array_map('reset', $ids);
        if ($ids) {
            // Creer le lien s'il n'existe pas déjà
            objet_associer(array('document' => $ids), array($type => $id), array('vu' => 'oui'));
            objet_qualifier_liens(array('document' => $ids), array($type => $id), array('vu' => 'oui'));
        }
    }
    if ($anciens) {
        objet_qualifier_liens(array('document' => $anciens), array($type => $id), array('vu' => 'non'));
    }
}
Esempio n. 24
0
/**
 * Retourne la description d'une table SQL
 *
 * Cela sert notamment au moment de la compilation des boucles, critères et balise.
 *
 * Les champs et clés de la tables sont retrouvés prioritairement via le
 * gestionnaire de base de données. Les descriptions sont complétées,
 * pour les tables éditoriales, des informations déclarées ou construites
 * par la déclaration des objets éditoriaux.
 *
 * @example
 *     $trouver_table = charger_fonction('trouver_table', 'base');
 *     $desc = $trouver_table('spip_groupes_mots');
 *
 * Cette fonction intervient à la compilation, mais aussi pour la balise
 * contextuelle EXPOSE ou certains critères.
 *
 * L'ensemble des descriptions de table d'un serveur est stocké dans un
 * fichier cache/sql_desc.txt par soucis de performance. Un appel
 * avec $nom vide est une demande explicite de vidange de ce cache
 *
 * @see lister_tables_objets_sql()
 *
 * @api
 * @param string $nom
 *     Nom de la table
 *     Vide '' demande de vider le cache des discriptions
 * @param string $serveur
 *     Nom du connecteur
 * @param bool $table_spip
 *     Indique s'il faut transformer le préfixe de table
 * @return array|bool
 *     false si table introuvable
 *     tableau de description de la table sinon, en particulier :
 *     - field : tableau des colonnes SQL et leur description (comme dans serial.php ou objets.php)
 *     - key   : tableau des KEY (comme dans serial.php ou objets.php)
 *     - table et table_sql : nom de la table (avec spip_ en préfixe)
 *     - id_table : nom SPIP de la table (type de boucle)
 *                  le compilateur produit  FROM $r['table'] AS $r['id_table']
 *     - Toutes les autres informations des objets éditoriaux si la table est l'un d'eux.
 *
 *
 **/
function base_trouver_table_dist($nom, $serveur = '', $table_spip = true)
{
    static $nom_cache_desc_sql = array();
    if (!spip_connect($serveur) or !preg_match('/^[a-zA-Z0-9._-]*/', $nom)) {
        return null;
    }
    $connexion =& $GLOBALS['connexions'][$serveur ? strtolower($serveur) : 0];
    $objets_sql = lister_tables_objets_sql("::md5");
    // le nom du cache depend du serveur mais aussi du nom de la db et du prefixe
    // ce qui permet une auto invalidation en cas de modif manuelle du fichier
    // de connexion, et tout risque d'ambiguite
    if (!isset($nom_cache_desc_sql[$serveur][$objets_sql])) {
        $nom_cache_desc_sql[$serveur][$objets_sql] = _DIR_CACHE . 'sql_desc_' . ($serveur ? "{$serveur}_" : "") . substr(md5($connexion['db'] . ":" . $connexion['prefixe'] . ":{$objets_sql}"), 0, 8) . '.txt';
        // nouveau nom de cache = nouvelle version en memoire
        unset($connexion['tables']);
    }
    // un appel avec $nom vide est une demande explicite de vidange du cache des descriptions
    if (!$nom) {
        spip_unlink($nom_cache_desc_sql[$serveur][$objets_sql]);
        $connexion['tables'] = array();
        return null;
    }
    $nom_sql = $nom;
    if (preg_match('/\\.(.*)$/', $nom, $s)) {
        $nom_sql = $s[1];
    } else {
        $nom_sql = $nom;
    }
    $fdesc = $desc = '';
    $connexion =& $GLOBALS['connexions'][$serveur ? $serveur : 0];
    // base sous SPIP: gerer les abreviations explicites des noms de table
    if ($connexion['spip_connect_version']) {
        if ($table_spip and isset($GLOBALS['table_des_tables'][$nom])) {
            $nom = $GLOBALS['table_des_tables'][$nom];
            $nom_sql = 'spip_' . $nom;
        }
    }
    // si c'est la premiere table qu'on cherche
    // et si on est pas explicitement en recalcul
    // on essaye de recharger le cache des decriptions de ce serveur
    // dans le fichier cache
    if (!isset($connexion['tables'][$nom_sql]) and defined('_VAR_MODE') and _VAR_MODE !== 'recalcul' and (!isset($connexion['tables']) or !$connexion['tables'])) {
        if (lire_fichier($nom_cache_desc_sql[$serveur][$objets_sql], $desc_cache) and $desc_cache = unserialize($desc_cache)) {
            $connexion['tables'] = $desc_cache;
        }
    }
    if ($table_spip and !isset($connexion['tables'][$nom_sql])) {
        if (isset($GLOBALS['tables_principales'][$nom_sql])) {
            $fdesc = $GLOBALS['tables_principales'][$nom_sql];
        } elseif ($nom_sql == $nom and isset($GLOBALS['tables_principales']['spip_' . $nom])) {
            $nom_sql = 'spip_' . $nom;
            $fdesc =& $GLOBALS['tables_principales'][$nom_sql];
        } elseif (isset($GLOBALS['tables_auxiliaires'][$n = $nom]) or isset($GLOBALS['tables_auxiliaires'][$n = 'spip_' . $nom])) {
            $nom_sql = $n;
            $fdesc =& $GLOBALS['tables_auxiliaires'][$n];
        }
        # table locale a cote de SPIP, comme non SPIP:
    }
    if (!isset($connexion['tables'][$nom_sql])) {
        // La *vraie* base a la priorite
        $desc = sql_showtable($nom_sql, $table_spip, $serveur);
        if (!$desc or !$desc['field']) {
            if (!$fdesc) {
                spip_log("trouver_table: table inconnue '{$serveur}' '{$nom}'", _LOG_INFO_IMPORTANTE);
                return null;
            }
            // on ne sait pas lire la structure de la table :
            // on retombe sur la description donnee dans les fichiers spip
            $desc = $fdesc;
            $desc['exist'] = false;
        } else {
            $desc['exist'] = true;
        }
        $desc['table'] = $desc['table_sql'] = $nom_sql;
        $desc['connexion'] = $serveur;
        // charger les infos declarees pour cette table
        // en lui passant les infos connues
        // $desc est prioritaire pour la description de la table
        $desc = array_merge(lister_tables_objets_sql($nom_sql, $desc), $desc);
        // si tables_objets_sql est bien fini d'init, on peut cacher
        $connexion['tables'][$nom_sql] = $desc;
        $res =& $connexion['tables'][$nom_sql];
        // une nouvelle table a ete decrite
        // mettons donc a jour le cache des descriptions de ce serveur
        if (is_writeable(_DIR_CACHE)) {
            ecrire_fichier($nom_cache_desc_sql[$serveur][$objets_sql], serialize($connexion['tables']), true);
        }
    } else {
        $res =& $connexion['tables'][$nom_sql];
    }
    // toujours retourner $nom dans id_table
    $res['id_table'] = $nom;
    return $res;
}
Esempio n. 25
0
/**
 * Retrouve la table sql à partir de l'objet ou du type
 *
 * - articles    -> spip_articles
 * - article     -> spip_articles
 * - id_article  -> spip_articles
 *
 * @api
 * @param string $type
 *     Nom ou type de l'objet
 *     Tolère un nom de clé primaire.
 * @param string $serveur
 *     Nom du connecteur
 * @return string
 *     Nom de la table SQL
**/
function table_objet_sql($type, $serveur = '')
{
    global $table_des_tables;
    $nom = table_objet($type, $serveur);
    if (!isset($table_des_tables['articles'])) {
        // eviter de multiples inclusions
        include_spip('public/interfaces');
    }
    if (isset($table_des_tables[$nom])) {
        $nom = $table_des_tables[$nom];
        $nom = "spip_{$nom}";
    } else {
        $infos_tables = lister_tables_objets_sql();
        if (isset($infos_tables["spip_{$nom}"])) {
            $nom = "spip_{$nom}";
        } elseif ($serveur !== false) {
            $trouver_table = charger_fonction('trouver_table', 'base');
            if ($desc = $trouver_table($nom, $serveur)) {
                return $desc['table_sql'];
            }
        }
    }
    return $nom;
}
Esempio n. 26
0
/**
 * Autorisation de prévisualiser un contenu
 *
 * @param  string $faire Action demandée
 * @param  string $type  Type d'objet sur lequel appliquer l'action
 * @param  int    $id    Identifiant de l'objet
 * @param  array  $qui   Description de l'auteur demandant l'autorisation
 * @param  array  $opt   Options de cette autorisation
 * @return bool          true s'il a le droit, false sinon
**/
function autoriser_previsualiser_dist($faire, $type, $id, $qui, $opt)
{
    // si auteur pas autorise, NIET
    if (strpos($GLOBALS['meta']['preview'], "," . $qui['statut'] . ",") === false) {
        return false;
    }
    // si pas de type et statut fourni, c'est une autorisation generale => OK
    if (!$type) {
        return true;
    }
    include_spip('base/objets');
    $infos = lister_tables_objets_sql(table_objet_sql($type));
    if (isset($infos['statut'])) {
        foreach ($infos['statut'] as $c) {
            if (isset($c['publie'])) {
                if (!isset($c['previsu'])) {
                    return false;
                }
                // pas de previsu definie => NIET
                $champ = $c['champ'];
                if (!isset($opt[$champ])) {
                    return false;
                }
                // pas de champ passe a la demande => NIET
                $previsu = explode(',', $c['previsu']);
                if (!in_array($opt[$champ], $previsu)) {
                    // le statut n'est pas dans ceux definis par la previsu => NIET
                    return false;
                }
            }
        }
    }
    return true;
}
Esempio n. 27
0
/**
 * Options de la fonction autoriser_previsualiser_dist
 *
 * commande l'affichage dans l'espace prive du bouton "previsualiser"
 * voir prive/objets/infos/article.html etc.
 * 
 * @uses lister_tables_objets_sql()
 * @uses table_objet_sql()
 * 
 * @param array $qui 
 * @param string|null $type
 * @param string|null $id
 * @param array $opt
 * @return boolean
 */
function test_previsualiser_objet_champ($type = null, $id = 0, $qui = array(), $opt = array())
{
    // si pas de type et statut fourni, c'est une autorisation generale => OK
    if (!$type) {
        return true;
    }
    include_spip('base/objets');
    $infos = lister_tables_objets_sql(table_objet_sql($type));
    if (isset($infos['statut'])) {
        foreach ($infos['statut'] as $c) {
            if (isset($c['publie'])) {
                if (!isset($c['previsu'])) {
                    return false;
                }
                // pas de previsu definie => NIET
                $champ = $c['champ'];
                if (!isset($opt[$champ])) {
                    return false;
                }
                // pas de champ passe a la demande => NIET
                $previsu = explode(',', $c['previsu']);
                // regarder si ce statut est autorise pour l'auteur
                if (in_array($opt[$champ] . "/auteur", $previsu)) {
                    if (!sql_countsel("spip_auteurs_liens", "id_auteur=" . intval($qui['id_auteur']) . " AND objet=" . sql_quote($type) . " AND id_objet=" . intval($id))) {
                        return false;
                    }
                    // pas auteur de cet objet => NIET
                } elseif (!in_array($opt[$champ], $previsu)) {
                    // le statut n'est pas dans ceux definis par la previsu => NIET
                    return false;
                }
            }
        }
    }
    return true;
}
Esempio n. 28
0
function crayons_store_set_modifs($modifs, $return)
{
    // sinon on bosse : toutes les modifs ont ete acceptees
    // verifier qu'on a tout ce qu'il faut pour mettre a jour la base
    // et regrouper les mises a jour par type/id
    foreach ($modifs as $modif) {
        list($type, $modele, $id, $content, $wid) = $modif;
        $fun = '';
        // si le crayon est un MODELE avec une fonction xxx_revision associee
        // cas ou une fonction xxx_revision existe
        if (function_exists($f = $type . '_' . $modele . "_revision") or function_exists($f = $modele . "_revision") or function_exists($f = $type . "_revision")) {
            $fun = $f;
        } elseif (function_exists('lister_tables_objets_sql') and $tables_objet = lister_tables_objets_sql() and isset($tables_objet[table_objet_sql($type)])) {
            $fun = 'crayons_objet_modifier';
        } else {
            switch ($type) {
                case 'article':
                    $fun = 'crayons_update_article';
                    break;
                case 'breve':
                    include_spip('action/editer_breve');
                    $fun = 'revisions_breves';
                    break;
                case 'forum':
                    include_spip('inc/forum');
                    $fun = 'enregistre_et_modifie_forum';
                    break;
                case 'rubrique':
                    include_spip('action/editer_rubrique');
                    $fun = 'revisions_rubriques';
                    break;
                case 'syndic':
                case 'site':
                    include_spip('action/editer_site');
                    $fun = 'revisions_sites';
                    break;
                case 'document':
                    include_spip('plugins/installer');
                    include_spip('inc/plugin');
                    if (spip_version_compare($GLOBALS['spip_version_branche'], '3.0.0alpha', '>=')) {
                        include_spip('action/editer_document');
                        $fun = 'document_modifier';
                    } else {
                        include_spip('inc/modifier');
                        $fun = 'revision_document';
                    }
                    break;
                    // cas geres de la maniere la plus standard
                // cas geres de la maniere la plus standard
                case 'auteur':
                case 'mot':
                case 'signature':
                case 'petition':
                default:
                    include_spip('inc/modifier');
                    $fun = 'revision_' . $type;
                    break;
            }
        }
        // si on a pas reussi on passe par crayons_update() qui fera un update sql brutal
        if (!$fun or !function_exists($fun)) {
            $fun = 'crayons_update';
            // $return['$erreur'] = "$type: " . _U('crayons:non_implemente');
            // break;
        }
        if (!isset($updates[$type][$fun])) {
            $updates[$type][$fun] = array();
        }
        if (!isset($updates[$type][$fun][$id])) {
            $updates[$type][$fun][$id] = array('wdg' => array(), 'chval' => array());
        }
        // pour reaffecter le retour d'erreur sql au cas ou
        $updates[$type][$fun][$id]['wdg'][] = $wid;
        foreach ($content as $champtable => $val) {
            $updates[$type][$fun][$id]['chval'][$champtable] = $val;
        }
    }
    // il manque une fonction de mise a jour ==> on ne fait rien !
    if ($return['$erreur']) {
        return $return;
    }
    // hop ! mises a jour table par table et id par id
    foreach ($updates as $type => $idschamps) {
        foreach ($idschamps as $fun => $ids) {
            foreach ($ids as $id => $champsvaleurs) {
                /* cas particulier du logo dans un crayon complexe :
                   ce n'est pas un champ de la table */
                if (isset($champsvaleurs['chval']['logo'])) {
                    spip_log('revision logo', 'crayons');
                    logo_revision($id, $champsvaleurs['chval'], $type, $champsvaleurs['wdg']);
                    unset($champsvaleurs['chval']['logo']);
                }
                if (count($champsvaleurs['chval'])) {
                    // -- revisions_articles($id_article, $c) --
                    spip_log("{$fun}({$id} ...)", 'crayons');
                    $updok = $fun($id, $champsvaleurs['chval'], $type, $champsvaleurs['wdg']);
                    // Renvoyer erreur si update base distante echoue, on ne regarde pas les updates base local car ils ne renvoient rien
                    list($distant, $table) = distant_table($type);
                    if ($distant and !$updok) {
                        $return['$erreur'] = "{$type}: " . _U('crayons:update_impossible');
                    }
                }
            }
        }
    }
    return $return;
}
Esempio n. 29
0
/**
 * Afficher la mention des autres auteurs ayant modifié un objet
 *
 * @param int $id_objet
 * @param string $objet
 * @return string
 */
function afficher_qui_edite($id_objet, $objet)
{
    static $qui = array();
    if (isset($qui[$objet][$id_objet])) {
        return $qui[$objet][$id_objet];
    }
    if ($GLOBALS['meta']['articles_modif'] == 'non') {
        return $qui[$objet][$id_objet] = '';
    }
    include_spip('inc/drapeau_edition');
    $modif = mention_qui_edite($id_objet, $objet);
    if (!$modif) {
        return $qui[$objet][$id_objet] = '';
    }
    include_spip('base/objets');
    $infos = lister_tables_objets_sql(table_objet_sql($objet));
    if (isset($infos['texte_signale_edition'])) {
        return $qui[$objet][$id_objet] = _T($infos['texte_signale_edition'], $modif);
    }
    return $qui[$objet][$id_objet] = _T('info_qui_edite', $modif);
}
Esempio n. 30
0
<?php

/***************************************************************************\
 *  SPIP, Systeme de publication pour l'internet                           *
 *                                                                         *
 *  Copyright (c) 2001-2015                                                *
 *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
 *                                                                         *
 *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
 *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
\***************************************************************************/
/**
 * Déclare la liste des tables auxiliaires
 *
 * @todo
 *     Nettoyages à faire dans le core : on ne devrait plus appeler
 *     Ce fichier mais directement base/objets si nécessaire
 *
 * @package SPIP\Core\SQL\Tables
**/
if (!defined('_ECRIRE_INC_VERSION')) {
    return;
}
include_spip('base/objets');
lister_tables_objets_sql();