Créer un nouvel objet éditorial A pas de chat…

, par Matthieu Marcillaud

| 50

Nous allons étudier comment créer un nouvel objet éditorial très simple et sans relation, pour SPIP 2.0. De ces explications vont naître un petit plugin d’exemple. Mais le tout fait appel à un grand nombre de fonctions de SPIP et n’est pas évident à mettre en œuvre. Nous en profitons pour relever un défi : aucun affichage géré en PHP, mais tout en squelette SPIP.

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&eacute;ation
		d'un nouvel objet &eacute;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 table spip_chats sera créée ;
  • chats_vider_tables sert pour la désinstallation. Elle supprime simplement la table SQL spip_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() de base/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, appelle insert_chat() si on a besoin d’un nouveau chat, puis appelle revisions_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.