Browse Source

Typage des fonctions et correction d'un appel devnu incorrect (null pas admis).

master v0.5.2
Eric Lupinacci 4 weeks ago
parent
commit
c1e86adeda
  1. 4
      README.md
  2. 2
      action/affecter_plugin.php
  3. 2
      action/desaffecter_plugin.php
  4. 2
      action/supprimer_export.php
  5. 2
      action/telecharger_export.php
  6. 16
      base/svptype_declarations.php
  7. 28
      ezrest/svptype.php
  8. 30
      formulaires/editer_affectations.php
  9. 8
      formulaires/exporter_typologie.php
  10. 6
      formulaires/importer_typologie.php
  11. 4
      formulaires/vider_typologie.php
  12. 10
      inc/svptype_mot.php
  13. 18
      inc/svptype_plugin.php
  14. 68
      inc/svptype_type_plugin.php
  15. 38
      inc/svptype_typologie.php
  16. 3
      prive/squelettes/contenu/svptype_typologie.html
  17. 34
      saisies/selection_type_plugin_fonctions.php
  18. 4
      svptype_administrations.php
  19. 19
      svptype_autorisations.php
  20. 2
      svptype_fonctions.php
  21. 96
      svptype_pipelines.php

4
README.md

@ -1,2 +1,2 @@
# svp_tag
Module SVP de gestion des catégories et des tags
# SVP Typologie
Module SVP de gestion des catégories et des tags de plugins

2
action/affecter_plugin.php

@ -19,7 +19,7 @@ if (!defined('_ECRIRE_INC_VERSION')) {
*
* @return void
*/
function action_affecter_plugin_dist($arguments = null) {
function action_affecter_plugin_dist(?string $arguments = null) : void {
// Récupération des arguments de façon sécurisée.
if (null === $arguments) {
$securiser_action = charger_fonction('securiser_action', 'inc');

2
action/desaffecter_plugin.php

@ -18,7 +18,7 @@ if (!defined('_ECRIRE_INC_VERSION')) {
*
* @return void
*/
function action_desaffecter_plugin_dist($arguments = null) {
function action_desaffecter_plugin_dist(?string $arguments = null) : void {
// Récupération des arguments de façon sécurisée.
if (null === $arguments) {
$securiser_action = charger_fonction('securiser_action', 'inc');

2
action/supprimer_export.php

@ -14,7 +14,7 @@ if (!defined('_ECRIRE_INC_VERSION')) {
*
* @return void
*/
function action_supprimer_export_dist() {
function action_supprimer_export_dist() : void {
$securiser_action = charger_fonction('securiser_action', 'inc');
$fichier = $securiser_action();

2
action/telecharger_export.php

@ -14,7 +14,7 @@ if (!defined('_ECRIRE_INC_VERSION')) {
*
* @return void
*/
function action_telecharger_export_dist() {
function action_telecharger_export_dist() : void {
$securiser_action = charger_fonction('securiser_action', 'inc');
$fichier = $securiser_action();

16
base/svptype_declarations.php

@ -15,7 +15,7 @@ if (!defined('_ECRIRE_INC_VERSION')) {
*
* @return array Description des tables de la base complétée par celles du plugin.
*/
function svptype_declarer_tables_objets_sql($tables) {
function svptype_declarer_tables_objets_sql(array $tables) : array {
// Colonne 'identifiant'
$tables['spip_mots']['field']['identifiant'] = "varchar(255) DEFAULT '' NOT NULL";
@ -24,15 +24,15 @@ function svptype_declarer_tables_objets_sql($tables) {
/**
* Déclarations des tables auxilliaires nécessaires au plugin :
* - plugins_typologies, liens entre plugins et types de plugin
* - plugins_typologies, liens entre plugins et types de plugin.
*
* @pipeline declarer_tables_auxiliaires
*
* @param $tables_auxiliaires
* @param array $tables Liste des tables auxillaires
*
* @return mixed
* @return array Liste des tables auxillaires mises à jour.
*/
function svptype_declarer_tables_auxiliaires($tables_auxiliaires) {
function svptype_declarer_tables_auxiliaires(array $tables) : array {
// Tables de liens entre plugins et les types de plugins : spip_plugins_typologies
$plugins_typologies = [
'id_groupe' => 'bigint(21) DEFAULT 0 NOT NULL',
@ -45,12 +45,12 @@ function svptype_declarer_tables_auxiliaires($tables_auxiliaires) {
'KEY id_groupe' => 'id_groupe'
];
$tables_auxiliaires['spip_plugins_typologies'] = [
$tables['spip_plugins_typologies'] = [
'field' => &$plugins_typologies,
'key' => &$plugins_typologies_key
];
return $tables_auxiliaires;
return $tables;
}
/**
@ -65,7 +65,7 @@ function svptype_declarer_tables_auxiliaires($tables_auxiliaires) {
*
* @return array Tableau fourni en entrée et mis à jour avec les nouvelles informations
*/
function svptype_declarer_tables_interfaces($interface) {
function svptype_declarer_tables_interfaces(array $interface) : array {
// Les tables
$interface['table_des_tables']['plugins_typologies'] = 'plugins_typologies';

28
ezrest/svptype.php

@ -22,7 +22,7 @@ if (!defined('_ECRIRE_INC_VERSION')) {
*
* @return array Tableau des catégories.
*/
function categories_collectionner($conditions, $filtres, $configuration) {
function categories_collectionner(array $conditions, array $filtres, array $configuration) : array {
// Initialisation de la typologie
$typologie = 'categorie';
@ -36,12 +36,12 @@ function categories_collectionner($conditions, $filtres, $configuration) {
/**
* Détermine si la valeur de la profondeur est valide.
*
* @param string $profondeur La valeur du critère profondeur
* @param mixed $erreur Erreur retournée éventuellement par la vérification
* @param mixed $profondeur La valeur du critère profondeur
* @param array<string, mixed> &$erreur Tableau initialisé avec les index identifiant l'erreur.
*
* @return bool `true` si la valeur est valide, `false` sinon.
*/
function categories_verifier_filtre_profondeur($profondeur, &$erreur) {
function categories_verifier_filtre_profondeur($profondeur, array &$erreur) : bool {
$est_valide = true;
// Acquisition de la liste des catégories affectables.
@ -72,7 +72,7 @@ function categories_verifier_filtre_profondeur($profondeur, &$erreur) {
*
* @return array Tableau des catégories.
*/
function tags_collectionner($conditions, $filtres, $configuration) {
function tags_collectionner(array $conditions, array $filtres, array $configuration) : array {
// Initialisation de la typologie
$typologie = 'tag';
@ -97,7 +97,7 @@ function tags_collectionner($conditions, $filtres, $configuration) {
*
* @return array Tableau des affectations indexé par préfixe de plugin.
*/
function affectations_collectionner($conditions, $filtres, $configuration) {
function affectations_collectionner(array $conditions, array $filtres, array $configuration) : array {
// Initialisation de la collection
$affectations = [];
@ -144,12 +144,12 @@ function affectations_collectionner($conditions, $filtres, $configuration) {
/**
* Détermine si la valeur de la profondeur est valide.
*
* @param string $typologie Identifiant de la typologie concernée : categorie, tag...
* @param mixed $erreur Erreur retournée éventuellement par la vérification
* @param mixed $typologie Identifiant de la typologie concernée : categorie, tag...
* @param array<string, mixed> &$erreur Tableau initialisé avec les index identifiant l'erreur.
*
* @return bool `true` si la valeur est valide, `false` sinon.
*/
function affectations_verifier_filtre_typologie($typologie, &$erreur) {
function affectations_verifier_filtre_typologie($typologie, array &$erreur) : bool {
$est_valide = true;
// Acquisition de la liste des catégories affectables.
@ -174,12 +174,12 @@ function affectations_verifier_filtre_typologie($typologie, &$erreur) {
* Détermine si la valeur de la catégorie est valide.
* La fonction récupère via l'API du plugin la liste des catégories autorisées.
*
* @param string $categorie La valeur du critère catégorie
* @param mixed $erreur Erreur retournée éventuellement par la vérification
* @param string $categorie La valeur du critère catégorie
* @param array<string, mixed> &$erreur Tableau initialisé avec les index identifiant l'erreur.
*
* @return bool `true` si la valeur est valide, `false` sinon.
*/
function plugins_verifier_filtre_categorie($categorie, &$erreur) {
function plugins_verifier_filtre_categorie($categorie, array &$erreur) : bool {
$est_valide = true;
// Acquisition de la liste des catégories affectables.
@ -202,11 +202,11 @@ function plugins_verifier_filtre_categorie($categorie, &$erreur) {
* Construit le critère applicable sur la table spip_plugins pour filtrer la collection sur le
* critère categorie.
*
* @param string $categorie La valeur du critère catégorie
* @param mixed $categorie La valeur du critère catégorie
*
* @return string Chaine représentant le critère sur la catégorie appliqué à la table spip_plugins.
*/
function plugins_conditionner_categorie($categorie) {
function plugins_conditionner_categorie($categorie) : string {
// On initialise le critère avec une condition toujours fausse.
$condition = '0=1';

30
formulaires/editer_affectations.php

@ -9,13 +9,13 @@ if (!defined('_ECRIRE_INC_VERSION')) {
/**
* Chargement du formulaire d'affectation d'un type de plugin à un plugin donné.
*
* @param int $id_plugin Identifiant unique du plugin
* @param string $typologie Identifiant de la typologie
* @param array $options Options de chargement du formulaire :
* @param int $id_plugin Identifiant unique du plugin
* @param string $typologie Identifiant de la typologie
* @param null|array $options Options de chargement du formulaire :
*
* @return array Variables de contexte en entrée du formulaire
*/
function formulaires_editer_affectations_charger($id_plugin, $typologie, $options = []) {
function formulaires_editer_affectations_charger(int $id_plugin, string $typologie, array $options = []) : array {
// Les options peuvent être limitées au booléen d'éditabilité
if (!isset($options['editable'])) {
$options['editable'] = true;
@ -62,25 +62,15 @@ function formulaires_editer_affectations_charger($id_plugin, $typologie, $option
}
/**
* Traiter le post des informations d'édition de liens.
* Traitement du formulaire d'affectation d'un type de plugin à un plugin donné.
*
* Les formulaires peuvent poster dans quatre variables
* - ajouter_lien et supprimer_lien
* @param int $id_plugin Identifiant unique du plugin
* @param string $typologie Identifiant de la typologie
* @param null|array $options Options de chargement du formulaire :
*
* Les deux premières peuvent être de trois formes différentes :
* ajouter_lien[]="objet1-id1-objet2-id2"
* ajouter_lien[objet1-id1-objet2-id2]="nimportequoi"
* ajouter_lien['clenonnumerique']="objet1-id1-objet2-id2"
* Dans ce dernier cas, la valeur ne sera prise en compte
* que si _request('clenonnumerique') est vrai (submit associé a l'input)
*
* @param int $id_plugin
* @param string $typologie
* @param array $options
*
* @return array
* @return array Tableau des messages à afficher sur le formulaire
*/
function formulaires_editer_affectations_traiter($id_plugin, $typologie, $options = []) {
function formulaires_editer_affectations_traiter(int $id_plugin, string $typologie, array $options = []) : array {
// Les options peuvent être limitées au booléen d'éditabilité
if (!isset($options['editable'])) {
$options['editable'] = true;

8
formulaires/exporter_typologie.php

@ -17,7 +17,7 @@ if (!defined('_ECRIRE_INC_VERSION')) {
* - `_vues` : (affichage) choix d'exportation entre les types de plugin ou leurs affectations.
* - `_vue_defaut` : choix par défaut (types de plugin).
*/
function formulaires_exporter_typologie_charger($typologie) {
function formulaires_exporter_typologie_charger(string $typologie) : array {
// Initialisation du tableau des variables fournies au formulaire.
$valeurs = [];
@ -35,7 +35,7 @@ function formulaires_exporter_typologie_charger($typologie) {
*
* @return array Tableau des erreurs concernant le choix de la vue qui est obligatoire.
*/
function formulaires_exporter_typologie_verifier($typologie) {
function formulaires_exporter_typologie_verifier(string $typologie) : array {
// Initialisation des messages d'erreur
$erreurs = [];
@ -57,7 +57,7 @@ function formulaires_exporter_typologie_verifier($typologie) {
* @return array Tableau retourné par le formulaire contenant toujours un message de bonne exécution ou
* d'erreur. L'indicateur editable est toujours à vrai.
*/
function formulaires_exporter_typologie_traiter($typologie) {
function formulaires_exporter_typologie_traiter(string $typologie) : array {
// Initialisation du retour de traitement du formulaire (message, editable).
$retour = [];
@ -70,7 +70,7 @@ function formulaires_exporter_typologie_traiter($typologie) {
$exporter = "typologie_plugin_exporter{$suffixe}";
// Création du fichier d'export sur le serveur.
if ($fichier = $exporter($typologie)) {
if ($exporter($typologie)) {
$retour['message_ok'] = _T('svptype:export_message_ok');
} else {
$retour['message_erreur'] = _T('svptype:export_message_nok');

6
formulaires/importer_typologie.php

@ -16,7 +16,7 @@ if (!defined('_ECRIRE_INC_VERSION')) {
* @return array Tableau des données à charger par le formulaire (affichage) :
* - `_vues` : (affichage) choix d'exportation entre les types de plugin ou leurs affectations.
*/
function formulaires_importer_typologie_charger($typologie) {
function formulaires_importer_typologie_charger(string $typologie) : array {
// Initialisation du tableau des variables fournies au formulaire.
$valeurs = [];
@ -36,7 +36,7 @@ function formulaires_importer_typologie_charger($typologie) {
*
* @return array Tableau des erreurs concernant le fichier ou tableau vide si aucune erreur.
*/
function formulaires_importer_typologie_verifier($typologie) {
function formulaires_importer_typologie_verifier(string $typologie) : array {
// Initialisation des messages d'erreur
$erreurs = [];
@ -69,7 +69,7 @@ function formulaires_importer_typologie_verifier($typologie) {
* @return array Tableau retourné par le formulaire contenant toujours un message de bonne exécution ou
* d'erreur. L'indicateur editable est toujours à vrai.
*/
function formulaires_importer_typologie_traiter($typologie) {
function formulaires_importer_typologie_traiter(string $typologie) : array {
// Initialisation du retour de traitement du formulaire (message, editable).
$retour = [];
$resultat_import = false;

4
formulaires/vider_typologie.php

@ -20,7 +20,7 @@ if (!defined('_ECRIRE_INC_VERSION')) {
* - `_label_affectation` : (affichage) indique que des affectations existent pour la typologie.
* - `_nb_affectations` : (affichage) permet d'afficher ou de masquer le choix des types de plugin en JS
*/
function formulaires_vider_typologie_charger($typologie) {
function formulaires_vider_typologie_charger(string $typologie) : array {
// Initialisation du tableau des variables fournies au formulaire.
$valeurs = [];
@ -56,7 +56,7 @@ function formulaires_vider_typologie_charger($typologie) {
* @return array Tableau retourné par le formulaire contenant toujours un message de bonne exécution ou
* d'erreur. L'indicateur editable est toujours à vrai.
*/
function formulaires_vider_typologie_traiter($typologie) {
function formulaires_vider_typologie_traiter(string $typologie) : array {
// Initialisation du retour de traitement du formulaire (message, editable).
$retour = [];

10
inc/svptype_mot.php

@ -17,7 +17,7 @@ if (!defined('_ECRIRE_INC_VERSION')) {
*
* @return bool True si le mot est une racine d'une typologie arborescente, false sinon.
*/
function mot_est_racine($id_mot) {
function mot_est_racine(int $id_mot) : bool {
// Initialisation du tableau statique des indicateurs de groupe typologique.
static $est_racine = [];
@ -51,7 +51,7 @@ function mot_est_racine($id_mot) {
*
* @return bool True si le groupe est celui d'une typologie, false sinon.
*/
function groupe_est_typologie_plugin($id_groupe) {
function groupe_est_typologie_plugin(int $id_groupe) : bool {
// Initialisation du tableau statique des indicateurs de groupe typologique.
static $est_typologie = [];
@ -79,7 +79,7 @@ function groupe_est_typologie_plugin($id_groupe) {
*
* @return int Id du groupe d'appartenance du mot-clé ou 0 sinon.
*/
function mot_lire_groupe($id_mot) {
function mot_lire_groupe(int $id_mot) : int {
static $ids_groupe = [];
if (!isset($ids_groupe[$id_mot])) {
@ -106,7 +106,7 @@ function mot_lire_groupe($id_mot) {
*
* @return string Champ `identifiant` du mot-clé si celui-ci est un type de plugin ou chaine vide sinon.
*/
function mot_lire_identifiant($id_mot) {
function mot_lire_identifiant(int $id_mot) : string {
static $identifiants = [];
if (!isset($identifiants[$id_mot])) {
@ -130,7 +130,7 @@ function mot_lire_identifiant($id_mot) {
*
* @return array Tableau des id des enfants d'un mot-clé ou tableau vide sinon.
*/
function mot_lire_enfants($id_mot) {
function mot_lire_enfants(int $id_mot) : array {
static $ids_enfant = [];
if (!isset($ids_enfant[$id_mot])) {

18
inc/svptype_plugin.php

@ -17,7 +17,7 @@ if (!defined('_ECRIRE_INC_VERSION')) {
*
* @return bool `true` si l'insertion se passe correctement ou `false` sinon.
*/
function plugin_affecter_type_plugin($plugin, $id_mot, $typologie) {
function plugin_affecter_type_plugin($plugin, int $id_mot, string $typologie) : bool {
// La sortie est toujours ok a priori
$retour = true;
@ -70,7 +70,7 @@ function plugin_affecter_type_plugin($plugin, $id_mot, $typologie) {
*
* @return bool `true` si la suppresion se passe correctement ou `false` sinon.
*/
function plugin_desaffecter_type_plugin($plugin, $id_mot) {
function plugin_desaffecter_type_plugin($plugin, int $id_mot) : bool {
// La sortie est toujours ok a priori
$retour = true;
@ -107,7 +107,7 @@ function plugin_desaffecter_type_plugin($plugin, $id_mot) {
* @return array Liste des types de plugin d'une typologie (id du mot représentant le type)
* affectés au plugin concerné. Vide si aucune affectation.
*/
function plugin_lister_type_plugin($plugin, $typologie) {
function plugin_lister_type_plugin($plugin, string $typologie) : array {
// On détermine le préfixe du plugin qui est utilisé dans la table des affectations :
// -- si c'est le préfixe on le passe en majuscules pour être cohérent avec le stockage en base.
// -- sinon on lit le préfixe à partir de l'id du plugin.
@ -135,7 +135,17 @@ function plugin_lister_type_plugin($plugin, $typologie) {
return $affectations;
}
function plugin_elaborer_condition($typologie, $id_mot = 0, $plugins_exclus = []) {
/**
* Elabore la condition SQL pour lister les plugins ayant une affectation avec un type donné, un type quelconque ou
* n'étant pas du tout affecté.
*
* @param string $typologie Identifiant de la typologie
* @param null|int $id_mot Id du mot représentant le type de plugin
* @param null|array $plugins_exclus Liste des id de plugin exclus
*
* @return string Condition SQL
*/
function plugin_elaborer_condition(string $typologie, ?int $id_mot = 0, ?array $plugins_exclus = []) : string {
// Initialisation de la condition
$condition = '0=1';

68
inc/svptype_type_plugin.php

@ -9,22 +9,21 @@ if (!defined('_ECRIRE_INC_VERSION')) {
}
/**
* Retourne la description complète du type de plugin ou uniquement une information précise.
* Retourne la description complète du type de plugin ou partielle ou uniquement une information précise.
*
* @api
*
* @param string $typologie Typologie concernée : categorie, tag... Ne sert que si le type est passé sous forme du champ `identifiant`
* qui n'est unique qu'au sein d'une même typologie.
* @param int|string $type_plugin Identifiant d'un type de plugin correspondant soit à son `id_mot` soit au champ `identifiant`.
* @param array|string $informations Identifiant d'un champ ou de plusieurs champs de la description d'un type de plugin.
* Si l'argument est vide, la fonction renvoie la description complète.
* @param string $typologie Typologie concernée : categorie, tag... Ne sert que si le type est passé sous forme du champ `identifiant`
* qui n'est unique qu'au sein d'une même typologie.
* @param int|string $type_plugin Identifiant d'un type de plugin correspondant soit à son `id_mot` soit au champ `identifiant`.
* @param null|array|string $informations Identifiant d'un champ ou de plusieurs champs de la description d'un type de plugin.
* Si l'argument est vide, la fonction renvoie la description complète.
*
* @return array|string
* La description brute complète ou partielle du type de plugin :
* @return array|string La description brute complète ou partielle du type de plugin :
* - sous la forme d'une valeur simple si l'information demandée est unique (chaine)
* - sous la forme d'un tableau associatif indexé par le nom du champ sinon.
*/
function type_plugin_lire($typologie, $type_plugin, $informations = []) {
function type_plugin_lire(string $typologie, $type_plugin, $informations = []) {
static $description_type = [];
static $configurations = [];
@ -104,13 +103,13 @@ function type_plugin_lire($typologie, $type_plugin, $informations = []) {
* @api
*
* @param string $typologie Typologie concernée : categorie, tag...
* @param array $filtres Liste des couples (champ, valeur) ou tableau vide.
* @param null|array $filtres Liste des couples (champ, valeur) ou tableau vide.
* @param array|string $informations Identifiant d'un champ ou de plusieurs champs de la description d'un type de plugin.
* Si l'argument est vide, la fonction renvoie les descriptions complètes.
*
* @return array Description complète ou information précise pour chaque type de plugin de la typologie concernée.
*/
function type_plugin_repertorier($typologie, $filtres = [], $informations = []) {
function type_plugin_repertorier(string $typologie, ?array $filtres = [], $informations = []) : array {
// Utilisation d'une statique pour éviter les requêtes multiples sur le même hit.
static $types = [];
@ -158,16 +157,16 @@ function type_plugin_repertorier($typologie, $filtres = [], $informations = [])
*
* @api
*
* @param string $typologie Typologie concernée : categorie, tag...
* @param array $filtres Liste des couples (champ, valeur) ou tableau vide.
* Pratiquement, les critères admis sont `prefixe`, `id_mot` et aussi `type` qui revient à filtrer
* sur un type de plugin comme id_mot.
* Il est possible aussi d'utiliser `type_racine` qui indique qu'on cherche toutes les affectations
* des types enfants du type racine.
* @param string $typologie Typologie concernée : categorie, tag...
* @param null|array $filtres Liste des couples (champ, valeur) ou tableau vide.
* Pratiquement, les critères admis sont `prefixe`, `id_mot` et aussi `type` qui revient à filtrer
* sur un type de plugin comme id_mot.
* Il est possible aussi d'utiliser `type_racine` qui indique qu'on cherche toutes les affectations
* des types enfants du type racine.
*
* @return array Description de chaque affectation (type de plugin, plugin) de la typologie concernée.
*/
function type_plugin_repertorier_affectation($typologie, $filtres = []) {
function type_plugin_repertorier_affectation(string $typologie, ?array $filtres = []) : array {
// On récupère l'id du groupe pour la typologie concernée.
include_spip('inc/config');
$id_groupe = lire_config("svptype/typologies/{$typologie}/id_groupe", 0);
@ -232,7 +231,7 @@ function type_plugin_repertorier_affectation($typologie, $filtres = []) {
*
* @return array Liste des enfants d'un type de plugin ou tableau vide si aucun.
*/
function type_plugin_repertorier_enfant($typologie, $type_plugin) {
function type_plugin_repertorier_enfant(string $typologie, $type_plugin) : array {
// Initialisations statiques pour les performances.
static $enfants = [];
@ -262,7 +261,7 @@ function type_plugin_repertorier_enfant($typologie, $type_plugin) {
*
* @return int Nombre d'enfants d'un type de plugin ou 0 si aucun.
*/
function type_plugin_compter_enfant($typologie, $type_plugin) {
function type_plugin_compter_enfant(string $typologie, $type_plugin) : int {
return count(type_plugin_repertorier_enfant($typologie, $type_plugin));
}
@ -276,7 +275,7 @@ function type_plugin_compter_enfant($typologie, $type_plugin) {
*
* @return int Nombre d'affectations (type de plugin, plugin) d'un type de plugin ou 0 si aucun.
*/
function type_plugin_compter_affectation($typologie, $type_plugin) {
function type_plugin_compter_affectation(string $typologie, $type_plugin) : int {
// Initialisations statiques pour les performances.
static $compteurs = [];
static $configurations_typologie = [];
@ -322,7 +321,16 @@ function type_plugin_compter_affectation($typologie, $type_plugin) {
return $compteurs[$id_mot];
}
function type_plugin_elaborer_condition($typologie, $type_plugin, $vue) {
/**
* Elabore la condition SQL pour lister les types de plugin.
*
* @param string $typologie Typologie concernée : categorie, tag...
* @param string $type_plugin Identifiant d'un type de plugin correspondant au champ `identifiant`.
* @param string $vue Vue pour laquelle la condition est calculée
*
* @return string Condition SQL
*/
function type_plugin_elaborer_condition(string $typologie, string $type_plugin, string $vue) : string {
$filtre = '';
if ($type_plugin) {
@ -349,18 +357,12 @@ function type_plugin_elaborer_condition($typologie, $type_plugin, $vue) {
} else {
$filtre = 'plugins_typologies.id_mot=' . $id;
}
} elseif (($vue === 'liste') or ($vue === 'objet')) {
$filtre = 'id_mot=' . $id;
} elseif ($vue === 'navigation') {
$filtre = 'identifiant!=' . sql_quote($type_plugin);
} else {
// La typologie est arborescente et le type est une racine.
// Suivant la vue (liste ou affectation il faut utiliser un critère différent :
// - liste : on veut les sous-types du type racine
// - affectation : on veut toutes les affectations liées à ce type ou celui de ses enfants.
if (($vue === 'liste') or ($vue === 'objet')) {
$filtre = 'id_mot=' . $id;
} elseif ($vue === 'navigation') {
$filtre = 'identifiant!=' . sql_quote($type_plugin);
} else {
$filtre = 'id_parent=' . $id;
}
$filtre = 'id_parent=' . $id;
}
}
}

38
inc/svptype_typologie.php

@ -16,7 +16,7 @@ if (!defined('_ECRIRE_INC_VERSION')) {
*
* @return array Le tableau de la configuration par défaut indexé par l'identifiant de chaque typologie.
*/
function typologie_plugin_configurer() {
function typologie_plugin_configurer() : array {
// Deux typologies actuellement :
// - categorie : les catégories de plugin
// - tag : les tags de plugin
@ -63,7 +63,7 @@ function typologie_plugin_configurer() {
*
* @return void
*/
function typologie_plugin_creer_groupe() {
function typologie_plugin_creer_groupe() : void {
// Les groupes de typologie de plugin ont les caractéristiques communes suivantes :
// - groupe technique
// - sans tables liées
@ -113,14 +113,14 @@ function typologie_plugin_creer_groupe() {
*
* @api
*
* @param string $typologie Identifiant de la typologie concernée : categorie, tag...
* @param string $vue Nature des données à supprimer. Prend les valeurs :
* - liste : pour les types de plugin,
* - affectation : pour les affectations plugin-type de plugin.
* @param string $typologie Identifiant de la typologie concernée : categorie, tag...
* @param null|string $vue Nature des données à supprimer. Prend les valeurs :
* - liste : pour les types de plugin,
* - affectation : pour les affectations plugin-type de plugin.
*
* @return bool True si le vidage s'est bien passé, false sinon.
*/
function typologie_plugin_vider($typologie, $vue = 'liste') {
function typologie_plugin_vider(string $typologie, ?string $vue = 'liste') : bool {
// Initialisation du retour.
$retour = true;
@ -153,9 +153,9 @@ function typologie_plugin_vider($typologie, $vue = 'liste') {
* @param string $typologie Identifiant de la typologie concernée : categorie, tag...
* @param array $types Tableau des types présenté comme une arborescence ou à plat suivant la typologie.
*
* @return bool|int Nombre de catégories ajoutées.
* @return int Nombre de catégories ajoutées.
*/
function typologie_plugin_importer($typologie, $types) {
function typologie_plugin_importer(string $typologie, array $types) : int {
// Initialisation du nombre de types ajoutés.
$types_ajoutes = 0;
@ -222,11 +222,11 @@ function typologie_plugin_importer($typologie, $types) {
*
* @param string $typologie Identifiant de la typologie concernée : categorie, tag...
*
* @return bool|string Le nom du fichier d'export ou false si erreur.
* @return string Le nom du fichier d'export ou vide si erreur.
*/
function typologie_plugin_exporter($typologie) {
function typologie_plugin_exporter(string $typologie) : string {
// Initialisation de la sortie.
$retour = false;
$retour = '';
// Déterminer les informations du groupe typologique.
include_spip('inc/config');
@ -293,7 +293,7 @@ function typologie_plugin_exporter($typologie) {
*
* @return int Nombre d'affectations ajoutées.
*/
function typologie_plugin_importer_affectation($typologie, $affectations) {
function typologie_plugin_importer_affectation(string $typologie, array $affectations) : int {
// Initialisation du nombre d'affectations catégorie-plugin ajoutées.
$nb_affectations_ajoutees = 0;
@ -355,11 +355,11 @@ function typologie_plugin_importer_affectation($typologie, $affectations) {
*
* @param string $typologie Identifiant de la typologie concernée : categorie, tag...
*
* @return bool|string Le nom du fichier d'export ou false si erreur.
* @return string Le nom du fichier d'export ou vide si erreur.
*/
function typologie_plugin_exporter_affectation($typologie) {
function typologie_plugin_exporter_affectation(string $typologie) : string {
// Initialisation de la sortie.
$retour = false;
$retour = '';
// Déterminer les informations du groupe typologique.
include_spip('inc/config');
@ -406,7 +406,7 @@ function typologie_plugin_exporter_affectation($typologie) {
* @return array Tableau associatif des fichiers d'export fournissant, le chemin complet, le nom sans extension,
* la date et la taille de chaque fichier.
*/
function typologie_plugin_export_lister($typologie) {
function typologie_plugin_export_lister(string $typologie) : array {
// Initialisation de la liste
$exports = [];
@ -434,7 +434,7 @@ function typologie_plugin_export_lister($typologie) {
*
* @return array Tableau des types des plugins demandés.
*/
function typologie_plugin_collectionner($typologie, $filtres) {
function typologie_plugin_collectionner(string $typologie, array $filtres) : array {
// Initialisation de la collection
$types = [];
@ -509,7 +509,7 @@ function typologie_plugin_collectionner($typologie, $filtres) {
*
* @return string Condition SQL traduisant le critère (égalité ou IN).
*/
function typologie_plugin_calculer_critere($typologies, $table) {
function typologie_plugin_calculer_critere(array $typologies, string $table) : string {
// Initialisation de la condition pour le cas où il y aurait une erreur :
// -- on annule l'effet du critère.
$condition = '1=1';

3
prive/squelettes/contenu/svptype_typologie.html

@ -1,6 +1,7 @@
[(#AUTORISER{typologie}|sinon_interdire_acces)]
#SET{typologie, #ENV{typologie, categorie}}
#SET{vue, #ENV{vue, liste}}
#SET{type, #ENV{type, ''}}
#SET{id_groupe, #CONFIG{svptype/typologies/#GET{typologie}/id_groupe, 0}}
#SET{avec_enfants, #CONFIG{svptype/typologies/#ENV{typologie}/est_arborescente}|?{oui, ''}}
@ -60,7 +61,7 @@
[(#SET{fond_titre, [(#VAL{svptype:}|concat{#GET{typologie}_}|concat{#GET{vue}}|concat{_titre}|_T)]})]
[(#SET{liste_vide, [(#VAL{svptype:}|concat{#GET{typologie}_}|concat{#GET{vue}}|concat{_erreur_vide}|_T)]})]
[(#SET{option_tout, [(#VAL{svptype:}|concat{#GET{typologie}}|concat{_selection_option_tout}|_T)]})]
[(#SET{filtre, #GET{typologie}|type_plugin_elaborer_condition{#ENV{type}, #GET{vue}}})]
[(#SET{filtre, #GET{typologie}|type_plugin_elaborer_condition{#GET{type}, #GET{vue}}})]
<INCLURE{fond=prive/objets/#GET{vue}/types_plugins,
typologie=#GET{typologie},

34
saisies/selection_type_plugin_fonctions.php

@ -6,7 +6,15 @@ if (!defined('_ECRIRE_INC_VERSION')) {
return;
}
function selection_type_plugin_peupler($typologie, $options = []) {
/**
* Lister les types de plugins d'une typologie donnée pourl'afficher dans une saisie.
*
* @param string $typologie Identifiant de la typologie concernée : categorie, tag...
* @param null|array $options Options d'affichage de la liste
*
* @return array Liste des types de plugins de la typologie concernée à afficher
*/
function selection_type_plugin_peupler(string $typologie, ?array $options = []) : array {
// Déterminer les informations du groupe typologique.
include_spip('inc/config');
$config_typologie = lire_config("svptype/typologies/{$typologie}", []);
@ -82,22 +90,20 @@ function selection_type_plugin_peupler($typologie, $options = []) {
: $_type['titre'];
}
}
} else {
} elseif (!empty($options['niveau_affiche'])) {
// Si on ne veut pas de optgroup, on liste les types dans l'ordre alphabétique en gérant l'icone qui indique
// la profondeur quand cela est nécessaire (arborescence).
// Seule l'option du titre est à considérer.
if (!empty($options['niveau_affiche'])) {
$data = !empty($options['titre_affiche'])
? array_column($types, 'titre', 'identifiant')
: array_column($types, 'identifiant', 'identifiant');
} else {
include_spip('motsar_fonctions');
foreach ($types as $_type) {
$prefixe = mostar_tabulation($_type['profondeur']);
$data[$_type['identifiant']] = empty($options['titre_affiche'])
? $prefixe . $_type['identifiant']
: $prefixe . $_type['titre'];
}
$data = !empty($options['titre_affiche'])
? array_column($types, 'titre', 'identifiant')
: array_column($types, 'identifiant', 'identifiant');
} else {
include_spip('motsar_fonctions');
foreach ($types as $_type) {
$prefixe = mostar_tabulation($_type['profondeur']);
$data[$_type['identifiant']] = empty($options['titre_affiche'])
? $prefixe . $_type['identifiant']
: $prefixe . $_type['titre'];
}
}

4
svptype_administrations.php

@ -20,7 +20,7 @@ if (!defined('_ECRIRE_INC_VERSION')) {
*
* @return void
*/
function svptype_upgrade($nom_meta_base_version, $version_cible) {
function svptype_upgrade(string $nom_meta_base_version, string $version_cible) : void {
// Initialisation du tableau des mises à jour
$maj = [];
@ -54,7 +54,7 @@ function svptype_upgrade($nom_meta_base_version, $version_cible) {
*
* @return void
*/
function svptype_vider_tables($nom_meta_base_version) {
function svptype_vider_tables(string $nom_meta_base_version) : void {
// on exporte les données du plugin avant de tout supprimer
include_spip('inc/svptype_typologie');
include_spip('inc/config');

19
svptype_autorisations.php

@ -10,6 +10,7 @@ function svptype_autoriser() {
/**
* Autorisation minimale d'accès à toutes les pages ds SVP Typologie.
*
* Par défaut, seuls les administrateurs complets sont autorisés à utiliser le plugin.
* Cette autorisation est à la base de la plupart des autres autorisations du plugin.
*
@ -48,8 +49,10 @@ function autoriser_typeplugin_supprimer_dist($faire, $type, $id, $qui, $opt) {
// Vérification préalable de l'autorisation de suppression d'un 'mot'
// qui combine déjà celle du plugin mots et celle du plugin mots arborescents.
if (autoriser('supprimer', 'mot', $id, $qui, $opt)
and autoriser('typologie')) {
if (
autoriser('supprimer', 'mot', $id, $qui, $opt)
and autoriser('typologie')
) {
include_spip('inc/svptype_mot');
$id_mot = (int) $id;
$id_groupe = mot_lire_groupe($id_mot);
@ -89,8 +92,10 @@ function autoriser_typeplugin_modifier_dist($faire, $type, $id, $qui, $opt) {
$autoriser = false;
// Vérification préalable de l'autorisation standard du plugin 'mots'.
if (autoriser('modifier', 'mot', $id, $qui, $opt)
and autoriser('typologie')) {
if (
autoriser('modifier', 'mot', $id, $qui, $opt)
and autoriser('typologie')
) {
$autoriser = true;
}
@ -117,8 +122,10 @@ function autoriser_typeplugin_creer_dist($faire, $type, $id, $qui, $opt) {
$autoriser = false;
// Vérification préalable de l'autorisation standard du plugin 'mots'.
if (autoriser('creer', 'mot', $id, $qui, $opt)
and autoriser('typologie')) {
if (
autoriser('creer', 'mot', $id, $qui, $opt)
and autoriser('typologie')
) {
$autoriser = true;
}

2
svptype_fonctions.php

@ -34,7 +34,7 @@ include_spip('inc/svptype_type_plugin');
*
* @return void
*/
function critere_typologie_plugin_dist($idb, &$boucles, $critere) {
function critere_typologie_plugin_dist(string $idb, array &$boucles, Critere $critere) : void {
// Initialisation de la table (spip_mots ou spip_groupes_mots) et de la boucle concernée.
$boucle = &$boucles[$idb];
$table = $boucle->id_table;

96
svptype_pipelines.php

@ -18,11 +18,13 @@ if (!defined('_ECRIRE_INC_VERSION')) {
*
* @return array Données du pipeline complétées
**/
function svptype_formulaire_fond($flux) {
if (($env = $flux['args']['contexte'])
and ($flux['args']['form'] == 'editer_mot')
and isset($env['id_groupe'])
and ($id_groupe = (int) ($env['id_groupe']))) {
function svptype_formulaire_fond(array $flux) : array {
if (
($env = $flux['args']['contexte'])
and ($flux['args']['form'] === 'editer_mot')
and isset($env['id_groupe'])
and ($id_groupe = (int) ($env['id_groupe']))
) {
// Formulaire d'édition d'un mot :
// -- on teste si c'est un mot plugin (catégorie ou tag)
include_spip('inc/svptype_mot');
@ -92,7 +94,7 @@ function svptype_formulaire_fond($flux) {
*
* @return array Données du pipeline complétées
**/
function svptype_formulaire_verifier($flux) {
function svptype_formulaire_verifier(array $flux) : array {
if ($flux['args']['form'] == 'editer_mot') {
// Formulaire d'édition d'un mot :
// -- on récupère l'id du groupe.
@ -110,8 +112,10 @@ function svptype_formulaire_verifier($flux) {
// il faut exclure de la liste le mot lui-même si il existe déjà.
$where[] = 'id_mot!=' . $id_mot;
}
if (($identifiants = sql_allfetsel('identifiant', $from, $where))
and (in_array($identifiant, array_map('reset', $identifiants)))) {
if (
($identifiants = sql_allfetsel('identifiant', $from, $where))
and (in_array($identifiant, array_map('reset', $identifiants)))
) {
$flux['data']['identifiant'] = _T('svptype:identifiant_erreur_duplication');
}
}
@ -134,12 +138,14 @@ function svptype_formulaire_verifier($flux) {
*
* @return array Données du pipeline complétées
**/
function svptype_pre_insertion($flux) {
if ($flux['args']['table'] == 'spip_mots') {
function svptype_pre_insertion(array $flux) : array {
if ($flux['args']['table'] === 'spip_mots') {
// Création d'un mot :
// -- L'identifiant et l'id du groupe doivent être fournis
if ($identifiant = _request('identifiant')
and ($id_groupe = (int) (_request('id_groupe')))) {
if (
$identifiant = _request('identifiant')
and ($id_groupe = (int) (_request('id_groupe')))
) {
include_spip('inc/svptype_mot');
// On teste si c'est un mot plugin (catégorie ou tag)
if (groupe_est_typologie_plugin($id_groupe)) {
@ -163,13 +169,17 @@ function svptype_pre_insertion($flux) {
*
* @return array Données du pipeline complétées
**/
function svptype_pre_edition($flux) {
if ($flux['args']['table'] == 'spip_mots'
and $flux['args']['action'] == 'modifier') {
function svptype_pre_edition(array $flux) : array {
if (
($flux['args']['table'] === 'spip_mots')
and ($flux['args']['action'] === 'modifier')
) {
// Edition d'un mot :
// -- L'identifiant et l'id du groupe doivent être fournis
if ($identifiant = _request('identifiant')
and ($id_groupe = (int) (_request('id_groupe')))) {
if (
($identifiant = _request('identifiant'))
and ($id_groupe = (int) (_request('id_groupe')))
) {
// On teste si c'est un mot plugin (catégorie ou tag)
include_spip('inc/svptype_mot');
if (groupe_est_typologie_plugin($id_groupe)) {
@ -185,17 +195,23 @@ function svptype_pre_edition($flux) {
* Exclure les groupes de mots et les mots-clés relatifs à une typologie de plugin si le critère typologie_plugin
* n'est pas explicitement utilisé.
*
* @param object $boucle Description de la boucle.
* @param Boucle $boucle Description de la boucle.
*
* @return object Description complétée de la boucle.
* @return Boucle Description complétée de la boucle.
**/
function svptype_pre_boucle($boucle) {
function svptype_pre_boucle(Boucle $boucle) : Boucle {
// Vérifier qu'on n'a pas un critère utilisant l'id de la table auquel cas on ne fait.
if ((($boucle->type_requete == 'mots')
and (!isset($boucle->modificateur['criteres']['id_mot']))
and (!isset($boucle->modificateur['criteres']['id_groupe'])))
or (($boucle->type_requete == 'groupes_mots')
and (!isset($boucle->modificateur['criteres']['id_groupe'])))) {
if (
(
($boucle->type_requete === 'mots')
and !isset($boucle->modificateur['criteres']['id_mot'])
and !isset($boucle->modificateur['criteres']['id_groupe'])
)
or (
($boucle->type_requete === 'groupes_mots')
and !isset($boucle->modificateur['criteres']['id_groupe'])
)
) {
// Vérification de l'existence ou pas du critère {typologie_plugin}
$typologie_plugin = false;
foreach ($boucle->criteres as $_critere) {
@ -240,19 +256,24 @@ function svptype_pre_boucle($boucle) {
*
* @return array Données du pipeline complétées
**/
function svptype_afficher_contenu_objet($flux) {
function svptype_afficher_contenu_objet(array $flux) : array {
// On est bien en présence d'un objet
if (isset($flux['args']['type'], $flux['args']['id_objet'])) {
// Détermination de l'objet affiché
$objet = $flux['args']['type'];
$id_objet = $flux['args']['id_objet'];
if (($objet == 'mot') and $id_objet) {
if (
($objet === 'mot')
and $id_objet
) {
// On est bien en présence d'un mot:
// -- on teste si c'est un mot plugin (catégorie ou tag)
include_spip('inc/svptype_mot');
if (($id_groupe = mot_lire_groupe($id_objet))
and groupe_est_typologie_plugin($id_groupe)) {
if (
($id_groupe = mot_lire_groupe($id_objet))
and groupe_est_typologie_plugin($id_groupe)
) {
// On affiche l'identifiant du mot
$contexte = ['id_mot' => $id_objet];
$html_identifiant = recuperer_fond('prive/squelettes/inclure/inc-type_plugin_identifiant', $contexte);
@ -275,12 +296,13 @@ function svptype_afficher_contenu_objet($flux) {
*
* @return array Données du pipeline mise à jour.
*/
function svptype_affiche_milieu($flux) {
function svptype_affiche_milieu(array $flux) : array {
// Si on est sur la page d'un plugin, il faut inserer les formulaires d'affectations des types de plugin.
if (($exec = trouver_objet_exec($flux['args']['exec']))
if (
($exec = trouver_objet_exec($flux['args']['exec']))
and ($exec['edition'] !== true) // page visu
and ($type = $exec['type'])
and ($type == 'plugin')
and ($type === 'plugin')
and ($id_table_objet = $exec['id_table_objet'])
and isset($flux['args'][$id_table_objet])
and ($id_plugin = (int) ($flux['args'][$id_table_objet]))
@ -322,9 +344,9 @@ function svptype_affiche_milieu($flux) {
*
* @return array Flux mis à jour
*/
function svptype_affiche_droite($flux) {
function svptype_affiche_droite(array $flux) : array {
if (
($flux['args']['exec'] == 'plugin')
($flux['args']['exec'] === 'plugin')
and isset($flux['args']['id_plugin'])
and ($id_plugin = (int) ($flux['args']['id_plugin']))
) {
@ -375,7 +397,7 @@ function svptype_affiche_droite($flux) {
*
* @return array Collections complétées.
*/
function svptype_liste_ezcollection($collections) {
function svptype_liste_ezcollection(array $collections) : array {
// Les index désignent les collections. SVP Typologie rajoute :
// -- les collections correspondant aux typologies supportées
include_spip('inc/config');
@ -435,7 +457,7 @@ function svptype_liste_ezcollection($collections) {
*
* @return array Données du pipeline complétées
**/
function svptype_post_ezcollection($flux) {
function svptype_post_ezcollection(array $flux) : array {
// Extraction des informations sur la collection.
// La collection et la configuration existent toujours.
$collection = $flux['args']['collection'];
@ -485,7 +507,7 @@ function svptype_post_ezcollection($flux) {
*
* @return array Données du pipeline complétées
**/
function svptype_post_ezressource($flux) {
function svptype_post_ezressource(array $flux) : array {
// Extraction des informations sur la collection.
// La collection et la configuration existent toujours.
$collection = $flux['args']['collection'];

Loading…
Cancel
Save