Nous allons définir un nouvel objet SPIP. Cet objet sera un « chat » ! Pourquoi pas ? Nous allons voir dans un premier temps comment créer la table SQL correspondante et donner un exemple de mise à jour. Nous décrirons ensuite la création d’une page de visualisation des chats, celle pour éditer un chat existant, et le formulaire CVT qui correspond. Enfin, nous ajouterons une action pour pouvoir supprimer un chat ! Et que la SPA ne m’en veuille pas trop, ce n’est qu’un exemple ! Et pour terminer, nous verrons comment interfacer le plugin « Champs Extras 2 » sur le nouvel objet !
Création du plugin
On commence par un fichier plugin.xml
rudimentaire. On déclare dedans cependant une information qui peut être utile : 1 dépendance, à SPIP 2.
<plugin>
<nom>Chats (plugin d'exemple)</nom>
<auteur>Matthieu Marcillaud</auteur>
<version>1.0</version>
<etat>stable</etat>
<description>
Ce plugin est un exemple de création
d'un nouvel objet éditorial dans SPIP
</description>
<lien>http://marcimat.magraine.net/?article344</lien>
<icon>images/chat-128.png</icon>
<prefix>chats</prefix>
<necessite id="SPIP" version="[2.0.9;]" />
</plugin>
Nous créons un premier dossier images
pour stocker les images relatives au plugin, et un dossier lang
pour stocker les traductions, avec un premier fichier dedans chats_fr.php
contenant quelques premiers mots :
<?php
// This is a SPIP language file -- Ceci est un fichier langue de SPIP
if (!defined("_ECRIRE_INC_VERSION")) return;
$GLOBALS[$GLOBALS['idx_lang']] = array(
// C
'chats' => 'Chats',
);
?>
Déclaration de la table spip_chats
Nous allons déclarer une table très simple « spip_chats » contenant les champs :
- id_chat
- race
- nom
- age
- maj (mise à jour)
Pour cela nous devons utiliser des pipelines adaptés : declarer_tables_principales
et declarer_tables_interfaces
. Nous ajoutons donc leur appel dans le fichier plugin.xml
:
<pipeline>
<nom>declarer_tables_interfaces</nom>
<inclure>base/chats.php</inclure>
</pipeline>
<pipeline>
<nom>declarer_tables_principales</nom>
<inclure>base/chats.php</inclure>
</pipeline>
Nous créons alors le fichier base/chats.php
contenant les fonctions qui seront appelés par les pipelines en question. Voici son contenu. La première fonction chats_declarer_tables_interfaces
indique que l’on peut utiliser le raccourcis « CHATS » comme table de boucle SPIP et que la balise #RACE
reçoit par défaut des traitements typographiques. La seconde fonction chats_declarer_tables_principales
déclare la table « spip_chats » et ses champs SQL associés.
<?php
function chats_declarer_tables_interfaces($interface){
$interface['table_des_tables']['chats'] = 'chats';
$interface['table_des_traitements']['RACE']['chats'] = _TRAITEMENT_TYPO;
return $interface;
}
function chats_declarer_tables_principales($tables_principales){
//-- Table CHATS ------------------------------------------
$chats = array(
"id_chat" => "bigint(21) NOT NULL",
"race" => "tinytext DEFAULT '' NOT NULL",
"nom" => "tinytext DEFAULT '' NOT NULL",
"annee_naissance" => "int(4) DEFAULT '0' NOT NULL",
"maj" => "TIMESTAMP"
);
$chats_key = array(
"PRIMARY KEY" => "id_chat",
);
$tables_principales['spip_chats'] =
array('field' => &$chats, 'key' => &$chats_key);
return $tables_principales;
}
?>
Installation/désinstallation de la table spip_chats
Pour gérer l’installation et la désinstallation, il faut indiquer un numéro de version des informations SQL du plugin ainsi qu’un fichier d’installation dans plugin.xml
:
<version_base>1.0</version_base>
<install>base/chats_upgrade.php</install>
Ce fichier base/chats_upgrade.php
contient deux fonctions :
-
chats_upgrade
sert à l’installation et aux mises à jour. Ici, à la première activation du plugin,$current_version
vaut encore "0.0" et la fonction creer_base() est executée. Cette fonction crée les tables SQL déclarées à SPIP mais absentes de la base de donnée. Par conséquent, la tablespip_chats
sera créée ; -
chats_vider_tables
sert pour la désinstallation. Elle supprime simplement la table SQLspip_chats
ainsi que la variable meta contenant le numéro de version SQL installé du plugin.
<?php
include_spip('inc/meta');
include_spip('base/create');
function chats_upgrade($nom_meta_base_version, $version_cible){
$current_version = "0.0";
if (isset($GLOBALS['meta'][$nom_meta_base_version]))
$current_version = $GLOBALS['meta'][$nom_meta_base_version];
if ($current_version=="0.0") {
creer_base();
ecrire_meta($nom_meta_base_version, $current_version=$version_cible);
}
}
function chats_vider_tables($nom_meta_base_version) {
sql_drop_table("spip_chats");
effacer_meta($nom_meta_base_version);
}
?>
Mise à jour de la table
Mince ! Nous avons oublié les champs « robe » et « infos » ! Mettons à jour le plugin :
- on ajoute la déclaration des champs dans
base/chats.php
("robe" => "tinytext DEFAULT '' NOT NULL",
et"infos" => "text DEFAULT '' NOT NULL",
au dessus de « maj ») ; - on modifie la version SQL du plugin dans
plugin.xml
(<version_base>1.1</version_base>
) ; - on crée une mise à jour dans la fonction
chats_upgrade()
debase/chats_upgrade.php
qui devient :
function chats_upgrade($nom_meta_base_version, $version_cible){
$current_version = "0.0";
if ($current_version=="0.0") {
creer_base();
ecrire_meta($nom_meta_base_version, $current_version=$version_cible);
}
if (version_compare($current_version,"1.1","<")){
// ajout du champ "robe" et "infos"
maj_tables('spip_chats');
ecrire_meta($nom_meta_base_version,$current_version="1.1");
}
}
On remarque que l’on teste si la version des tables SQL du plugin est inférieur à la nouvelle version renseignée dans plugin.xml
. Si c’est le cas, on lance la fonction maj_tables('spip_chats')
qui va créer tous les champs manquant de la table désignée. Cette fonction ne fait qu’ajouter des champs, en aucun cas elle ne supprime ou modifie des champs existants. Pour des opérations plus complexes, il faut utiliser les fonctions sql_*
adaptées, tel que sql_alter()
.
Création du bouton pour accéder à la liste des chats
Commençons par créer un bouton dans le menu d’édition pour amener à la page qui listera les chats. On ajoute au plugin.xml
la déclaration suivante d’un bouton, ainsi que l’usage du pipelines d’autorisations :
<bouton id='chats' parent='naviguer'>
<icone>images/chat-24.png</icone>
<titre>chats:chats</titre>
</bouton>
<pipeline>
<nom>autoriser</nom>
<inclure>chats_autorisations.php</inclure>
</pipeline>
Le bouton indique que l’on crée un lien vers la page ?exec=chats
(indiquée par l’attribut id
) dans le menu « Édition » de SPIP. A chaque bouton est associé une autorisation de le voir. Nous créons donc le fichier chats_autorisations.php
pour déclarer cette fonction (autoriser_chats_bouton_dist
) :
<?php
if (!defined("_ECRIRE_INC_VERSION")) return;
// fonction pour le pipeline, n'a rien a effectuer
function chats_autoriser(){}
// declarations d'autorisations
function autoriser_chats_bouton_dist($faire, $type, $id, $qui, $opt) {
return autoriser('voir', 'chats', $id, $qui, $opt);
}
function autoriser_chats_voir_dist($faire, $type, $id, $qui, $opt) {
return true;
}
?>
-
- Bouton d’accès aux Chats
Création d’une page privée pour lister les chats
Nous créons alors le fichier prive/exec/chats.html
. Il liste les chats présents et propose des actions pour « voir », « modifier » ou « supprimer » chaque chat. Dans la colonne de navigation, une description du plugin ainsi qu’un lien pour créer un nouveau chat est présent. Le filtre icone
utilisé qui facilite la création d’icone en squelette provient du plugin « spip_bonux ». Nous devons donc ajouter cette dépendance dans le fichier plugin.xml
. De nouvelles autorisations permettent de gérer l’affichage des actions possibles, il faut aussi les renseigner.
Le fichier ne doit retourner aucun contenu si le visiteur n’a pas le droit de voir cette page. On place donc la même autorisation que pour le bouton du menu qui conditionne l’affichage du contenu. Dedans, une inclusion appelle une boucle sur la table chats.
[(#AUTORISER{voir, chats})
<h1><:chats:liste_des_chats:></h1>
<div class='ajax'>
<INCLURE{fond=inclure/liste_chats,env,ajax} />
</div>
<!--#navigation-->
<div class='cadre cadre-info'>
<p><:chats:description_chats:></p>
[(#AUTORISER{modifier, chat})
[(#URL_ECRIRE{chat_edit}
|parametre_url{new,oui}
|icone{<:chats:action_ajouter:>, #CHEMIN{images/chat-24.png}, center, creer.gif})]
]
</div>
<!--/#navigation-->
]
Contenu de inclure/liste_chats.html
:
<B_chats>
<table class='chats spip'>
<thead>
<tr>
<th><:chats:label_id:></th>
<th><:chats:label_nom:></th>
<th><:chats:label_race:></th>
<th><:chats:label_robe:></th>
<th><:chats:label_annee_naissance:></td>
<th><:chats:label_actions:></td>
</tr>
</thead>
<tbody>
<BOUCLE_chats(CHATS){par nom}{pagination 10}>
<tr class="[(#COMPTEUR_BOUCLE|alterner{row_odd,row_even})]">
<td>#ID_CHAT</td>
<td>#NOM</td>
<td>#RACE</td>
<td>#ROBE</td>
[(#SET{nb,[(#DATE{Y}|moins{#ANNEE_NAISSANCE})]})]
<td>[(#ANNEE_NAISSANCE|oui)<:chats:nb_ans{nb=#GET{nb}}:>]</td>
<td>
[(#AUTORISER{voir,chat,#ID_CHAT})
<a href='[(#URL_ECRIRE{chat_voir}|parametre_url{id_chat,#ID_CHAT})]'><:chats:action_voir:></a>
]
[(#AUTORISER{modifier,chat,#ID_CHAT})
|
<a href='[(#URL_ECRIRE{chat_edit}|parametre_url{id_chat,#ID_CHAT})]'><:chats:action_modifier:></a>
|
<a href='[(#URL_ACTION_AUTEUR{supprimer_chat,#ID_CHAT,#SELF})]'><:chats:action_supprimer:></a>
]
</td>
</tr>
</BOUCLE_chats>
</tbody>
</table>
[<p class='pagination'>(#PAGINATION)</p>]
</B_chats>
Les autorisations correspondantes sont ajoutées au fichier chats_autorisations.php
:
function autoriser_chat_voir_dist($faire, $type, $id, $qui, $opt) {
return autoriser('modifier', 'chat', $id, $qui, $opt);
}
function autoriser_chat_modifier_dist($faire, $type, $id, $qui, $opt) {
return in_array($qui['statut'], array('0minirezo', '1comite'));
}
-
- Liste des chats
Création d’une page privée pour voir un chat
Nous cherchons maintenant à afficher une page, nommée « chat_voir » qui détaille un chat. On va créer pour cela 3 fichiers :
-
prive/exec/chat_voir.html
gère l’ensemble de la page, -
prive/contenu/chat.html
, s’occupe simplement du contenu à afficher au centre et -
prive/infos/chat.html
décrit l’objet dans la colonne gauche.
Code de prive/exec/chat_voir.html
. Comme précédemment, une autorisation teste si on a le droit d’acceder au contenu. Ici, on utilise la boucle CONDITION du plugin « spip_bonux » pour pouvoir insérer des boucles dans la condition. En l’occurrence une boucle sur le chat sélectionné.
Un lien pour modifier ansi que le titre sont affichés avant d’appeler le fichier affichant le contenu ([(#INCLURE{fond=prive/contenu/chat,id=#ID_CHAT})]
) dont tout le contenu est envoyé au pipeline « afficher_contenu_objet » (qui servira notamment au plugin « Champs Extras »).
Enfin, dans la navigation, on appelle le pipeline « boite_infos » ; c’est lui qui chargera le fichier prive/infos/chat.html
.
<BOUCLE_si_autorise(CONDITION){si (#ID_CHAT|intval|et{#AUTORISER{voir,chat,#ID_CHAT}})}>
<BOUCLE_chat(CHATS){id_chat}{tout}>
<div class='fiche_objet'>
[(#AUTORISER{modifier,chat,#ID_CHAT})
<div class='bandeau_actions'>
[(#URL_ECRIRE{chat_edit}
|parametre_url{id_chat,#ID_CHAT}
|parametre_url{retour,#SELF}
|icone{<:chats:action_modifier:>, #CHEMIN{images/chat-24.png}, #LANG_RIGHT, edit.gif})]
</div>
]
<h1>#NOM</h1>
<div id='wysiwyg'>
[(#PIPELINE{afficher_contenu_objet,[(#ARRAY{
args,[(#ARRAY{
type,chat,
id_objet,#ID_CHAT,
contexte,[(#ARRAY{
id_chat,#ID_CHAT})]})],
data,[(#INCLURE{fond=prive/contenu/chat,id=#ID_CHAT})]})]})]
</div>
</div>
<!--#navigation-->
[(#REM) Ce pipeline charge prive/infos/$type ]
[<div class='cadre cadre-info'>
(#PIPELINE{boite_infos,[(#ARRAY{
args,[(#ARRAY{
type,chat,
id,#ID_CHAT})],
data,''})]})
</div>]
<!--/#navigation-->
</BOUCLE_chat>
</BOUCLE_si_autorise>
Le second fichier prive/contenu/chat.html
affiche le contenu du chat et se présente comme une liste de champs à afficher. C’est le même code répété pour chaque champ (pour notre exemple) :
<BOUCLE_afficher_contenu(CHATS){id_chat=#ENV{id}}{tout}>
<div class="champ contenu_nom[ (#NOM*|strlen|?{'',vide})]">
<div class='label'><:chats:label_nom:></div>
<div dir='#LANG_DIR' class='#EDIT{nom} nom'>#NOM</div>
</div>
<div class="champ contenu_race[ (#RACE*|strlen|?{'',vide})]">
<div class='label'><:chats:label_race:></div>
<div dir='#LANG_DIR' class='#EDIT{race} race'>#RACE</div>
</div>
<div class="champ contenu_robe[ (#ROBE*|strlen|?{'',vide})]">
<div class='label'><:chats:label_robe:></div>
<div dir='#LANG_DIR' class='#EDIT{robe} robe'>#ROBE</div>
</div>
<div class="champ contenu_annee_naissance[ (#ANNEE_NAISSANCE*|strlen|?{'',vide})]">
<div class='label'><:chats:label_annee_naissance:></div>
<div dir='#LANG_DIR' class='#EDIT{annee_naissance} annee_naissance'>#ANNEE_NAISSANCE</div>
</div>
<div class="champ contenu_infos[ (#INFOS*|strlen|?{'',vide})]">
<div class='label'><:chats:label_infos:></div>
<div dir='#LANG_DIR' class='#EDIT{infos} infos'>#INFOS</div>
</div>
</BOUCLE_afficher_contenu>
Le dernier fichier prive/infos/chat.html
décrit quelques statistiques des objets. Ici rien d’intéressant ne nous concerne, on affiche simplement l’identifiant du chat :
<BOUCLE_chat_info(CHATS){id_chat=#ENV{id}}{tout}>
<div class='infos'>
<div class='numero'>
<:chats:info_gauche_numero_chat:>
<p>#ID_CHAT</p>
</div>
</div>
</BOUCLE_chat_info>
- Vue du chat
Création d’une page privée pour ajouter ou modifier un chat
Nous créons pour cela 2 fichiers :
-
prive/exec/chat_edit.html
gère l’affichage de l’ensemble de la page et appelle le fichier suivant -
prive/editer/chat.html
charge le formulaire. On pourrait cela dit mettre l’intégralité de ce fichier dans le premier. Cette inclusion est simplement là pour reprendre le même schéma que le core de SPIP.
Le code le prive/exec/chat_edit.html
calcule une icone de retour (pour revenir en arrière sans valider le formulaire), et un titre, puis appelle l’inclusion avec ces valeurs.
#CACHE{0}
[(#SET{id_chat,#ENV{id_chat,#ENV{new,oui}}})]
<BOUCLE_si_autorise(CONDITION){si (#AUTORISER{modifier,chat,#GET{id_chat}})}>
[(#SET{retour, #URL_ECRIRE{chats}})]
<BOUCLE_titre(CHATS){id_chat=#GET{id_chat}}{tout}>
[(#SET{titre, #NOM})]
[(#SET{retour, [(#URL_ECRIRE{chat_voir}|parametre_url{id_chat,#ID_CHAT})]})]
</BOUCLE_titre>
[(#INCLURE{fond=prive/editer/chat,
id_chat=#GET{id_chat},
icone_retour=[(#ENV{retour,#GET{retour}}
|icone{<:icone_retour:>, #CHEMIN{images/chat-24.png}, #LANG_LEFT })],
titre=#GET{titre}
})]
</BOUCLE_si_autorise>
Le second fichier, prive/editer/chat.html
affiche l’icone, le titre, et appelle le formulaire d’édition CVT.
<div class='cadre-formulaire-editer'>
<div class="entete-formulaire">
#ENV**{icone_retour}
[<:chats:info_modifier_chat:>
<h1>(#ENV{titre,<:chats:texte_nouveau_chat:>})</h1>]
</div>
#FORMULAIRE_EDITER_CHAT{#ENV{new},#ENV{redirect}}
</div>
Création du formulaire CVT d’édition
Nous créons 3 fichiers en tout :
-
formulaires/editer_chat.html
contenant le HTML du formulaire, -
formulaires/editer_chat.php
contenant les 3 fonctions Charger, Vérifier et Traiter, mais qui appellent simplement des fonctions SPIP génériques, -
action/editer_chat.php
qui contient le traitement du formulaire.
Le code HTML du formulaire CVT, utilise ici la balise #SAISIE du plugin « saisies » simplement pour se simplifier l’écriture (Oui je sais, y l’heure actuelle ce plugin n’est pas documenté !). Le fichier formulaires/editer_chat.html
contient :
<div class='formulaire_spip formulaire_editer formulaire_#FORM formulaire_#FORM-#ENV{id_chat,nouveau}'>
[<p class="reponse_formulaire reponse_formulaire_ok">(#ENV**{message_ok})</p>]
[<p class="reponse_formulaire reponse_formulaire_erreur">(#ENV*{message_erreur})</p>]
[(#ENV{editable}|oui)
<form method='post' action='#ENV{action}'><div>
#ACTION_FORMULAIRE{#ENV{action}}
<input type='hidden' name='id_chat' value='#ENV{id_chat}' />
<ul class='editer-groupe'>
[(#SAISIE{input, nom,
label=<:chats:label_nom:>,
obligatoire=oui})]
[(#SAISIE{input, race,
label=<:chats:label_race:>})]
[(#SAISIE{input, robe,
label=<:chats:label_robe:>,
size=4})]
[(#SAISIE{input, annee_naissance,
label=<:chats:label_annee_naissance:>,
size=4})]
[(#SAISIE{textarea, infos,
label=<:chats:label_infos:>,
explication=<:chats:explication_infos:>})]
</ul>
[(#REM) ajouter les saisies supplementaires : extra et autre, a cet endroit ]
<!--extra-->
<p class="boutons"><input type='submit' class='submit' value='<:bouton_enregistrer:>' /></p>
</div></form>
]
</div>
-
- Edition d’un chat
Le fichier PHP correspondant formulaires/editer_chat.php
quant à lui contient :
<?php
if (!defined("_ECRIRE_INC_VERSION")) return;
include_spip('inc/actions');
include_spip('inc/editer');
function formulaires_editer_chat_charger_dist($id_chat='new', $retour=''){
$valeurs = formulaires_editer_objet_charger('chat', $id_chat, '', '', $retour, '');
return $valeurs;
}
function formulaires_editer_chat_verifier_dist($id_chat='new', $retour=''){
$erreurs = formulaires_editer_objet_verifier('chat', $id_chat, array('nom'));
return $erreurs;
}
function formulaires_editer_chat_traiter_dist($id_chat='new', $retour=''){
return formulaires_editer_objet_traiter('chat', $id_chat, '', '', $retour, '');
}
?>
Les fonctions génériques formulaires_editer_objet_$action()
ont des arguments prédéfinis. Certains nous sont inutiles et nous mettons simplement une chaine vide ''
à la place. Les deux premières fonctions (charger et vérifier) peuvent être complètement prises en charge sans rien faire de plus (si nous n’avons pas de besoins particuliers). Seule la fonction traiter nécessite de créer une action de traitement, dans un fichier action/editer_chat.php
.
Ce dernier fichier contient 3 fonctions :
-
action_editer_chat_dist()
verifie l’argument, appelleinsert_chat()
si on a besoin d’un nouveau chat, puis appellerevisions_chats($id_chat)
qui va appliquer les modifications. -
insert_chat()
crée un nouvel enregistrement de chat, en appelant juste avant le pipeline « pre_insertion ». -
revisions_chats($id_chat)
, récupère les champs postés du formulaire, puis appelle la fonction générique « modifier_contenu » en passant le nom de la table, l’identifiant, et les champs à modifier. Cette fonction appellera automatiquement les pipelines « pre_edition » et « post_edition ». Peu connu, on peut aussi lui passer en paramètre d’option la clé pour invalider le cache en même temps.
Voici le contenu de ce fichier :
<?php
if (!defined("_ECRIRE_INC_VERSION")) return;
function action_editer_chat_dist() {
$securiser_action = charger_fonction('securiser_action', 'inc');
$arg = $securiser_action();
// pas de chat ? on en cree un nouveau, mais seulement si 'oui' en argument.
if (!$id_chat = intval($arg)) {
if ($arg != 'oui') {
include_spip('inc/headers');
redirige_url_ecrire();
}
$id_chat = insert_chat();
}
if ($id_chat) $err = revisions_chats($id_chat);
return array($id_chat,$err);
}
function insert_chat() {
$champs = array(
'nom' => _T('chats:item_nouveau_chat')
);
// Envoyer aux plugins
$champs = pipeline('pre_insertion', array(
'args' => array(
'table' => 'spip_chats',
),
'data' => $champs
));
$id_chat = sql_insertq("spip_chats", $champs);
return $id_chat;
}
// Enregistrer certaines modifications d'un chat
function revisions_chats($id_chat, $c=false) {
// recuperer les champs dans POST s'ils ne sont pas transmis
if ($c === false) {
$c = array();
foreach (array('nom', 'race', 'robe', 'annee_naissance', 'infos') as $champ) {
if (($a = _request($champ)) !== null) {
$c[$champ] = $a;
}
}
}
include_spip('inc/modifier');
modifier_contenu('chat', $id_chat, array(
'nonvide' => array('nom' => _T('info_sans_titre')),
'invalideur' => "id='id_chat/$id_chat'"
),
$c);
}
?>
Création de l’action de suppression
L’action de suppression nécessite de créer un fichier action/supprimer_chat.php
qui va réaliser la suppression après avoir vérifié que l’argument attendu est correct.
<?php
if (!defined("_ECRIRE_INC_VERSION")) return;
function action_supprimer_chat_dist() {
$securiser_action = charger_fonction('securiser_action', 'inc');
$arg = $securiser_action();
if (!preg_match(",^(\d+)$,", $arg, $r)) {
spip_log("action_supprimer_chat_dist $arg pas compris");
} else {
action_supprimer_chat_post($r[1]);
}
}
function action_supprimer_chat_post($id_chat) {
sql_delete("spip_chats", "id_chat=" . sql_quote($id_chat));
include_spip('inc/invalideur');
suivre_invalideur("id='id_chat/$id_chat'");
}
?>
Interface avec « Champs Extras 2 »
Figurez-vous que c’est le plus simple maintenant, car notre objet CHAT traverse tous les pipelines qu’il faut pour que Champs Extras insère de nouveaux champs à cet objet.
Il suffit donc de déclarer à Champs Extras que l’objet Chat peut-être utilisé. Pour cela, on déclare utiliser un pipeline dans plugin.xml
, et l’on crée un fichier chats_pipelines.php
pour accueillir la fonction correspondante.
plugin.xml
:
<!-- avec plugin champs extras 2 -->
<pipeline>
<nom>objets_extensibles</nom>
<inclure>chats_pipelines.php</inclure>
</pipeline>
chats_pipelines.php
:
<?php
function chats_objets_extensibles($objets){
return array_merge($objets, array('chat' => _T('chats:chats')));
}
?>
-
- Champs Extras des Chats
- Liste des champs extras déclarés.
-
- Edition d’un chat avec extras
- Vue du chat avec extra
Conclusions
Cet objet « Chat » très sommaire montre que réaliser l’interface et l’outil de modification nécessite encore beaucoup de code et de squelettes SPIP. Cependant, créer un nouvel objet est possible et de nombreuses fonctions de l’API de SPIP 2.0 permettent un gain de temps appréciable.
Le chemin parcouru par SPIP en quelques temps est bien visible mais il reste encore des outils qui mériteraient d’être simplifiées et améliorées, comme créer une fonction inserer_contenu($objet, $champs)
pour la création d’éléments, ou encore $c = recuperer_champs_post($noms)
. Je n’ai pas réussi, sans chercher non plus, si on avait un moyen de créer un fil d’ariane sur les pages exec en squelette, mais je n’ai pas ce souvenir.
Tout cela m’a entre autre permis de distinguer qu’un plugin « Tables Extras » est difficilement envisageable encore sans faire écrire du code, mais en même temps que des parties pourraient se réaliser automatiquement.