source: spip-zone/_core_/plugins/mots/action/editer_mot.php @ 93645

Last change on this file since 93645 was 93645, checked in by marcimat@…, 5 years ago

Meilleure compatibilité avec PSR-2 et nos règles d'écriture, en appliquant
différents fix avec php-cs-fixers. Fixers appliqués ici :

'encoding', utf8
'eof_ending',
un saut de ligne en fin de fichier
'elseif', elseif plutôt que else if
'function_call_space',
espaces sur fonctions
'function_declaration', espaces sur fonctions
'function_typehint_space',
espaces sur fonctions
'linefeed', sauts de ligne \n uniquement
'lowercase_constants',
true, false, null en munuscule
'lowercase_keywords', mots clés PHP en lowercase
'method_argument_space',
espaces sur appels de fonctions
'multiple_use', use unique sur fonctions anonymes
'newline_after_open_tag',
ouverture de php… et c'est tout sur cette ligne
'operators_spaces', espaces de part et d'autres des opérateurs binaires
'parenthesis',
pas d'espace juste après parenthèse ouvrante, ou avant parenthèse fermante
'php_closing_tag', pas de fermeture de php
'short_tag',
tag PHP corrects
'trailing_spaces', pas d'espace qui traîne en fin de ligne
'visibility',
déclarer 'public / private / protected' sur les méthodes

File size: 10.4 KB
Line 
1<?php
2
3/***************************************************************************\
4 *  SPIP, Systeme de publication pour l'internet                           *
5 *                                                                         *
6 *  Copyright (c) 2001-2015                                                *
7 *  Arnaud Martin, Antoine Pitrou, Philippe Riviere, Emmanuel Saint-James  *
8 *                                                                         *
9 *  Ce programme est un logiciel libre distribue sous licence GNU/GPL.     *
10 *  Pour plus de details voir le fichier COPYING.txt ou l'aide en ligne.   *
11\***************************************************************************/
12
13/**
14 * Gestion de l'action editer_mot
15 *
16 * @package SPIP\Mots\Actions
17 */
18if (!defined("_ECRIRE_INC_VERSION")) {
19        return;
20}
21
22include_spip('inc/filtres');
23
24/**
25 * Action d'édition d'un mot clé dans la base de données dont
26 * l'identifiant est donné en paramètre de cette fonction ou
27 * en argument de l'action sécurisée
28 *
29 * Si aucun identifiant n'est donné, on crée alors un nouveau mot clé.
30 *
31 * @param null|int $arg
32 *     Identifiant du mot-clé. En absence utilise l'argument
33 *     de l'action sécurisée.
34 * @return array
35 *     Liste (identifiant du mot clé, Texte d'erreur éventuel)
36 **/
37function action_editer_mot_dist($arg = null) {
38        if (is_null($arg)) {
39                $securiser_action = charger_fonction('securiser_action', 'inc');
40                $arg = $securiser_action();
41        }
42        $id_mot = intval($arg);
43
44        $id_groupe = intval(_request('id_groupe'));
45        if (!$id_mot and $id_groupe) {
46                $id_mot = mot_inserer($id_groupe);
47        }
48
49        // Enregistre l'envoi dans la BD
50        if ($id_mot > 0) {
51                $err = mot_modifier($id_mot);
52        }
53
54        return array($id_mot, $err);
55}
56
57/**
58 * Insertion d'un mot dans un groupe
59 *
60 * @pipeline_appel pre_insertion
61 * @pipeline_appel post_insertion
62 *
63 * @param int $id_groupe
64 *     Identifiant du groupe de mot
65 * @param array|null $set
66 * @return int|bool
67 *     Identifiant du nouveau mot clé, false si erreur.
68 */
69function mot_inserer($id_groupe, $set = null) {
70
71        $champs = array();
72        $row = sql_fetsel("titre", "spip_groupes_mots", "id_groupe=" . intval($id_groupe));
73        if ($row) {
74                $champs['id_groupe'] = $id_groupe;
75                $champs['type'] = $row['titre'];
76        } else {
77                return false;
78        }
79
80        if ($set) {
81                $champs = array_merge($champs, $set);
82        }
83
84        // Envoyer aux plugins
85        $champs = pipeline('pre_insertion',
86                array(
87                        'args' => array(
88                                'table' => 'spip_mots',
89                        ),
90                        'data' => $champs
91                )
92        );
93
94        $id_mot = sql_insertq("spip_mots", $champs);
95
96        pipeline('post_insertion',
97                array(
98                        'args' => array(
99                                'table' => 'spip_mots',
100                                'id_objet' => $id_mot
101                        ),
102                        'data' => $champs
103                )
104        );
105
106        return $id_mot;
107}
108
109/**
110 * Modifier un mot
111 *
112 * @param int $id_mot
113 *     Identifiant du mot clé à modifier
114 * @param array|null $set
115 *     Couples (colonne => valeur) de données à modifier.
116 *     En leur absence, on cherche les données dans les champs éditables
117 *     qui ont été postés (via _request())
118 * @return string|null
119 *     - Chaîne vide si aucune erreur,
120 *     - Null si aucun champ n'est à modifier,
121 *     - Chaîne contenant un texte d'erreur sinon.
122 */
123function mot_modifier($id_mot, $set = null) {
124        include_spip('inc/modifier');
125        $c = collecter_requests(
126        // white list
127                array(
128                        'titre',
129                        'descriptif',
130                        'texte',
131                        'id_groupe'
132                ),
133                // black list
134                array('id_groupe'),
135                // donnees eventuellement fournies
136                $set
137        );
138
139        if ($err = objet_modifier_champs('mot', $id_mot,
140                array(
141                        'data' => $set,
142                        'nonvide' => array('titre' => _T('info_sans_titre'))
143                ),
144                $c)
145        ) {
146                return $err;
147        }
148
149        $c = collecter_requests(array('id_groupe', 'type'), array(), $set);
150        $err = mot_instituer($id_mot, $c);
151
152        return $err;
153}
154
155/**
156 * Instituer un mot clé : modifier son groupe parent
157 *
158 * @pipeline_appel pre_insertion
159 * @pipeline_appel post_insertion
160 *
161 * @param int $id_mot
162 *     Identifiant du mot clé
163 * @param array $c
164 *     Couples (colonne => valeur) des données à instituer
165 * @return null|string
166 *     Null si aucun champ à modifier, chaîne vide sinon.
167 */
168function mot_instituer($id_mot, $c) {
169        $champs = array();
170        // regler le groupe
171        if (isset($c['id_groupe']) or isset($c['type'])) {
172                $row = sql_fetsel("titre", "spip_groupes_mots", "id_groupe=" . intval($c['id_groupe']));
173                if ($row) {
174                        $champs['id_groupe'] = $c['id_groupe'];
175                        $champs['type'] = $row['titre'];
176                }
177        }
178
179        // Envoyer aux plugins
180        $champs = pipeline('pre_edition',
181                array(
182                        'args' => array(
183                                'table' => 'spip_mots',
184                                'id_objet' => $id_mot,
185                                'action' => 'instituer',
186                        ),
187                        'data' => $champs
188                )
189        );
190
191        if (!$champs) {
192                return;
193        }
194
195        sql_updateq('spip_mots', $champs, "id_mot=" . intval($id_mot));
196
197        //
198        // Post-modifications
199        //
200
201        // Invalider les caches
202        include_spip('inc/invalideur');
203        suivre_invalideur("id='mot/$id_mot'");
204
205        // Pipeline
206        pipeline('post_edition',
207                array(
208                        'args' => array(
209                                'table' => 'spip_mots',
210                                'id_objet' => $id_mot,
211                                'action' => 'instituer',
212                        ),
213                        'data' => $champs
214                )
215        );
216
217        // Notifications
218        if ($notifications = charger_fonction('notifications', 'inc')) {
219                $notifications('instituermot', $id_mot,
220                        array('id_groupe' => $champs['id_groupe'])
221                );
222        }
223
224        return ''; // pas d'erreur
225}
226
227/**
228 * Supprimer un mot
229 *
230 * @pipeline_appel trig_supprimer_objets_lies
231 *
232 * @param int $id_mot
233 *     Identifiant du mot clé à supprimer
234 * @return void
235 */
236function mot_supprimer($id_mot) {
237        sql_delete("spip_mots", "id_mot=" . intval($id_mot));
238        mot_dissocier($id_mot, '*');
239        pipeline('trig_supprimer_objets_lies',
240                array(
241                        array('type' => 'mot', 'id' => $id_mot)
242                )
243        );
244}
245
246
247/**
248 * Associer un mot à des objets listés sous forme
249 * `array($objet=>$id_objets,...)`
250 *
251 * $id_objets peut lui-même être un scalaire ou un tableau pour une
252 * liste d'objets du même type
253 *
254 * On peut passer optionnellement une qualification du (des) lien(s) qui sera
255 * alors appliquée dans la foulée. En cas de lot de liens, c'est la
256 * même qualification qui est appliquée à tous.
257 *
258 * @example
259 *     ```
260 *     mot_associer(3, array('auteur'=>2));
261 *     // Ne fonctionnera pas ici car pas de champ 'vu' sur spip_mots_liens :
262 *     mot_associer(3, array('auteur'=>2), array('vu'=>'oui));
263 *     ```
264 *
265 * @param int $id_mot
266 *     Identifiant du mot à faire associer
267 * @param array $objets
268 *     Description des associations à faire
269 * @param array $qualif
270 *     Couples (colonne => valeur) de qualifications à faire appliquer
271 * @return int|bool
272 *     Nombre de modifications, false si erreur
273 */
274function mot_associer($id_mot, $objets, $qualif = null) {
275
276        include_spip('action/editer_liens');
277
278        // si il s'agit d'un groupe avec 'unseul', alors supprimer d'abord les autres
279        // mots de ce groupe associe a ces objets
280        $id_groupe = sql_getfetsel('id_groupe', 'spip_mots', 'id_mot=' . intval($id_mot));
281        if (un_seul_mot_dans_groupe($id_groupe)) {
282                $mots_groupe = sql_allfetsel("id_mot", "spip_mots", "id_groupe=" . intval($id_groupe));
283                $mots_groupe = array_map('reset', $mots_groupe);
284                objet_dissocier(array('mot' => $mots_groupe), $objets);
285        }
286
287        return objet_associer(array('mot' => $id_mot), $objets, $qualif);
288}
289
290
291/**
292 * Dissocier un mot des objets listés sous forme
293 * `array($objet=>$id_objets,...)`
294 *
295 * $id_objets peut lui-même être un scalaire ou un tableau pour une
296 * liste d'objets du même type
297 *
298 * un * pour $id_mot,$objet,$id_objet permet de traiter par lot
299 *
300 * @param int $id_mot
301 *     Identifiant du mot à faire dissocier
302 * @param array $objets
303 *     Description des dissociations à faire
304 * @return int|bool
305 *     Nombre de modifications, false si erreur
306 */
307function mot_dissocier($id_mot, $objets) {
308        include_spip('action/editer_liens');
309
310        return objet_dissocier(array('mot' => $id_mot), $objets);
311}
312
313/**
314 * Qualifier le lien d'un mot avec les objets listés
315 * `array($objet=>$id_objets,...)`
316 *
317 * $id_objets peut lui-même être un scalaire ou un tableau pour une
318 * liste d'objets du même type
319 *
320 * Une * pour $id_auteur,$objet,$id_objet permet de traiter par lot
321 *
322 * @example
323 *     ```
324 *     $c = array('vu'=>'oui');
325 *     ```
326 *
327 * @param int $id_mot
328 *     Identifiant du mot à faire associer
329 * @param array $objets
330 *     Description des associations à faire
331 * @param array $qualif
332 *     Couples (colonne => valeur) de qualifications à faire appliquer
333 * @return int|bool
334 *     Nombre de modifications, false si erreur
335 */
336function mot_qualifier($id_mot, $objets, $qualif) {
337        include_spip('action/editer_liens');
338
339        return objet_qualifier(array('mot' => $id_mot), $objets, $qualif);
340}
341
342
343/**
344 * Teste si un groupe ne doit avoir qu'un seul mot clé associé
345 *
346 * Renvoyer TRUE si le groupe de mot ne doit être associé qu'une fois aux objet
347 * (maximum un seul mot de ce groupe associé à chaque objet)
348 *
349 * @param int $id_groupe
350 *     Identifiant du groupe de mot clé
351 * @return bool
352 *     true si un seul mot doit être lié avec ce groupe, false sinon.
353 */
354function un_seul_mot_dans_groupe($id_groupe) {
355        return sql_countsel('spip_groupes_mots', "id_groupe=$id_groupe AND unseul='oui'");
356}
357
358
359// Fonctions Dépréciées
360// --------------------
361
362/**
363 * Insertion d'un mot dans un groupe
364 *
365 * @deprecated Utiliser mot_inserer()
366 * @see mot_inserer()
367 *
368 * @param int $id_groupe
369 *     Identifiant du groupe de mot
370 * @return int|bool
371 *     Identifiant du nouveau mot clé, false si erreur.
372 */
373function insert_mot($id_groupe) {
374        return mot_inserer($id_groupe);
375}
376
377/**
378 * Modifier un mot
379 *
380 * @deprecated Utiliser mot_modifier()
381 * @see mot_modifier()
382 *
383 * @param int $id_mot
384 *     Identifiant du mot clé à modifier
385 * @param array|null $set
386 *     Couples (colonne => valeur) de données à modifier.
387 *     En leur absence, on cherche les données dans les champs éditables
388 *     qui ont été postés
389 * @return string|null
390 *     - Chaîne vide si aucune erreur,
391 *     - Null si aucun champ à modifier,
392 *     - Chaîne contenant un texte d'erreur sinon.
393 */
394function mots_set($id_mot, $set = null) {
395        return mot_modifier($id_mot, $set);
396}
397
398/**
399 * Créer une révision d'un mot
400 *
401 * @deprecated Utiliser mot_modifier()
402 * @see mot_modifier()
403 *
404 * @param int $id_mot
405 *     Identifiant du mot clé à modifier
406 * @param array|null $c
407 *     Couples (colonne => valeur) de données à modifier.
408 *     En leur absence, on cherche les données dans les champs éditables
409 *     qui ont été postés
410 * @return string|null
411 *     - Chaîne vide si aucune erreur,
412 *     - Null si aucun champ à modifier,
413 *     - Chaîne contenant un texte d'erreur sinon.
414 */
415function revision_mot($id_mot, $c = false) {
416        return mot_modifier($id_mot, $c);
417}
Note: See TracBrowser for help on using the repository browser.