Gravity Forms permet d’ajouter un champ d’upload de fichier dans un formulaire WordPress. C’est très pratique pour recevoir des CV, documents administratifs, images, justificatifs, contrats, captures d’écran ou pièces jointes clients.
Mais il y a un détail important : lorsqu’une entrée Gravity Forms est supprimée définitivement, les fichiers uploadés associés peuvent être supprimés eux aussi. C’est logique pour la confidentialité et le nettoyage serveur, mais ce n’est pas toujours le comportement voulu.
Si vous voulez supprimer les entrées Gravity Forms tout en conservant les fichiers uploadés, il faut modifier le comportement de suppression des fichiers avec un filtre prévu par Gravity Forms.
Pourquoi Gravity Forms supprime les fichiers uploadés ?
Gravity Forms associe les fichiers uploadés à l’entrée du formulaire. Quand vous supprimez définitivement une entrée, Gravity Forms peut supprimer les fichiers liés afin d’éviter de laisser des fichiers orphelins sur le serveur.
Ce comportement est généralement sain. Si vous supprimez une entrée contenant des données personnelles, conserver automatiquement les fichiers liés pourrait poser problème. Un CV, une pièce d’identité ou un justificatif ne doit pas rester sur le serveur par accident.
Mais certains sites ont un besoin différent : ils veulent supprimer les entrées pour alléger la base de données, tout en conservant les fichiers pour archivage, traitement métier, sauvegarde, comptabilité ou suivi client.
Cas d’usage : quand faut-il conserver les fichiers ?
Conserver les fichiers uploadés peut être utile dans plusieurs situations :
- formulaire de candidature avec CV à archiver ;
- formulaire client avec documents contractuels ;
- formulaire de support avec captures d’écran ;
- formulaire administratif avec justificatifs ;
- demande de devis avec fichiers techniques ;
- formulaire interne où les entrées sont supprimées après export ;
- workflow qui copie les fichiers vers un CRM ou un stockage externe ;
- site où l’entrée Gravity Forms n’est qu’un point de transit.
Dans ces cas, supprimer l’entrée ne signifie pas forcément supprimer le document. Il faut donc dissocier la conservation des fichiers de la conservation des entrées.
Où Gravity Forms stocke les fichiers uploadés ?
Par défaut, les fichiers uploadés par Gravity Forms sont stockés dans le dossier des uploads WordPress, généralement dans un sous-dossier lié à Gravity Forms.
wp-content/uploads/gravity_forms/La structure exacte peut varier selon la version, le formulaire, le champ, la date et la configuration du site. Le plus simple consiste à inspecter directement les URLs enregistrées dans les entrées ou les fichiers présents sur le serveur.
Pour afficher les dossiers Gravity Forms :
find wp-content/uploads/gravity_forms -maxdepth 3 -type d | head -50Pour afficher quelques fichiers uploadés :
find wp-content/uploads/gravity_forms -type f | head -50Avant de changer le comportement de suppression, vérifiez bien ce que vous stockez. Conserver des fichiers, c’est aussi conserver une responsabilité. Charmant, mais réel.
La solution : utiliser gform_field_types_delete_files
Gravity Forms fournit le filtre gform_field_types_delete_files. Il permet de contrôler quels types de champs doivent entraîner la suppression des fichiers quand une entrée est supprimée.
Par défaut, les champs d’upload peuvent être inclus dans les types de champs dont les fichiers sont supprimés. Pour conserver les fichiers, on retire les champs concernés de cette liste.
Voici un snippet propre à placer dans un mini-plugin, un plugin spécifique au site, ou un gestionnaire de snippets fiable. Évitez de le mettre dans un thème parent.
<?php
/**
* Plugin Name: Sky Gravity Forms Keep Uploaded Files
* Description: Prevents Gravity Forms from deleting uploaded files when entries are permanently deleted.
* Version: 1.0.0
* Author: Matt Biscay
* License: GPL-2.0-or-later
*/
declare(strict_types=1);
defined( 'ABSPATH' ) || exit;
add_filter( 'gform_field_types_delete_files', 'skyminds_gf_keep_uploaded_files_on_entry_delete' );
/**
* Prevent Gravity Forms from deleting uploaded files when entries are deleted.
*
* Gravity Forms uses this list to determine which field types should have
* their uploaded files removed during permanent entry deletion.
*
* @param array<int, string> $field_types Field types whose files should be deleted.
*
* @return array<int, string> Filtered field types.
*/
function skyminds_gf_keep_uploaded_files_on_entry_delete( array $field_types ): array {
return array_values(
array_diff(
$field_types,
array(
'fileupload',
'post_image',
)
)
);
}Langage du code : HTML, XML (xml)Ce code indique à Gravity Forms de ne plus supprimer les fichiers des champs fileupload et post_image lors de la suppression définitive des entrées.
Version ciblée : conserver les fichiers seulement pour certains formulaires
Le filtre précédent agit globalement. Si vous voulez conserver les fichiers uniquement pour certains formulaires, il vaut mieux ajouter une logique plus ciblée.
Le filtre gform_field_types_delete_files ne reçoit pas directement l’ID du formulaire. Pour un contrôle fin par formulaire, une stratégie plus robuste consiste à copier les fichiers ailleurs après soumission, puis à laisser Gravity Forms gérer la suppression normale des fichiers originaux.
C’est souvent préférable pour les workflows métier. Vous gardez le comportement standard de Gravity Forms, mais vous archivez une copie dans un dossier maîtrisé.
Alternative robuste : copier les fichiers après soumission
Si vous devez conserver certains fichiers indépendamment des entrées Gravity Forms, copiez-les après soumission avec le hook gform_after_submission. Ce hook s’exécute après la création de l’entrée, une fois les données disponibles.
Voici un exemple qui copie les fichiers uploadés d’un formulaire précis vers un dossier d’archive dans wp-content/uploads/gf-archives.
<?php
/**
* Plugin Name: Sky Gravity Forms Archive Uploaded Files
* Description: Archives uploaded files from a specific Gravity Forms form after submission.
* Version: 1.0.0
* Author: Matt Biscay
* License: GPL-2.0-or-later
*/
declare(strict_types=1);
defined( 'ABSPATH' ) || exit;
add_action( 'gform_after_submission_3', 'skyminds_gf_archive_uploaded_files', 10, 2 );
/**
* Archive uploaded files after a Gravity Forms submission.
*
* Replace the form-specific hook suffix `_3` with your actual form ID.
*
* @param array<string, mixed> $entry Gravity Forms entry object as an array.
* @param array<string, mixed> $form Gravity Forms form object as an array.
*
* @return void
*/
function skyminds_gf_archive_uploaded_files( array $entry, array $form ): void {
$upload_dir = wp_upload_dir();
if ( ! empty( $upload_dir['error'] ) || empty( $upload_dir['basedir'] ) ) {
return;
}
$archive_dir = trailingslashit( $upload_dir['basedir'] ) . 'gf-archives/form-' . absint( (int) $form['id'] );
if ( ! wp_mkdir_p( $archive_dir ) ) {
return;
}
foreach ( $form['fields'] as $field ) {
if ( ! is_object( $field ) || 'fileupload' !== $field->type ) {
continue;
}
$field_id = (string) $field->id;
$value = rgar( $entry, $field_id );
if ( empty( $value ) || ! is_string( $value ) ) {
continue;
}
$file_urls = skyminds_gf_normalize_file_upload_value( $value );
foreach ( $file_urls as $file_url ) {
skyminds_gf_copy_uploaded_file_to_archive( $file_url, $archive_dir );
}
}
}
/**
* Normalize a Gravity Forms file upload value into a list of URLs.
*
* Multiple file upload fields can store JSON-encoded arrays.
*
* @param string $value Raw field value.
*
* @return array<int, string> File URLs.
*/
function skyminds_gf_normalize_file_upload_value( string $value ): array {
$decoded = json_decode( $value, true );
if ( is_array( $decoded ) ) {
return array_values(
array_filter(
$decoded,
static fn ( mixed $url ): bool => is_string( $url ) && '' !== $url
)
);
}
return array( $value );
}
/**
* Copy an uploaded file URL to the archive directory.
*
* @param string $file_url Uploaded file URL.
* @param string $archive_dir Archive directory path.
*
* @return void
*/
function skyminds_gf_copy_uploaded_file_to_archive( string $file_url, string $archive_dir ): void {
$upload_dir = wp_upload_dir();
if ( empty( $upload_dir['baseurl'] ) || empty( $upload_dir['basedir'] ) ) {
return;
}
$base_url = trailingslashit( $upload_dir['baseurl'] );
$base_dir = trailingslashit( $upload_dir['basedir'] );
if ( 0 !== strpos( $file_url, $base_url ) ) {
return;
}
$relative_path = ltrim( str_replace( $base_url, '', $file_url ), '/' );
$source_path = wp_normalize_path( $base_dir . $relative_path );
if ( ! is_readable( $source_path ) || ! is_file( $source_path ) ) {
return;
}
$filename = wp_unique_filename( $archive_dir, basename( $source_path ) );
$target_path = trailingslashit( $archive_dir ) . $filename;
copy( $source_path, $target_path );
}Langage du code : HTML, XML (xml)Dans cet exemple, le hook gform_after_submission_3 cible le formulaire ID 3. Remplacez 3 par l’ID réel de votre formulaire.
Cette approche a un avantage clair : vous pouvez garder Gravity Forms propre, supprimer les entrées selon vos règles, et conserver une copie métier des fichiers nécessaires.
Quelle méthode choisir ?
| Besoin | Méthode recommandée |
|---|---|
| Conserver tous les fichiers Gravity Forms | Filtre gform_field_types_delete_files |
| Conserver les fichiers seulement pour certains formulaires | Copie via gform_after_submission_FORMID |
| Supprimer les entrées mais garder une archive métier | Copie dans un dossier dédié ou stockage externe |
| Respecter une politique stricte de confidentialité | Suppression normale des fichiers avec les entrées |
| Envoyer les fichiers vers un CRM ou stockage cloud | Hook après soumission ou add-on dédié |
La méthode la plus simple consiste à empêcher Gravity Forms de supprimer les fichiers. La méthode la plus propre, pour un besoin métier précis, consiste souvent à archiver une copie contrôlée.
Attention à la suppression dans la corbeille
Il faut distinguer une entrée mise à la corbeille et une entrée supprimée définitivement. Les fichiers ne sont pas forcément supprimés au moment où l’entrée est simplement déplacée dans la corbeille. Le comportement critique intervient lors de la suppression définitive.
Si vous utilisez les réglages de conservation des données personnelles de Gravity Forms, vérifiez si vos entrées sont mises à la corbeille ou supprimées définitivement. Ce détail change ce qui arrive aux fichiers.
Tester le comportement avant production
Avant de déployer ce type de snippet sur un site client, testez le cycle complet sur staging.
- Créez une entrée de test avec un fichier uploadé.
- Notez l’URL du fichier dans l’entrée.
- Vérifiez que le fichier existe sur le serveur.
- Supprimez l’entrée définitivement.
- Vérifiez si le fichier existe encore.
- Vérifiez les logs PHP et Gravity Forms.
- Confirmez que le comportement correspond à votre politique de conservation.
Pour vérifier un fichier sur le serveur :
find wp-content/uploads/gravity_forms -type f -name 'nom-du-fichier.pdf'Langage du code : JavaScript (javascript)Pour suivre les erreurs PHP pendant le test :
tail -f wp-content/debug.logSécurité : ne rendez pas les uploads sensibles publics
Conserver les fichiers uploadés peut être utile, mais cela augmente aussi votre responsabilité. Les fichiers Gravity Forms peuvent contenir des données personnelles ou confidentielles.
Avant de conserver les fichiers, posez-vous les bonnes questions :
- les fichiers doivent-ils être accessibles publiquement ?
- contiennent-ils des données personnelles ?
- combien de temps faut-il les conserver ?
- qui peut y accéder ?
- sont-ils inclus dans les sauvegardes ?
- faut-il les déplacer hors du webroot ?
- faut-il les supprimer après traitement ?
Un dossier d’uploads accessible par URL directe n’est pas toujours adapté aux documents sensibles. Pour des fichiers confidentiels, préférez un stockage privé, un contrôle d’accès applicatif, ou un export vers un système documentaire sécurisé.
Limiter les types de fichiers autorisés
Dans le champ File Upload de Gravity Forms, limitez les extensions autorisées. Ne laissez pas les utilisateurs envoyer n’importe quel type de fichier.
Exemple de liste raisonnable pour des documents :
pdf, doc, docx, jpg, jpeg, pngÉvitez les formats exécutables ou dangereux. Et si le site reçoit des fichiers clients, gardez une stratégie de scan antivirus côté serveur ou côté stockage externe lorsque le contexte le justifie.
Limiter la taille des fichiers
Les uploads Gravity Forms peuvent remplir rapidement le disque. Définissez une taille maximale cohérente dans les réglages du champ File Upload.
Sur le serveur, vérifiez aussi les limites PHP :
php -i | grep -E 'upload_max_filesize|post_max_size|max_file_uploads'Langage du code : JavaScript (javascript)Dans WordPress, vous pouvez vérifier les valeurs vues par PHP :
wp eval 'echo "upload_max_filesize: " . ini_get( "upload_max_filesize" ) . PHP_EOL; echo "post_max_size: " . ini_get( "post_max_size" ) . PHP_EOL;'Langage du code : JavaScript (javascript)Si vous conservez les fichiers longtemps, surveillez l’espace disque. Les pièces jointes ont cette charmante habitude de ne jamais maigrir toutes seules.
Surveiller l’espace disque utilisé par Gravity Forms
Pour connaître la taille du dossier Gravity Forms :
du -sh wp-content/uploads/gravity_formsPour afficher les plus gros fichiers :
find wp-content/uploads/gravity_forms -type f -printf '%s %p\n' | sort -nr | head -20Langage du code : JavaScript (javascript)Pour compter les fichiers :
find wp-content/uploads/gravity_forms -type f | wc -lSi le dossier devient énorme, définissez une politique claire : archivage, compression, export, purge, ou stockage externe.
Créer un fichier index.html dans les dossiers d’archive
Si vous créez un dossier d’archive dans les uploads, ajoutez au minimum un fichier index.html vide pour éviter un listing de dossier si le serveur est mal configuré.
Vous pouvez modifier la fonction d’archive précédente pour créer ce fichier :
if ( wp_mkdir_p( $archive_dir ) ) {
$index_file = trailingslashit( $archive_dir ) . 'index.html';
if ( ! file_exists( $index_file ) ) {
file_put_contents( $index_file, '' );
}
}Langage du code : PHP (php)Ce n’est pas une sécurité complète, mais c’est une hygiène minimale. Côté serveur, désactivez aussi l’indexation automatique des dossiers.
Protéger les dossiers avec Apache
Sur Apache, vous pouvez empêcher le listing de répertoires avec cette directive :
Options -IndexesDans un vhost Apache, cela peut se placer dans le bloc Directory du site :
<Directory /var/www/example.com/public_html>
Options -Indexes +FollowSymLinks
AllowOverride All
Require all granted
</Directory>Langage du code : HTML, XML (xml)Pour la configuration Apache complète, vous pouvez consulter l’article sur l’activation d’un virtual host Apache sur serveur dédié.
Protéger les dossiers avec nginx
Sur nginx, le listing de dossier est désactivé par défaut sauf si autoindex on est configuré. Vérifiez que vous n’avez pas activé l’autoindex sur les uploads.
location /wp-content/uploads/gravity_forms/ {
autoindex off;
}Si les fichiers sont sensibles, ne vous contentez pas de masquer le listing. Une personne qui connaît l’URL exacte peut encore accéder au fichier si le serveur le sert publiquement. Pour une vraie confidentialité, stockez les fichiers hors du dossier public ou servez-les via un contrôle d’accès.
Conserver les fichiers ne remplace pas une sauvegarde
Empêcher Gravity Forms de supprimer les fichiers ne signifie pas que ces fichiers sont sauvegardés. Ils restent sur le disque du serveur. Si le serveur tombe, si le dossier est supprimé, ou si une migration oublie wp-content/uploads, les fichiers peuvent disparaître.
Vérifiez que vos sauvegardes incluent :
- la base de données WordPress ;
wp-content/uploads/gravity_forms;- vos dossiers d’archive éventuels ;
- les fichiers uploadés déplacés hors webroot ;
- les exports envoyés vers un stockage externe.
Pour automatiser ce point, l’article sur les sauvegardes de fichiers et bases de données avec cron complète bien cette procédure.
Ne pas supprimer les entrées trop vite
Si les fichiers doivent rester liés à un contexte, ne supprimez pas les entrées trop vite. Une URL de fichier seule ne donne pas toujours assez d’informations : qui l’a envoyé, quand, pour quel formulaire, avec quel message, dans quel état de traitement ?
Une bonne approche consiste parfois à exporter les entrées avant suppression :
- export CSV Gravity Forms ;
- export vers CRM ;
- copie vers stockage documentaire ;
- archivage des fichiers avec un nom clair ;
- journal de correspondance entre entrée et fichier.
Si vous archivez les fichiers avec un script, pensez à enregistrer une trace : ID du formulaire, ID d’entrée, ID du champ, URL source, chemin d’archive et date d’archivage.
Ajouter un log lors de l’archivage
Pour un workflow sérieux, ajoutez un log applicatif lorsque vous copiez un fichier. Cela facilite les audits et les débogages.
error_log(
sprintf(
'[GF ARCHIVE] Copied uploaded file from %s to %s',
$source_path,
$target_path
)
);Langage du code : PHP (php)Sur un site en production, préférez un vrai logger ou un log dédié plutôt que error_log() si le volume est élevé. Les logs WordPress qui grossissent sans contrôle finissent eux aussi par devenir un problème.
Que faire si les fichiers ont déjà été supprimés ?
Si les entrées ont été supprimées définitivement et que Gravity Forms a supprimé les fichiers associés, il n’y a pas de bouton magique dans WordPress pour les restaurer.
Vérifiez dans cet ordre :
- sauvegarde du site ;
- sauvegarde serveur ;
- sauvegarde hébergeur ;
- backup distant ;
- ancienne migration ;
- stockage externe ;
- email de notification contenant le lien ou la pièce jointe ;
- CRM ou helpdesk connecté au formulaire.
Si les fichiers sont importants, restaurez-les dans un dossier contrôlé, puis ajustez la politique de conservation pour éviter que cela se reproduise.
Cas fréquent : fichiers en lien dans les notifications email
Si vos notifications Gravity Forms contiennent simplement un lien vers le fichier uploadé, ce lien ne fonctionnera plus si le fichier est supprimé avec l’entrée.
Pour les documents importants, vérifiez si vous voulez :
- joindre le fichier à l’email ;
- copier le fichier vers une archive ;
- envoyer le fichier vers un CRM ;
- envoyer le fichier vers un stockage cloud ;
- garder l’entrée Gravity Forms plus longtemps.
Le bon choix dépend du volume, de la sensibilité des fichiers et du workflow métier. Un lien seul est pratique, mais fragile si le fichier disparaît.
Checklist de configuration
- Identifier les formulaires qui contiennent des champs File Upload.
- Décider si les fichiers doivent survivre à la suppression des entrées.
- Tester le comportement sur staging.
- Utiliser
gform_field_types_delete_filespour conserver les fichiers globalement. - Utiliser
gform_after_submission_FORMIDpour archiver certains fichiers seulement. - Limiter les types de fichiers autorisés.
- Limiter la taille maximale des uploads.
- Vérifier l’espace disque utilisé par
wp-content/uploads/gravity_forms. - Protéger les dossiers contre le listing public.
- Vérifier que les fichiers sont inclus dans les sauvegardes.
- Documenter la durée de conservation.
- Tester la suppression définitive d’une entrée.
Commandes utiles
Voir la taille des fichiers Gravity Forms :
du -sh wp-content/uploads/gravity_formsLister les fichiers uploadés :
find wp-content/uploads/gravity_forms -type f | head -50Trouver les plus gros fichiers :
find wp-content/uploads/gravity_forms -type f -printf '%s %p\n' | sort -nr | head -20Langage du code : JavaScript (javascript)Compter les fichiers :
find wp-content/uploads/gravity_forms -type f | wc -lVérifier les limites PHP d’upload :
wp eval 'echo "upload_max_filesize: " . ini_get( "upload_max_filesize" ) . PHP_EOL; echo "post_max_size: " . ini_get( "post_max_size" ) . PHP_EOL;'Langage du code : JavaScript (javascript)Sauvegarder la base avant changement :
wp db export "backup-before-gravity-forms-file-retention-$(date +%F-%H%M%S).sql"Langage du code : JavaScript (javascript)Conclusion
Pour conserver les fichiers uploadés par Gravity Forms après suppression des entrées, la solution directe consiste à utiliser le filtre gform_field_types_delete_files et à retirer les champs fileupload ou post_image de la liste des fichiers à supprimer.
Pour un workflow plus propre, surtout sur un site client ou un site avec documents sensibles, archivez plutôt une copie des fichiers après soumission avec gform_after_submission. Vous gardez ainsi un contrôle clair sur ce qui est conservé, où, combien de temps, et pourquoi.
Gravity Forms sait gérer les uploads. Votre rôle consiste surtout à définir la bonne politique de conservation. Les fichiers ne doivent ni disparaître trop tôt, ni rester éternellement sur le serveur comme des cartons oubliés dans une cave numérique.
Sources
- Gravity Forms Documentation — File Upload Field
- Gravity Forms Documentation — GF_Field_FileUpload
- Gravity Forms Documentation — Delete Entry Data after Submission
- Gravity Forms Documentation — gform_field_types_delete_files
- Gravity Forms Documentation — gform_after_submission
- Gravity Forms Documentation — gform_delete_entry
