Changeset 65485 in spip-zone


Ignore:
Timestamp:
Sep 3, 2012, 8:10:07 PM (7 years ago)
Author:
marcimat@…
Message:

Poursuite du passage à SPIP 3 du plugin dictionnaire. On utilise l'api d'objets éditoriaux et on ne met que les squelettes nécessaires dans le plugin. Au passage on PHPDoc toutes les fonctions.

Location:
_plugins_/dictionnaires/trunk
Files:
10 added
6 deleted
20 edited

Legend:

Unmodified
Added
Removed
  • _plugins_/dictionnaires/trunk/action/editer_definition.php

    r58145 r65485  
    11<?php
    22
     3
     4/**
     5 * Gestion de l'action editer_definition
     6 *
     7 * @package SPIP\Dictionnaires\Actions
     8 */
     9 
    310// Sécurité
    411if (!defined('_ECRIRE_INC_VERSION')) return;
    512
    613/**
    7  * Action de création / Modification d'un definition
    8  * @param unknown_type $arg
    9  * @return unknown_type
    10  */
     14 * Action d'édition d'une définition de dictionnaire dans la base de données dont
     15 * l'identifiant est donné en paramètre de cette fonction ou
     16 * en argument de l'action sécurisée
     17 *
     18 * Si aucun identifiant n'est donné, on crée alors une nouvelle définition.
     19 *
     20 * @param null|int $arg
     21 *     Identifiant de la définition. En absence utilise l'argument
     22 *     de l'action sécurisée.
     23 * @return array
     24 *     Liste (identifiant de la définition, Texte d'erreur éventuel)
     25**/
    1126function action_editer_definition_dist($arg=null) {
    1227        if (is_null($arg)){
     
    2338        if ($id_definition > 0) $err = definition_set($id_definition);
    2439
    25         if (_request('redirect')) {
    26                 $redirect = parametre_url(urldecode(_request('redirect')),
    27                         'id_definition', $id_definition, '&') . $err;
    28 
    29                 include_spip('inc/headers');
    30                 redirige_par_entete($redirect);
    31         }
    32         else
    33                 return array($id_definition,$err);
    34 }
    35 
    36 /**
    37  * Crée un nouveau definition et retourne son ID
    38  *
    39  * @param array $champs Un tableau avec les champs par défaut lors de l'insertion
    40  * @return int id_definition
     40        return array($id_definition, $err);
     41}
     42
     43
     44/**
     45 * Crée une nouvelle définition de dictionnaire
     46 *
     47 * @param array $champs
     48 *     Un tableau avec les champs par défaut lors de l'insertion
     49 * @return int
     50 *     Identifiant de la nouvelle définition
    4151 */
    4252function insert_definition($champs=array()) {
     
    6676}
    6777
    68 /**
    69  * Appelle la fonction de modification d'un definition
    70  *
     78
     79/**
     80 * Modifier une définition
     81 *
    7182 * @param int $id_definition
    72  * @param unknown_type $set
    73  * @return $err
     83 *     Identifiant de la définition à modifier
     84 * @param array|null $set
     85 *     Couples (colonne => valeur) de données à modifier.
     86 *     En leur absence, on cherche les données dans les champs éditables
     87 *     qui ont été postés (via _request())
     88 * @param bool $purger_cache
     89 *     true pour purcher le cache des définitions au passage lors de l'institution
     90 * @return string|null
     91 *     Chaîne vide si aucune erreur,
     92 *     Null si aucun champ à modifier,
     93 *     Chaîne contenant un texte d'erreur sinon.
    7494 */
    7595function definition_set($id_definition, $set=null, $purger_cache=true) {
    7696        $err = '';
    7797
    78         include_spip('inc/saisies');
    79         $saisies = saisies_chercher_formulaire('editer_definition', array($id_definition));
    80         $champs = saisies_lister_champs($saisies, false);
    81        
    82         $c = array();
    83         foreach ($champs as $champ)
    84                 $c[$champ] = _request($champ,$set);
    85        
     98        include_spip('base/objets');
     99        $desc = lister_tables_objets_sql('spip_definitions');
     100
     101        include_spip('inc/modifier');
     102        $c = collecter_requests(
     103                // white list
     104                $desc['champs_editables'],
     105                // black list
     106                array(),
     107                // donnees eventuellement fournies
     108                $set
     109        );
     110
    86111        // Pour le parent on fera plus tard
    87         if (isset($c['id_dictionnaire'])){
    88                 unset($c['id_dictionnaire']);
    89         }
    90        
    91         include_spip('inc/modifier');
    92         revision_definition($id_definition, $c);
    93        
    94         // Modification de statut, changement de rubrique ?
    95         $c = array();
    96         foreach (array(
    97                 'date', 'statut', 'id_dictionnaire'
    98         ) as $champ)
    99                 $c[$champ] = _request($champ, $set);
    100         $err .= instituer_definition($id_definition, $c, $purger_cache);
    101 
     112        unset($c['id_dictionnaire']);
     113
     114        if ($err = objet_modifier_champs('definition', $id_definition,
     115                array(
     116                        'nonvide' => array('titre' => _T('info_sans_titre'))
     117                ),
     118                $c)) {
     119                return $err;
     120        }
     121
     122        $c = collecter_requests(array('date', 'statut', 'id_dictionnaire'),array(),$set);
     123        $err = instituer_definition($id_definition, $c, $purger_cache);
    102124        return $err;
    103125}
    104126
    105 /**
    106  * Enregistre une révision de definition
    107  *
     127
     128/**
     129 * Instituer une définition : modifier son statut, date, parent
     130 *
     131 * @pipeline_appel pre_insertion
     132 * @pipeline_appel post_insertion
     133 *
    108134 * @param int $id_definition
     135 *     Identifiant de la définition
    109136 * @param array $c
    110  * @return
    111  */
    112 function revision_definition($id_definition, $c=false) {
    113         $invalideur = "id='id_definition/$id_definition'";
    114 
    115         modifier_contenu('definition', $id_definition,
    116                 array(
    117                         'nonvide' => array('titre' => _T('info_sans_titre')),
    118                         'invalideur' => $invalideur
    119                 ),
    120                 $c);
    121 
    122         return ''; // pas d'erreur
    123 }
    124 
    125 /**
    126  * Modifie des éléments à part
    127  *
    128  * @param int $id_definition
    129  * @param array $c
    130  * @return
     137 *     Couples (colonne => valeur) des données à instituer
     138 * @param bool $purger_cache
     139 *     true pour purcher le cache des définitions au passage
     140 * @return null|string
     141 *     Null si aucun champ à modifier, chaîne vide sinon.
    131142 */
    132143function instituer_definition($id_definition, $c, $purger_cache=true){
     
    237248                )
    238249        );
    239        
     250
    240251        // On refait le cache des définitions si le nouveau ou l'ancien statut était publié
    241         if ($purger_cache and ($champs['statut'] == 'publie' or $statut_ancien == 'publie')){
    242                 include_spip('inc/dictionnaires');
    243                 dictionnaires_lister_definitions(true);
    244         }
    245        
     252        if ($purger_cache and ((isset($champs['statut']) AND $champs['statut'] == 'publie')
     253                 OR $statut_ancien == 'publie'))
     254                {
     255                        include_spip('inc/dictionnaires');
     256                        dictionnaires_lister_definitions(true);
     257        }
     258
    246259        // Notifications
    247260        if ($notifications = charger_fonction('notifications', 'inc', true)) {
  • _plugins_/dictionnaires/trunk/action/editer_dictionnaire.php

    r57283 r65485  
    11<?php
     2
     3/**
     4 * Gestion de l'action editer_dictionnaire
     5 *
     6 * @package SPIP\Dictionnaires\Actions
     7 */
    28
    39// Sécurité
    410if (!defined('_ECRIRE_INC_VERSION')) return;
    511
    6 /**
    7  * Action de création / Modification d'un dictionnaire
    8  * @param unknown_type $arg
    9  * @return unknown_type
    10  */
     12
     13/**
     14 * Action d'édition d'un dictionnaire dans la base de données dont
     15 * l'identifiant est donné en paramètre de cette fonction ou
     16 * en argument de l'action sécurisée
     17 *
     18 * Si aucun identifiant n'est donné, on crée alors un nouveau dictionnaire.
     19 *
     20 * @param null|int $arg
     21 *     Identifiant du dictionnaire. En absence utilise l'argument
     22 *     de l'action sécurisée.
     23 * @return array
     24 *     Liste (identifiant du dictionnaire, Texte d'erreur éventuel)
     25**/
    1126function action_editer_dictionnaire_dist($arg=null) {
    1227        if (is_null($arg)){
     
    2338        if ($id_dictionnaire > 0) $err = dictionnaire_set($id_dictionnaire);
    2439
    25         if (_request('redirect')) {
    26                 $redirect = parametre_url(urldecode(_request('redirect')),
    27                         'id_dictionnaire', $id_dictionnaire, '&') . $err;
    28 
    29                 include_spip('inc/headers');
    30                 redirige_par_entete($redirect);
    31         }
    32         else
    33                 return array($id_dictionnaire,$err);
     40        return array($id_dictionnaire,$err);
    3441}
    3542
     
    3744 * Crée un nouveau dictionnaire et retourne son ID
    3845 *
    39  * @param array $champs Un tableau avec les champs par défaut lors de l'insertion
    40  * @return int id_dictionnaire
     46 * @param array $champs
     47 *     Un tableau avec les champs par défaut lors de l'insertion
     48 * @return int
     49 *     Identifiant du nouveau dictionnaire
    4150 */
    4251function insert_dictionnaire($champs=array()) {
     
    6776
    6877/**
    69  * Appelle la fonction de modification d'un dictionnaire
    70  *
     78 * Modifier un dictionnaire
     79 * 
    7180 * @param int $id_dictionnaire
    72  * @param unknown_type $set
    73  * @return $err
     81 *     Identifiant du dictionnaire à modifier
     82 * @param array|null $set
     83 *     Couples (colonne => valeur) de données à modifier.
     84 *     En leur absence, on cherche les données dans les champs éditables
     85 *     qui ont été postés (via _request())
     86 * @return string|null
     87 *     Chaîne vide si aucune erreur,
     88 *     Null si aucun champ à modifier,
     89 *     Chaîne contenant un texte d'erreur sinon.
    7490 */
    7591function dictionnaire_set($id_dictionnaire, $set=null) {
    7692        $err = '';
    7793
    78         include_spip('inc/saisies');
    79         $saisies = saisies_chercher_formulaire('editer_dictionnaire', array($id_dictionnaire));
    80         $champs = saisies_lister_champs($saisies, false);
    81        
    82         $c = array();
    83         foreach ($champs as $champ)
    84                 $c[$champ] = _request($champ,$set);
    85        
    86         // Pour le statut on fera le travail autre part
    87         $instituer = false;
    88         if (isset($c['actif'])){
    89                 $instituer = array('actif' => $c['actif']);
    90                 unset($c['actif']);
    91         }
     94        include_spip('base/objets');
     95        $desc = lister_tables_objets_sql('spip_dictionnaires');
    9296
    9397        include_spip('inc/modifier');
    94         revision_dictionnaire($id_dictionnaire, $c);
    95        
    96         if ($instituer){
    97                 instituer_dictionnaire($id_dictionnaire, $instituer);
    98         }
    99 
     98        $c = collecter_requests(
     99                // white list
     100                $desc['champs_editables'],
     101                // black list
     102                array(),
     103                // donnees eventuellement fournies
     104                $set
     105        );
     106
     107
     108        if ($err = objet_modifier_champs('dictionnaire', $id_dictionnaire,
     109                array(
     110                        'nonvide' => array('titre' => _T('info_sans_titre'))
     111                ),
     112                $c)) {
     113                return $err;
     114        }
     115
     116        $c = collecter_requests(array('statut'),array(),$set);
     117        $err = instituer_dictionnaire($id_dictionnaire, $c);
    100118        return $err;
    101119}
    102120
    103 /**
    104  * Enregistre une révision de dictionnaire
    105  *
     121
     122/**
     123 * Instituer un dictionnaire : modifier son statut
     124 *
     125 * @pipeline_appel pre_insertion
     126 * @pipeline_appel post_insertion
     127 *
    106128 * @param int $id_dictionnaire
     129 *     Identifiant du dictionnaire
    107130 * @param array $c
    108  * @return
    109  */
    110 function revision_dictionnaire($id_dictionnaire, $c=false) {
    111         $invalideur = "id='id_dictionnaire/$id_dictionnaire'";
    112 
    113         modifier_contenu('dictionnaire', $id_dictionnaire,
    114                 array(
    115                         'nonvide' => array('titre' => _T('info_sans_titre')),
    116                         'invalideur' => $invalideur
    117                 ),
    118                 $c);
    119 
    120         return ''; // pas d'erreur
    121 }
    122 
    123 /**
    124  * Modifie des éléments à part
    125  *
    126  * @param int $id_dictionnaire
    127  * @param array $c
    128  * @return
     131 *     Couples (colonne => valeur) des données à instituer
     132 * @return null|string
     133 *     Null si aucun champ à modifier, chaîne vide sinon.
    129134 */
    130135function instituer_dictionnaire($id_dictionnaire, $c){
    131136        include_spip('inc/autoriser');
    132        
    133         if (isset($c['actif']) and in_array(($actif = $c['actif']), array(0,1))){
    134                 $ancien = sql_getfetsel('actif', 'spip_dictionnaires', 'id_dictionnaire = '.$id_dictionnaire);
     137        include_spip('base/objets');
     138        $desc = lister_tables_objets_sql('spip_dictionnaires');
     139
     140        if (isset($c['statut']) and in_array(($statut = $c['statut']), array_keys($desc['statut_textes_instituer']))){
     141                $ancien = sql_getfetsel('statut', 'spip_dictionnaires', 'id_dictionnaire = '.$id_dictionnaire);
    135142                $champs = array();
    136                
     143
    137144                // Seulement si on change le statut et qu'on a le droit
    138                 if ($actif != $ancien and autoriser('modifier', 'dictionnaire', $id_dictionnaire)){
    139                         $champs['actif'] = $actif;
     145                if ($statut != $ancien and autoriser('modifier', 'dictionnaire', $id_dictionnaire)){
     146                        $champs['statut'] = $statut;
    140147                }
    141148               
     
    179186                        )
    180187                );
    181                
     188
     189                // Notifications
     190                if ($notifications = charger_fonction('notifications', 'inc')) {
     191                        $notifications('instituerdictionnaire', $id_dictionnaire, $champs);
     192                }
     193
    182194                // On refait le cache des définitions
    183195                include_spip('inc/dictionnaires');
    184196                dictionnaires_lister_definitions(true);
    185197        }
     198
     199        return '';
    186200}
    187201
  • _plugins_/dictionnaires/trunk/action/supprimer_dictionnaire.php

    r58087 r65485  
    11<?php
    22
     3/**
     4 * Gestion de l'action supprimer_dictionnaire
     5 *
     6 * @package SPIP\Dictionnaires\Actions
     7 */
     8 
    39// Sécurité
    410if (!defined('_ECRIRE_INC_VERSION')) return;
    511
     12/**
     13 * Action supprimant un dictionnaire dans la base de données
     14 * dont l'identifiant du dictionnaire est donné en paramètre de cette fonction
     15 * ou en argument de l'action sécurisée
     16 *
     17 * Supprime le dictionnaire uniquement si on en a l'autorisation.
     18 * Cela supprime toutes les définitions attachées à ce dictionnaire.
     19 *
     20 * @param null|int $arg
     21 *     Identifiant du dictionnaire à supprimer. En absence utilise l'argument
     22 *     de l'action sécurisée.
     23 */
    624function action_supprimer_dictionnaire_dist($arg=null){
    725        if (is_null($arg)){
     
    927                $arg = $securiser_action();
    1028        }
    11        
     29
    1230        if ($id_dictionnaire = intval($arg)){
    13                 // On supprime réellement toutes les définitions contenues
    14                 sql_delete('spip_definitions', 'id_dictionnaire = '.$id_dictionnaire);
    15                 // On supprime le dictionnaire
    16                 sql_delete('spip_dictionnaires', 'id_dictionnaire = '.$id_dictionnaire);
     31                if (autoriser('supprimer', 'dictionnaire', $id_dictionnaire)) {
     32                        // On supprime réellement toutes les définitions contenues
     33                        sql_delete('spip_definitions', 'id_dictionnaire = '.$id_dictionnaire);
     34                        // On supprime le dictionnaire
     35                        sql_delete('spip_dictionnaires', 'id_dictionnaire = '.$id_dictionnaire);
     36                        // On supprime les liens disparus
     37                        include_spip('action/editer_liens');
     38                        objet_optimiser_liens(array('definition'=>'*'),'*');
     39                }
    1740        }
    1841}
  • _plugins_/dictionnaires/trunk/base/dictionnaires_tables.php

    r58145 r65485  
    11<?php
     2
     3/**
     4 * Déclarations relatives à la base de données
     5 *
     6 * @package SPIP\Dictionnaires\Pipelines
     7**/
    28
    39// Sécurité
    410if (!defined('_ECRIRE_INC_VERSION')) return;
    511
    6 function dictionnaires_declarer_tables_interfaces($interface){
     12/**
     13 * Déclarer les interfaces des tables dictionnaires et definitions pour le compilateur
     14 *
     15 * @pipeline declarer_tables_interfaces
     16 * @param array $interfaces
     17 *     Déclarations d'interface pour le compilateur
     18 * @return array
     19 *     Déclarations d'interface pour le compilateur
     20 */
     21function dictionnaires_declarer_tables_interfaces($interfaces){
    722        // 'spip_' dans l'index de $tables_principales
    8         $interface['table_des_tables']['dictionnaires'] = 'dictionnaires';
    9         $interface['table_des_tables']['definitions'] = 'definitions';
    10        
    11         $interface['table_date']['definitions'] = 'date';
    12        
    13         $interface['table_titre']['dictionnaires'] = 'titre, "" as lang';
    14         $interface['table_titre']['definitions'] = 'titre, lang';
    15        
    16         // Traitement automatique des champs des dictionnaires
    17         $interface['table_des_traitements']['TITRE'][]= _TRAITEMENT_TYPO;
    18         $interface['table_des_traitements']['DESCRIPTION'][]= _TRAITEMENT_RACCOURCIS;
    19        
    20         return $interface;
     23        $interfaces['table_des_tables']['dictionnaires'] = 'dictionnaires';
     24        $interfaces['table_des_tables']['definitions']   = 'definitions';
     25        return $interfaces;
    2126}
    2227
    23 function dictionnaires_declarer_tables_principales($tables_principales){
    24         //-- Table dictionnaires -----------------------------------------------------------
    25         $dictionnaires = array(
    26                 'id_dictionnaire' => 'bigint(21) not null',
    27                 'titre' => 'text not null default ""',
    28                 'descriptif' => 'text not null default ""',
    29                 'type_defaut' => 'varchar(255) not null default ""',
    30                 'actif' => 'tinyint(1) not null default 0',
    31                 'maj' => 'timestamp',
    32         );
    33        
    34         $dictionnaires_cles = array(
    35                 'PRIMARY KEY' => 'id_dictionnaire'
    36         );
    37        
    38         $tables_principales['spip_dictionnaires'] = array(
    39                 'field' => &$dictionnaires,
    40                 'key' => &$dictionnaires_cles,
    41                 'join'=> array(
    42                         'id_dictionnaire' => 'id_dictionnaire'
    43                 )
    44         );
    45        
    46         //-- Table definitions -----------------------------------------------------------
    47         $definitions = array(
    48                 'id_definition' => 'bigint(21) not null',
    49                 'id_dictionnaire' => 'bigint(21) not null',
    50                 'titre' => 'text not null default ""',
    51                 'texte' => 'text not null default ""',
    52                 'termes' => 'text not null default ""',
    53                 'type' => 'varchar(255) not null default ""',
    54                 'casse' => 'tinyint(1) not null default 0',
    55                 'statut' => 'varchar(255) not null default "prop"',
    56                 'lang' => 'varchar(10) not null default ""',
    57                 'date' => 'datetime default "0000-00-00 00:00:00" not null',
    58                 'maj' => 'timestamp',
    59         );
    60        
    61         $definitions_cles = array(
    62                 'PRIMARY KEY' => 'id_definition',
    63                 'KEY id_dictionnaire' => 'id_dictionnaire'
    64         );
    65        
    66         $tables_principales['spip_definitions'] = array(
    67                 'field' => &$definitions,
    68                 'key' => &$definitions_cles,
    69                 'join'=> array(
    70                         'id_definition' => 'id_definition'
    71                 )
     28
     29/**
     30 * Déclarer les objets éditoriaux des dictionnaires et définitions
     31 *
     32 * @pipeline declarer_tables_objets_sql
     33 * @param array $tables
     34 *     Description des tables
     35 * @return array
     36 *     Description complétée des tables
     37 */
     38function dictionnaires_declarer_tables_objets_sql($tables) {
     39
     40        //-- Table dictionnaires
     41        $tables['spip_dictionnaires'] = array(
     42                'type' => 'dictionnaire',
     43
     44                'titre' => "titre, '' AS lang",
     45                'date' => '',
     46                'principale' => 'oui',
     47
     48                'field' => array(
     49                        'id_dictionnaire' => 'bigint(21) not null',
     50                        'titre' => 'text not null default ""',
     51                        'descriptif' => 'text not null default ""',
     52                        'type_defaut' => 'varchar(255) not null default ""',
     53                        'statut' => "varchar(10) DEFAULT 'inactif' NOT NULL",
     54                        'maj' => 'timestamp',
     55                ),
     56                'key' => array(
     57                        "PRIMARY KEY"   => "id_dictionnaire",
     58                ),
     59                'join' => array(
     60                        "id_dictionnaire" => "id_dictionnaire"
     61                ),
     62                'champs_editables' => array(
     63                        'titre', 'descriptif',
     64                        'type_defaut','statut'
     65                ),
     66
     67                'statut' => array(
     68                        array(
     69                                'champ'=>'statut',
     70                                'publie'=>'actif',
     71                                'previsu'=>'actif,inactif',
     72                                'exception'=> array('statut', 'tout')
     73                        )
     74                ),
     75                'texte_changer_statut' => 'dictionnaire:changer_statut',
     76                'statut_titres' => array(
     77                        'actif'   => 'dictionnaire:champ_actif_oui',
     78                        'inactif' => 'dictionnaire:champ_actif_non',
     79                ),
     80                'statut_textes_instituer' => array(
     81                        'actif'   => 'dictionnaire:champ_actif_oui',
     82                        'inactif' => 'dictionnaire:champ_actif_non',
     83                ),
     84                'statut_images' => array(
     85                        'actif'   => 'puce-publier-8.png',
     86                        'inactif' => 'puce-proposer-8.png',
     87                ),
    7288        );
    7389
    74         return $tables_principales;
     90
     91        //-- Table definitions
     92        $tables['spip_definitions'] = array(
     93                'type' => 'definition',
     94
     95                'titre' => "titre, lang",
     96                'date' => 'date',
     97                'principale' => 'oui',
     98
     99                'field' => array(
     100                        'id_definition' => 'bigint(21) not null',
     101                        'id_dictionnaire' => 'bigint(21) not null default 0',
     102                        'titre' => 'text not null default ""',
     103                        'texte' => 'text not null default ""',
     104                        'termes' => 'text not null default ""',
     105                        'type' => 'varchar(255) not null default ""',
     106                        'casse' => 'tinyint(1) not null default 0',
     107                        'statut' => 'varchar(255) not null default "prop"',
     108                        'lang' => 'varchar(10) not null default ""',
     109                        'date' => 'datetime default "0000-00-00 00:00:00" not null',
     110                        'maj' => 'timestamp',
     111                ),
     112                'key' => array(
     113                        "PRIMARY KEY"         => "id_definition",
     114                        "KEY id_dictionnaire" => "id_dictionnaire",
     115                ),
     116                'join' => array(
     117                        "id_definition"   => "id_definition",
     118                        "id_dictionnaire" => "id_dictionnaire"
     119                ),
     120                'tables_jointures' => array('definitions_liens'),
     121                'champs_editables' => array(
     122                        'id_dictionnaire',
     123                        'titre', 'texte', 'termes',
     124                        'type', 'casse', 'statut',
     125                        'lang', 'date',
     126                ),
     127                'statut' => array(
     128                        array(
     129                                'champ'=>'statut',
     130                                'publie'=>'publie',
     131                                'previsu'=>'prepa,publie',
     132                                'exception'=> array('statut', 'tout')
     133                        )
     134                ),
     135                'texte_changer_statut' => 'definition:changer_statut',
     136                'statut_titres' => array(
     137                        'prop'=>'info_article_propose',
     138                        'publie'=>'info_article_publie',
     139                        'poubelle'=>'info_article_supprime'
     140                ),
     141                'statut_textes_instituer' => array(
     142                        'prop' => 'texte_statut_propose_evaluation',
     143                        'publie' => 'texte_statut_publie',
     144                        'refuse' => 'texte_statut_poubelle',
     145                ),
     146        );
     147
     148        return $tables;
    75149}
    76150
     151
     152/**
     153 * Déclarer les tables auxiliaires des definitions
     154 *
     155 * @pipeline declarer_tables_auxiliaires
     156 * @param array $tables_auxiliaires
     157 *     Description des tables
     158 * @return array
     159 *     Description complétée des tables
     160 */
    77161function dictionnaires_declarer_tables_auxiliaires($tables_auxiliaires){
    78         //-- Table de relations definitions_liens -----------------------------------------
     162        //-- Table de relations definitions_liens
    79163        $spip_definitions_liens = array(
    80164                'id_definition' => 'bigint(21) not null default 0',
  • _plugins_/dictionnaires/trunk/dictionnaires_administrations.php

    r61875 r65485  
    11<?php
     2
     3/**
     4 * Fichier gérant l'installation et désinstallation du plugin
     5 *
     6 * @package SPIP\Dictionnaire\Installation
     7**/
    28
    39// Sécurité
    410if (!defined('_ECRIRE_INC_VERSION')) return;
    511
    6 include_spip('inc/meta');
     12/**
     13 * Installation/maj des tables dictionnaires et définitions...
     14 *
     15 * @param string $nom_meta_base_version
     16 *     Nom de la meta informant de la version du schéma de données du plugin installé dans SPIP
     17 * @param string $version_cible
     18 *     Version du schéma de données dans ce plugin (déclaré dans paquet.xml)
     19 * @return void
     20 */
     21function dictionnaires_upgrade($nom_meta_base_version, $version_cible) {
    722
    8 // Installation et mise à jour
    9 function dictionnaires_upgrade($nom_meta_version_base, $version_cible){
     23        include_spip('inc/config');
     24        include_spip('base/create');
    1025
    11         $version_actuelle = '0.0.0';
    12         if (
    13                 (!isset($GLOBALS['meta'][$nom_meta_version_base]))
    14                 || (($version_actuelle = $GLOBALS['meta'][$nom_meta_version_base]) != $version_cible)
    15         ){
    16                
    17                 if (version_compare($version_actuelle,'0.0.0','=')){
    18                         // Création des tables
    19                         include_spip('base/create');
    20                         include_spip('base/abstract_sql');
    21                         creer_base();
    22                        
    23                         // Valeurs de config par défaut
    24                         include_spip('inc/config');
    25                         ecrire_config('dictionnaires/remplacer_premier_defaut', 'on');
    26                         ecrire_config('dictionnaires/remplacer_premier_abbr', 'on');
    27                        
    28                         // Migration depuis F&T si présent
    29                         dictionnaires_migrer_acronymes();
    30                        
    31                         echo "Installation du plugin dictionnaires<br/>";
    32                         ecrire_meta($nom_meta_version_base, $version_actuelle=$version_cible, 'non');
    33                 }
    34                
    35                 if (version_compare($version_actuelle,$version_cible='0.2.0','<')){
    36                         include_spip('base/create');
    37                         include_spip('base/abstract_sql');
    38                        
    39                         // On ajoute un champ pour choisir le type par défaut dans un dictionnaire
    40                         maj_tables('spip_dictionnaires');
    41                        
    42                         // On change la version
    43                         ecrire_meta($nom_meta_version_base, $version_actuelle=$version_cible, 'non');
    44                 }
    45                
    46                 if (version_compare($version_actuelle,$version_cible='0.3.0','<')){
    47                         include_spip('base/create');
    48                         include_spip('base/abstract_sql');
    49                        
    50                         // On ajoute un champ pour forcer la prise en compte de la casse pour une définition
    51                         maj_tables('spip_definitions');
    52                        
    53                         // On change la version
    54                         ecrire_meta($nom_meta_version_base, $version_actuelle=$version_cible, 'non');
    55                 }
    56         }
     26        $maj = array();
     27        $maj['create'] = array(
     28                array('maj_tables', array('spip_dictionnaires', 'spip_definitions', 'spip_definitions_liens')),
     29                array('ecrire_config', 'dictionnaires/remplacer_premier_defaut', 'on'),
     30                array('ecrire_config', 'dictionnaires/remplacer_premier_abbr', 'on'),
     31                array('dictionnaires_migrer_acronymes'),
     32        );
    5733
     34        $maj['0.2.0'] = array(array('maj_tables', 'spip_dictionnaires'));
     35        $maj['0.3.0'] = array(array('maj_tables', 'spip_definitions'));
     36
     37        // deplacer les statuts du dictionnaires de 'actif' a 'statut'
     38        $maj['0.4.0'] = array(
     39                array('maj_tables', 'spip_dictionnaires'),
     40                array('sql_update', 'spip_dictionnaires', array('statut'=>'actif'), 'actif=1'),
     41                array('sql_update', 'spip_dictionnaires', array('statut'=>'inactif'), 'actif=0'),
     42                array('sql_alter', 'TABLE spip_dictionnaires DROP COLUMN actif'),
     43        );
     44        // pas de not null sans integer pour sqlite
     45        $maj['0.4.1'] = array(
     46                array('sql_alter', 'TABLE spip_definitions CHANGE COLUMN id_dictionnaire id_dictionnaire bigint(21) not null default 0')
     47        );
     48
     49        include_spip('base/upgrade');
     50        maj_plugin($nom_meta_base_version, $version_cible, $maj);
    5851}
    5952
     53/**
     54 * Migre les acronymes du plugins Forms & Tables (s'il est actif)
     55 * dans ce plugin.
     56**/
    6057function dictionnaires_migrer_acronymes(){
    6158        // Si F&T est actif là tout de suite et qu'il y a une table d'acronymes
     
    6764                include_spip('forms_fonctions');
    6865                $id_form = intval(reset($liste));
    69                 spip_query("SELECT id_donnee FROM spip_forms_donnees WHERE id_form="._q($id_form)." AND statut='publie'");
    7066                $acronymes = sql_allfetsel('id_donnee, statut, date', 'spip_forms_donnees', 'id_form = '.$id_form);
    7167                if ($acronymes and is_array($acronymes)){
     
    7672                                dictionnaire_set($id_dictionnaire, array(
    7773                                        'titre' => _T('dictionnaire:importer_acronymes_titre'),
    78                                         'actif' => 1,
     74                                        'statut' => 'actif',
    7975                                        'descriptif' => _T('dictionnaire:importer_acronymes_descriptif'),
    8076                                        'type_defaut' => 'abbr',
     
    111107}
    112108
    113 // Désinstallation
    114 function dictionnaires_vider_tables($nom_meta_version_base){
     109/**
     110 * Désinstallation/suppression des tables dictionnaires et definitions
     111 *
     112 * @param string $nom_meta_base_version
     113 *     Nom de la meta informant de la version du schéma de données du plugin installé dans SPIP
     114 * @return void
     115 */
     116function dictionnaires_vider_tables($nom_meta_base_version){
    115117
    116118        include_spip('base/abstract_sql');
    117        
     119
    118120        // On efface les tables du plugin
    119121        sql_drop_table('spip_dictionnaires');
    120122        sql_drop_table('spip_definitions');
    121123        sql_drop_table('spip_definitions_liens');
    122                
     124
     125        // Effacer les configurations
     126        effacer_meta('dictionnaires');
     127
    123128        // On efface la version entregistrée
    124         effacer_meta($nom_meta_version_base);
     129        effacer_meta($nom_meta_base_version);
    125130
    126131}
  • _plugins_/dictionnaires/trunk/dictionnaires_autoriser.php

    r58087 r65485  
    11<?php
     2
     3/**
     4 * Définit les autorisations du plugin dictionnaires
     5 *
     6 * @package SPIP\Dictionnaires\Autorisations
     7**/
    28
    39// Sécurité
    410if (!defined('_ECRIRE_INC_VERSION')) return;
    511
    6 function dictionnaires_autoriser($flux){
    7         return $flux;
     12/**
     13 * Fonction d'appel pour le pipeline
     14 * @pipeline autoriser
     15 */
     16function dictionnaires_autoriser(){}
     17
     18// Qui peut voir la liste des dictionnaires : tout le monde
     19
     20/**
     21 * Autorisation de voir le bouton de dictionnaires
     22 *
     23 * Tout le monde
     24 *
     25 * @param  string $faire Action demandée
     26 * @param  string $type  Type d'objet sur lequel appliquer l'action
     27 * @param  int    $id    Identifiant de l'objet
     28 * @param  array  $qui   Description de l'auteur demandant l'autorisation
     29 * @param  array  $opt   Options de cette autorisation
     30 * @return bool          true s'il a le droit, false sinon
     31**/
     32function autoriser_dictionnaires_bouton_dist($faire, $type, $id, $qui, $opt){
     33        return autoriser('bouton', 'dictionnaires_edition', $id, $qui, $opt);
    834}
    935
    10 // Qui peut voir la liste des dictionnaires : tout le monde
    11 function autoriser_dictionnaires_bouton_dist($faire, $quoi, $id, $qui, $options){
    12         return autoriser('bouton', 'dictionnaires_edition');
    13 }
    14 function autoriser_dictionnaires_edition_bouton_dist($faire, $quoi, $id, $qui, $options){
     36/**
     37 * Autorisation de voir le bouton de dictionnaires du menu d'édition
     38 *
     39 * Tout le monde
     40 *
     41 * @param  string $faire Action demandée
     42 * @param  string $type  Type d'objet sur lequel appliquer l'action
     43 * @param  int    $id    Identifiant de l'objet
     44 * @param  array  $qui   Description de l'auteur demandant l'autorisation
     45 * @param  array  $opt   Options de cette autorisation
     46 * @return bool          true s'il a le droit, false sinon
     47**/
     48function autoriser_dictionnaires_edition_bouton_dist($faire, $type, $id, $qui, $opt){
    1549        return true;
    1650}
    1751
    18 // Qui peut créer un dictionnaire : ceux qui peuvent configurer le site
    19 function autoriser_dictionnaire_creer_dist($faire, $quoi, $id, $qui, $options){
    20         return autoriser('configurer');
     52
     53/**
     54 * Autorisation de créer un dictionnaire
     55 *
     56 * Ceux qui peuvent configurer le site
     57 *
     58 * @param  string $faire Action demandée
     59 * @param  string $type  Type d'objet sur lequel appliquer l'action
     60 * @param  int    $id    Identifiant de l'objet
     61 * @param  array  $qui   Description de l'auteur demandant l'autorisation
     62 * @param  array  $opt   Options de cette autorisation
     63 * @return bool          true s'il a le droit, false sinon
     64**/
     65function autoriser_dictionnaire_creer_dist($faire, $type, $id, $qui, $opt){
     66        return autoriser('configurer', $type, $id, $qui, $opt);
    2167}
    22 // Qui peut modifier un dictionnaire : ceux qui peuvent configurer le site
    23 function autoriser_dictionnaire_modifier_dist($faire, $quoi, $id, $qui, $options){
    24         return autoriser('configurer');
     68
     69/**
     70 * Autorisation de modifier un dictionnaire
     71 *
     72 * Ceux qui peuvent configurer le site
     73 *
     74 * @param  string $faire Action demandée
     75 * @param  string $type  Type d'objet sur lequel appliquer l'action
     76 * @param  int    $id    Identifiant de l'objet
     77 * @param  array  $qui   Description de l'auteur demandant l'autorisation
     78 * @param  array  $opt   Options de cette autorisation
     79 * @return bool          true s'il a le droit, false sinon
     80**/
     81function autoriser_dictionnaire_modifier_dist($faire, $type, $id, $qui, $opt){
     82        return autoriser('configurer', $type, $id, $qui, $opt);
    2583}
    26 // Qui peut supprimer un dictionnaire : ceux qui peuvent configurer le site SI ya plus aucune définition dedans !
    27 function autoriser_dictionnaire_supprimer_dist($faire, $quoi, $id, $qui, $options){
     84
     85/**
     86 * Autorisation de dupprimer un dictionnaire
     87 *
     88 * Ceux qui peuvent configurer le site,
     89 * s'il n'y a plus aucune définition dedans !
     90 *
     91 * @param  string $faire Action demandée
     92 * @param  string $type  Type d'objet sur lequel appliquer l'action
     93 * @param  int    $id    Identifiant de l'objet
     94 * @param  array  $qui   Description de l'auteur demandant l'autorisation
     95 * @param  array  $opt   Options de cette autorisation
     96 * @return bool          true s'il a le droit, false sinon
     97**/
     98function autoriser_dictionnaire_supprimer_dist($faire, $type, $id, $qui, $opt){
    2899        return ($id > 0)
    29                 and autoriser('configurer')
     100                and autoriser('configurer', $type, $id, $qui, $opt)
    30101                and !sql_fetsel(
    31102                        'id_definition',
     
    38109}
    39110
    40 // Qui peut créer une définition : un rédacteur
    41 function autoriser_dictionnaire_creerdefinitiondans_dist($faire, $quoi, $id, $qui, $options){
     111
     112/**
     113 * Autorisation de créer une définition
     114 *
     115 * Les rédacteurs
     116 *
     117 * @param  string $faire Action demandée
     118 * @param  string $type  Type d'objet sur lequel appliquer l'action
     119 * @param  int    $id    Identifiant de l'objet
     120 * @param  array  $qui   Description de l'auteur demandant l'autorisation
     121 * @param  array  $opt   Options de cette autorisation
     122 * @return bool          true s'il a le droit, false sinon
     123**/
     124function autoriser_dictionnaire_creerdefinitiondans_dist($faire, $type, $id, $qui, $opt){
    42125        return $qui['statut'] <= '1comite';
    43126}
    44 // Qui peut modifier une définition : un rédacteur si pas publié, un admin sinon
    45 function autoriser_definition_modifier_dist($faire, $quoi, $id, $qui, $options){
     127
     128/**
     129 * Autorisation de modifier une définition
     130 *
     131 * Un rédacteur si pas publié, un admin sinon
     132 *
     133 * @param  string $faire Action demandée
     134 * @param  string $type  Type d'objet sur lequel appliquer l'action
     135 * @param  int    $id    Identifiant de l'objet
     136 * @param  array  $qui   Description de l'auteur demandant l'autorisation
     137 * @param  array  $opt   Options de cette autorisation
     138 * @return bool          true s'il a le droit, false sinon
     139**/
     140function autoriser_definition_modifier_dist($faire, $type, $id, $qui, $opt){
    46141        if ($id > 0
    47142                and $statut = sql_getfetsel('statut', 'spip_definitions', 'id_definition = '.$id)
     
    57152        return false;
    58153}
    59 // Qui peut supprimer une définition : pareil que modifier
    60 function autoriser_definition_supprimer_dist($faire, $quoi, $id, $qui, $options){
    61         return autoriser('modifier', $quoi, $id, $quoi, $options);
     154
     155
     156/**
     157 * Autorisation de supprimer une définition
     158 *
     159 * Pareil que pour modifier une définition
     160 *
     161 * @param  string $faire Action demandée
     162 * @param  string $type  Type d'objet sur lequel appliquer l'action
     163 * @param  int    $id    Identifiant de l'objet
     164 * @param  array  $qui   Description de l'auteur demandant l'autorisation
     165 * @param  array  $opt   Options de cette autorisation
     166 * @return bool          true s'il a le droit, false sinon
     167**/
     168function autoriser_definition_supprimer_dist($faire, $type, $id, $qui, $opt){
     169        return autoriser('modifier', $type, $id, $qui, $opt);
    62170}
    63171
  • _plugins_/dictionnaires/trunk/dictionnaires_pipelines.php

    r61875 r65485  
    11<?php
     2
     3/**
     4 * Usage de pipelines
     5 *
     6 * @package SPIP\Dictionnaires\Pipelines
     7**/
    28
    39// Sécurité
    410if (!defined('_ECRIRE_INC_VERSION')) return;
    511
    6 function dictionnaires_declarer_url_objets($objets){
    7         $objets[] = 'dictionnaire';
    8         $objets[] = 'definition';
    9         return $objets;
    10 }
     12/**
     13 * Crée des liaisons entre les objets et les définitions.
     14 *
     15 * Pour chaque objet édité, regarde si les contenus possèdent des définitions
     16 * que l'on connaît et dans ce cas crée une liaison entre l'objet et la définition.
     17 *
     18 * Cela permet de connaître, pour une définition donnée, la liste des
     19 * objets sur lesquels est rattaché une définition. À l'inverse, cela
     20 * permet, pour un objet de connaître les définitions qu'il possède.
     21 *
     22 * @todo
     23 *     Tout cela est à faire !!!
     24 *
     25 * @pipeline post_edition
     26 *
     27 * @param array $flux   Données du pipeline
     28 * @return array        Données du pipeline
     29**/
     30function dictionnaires_post_edition($flux){
     31        // TOUT CELA EST A FAIRE
     32        return $flux;
    1133
    12 function dictionnaires_post_edition($flux){
    1334        // Seulement si c'est une modif d'objet
    1435        if ($flux['args']['action'] == 'modifier' and $id_objet = $flux['args']['id_objet']){
     
    3859}
    3960
     61/**
     62 * Ajoute pour les textes passés à propre les définitions sur les
     63 * termes à définir.
     64 *
     65 * N'ajoute pas de définition si les termes à définir sont déjà
     66 * dans des balises de définition ou de code, genre <abbr> ou <code>
     67 *
     68 * @pipeline post_edition
     69 *
     70 * @param string $texte  Texte
     71 * @return string        Texte
     72**/
    4073function dictionnaires_post_propre($texte){
    4174        $GLOBALS['dictionnaires_id_texte'] = uniqid();
     
    77110}
    78111
     112
     113/**
     114 * Callback réceptionnant les captures de termes à définir
     115 *
     116 * Remplace la trouvaille par une description avec sa définition.
     117 * Et on ne le fait qu'au moment de la première occurence, lorsque
     118 * c'est configuré comme tel.
     119 *
     120 * @pipeline post_edition
     121 *
     122 * @param string $captures Terme trouvé
     123 * @return string          HTML du terme et de sa définition
     124**/
    79125function dictionnaires_replace_callback($captures){
    80126        include_spip('inc/config');
  • _plugins_/dictionnaires/trunk/formulaires/configurer_dictionnaires.php

    r57316 r65485  
    11<?php
     2
     3/**
     4 * Gestion du formulaire de configuration des dictionnaires
     5 *
     6 * @package SPIP\Dictionnaires\Formulaires
     7**/
    28
    39// Sécurité
    410if (!defined('_ECRIRE_INC_VERSION')) return;
    511
     12/**
     13 * Liste des saisies du formulaire de configuration de dictionnaires
     14 *
     15 * @return array
     16 *     Liste des saisies du formulaire
     17**/
    618function formulaires_configurer_dictionnaires_saisies_dist(){
    719        include_spip('inc/config');
     
    2739}
    2840
     41/**
     42 * Chargement du formulaire de configuration de dictionnaires
     43 *
     44 * @return array
     45 *     Environnement du formulaire
     46**/
    2947function formulaires_configurer_dictionnaires_charger_dist(){
    3048        return array(
  • _plugins_/dictionnaires/trunk/formulaires/editer_definition.php

    r58145 r65485  
    11<?php
     2
     3/**
     4 * Gestion du formulaire de d'édition d'une définition
     5 *
     6 * @package SPIP\Dictionnaires\Formulaires
     7**/
    28
    39// Sécurité
     
    612include_spip('inc/editer');
    713
     14
     15/**
     16 * Définition des champs de saisie du formulaire d'édition de définition
     17 *
     18 * @param int|string $id_definition
     19 *     Identifiant de la définition. 'new' pour une nouvelle définition.
     20 * @param int $id_dictionnaire
     21 *     Identifiant du dictionnaire parent
     22 * @param string $retour
     23 *     URL de redirection après le traitement
     24 * @return array
     25 *     Liste de saisies et leurs options
     26**/
    827function formulaires_editer_definition_saisies_dist($id_definition='new', $id_dictionnaire=0, $retour=''){
    928        $saisies = array(
     29                array(
     30                        'saisie' => 'hidden',
     31                        'options' => array(
     32                                'nom' => 'id_definition',
     33                                'valeur' => $id_definition
     34                        )
     35                ),
    1036                array(
    1137                        'saisie' => 'input',
     
    6490}
    6591
     92/**
     93 * Chargement du formulaire d'édition de définition
     94 *
     95 * @see formulaires_editer_objet_charger()
     96 *
     97 * @param int|string $id_definition
     98 *     Identifiant de la définition. 'new' pour une nouvelle définition.
     99 * @param int $id_dictionnaire
     100 *     Identifiant du dictionnaire parent
     101 * @param string $retour
     102 *     URL de redirection après le traitement
     103 * @return array
     104 *     Environnement du formulaire
     105**/
    66106function formulaires_editer_definition_charger_dist($id_definition='new',  $id_dictionnaire=0, $retour=''){
    67107        $contexte = formulaires_editer_objet_charger('definition', $id_definition, $id_dictionnaire, 0, $retour, '');
     
    75115}
    76116
     117/**
     118 * Vérifications du formulaire d'édition de définition
     119 *
     120 * @see formulaires_editer_objet_verifier()
     121 *
     122 * @param int|string $id_definition
     123 *     Identifiant de la définition. 'new' pour une nouvelle définition.
     124 * @param int $id_dictionnaire
     125 *     Identifiant du dictionnaire parent
     126 * @param string $retour
     127 *     URL de redirection après le traitement
     128 * @return array
     129 *     Tableau des erreurs
     130**/
    77131function formulaires_editer_definition_verifier_dist($id_definition='new',  $id_dictionnaire=0, $retour=''){
    78132        $erreurs = formulaires_editer_objet_verifier('definition', $id_definition);
     
    80134}
    81135
     136/**
     137 * Traitements du formulaire d'édition de définition
     138 *
     139 * @see formulaires_editer_objet_traiter()
     140 *
     141 * @param int|string $id_definition
     142 *     Identifiant de la définition. 'new' pour une nouvelle définition.
     143 * @param int $id_dictionnaire
     144 *     Identifiant du dictionnaire parent
     145 * @param string $retour
     146 *     URL de redirection après le traitement
     147 * @return array
     148 *     Retour des traitements
     149**/
    82150function formulaires_editer_definition_traiter_dist($id_definition='new',  $id_dictionnaire=0, $retour=''){
    83         if ($retour) refuser_traiter_formulaire_ajax();
     151
    84152        if (is_null(_request('type'))){ set_request('type', ''); }
    85153        if (is_null(_request('casse'))){ set_request('casse', ''); }
     154
    86155        $retours = formulaires_editer_objet_traiter('definition', $id_definition, $id_dictionnaire, 0, $retour, '');
    87        
    88156        return $retours;
    89157}
  • _plugins_/dictionnaires/trunk/formulaires/editer_dictionnaire.php

    r58145 r65485  
    11<?php
     2
     3/**
     4 * Gestion du formulaire de d'édition d'un dictionnaire
     5 *
     6 * @package SPIP\Dictionnaires\Formulaires
     7**/
    28
    39// Sécurité
     
    612include_spip('inc/editer');
    713
     14/**
     15 * Définition des champs de saisie du formulaire d'édition de dictionnaire
     16 *
     17 * @param int|string $id_dictionnaire
     18 *     Identifiant du dictionnaire. 'new' pour un nouveau dictionnaire.
     19 * @param string $retour
     20 *     URL de redirection après le traitement
     21 * @return array
     22 *     Liste de saisies et leurs options
     23**/
    824function formulaires_editer_dictionnaire_saisies_dist($id_dictionnaire='new', $retour=''){
    925        $saisies = array(
     26                array(
     27                        'saisie' => 'hidden',
     28                        'options' => array(
     29                                'nom' => 'id_dictionnaire',
     30                                'valeur' => $id_dictionnaire
     31                        )
     32                ),
    1033                array(
    1134                        'saisie' => 'input',
     
    2144                                'nom' => 'descriptif',
    2245                                'label' => _T('dictionnaire:champ_descriptif_label'),
     46                                'class' => 'inserer_barre_edition inserer_previsualisation',
    2347                        )
    2448                ),
     
    3559                        'saisie' => 'selection',
    3660                        'options' => array(
    37                                 'nom' => 'actif',
     61                                'nom' => 'statut',
    3862                                'label' => _T('dictionnaire:champ_actif_label'),
    3963                                'explication' => _T('dictionnaire:champ_actif_explication'),
    4064                                'datas' => array(
    41                                         '0' => _T('dictionnaire:champ_actif_non'),
    42                                         '1' => _T('dictionnaire:champ_actif_oui'),
     65                                        'inactif' => _T('dictionnaire:champ_actif_non'),
     66                                        'actif'  => _T('dictionnaire:champ_actif_oui'),
    4367                                ),
    4468                                'cacher_option_intro' => 'on'
     
    5074}
    5175
     76
     77/**
     78 * Chargement du formulaire d'édition de dictionnaire
     79 *
     80 * @see formulaires_editer_objet_charger()
     81 *
     82 * @param int|string $id_dictionnaire
     83 *     Identifiant du dictionnaire. 'new' pour un nouveau dictionnaire.
     84 * @param string $retour
     85 *     URL de redirection après le traitement
     86 * @return array
     87 *     Environnement du formulaire
     88**/
    5289function formulaires_editer_dictionnaire_charger_dist($id_dictionnaire='new', $retour=''){
    5390        $contexte = formulaires_editer_objet_charger('dictionnaire', $id_dictionnaire, 0, 0, $retour, '');
     
    5592}
    5693
     94/**
     95 * Vérifications du formulaire d'édition de dictionnaire
     96 *
     97 * @see formulaires_editer_objet_verifier()
     98 *
     99 * @param int|string $id_dictionnaire
     100 *     Identifiant du dictionnaire. 'new' pour un nouveau dictionnaire.
     101 * @param string $retour
     102 *     URL de redirection après le traitement
     103 * @return array
     104 *     Tableau des erreurs
     105**/
    57106function formulaires_editer_dictionnaire_verifier_dist($id_dictionnaire='new', $retour=''){
    58107        $erreurs = formulaires_editer_objet_verifier('dictionnaire', $id_dictionnaire);
     
    60109}
    61110
     111/**
     112 * Traitements du formulaire d'édition de dictionnaire
     113 *
     114 * @see formulaires_editer_objet_traiter()
     115 *
     116 * @param int|string $id_dictionnaire
     117 *     Identifiant du dictionnaire. 'new' pour un nouveau dictionnaire.
     118 * @param string $retour
     119 *     URL de redirection après le traitement
     120 * @return array
     121 *     Retour des traitements
     122**/
    62123function formulaires_editer_dictionnaire_traiter_dist($id_dictionnaire='new', $retour=''){
    63         if ($retour) refuser_traiter_formulaire_ajax();
    64124        if (is_null(_request('type_defaut'))){ set_request('type_defaut', ''); }
    65125        $retours = formulaires_editer_objet_traiter('dictionnaire', $id_dictionnaire, 0, 0, $retour, '');
    66        
    67126        return $retours;
    68127}
  • _plugins_/dictionnaires/trunk/inc/dictionnaires.php

    r58145 r65485  
    11<?php
    22
     3/**
     4 * Fonctions et filtres du dictionnaires
     5 *
     6 * @package SPIP\Dictionnaires\Fonctions
     7 */
     8 
    39// Sécurité
    410if (!defined('_ECRIRE_INC_VERSION')) return;
    511
    6 /*
    7  * Récupérer un tableau facilement utilisable de toutes les définitions en activité sur le site
     12/**
     13 * Liste les définitions en activité
     14 *
     15 * Récupére un tableau facilement utilisable de toutes les définitions en activité sur le site
    816 * Une définition active est une définition publié ET dans un dico actif
    917 *
    10  * @return array Retourne un tableau des définitions
     18 * @param bool $purger
     19 *     true pour vider le cache statique des définitions connues.
     20 * @return array
     21 *     Tableau des définitions
    1122 *      array(
    12                 array(
    13                         'titre' => 'Truc',
    14                         'texte' => 'Ma définition',
    15                         'termes' => array('trucs', 'bidule'), // autres termes qui seront reconnus
    16                         'type' => '' | 'abbr',
    17                 ),
    18                 array(
    19                         ...
    20                 )
    21  *      )
     23 *              array(
     24 *                      'titre' => 'Truc',
     25 *                      'texte' => 'Ma définition',
     26 *                      'termes' => array('trucs', 'bidule'), // autres termes qui seront reconnus
     27 *                      'type' => '' | 'abbr',
     28 *              ),
     29 *              array(
     30 *                      ...
     31 *              )
     32 *      )
    2233 */
    2334function dictionnaires_lister_definitions($purger=false){
     
    4657               
    4758                // On récupère tous les dictionnaires actifs
    48                 $dicos_actifs = sql_allfetsel('id_dictionnaire', 'spip_dictionnaires', 'actif = 1');
     59                $dicos_actifs = sql_allfetsel('id_dictionnaire', 'spip_dictionnaires', 'statut = '. sql_quote('actif'));
    4960                if ($dicos_actifs and is_array($dicos_actifs)){
    5061                        $dicos_actifs = array_map('reset', $dicos_actifs);
     
    124135}
    125136
    126 /*
     137/**
    127138 * Lister les définitions par terme.
     139 *
    128140 * Chaque clé du tableau est alors un terme reconnu, en minuscule.
    129141 * Une même définition peut donc se trouver plusieurs fois dans la liste, avec différentes clés.
     142 *
     143 * @return array Tableau des définitions classé par terme
    130144 */
    131145function dictionnaires_lister_definitions_par_terme(){
     
    144158}
    145159
    146 /*
     160/**
    147161 * Fonction de remplacement par défaut pour les termes trouvés dans les textes
     162 *
     163 * @param string $mot
     164 *     Le mot trouvé
     165 * @param string $definition
     166 *     La définition correspondante
     167 * @return string
     168 *     Code HTML de remplacement de la définition
    148169 */
    149 function dictionnaires_remplacer_defaut_dist($mot, $definition){
     170function dictionnaires_remplacer_defaut_dist($mot, $definition) {
     171        if (!isset($definition['url']) OR !$url = $definition['url']) {
     172                $url = generer_url_entite($definition['id_definition'],'definition');
     173        }
    150174        return $mot
    151                 .'<sup><a href="'
    152                 .($definition['url']?$definition['url']:generer_url_entite($definition['id_definition'],'definition'))
    153                 .'" title="'._T('definition:titre_definition').': '.couper(trim(attribut_html(supprimer_tags(typo($definition['texte'])))),80).'">'
     175                .'<sup><a href="'.$url.'" title="'._T('definition:titre_definition').': '
     176                        . couper(trim(attribut_html(supprimer_tags(typo($definition['texte'])))),80).'">'
    154177                .'?'
    155178                .'</a></sup>';
  • _plugins_/dictionnaires/trunk/lang/definition_fr.php

    r58145 r65485  
    66$GLOBALS[$GLOBALS['idx_lang']] = array(
    77'bulledaide_definitions' => 'Consulter le glossaire du site (sigles et définitions)',
     8'changer_statut' => 'Cette définition est :',
    89'champ_casse_label' => 'Sensibilité de la casse',
    910'champ_casse_label_case' => 'La détection de ce terme sera sensible aux minuscules et majuscules.',
  • _plugins_/dictionnaires/trunk/lang/dictionnaire_fr.php

    r58145 r65485  
    55
    66$GLOBALS[$GLOBALS['idx_lang']] = array(
     7'changer_statut' => 'Ce dictionnaire est :',
    78'champ_actif_explication' => 'Un dictionnaire actif aura ses termes détectés dans les contenus du site.',
    89'champ_actif_label' => 'Activé',
     
    1617'configurer_champ_remplacer_premier_defaut_label' => 'Remplacer uniquement la première occurence d\'une définition',
    1718'configurer_titre' => 'Configurer les dictionnaires',
     19'confirmer_supprimer_dictionnaire' => 'Voulez-vous réellement supprimer ce dictionnaire et ses définitions ?',
    1820'icone_creer_dictionnaire' => 'Ajouter un nouveau dictionnaire',
    1921'icone_modifier_dictionnaire' => 'Modifier ce dictionnaire',
     
    2628'info_nouveau_dictionnaire' => 'Nouveau dictionnaire',
    2729'info_numero_dictionnaire' => 'Dictionnaire numéro :',
     30'info_supprimer_dictionnaire' => 'supprimer ce dictionnaire',
    2831'titre_dictionnaire' => 'Dictionnaire',
    2932'titre_dictionnaires' => 'Dictionnaires',
  • _plugins_/dictionnaires/trunk/lang/paquet-dictionnaires_fr.php

    r58163 r65485  
    1616        'dictionnaires_description' => 'Permet la création de dictionnaires regroupant des définitions. Les termes définis sont automatiquement détectés dans les textes du site et il est alors possible de les insérer dans le HTML du texte de manière accessible.',
    1717        'dictionnaires_slogan' => 'Créer des dictionnaires',
     18        'dictionnaires_nom' => 'Dictionnaires',
    1819);
    1920?>
  • _plugins_/dictionnaires/trunk/modeles/dictionnaires.html

    r61875 r65485  
    1 <BOUCLE_Dictionnaires(DICTIONNAIRES){id_dictionnaire ?}{par titre}{actif=1}>
     1<BOUCLE_Dictionnaires(DICTIONNAIRES){id_dictionnaire ?}{par titre}>
    22[<h2>#TITRE</h2>
    33(#INCLURE{fond=modeles/dictionnaire,id_dictionnaire,env})]
  • _plugins_/dictionnaires/trunk/paquet.xml

    r65458 r65485  
    22        prefix="dictionnaires"
    33        categorie="divers"
    4         version="0.3.4"
     4        version="0.4.0"
    55        etat="dev"
    6         compatibilite="[2.1.12;3.0.*]"
     6        compatibilite="[3.0.0;3.0.*]"
    77        logo="prive/themes/spip/images/dictionnaire-32.png"
    8         schema="0.3.0"
    9 >       
     8        schema="0.4.1"
     9>
    1010
    1111        <nom>Dictionnaires</nom>
     
    1717
    1818        <pipeline nom="autoriser" inclure="dictionnaires_autoriser.php" />
    19         <pipeline nom="declarer_tables_principales" inclure="base/dictionnaires_tables.php" />
     19        <pipeline nom="declarer_tables_objets_sql" inclure="base/dictionnaires_tables.php" />
    2020        <pipeline nom="declarer_tables_interfaces" inclure="base/dictionnaires_tables.php" />
    2121        <pipeline nom="declarer_tables_auxiliaires" inclure="base/dictionnaires_tables.php" />
    22         <pipeline nom="declarer_url_objets" inclure="dictionnaires_pipelines.php" />
    23         <pipeline nom="post_edition" inclure="dictionnaires_pipelines.php" />
     22
     23        <!-- <pipeline nom="post_edition" inclure="dictionnaires_pipelines.php" /> -->
    2424        <pipeline nom="post_propre" inclure="dictionnaires_pipelines.php" />
    2525
    26         <necessite nom="spip_bonux" compatibilite="[2.2.17;[" />
    2726        <necessite nom="saisies" compatibilite="[1.20.0;[" />
    2827
  • _plugins_/dictionnaires/trunk/prive/objets/contenu/dictionnaire.html

    r57283 r65485  
    1 <BOUCLE_afficher_contenu(DICTIONNAIRES){id_dictionnaire=#ENV{id}}{actif?}>
     1<BOUCLE_afficher_contenu(DICTIONNAIRES){id_dictionnaire=#ENV{id}}{statut ?}>
    22<div class="champ contenu_titre[ (#TITRE*|strlen|?{'',vide})]">
    33        <div class='label'><:dictionnaire:champ_titre_label:></div>
  • _plugins_/dictionnaires/trunk/prive/objets/liste/definitions.html

    r57618 r65485  
    2828        >
    2929                <tr class="[(COMPTEUR_BOUCLE|alterner{row_odd,row_even})]">
    30                         <td class="statut">[(#ID_DEFINITION|puce_changement_statut{#STATUT,#ID_DICTIONNAIRE,definition,true})]</td>
     30                        <td class="statut">[(#ID_DEFINITION|puce_changement_statut{#STATUT, #ID_DICTIONNAIRE, definition, true})]</td>
    3131                        <td class="titre principale"><a href="[(#ID_DEFINITION|generer_url_entite{definition})]"
    3232                                title="<:info_numero_abbreviation|attribut_html:> #ID_DEFINITION">[(#RANG). ]#TITRE</a></td>
  • _plugins_/dictionnaires/trunk/prive/objets/liste/dictionnaires.html

    r57618 r65485  
    1919        <tbody>
    2020        <BOUCLE_liste_dictionnaires(DICTIONNAIRES)
    21                 {actif?}
     21                {statut?}
    2222                {recherche?}
    2323                {tri #ENV{par,#ENV{recherche}|?{points,titre}},#GET{defaut_tri}}
     
    2525        >
    2626                <tr class="[(COMPTEUR_BOUCLE|alterner{row_odd,row_even})]">
    27                         <td class="statut">[(#ACTIF|?{<:dictionnaire:champ_actif_oui:>, <:dictionnaire:champ_actif_non:>})]</td>
     27                        <td class="statut">[(#ID_DICTIONNAIRE|puce_changement_statut{#STATUT, '', dictionnaire, true})]</td>
    2828                        <td class="titre principale"><a href="[(#ID_DICTIONNAIRE|generer_url_entite{dictionnaire})]"
    2929                                title="<:info_numero_abbreviation|attribut_html:> #ID_DICTIONNAIRE">[(#RANG). ]#TITRE <BOUCLE_nb_definitions(DEFINITIONS){id_dictionnaire}{tout}/>[(#TOTAL_BOUCLE|oui)([(#TOTAL_BOUCLE|singulier_ou_pluriel{definition:info_1_definition, definition:info_nb_definitions})])]<//B_nb_definitions></a></td>
  • _plugins_/dictionnaires/trunk/saisies/dictionnaires.html

    r57283 r65485  
    2424        [(#ENV{cacher_option_intro}|ou{#ENV{multiple}}|non)
    2525                <option value="">[(#ENV{option_intro})]</option>]
    26         <BOUCLE_dictionnaires(DICTIONNAIRES){par num titre, titre}{actif ?}>
     26        <BOUCLE_dictionnaires(DICTIONNAIRES){par num titre, titre}{statut ?}>
    2727                [(#ENV{multiple}|oui)
    2828                <option value="#ID_DICTIONNAIRE"[(#ID_DICTIONNAIRE|in_array{#ENV{valeur_forcee,#GET{valeur,#ENV{defaut,#ARRAY}}}}|oui) selected="selected"]>#TITRE</option>]
Note: See TracChangeset for help on using the changeset viewer.