Gestion Entreprise de la Suppression de Fichiers et Dossiers pour macOS

Implémentez une gestion de suppression de fichiers et dossiers de niveau entreprise sur votre déploiement Roundfleet avec la suppression sécurisée de données, les pistes d'audit, la protection par sauvegarde, la gestion de conformité et les opérations de nettoyage automatisées. Ce tutoriel fournit des solutions pour maintenir l'hygiène des données tout en assurant la sécurité, la conformité et la protection des données.

Comprendre la Gestion de Suppression de Fichiers macOS

macOS fournit plusieurs méthodes pour la suppression de fichiers et dossiers :

rm - Supprimer fichiers et répertoires depuis la ligne de commande
rm -r - Suppression récursive pour répertoires avec contenu
rm -f - Suppression forcée sans invites de confirmation
Finder - Opérations de suppression/corbeille basées sur GUI
srm - Suppression sécurisée avec écrasement de données (legacy)

Opérations de Suppression de Fichiers de Base

Suppression Simple de Fichier/Dossier

#!/bin/bash

# Suppression de fichier de base
rm '/chemin vers le fichier ou dossier'

Suppression de Répertoire Récursive

#!/bin/bash

# Suppression de dossier récursive
rm -rf /Users/nomutilisateur/Desktop/Mes\ Fichiers

Supprimer Seulement le Contenu du Dossier

#!/bin/bash

# Supprimer le contenu du dossier
rm '/chemin vers le dossier/*'

Suppression de Fichiers Multiples

#!/bin/bash

# Supprimer des fichiers spécifiques multiples
rm Desktop/1.png Desktop/2.png

# Supprimer des fichiers par motif
rm Desktop/{1,2}.png

# Supprimer tous les fichiers d'un type
rm Desktop/*.png

Système de Gestion de Suppression de Fichiers Entreprise

#!/bin/bash

# Outil de Gestion de Suppression de Fichiers et Dossiers Entreprise Roundfleet
# Suppression sécurisée de données avec capacités de conformité et d'audit

# Configuration
CONFIG_FILE="/etc/roundfleet/file_deletion_policy.conf"
LOG_FILE="/var/log/roundfleet_file_deletion.log"
BACKUP_DIR="/Library/Roundfleet/DeletedFiles"
AUDIT_LOG="/var/log/roundfleet_deletion_audit.log"
QUARANTINE_DIR="/Library/Roundfleet/QuarantinedFiles"

# Créer les répertoires
mkdir -p "$(dirname "$CONFIG_FILE")" "$(dirname "$LOG_FILE")" "$BACKUP_DIR" "$(dirname "$AUDIT_LOG")" "$QUARANTINE_DIR"

# Politique de gestion de suppression de fichiers par défaut
cat > "$CONFIG_FILE" 2>/dev/null << 'EOF' || true
# Politique de Gestion de Suppression de Fichiers Entreprise Roundfleet
# Version : 2.0

# Application des Politiques de Suppression
ENFORCE_DELETION_POLICIES=true
REQUIRE_BACKUP_BEFORE_DELETE=true
SECURE_DELETION_ENABLED=true
PREVENT_SYSTEM_FILE_DELETION=true
BUSINESS_HOURS_PROTECTION=true

# Sécurité et Protection des Données
REQUIRE_ADMIN_APPROVAL=false
VALIDATE_FILE_PERMISSIONS=true
PROTECTED_DIRECTORIES_ENFORCEMENT=true
MALWARE_QUARANTINE_CHECK=true
SENSITIVE_DATA_DETECTION=true

# Sauvegarde et Récupération
AUTOMATIC_BACKUP_ENABLED=true
BACKUP_RETENTION_DAYS=30
COMPRESSED_BACKUPS=true
ENCRYPTED_BACKUPS=true
RECOVERY_VALIDATION=true

# Conformité et Audit
AUDIT_ALL_DELETIONS=true
COMPLIANCE_REPORTING=true
INCIDENT_DOCUMENTATION=true
GDPR_COMPLIANCE=true
DATA_CLASSIFICATION_AWARE=true

# Expérience Utilisateur
USER_NOTIFICATION_ENABLED=true
DELETION_CONFIRMATION=true
PROGRESS_MONITORING=true
BATCH_OPERATION_SUPPORT=true
ROLLBACK_CAPABILITY=true

# Performance et Sécurité
DELETION_TIMEOUT=300
MAX_CONCURRENT_DELETIONS=5
SIZE_LIMIT_CHECK=true
FREE_SPACE_MONITORING=true
SYSTEM_LOAD_MONITORING=true
EOF

# Charger la configuration
source "$CONFIG_FILE" 2>/dev/null || true

# Fonction de journalisation
log_action() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') - $1" | tee -a "$LOG_FILE"
}

# Fonction de journalisation d'audit
audit_log() {
    local action="$1"
    local file_path="$2"
    local result="$3"
    local details="$4"
    echo "$(date '+%Y-%m-%d %H:%M:%S') - ACTION:$action FILE:$file_path RESULT:$result DETAILS:$details USER:$(whoami) SIZE:$(get_file_size "$file_path")" >> "$AUDIT_LOG"
}

# Obtenir la taille de fichier pour audit
get_file_size() {
    local file_path="$1"
    if [[ -e "$file_path" ]]; then
        du -sh "$file_path" 2>/dev/null | awk '{print $1}' || echo "inconnu"
    else
        echo "0"
    fi
}

# Valider la sécurité de suppression de fichier
validate_deletion_safety() {
    local file_path="$1"
    local force="${2:-false}"
    
    echo "=== Validation de Sécurité de Suppression de Fichier ==="
    
    # Vérifier si le fichier/répertoire existe
    if [[ ! -e "$file_path" ]]; then
        echo "❌ Fichier ou répertoire introuvable : $file_path"
        audit_log "VALIDATION" "$file_path" "NOT_FOUND" "Fichier ou répertoire n'existe pas"
        return 1
    fi
    
    echo "✅ Fichier/répertoire trouvé : $file_path"
    
    # Empêcher la suppression de fichiers système
    if [[ "$PREVENT_SYSTEM_FILE_DELETION" == "true" ]]; then
        local protected_paths=(
            "/System"
            "/Library/System"
            "/usr/bin"
            "/usr/sbin"
            "/bin"
            "/sbin"
            "/var/db"
            "/private/var/db"
            "/Applications/Utilities"
        )
        
        for protected_path in "${protected_paths[@]}"; do
            if [[ "$file_path" == "$protected_path"* ]]; then
                echo "❌ Impossible de supprimer le chemin système protégé : $file_path"
                audit_log "VALIDATION" "$file_path" "PROTECTED_PATH" "Suppression de fichier système bloquée"
                return 1
            fi
        done
    fi
    
    # Vérifier les répertoires protégés
    if [[ "$PROTECTED_DIRECTORIES_ENFORCEMENT" == "true" && "$force" != "true" ]]; then
        local protected_dirs=(
            "/Users/*/Documents/Important"
            "/Users/*/Desktop/Critique"
            "/Library/Roundfleet/Config"
            "/etc"
            "/Applications"
        )
        
        for protected_dir in "${protected_dirs[@]}"; do
            if [[ "$file_path" == $protected_dir* ]]; then
                echo "❌ Fichier dans répertoire protégé : $file_path"
                audit_log "VALIDATION" "$file_path" "PROTECTED_DIR" "Accès répertoire protégé bloqué"
                return 1
            fi
        done
    fi
    
    # Protection des heures de bureau pour données utilisateur
    if [[ "$BUSINESS_HOURS_PROTECTION" == "true" && "$force" != "true" ]]; then
        local current_hour
        current_hour=$(date +%H)
        local current_day
        current_day=$(date +%u)  # 1=Lundi, 7=Dimanche
        
        if [[ $current_day -ge 1 && $current_day -le 5 && $current_hour -ge 9 && $current_hour -lt 18 ]]; then
            if [[ "$file_path" == "/Users/"* ]]; then
                echo "⚠️  Protection heures de bureau : Suppression données utilisateur restreinte"
                audit_log "VALIDATION" "$file_path" "BUSINESS_HOURS" "Suppression données utilisateur bloquée pendant heures de bureau"
                return 1
            fi
        fi
    fi
    
    # Vérifier les permissions de fichier
    if [[ "$VALIDATE_FILE_PERMISSIONS" == "true" ]]; then
        if [[ ! -w "$file_path" && ! -w "$(dirname "$file_path")" ]]; then
            echo "❌ Permissions insuffisantes pour supprimer : $file_path"
            audit_log "VALIDATION" "$file_path" "NO_PERMISSION" "Permissions insuffisantes pour suppression"
            return 1
        fi
    fi
    
    # Détection de données sensibles
    if [[ "$SENSITIVE_DATA_DETECTION" == "true" ]]; then
        if detect_sensitive_data "$file_path"; then
            echo "⚠️  Données sensibles détectées dans : $file_path"
            if [[ "$force" != "true" ]]; then
                audit_log "VALIDATION" "$file_path" "SENSITIVE_DATA" "Suppression données sensibles nécessite flag force"
                return 1
            fi
        fi
    fi
    
    audit_log "VALIDATION" "$file_path" "PASSED" "Toutes les vérifications de sécurité réussies"
    return 0
}

# Détecter les données sensibles dans les fichiers
detect_sensitive_data() {
    local file_path="$1"
    
    if [[ -f "$file_path" ]]; then
        # Vérifier les motifs de données sensibles courants
        local sensitive_patterns=(
            "\b\d{3}-\d{2}-\d{4}\b"  # Motif SSN
            "\b\d{4}[- ]?\d{4}[- ]?\d{4}[- ]?\d{4}\b"  # Motif carte de crédit
            "password"
            "secret"
            "private.*key"
            "confidential"
        )
        
        for pattern in "${sensitive_patterns[@]}"; do
            if grep -qi "$pattern" "$file_path" 2>/dev/null; then
                return 0  # Données sensibles trouvées
            fi
        done
    fi
    
    return 1  # Aucune donnée sensible trouvée
}

# Créer une sauvegarde avant suppression
create_backup() {
    local file_path="$1"
    local backup_reason="${2:-deletion}"
    
    if [[ "$AUTOMATIC_BACKUP_ENABLED" != "true" ]]; then
        return 0
    fi
    
    echo "=== Création de Sauvegarde ==="
    
    local backup_timestamp
    backup_timestamp=$(date +%Y%m%d_%H%M%S)
    local backup_name
    backup_name="$(basename "$file_path")_${backup_timestamp}_${backup_reason}"
    local backup_path="$BACKUP_DIR/$backup_name"
    
    # Créer la structure de répertoire de sauvegarde
    mkdir -p "$BACKUP_DIR"
    
    # Copier fichier/répertoire vers l'emplacement de sauvegarde
    if [[ -d "$file_path" ]]; then
        # Sauvegarde de répertoire
        if [[ "$COMPRESSED_BACKUPS" == "true" ]]; then
            tar -czf "${backup_path}.tar.gz" -C "$(dirname "$file_path")" "$(basename "$file_path")" 2>/dev/null
            backup_path="${backup_path}.tar.gz"
        else
            cp -R "$file_path" "$backup_path" 2>/dev/null
        fi
    else
        # Sauvegarde de fichier
        if [[ "$COMPRESSED_BACKUPS" == "true" && $(stat -f%z "$file_path" 2>/dev/null || echo 0) -gt 1048576 ]]; then
            gzip -c "$file_path" > "${backup_path}.gz" 2>/dev/null
            backup_path="${backup_path}.gz"
        else
            cp "$file_path" "$backup_path" 2>/dev/null
        fi
    fi
    
    if [[ $? -eq 0 ]]; then
        echo "✅ Sauvegarde créée : $backup_path"
        
        # Chiffrer la sauvegarde si activé
        if [[ "$ENCRYPTED_BACKUPS" == "true" ]]; then
            encrypt_backup "$backup_path"
        fi
        
        # Enregistrer la sauvegarde dans les métadonnées
        echo "$(date -u +%Y-%m-%dT%H:%M:%SZ)|$file_path|$backup_path|$backup_reason" >> "$BACKUP_DIR/backup_manifest.log"
        
        log_action "Sauvegarde créée pour $file_path à $backup_path"
        audit_log "BACKUP" "$file_path" "CREATED" "Chemin sauvegarde : $backup_path"
        
        return 0
    else
        echo "❌ Échec de création de sauvegarde pour : $file_path"
        log_action "ÉCHEC : Création de sauvegarde échouée pour $file_path"
        audit_log "BACKUP" "$file_path" "FAILED" "Erreur création sauvegarde"
        return 1
    fi
}

# Chiffrer le fichier de sauvegarde
encrypt_backup() {
    local backup_path="$1"
    
    # Chiffrement simple utilisant les outils intégrés (en production, utiliser chiffrement entreprise approprié)
    if command -v openssl >/dev/null 2>&1; then
        openssl enc -aes-256-cbc -salt -in "$backup_path" -out "${backup_path}.enc" -k "Roundfleet_Backup_Key_$(date +%Y)" 2>/dev/null
        if [[ $? -eq 0 ]]; then
            rm "$backup_path"
            echo "🔐 Sauvegarde chiffrée : ${backup_path}.enc"
            log_action "Sauvegarde chiffrée : ${backup_path}.enc"
        fi
    fi
}

# Suppression sécurisée de fichier
secure_delete() {
    local file_path="$1"
    local secure_passes="${2:-3}"
    
    echo "=== Processus de Suppression Sécurisée ==="
    
    if [[ ! -e "$file_path" ]]; then
        echo "❌ Fichier introuvable pour suppression sécurisée : $file_path"
        return 1
    fi
    
    local file_size
    file_size=$(get_file_size "$file_path")
    
    # Pour les fichiers, effectuer écrasement sécurisé avant suppression
    if [[ -f "$file_path" && "$SECURE_DELETION_ENABLED" == "true" ]]; then
        echo "🔐 Effectuant suppression sécurisée avec $secure_passes passes..."
        
        # Écrasement multiple passes
        for ((pass=1; pass<=secure_passes; pass++)); do
            echo "Passe $pass/$secure_passes : Écrasement avec données aléatoires..."
            dd if=/dev/urandom of="$file_path" bs=1024 count=$(du -k "$file_path" 2>/dev/null | cut -f1) 2>/dev/null || true
            sync
        done
        
        # Passe finale zéros
        dd if=/dev/zero of="$file_path" bs=1024 count=$(du -k "$file_path" 2>/dev/null | cut -f1) 2>/dev/null || true
        sync
        
        echo "🔐 Écrasement sécurisé terminé"
        audit_log "SECURE_DELETE" "$file_path" "OVERWRITTEN" "Écrasement sécurisé avec $secure_passes passes"
    fi
    
    # Effectuer suppression finale
    if [[ -d "$file_path" ]]; then
        # Suppression de répertoire
        rm -rf "$file_path" 2>/dev/null
    else
        # Suppression de fichier
        rm -f "$file_path" 2>/dev/null
    fi
    
    local deletion_result=$?
    
    if [[ $deletion_result -eq 0 ]]; then
        echo "✅ Fichier supprimé de manière sécurisée : $file_path (Taille : $file_size)"
        audit_log "SECURE_DELETE" "$file_path" "SUCCESS" "Suppression sécurisée terminée (Taille : $file_size)"
        return 0
    else
        echo "❌ Échec de suppression : $file_path"
        audit_log "SECURE_DELETE" "$file_path" "FAILED" "Suppression échouée"
        return 1
    fi
}

# Suppression de fichier entreprise avec gestion complète
enterprise_file_delete() {
    local file_path="$1"
    local force="${2:-false}"
    local secure="${3:-true}"
    local backup="${4:-true}"
    
    echo "=== Suppression de Fichier Entreprise ==="
    
    if [[ -z "$file_path" ]]; then
        echo "❌ Chemin de fichier requis"
        return 1
    fi
    
    log_action "SUPPRESSION FICHIER ENTREPRISE : Début suppression de $file_path"
    
    # Validation pré-suppression
    if ! validate_deletion_safety "$file_path" "$force"; then
        log_action "ÉCHEC : Validation sécurité suppression fichier échouée pour $file_path"
        return 1
    fi
    
    # Créer sauvegarde si requis
    if [[ "$backup" == "true" || "$REQUIRE_BACKUP_BEFORE_DELETE" == "true" ]]; then
        if ! create_backup "$file_path" "pre_deletion"; then
            if [[ "$force" != "true" ]]; then
                echo "❌ Sauvegarde échouée et mode force non activé"
                return 1
            else
                echo "⚠️  Procédure sans sauvegarde (mode force)"
            fi
        fi
    fi
    
    # Vérifier les ressources système
    check_system_resources
    
    # Confirmation utilisateur si activée
    if [[ "$DELETION_CONFIRMATION" == "true" && "$force" != "true" ]]; then
        echo "⚠️  Confirmation suppression requise pour : $file_path"
        # Dans les scripts automatisés, ceci s'intégrerait avec les flux d'approbation
        log_action "Confirmation suppression requise pour $file_path"
    fi
    
    # Effectuer la suppression
    local start_time
    start_time=$(date +%s)
    
    if [[ "$secure" == "true" ]]; then
        secure_delete "$file_path"
    else
        # Suppression standard
        if [[ -d "$file_path" ]]; then
            rm -rf "$file_path" 2>/dev/null
        else
            rm -f "$file_path" 2>/dev/null
        fi
    fi
    
    local deletion_result=$?
    local end_time
    end_time=$(date +%s)
    local duration=$((end_time - start_time))
    
    # Envoyer des notifications
    send_deletion_notification "$file_path" "$deletion_result" "$duration"
    
    # Nettoyage et vérification
    if [[ $deletion_result -eq 0 ]]; then
        echo "✅ Suppression de fichier terminée avec succès : $file_path"
        log_action "SUCCÈS : Fichier supprimé avec succès : $file_path (Durée : ${duration}s)"
        
        # Mettre à jour les statistiques d'utilisation
        update_deletion_stats "$file_path"
        
        # Nettoyer les fichiers liés
        cleanup_related_files "$file_path"
        
        return 0
    else
        echo "❌ Suppression de fichier échouée : $file_path"
        log_action "ÉCHEC : Impossible de supprimer le fichier : $file_path"
        return 1
    fi
}

# Envoyer une notification de suppression
send_deletion_notification() {
    local file_path="$1"
    local result="$2"
    local duration="$3"
    
    if [[ "$USER_NOTIFICATION_ENABLED" != "true" ]]; then
        return 0
    fi
    
    echo "=== Envoi des Notifications de Suppression ==="
    
    local notification_title="Gestion de Fichiers Roundfleet"
    local result_text="succès"
    if [[ $result -ne 0 ]]; then
        result_text="échec"
    fi
    
    local notification_message="Suppression de fichier $result_text : $(basename "$file_path") (${duration}s)"
    
    # Afficher notification aux utilisateurs connectés
    local logged_users
    logged_users=$(who | awk '{print $1}' | sort -u)
    
    for user in $logged_users; do
        if [[ -n "$user" ]]; then
            sudo -u "$user" osascript -e "display notification \"$notification_message\" with title \"$notification_title\"" 2>/dev/null || true
            echo "📱 Notification envoyée à l'utilisateur : $user"
        fi
    done
    
    log_action "Notifications de suppression envoyées pour $file_path ($result_text)"
}

# Opérations de suppression de fichiers en masse
bulk_file_deletion() {
    local file_list="$1"
    local force="${2:-false}"
    local secure="${3:-true}"
    
    echo "=== Opérations de Suppression de Fichiers en Masse ==="
    
    local success_count=0
    local failure_count=0
    local total_count=0
    
    # Gérer différents types d'entrée
    if [[ -f "$file_list" ]]; then
        # Liste de fichiers depuis fichier
        while IFS= read -r file_path; do
            # Ignorer lignes vides et commentaires
            if [[ -z "$file_path" || "$file_path" == \#* ]]; then
                continue
            fi
            
            ((total_count++))
            echo "Traitement ($total_count) : $file_path"
            
            if enterprise_file_delete "$file_path" "$force" "$secure"; then
                ((success_count++))
            else
                ((failure_count++))
            fi
            
            echo "---"
            sleep 1  # Brève pause entre opérations
        done < "$file_list"
    else
        # Suppression basée sur motif
        echo "Suppression basée sur motif : $file_list"
        
        # Étendre le motif et traiter chaque fichier
        for file_path in $file_list; do
            if [[ -e "$file_path" ]]; then
                ((total_count++))
                echo "Traitement ($total_count) : $file_path"
                
                if enterprise_file_delete "$file_path" "$force" "$secure"; then
                    ((success_count++))
                else
                    ((failure_count++))
                fi
            fi
        done
    fi
    
    echo "=== Résumé de Suppression en Masse ==="
    echo "Total fichiers traités : $total_count"
    echo "Suppressions réussies : $success_count"
    echo "Suppressions échouées : $failure_count"
    
    log_action "Suppression en masse terminée : $success_count/$total_count réussies"
    audit_log "BULK_DELETE" "MULTIPLE" "COMPLETED" "Succès : $success_count Échecs : $failure_count Total : $total_count"
}

# Nettoyer les anciennes sauvegardes selon la politique de rétention
cleanup_old_backups() {
    echo "=== Nettoyage de Rétention de Sauvegarde ==="
    
    if [[ ! -d "$BACKUP_DIR" ]]; then
        echo "Aucun répertoire de sauvegarde trouvé"
        return 0
    fi
    
    local retention_days="${BACKUP_RETENTION_DAYS:-30}"
    local cleanup_count=0
    
    # Trouver et supprimer les anciennes sauvegardes
    while IFS= read -r old_backup; do
        if [[ -n "$old_backup" ]]; then
            rm -f "$old_backup"
            ((cleanup_count++))
            echo "Ancienne sauvegarde supprimée : $old_backup"
        fi
    done < <(find "$BACKUP_DIR" -type f -mtime +$retention_days 2>/dev/null)
    
    echo "Nettoyage de $cleanup_count anciennes sauvegardes (plus de $retention_days jours)"
    log_action "Nettoyage sauvegarde : $cleanup_count anciennes sauvegardes supprimées"
}

# Vérifier les ressources système avant suppression
check_system_resources() {
    echo "=== Vérification des Ressources Système ==="
    
    # Vérifier l'espace disque disponible
    local available_space
    available_space=$(df -h / | tail -1 | awk '{print $4}' | sed 's/G//')
    
    echo "Espace Disponible : ${available_space}GB"
    
    if [[ "$FREE_SPACE_MONITORING" == "true" ]] && (( $(echo "$available_space < 5" | bc -l) )); then
        echo "⚠️  Avertissement espace disque faible : ${available_space}GB disponible"
        log_action "Espace disque faible pendant opération suppression : ${available_space}GB"
    fi
    
    # Vérifier la charge système
    local load_average
    load_average=$(uptime | awk -F'load average:' '{print $2}' | awk '{print $1}' | tr -d ',')
    
    echo "Charge Système : $load_average"
    
    if [[ "$SYSTEM_LOAD_MONITORING" == "true" ]] && (( $(echo "$load_average > 5.0" | bc -l) )); then
        echo "⚠️  Charge système élevée : $load_average"
        log_action "Charge système élevée pendant opération suppression : $load_average"
    fi
}

# Générer un rapport de suppression de fichiers
generate_deletion_report() {
    local report_file="/Library/Roundfleet/Reports/file_deletion_report_$(date +%Y%m%d_%H%M%S).json"
    
    echo "=== Génération du Rapport de Suppression de Fichiers ==="
    
    mkdir -p "$(dirname "$report_file")"
    
    # Compter les opérations récentes du journal d'audit
    local recent_deletions=0
    local successful_deletions=0
    local failed_deletions=0
    local total_backup_size=0
    
    if [[ -f "$AUDIT_LOG" ]]; then
        recent_deletions=$(grep -c "ACTION:SECURE_DELETE\|ACTION:BULK_DELETE" "$AUDIT_LOG" 2>/dev/null || echo 0)
        successful_deletions=$(grep -c "RESULT:SUCCESS" "$AUDIT_LOG" 2>/dev/null || echo 0)
        failed_deletions=$(grep -c "RESULT:FAILED" "$AUDIT_LOG" 2>/dev/null || echo 0)
    fi
    
    if [[ -d "$BACKUP_DIR" ]]; then
        total_backup_size=$(du -sh "$BACKUP_DIR" 2>/dev/null | awk '{print $1}' || echo "0")
    fi
    
    cat > "$report_file" << EOF
{
  "report_type": "file_deletion_management",
  "timestamp": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
  "device_info": {
    "hostname": "$(hostname)",
    "os_version": "$(sw_vers -productVersion)",
    "available_space": "$(df -h / | tail -1 | awk '{print $4}')"
  },
  "deletion_statistics": {
    "recent_deletions": $recent_deletions,
    "successful_deletions": $successful_deletions,
    "failed_deletions": $failed_deletions,
    "success_rate": "$(echo "scale=2; $successful_deletions * 100 / ($successful_deletions + $failed_deletions + 1)" | bc)%"
  },
  "backup_statistics": {
    "total_backup_size": "$total_backup_size",
    "backup_retention_days": $BACKUP_RETENTION_DAYS,
    "encrypted_backups": $ENCRYPTED_BACKUPS
  },
  "policy_configuration": {
    "secure_deletion": $SECURE_DELETION_ENABLED,
    "automatic_backup": $AUTOMATIC_BACKUP_ENABLED,
    "business_hours_protection": $BUSINESS_HOURS_PROTECTION,
    "sensitive_data_detection": $SENSITIVE_DATA_DETECTION
  },
  "security_status": {
    "system_file_protection": $PREVENT_SYSTEM_FILE_DELETION,
    "protected_directories": $PROTECTED_DIRECTORIES_ENFORCEMENT,
    "audit_enabled": $AUDIT_ALL_DELETIONS
  }
}
EOF
    
    echo "Rapport de suppression de fichiers sauvegardé dans : $report_file"
    log_action "Rapport de suppression généré : $report_file"
}

# Fonction principale avec gestion d'arguments
main() {
    log_action "=== Outil de Gestion de Suppression de Fichiers Roundfleet Démarré ==="
    
    case "${1:-help}" in
        "delete"|"supprimer")
            enterprise_file_delete "$2" "$3" "$4" "$5"
            ;;
        "bulk"|"masse")
            bulk_file_deletion "$2" "$3" "$4"
            ;;
        "cleanup-backups"|"nettoyer-sauvegardes")
            cleanup_old_backups
            ;;
        "report"|"rapport")
            generate_deletion_report
            ;;
        *)
            echo "Outil de Gestion de Suppression de Fichiers et Dossiers Entreprise Roundfleet"
            echo "Usage : $0 [commande] [options]"
            echo ""
            echo "Commandes :"
            echo "  delete [chemin_fichier] [force] [secure] [backup]  - Supprimer fichier avec contrôles entreprise"
            echo "  bulk [fichier_liste/motif] [force] [secure]       - Suppression en masse depuis liste ou motif"
            echo "  cleanup-backups                                   - Supprimer anciennes sauvegardes selon politique rétention"
            echo "  report                                            - Générer rapport gestion suppression"
            echo ""
            echo "Options :"
            echo "  force    - true/false (contourner vérifications sécurité)"
            echo "  secure   - true/false (activer suppression sécurisée)"
            echo "  backup   - true/false (créer sauvegarde avant suppression)"
            echo ""
            echo "Exemples :"
            echo "  $0 delete \"/Users/user/temp.txt\"            - Suppression sécurisée avec sauvegarde"
            echo "  $0 delete \"/tmp/folder\" true true false     - Suppression sécurisée forcée sans sauvegarde"
            echo "  $0 bulk \"*.log\" false true                 - Suppression sécurisée en masse fichiers log"
            echo "  $0 bulk file_list.txt true                   - Suppression forcée en masse depuis liste"
            echo "  $0 cleanup-backups                           - Nettoyer anciennes sauvegardes"
            ;;
    esac
    
    log_action "=== Opération de gestion de suppression de fichiers terminée ==="
}

# Exécuter la fonction principale
main "$@"

## Notes de Configuration Importantes

### Commandes de Suppression de Fichiers macOS

- **`rm`** - Suppression de fichier de base
- **`rm -r`** - Suppression de répertoire récursive
- **`rm -f`** - Suppression forcée sans invites
- **`rm -rf`** - Suppression récursive forcée
- **Correspondance de motifs** - `*.txt`, `{1,2}.png` pour opérations en masse

### Points d'Intégration Entreprise

- **Prévention de Perte de Données (DLP)** - Intégration avec systèmes DLP
- **Systèmes de Sauvegarde et Récupération** - Intégration sauvegarde automatisée
- **Plateformes de Conformité** - Rapports de conformité GDPR, HIPAA
- **Gestion d'Information et d'Événements de Sécurité (SIEM)** - Journalisation audit suppression

### Bonnes Pratiques pour Suppression de Fichiers Entreprise

1. **Sécurité et Protection des Données**
   - Toujours créer des sauvegardes avant suppression
   - Utiliser suppression sécurisée pour données sensibles
   - Valider les permissions de fichier avant suppression
   - Implémenter protection heures de bureau

2. **Conformité et Gouvernance**
   - Maintenir pistes d'audit complètes
   - Implémenter conscience classification données
   - Supporter exigences conformité réglementaires
   - Documenter toutes opérations suppression

3. **Sécurité et Récupération**
   - Empêcher suppression fichiers système
   - Implémenter capacités de retour arrière
   - Surveiller ressources système pendant opérations
   - Fournir systèmes notification clairs

N'oubliez pas de tester minutieusement les procédures de suppression de fichiers dans un environnement contrôlé avant l'implémentation sur l'ensemble de votre Roundfleet pour assurer la sécurité des données et la conformité avec les politiques organisationnelles.

Guide

Avis important