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.

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 -50

Pour afficher quelques fichiers uploadés :

find wp-content/uploads/gravity_forms -type f | head -50

Avant 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',
			)
		)
	);
}

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 );
}

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.

1. Créez une entrée de test avec un fichier uploadé.
2. Notez l’URL du fichier dans l’entrée.
3. Vérifiez que le fichier existe sur le serveur.
4. Supprimez l’entrée définitivement.
5. Vérifiez si le fichier existe encore.
6. Vérifiez les logs PHP et Gravity Forms.
7. 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'

Pour suivre les erreurs PHP pendant le test :

tail -f wp-content/debug.log

Sé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'

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;'

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_forms

Pour afficher les plus gros fichiers :

find wp-content/uploads/gravity_forms -type f -printf '%s %p\n' | sort -nr | head -20

Pour compter les fichiers :

find wp-content/uploads/gravity_forms -type f | wc -l

Si 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, '' );
	}
}

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 -Indexes

Dans 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>

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
	)
);

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_files pour conserver les fichiers globalement.
• Utiliser gform_after_submission_FORMID pour 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_forms

Lister les fichiers uploadés :

find wp-content/uploads/gravity_forms -type f | head -50

Trouver les plus gros fichiers :

find wp-content/uploads/gravity_forms -type f -printf '%s %p\n' | sort -nr | head -20

Compter les fichiers :

find wp-content/uploads/gravity_forms -type f | wc -l

Vé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;'

Sauvegarder la base avant changement :

wp db export "backup-before-gravity-forms-file-retention-$(date +%F-%H%M%S).sql"

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

Report a typo