You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
369 lines
13 KiB
369 lines
13 KiB
<?php |
|
|
|
/** |
|
* Utilisation des pipelines |
|
* |
|
* @package SPIP\Saisies\Pipelines |
|
**/ |
|
|
|
// Sécurité |
|
if (!defined('_ECRIRE_INC_VERSION')) { |
|
return; |
|
} |
|
|
|
/** |
|
* Préambule, les constantes pour afficher_si |
|
**/ |
|
if (!defined('_SAISIES_AFFICHER_SI_JS_SHOW')) { |
|
define ('_SAISIES_AFFICHER_SI_JS_SHOW', 'slideDown(800)'); |
|
} |
|
if (!defined('_SAISIES_AFFICHER_SI_JS_HIDE')) { |
|
define ('_SAISIES_AFFICHER_SI_JS_HIDE', 'slideUp(800)'); |
|
} |
|
|
|
/** |
|
* Ajoute les scripts JS et CSS de saisies dans l'espace privé |
|
* |
|
* @param string $flux |
|
* @return string |
|
**/ |
|
function saisies_header_prive($flux) { |
|
foreach (array('javascript/saisies.js', 'javascript/saisies_afficher_si.js') as $script) { |
|
$js = timestamp(find_in_path($script)); |
|
$flux .= "\n<script type='text/javascript' src='$js'></script>\n"; |
|
} |
|
$js = timestamp(find_in_path('javascript/saisies_textarea_counter.js')); |
|
$flux .= '<script type="text/javascript">saisies_caracteres_restants = "'._T('saisies:caracteres_restants').'";</script>'; |
|
$flux .= "\n<script type='text/javascript' src='$js'></script>\n"; |
|
$flux .= afficher_si_definir_fonctions(); |
|
include_spip('inc/filtres'); |
|
$css = timestamp(find_in_path('css/saisies.css')); |
|
$flux .= "\n<link rel='stylesheet' href='$css' type='text/css' media='all' />\n"; |
|
$css_constructeur = timestamp(find_in_path('css/formulaires_constructeur.css')); |
|
$flux .= "\n<link rel='stylesheet' href='$css_constructeur' type='text/css' />\n"; |
|
|
|
return $flux; |
|
} |
|
|
|
/** |
|
* Insérer automatiquement les scripts JS et CSS de saisies dans toutes les pages de l'espace public |
|
* @param array $flux |
|
* @return array $flux modifié |
|
**/ |
|
function saisies_insert_head($flux) { |
|
include_spip('inc/config'); |
|
if(lire_config('saisies/assets_global')) { |
|
$flux .= saisies_generer_head(); |
|
} |
|
return $flux; |
|
} |
|
|
|
/** |
|
* Ajoute les scripts JS et CSS de saisies dans l'espace public |
|
* |
|
* Ajoute également de quoi gérer le datepicker de la saisie date si |
|
* celle-ci est utilisée dans la page. |
|
* |
|
* @param string $flux |
|
* @return string |
|
**/ |
|
function saisies_affichage_final($flux) { |
|
include_spip('inc/config'); |
|
if ( |
|
!lire_config('saisies/assets_global') |
|
and $GLOBALS['html'] // si c'est bien du HTML |
|
and strpos($flux, '<!--!inserer_saisie_editer-->') !== false // et qu'on a au moins une saisie |
|
and strpos($flux, '<head') !== false // et qu'on a la balise <head> quelque part |
|
) { |
|
$head = saisies_generer_head($flux, true); |
|
$flux = str_replace('</head>', "$head</head>", $flux); |
|
} |
|
|
|
return $flux; |
|
} |
|
|
|
/** |
|
* Génère le contenu du head pour les saisies (css et js) |
|
* @param str $html_content le contenu html où l'on teste la présence de saisies |
|
* @param bool (false) $tester_saisies |
|
* |
|
* @return string |
|
*/ |
|
function saisies_generer_head($html_content = '', $tester_saisies = false) { |
|
|
|
$flux = ''; |
|
include_spip('inc/filtres'); |
|
// Pas de saisie alors qu'on veux tester leur présence > hop, on retourne direct |
|
if ($tester_saisies and strpos($html_content, '<!--!inserer_saisie_editer-->') === false) { |
|
return $flux; |
|
} |
|
|
|
$css = timestamp(find_in_path('css/saisies.css')); |
|
$ins_css = "\n<link rel='stylesheet' href='$css' type='text/css' media='all' />\n"; |
|
|
|
$flux = $ins_css . $flux; |
|
|
|
// on insère le JS à la fin du <head> |
|
$ins_js = ''; |
|
// JS général |
|
$js = timestamp(find_in_path('javascript/saisies.js')); |
|
$ins_js .= "\n<script type='text/javascript' src='$js'></script>\n"; |
|
|
|
|
|
// si on a une saisie de type textarea avec maxlength, on va charger un script |
|
if (!$tester_saisies or (strpos($html_content, 'textarea') !==false and strpos($html_content, 'maxlength') !==false)) { |
|
$js = timestamp(find_in_path('javascript/saisies_textarea_counter.js')); |
|
$ins_js .= '<script type="text/javascript">saisies_caracteres_restants = "'._T('saisies:caracteres_restants').'";</script>'; |
|
$ins_js .= "\n<script type='text/javascript' src='$js'></script>\n"; |
|
} |
|
// Afficher_si |
|
if (!$tester_saisies or strpos($html_content, 'data-afficher_si') !==false) { |
|
$ins_js .= afficher_si_definir_fonctions(); |
|
$js = timestamp(find_in_path('javascript/saisies_afficher_si.js')); |
|
$ins_js .= "\n<script type='text/javascript' src='$js'></script>\n"; |
|
} |
|
|
|
$flux = $flux . $ins_js; |
|
|
|
return $flux; |
|
} |
|
|
|
/** |
|
* Déclarer automatiquement les champs d'un formulaire CVT qui déclare des saisies |
|
* |
|
* Recherche une fonction `formulaires_XX_saisies_dist` et l'utilise si elle |
|
* est présente. Cette fonction doit retourner une liste de saisies dont on se |
|
* sert alors pour calculer les champs utilisés dans le formulaire. |
|
* |
|
* @param array $flux |
|
* @return array |
|
**/ |
|
function saisies_formulaire_charger($flux) { |
|
// Si le flux data est inexistant, on quitte : Le CVT d'origine a décidé de ne pas continuer |
|
if (!is_array($flux['data'])) { |
|
return $flux; |
|
} |
|
|
|
// Il faut que la fonction existe et qu'elle retourne bien un tableau |
|
include_spip('inc/saisies'); |
|
$saisies = saisies_chercher_formulaire($flux['args']['form'], $flux['args']['args'], $flux['args']['je_suis_poste']); |
|
|
|
if ($saisies) { |
|
|
|
// Si c'est un formulaire de config, on va régler automatiquement les defaut |
|
if (strpos($flux['args']['form'], 'configurer_') === 0) { |
|
$par_nom = saisies_lister_par_nom($saisies); |
|
$contexte = array(); |
|
if (isset($par_nom['_meta_casier'])) { |
|
$meta = $par_nom['_meta_casier']['options']['defaut']; |
|
} else { |
|
$meta = str_replace('configurer_', '', $flux['args']['form']); |
|
} |
|
$saisies = saisies_preremplir_defaut_depuis_config($saisies, $meta); |
|
} |
|
$contexte = saisies_lister_valeurs_defaut($saisies); |
|
// On rajoute ce contexte en défaut de ce qui existe déjà (qui est prioritaire) |
|
$flux['data'] = array_merge($contexte, $flux['data']); |
|
|
|
// On cherche si on gère des étapes |
|
if ($etapes = saisies_lister_par_etapes($saisies)) { |
|
$flux['data']['_etapes'] = count($etapes); |
|
$flux['data']['_saisies_par_etapes'] = $etapes; |
|
} |
|
|
|
// On ajoute le tableau complet des saisies |
|
$flux['data']['_saisies'] = $saisies; |
|
|
|
// On ajoute également un bouton submit caché qui sert exclusivement à la validation au clavier |
|
if (!isset($flux['data']['_hidden'])) { |
|
$flux['data']['_hidden'] = ''; |
|
} |
|
$flux['data']['_hidden'] .= '<!--Saisies : bouton caché pour validation au clavier--><button type="submit" value="1" hidden tabindex="-1" style="display:none"></button>'; |
|
} |
|
|
|
return $flux; |
|
} |
|
|
|
/** |
|
* Pre remplir les options 'defaut' des saisies depuis `lire_config()` |
|
* @param array $saisies; |
|
* @param string $meta_case; |
|
* @return array $saisies |
|
**/ |
|
function saisies_preremplir_defaut_depuis_config($saisies, $meta_case) { |
|
include_spip('inc/config'); |
|
foreach ($saisies as &$saisie) { |
|
if (isset ($saisie['options']['nom']) and $saisie['options']['nom']!='_meta_casier') { |
|
$nom = $saisie['options']['nom']; |
|
$nom = str_replace('[', '/', $nom); |
|
$nom = str_replace(']', '', $nom); |
|
$nom = trim($nom, '/'); |
|
$config = lire_config("$meta_case/$nom"); |
|
if ($config !== null) { |
|
$saisie['options']['defaut'] = $config; |
|
} |
|
$contexte[$nom] = isset($saisies['options']['defaut']) ? $saisies['options']['defaut'] : ''; |
|
if (isset($saisie['saisies'])) { |
|
$saisie['saisies'] = saisies_preremplir_defaut_depuis_config($saisie['saisies'], $meta_case); |
|
} |
|
} |
|
} |
|
return $saisies; |
|
} |
|
|
|
/** |
|
* Aiguiller CVT vers un squelette propre à Saisies lorsqu'on a déclaré des saisies et qu'il n'y a pas déjà un HTML |
|
* |
|
* Dans le cadre d'un formulaire CVT demandé, si ce formulaire a déclaré des saisies, et |
|
* qu'il n'y a pas de squelette spécifique pour afficher le HTML du formulaire, |
|
* alors on utilise le formulaire générique intégré au plugin saisie, qui calculera le HTML |
|
* à partir de la déclaration des saisies indiquées. |
|
* |
|
* @see saisies_formulaire_charger() |
|
* |
|
* @param array $flux |
|
* @return array |
|
**/ |
|
function saisies_styliser($flux) { |
|
if ( |
|
// Si on cherche un squelette de formulaire |
|
strncmp($flux['args']['fond'], 'formulaires/', 12) == 0 |
|
// Et que ce n'est pas une inclusion (on teste ça pour l'instant mais c'est pas très générique) |
|
and strpos($flux['args']['fond'], 'inc-', 12) === false |
|
// Et qu'il y a des saisies dans le contexte |
|
and isset($flux['args']['contexte']['_saisies']) |
|
// Et que le fichier choisi est vide ou n'existe pas |
|
and include_spip('inc/flock') |
|
and $ext = $flux['args']['ext'] |
|
and lire_fichier($flux['data'].'.'.$ext, $contenu_squelette) |
|
and !trim($contenu_squelette) |
|
) { |
|
$flux['data'] = preg_replace("/\.$ext$/", '', find_in_path("formulaires/inc-saisies-cvt.$ext")); |
|
} |
|
|
|
return $flux; |
|
} |
|
|
|
/** |
|
* Ajouter les vérifications déclarées dans la fonction "saisies" du CVT |
|
* |
|
* Si un formulaire CVT a déclaré des saisies, on utilise sa déclaration |
|
* pour effectuer les vérifications du formulaire. |
|
* |
|
* @see saisies_formulaire_charger() |
|
* @uses saisies_verifier() |
|
* |
|
* @param array $flux |
|
* Liste des erreurs du formulaire |
|
* @return array |
|
* iste des erreurs |
|
*/ |
|
function saisies_formulaire_verifier($flux) { |
|
// Il faut que la fonction existe et qu'elle retourne bien un tableau |
|
include_spip('inc/saisies'); |
|
|
|
$saisies = saisies_chercher_formulaire($flux['args']['form'], $flux['args']['args'], true); |
|
if ($saisies and !saisies_lister_par_etapes($saisies, true)) { |
|
$erreurs = saisies_verifier($saisies); |
|
|
|
if ($erreurs and !isset($erreurs['message_erreur'])) { |
|
$erreurs['message_erreur'] = _T('saisies:erreur_generique'); |
|
} |
|
if (!is_array($flux['data'])) { |
|
$flux['data'] = array(); |
|
} |
|
|
|
$flux['data'] = array_merge($erreurs, $flux['data']); |
|
} |
|
return $flux; |
|
} |
|
|
|
/** |
|
* Ajouter les vérifications déclarées dans la fonction "saisies" du CVT mais pour les étapes |
|
* |
|
* @see saisies_formulaire_charger() |
|
* @uses saisies_verifier() |
|
* |
|
* @param array $flux |
|
* Liste des erreurs du formulaire |
|
* @return array |
|
* iste des erreurs |
|
*/ |
|
function saisies_formulaire_verifier_etape($flux) { |
|
$saisies = saisies_chercher_formulaire($flux['args']['form'], $flux['args']['args'], true); |
|
if ($saisies) { |
|
//A quelle étape est-on ? |
|
$etape = $flux['args']['etape']; |
|
$erreurs = saisies_verifier($saisies, true, $etape); |
|
$flux['data'] = array_merge($erreurs, $flux['data']); |
|
// Si on est en train de vérifier la dernière étape courante et qu'elle n'a pas d'erreur, alors voir si on peut sauter les étapes suivantes |
|
if ( |
|
isset($flux['args']['etape_saisie']) |
|
and $etape == $flux['args']['etape_saisie'] |
|
and empty($flux['data']) |
|
and (!$flux['args']['etape_demandee'] or $flux['args']['etape_demandee'] > $etape) |
|
) { |
|
if ( |
|
$avance_rapide = saisies_determiner_avance_rapide($saisies, $etape) |
|
and $avance_rapide != $etape + 1 |
|
) { |
|
set_request('aller_a_etape', $avance_rapide); |
|
$flux['args']['etape_demandee'] = $avance_rapide; |
|
} |
|
} |
|
} |
|
|
|
|
|
return $flux; |
|
} |
|
|
|
/** |
|
* À la réception d'un formulaire de config |
|
* rechercher les input avec l'option cle_secrete. |
|
* Si la valeur postée est vide, cela veut dire qu'on conserve celle en base. |
|
* Dans ce cas, reinjecter cette dernière en `set_request'. |
|
* Cela permet de ne pas perdre la valeur à chaque configuration du formulaire |
|
* @param array $flux; |
|
* @return array $flux; |
|
**/ |
|
function saisies_formulaire_receptionner($flux) { |
|
if (strpos($flux['args']['form'], 'configurer_') === 0) { |
|
$config = str_replace('configurer_', '', $flux['args']['form']); |
|
$saisies = saisies_chercher_formulaire($flux['args']['form'], $flux['args']['args'], true); |
|
$avec_cle_secrete = saisies_lister_avec_option('cle_secrete', $saisies); |
|
foreach ($avec_cle_secrete as $saisie => $description) { |
|
if (!saisies_request($saisie)) { |
|
$saisie = str_replace('[', '/', $saisie); |
|
$saisie = str_replace(']', '', $saisie); |
|
$saisie = trim($saisie, '/'); |
|
saisies_set_request($saisie, lire_config("$config/$saisie")); |
|
} |
|
} |
|
} |
|
return $flux; |
|
|
|
} |
|
|
|
/** |
|
* Retourne une chaine renvoyant les functions js de masquage/affiche |
|
**/ |
|
function afficher_si_definir_fonctions() { |
|
return '<script> |
|
function afficher_si_show(src) { |
|
src.'._SAISIES_AFFICHER_SI_JS_SHOW.'; |
|
} |
|
function afficher_si_hide(src) { |
|
src.'._SAISIES_AFFICHER_SI_JS_HIDE.'; |
|
} |
|
</script>'; |
|
} |
|
|
|
/** |
|
* Bien que proposé avec le plugin verifier |
|
* la vérification `fichiers` n'a de sens que si la saisie `fichiers` du plugin CVT-Upload est disponible. |
|
* @param array $flux |
|
* @return array $flux |
|
**/ |
|
function saisies_saisies_verifier_lister_disponibles(array $flux): array { |
|
unset($flux['data']['disponibles']['fichiers']);// CVTUpload s'occupe tout seul de remettre cette verification |
|
}
|
|
|