source: spip-zone/_plugins_/formidable/trunk/inc/formidable_fichiers.php @ 112893

Last change on this file since 112893 was 112893, checked in by maieul@…, 2 years ago

mieux ranger

File size: 20.5 KB
Line 
1<?php
2
3// Sécurité
4if (!defined('_ECRIRE_INC_VERSION')) {
5        return;
6}
7include_spip('inc/flock');
8include_spip('inc/documents');
9if (!defined('_FORMIDABLE_TAILLE_MAX_FICHIERS_EMAIL')) {// la taille maximum (en Mio) des fichiers qu'on autorise directement en PJ dans les emails.
10        define('_FORMIDABLE_TAILLE_MAX_FICHIERS_EMAIL', 10);
11}
12
13
14// Lieux de stockages des fichiers
15if (!defined('_DIR_FICHIERS')) { // En attendant que ce soit natif spip
16        define('_DIR_FICHIERS', _DIR_ETC.'fichiers/');
17}
18
19if (!defined('_DIR_FICHIERS_FORMIDABLE')) {
20        define('_DIR_FICHIERS_FORMIDABLE', _DIR_FICHIERS.'formidable/');
21}
22
23if (!defined('_FORMIDABLE_EXPIRATION_FICHIERS_EMAIL')) {
24        // Combien de temps un lien par email dans fichier est valable (en seconde)
25        define('_FORMIDABLE_EXPIRATION_FICHIERS_EMAIL', 24*3600);
26}
27if (!defined('_FORMIDABLE_EFFACEMENT_FICHIERS_EMAIL')) {
28        // Au bout de combien de temps efface-t-on les fichiers enregistrés lorsque le traitement est uniquement email?
29        define('_FORMIDABLE_EFFACEMENT_FICHIERS_EMAIL', _FORMIDABLE_EXPIRATION_FICHIERS_EMAIL);
30}
31if (!defined('_FORMIDABLE_LIENS_FICHIERS_ACCUSE_RECEPTION')) {
32        // mettre à false si on ne veut pas de lien vers les fichiers dans l'accusé de réception
33        define('_FORMIDABLE_LIENS_FICHIERS_ACCUSE_RECEPTION', true);
34}
35/**
36 * Créer, si le formulaire contient des saisies de type fichiers, un dossier pour stocker les fichiers.
37 * Vérifier que ce dossier soit accessible en écriture.
38 * Vérifier qu'on ne puisse pas y accéder de l'exterieur.
39 *
40 * @param int $id_formulaire
41 * @param bool $forcer, pour forcer la création du dossier même si pas de saisie fichiers
42 * @return $erreur
43 **/
44function formidable_creer_dossier_formulaire($id_formulaire, $forcer = false) {
45        if (!$forcer) {
46                include_spip('formulaires/formidable');
47                // Récuperer la liste des saisies de type fichier
48                $saisies_fichiers = formulaires_formidable_fichiers($id_formulaire);
49
50                if (!is_array($saisies_fichiers) or $saisies_fichiers == array ()) {
51                        //pas de saisie fichiers?
52                        return '';
53                }
54        }
55        $nom_dossier = "formulaire_$id_formulaire";
56
57        // On crée le dossier
58        sous_repertoire(_DIR_FICHIERS, '', true, true);
59        sous_repertoire(_DIR_FICHIERS_FORMIDABLE, '', true, true);
60        $dossier = sous_repertoire(_DIR_FICHIERS_FORMIDABLE, $nom_dossier, false, true);
61        if (strpos($dossier, "$nom_dossier/") === false) {
62                spip_log("Impossible d'écrire $nom_dossier", 'formidable'._LOG_ERREUR);
63                return _T(
64                        'formidable:creer_dossier_formulaire_erreur_impossible_creer',
65                        array('dossier'=>_DIR_FICHIERS_FORMIDABLE . $nom_dossier)
66                );
67        }
68
69        // Créer un htaccess ici
70        include_spip('inc/acces');
71        verifier_htaccess($dossier);
72
73        // on crée un fichier de test, pour s'assurer
74        // 1. Qu'on puisse écrire dans le rep
75        // 2. Qu'on ne puisse pas accéder à ce fichier depuis l'exterieur.
76        $fichier = $dossier.'test.txt';
77        $ecriture_ok = ecrire_fichier(
78                $fichier,
79                "Ce fichier n'est normalement pas lisible de l'extérieur. Si tel est le cas, il y a un souci de confidentialité.",
80                false
81        );
82        if ($ecriture_ok == false) {
83                spip_log("Impossible d'écrire dans $nom_dossier", 'formidable'._LOG_ERREUR);
84                return _T(
85                        'formidable:creer_dossier_formulaire_erreur_impossible_ecrire',
86                        array('dossier'=>_DIR_FICHIERS_FORMIDABLE . $nom_dossier)
87                );
88        }
89
90        include_spip('inc/distant');
91        $url = url_absolue($fichier);
92        if ($data = recuperer_page($url) && $data != null) {
93                // si on peut récuperer la page avec un statut http 200,
94                // c'est qu'il y a un problème. recuperer_page() est obsolète en 3.1, mais recuperer_url() n'existe pas en 3.0
95                spip_log("$nom_dossier accessible en lecture depuis le web", 'formidable'._LOG_CRITIQUE);
96                return _T(
97                        'formidable:creer_dossier_formulaire_erreur_possible_lire_exterieur',
98                        array('dossier'=>_DIR_FICHIERS_FORMIDABLE . $nom_dossier)
99                );
100        }
101        // Et si tout va bien
102        spip_log("Création du dossier $nom_dossier", 'formidable');
103        return '';
104}
105
106/**
107 * Déplace un fichier uploadé de son adresse temporaire vers son adresse définitive.
108 * Crée si besoin les dossiers de stockage.
109 *
110 * @param string $fichier l'adresse temporaire du fichier
111 * @param string $nom le nom du fichier
112 * @param string $mime le mime du fichier
113 * @param string $extension l'extension du fichier
114 * @param string $champ le champ concerné
115 * @return string $nom_definitif
116 *              le nom définitif du fichier tel que stocké dans son dossier,
117 *              vide s'il y a eu un souci lors du déplacement (dans ce cas un courriel sera envoyé au webmestre)
118 *
119 **/
120function formidable_deplacer_fichier_emplacement_definitif($fichier, $nom, $mime, $extension, $champ, $options) {
121        if (isset($options['id_formulaire'])) {
122                $id_formulaire = $options['id_formulaire'];
123                $dossier_formulaire =  "formulaire_$id_formulaire";
124        } else {
125                // si c'est pas set, c'est qu'il y a une erreur
126                return '';
127        }
128
129        if (isset($options['id_formulaires_reponse'])) {
130                $dossier_reponse = 'reponse_'.$options['id_formulaires_reponse'];
131        } elseif (isset($options['timestamp'])) {
132                $dossier_reponse = 'reponse_'.$options['timestamp'];
133        } else { // si ni timestamp, ni id_formulaires_reponse => erreur
134                return '';
135        }
136        // déterminer le basename
137        $basename = pathinfo($nom, PATHINFO_BASENAME);
138
139        // Appliquer les alias de type_mime
140        include_spip('base/typedoc');
141        while (isset($GLOBALS['mime_alias'][$mime])) {
142                $mime = $GLOBALS['mime_alias'][$mime];
143        }
144
145        // sécurité : si la combinaison extension/mime_type est inconnu de SPIP (spip_documents_type), on zip.
146        // On n'utilise volontairement pas verifier/fichiers.php, dès fois que celui-ci évolue dans le future
147        $res = sql_select(
148                'mime_type',
149                'spip_types_documents',
150                'mime_type='.sql_quote($mime).' and extension='.sql_quote($extension)
151        );
152        if (sql_count($res) == 0) {
153                $zipper = true;
154                $nom_dans_zip = $nom;
155                // pas de fichier nom de zip commencant par point
156                while (strpos($basename, '.') === 0) {
157                        $basename = substr($basename, 1);
158                }
159                $nom = "$basename.zip";
160        } else {
161                $zipper = false;
162        }
163        if (!isset($options['timestamp'])) { // si on enregistre la réponse en base
164
165                // d'abord, créer si besoin le dossier pour le formulaire, si on a une erreur, on ne déplace pas le fichier
166                if (formidable_creer_dossier_formulaire($id_formulaire, true) != '') {
167                        return '';
168                }
169
170                // puis on créer le dossier pour la réponse
171                $dossier_reponse = sous_repertoire(
172                        _DIR_FICHIERS_FORMIDABLE.$dossier_formulaire.'/',
173                        $dossier_reponse,
174                        false,
175                        true
176                );
177
178                // puis le dossier pour le champ
179                $dossier_champ = sous_repertoire($dossier_reponse, $champ, false, true);
180                $appendice_nom = 0;
181        } else { // si on enregistre sous forme de timestamp
182                sous_repertoire(_DIR_FICHIERS, '', true, true);
183                sous_repertoire(_DIR_FICHIERS_FORMIDABLE, '', true, true);
184                $dossier = sous_repertoire(_DIR_FICHIERS_FORMIDABLE, 'timestamp', false, true);
185                $dossier = sous_repertoire($dossier, $options['timestamp'], false, true);
186                $dossier_champ = sous_repertoire($dossier, $champ, false, true);
187
188                // Générer un fichier htaccess ici
189                include_spip('inc/acces');
190                verifier_htaccess($dossier);
191
192                // on crée un fichier de test, pour s'assurer
193                // 1. Qu'on puisse écrire dans le rep
194                // 2. Qu'on ne puisse pas accéder à ce fichier depuis l'exterieur.
195                $fichier_test = $dossier.'test.txt';
196                $ecriture_ok = ecrire_fichier(
197                        $fichier_test,
198                        "Ce fichier n'est normalement pas lisible de l'extérieur. Si tel est le cas, il y a un souci de confidentialité.",
199                        false
200                );
201                if ($ecriture_ok == false) {
202                        spip_log("Impossible d'écrire dans $dossier", 'formidable'._LOG_ERREUR);
203                        return '';
204                }
205                // WARNING : ce test n'est pas fiable car il repose sur le fait que le serveur est capable d'acceder a ses propres URLs
206                // ce qui n'est pas forcement vrai selon la config reseau etc. Peut provoquer un delai d'attente important si le firewall bloque la requete http
207                include_spip('inc/distant');
208                $url = url_absolue($fichier_test);
209                if ($data = recuperer_page($url) && $data != null) {
210                        // si on peut récuperer la page avec un statut http 200,
211                        // c'est qu'il y a un problème.
212                        // recuperer_page() est obsolète en 3.1, mais recuperer_url() n'existe pas en 3.0
213                        spip_log("$dossier accessible en lecture depuis le web", 'formidable'._LOG_CRITIQUE);
214                        return '';
215                }
216        }
217        // S'assurer qu'il n'y a pas un fichier du même nom à destination
218        $chemin_final = $dossier_champ.$nom;
219        $n = 1;
220        //la constante PATHINFO_FILENAME n'est qu'à partir de PHP 5.2, or SPIP 3 peut fonctionne en PHP 5.1
221        $basename_sans_extension = substr_replace($basename, '', -strlen($extension)-1);
222        while (@file_exists($chemin_final)) {
223                $nom = $basename_sans_extension."_$n.".$extension;
224                $chemin_final = $dossier_champ.$nom;
225                $n++;
226        }
227        if (!$zipper) { // si on ne zippe pas, c'est simple
228                if ($fichier_dest = deplacer_fichier_upload($fichier, $chemin_final, true)) {
229                        spip_log("Enregistrement du fichier $chemin_final", 'formidable');
230                        return $nom;
231                } else {
232                        spip_log("Pb lors de l'enregistrement du fichier $chemin_final", 'formidable'._LOG_ERREUR);
233                        return '';
234                }
235        } else { // si on doit zipper, c'est plus complexe
236                include_spip('inc/pclzip');
237                $zip = new PclZip($chemin_final);
238                // mettre à jour le fichier dans le dossier cvtupload
239                if (!$tmp_dir = tempnam($dossier_champ, 'tmp_upload')) {
240                        return '';
241                }
242                spip_unlink($tmp_dir);
243                @mkdir($tmp_dir);
244                if (!$fichier_tmp = deplacer_fichier_upload($fichier, $tmp_dir.'/'.$nom_dans_zip, false)) {
245                        spip_log("Pb lors de l'enregistrement du fichier $tmp_dir/$nom_dans_zip", 'formidable'._LOG_ERREUR);
246                        return '';
247                }
248                $zip_final = $zip -> create(
249                        $fichier_tmp,
250                        PCLZIP_OPT_REMOVE_PATH,
251                        $tmp_dir,
252                        PCLZIP_OPT_ADD_PATH,
253                        ''
254                );
255                if (!$zip_final) {
256                        spip_log("Pb lors de l'enregistrement du fichier $fichier", 'formidable'._LOG_ERREUR);
257                        return '';
258                } else {
259                        spip_unlink($fichier);
260                        supprimer_repertoire($tmp_dir);
261                        spip_log("Enregistrement du fichier $fichier, automatiquement zippé", 'formidable');
262                        return $nom;
263                }
264        }
265
266        return $nom;
267}
268
269/**
270 * Fournit à l'utilisateur·trice un fichier qui se trouve normalement dans un endroit inaccessible,
271 * par exemple dans config.
272 *
273 * La fonction ne vérifie ni l'existence effective du fichier,
274 * ni le droit effectif de l'utilisateur.
275 * Ceci doit être fait dans l'action qui appelle cette fonction
276 *
277 * @param string $chemin le chemin du fichier
278 * @param string $f le nom du fichier qui sera envoyé à l'utilisateur·trice.
279 * @param string $content_type Si Connu, sinon calculé
280 *
281**/
282function formidable_retourner_fichier($chemin, $f, $content_type = '') {
283        header('Content-Type: ' . ($content_type ?: mime_content_type($chemin)));
284        header("Content-Disposition: attachment; filename=\"$f\";");
285        header('Content-Transfer-Encoding: binary');
286        // fix for IE catching or PHP bug issue (inspiré de plugins-dist/dump/action/telecharger_dump.php
287        header('Pragma: public');
288        header('Expires: 0'); // set expiration time
289        header('Cache-Control: must-revalidate, post-check=0, pre-check=0');
290        if ($cl = filesize($chemin)) {
291                header('Content-Length: '.$cl);
292        }
293        readfile($chemin);
294        exit;
295}
296/**
297 * Déplacer un fichier temporaire à son emplacement définif.
298 * Produire un tableau de description des fichiers déplacés.
299 * Le tout à partir de la description d'une saisies 'fichiers'
300 * @param array $saisie la description de la saisie fichiers
301 * @param array $options
302 *              des options, dépendantes du type de traitement,
303 *              qui permettent d'indiquer où l'on déplace le fichier
304 * @return array un tableau de "vue" de la saisie
305**/
306function formidable_deplacer_fichiers_produire_vue_saisie($saisie, $options) {
307        $nb_fichiers_max = $saisie['options']['nb_fichiers'];
308        // on va parcourir $_FILES en nous limitant aux nombres de fichiers définies par la saisie,
309        // pour éviter les éventuelles ajout supplémentaire de fichiers par modif du html
310        $champ = $saisie['options']['nom'];
311        if (!isset($_FILES[$champ])) {//précaution
312                return null;
313        }
314        $description_fichiers = array();
315        $mon_file = $_FILES[$champ];
316        $i = 0;
317        while ($i < $nb_fichiers_max) {
318                if ($mon_file['error'][$i] == 0) {
319                        // la saisie fichiers est forcément structurée sous la forme d'un tableau,
320                        // on peut donc vérifier qu'il n'y a pas d'erreur facilement
321                        $description = array(); // tableau pour stocker la description de ce fichier
322
323                        // les infos qu'on peut récuperer directement de $files
324                        $description['taille'] = $mon_file['size'][$i];
325                        $description['mime'] = $mon_file['type'][$i];
326
327                        // l'adresse du nouveau fichier, sans le chemin
328                        if ($nouveau_nom = formidable_deplacer_fichier_emplacement_definitif(
329                                $mon_file['tmp_name'][$i],
330                                $mon_file['name'][$i],
331                                $mon_file['type'][$i],
332                                pathinfo($mon_file['name'][$i], PATHINFO_EXTENSION),
333                                $champ,
334                                $options
335                        )) {
336                                        $description['nom'] = $nouveau_nom;
337                                        $description['extension'] = pathinfo($nouveau_nom, PATHINFO_EXTENSION);
338                        } else {
339                                $description['erreur'] = _T(
340                                        'formidable:erreur_deplacement_fichier',
341                                        array('nom'=>$mon_file['name'][$i])
342                                );
343                                $description['nom'] = $mon_file['name'][$i];
344                                $description['tmp_name'] = $mon_file['tmp_name'][$i];
345                        }
346                        //on ajoute la description au tableau global
347                        $description_fichiers[$i] = $description;
348                }
349                $i++;
350        }
351        return $description_fichiers;
352}
353/**
354 * Efface les fichiers d'un formulaire
355 * @param $str $id_formulaire
356 * @return int 1 ou 0 selon que l'on a effacé ou non un répertoire
357**/
358function formidable_effacer_fichiers_formulaire($id_formulaire) {
359        $chemin = _DIR_FICHIERS_FORMIDABLE."formulaire_$id_formulaire";
360        if (file_exists($chemin)) {// par sécurité
361                if (supprimer_repertoire($chemin)) {
362                        spip_log("Effacement du dossier $chemin", 'formidable');
363                        return 1;
364                } else {
365                        spip_log("Pb lors de l'effacement du dossier $chemin", 'formidable'._LOG_ERREUR);
366                        return 0;
367                }
368        }
369        return 0;
370}
371
372/**
373 * efface les fichiers d'une réponse formidable
374 * @param $str $id_formulaire
375 * @param $str $id_formulaires_reponse
376 * @return int 1 ou 0 selon que l'on a effacé ou non un répertoire
377**/
378function formidable_effacer_fichiers_reponse($id_formulaire, $id_formulaires_reponse) {
379        $chemin = _DIR_FICHIERS_FORMIDABLE."formulaire_$id_formulaire/reponse_$id_formulaires_reponse";
380        if (file_exists($chemin)) {// par sécurité
381                if (supprimer_repertoire($chemin)) {
382                        spip_log("Effacement du dossier $chemin", 'formidable');
383                        return 1;
384                } else {
385                        spip_log("Pb lors de l'effacement du dossier $chemin", 'formidable'._LOG_ERREUR);
386                        return 0;
387                }
388        }
389        return 0;
390}
391
392/** Efface les fichiers d'un champ pour les réponses d'un formulaire
393 * @param str $id_formulaire
394 * @param array|str $reponses
395 * @param str $champ
396**/
397function formidable_effacer_fichiers_champ($id_formulaire, $reponses, $champ) {
398        if ($champ != '') { // on devrait pas arriver ici avec un $champ vide, mais prenons nos précaution
399
400                if (!is_array($reponses)) {
401                        $reponses = array($reponses);
402                }
403
404                $rep_vide = array('.', '..', '.ok'); // si scandire retourne cela où inférieur, alors le dossier est vide
405                foreach ($reponses as $rep) {
406                        $chemin_reponse = _DIR_FICHIERS_FORMIDABLE."formulaire_$id_formulaire/reponse_$rep";
407                        $chemin_champ = $chemin_reponse.'/'.$champ;
408
409                        if (file_exists($chemin_champ)) {
410                                if (supprimer_repertoire($chemin_champ)) {
411                                        spip_log("Effacement du dossier $chemin_champ", 'formidable');
412                                } else {
413                                        spip_log("Pb lors de l'effacement du dossier $chemin_champ", 'formidable'._LOG_ERREUR);
414                                }
415                                if (count(array_diff(scandir($chemin_reponse), $rep_vide)) == 0) {
416                                        // si jamais il ne reste plus aucun fichiers pour cette réponse,
417                                        // on peut effacer le repertoire de celle-ci
418                                        if (supprimer_repertoire($chemin_reponse)) {
419                                                spip_log("Effacement du dossier $chemin_reponse", 'formidable');
420                                        } else {
421                                                spip_log("Pb lors de l'effacement du dossier $chemin_reponse", 'formidable'._LOG_ERREUR);
422                                        }
423                                }
424                        }
425                }
426        }
427}
428
429/** Efface les fichiers des réponses par email
430 * lorsque la constante _FORMIDABLE_EFFACEMENT_FICHIERS_EMAIL est différent de 0 et que le temps est écoulé
431 * @return int nombre de dossiers effacés
432 **/
433function formidable_effacer_fichiers_email() {
434        if (_FORMIDABLE_EFFACEMENT_FICHIERS_EMAIL == 0) {
435                return 0;
436        }
437        $dossiers_effaces = 0;
438        $chemin = _DIR_FICHIERS_FORMIDABLE.'timestamp';
439        $timestamp = time();
440        if (is_dir($chemin)) {
441                $dossiers = scandir($chemin);
442                if (is_array($dossiers)) {
443                        foreach ($dossiers as $dossier) {
444                                if (strval(intval($dossier)) != $dossier) { // on ne traite que les dossiers qui ont comme nom un entier
445                                        continue;
446                                }
447                                if ($timestamp - intval($dossier) >= _FORMIDABLE_EFFACEMENT_FICHIERS_EMAIL) {
448                                        $chemin_complet = "$chemin/$dossier";
449                                        if (supprimer_repertoire($chemin_complet)) {
450                                                spip_log("Effacement du dossier $chemin_complet", 'formidable');
451                                                $dossiers_effaces++;
452                                        } else {
453                                                spip_log("Pb lors de l'effacement du dossier $chemin_complet", 'formidable'._LOG_ERREUR);
454                                        }
455                                }
456                        }
457                }
458        }
459        return $dossiers_effaces;
460}
461
462/**
463 * Génerer un zip des réponses d'un formulaire
464 *
465 * @param int $id_formulaire  (identifiant numérique)
466 * @param string $chemin_du_zip chemin complet du zip
467 * @param string $fichier_csv un fichier csv à ajouter, contenant les réponses
468 * @return string|int chemin complet du zip ou 0 si erreur lors de la création
469**/
470function formidable_zipper_reponses_formulaire($id_formulaire, $chemin_du_zip, $fichier_csv, $saisies_fichiers) {
471        include_spip('inc/pclzip');
472        $zip = new PclZip("$chemin_du_zip");
473        $chemin_fichiers = _DIR_FICHIERS_FORMIDABLE . 'formulaire_' . $id_formulaire;
474        if (!$zip->create($saisies_fichiers, PCLZIP_OPT_REMOVE_PATH, $chemin_fichiers)) {
475                spip_log(
476                        "Impossible de créer le zip pour l'export des réponses du formulaire $id_formulaire",
477                        'formidable'._LOG_ERREUR
478                );
479                return 0;
480        } else {
481                $zip->add($fichier_csv, PCLZIP_OPT_REMOVE_ALL_PATH);
482                return $chemin_du_zip;
483        }
484}
485/**
486 * Générer une url d'action pour la récupération d'un fichier lié à une réponse
487 * @param int|str $id_formulaire
488 * @param int|str $id_formulaires_reponse
489 * @param str $saisie
490 * @param str $fichier
491 **/
492function formidable_generer_url_action_recuperer_fichier($id_formulaire, $id_formulaires_reponse, $saisie, $fichier) {
493        $param = array(
494                'formulaire' => $id_formulaire,
495                'reponse' => $id_formulaires_reponse,
496                'saisie' => $saisie,
497                'fichier' => $fichier
498        );
499
500        // Pour les utilisateurs non authentifiés, on se base sur le cookier
501        $nom_cookie = formidable_generer_nom_cookie($id_formulaire);
502        if (isset($_COOKIE[$nom_cookie])) {
503                include_spip('inc/securiser_action');
504                $param['cookie'] = sha1($_COOKIE[$nom_cookie].secret_du_site());
505        }
506
507        $param = serialize($param);
508        $securiser_action = charger_fonction('securiser_action', 'inc');
509        return $securiser_action('formidable_recuperer_fichier', $param, '', false);
510}
511
512/** Générer une url d'action pour récuperer un fichier à partir d'un lien email
513 * @param string $saisie
514 * @param string $fichier
515 * @param array $options décrivant si on récupère par id de réponse ou par timestamp
516 * @return string $url
517 *
518**/
519function formidable_generer_url_action_recuperer_fichier_email($saisie, $fichier, $options) {
520        if (isset($options['id_formulaires_reponse'])) {//si reponses enregistrées
521                $arg = serialize(array(
522                        'formulaire' => strval($options['id_formulaire']),
523                        'reponse' => strval($options['id_formulaires_reponse']),
524                        'fichier' => $fichier,
525                        'saisie' => $saisie
526                ));
527        } elseif (isset($options['timestamp'])) {//si par timestamp
528                $arg = serialize(array(
529                        'timestamp' => strval($options['timestamp']),
530                        'fichier' => $fichier,
531                        'saisie' => $saisie
532                ));
533        }
534        $pass = secret_du_site();
535        $action = 'formidable_recuperer_fichier_par_email';
536        $hash = _action_auteur("$action-$arg", '', $pass, 'alea_ephemere');
537        $url = generer_url_action($action, "arg=$arg&hash=$hash", true, true);
538        return $url;
539}
540
541/** Générer le chemin d'un fichier d'après les paramètres passés en argument
542 * @param array $param, paramètres décrivant le fichiers:
543 * formulaire => identifiant numérique du formulaire,
544 * timestamp => timestamp de la réponse (si la réponse est uniquement envoyée par courriel)
545 * reponse => identifiant numérique de la réponse
546 * saisie => nom du champ formidable (type fichier_1)
547 * fichier => nom du fichier
548 * @return string $chemin;
549**/
550function formidable_generer_chemin_fichier($param){
551        $chemin_fichier = '';
552        if (isset($param['reponse'])) {
553                $chemin_fichier = _DIR_FICHIERS_FORMIDABLE
554                        .'formulaire_'.$param['formulaire']
555                        .'/reponse_'.$param['reponse']
556                        .'/'.$param['saisie']
557                        .'/'.$param['fichier'];
558        } elseif (isset($param['timestamp'])) {
559                $chemin_fichier = _DIR_FICHIERS_FORMIDABLE
560                        . 'timestamp/'
561                        . $param['timestamp'].'/'
562                        . $param['saisie'].'/'
563                        . $param['fichier'];
564        } else {
565                include_spip('inc/minipres');
566                echo minipres(_T('formidable:erreur_fichier_introuvable'));
567        }
568        return $chemin_fichier;
569}
570
Note: See TracBrowser for help on using the repository browser.