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.
411 lines
13 KiB
411 lines
13 KiB
<?php |
|
|
|
/** |
|
* Utilisation de pipelines |
|
* |
|
* @package SPIP\Formidable\Pipelines |
|
**/ |
|
|
|
// Sécurité |
|
if (!defined('_ECRIRE_INC_VERSION')) { |
|
return; |
|
} |
|
include_spip('inc/formidable_fichiers'); |
|
define( |
|
'_RACCOURCI_MODELE_FORMIDABLE', |
|
'(<(formulaire\|formidable|formidable|form)' # <modele |
|
.'([0-9]*)\s*' # id |
|
.'([|](?:<[^<>]*>|[^>])*)?' # |arguments (y compris des tags <...>) |
|
.'>)' # fin du modele > |
|
.'\s*(<\/a>)?' # eventuel </a> |
|
); |
|
|
|
/** |
|
* Ajouter la protection NoSpam de base a formidable (jeton) |
|
* |
|
* @param $formulaires |
|
* @return array |
|
*/ |
|
function formidable_nospam_lister_formulaires($formulaires) { |
|
$formulaires[] = 'formidable'; |
|
return $formulaires; |
|
} |
|
|
|
/** |
|
* Trouver les liens <form |
|
* @param $texte |
|
* @return array |
|
*/ |
|
function formidable_trouve_liens($texte) { |
|
$formulaires = array(); |
|
if (preg_match_all(','._RACCOURCI_MODELE_FORMIDABLE.',ims', $texte, $regs, PREG_SET_ORDER)) { |
|
foreach ($regs as $r) { |
|
$id_formulaire = 0; |
|
if ($r[2] == 'formidable') { |
|
$id_formulaire = $r[3]; |
|
} elseif ($r[2] == 'form') { |
|
$id_formulaire = sql_getfetsel( |
|
'id_formulaire', |
|
'spip_formulaires', |
|
'identifiant='.sql_quote('form'.$r[3]) |
|
); |
|
} elseif ($r[2] == 'formulaire|formidable') { |
|
$args = ltrim($r[4], '|'); |
|
if(strpos($args,'=')!==false) { |
|
$args = explode('=', $args); |
|
$args = $args[1]; |
|
} |
|
if(strpos($args,'|')!==false) { |
|
$args = explode('|', $args); |
|
$args = trim(reset($args)); |
|
} |
|
if (is_numeric($args)) { |
|
$id_formulaire = intval($args); |
|
} else { |
|
$id_formulaire = sql_getfetsel( |
|
'id_formulaire', |
|
'spip_formulaires', |
|
'identifiant='.sql_quote($args) |
|
); |
|
} |
|
} |
|
if ($id_formulaire = intval($id_formulaire)) { |
|
$formulaires[$id_formulaire] = $id_formulaire; |
|
} |
|
} |
|
} |
|
return $formulaires; |
|
} |
|
|
|
/** |
|
* Associer/dissocier les formulaires a un objet qui les utilise (ou ne les utilise plus) |
|
* @param $flux |
|
* @return mixed |
|
*/ |
|
function formidable_post_edition($flux) { |
|
if (isset($flux['args']['table']) |
|
and $table = $flux['args']['table'] |
|
and $id_objet = intval($flux['args']['id_objet']) |
|
and $primary = id_table_objet($table) |
|
and $row = sql_fetsel('*', $table, "$primary=".intval($id_objet)) |
|
) { |
|
$objet = objet_type($table); |
|
$contenu = implode(' ', $row); |
|
|
|
// On cherche les modèles insérés dans les textes du contenu |
|
$formulaires = formidable_trouve_liens($contenu); |
|
|
|
// On cherche les liaisons "vu dans le texte" qui étaient là avant |
|
include_spip('action/editer_liens'); |
|
$deja = objet_trouver_liens(array('formulaire' => '*'), array($objet => $id_objet), array('vu="oui"')); |
|
|
|
// On compare pour savoir quelles liaisons "dans le texte" n'est plus là désormais |
|
$del = array(); |
|
if (count($deja)) { |
|
foreach ($deja as $l) { |
|
if (!isset($formulaires[$l['id_formulaire']])) { |
|
$del[] = $l['id_formulaire']; |
|
} |
|
} |
|
} |
|
|
|
// Pour les liens trouvés dans la dernière version des textes |
|
if (count($formulaires)) { |
|
objet_associer(array('formulaire' => $formulaires), array($objet => $id_objet), array('vu' => 'oui')); |
|
objet_qualifier_liens(array('formulaire' => $formulaires), array($objet => $id_objet), array('vu' => 'oui')); |
|
} |
|
|
|
// Pour les liens qui étaient avant dans le texte mais qui n'y sont plus |
|
// => on garde toujours la liaison mais avec vu=non, à chacun de retirer la liaison si on ne veut plus du tout, comme pour les docs |
|
if (count($del)) { |
|
objet_qualifier_liens(array('formulaire' => $del), array($objet => $id_objet), array('vu' => 'non')); |
|
} |
|
} |
|
|
|
return $flux; |
|
} |
|
|
|
/** |
|
* Afficher les formulaires utilises par un objet |
|
* @param $flux |
|
* @return mixed |
|
*/ |
|
function formidable_affiche_droite($flux) { |
|
if ($e = trouver_objet_exec($flux['args']['exec']) |
|
and isset($e['type']) |
|
and $objet = $e['type'] |
|
and isset($flux['args'][$e['id_table_objet']]) |
|
and $id = $flux['args'][$e['id_table_objet']] |
|
and sql_countsel('spip_formulaires_liens', 'objet='.sql_quote($objet).' AND id_objet='.intval($id))) { |
|
$flux['data'] .= recuperer_fond( |
|
'prive/squelettes/inclure/formulaires_lies', |
|
array('objet' => $objet, 'id_objet' => $id) |
|
); |
|
} |
|
return $flux; |
|
} |
|
|
|
/** |
|
* Afficher l'édition des liens sur les objets configurés |
|
* + les dernières réponses sur la page d'accueil (si configurée) |
|
**/ |
|
function formidable_affiche_milieu($flux) { |
|
|
|
//Afficher l'édition des liens sur les objets configurés |
|
include_spip('inc/config'); |
|
$texte = ''; |
|
$e = trouver_objet_exec($flux['args']['exec']); |
|
|
|
if ($e and !$e['edition'] and isset($flux['args'][$e['id_table_objet']]) and in_array($e['table_objet_sql'], lire_config('formidable/objets', array()))) { |
|
$texte .= recuperer_fond('prive/objets/editer/liens', array( |
|
'table_source' => 'formulaires', |
|
'objet' => $e['type'], |
|
'id_objet' => $flux['args'][$e['id_table_objet']] |
|
)); |
|
} |
|
|
|
if ($texte) { |
|
if ($p=strpos($flux['data'], '<!--affiche_milieu-->')) { |
|
$flux['data'] = substr_replace($flux['data'], $texte, $p, 0); |
|
} else { |
|
$flux['data'] .= $texte; |
|
} |
|
} |
|
|
|
if (in_array($flux['args']['exec'], array('accueil', 'suivi_edito')) |
|
and lire_config('formidable/reponses_page_accueil') |
|
) { |
|
$flux['data'] .= recuperer_fond('prive/objets/liste/formulaires_reponses', array(), array('ajax' => true)); |
|
} |
|
return $flux; |
|
} |
|
|
|
/** |
|
* Optimiser la base de donnée en enlevant les liens de formulaires supprimés |
|
* |
|
* @pipeline optimiser_base_disparus |
|
* @param array $flux |
|
* Données du pipeline |
|
* @return array |
|
* Données du pipeline |
|
*/ |
|
function formidable_optimiser_base_disparus($flux) { |
|
// Les formulaires qui sont à la poubelle |
|
$res = sql_select( |
|
'id_formulaire AS id', |
|
'spip_formulaires', |
|
'statut='.sql_quote('poubelle') |
|
); |
|
$res2 = sql_select( |
|
'id_formulaire AS id', |
|
'spip_formulaires', |
|
'statut='.sql_quote('poubelle') |
|
);//Copie pour supprimer les fichiers |
|
|
|
// On génère la suppression |
|
$flux['data'] += optimiser_sansref('spip_formulaires', 'id_formulaire', $res); |
|
|
|
while ($reponse = sql_fetch($res2)) { |
|
$flux['data'] += formidable_effacer_fichiers_formulaire($reponse['id']); |
|
} |
|
|
|
// les reponses qui sont associees a un formulaire inexistant |
|
$res = sql_select( |
|
'R.id_formulaire AS id', |
|
'spip_formulaires_reponses AS R LEFT JOIN spip_formulaires AS F ON R.id_formulaire=F.id_formulaire', |
|
'R.id_formulaire > 0 AND F.id_formulaire IS NULL' |
|
); |
|
|
|
$flux['data'] += optimiser_sansref('spip_formulaires_reponses', 'id_formulaire', $res); |
|
|
|
// Les réponses qui sont à la poubelle |
|
$res = sql_select( |
|
'id_formulaires_reponse AS id, id_formulaire AS form', |
|
'spip_formulaires_reponses', |
|
'statut='.sql_quote('poubelle') |
|
); |
|
$res2 = sql_select( |
|
'id_formulaires_reponse AS id, id_formulaire AS form', |
|
'spip_formulaires_reponses', |
|
'statut='.sql_quote('poubelle') |
|
); //Copie pour la suppression des fichiers des réponses, c'est idiot de pas pouvoir faire une seule requete |
|
// On génère la suppression |
|
$flux['data'] += optimiser_sansref('spip_formulaires_reponses', 'id_formulaires_reponse', $res); |
|
while ($reponse = sql_fetch($res2)) { |
|
$flux['data'] += formidable_effacer_fichiers_reponse($reponse['form'], $reponse['id']); |
|
} |
|
|
|
|
|
// les champs des reponses associes a une reponse inexistante |
|
$res = sql_select( |
|
'C.id_formulaires_reponse AS id', |
|
'spip_formulaires_reponses_champs AS C |
|
LEFT JOIN spip_formulaires_reponses AS R ON C.id_formulaires_reponse=R.id_formulaires_reponse', |
|
'C.id_formulaires_reponse > 0 AND R.id_formulaires_reponse IS NULL' |
|
); |
|
|
|
$flux['data'] += optimiser_sansref('spip_formulaires_reponses_champs', 'id_formulaires_reponse', $res); |
|
|
|
|
|
// Les liens morts entre formulaires et objets supprimes |
|
include_spip('action/editer_liens'); |
|
$flux['data'] += objet_optimiser_liens(['formulaire' => '*'], '*'); |
|
|
|
return $flux; |
|
} |
|
|
|
/** |
|
* S'assurer que le traitement email ait lieu après le traitement enregistrement |
|
* |
|
* @pipeline formidable_traitements |
|
* @param array $flux |
|
* @return array $flux |
|
**/ |
|
function formidable_formidable_traitements($flux) { |
|
if (isset($flux['data']['email']) and isset($flux['data']['enregistrement'])) { |
|
$keys = array_keys($flux['data']); |
|
$position_email = array_search('email', $keys); |
|
$position_enregistrement = array_search('enregistrement', $keys); |
|
|
|
if ($position_enregistrement > $position_email) { // si enregistrement après email |
|
$nouveau_tab = array(); |
|
foreach ($keys as $key) { //on reconstruit le tableau, en inversant simplement email et enregistrement |
|
if ($key == 'email') { |
|
$nouveau_tab['enregistrement'] = $flux['data']['enregistrement']; |
|
} elseif ($key == 'enregistrement') { |
|
$nouveau_tab['email'] = $flux['data']['email']; |
|
} else { |
|
$nouveau_tab[$key] = $flux['data'][$key]; |
|
} |
|
} |
|
$flux['data'] = $nouveau_tab; |
|
} |
|
} |
|
|
|
return $flux; |
|
} |
|
|
|
/** Hasher les ip régulièrement |
|
* @param array $flux |
|
* @return array $flux |
|
**/ |
|
function formidable_taches_generales_cron($flux) { |
|
$flux['formidable_hasher_ip'] = 24*3600; |
|
$flux['formidable_effacer_fichiers_email'] = 24*3600; |
|
$flux['formidable_effacer_enregistrements'] = 24*3600; |
|
return $flux; |
|
} |
|
|
|
/** Déclarer les formulaires et les réponses |
|
* au plugin corbeille |
|
* @param array $flux; |
|
* @return array $flux; |
|
**/ |
|
function formidable_corbeille_table_infos($flux) { |
|
$flux['formulaires']= array( |
|
'statut'=>'poubelle', |
|
'table'=>'formulaires', |
|
'tableliee'=>array('spip_formulaires_liens') |
|
); |
|
$flux['formulaires_reponses']= array( |
|
'statut'=>'poubelle', |
|
'table'=>'formulaires_reponses' |
|
); |
|
return $flux; |
|
} |
|
|
|
|
|
/** |
|
* Définir une fonction de contrôleur pour Crayons si on tente d'éditer un champ d'une réponse de formulaire. |
|
* |
|
* Si on édite un champ d'une réponse de formulaires avec Crayons, sans avoir créé manuellement de contrôleur spécifique |
|
* pour le champ en question, Crayons propose soit un textarea, soit un input. |
|
* |
|
* Vu que l'on connaît les déclarations de nos champ , on va les utiliser pour créer |
|
* un formulaire d'édition plus adapté à notre champ. |
|
* |
|
* @pipeline crayons_controleur |
|
* @param array $flux |
|
* @return array |
|
*/ |
|
function formidable_crayons_controleur($flux) { |
|
// si Crayons a déjà trouvé de contrôleur PHP, on ne fait rien |
|
if ($flux['data'] != 'controleur_dist') { |
|
return $flux; |
|
} |
|
$type = $flux['args']['type']; |
|
|
|
if ($type === 'formulaires_reponses_champ') { |
|
$flux['data'] = charger_fonction('formulaires_reponses_champ', 'controleurs'); |
|
} |
|
|
|
return $flux; |
|
} |
|
|
|
/** |
|
* Vérifier une saisie envoyée depuis un formulaire de Crayons. |
|
* |
|
* @pipeline crayons_verifier |
|
* @param array $flux |
|
* @return array |
|
*/ |
|
function formidable_crayons_verifier($flux) { |
|
// Le nom du modèle envoyé par le controleur/formulaires_reponses_champs. |
|
if ($flux['args']['modele'] !== 'valeur' or $flux['args']['type'] !== 'formulaires_reponses_champ') { |
|
return $flux; |
|
} |
|
include_spip('inc/saisies'); |
|
$id = $flux['args']['id']; |
|
$valeur = $flux['args']['content']['valeur']; |
|
$data = sql_fetsel( |
|
['nom', 'saisies'], |
|
['spip_formulaires_reponses_champs AS c', 'spip_formulaires_reponses AS r', 'spip_formulaires AS f'], |
|
["id_formulaires_reponses_champ = $id", 'r.id_formulaires_reponse = c.id_formulaires_reponse', 'f.id_formulaire = r.id_formulaire'] |
|
); |
|
include_spip('formidable_fonctions'); |
|
$saisies = formidable_deserialize($data['saisies']); |
|
$saisie = saisies_chercher($saisies, $data['nom']); |
|
if (saisies_saisie_est_tabulaire($saisie)) { |
|
$atrouver = 'content_'.$flux['args']['wid'].'_valeur'; |
|
$valeur = saisies_request($atrouver); |
|
$flux['data']['normaliser']['valeur'] = formidable_serialize($valeur); |
|
} |
|
saisies_set_request($data['nom'], $valeur); |
|
$erreur = saisies_verifier(array($saisie), false); |
|
|
|
if ($erreur) { |
|
$flux['data']['erreurs']['valeur'] = implode('<br />',$erreur); |
|
} elseif (saisies_request($data['nom']) !== $valeur) { |
|
$flux['data']['normaliser']['valeur'] = $normaliser; |
|
} |
|
return $flux; |
|
} |
|
|
|
|
|
|
|
/** |
|
* Function _revision pour le crayonnage direct des champs, |
|
* permet ensuite d'utiliser si besoin un pipeline |
|
* cf échange avec Cerdic sur https://git.spip.net/spip-contrib-extensions/crayons/pulls/4 |
|
* Notes : peut être qu'il faudrait vraiment déclarer les champs comme des objets? |
|
* A reflechir quand on travaillera vraiment au versionnage |
|
* Note : paramètres obscures, mais tentons : |
|
* @param int $id id de la réponse |
|
* @param array $champs champs sql à modifier, pour nous juste un |
|
* @param string $type type de crayonnage |
|
* @param string $ref ref technique du crayon, pas utilisé chez nous |
|
**/ |
|
function formulaires_reponses_champ_revision($id, $champs, $type, $ref) { |
|
include_spip('inc/modifier'); |
|
return objet_modifier_champs($type, $id, array(), $champs); |
|
} |
|
|
|
/** |
|
* La saisie `champ` est autonome |
|
* @param array $flux |
|
* @return array $flux |
|
**/ |
|
function formidable_saisies_autonomes($flux) { |
|
$flux[] = 'champ'; |
|
return $flux; |
|
}
|
|
|