Guide

Découvrez et gérez les fichiers sur vos appareils Roundfleet en utilisant des systèmes de recherche et découverte de fichiers avancés. Ce tutoriel couvre la recherche de chemins de fichiers, les recherches basées sur les extensions, l'analyse de contenu et la gestion complète du cycle de vie des fichiers.

Comprendre la Découverte de Fichiers macOS

macOS fournit plusieurs capacités de découverte et recherche de fichiers :

• find - Utilitaire de recherche de fichiers et répertoires en ligne de commande
• Résolution de Chemin de Fichier - Localiser des fichiers spécifiques par nom et extension
• Filtrage par Extension - Rechercher des fichiers par type et format de fichier
• Recherche de Contenu - Trouver des fichiers basés sur le contenu et les métadonnées
• Intégration Spotlight - Exploiter l'indexation macOS pour des recherches rapides

Opérations de Découverte de Fichiers de Base

Trouver un Chemin de Fichier

#!/bin/bash

# Recherche de chemin de fichier de base
find / -name 'nom de fichier avec extension' -print 2>/dev/null

echo "Recherche de chemin de fichier terminée"

Découverte de Fichiers Améliorée

#!/bin/bash

# Découverte de fichiers complète avec multiples méthodes de recherche
discover_file_paths() {
    local file_pattern="$1"
    local search_scope="${2:-/}"
    local search_type="${3:-name}"
    
    echo "=== Découverte de Fichiers et Résolution de Chemin ==="
    echo "Motif de Recherche : $file_pattern"
    echo "Portée de Recherche : $search_scope"
    echo "Type de Recherche : $search_type"
    
    # Valider les paramètres de recherche
    if [[ -z "$file_pattern" ]]; then
        echo "❌ Le motif de fichier est requis"
        return 1
    fi
    
    if [[ ! -d "$search_scope" ]]; then
        echo "❌ Répertoire de portée de recherche non trouvé : $search_scope"
        return 1
    fi
    
    # Effectuer la recherche basée sur le type
    echo "Démarrage de la découverte de fichiers..."
    local results_count=0
    
    case "$search_type" in
        "name")
            echo "Recherche par nom de fichier..."
            find "$search_scope" -name "$file_pattern" -print 2>/dev/null | while read -r file_path; do
                echo "Trouvé : $file_path"
                ((results_count++))
            done
            ;;
        "iname")
            echo "Recherche par nom de fichier (insensible à la casse)..."
            find "$search_scope" -iname "$file_pattern" -print 2>/dev/null | while read -r file_path; do
                echo "Trouvé : $file_path"
                ((results_count++))
            done
            ;;
        "type")
            echo "Recherche par type de fichier..."
            find "$search_scope" -type f -name "$file_pattern" -print 2>/dev/null | while read -r file_path; do
                echo "Trouvé : $file_path"
                ((results_count++))
            done
            ;;
        "content")
            echo "Recherche par contenu..."
            grep -r "$file_pattern" "$search_scope" 2>/dev/null | while read -r match; do
                echo "Correspondance de contenu : $match"
                ((results_count++))
            done
            ;;
        *)
            echo "❌ Type de recherche inconnu : $search_type"
            return 1
            ;;
    esac
    
    echo "✅ Découverte de fichiers terminée"
    log_discovery_action "$file_pattern" "$search_scope" "$search_type" "succès"
    
    return 0
}

# Exemple d'utilisation
# discover_file_paths "document.txt" "/" "name"

Lister les Fichiers par Extension

#!/bin/bash

# Recherche d'extension de fichier améliorée
find_files_by_extension() {
    local extension="$1"
    local count="${2:-10}"
    local search_path="${3:-/}"
    
    echo "=== Recherche de Fichiers par Extension ==="
    echo "Extension : .$extension"
    echo "Limite de Résultats : $count"
    echo "Chemin de Recherche : $search_path"
    
    # Recherche d'extension de base
    echo "Recherche de fichiers .$extension..."
    find "$search_path" -name "*.$extension" -print 2>/dev/null | head -n "$count"
    
    echo "✅ Recherche d'extension terminée"
}

# Exemple d'utilisation
# find_files_by_extension "txt" 10 "/"

Catégories de Découverte de Fichiers

Classifications de Types de Fichiers

#!/bin/bash

# Catégories de découverte de fichiers pour différents types de fichiers et objectifs
declare -A FILE_CATEGORIES=(
    ["config_systeme"]="Fichiers de configuration système et préférences"
    ["donnees_application"]="Fichiers de données d'application et préférences utilisateur"
    ["contenu_media"]="Images, vidéos, fichiers audio et contenu multimédia"
    ["fichiers_document"]="Documents texte, feuilles de calcul, présentations"
    ["code_developpement"]="Code source, scripts, projets de développement"
    ["archive_compresse"]="Archives compressées et fichiers de sauvegarde"
    ["certificats_securite"]="Certificats de sécurité, clés et identifiants"
    ["log_diagnostic"]="Journaux système, fichiers de diagnostic et données de dépannage"
    ["cache_temporaire"]="Fichiers cache, données temporaires et contenu jetable"
    ["base_donnees_structuree"]="Fichiers de base de données et stockage de données structurées"
)

# Extensions de fichiers pour chaque catégorie
declare -A CATEGORY_EXTENSIONS=(
    ["config_systeme"]="plist,conf,cfg,ini,settings,preferences"
    ["donnees_application"]="app,dmg,pkg,bundle,framework"
    ["contenu_media"]="jpg,jpeg,png,gif,mp4,mov,mp3,wav,m4a"
    ["fichiers_document"]="pdf,doc,docx,xls,xlsx,ppt,pptx,txt,rtf"
    ["code_developpement"]="swift,m,h,py,js,ts,php,java,cpp,c"
    ["archive_compresse"]="zip,tar,gz,bz2,rar,7z,dmg"
    ["certificats_securite"]="p12,pem,crt,key,keychain,cer"
    ["log_diagnostic"]="log,crash,diag,report,trace"
    ["cache_temporaire"]="cache,tmp,temp,bak,swp"
    ["base_donnees_structuree"]="db,sqlite,sql,json,xml,csv"
)

# Priorités de recherche pour différentes catégories
declare -A SEARCH_PRIORITIES=(
    ["config_systeme"]="haute"
    ["donnees_application"]="moyenne"
    ["contenu_media"]="faible"
    ["fichiers_document"]="haute"
    ["code_developpement"]="moyenne"
    ["archive_compresse"]="faible"
    ["certificats_securite"]="critique"
    ["log_diagnostic"]="moyenne"
    ["cache_temporaire"]="faible"
    ["base_donnees_structuree"]="haute"
)

print_file_categories() {
    echo "=== Catégories de Découverte de Fichiers ==="
    for category in "${!FILE_CATEGORIES[@]}"; do
        echo "Catégorie : $category"
        echo "  Description : ${FILE_CATEGORIES[$category]}"
        echo "  Extensions : ${CATEGORY_EXTENSIONS[$category]}"
        echo "  Priorité : ${SEARCH_PRIORITIES[$category]}"
        echo ""
    done
}

# Afficher les catégories disponibles
print_file_categories

Politiques de Découverte de Fichiers

Politiques de Recherche et Découverte

#!/bin/bash

# Politiques de découverte de fichiers pour différentes exigences organisationnelles
declare -A DISCOVERY_POLICIES=(
    ["audit_securite"]="Découverte de fichiers axée sécurité avec numérisation complète"
    ["conformite_gdpr"]="Découverte de fichiers conforme GDPR pour identification de données personnelles"
    ["inventaire_actifs"]="Inventaire complet d'actifs et catalogage de fichiers"
    ["nettoyage_performance"]="Optimisation de performance par identification de nettoyage de fichiers"
    ["verification_sauvegarde"]="Vérification de sauvegarde et contrôle d'intégrité de données"
    ["enquete_medico_legale"]="Découverte de fichiers médico-légaux pour enquête d'incident"
)

# Obtenir la configuration de politique de découverte
get_discovery_policy() {
    local policy_type="$1"
    
    case "$policy_type" in
        "audit_securite")
            cat << EOF
{
    "decouverte_activee": true,
    "portee_recherche": "complete",
    "types_fichiers_priorite": ["certificats_securite", "config_systeme", "log_diagnostic"],
    "analyse_contenu": true,
    "collecte_metadonnees": true,
    "analyse_permissions": true,
    "verification_hash": true,
    "suivi_acces": true,
    "detection_chiffrement": true,
    "motifs_suspects": ["password", "key", "token", "secret"],
    "niveau_rapport": "detaille",
    "journalisation_audit": "complete",
    "surveillance_temps_reel": true
}
EOF
            ;;
        "conformite_gdpr")
            cat << EOF
{
    "decouverte_activee": true,
    "portee_recherche": "donnees_utilisateur_focus",
    "types_fichiers_priorite": ["fichiers_document", "base_donnees_structuree", "donnees_application"],
    "analyse_contenu": true,
    "collecte_metadonnees": true,
    "detection_donnees_personnelles": true,
    "classification_donnees": true,
    "analyse_retention": true,
    "suivi_consentement": false,
    "identification_sujet_donnees": true,
    "analyse_transfrontaliere": true,
    "motifs_vie_privee": ["email", "phone", "ssn", "passport", "address"],
    "niveau_rapport": "conforme_vie_privee",
    "journalisation_audit": "conforme_gdpr",
    "cartographie_donnees": true
}
EOF
            ;;
        "inventaire_actifs")
            cat << EOF
{
    "decouverte_activee": true,
    "portee_recherche": "systeme_complet",
    "types_fichiers_priorite": ["donnees_application", "config_systeme", "fichiers_document"],
    "analyse_contenu": false,
    "collecte_metadonnees": true,
    "analyse_taille": true,
    "suivi_modification": true,
    "analyse_propriete": true,
    "detection_version": true,
    "conformite_licence": true,
    "detection_doublons": true,
    "optimisation_stockage": true,
    "niveau_rapport": "focus_inventaire",
    "journalisation_audit": "standard",
    "catalogage": true
}
EOF
            ;;
        *)
            echo "Politique de découverte inconnue : $policy_type"
            return 1
            ;;
    esac
}

# Appliquer une politique de découverte
apply_discovery_policy() {
    local policy="$1"
    local config_file="/tmp/politique_decouverte.json"
    
    echo "Application de la politique de découverte de fichiers : $policy"
    
    get_discovery_policy "$policy" > "$config_file"
    
    if [[ ! -f "$config_file" ]]; then
        echo "❌ Échec de génération de configuration de politique"
        return 1
    fi
    
    echo "✅ Politique de découverte de fichiers appliquée avec succès"
    echo "Configuration : $config_file"
    
    # Afficher les paramètres clés de politique
    echo "=== Résumé de Politique ==="
    echo "Découverte Activée : $(jq -r '.decouverte_activee' "$config_file")"
    echo "Portée de Recherche : $(jq -r '.portee_recherche' "$config_file")"
    echo "Analyse de Contenu : $(jq -r '.analyse_contenu' "$config_file")"
    echo "Collecte de Métadonnées : $(jq -r '.collecte_metadonnees' "$config_file")"
    echo "Niveau de Rapport : $(jq -r '.niveau_rapport' "$config_file")"
    
    return 0
}

Découverte et Analyse Avancées de Fichiers

Système de Découverte de Fichiers Complet

#!/bin/bash

# Découverte de fichiers avancée avec analyse de contenu et extraction de métadonnées
advanced_file_discovery() {
    local search_criteria="$1"
    local analysis_level="${2:-standard}"
    local output_format="${3:-text}"
    
    echo "=== Système de Découverte de Fichiers Avancé ==="
    echo "Critères de Recherche : $search_criteria"
    echo "Niveau d'Analyse : $analysis_level"
    echo "Format de Sortie : $output_format"
    
    local discovery_report="/tmp/decouverte_fichiers_$(date +%Y%m%d_%H%M%S).json"
    
    # Initialiser le rapport de découverte
    cat > "$discovery_report" << EOF
{
    "session_decouverte": {
        "criteres_recherche": "$search_criteria",
        "niveau_analyse": "$analysis_level",
        "horodatage": "$(date -Iseconds)",
        "nom_hote": "$(hostname)",
        "operateur": "$(whoami)"
    },
    "fichiers_decouverts": [],
    "statistiques_fichiers": {},
    "analyse_contenu": {},
    "resultats_securite": {}
}
EOF
    
    # Effectuer une découverte de fichiers complète
    echo "Exécution de recherche de fichiers complète..."
    
    # Recherche par multiples critères
    local files_found=0
    
    # Recherche de nom de fichier de base
    echo "  - Recherche par motifs de nom de fichier..."
    find / -name "*$search_criteria*" -type f -print 2>/dev/null | while read -r file_path; do
        analyze_discovered_file "$file_path" "$analysis_level" "$discovery_report"
        ((files_found++))
    done
    
    # Recherche basée sur le contenu
    if [[ "$analysis_level" == "complet" ]]; then
        echo "  - Exécution d'analyse de contenu..."
        grep -r "$search_criteria" / 2>/dev/null | head -100 | while read -r match; do
            local file_path
            file_path=$(echo "$match" | cut -d':' -f1)
            analyze_discovered_file "$file_path" "$analysis_level" "$discovery_report"
        done
    fi
    
    # Générer des statistiques de fichiers
    generate_file_statistics "$discovery_report"
    
    # Afficher les résultats
    echo ""
    echo "Résultats de Découverte :"
    echo "  Fichiers Trouvés : $files_found"
    echo "  Rapport de Découverte : $discovery_report"
    
    # Formater la sortie
    case "$output_format" in
        "json")
            cat "$discovery_report"
            ;;
        "resume")
            jq -r '.session_decouverte, .statistiques_fichiers' "$discovery_report"
            ;;
        *)
            echo "Découverte terminée - voir le fichier de rapport pour détails"
            ;;
    esac
    
    return 0
}

# Analyser un fichier découvert
analyze_discovered_file() {
    local file_path="$1"
    local analysis_level="$2"
    local report_file="$3"
    
    if [[ ! -f "$file_path" ]]; then
        return 1
    fi
    
    # Informations de fichier de base
    local file_size
    file_size=$(stat -f%z "$file_path" 2>/dev/null || echo "0")
    local file_permissions
    file_permissions=$(stat -f%A "$file_path" 2>/dev/null || echo "inconnu")
    local file_owner
    file_owner=$(stat -f%Su "$file_path" 2>/dev/null || echo "inconnu")
    local modification_time
    modification_time=$(stat -f%Sm "$file_path" 2>/dev/null || echo "inconnu")
    
    # Analyse améliorée pour niveau complet
    local file_type="inconnu"
    local content_preview=""
    local security_flags=""
    
    if [[ "$analysis_level" == "complet" ]]; then
        file_type=$(file -b "$file_path" 2>/dev/null || echo "inconnu")
        
        # Aperçu de contenu sécurisé pour fichiers texte
        if file "$file_path" | grep -q "text"; then
            content_preview=$(head -c 200 "$file_path" 2>/dev/null | tr '\n' ' ')
        fi
        
        # Analyse de sécurité
        if [[ "$file_permissions" =~ 7.* ]]; then
            security_flags="executable_par_proprietaire"
        fi
        
        if [[ "$file_path" =~ \.key$|\.pem$|\.p12$ ]]; then
            security_flags="${security_flags},potentiel_identifiant_securite"
        fi
    fi
    
    # Journaliser la découverte de fichier
    log_discovered_file "$file_path" "$file_size" "$file_type" "$security_flags"
}

# Journaliser un fichier découvert
log_discovered_file() {
    local file_path="$1"
    local file_size="$2"
    local file_type="$3"
    local security_flags="$4"
    
    echo "$(date '+%Y-%m-%d %H:%M:%S') - Fichier Découvert : $file_path (Taille : $file_size, Type : $file_type, Sécurité : $security_flags)" >> "/var/log/roundfleet_decouverte_fichiers.log"
}

Système de Gestion de Découverte de Fichiers

#!/bin/bash

# Système de Gestion de Découverte et Recherche de Fichiers Roundfleet
# Découverte, catalogage et gestion complètes de fichiers

# Configuration
CONFIG_DIR="/etc/roundfleet/decouverte"
LOG_FILE="/var/log/roundfleet_decouverte_fichiers.log"
AUDIT_LOG="/var/log/roundfleet_audit_decouverte.log"
INDEX_DIR="/var/index/roundfleet/decouverte"

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

audit_log() {
    echo "$(date '+%Y-%m-%d %H:%M:%S') [AUDIT] $1" | tee -a "$AUDIT_LOG"
}

# Indexation du système de fichiers
create_file_index() {
    local index_scope="${1:-/Users}"
    local index_level="${2:-standard}"
    
    log_action "Création d'index du système de fichiers : $index_scope (Niveau : $index_level)"
    
    echo "=== Indexation du Système de Fichiers ==="
    echo "Portée d'Index : $index_scope"
    echo "Niveau d'Index : $index_level"
    
    local index_file="$INDEX_DIR/index_fichiers_$(date +%Y%m%d_%H%M%S).json"
    
    # Initialiser l'index
    cat > "$index_file" << EOF
{
    "metadonnees_index": {
        "portee": "$index_scope",
        "niveau": "$index_level",
        "cree": "$(date -Iseconds)",
        "nom_hote": "$(hostname)",
        "total_fichiers": 0,
        "taille_totale": 0
    },
    "entrees_fichiers": []
}
EOF
    
    echo "Démarrage de l'indexation du système de fichiers..."
    local file_count=0
    
    # Indexer les fichiers basé sur le niveau
    case "$index_level" in
        "de_base")
            find "$index_scope" -type f -print 2>/dev/null | while read -r file_path; do
                index_file_basic "$file_path" "$index_file"
                ((file_count++))
                
                if [[ $((file_count % 1000)) -eq 0 ]]; then
                    echo "  Indexé $file_count fichiers..."
                fi
            done
            ;;
        "standard")
            find "$index_scope" -type f -print 2>/dev/null | while read -r file_path; do
                index_file_standard "$file_path" "$index_file"
                ((file_count++))
                
                if [[ $((file_count % 500)) -eq 0 ]]; then
                    echo "  Indexé $file_count fichiers..."
                fi
            done
            ;;
        "complet")
            find "$index_scope" -type f -print 2>/dev/null | while read -r file_path; do
                index_file_comprehensive "$file_path" "$index_file"
                ((file_count++))
                
                if [[ $((file_count % 100)) -eq 0 ]]; then
                    echo "  Indexé $file_count fichiers..."
                fi
            done
            ;;
        *)
            echo "❌ Niveau d'index inconnu : $index_level"
            return 1
            ;;
    esac
    
    echo "✅ Indexation du système de fichiers terminée"
    echo "  Fichiers Indexés : $file_count"
    echo "  Fichier d'Index : $index_file"
    
    audit_log "Index du système de fichiers créé : $index_scope ($file_count fichiers)"
    
    return 0
}

# Fonction principale avec routage de commandes
main() {
    local command="$1"
    shift
    
    case "$command" in
        "trouver_fichier")
            # Trouver un fichier spécifique par nom
            discover_file_paths "$@"
            ;;
        "trouver_extension")
            # Trouver des fichiers par extension
            find_files_by_extension "$@"
            ;;
        "recherche_avancee")
            # Découverte de fichiers avancée
            advanced_file_discovery "$@"
            ;;
        "creer_index")
            # Créer un index du système de fichiers
            create_file_index "$@"
            ;;
        "appliquer_politique")
            # Appliquer une politique de découverte
            apply_discovery_policy "$@"
            ;;
        "afficher_categories")
            # Afficher les catégories de fichiers
            print_file_categories
            ;;
        "afficher_politiques")
            # Afficher les politiques disponibles
            for policy in audit_securite conformite_gdpr inventaire_actifs nettoyage_performance verification_sauvegarde enquete_medico_legale; do
                echo "Politique : $policy"
                get_discovery_policy "$policy" | jq .
                echo ""
            done
            ;;
        *)
            echo "Système de Gestion de Découverte et Recherche de Fichiers Roundfleet"
            echo "Utilisation : $0 <commande> [options]"
            echo ""
            echo "Commandes :"
            echo "  trouver_fichier <motif> [portée] [type]               - Trouver fichiers spécifiques par motif"
            echo "  trouver_extension <ext> [nombre] [chemin]             - Trouver fichiers par extension"
            echo "  recherche_avancee <critères> [niveau] [format]       - Découverte de fichiers avancée"
            echo "  creer_index [portée] [niveau]                        - Créer index du système de fichiers"
            echo "  appliquer_politique <politique>                      - Appliquer politique de découverte"
            echo "  afficher_categories                                  - Afficher catégories de fichiers"
            echo "  afficher_politiques                                  - Afficher politiques de découverte"
            echo ""
            echo "Exemples :"
            echo "  $0 trouver_fichier \"document.txt\" \"/Users\" \"name\""
            echo "  $0 trouver_extension \"pdf\" 20 \"/Users\""
            echo "  $0 recherche_avancee \"config\" \"complet\" \"json\""
            echo "  $0 creer_index \"/Users\" \"standard\""
            echo "  $0 appliquer_politique \"audit_securite\""
            ;;
    esac
}

# Exécuter la fonction principale avec tous les arguments
main "$@"

Considérations de Sécurité

Sécurité de Découverte de Fichiers

• Contrôles d'Accès - Respecter les permissions de fichiers et restrictions d'accès
• Protection de Données Sensibles - Éviter d'exposer le contenu de fichiers sensibles dans les journaux
• Impact sur les Performances - Surveiller les performances système pendant la découverte à grande échelle
• Conformité de Vie Privée - S'assurer que les pratiques de découverte respectent les réglementations de vie privée
• Pistes d'Audit - Maintenir des journaux complets des activités de découverte

Cadre de Conformité

• Classification de Données - Classifier correctement les fichiers découverts basé sur la sensibilité
• Politiques de Rétention - Implémenter la rétention et élimination appropriées de données
• Journalisation d'Accès - Journaliser tous les accès aux fichiers et activités de découverte
• Protection de Vie Privée - Protéger les informations personnelles et sensibles pendant la découverte
• Conformité Réglementaire - Respecter les exigences de découverte et catalogage spécifiques à l'industrie

Guide de Dépannage

Problèmes Courants

Erreurs de Permission Refusée

• Exécuter la découverte avec privilèges appropriés : sudo pour recherches système
• Vérifier les permissions de fichiers et répertoires : ls -la
• Vérifier l'accessibilité de la portée de recherche

Performance de Recherche Lente

• Limiter la portée de recherche à des répertoires spécifiques
• Utiliser des recherches indexées pour données fréquemment consultées
• Considérer la spécificité des critères de recherche

Commandes de Diagnostic

# Tester la fonctionnalité find de base
find /Users -name "*.txt" -print 2>/dev/null | head -5

# Vérifier les permissions du système de fichiers
ls -la /chemin/vers/repertoire/recherche

# Surveiller les performances de recherche
time find /Users -name "motif" -print 2>/dev/null

# Vérifier l'espace disque disponible pour l'indexation
df -h

Notes Importantes

• Échappement de Chemin de Fichier - Utiliser des guillemets ou barres obliques inverses pour chemins avec espaces : "Nouveau Dossier/fichier.txt" ou Nouveau\ Dossier/fichier.txt
• Portée de Recherche - Les recherches plus larges prennent plus de temps mais fournissent des résultats plus complets
• Impact Système - La découverte de fichiers à grande échelle peut impacter les performances système
• Limites de Résultats - Utiliser des limites appropriées pour éviter une sortie écrasante
• Maintenance d'Index - Mettre régulièrement à jour les index de fichiers pour précision
• Sensibilisation à la Sécurité - Être prudent lors de la recherche de fichiers et identifiants sensibles

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. 

Gérez efficacement les opérations de création de fichiers et dossiers dans votre déploiement Roundfleet avec une gestion de modèles de niveau entreprise, un contrôle des permissions et des capacités d'audit complètes. Ce tutoriel transforme les commandes de base touch et mkdir en solutions robustes de provisionnement de système de fichiers.

Comprendre les Opérations de Création de Fichiers en Entreprise

La création de fichiers en entreprise nécessite plus que de simples opérations de système de fichiers, exigeant :

• Gestion de modèles pour des structures de fichiers et dossiers standardisées
• Contrôle des permissions pour appliquer les politiques de sécurité
• Validation du contenu pour les fichiers et répertoires créés
• Journalisation d'audit pour le suivi de conformité
• Provisionnement automatisé pour l'intégration des utilisateurs
• Application de politiques pour les conventions de nommage et la structure

Opérations de Création de Base

Création de Fichier Basique

#!/bin/bash

# Création simple de fichier avec validation
create_file() {
    local file_path="$1"
    local content="${2:-}"
    
    # Valider que le répertoire parent existe
    local parent_dir=$(dirname "$file_path")
    if [[ ! -d "$parent_dir" ]]; then
        echo "Erreur : Le répertoire parent '$parent_dir' n'existe pas"
        return 1
    fi
    
    # Créer le fichier
    if touch "$file_path"; then
        # Ajouter le contenu si fourni
        if [[ -n "$content" ]]; then
            echo "$content" > "$file_path"
        fi
        echo "Fichier créé avec succès '$file_path'"
        return 0
    else
        echo "Échec de la création du fichier '$file_path'"
        return 1
    fi
}

# Exemple d'utilisation
# create_file "/Users/admin/document.txt" "Contenu initial"

Création de Répertoire Basique

#!/bin/bash

# Création de répertoire avec validation
create_directory() {
    local dir_path="$1"
    local permissions="${2:-755}"
    
    # Créer le répertoire avec parents si nécessaire
    if mkdir -p "$dir_path"; then
        # Définir les permissions
        chmod "$permissions" "$dir_path"
        echo "Répertoire créé avec succès '$dir_path'"
        return 0
    else
        echo "Échec de la création du répertoire '$dir_path'"
        return 1
    fi
}

# Exemple d'utilisation
# create_directory "/Users/admin/projet" "755"

Système de Gestion de Création Entreprise

#!/bin/bash

# Système de Gestion de Création de Fichiers Entreprise Roundfleet
# Création complète de fichiers et dossiers avec fonctionnalités entreprise

# Configuration
SCRIPT_NAME="Gestionnaire de Création Roundfleet"
VERSION="1.0.0"
LOG_FILE="/var/log/roundfleet_creation_operations.log"
TEMPLATE_DIR="/etc/roundfleet/templates"
POLICY_DIR="/etc/roundfleet/policies"
TEMP_DIR="/tmp/roundfleet_creation"
DEFAULT_FILE_PERMISSIONS="644"
DEFAULT_DIR_PERMISSIONS="755"
RESTRICTED_PATHS=("/System" "/usr/bin" "/usr/sbin" "/private/var" "/Library/LaunchDaemons")
ALLOWED_EXTENSIONS=(".txt" ".md" ".pdf" ".docx" ".xlsx" ".pptx" ".csv" ".json" ".xml" ".log")
MAX_FILENAME_LENGTH=255
MAX_PATH_DEPTH=20
BUSINESS_HOURS_START=9
BUSINESS_HOURS_END=17

# Créer les répertoires nécessaires
mkdir -p "$TEMP_DIR"
mkdir -p "$TEMPLATE_DIR"
mkdir -p "$POLICY_DIR"
mkdir -p "$(dirname "$LOG_FILE")"

# Fonction de journalisation
log_operation() {
    local level="$1"
    local message="$2"
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    local username=$(whoami)
    echo "[$timestamp] [$level] [$username] $message" | tee -a "$LOG_FILE"
}

# Vérifier si l'heure actuelle est dans les heures de bureau
is_business_hours() {
    local current_hour=$(date +%H)
    if [[ $current_hour -ge $BUSINESS_HOURS_START && $current_hour -lt $BUSINESS_HOURS_END ]]; then
        return 0
    else
        return 1
    fi
}

# Valider l'extension de fichier
is_allowed_extension() {
    local file="$1"
    local extension="${file##*.}"
    extension=".$extension"
    
    for allowed in "${ALLOWED_EXTENSIONS[@]}"; do
        if [[ "$extension" == "$allowed" ]]; then
            return 0
        fi
    done
    return 1
}

# Vérifier si le chemin est restreint
is_restricted_path() {
    local path="$1"
    for restricted in "${RESTRICTED_PATHS[@]}"; do
        if [[ "$path" == "$restricted"* ]]; then
            return 0
        fi
    done
    return 1
}

# Valider les conventions de nommage
validate_naming_convention() {
    local name="$1"
    local type="$2"  # "file" ou "directory"
    
    # Vérifier la longueur
    if [[ ${#name} -gt $MAX_FILENAME_LENGTH ]]; then
        log_operation "ERROR" "Nom trop long (${#name} > $MAX_FILENAME_LENGTH) : $name"
        return 1
    fi
    
    # Vérifier les caractères invalides
    if [[ "$name" =~ [^a-zA-Z0-9._-] ]]; then
        log_operation "WARNING" "Le nom contient des caractères spéciaux : $name"
    fi
    
    # Vérifier les noms réservés
    local reserved_names=("CON" "PRN" "AUX" "NUL" "COM1" "COM2" "LPT1" "LPT2")
    local base_name=$(basename "$name" | tr '[:lower:]' '[:upper:]')
    
    for reserved in "${reserved_names[@]}"; do
        if [[ "$base_name" == "$reserved" ]]; then
            log_operation "ERROR" "Nom réservé non autorisé : $name"
            return 1
        fi
    done
    
    return 0
}

# Vérifier la profondeur du chemin
validate_path_depth() {
    local path="$1"
    local depth=$(echo "$path" | tr '/' '\n' | wc -l)
    
    if [[ $depth -gt $MAX_PATH_DEPTH ]]; then
        log_operation "ERROR" "Profondeur de chemin trop importante ($depth > $MAX_PATH_DEPTH) : $path"
        return 1
    fi
    
    return 0
}

# Charger le modèle de fichier
load_file_template() {
    local template_name="$1"
    local template_file="$TEMPLATE_DIR/$template_name.template"
    
    if [[ -f "$template_file" ]]; then
        cat "$template_file"
        return 0
    else
        log_operation "WARNING" "Modèle non trouvé : $template_name"
        return 1
    fi
}

# Appliquer la substitution de variables au modèle
apply_template_variables() {
    local content="$1"
    local variables="$2"  # Chaîne JSON avec variables
    
    # Substitution de variables de base
    content=$(echo "$content" | sed "s/{{DATE}}/$(date '+%Y-%m-%d')/g")
    content=$(echo "$content" | sed "s/{{TIME}}/$(date '+%H:%M:%S')/g")
    content=$(echo "$content" | sed "s/{{USER}}/$(whoami)/g")
    content=$(echo "$content" | sed "s/{{HOSTNAME}}/$(hostname)/g")
    
    # Variables personnalisées depuis JSON (simplifié)
    if [[ -n "$variables" ]]; then
        # Ceci serait amélioré avec un parsing JSON approprié en production
        log_operation "INFO" "Application des variables de modèle personnalisées"
    fi
    
    echo "$content"
}

# Créer une structure de répertoire depuis un modèle
create_structure_from_template() {
    local template_name="$1"
    local base_path="$2"
    local variables="${3:-}"
    
    local structure_file="$TEMPLATE_DIR/structures/$template_name.json"
    
    if [[ ! -f "$structure_file" ]]; then
        log_operation "ERROR" "Modèle de structure non trouvé : $template_name"
        return 1
    fi
    
    log_operation "INFO" "Création de structure depuis le modèle : $template_name à $base_path"
    
    # Ceci analyserait la structure JSON et créerait répertoires/fichiers
    # Implémentation simplifiée pour démonstration
    mkdir -p "$base_path"
    
    return 0
}

# Création de fichier améliorée avec fonctionnalités entreprise
enterprise_create_file() {
    local file_path="$1"
    local template_name="${2:-}"
    local permissions="${3:-$DEFAULT_FILE_PERMISSIONS}"
    local variables="${4:-}"
    
    local operation_id=$(date +%s)
    log_operation "INFO" "Début de l'opération de création de fichier [$operation_id] : $file_path"
    
    # Validations préliminaires
    local filename=$(basename "$file_path")
    local parent_dir=$(dirname "$file_path")
    
    # Valider les conventions de nommage
    if ! validate_naming_convention "$filename" "file"; then
        log_operation "ERROR" "Échec de validation des conventions de nommage : $filename"
        return 1
    fi
    
    # Valider la profondeur du chemin
    if ! validate_path_depth "$file_path"; then
        return 1
    fi
    
    # Vérifier si le chemin est restreint
    if is_restricted_path "$file_path"; then
        log_operation "SECURITY" "Création bloquée dans un chemin restreint : $file_path"
        return 1
    fi
    
    # Valider l'extension de fichier
    if ! is_allowed_extension "$file_path"; then
        log_operation "SECURITY" "Fichier bloqué avec extension non autorisée : $file_path"
        return 1
    fi
    
    # Vérifier si le fichier existe déjà
    if [[ -f "$file_path" ]]; then
        log_operation "WARNING" "Le fichier existe déjà : $file_path"
        return 1
    fi
    
    # Créer le répertoire parent s'il n'existe pas
    if [[ ! -d "$parent_dir" ]]; then
        if ! mkdir -p "$parent_dir"; then
            log_operation "ERROR" "Échec de création du répertoire parent : $parent_dir"
            return 1
        fi
        log_operation "INFO" "Répertoire parent créé : $parent_dir"
    fi
    
    # Charger le contenu du modèle si spécifié
    local content=""
    if [[ -n "$template_name" ]]; then
        content=$(load_file_template "$template_name")
        if [[ $? -eq 0 ]]; then
            content=$(apply_template_variables "$content" "$variables")
            log_operation "INFO" "Modèle appliqué : $template_name"
        else
            log_operation "WARNING" "Échec du chargement du modèle, création d'un fichier vide"
        fi
    fi
    
    # Créer le fichier
    if touch "$file_path"; then
        # Ajouter le contenu si disponible
        if [[ -n "$content" ]]; then
            echo "$content" > "$file_path"
        fi
        
        # Définir les permissions
        chmod "$permissions" "$file_path"
        
        # Définir la propriété (si exécuté en tant que root)
        if [[ $EUID -eq 0 ]]; then
            local target_user=$(stat -f "%Su" "$parent_dir")
            local target_group=$(stat -f "%Sg" "$parent_dir")
            chown "$target_user:$target_group" "$file_path"
        fi
        
        log_operation "SUCCESS" "Fichier créé avec succès [$operation_id] : $file_path"
        log_operation "AUDIT" "Fichier créé : $file_path (permissions : $permissions)"
        
        return 0
    else
        log_operation "ERROR" "Échec de création du fichier [$operation_id] : $file_path"
        return 1
    fi
}

# Création de répertoire améliorée avec fonctionnalités entreprise
enterprise_create_directory() {
    local dir_path="$1"
    local template_name="${2:-}"
    local permissions="${3:-$DEFAULT_DIR_PERMISSIONS}"
    local create_parents="${4:-true}"
    
    local operation_id=$(date +%s)
    log_operation "INFO" "Début de l'opération de création de répertoire [$operation_id] : $dir_path"
    
    # Validations préliminaires
    local dirname=$(basename "$dir_path")
    
    # Valider les conventions de nommage
    if ! validate_naming_convention "$dirname" "directory"; then
        log_operation "ERROR" "Échec de validation des conventions de nommage : $dirname"
        return 1
    fi
    
    # Valider la profondeur du chemin
    if ! validate_path_depth "$dir_path"; then
        return 1
    fi
    
    # Vérifier si le chemin est restreint
    if is_restricted_path "$dir_path"; then
        log_operation "SECURITY" "Création bloquée dans un chemin restreint : $dir_path"
        return 1
    fi
    
    # Vérifier si le répertoire existe déjà
    if [[ -d "$dir_path" ]]; then
        log_operation "WARNING" "Le répertoire existe déjà : $dir_path"
        return 1
    fi
    
    # Créer le répertoire
    local mkdir_options=""
    if [[ "$create_parents" == "true" ]]; then
        mkdir_options="-p"
    fi
    
    if mkdir $mkdir_options "$dir_path"; then
        # Définir les permissions
        chmod "$permissions" "$dir_path"
        
        # Définir la propriété (si exécuté en tant que root)
        if [[ $EUID -eq 0 ]]; then
            local parent_dir=$(dirname "$dir_path")
            if [[ -d "$parent_dir" ]]; then
                local target_user=$(stat -f "%Su" "$parent_dir")
                local target_group=$(stat -f "%Sg" "$parent_dir")
                chown "$target_user:$target_group" "$dir_path"
            fi
        fi
        
        # Appliquer la structure du modèle si spécifiée
        if [[ -n "$template_name" ]]; then
            create_structure_from_template "$template_name" "$dir_path"
        fi
        
        log_operation "SUCCESS" "Répertoire créé avec succès [$operation_id] : $dir_path"
        log_operation "AUDIT" "Répertoire créé : $dir_path (permissions : $permissions)"
        
        return 0
    else
        log_operation "ERROR" "Échec de création du répertoire [$operation_id] : $dir_path"
        return 1
    fi
}

# Opérations de création en lot
bulk_create_operation() {
    local operation_type="$1"  # "file" ou "directory"
    local items_file="$2"      # Fichier contenant les spécifications de création
    local template_name="${3:-}"
    
    if [[ ! -f "$items_file" ]]; then
        log_operation "ERROR" "Fichier d'éléments non trouvé : $items_file"
        return 1
    fi
    
    local total_items=$(grep -v '^#\|^$' "$items_file" | wc -l)
    local current_item=0
    local success_count=0
    local failure_count=0
    
    log_operation "INFO" "Début de l'opération de création en lot - Total d'éléments : $total_items"
    
    while IFS='|' read -r path permissions variables; do
        # Ignorer les lignes vides et commentaires
        [[ -z "$path" || "$path" =~ ^#.* ]] && continue
        
        ((current_item++))
        
        # Supprimer les espaces
        path=$(echo "$path" | xargs)
        permissions=$(echo "$permissions" | xargs)
        variables=$(echo "$variables" | xargs)
        
        echo "Traitement [$current_item/$total_items] : $(basename "$path")"
        
        case "$operation_type" in
            "file")
                if enterprise_create_file "$path" "$template_name" "$permissions" "$variables"; then
                    ((success_count++))
                else
                    ((failure_count++))
                fi
                ;;
            "directory")
                if enterprise_create_directory "$path" "$template_name" "$permissions"; then
                    ((success_count++))
                else
                    ((failure_count++))
                fi
                ;;
        esac
        
        # Mise à jour du progrès
        local progress=$((current_item * 100 / total_items))
        echo "Progrès : $progress% ($success_count réussis, $failure_count échoués)"
        
    done < "$items_file"
    
    log_operation "SUCCESS" "Création en lot terminée - Succès : $success_count, Échecs : $failure_count"
    return $failure_count
}

# Automatisation d'intégration utilisateur
create_user_workspace() {
    local username="$1"
    local user_type="${2:-standard}"  # standard, admin, developer
    local base_path="/Users/$username"
    
    log_operation "INFO" "Création de l'espace de travail pour l'utilisateur : $username (type : $user_type)"
    
    # Créer les répertoires utilisateur
    local directories=(
        "$base_path/Documents"
        "$base_path/Desktop"
        "$base_path/Downloads"
        "$base_path/Pictures"
        "$base_path/Movies"
        "$base_path/Music"
    )
    
    # Ajouter des répertoires spécifiques au type
    case "$user_type" in
        "developer")
            directories+=("$base_path/Projects" "$base_path/Scripts" "$base_path/Tools")
            ;;
        "admin")
            directories+=("$base_path/Admin" "$base_path/Logs" "$base_path/Configs")
            ;;
    esac
    
    # Créer les répertoires
    for dir in "${directories[@]}"; do
        if enterprise_create_directory "$dir" "" "755"; then
            log_operation "INFO" "Répertoire utilisateur créé : $dir"
        fi
    done
    
    # Créer les fichiers par défaut
    local files=(
        "$base_path/Desktop/Bienvenue.txt|welcome|644"
        "$base_path/Documents/LISEZMOI.txt|readme|644"
    )
    
    for file_spec in "${files[@]}"; do
        IFS='|' read -r file_path template perms <<< "$file_spec"
        if enterprise_create_file "$file_path" "$template" "$perms"; then
            log_operation "INFO" "Fichier utilisateur créé : $file_path"
        fi
    done
    
    log_operation "SUCCESS" "Espace de travail utilisateur créé pour : $username"
}

# Générer un rapport de création
generate_creation_report() {
    local report_file="/tmp/roundfleet_creation_report_$(date +%Y%m%d_%H%M%S).txt"
    
    {
        echo "Rapport des Opérations de Création Roundfleet"
        echo "Généré : $(date)"
        echo "Nom d'hôte : $(hostname)"
        echo "Utilisateur : $(whoami)"
        echo "================================="
        echo ""
        
        echo "Opérations de Création Récentes (Dernières 24 heures) :"
        if [[ -f "$LOG_FILE" ]]; then
            local yesterday=$(date -v-1d '+%Y-%m-%d')
            grep "$yesterday\|$(date '+%Y-%m-%d')" "$LOG_FILE" | grep -E "(AUDIT|SUCCESS)" | tail -50
        else
            echo "Aucun fichier de log trouvé"
        fi
        
        echo ""
        echo "Statistiques de Création :"
        if [[ -f "$LOG_FILE" ]]; then
            echo "Total d'Opérations : $(grep -c "opération de création" "$LOG_FILE" 2>/dev/null || echo "0")"
            echo "Fichiers Créés : $(grep -c "Fichier créé :" "$LOG_FILE" 2>/dev/null || echo "0")"
            echo "Répertoires Créés : $(grep -c "Répertoire créé :" "$LOG_FILE" 2>/dev/null || echo "0")"
            echo "Opérations Échouées : $(grep -c "ERROR.*Échec" "$LOG_FILE" 2>/dev/null || echo "0")"
        fi
        
        echo ""
        echo "Utilisation des Modèles :"
        if [[ -d "$TEMPLATE_DIR" ]]; then
            echo "Modèles Disponibles :"
            find "$TEMPLATE_DIR" -name "*.template" -exec basename {} .template \; | sort
        fi
        
        echo ""
        echo "Informations Système :"
        echo "Espace Disponible :"
        df -h | grep -E "^/dev/"
        
    } > "$report_file"
    
    echo "Rapport des opérations de création sauvegardé à : $report_file"
    log_operation "INFO" "Rapport de création généré : $report_file"
}

# Gestion des modèles
manage_templates() {
    local action="$1"
    local template_name="$2"
    local template_content="$3"
    
    case "$action" in
        "create")
            if [[ -z "$template_name" || -z "$template_content" ]]; then
                echo "Usage : manage_templates create <nom> <contenu>"
                return 1
            fi
            
            local template_file="$TEMPLATE_DIR/$template_name.template"
            echo "$template_content" > "$template_file"
            log_operation "INFO" "Modèle créé : $template_name"
            ;;
        "list")
            echo "Modèles Disponibles :"
            find "$TEMPLATE_DIR" -name "*.template" -exec basename {} .template \;
            ;;
        "show")
            if [[ -z "$template_name" ]]; then
                echo "Usage : manage_templates show <nom>"
                return 1
            fi
            
            local template_file="$TEMPLATE_DIR/$template_name.template"
            if [[ -f "$template_file" ]]; then
                cat "$template_file"
            else
                echo "Modèle non trouvé : $template_name"
                return 1
            fi
            ;;
        "delete")
            if [[ -z "$template_name" ]]; then
                echo "Usage : manage_templates delete <nom>"
                return 1
            fi
            
            local template_file="$TEMPLATE_DIR/$template_name.template"
            if [[ -f "$template_file" ]]; then
                rm "$template_file"
                log_operation "INFO" "Modèle supprimé : $template_name"
            else
                echo "Modèle non trouvé : $template_name"
                return 1
            fi
            ;;
    esac
}

# Fonction principale de gestion de création
main() {
    local action="${1:-help}"
    
    case "$action" in
        "create-file")
            local file_path="$2"
            local template_name="$3"
            local permissions="${4:-$DEFAULT_FILE_PERMISSIONS}"
            local variables="$5"
            
            if [[ -z "$file_path" ]]; then
                echo "Usage : $0 create-file <chemin_fichier> [nom_modèle] [permissions] [variables]"
                exit 1
            fi
            
            enterprise_create_file "$file_path" "$template_name" "$permissions" "$variables"
            ;;
        "create-directory")
            local dir_path="$2"
            local template_name="$3"
            local permissions="${4:-$DEFAULT_DIR_PERMISSIONS}"
            local create_parents="${5:-true}"
            
            if [[ -z "$dir_path" ]]; then
                echo "Usage : $0 create-directory <chemin_répertoire> [nom_modèle] [permissions] [créer_parents]"
                exit 1
            fi
            
            enterprise_create_directory "$dir_path" "$template_name" "$permissions" "$create_parents"
            ;;
        "bulk-files")
            local items_file="$2"
            local template_name="$3"
            
            if [[ -z "$items_file" ]]; then
                echo "Usage : $0 bulk-files <fichier_éléments> [nom_modèle]"
                exit 1
            fi
            
            bulk_create_operation "file" "$items_file" "$template_name"
            ;;
        "bulk-directories")
            local items_file="$2"
            local template_name="$3"
            
            if [[ -z "$items_file" ]]; then
                echo "Usage : $0 bulk-directories <fichier_éléments> [nom_modèle]"
                exit 1
            fi
            
            bulk_create_operation "directory" "$items_file" "$template_name"
            ;;
        "user-workspace")
            local username="$2"
            local user_type="${3:-standard}"
            
            if [[ -z "$username" ]]; then
                echo "Usage : $0 user-workspace <nom_utilisateur> [type_utilisateur]"
                exit 1
            fi
            
            create_user_workspace "$username" "$user_type"
            ;;
        "template")
            local template_action="$2"
            local template_name="$3"
            local template_content="$4"
            
            manage_templates "$template_action" "$template_name" "$template_content"
            ;;
        "report")
            generate_creation_report
            ;;
        "help"|*)
            echo "$SCRIPT_NAME v$VERSION"
            echo "Gestion Entreprise de Création de Fichiers et Dossiers"
            echo ""
            echo "Usage : $0 <action> [options]"
            echo ""
            echo "Actions :"
            echo "  create-file <chemin> [modèle] [permissions] [variables]     - Créer un fichier unique"
            echo "  create-directory <chemin> [modèle] [permissions] [parents]  - Créer un répertoire"
            echo "  bulk-files <fichier_éléments> [modèle]                      - Créer plusieurs fichiers"
            echo "  bulk-directories <fichier_éléments> [modèle]               - Créer plusieurs répertoires"
            echo "  user-workspace <nom_utilisateur> [type_utilisateur]        - Créer un espace de travail utilisateur"
            echo "  template <action> [nom] [contenu]                           - Gérer les modèles"
            echo "  report                                                       - Générer un rapport d'opérations"
            echo "  help                                                         - Afficher ce message d'aide"
            echo ""
            echo "Actions de Modèles :"
            echo "  create <nom> <contenu>  - Créer un nouveau modèle"
            echo "  list                    - Lister les modèles disponibles"
            echo "  show <nom>              - Afficher le contenu du modèle"
            echo "  delete <nom>            - Supprimer un modèle"
            echo ""
            echo "Types d'Utilisateurs :"
            echo "  standard    - Espace de travail utilisateur de base"
            echo "  developer   - Espace de travail développeur avec répertoires de projet"
            echo "  admin       - Espace de travail administratif avec répertoires système"
            echo ""
            echo "Fonctionnalités :"
            echo "  • Création de fichiers et répertoires basée sur des modèles"
            echo "  • Gestion des permissions et de la propriété"
            echo "  • Validation des conventions de nommage"
            echo "  • Validation de profondeur de chemin et de sécurité"
            echo "  • Opérations en lot avec surveillance du progrès"
            echo "  • Automatisation de l'espace de travail utilisateur"
            echo "  • Journalisation d'audit complète"
            ;;
    esac
}

# Exécuter la fonction principale avec tous les arguments
main "$@"