Últimas publicaciones
Tutorial Un module qui parle toutes les langues du site : « Astuces » 3.0
Niveau expert · environ 2 heures · NeoFrag Reborn 1.2.50 ou plus récent
À l'intermédiaire, une astuce s'écrivait une fois, en français, et tous les visiteurs la lisaient ainsi. Ce tutoriel termine le module :
- chaque astuce s'écrit dans chaque langue du site, depuis l'administration. Le visiteur la lit dans sa langue ; si elle n'y est pas encore écrite, il la lit dans une autre, et un bandeau le lui dit ;
- les astuces entrent dans la recherche du site et dans son plan (
sitemap.xml), celui que lisent les moteurs de recherche ; - chaque astuce garde son auteur et reçoit des réactions, qui le préviennent.
En chemin, une leçon sur les migrations qu'on n'apprend qu'à la deuxième mise à jour.





Il te faut le module d'« Astuces » 2.0 (ou son archive, astuces-2.0.0.zip), installé sur un site d'essai. La
mise à jour marche aussi depuis la 1.0 : l'étape 2 explique comment. L'archive de ce tutoriel, astuces-3.0.0.zip,
est jointe à ce sujet.
Ce qui change dans le dossier
astuces-3.0.0/
├── modules/
│ └── astuces/
│ ├── astuces.php la version 3.0.0, et ce que le module apporte aux autres
│ ├── install/
│ │ ├── install.sql deux tables : l'astuce, et son texte dans chaque langue
│ │ ├── uninstall.sql
│ │ └── migrations/
│ │ ├── 2026_10_15_astuces_du_code.up.sql réécrite (étape 2)
│ │ └── 2026_10_16_astuces_traduites.up.sql nouvelle : le texte passe dans la table des langues
│ ├── models/
│ │ └── astuces.php nouveau : lire une astuce dans la bonne langue
│ ├── controllers/
│ │ ├── checker.php, index.php la page d'une astuce : son auteur, ses réactions
│ │ ├── admin_checker.php, admin.php écrire dans la langue de l'administration
│ │ ├── search.php nouveau : la recherche du site
│ │ └── sitemap.php nouveau : le plan du site
│ └── views/, css/, langs/, images/
└── widgets/
└── astuces/ « Astuce du jour », qui lit maintenant la table des langues
Étape 1 — Une table par langue
astuces/install/install.sql
-- Les tables du module Astuces. Ce fichier est joué à l'installation, et de nouveau à chaque mise à jour, AVANT les
-- migrations : « IF NOT EXISTS » ne crée que ce qui manque, et ne touche jamais à une table déjà là.
-- Il décrit toujours le schéma de la DERNIÈRE version : une installation neuve n'a que lui.
CREATE TABLE IF NOT EXISTS `nf_astuces` (
`id` int(10) unsigned NOT NULL AUTO_INCREMENT,
`user_id` int(11) unsigned DEFAULT NULL,
`published` tinyint(1) NOT NULL DEFAULT 1,
`sort_order` int(11) NOT NULL DEFAULT 0,
`created_at` timestamp NOT NULL DEFAULT current_timestamp(),
PRIMARY KEY (`id`),
KEY `user_id` (`user_id`),
CONSTRAINT `nf_astuces_auteur` FOREIGN KEY (`user_id`) REFERENCES `nf_user` (`id`) ON DELETE SET NULL
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
-- Le titre et le texte, une ligne par langue écrite.
CREATE TABLE IF NOT EXISTS `nf_astuces_lang` (
`astuce_id` int(10) unsigned NOT NULL,
`lang` varchar(5) NOT NULL,
`title` varchar(150) NOT NULL,
`content` text NOT NULL,
PRIMARY KEY (`astuce_id`, `lang`),
CONSTRAINT `nf_astuces_lang_astuce` FOREIGN KEY (`astuce_id`) REFERENCES `nf_astuces` (`id`) ON DELETE CASCADE
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_unicode_ci;
Une astuce se coupe en deux :
nf_astucesgarde ce qui ne dépend pas de la langue : la publication, l'ordre, la date, et maintenant l'auteur (user_id).nf_astuces_langgarde le titre et le texte, une ligne par langue écrite. Sa clé,(astuce_id, lang), interdit deux versions françaises d'une même astuce.
Les deux clés étrangères font le ménage à la place du code :
ON DELETE CASCADE: supprimer une astuce supprime ses versions dans toutes les langues.ON DELETE SET NULL: supprimer un membre laisse ses astuces en place, sans auteur.
nf_astuces_lang dépend de nf_astuces : la désinstallation l'efface donc en premier.
astuces/install/uninstall.sql
-- Désinstaller le module efface ses astuces, et leurs traductions d'abord : elles dépendent d'elles.
DROP TABLE IF EXISTS `nf_astuces_lang`;
DROP TABLE IF EXISTS `nf_astuces`;
Étape 2 — Deux migrations, et l'ordre dans lequel le site les joue
Une mise à jour fait deux choses, dans cet ordre :
- elle rejoue
install.sql, qui crée les tables qui manquent ; - elle joue les migrations que ce site n'a pas encore jouées, dans l'ordre de leur nom.
Le site retient les migrations jouées par leur nom. Une installation neuve les marque toutes comme jouées, sans
les jouer : install.sql lui donne déjà les tables de la dernière version.
La nouvelle migration verse le titre et le texte de chaque astuce dans nf_astuces_lang, en français, puisque
c'était leur langue. Elle retire ensuite les deux colonnes devenues inutiles, et ajoute l'auteur :
astuces/install/migrations/2026_10_16_astuces_traduites.up.sql
-- 3.0 : le titre et le texte d'une astuce passent dans nf_astuces_lang, une ligne par langue, et l'astuce retient son
-- auteur. install.sql, joué juste avant, a déjà créé nf_astuces_lang.
--
-- Deux sites arrivent ici. Celui qui était en 2.0 a ses astuces dans nf_astuces.title et nf_astuces.content. Celui
-- qui était en 1.0 a reçu les tables de la 3.0 : ces deux colonnes n'y sont pas, et la migration précédente a déjà
-- tout écrit. On les ajoute si elles manquent, pour que la copie et la suppression qui suivent marchent dans les deux.
ALTER TABLE `nf_astuces`
ADD COLUMN IF NOT EXISTS `title` varchar(150) NOT NULL DEFAULT '',
ADD COLUMN IF NOT EXISTS `content` text NOT NULL DEFAULT '';
-- Ce qui était écrit l'était en français.
INSERT IGNORE INTO `nf_astuces_lang` (`astuce_id`, `lang`, `title`, `content`)
SELECT `id`, 'fr', `title`, `content` FROM `nf_astuces` WHERE `title` <> '';
ALTER TABLE `nf_astuces`
DROP COLUMN `title`,
DROP COLUMN `content`,
ADD COLUMN IF NOT EXISTS `user_id` int(11) unsigned DEFAULT NULL AFTER `id`,
ADD KEY IF NOT EXISTS `user_id` (`user_id`),
ADD CONSTRAINT `nf_astuces_auteur` FOREIGN KEY IF NOT EXISTS (`user_id`) REFERENCES `nf_user` (`id`) ON DELETE SET NULL;
Pourquoi ce ADD COLUMN IF NOT EXISTS au début, pour des colonnes que la 2.0 avait déjà ? Parce que deux sites
différents arrivent à cette migration :
| Le site avait | install.sql de la 3.0 crée |
Migrations jouées |
|---|---|---|
| rien (installation neuve) | les deux tables | aucune : marquées comme jouées |
| la 2.0 | nf_astuces_lang (nf_astuces existe déjà, avec title et content) |
la nouvelle seulement |
| la 1.0 | les deux tables de la 3.0, sans title ni content |
celle de la 2.0, puis la nouvelle |
La dernière ligne est le piège. Un site qui passe directement de la 1.0 à la 3.0 joue d'abord la migration de la
2.0, mais sur les tables de la 3.0. Telle que la 2.0 l'avait écrite, elle versait les astuces dans
nf_astuces.title : cette colonne n'existe pas, la migration échoue, et le site s'arrête là.
La règle à retenir : une migration rencontre les tables du dernier install.sql, pas celles de sa version.
Quand le schéma change, les anciennes migrations qui écrivent des données se réécrivent pour le nouveau. Un site qui
les a déjà jouées ne les rejoue pas : il les reconnaît à leur nom. Ne renomme donc jamais une migration : sous un
autre nom, elle serait jouée une seconde fois.
astuces/install/migrations/2026_10_15_astuces_du_code.up.sql
-- Les quatre astuces que la version 1.0 écrivait dans son code passent dans les tables. Cette migration ne joue qu'à
-- la MISE À JOUR depuis la 1.0 : une installation neuve la marque comme faite sans la jouer, et commence vide.
--
-- Réécrite pour la 3.0. Une mise à jour joue install.sql AVANT les migrations : un site qui passe de la 1.0 à la 3.0
-- trouve donc déjà les tables de la 3.0, où le titre et le texte vivent dans nf_astuces_lang. Un site en 2.0 l'a
-- déjà jouée, sous son ancienne forme : le site retient les migrations faites par leur nom, et ne la rejoue pas.
INSERT INTO `nf_astuces` (`id`, `sort_order`) VALUES (1, 1), (2, 2), (3, 3), (4, 4);
INSERT INTO `nf_astuces_lang` (`astuce_id`, `lang`, `title`, `content`) VALUES
(1, 'fr', 'Complète ton profil', 'Un avatar et quelques mots sur toi : les autres membres savent à qui ils parlent.'),
(2, 'fr', 'Suis les sujets qui t''intéressent', 'Suivre un sujet du forum te prévient de chaque nouvelle réponse.'),
(3, 'fr', 'Change la langue du site', 'Le sélecteur du pied de page affiche le site dans ta langue, pour toi seul.'),
(4, 'fr', 'Choisis ce que ton profil montre', 'Dans ton espace membre, tu décides de ce que les autres voient de toi, comme ton âge ou ta présence en ligne.');
Les numéros sont donnés (1 à 4) : la table est neuve sur ce chemin, et chaque version doit savoir à quelle astuce
elle appartient.
En écrivant ce tutoriel, cette mise à jour a révélé un défaut du site lui-même : jusqu'à la version 1.2.49, une mise à jour d'addon rejouait toutes ses migrations, au lieu des seules nouvelles. Il est corrigé en 1.2.50 : c'est pour cela que le module la demande.
Étape 3 — Lire dans la bonne langue : le modèle
Les lectures du module passent dans un modèle, models/astuces.php. Un contrôleur le charge avec
$this->model().
astuces/models/astuces.php
<?php
declare(strict_types=1);
namespace NF\Modules\Astuces\Models;
use NF\NeoFrag\Loadables\Model;
class Astuces extends Model
{
/**
* Les astuces publiées, dans l'ordre choisi dans l'administration, chacune dans la meilleure langue :
* celle du visiteur, sinon le français, sinon celle qui existe.
*/
public function publiees(): array
{
return $this->db->select('a.id', 'a.created_at', 'al.title', 'al.content')
->from('nf_astuces a')
->join_lang('nf_astuces_lang al', 'astuce_id', 'a.id', NULL, 'INNER')
->where('a.published', 1)
->order_by('a.sort_order ASC, a.id ASC')
->get();
}
/**
* Une astuce publiée et son auteur, ou NULL. `langue_du_contenu()` choisit la langue où la servir, et dit au
* site dans quelles langues elle existe : il n'annonce qu'elles aux moteurs, et quand il sert une autre
* langue que celle demandée, il le dit au visiteur par un bandeau.
*/
public function astuce(int $id): ?array
{
$langue = $this->langue_du_contenu('nf_astuces_lang', 'astuce_id', $id);
$astuce = $this->db ->select('a.id', 'al.title', 'al.content', 'u.id AS user_id', 'u.username')
->from('nf_astuces a')
->join('nf_astuces_lang al', 'al.astuce_id = a.id', 'INNER')
->join('nf_user u', 'u.id = a.user_id AND u.deleted = "0"', 'LEFT')
->where('a.id', $id)
->where('a.published', 1)
->where('al.lang', $langue)
->row();
return $astuce ?: NULL;
}
}
Deux outils du site, selon ce qu'on lit :
join_lang()joint la meilleure version de chaque ligne : celle de la langue du visiteur, sinon le français, sinon la première qui existe. C'est l'outil des listes. Avec'INNER', une astuce écrite dans aucune langue est laissée de côté.langue_du_contenu()choisit la langue d'un contenu, et prévient le site au passage. Il sait alors dans quelles langues l'astuce existe : il n'annonce qu'elles aux moteurs de recherche (hreflang). Quand il sert une autre langue que celle demandée, il affiche le bandeau « Ce contenu n'existe pas en… » et désigne la version d'origine comme adresse de référence (canonical). Sans cela, un moteur verrait six adresses pour un même texte.
Le checker s'en sert :
astuces/controllers/checker.php
<?php
declare(strict_types=1);
namespace NF\Modules\Astuces\Controllers;
use NF\NeoFrag\Loadables\Controllers\Module_Checker;
class Checker extends Module_Checker
{
public function index()
{
return [$this->model()->publiees()];
}
public function _astuce($id, $url_title)
{
if (!($astuce = $this->model()->astuce((int) $id)))
{
// Introuvable, pas encore publiée, ou écrite dans aucune langue : « page introuvable ».
return;
}
// Le titre de l'adresse est celui de la langue servie : un lien partagé en français, ouvert en anglais, mène
// à l'adresse anglaise.
nf_bon_titre((string) $url_title, (string) $astuce['title'], 'astuces/'.(int) $id);
$ids = array_map('intval', array_column($this->model()->publiees(), 'id'));
return [$astuce, (int) array_search((int) $id, $ids, TRUE) + 1, count($ids)];
}
}
nf_bon_titre() compare le titre de l'adresse à celui de la langue servie. Un lien français ouvert en anglais,
/en/astuces/5/ecris-ta-signature, mène ainsi à /en/astuces/5/write-your-signature dès que la version anglaise
existe.
Étape 4 — L'auteur et les réactions
D'autres modules du site s'intéressent aux contenus des autres : les Réactions, les Notifications, la Gamification (le karma). Ils ne connaissent pas les astuces : c'est le module qui se présente à eux, dans sa classe.
astuces/astuces.php
<?php
declare(strict_types=1);
/**
* Astuces — le module des tutoriels « Mon premier module » (débutant), « Un module et sa base de données »
* (intermédiaire) et « Un module qui parle toutes les langues du site » (expert). LGPLv3.
*/
namespace NF\Modules\Astuces;
use NF\NeoFrag\Addons\Module;
class Astuces extends Module
{
protected function __info()
{
return [
'title' => $this->lang('Astuces'),
'description' => $this->lang('Quelques astuces pour bien démarrer sur le site, chacune sur sa page.'),
'icon' => 'fas fa-lightbulb',
'link' => 'https://neofrag-reborn.xyz',
'author' => 'NeoFrag Reborn',
'license' => 'LGPLv3 <https://www.gnu.org/licenses/lgpl-3.0.html>',
'version' => '3.0.0',
'depends' => [
'neofrag' => '1.2.50'
],
'core' => FALSE,
'presets' => [],
'requires' => [],
'admin' => TRUE,
'routes' => [
'' => 'index',
'{id}/{url_title}' => '_astuce',
'admin' => 'index',
'admin/ajouter' => '_ajouter',
'admin/{id}/{url_title}' => '_modifier',
'admin/supprimer/{id}/{url_title}' => '_supprimer'
]
];
}
/**
* Ce que le module apporte aux autres : une astuce est un contenu auquel on réagit. Les réactions,
* les notifications et le karma lisent ici sa table, sa clé, et la colonne de son auteur (`user_id`).
*/
public function declare_content_types()
{
return [
'astuce' => [
'table' => 'nf_astuces',
'pk' => 'id',
'author' => 'user_id',
'reactable' => TRUE
]
];
}
/** Une astuce se montre si elle est publiée : on ne réagit qu'à ce qu'on peut voir. */
public function contenu_visible(string $type, int $id): bool
{
return $type === 'astuce'
&& (bool) $this->db->select('1')->from('nf_astuces')->where('id', $id)->where('published', 1)->row();
}
/** L'adresse d'une astuce, pour le lien d'une notification (« X a réagi à ton astuce »). */
public function content_url($type, $id)
{
$titre = $this->db ->select('al.title')
->from('nf_astuces a')
->join_lang('nf_astuces_lang al', 'astuce_id', 'a.id')
->where('a.id', (int) $id)
->row();
return $type === 'astuce' && $titre ? 'astuces/'.(int) $id.'/'.url_title($titre) : '';
}
}
declare_content_types()décrit le contenuastuce: sa table, sa clé, la colonne de son auteur, et'reactable' => TRUE, qui ouvre les réactions. Les Notifications et la Gamification lisent la colonneuser_id.contenu_visible(): le module des réactions refuse qu'on réagisse à ce qu'on ne peut pas voir, comme une astuce en brouillon.content_url()donne l'adresse d'une astuce : c'est le lien de la notification « … a réagi ».
La page d'une astuce affiche la barre :
astuces/controllers/index.php
<?php
declare(strict_types=1);
namespace NF\Modules\Astuces\Controllers;
use NF\NeoFrag\Loadables\Controllers\Module as Controller_Module;
class Index extends Controller_Module
{
public function index($astuces)
{
$this ->title($this->lang('Astuces'))
->icon('fas fa-lightbulb')
->breadcrumb();
return $this->css('astuces')
->panel()
->heading()
->body($this->view('index', [
'astuces' => $astuces
]));
}
public function _astuce($astuce, $numero, $total)
{
// Le titre vient de la base, déjà dans sa langue : le site n'a pas à lui chercher de traduction.
$titre = $this->no_translate($astuce['title']);
$this ->title($titre)
->icon('fas fa-lightbulb')
->breadcrumb($this->lang('Astuces'), url('astuces'))
->breadcrumb();
// Les réactions sont un module : s'il est désactivé, l'astuce s'affiche sans elles.
$reactions = $this->module('reactions');
return $this->css('astuces')
->panel()
->heading($titre, 'fas fa-lightbulb')
->body($this->view('astuce', [
'astuce' => $astuce,
'numero' => $numero,
'total' => $total,
'reactions' => $reactions && $reactions->is_enabled() ? $reactions->bar('astuce', (int) $astuce['id']) : ''
]));
}
}
astuces/views/astuce.tpl.php
<p class="astuces-numero">
<?php echo $this->lang('Astuce %d sur %d', $numero, $total) ?>
<?php if ($astuce['user_id']): ?>
· <?php echo $this->lang('écrite par %s', $this->user->link($astuce['user_id'], $astuce['username'])) ?>
<?php endif ?>
</p>
<p class="astuces-texte"><?php echo nl2br(nf_texte($astuce['content'])) ?></p>
<div class="astuces-pied">
<a class="btn btn-outline-secondary btn-sm" href="<?php echo url('astuces') ?>">
<i class="fas fa-arrow-left"></i> <?php echo $this->lang('Toutes les astuces') ?>
</a>
<?php echo $reactions ?>
</div>
$this->module('reactions') rend le module s'il est installé ; is_enabled() dit s'il est actif. Sans lui, l'astuce
s'affiche sans barre : un module ne doit jamais dépendre d'un autre qu'il n'a pas déclaré. $this->user->link()
fait le lien vers le profil de l'auteur.
Les astuces écrites avant la 3.0 n'ont pas d'auteur : leur page n'en montre pas, et une réaction ne prévient personne.
Étape 5 — Écrire dans chaque langue : l'administration
Le formulaire écrit dans la langue de l'administration. Pour l'ouvrir en anglais, remplace fr par en au
début de l'adresse : /en/admin/astuces.
astuces/controllers/admin_checker.php
<?php
declare(strict_types=1);
namespace NF\Modules\Astuces\Controllers;
use NF\NeoFrag\Loadables\Controllers\Module_Checker;
class Admin_Checker extends Module_Checker
{
public function index()
{
// Le titre dans la meilleure langue, et les langues où l'astuce est écrite (« de,en,fr »).
return [$this->db ->select('a.id', 'a.published', 'al.title', '(SELECT GROUP_CONCAT(l.lang ORDER BY l.lang) FROM nf_astuces_lang l WHERE l.astuce_id = a.id) AS langues')
->from('nf_astuces a')
->join_lang('nf_astuces_lang al', 'astuce_id', 'a.id')
->order_by('a.sort_order ASC, a.id ASC')
->get()];
}
public function _ajouter()
{
// Rien à charger, mais un tableau VIDE vaudrait « rien » : le site répondrait « page introuvable ».
return [NULL];
}
public function _modifier($id, $url_title)
{
return $this->_astuce($id);
}
public function _supprimer($id, $url_title)
{
return $this->_astuce($id);
}
/**
* L'astuce demandée, ou rien : « page introuvable ». Son texte est celui de la langue de l'administration,
* TEL QU'IL EST ÉCRIT, vide s'il ne l'est pas encore : c'est ce qu'on vient écrire. Le repli vers une autre
* langue est fait pour le visiteur ; ici, il ferait enregistrer du français sous l'anglais au premier clic.
*/
private function _astuce($id): ?array
{
if (!($astuce = $this->db->select('id', 'published', 'sort_order')->from('nf_astuces')->where('id', (int) $id)->row()))
{
return NULL;
}
$ecrite = $this->db ->select('title', 'content')
->from('nf_astuces_lang')
->where('astuce_id', $astuce['id'])
->where('lang', $this->config->lang->info()->name)
->row();
return [$astuce + ($ecrite ?: ['title' => '', 'content' => ''])];
}
}
Ici, pas de repli vers une autre langue : le formulaire anglais d'une astuce qui n'est écrite qu'en français s'ouvre vide, puisque c'est ce qu'on vient écrire. S'il montrait le texte français, un simple clic sur « Enregistrer » le rangerait sous l'anglais.
astuces/controllers/admin.php
<?php
declare(strict_types=1);
namespace NF\Modules\Astuces\Controllers;
use NF\NeoFrag\Loadables\Controllers\Module as Controller_Module;
class Admin extends Controller_Module
{
/** La liste : une ligne par astuce, les langues où elle est écrite, son état, et ses deux boutons. */
public function index($astuces)
{
$this->title($this->lang('Astuces'))->icon('fas fa-lightbulb');
if (!$astuces)
{
$corps = $this->admin_empty('fas fa-lightbulb', $this->lang('Aucune astuce.'), $this->lang('Écris la première : elle paraîtra sur la page des astuces.'));
}
else
{
$corps = '<table class="table table-hover mb-0"><thead><tr>'
.'<th>'.$this->lang('Titre').'</th><th>'.$this->lang('Langues').'</th><th>'.$this->lang('État').'</th><th></th>'
.'</tr></thead><tbody>';
foreach ($astuces as $astuce)
{
$adresse = $astuce['id'].'/'.url_title($astuce['title']);
$etat = $astuce['published']
? '<span class="badge text-bg-success">'.$this->lang('Publiée').'</span>'
: '<span class="badge text-bg-secondary">'.$this->lang('Brouillon').'</span>';
$langues = '';
foreach (explode(',', (string) $astuce['langues']) as $langue)
{
$langues .= '<span class="badge text-bg-light text-uppercase">'.nf_texte($langue).'</span> ';
}
$corps .= '<tr>'
.'<td>'.nf_texte($astuce['title']).'</td>'
.'<td>'.$langues.'</td>'
.'<td>'.$etat.'</td>'
.'<td class="text-end text-nowrap">'
.'<a class="btn btn-sm btn-outline-secondary" href="'.url('admin/astuces/'.$adresse).'" title="'.$this->lang('Modifier').'"><i class="fas fa-pen"></i></a> '
.'<a class="btn btn-sm btn-outline-danger" href="'.$this->csrf_url('admin/astuces/supprimer/'.$adresse).'" data-confirm="'.nf_texte($this->lang('Supprimer cette astuce ?')).'" title="'.$this->lang('Supprimer').'"><i class="far fa-trash-alt"></i></a>'
.'</td></tr>';
}
$corps .= '</tbody></table>';
}
return $this->admin_card(
'fas fa-lightbulb',
$this->lang('Astuces'),
$corps,
$this->lang('%d astuce|%d astuces', count($astuces), count($astuces)),
$this->admin_create('admin/astuces/ajouter', $this->lang('Nouvelle astuce'))
);
}
public function _ajouter()
{
return $this->_formulaire(NULL);
}
public function _modifier($astuce)
{
return $this->_formulaire($astuce);
}
public function _supprimer($astuce)
{
// Un lien qui efface porte un jeton : un lien piégé, cliqué par un administrateur, ne fait rien.
$this->check_csrf('admin/astuces');
// Ses traductions partent avec elle : la clé étrangère de nf_astuces_lang les efface (ON DELETE CASCADE).
$this->db->where('id', $astuce['id'])->delete('nf_astuces');
notify($this->lang('Astuce supprimée.'));
redirect('admin/astuces');
}
/**
* Le même formulaire écrit une astuce neuve ou modifie une astuce existante, DANS LA LANGUE DE
* L'ADMINISTRATION : l'ouvrir en anglais écrit (ou corrige) la version anglaise, sans toucher aux autres.
*/
protected function _formulaire(?array $astuce)
{
$nouvelle = $astuce === NULL;
$titre = $nouvelle ? $this->lang('Nouvelle astuce') : $this->lang('Modifier l\'astuce');
$langue = $this->config->lang->info();
$this->title($titre)->icon('fas fa-lightbulb')->breadcrumb();
$this->form()
->add_rules([
'title' => ['label' => $this->lang('Titre'), 'type' => 'text', 'value' => $nouvelle ? '' : $astuce['title'], 'rules' => 'required',
'description' => $this->lang('Écrit pour %s. Change la langue de l\'administration pour traduire cette astuce ; les autres langues gardent leur texte.', $langue->title)],
'content' => ['label' => $this->lang('Texte'), 'type' => 'textarea', 'value' => $nouvelle ? '' : $astuce['content'], 'rules' => 'required'],
'sort_order' => ['label' => $this->lang('Ordre'), 'type' => 'text', 'value' => $nouvelle ? '0' : $astuce['sort_order']],
'published' => ['label' => $this->lang('Publication'), 'type' => 'checkbox', 'value' => ['1'], 'values' => ['1' => $this->lang('Astuce publiée')], 'checked' => ['1' => $nouvelle || !empty($astuce['published'])]]
])
->add_submit($nouvelle ? $this->lang('Ajouter') : $this->lang('Enregistrer'), $nouvelle ? 'fas fa-plus' : 'fas fa-check');
if ($this->form()->is_valid($post))
{
$donnees = [
'sort_order' => (int) $post['sort_order'],
'published' => in_array('1', (array) ($post['published'] ?? []), TRUE) ? 1 : 0
];
if ($nouvelle)
{
// L'auteur : les réactions à son astuce le préviennent, et comptent pour son karma.
$id = (int) $this->db->insert('nf_astuces', $donnees + ['user_id' => $this->user->id]);
}
else
{
$this->db->where('id', $id = (int) $astuce['id'])->update('nf_astuces', $donnees);
}
// La version de cette langue : `ecrire_lang` la crée si elle manque, la remplace sinon.
$this->db->ecrire_lang('nf_astuces_lang', ['astuce_id' => $id, 'lang' => (string) $langue->name], [
'title' => $post['title'],
'content' => $post['content']
]);
notify($nouvelle ? $this->lang('Astuce ajoutée.') : $this->lang('Astuce enregistrée.'));
redirect('admin/astuces');
}
return $this->admin_card($nouvelle ? 'fas fa-plus' : 'fas fa-pen', $titre, $this->form()->display());
}
}
ecrire_lang()écrit la version de cette langue : il la crée si elle manque, la remplace sinon. Les autres langues ne bougent pas.- La description du titre dit pour quelle langue on écrit : l'icône à côté de l'étiquette « Titre » l'affiche.
- La liste montre en pastilles les langues où chaque astuce est écrite.
- Une astuce neuve retient son auteur :
$this->user->id, l'administrateur qui l'écrit.
Étape 6 — La recherche
La recherche du site interroge chaque module qui a un contrôleur search.php :
astuces/controllers/search.php
<?php
declare(strict_types=1);
namespace NF\Modules\Astuces\Controllers;
use NF\NeoFrag\Loadables\Controllers\Module as Controller_Module;
/**
* La recherche du site : elle appelle `search()` de chaque module qui a ce contrôleur, ajoute les mots
* cherchés sur les colonnes qu'il rend, et lit les lignes trouvées.
*/
class Search extends Controller_Module
{
/** Les astuces publiées, dans la langue du visiteur, et les colonnes où chercher. */
public function search()
{
$this->db ->select('a.id', 'al.title', 'al.content')
->from('nf_astuces a')
->join_lang('nf_astuces_lang al', 'astuce_id', 'a.id', NULL, 'INNER')
->where('a.published', 1);
return ['al.title', 'al.content'];
}
/** Un résultat parmi les premiers de la page de recherche. */
public function index($astuce, $mots)
{
return $this->view('search', [
'astuce' => $astuce,
'extrait' => highlight($astuce['content'], $mots)
]);
}
/** Un résultat de la page « toutes les astuces trouvées », avec un extrait plus long. */
public function detail($astuce, $mots)
{
return $this->view('search', [
'astuce' => $astuce,
'extrait' => highlight($astuce['content'], $mots, 1024)
]);
}
/** La suggestion du champ de recherche, pendant la frappe. */
public function suggest($astuce)
{
return [
'title' => $astuce['title'],
'url' => url('astuces/'.$astuce['id'].'/'.url_title($astuce['title']))
];
}
}
search()prépare la requête sans l'envoyer, et rend les colonnes où chercher. La recherche y ajoute les mots tapés, puis lit les lignes trouvées. La requête ne prend que les astuces publiées, dans la langue du visiteur.index()etdetail()affichent un résultat, sur la page de tous les résultats et sur celle du module.suggest()propose l'astuce pendant la frappe, dans le champ de recherche.
highlight() échappe le texte et entoure les mots trouvés de <mark> : la vue l'affiche tel quel.
astuces/views/search.tpl.php
<p class="mb-1"><a href="<?php echo url('astuces/'.$astuce['id'].'/'.url_title($astuce['title'])) ?>"><b><?php echo nf_texte($astuce['title']) ?></b></a></p>
<p><?php echo $extrait ?></p>
Étape 7 — Le plan du site
/sitemap.xml dresse un plan par langue (/fr/sitemap.xml, /en/sitemap.xml…) en demandant leurs adresses aux
modules qui ont un contrôleur sitemap.php :
astuces/controllers/sitemap.php
<?php
declare(strict_types=1);
namespace NF\Modules\Astuces\Controllers;
use NF\NeoFrag\Loadables\Controllers\Module as Controller_Module;
/**
* Le plan du site (`/sitemap.xml`), que lisent les moteurs de recherche : le site le dresse langue par langue, en
* appelant `sitemap()` de chaque module qui a ce contrôleur, dans la langue du plan.
*/
class Sitemap extends Controller_Module
{
/** @return list<array{adresse: string, date?: int|string|null}> */
public function sitemap(): array
{
$adresses = [];
// Seules les astuces ÉCRITES dans la langue du plan. Celle qui ne l'est pas s'affiche bien sous cette langue, en
// repli, mais son adresse de référence est celle de sa langue : c'est le plan de cette langue qui l'annonce.
foreach ($this->db ->select('a.id', 'a.created_at', 'al.title')
->from('nf_astuces a')
->join('nf_astuces_lang al', 'al.astuce_id = a.id', 'INNER')
->where('al.lang', $this->config->lang->info()->name)
->where('a.published', 1)
->order_by('a.sort_order ASC, a.id ASC')
->get() as $astuce)
{
$adresses[] = ['adresse' => 'astuces/'.$astuce['id'].'/'.url_title($astuce['title']), 'date' => $astuce['created_at']];
}
// Sans astuce, la page des astuces ne dirait que « rien pour le moment » : on ne l'annonce pas.
if (!$adresses)
{
return [];
}
array_unshift($adresses, ['adresse' => 'astuces', 'date' => max(array_column($adresses, 'date'))]);
return $adresses;
}
}
Le plan anglais ne donne que les astuces écrites en anglais. Une astuce qui ne l'est pas s'affiche bien sous
/en/, avec le bandeau, mais son adresse de référence est la française : c'est au plan français de l'annoncer.
Étape 8 — Le widget suit
« Astuce du jour » lit maintenant le titre et le texte dans nf_astuces_lang, avec join_lang(). Sa version passe
aussi en 3.0.0 dans widgets/astuces/astuces.php.
widgets/astuces/controllers/index.php
<?php
declare(strict_types=1);
namespace NF\Widgets\Astuces\Controllers;
use NF\NeoFrag\Loadables\Controllers\Widget as Controller_Widget;
class Index extends Controller_Widget
{
/** L'astuce du jour : un tirage dont la graine est la date, donc la même astuce toute la journée. */
public function index($settings = [])
{
// Chaque astuce dans la meilleure langue : celle du visiteur, sinon le français, sinon celle qui existe.
$astuce = $this->db ->select('a.id', 'al.title', 'al.content')
->from('nf_astuces a')
->join_lang('nf_astuces_lang al', 'astuce_id', 'a.id', NULL, 'INNER')
->where('a.published', 1)
->order_by('RAND('.(int) date('Ymd').')')
->row();
$this->css('astuces');
return $this->panel()
->heading()
->body($this->view('index', [
'astuce' => $astuce ?: NULL
]));
}
/** Les dernières astuces écrites, autant que le réglage le demande. */
public function dernieres($settings = [])
{
$astuces = $this->db ->select('a.id', 'al.title')
->from('nf_astuces a')
->join_lang('nf_astuces_lang al', 'astuce_id', 'a.id', NULL, 'INNER')
->where('a.published', 1)
->order_by('a.created_at DESC, a.id DESC')
->limit((int) ($settings['nombre'] ?? 3))
->get();
$this->css('astuces');
return $this->panel()
->heading($this->lang('Les dernières astuces'), 'fas fa-lightbulb')
->body($this->view('dernieres', [
'astuces' => $astuces
]));
}
}
Étape 9 — Les traductions
Trois textes de plus dans les six fichiers de langs/ du module : « Langues », « écrite par %s », et la description
du titre. L'archive les porte.
Installer la mise à jour
- Compresse ensemble les dossiers
modulesetwidgets, puis Thèmes & addons → Ajouter. Le site répond « Le module Astuces a été mis à jour » et « Le widget Astuce du jour a été mis à jour ». - Ouvre
/astuces: les astuces sont toutes là. Dans l'administration, chacune porte la pastille FR. - Ouvre
/en/admin/astuces, puis une astuce : le formulaire est vide, et la description du titre dit « Written for English ». Écris la version anglaise, enregistre : la pastille EN apparaît. - Sur le site,
/en/astucesmontre la version anglaise. Les astuces pas encore traduites s'ouvrent en français, avec le bandeau. - Cherche un mot d'une astuce : elle sort dans les résultats.
Si ça ne marche pas
| Ce que tu vois | Ce que ça veut dire |
|---|---|
| Après la mise à jour, chaque astuce répond « page introuvable » | Une migration a échoué. Le journal du site (Monitoring) le dit, sur une ligne [addon.migrate] module/astuces qui donne la raison. Le plus souvent, une migration écrite pour d'autres tables (étape 2). |
| Une astuce pas encore traduite s'ouvre en anglais sans bandeau | Le checker ne passe pas par langue_du_contenu() du modèle. |
| Le formulaire anglais montre le texte français | L'admin_checker lit avec join_lang(), qui se replie sur le français. Il doit lire la langue de l'administration, exactement. |
| Pas de barre de réactions | Le module Réactions est désactivé, ou declare_content_types() ne dit pas 'reactable' => TRUE. |
| On réagit, mais l'auteur n'est pas prévenu | L'astuce a été écrite avant la 3.0 : elle n'a pas d'auteur. |
| Les astuces ne sortent pas dans la recherche | controllers/search.php manque, ou sa classe n'est pas NF\Modules\Astuces\Controllers\Search. |
Pour aller plus loin
- Traduire les quatre astuces d'origine par une migration :
INSERT IGNORE INTO nf_astuces_lang (astuce_id, lang, title, content) VALUES (1, 'en', 'Complete your profile', …).IGNORElaisse en place une version qu'un administrateur aurait déjà écrite. - Les outils de cette série,
join_lang()etecrire_lang()en tête, sont décrits dans le guide Le framework de la documentation du site.
C'est la fin de la série « Astuces » : un module installé par une archive, mis à jour deux fois sans rien perdre, dans toutes les langues du site.

Actividad del foro
ningún visitante
Estadísticas
- 72 temas creados
- 0 mensaje publicado
- 63 anuncios
- 1 participante