Gestion Entreprise de Création de Fichiers et Dossiers sur macOS

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 "$@"

Commandes de Référence Rapide

Opérations de Fichier Unique

# Créer un fichier vide
./creation_manager.sh create-file "/Users/admin/document.txt"

# Créer un fichier depuis un modèle
./creation_manager.sh create-file "/Users/admin/rapport.txt" "modele_rapport"

# Créer un fichier avec permissions spécifiques
./creation_manager.sh create-file "/Users/admin/script.sh" "" "755"

# Créer un fichier avec variables de modèle
./creation_manager.sh create-file "/Users/admin/config.json" "modele_config" "644" '{"projet":"MonApp"}'

Opérations de Répertoire

# Créer un répertoire
./creation_manager.sh create-directory "/Users/admin/projet"

# Créer un répertoire avec permissions spécifiques
./creation_manager.sh create-directory "/Users/admin/securise" "" "700"

# Créer une structure de répertoire depuis un modèle
./creation_manager.sh create-directory "/Users/admin/webapp" "structure_webapp"

Opérations en Lot

# Créer une spécification de fichiers en lot
cat > /tmp/fichiers_a_creer.txt << EOF
/Users/admin/doc1.txt|644|
/Users/admin/doc2.txt|644|
/Users/admin/config.json|600|{"env":"prod"}
EOF

# Exécuter la création de fichiers en lot
./creation_manager.sh bulk-files "/tmp/fichiers_a_creer.txt" "modele_defaut"

# Créer une spécification de répertoires en lot
cat > /tmp/repertoires_a_creer.txt << EOF
/Users/admin/projets|755|
/Users/admin/scripts|755|
/Users/admin/logs|750|
EOF

# Exécuter la création de répertoires en lot
./creation_manager.sh bulk-directories "/tmp/repertoires_a_creer.txt"

Gestion des Modèles

# Créer un nouveau modèle
./creation_manager.sh template create "readme" "# {{NOM_PROJET}}

Créé par : {{USER}}
Date : {{DATE}}
Heure : {{TIME}}

## Description
Ceci est un fichier README pour le projet.
"

# Lister les modèles disponibles
./creation_manager.sh template list

# Afficher le contenu d'un modèle
./creation_manager.sh template show "readme"

# Supprimer un modèle
./creation_manager.sh template delete "ancien_modele"

Création d'Espace de Travail Utilisateur

# Créer un espace de travail utilisateur standard
./creation_manager.sh user-workspace "jean.dupont" "standard"

# Créer un espace de travail développeur
./creation_manager.sh user-workspace "marie.martin" "developer"

# Créer un espace de travail admin
./creation_manager.sh user-workspace "admin.utilisateur" "admin"

Exemples d'Intégration

Intégration JAMF Pro

#!/bin/bash

# Script JAMF Pro pour création de fichiers entreprise
# Paramètres : $4 = type_operation, $5 = chemin, $6 = nom_modele, $7 = permissions

TYPE_OPERATION="$4"
CHEMIN="$5"
NOM_MODELE="$6"
PERMISSIONS="$7"

# Télécharger le gestionnaire de création s'il n'est pas présent
if [[ ! -f "/usr/local/bin/roundfleet_creation_manager.sh" ]]; then
    curl -o "/usr/local/bin/roundfleet_creation_manager.sh" "https://scripts.roundfleet.com/creation_manager.sh"
    chmod +x "/usr/local/bin/roundfleet_creation_manager.sh"
fi

# Exécuter l'opération de création
case "$TYPE_OPERATION" in
    "file")
        /usr/local/bin/roundfleet_creation_manager.sh create-file "$CHEMIN" "$NOM_MODELE" "$PERMISSIONS"
        ;;
    "directory")
        /usr/local/bin/roundfleet_creation_manager.sh create-directory "$CHEMIN" "$NOM_MODELE" "$PERMISSIONS"
        ;;
    "workspace")
        local username=$(basename "$CHEMIN")
        /usr/local/bin/roundfleet_creation_manager.sh user-workspace "$username" "$NOM_MODELE"
        ;;
    *)
        echo "Type d'opération invalide : $TYPE_OPERATION"
        exit 1
        ;;
esac

# Générer un rapport
/usr/local/bin/roundfleet_creation_manager.sh report

exit $?

Profil de Configuration pour Politiques de Création

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
<plist version="1.0">
<dict>
    <key>PayloadContent</key>
    <array>
        <dict>
            <key>PayloadType</key>
            <string>com.roundfleet.creation.policy</string>
            <key>PayloadIdentifier</key>
            <string>com.roundfleet.creation.policy.main</string>
            <key>PayloadDisplayName</key>
            <string>Politique de Création Roundfleet</string>
            <key>AllowedExtensions</key>
            <array>
                <string>.txt</string>
                <string>.md</string>
                <string>.pdf</string>
                <string>.docx</string>
            </array>
            <key>DefaultFilePermissions</key>
            <string>644</string>
            <key>DefaultDirectoryPermissions</key>
            <string>755</string>
            <key>MaxFilenameLength</key>
            <integer>255</integer>
            <key>MaxPathDepth</key>
            <integer>20</integer>
            <key>EnforceNamingConventions</key>
            <true/>
        </dict>
    </array>
</dict>
</plist>

Exemples de Modèles

Modèle de Structure de Projet

{
  "name": "structure_webapp",
  "type": "directory_structure",
  "structure": {
    "src": {
      "type": "directory",
      "permissions": "755",
      "files": {
        "index.js": {
          "template": "javascript_main",
          "permissions": "644"
        },
        "package.json": {
          "template": "package_json",
          "permissions": "644"
        }
      },
      "subdirectories": {
        "components": {
          "type": "directory",
          "permissions": "755"
        },
        "utils": {
          "type": "directory",
          "permissions": "755"
        }
      }
    },
    "docs": {
      "type": "directory",
      "permissions": "755",
      "files": {
        "README.md": {
          "template": "readme",
          "permissions": "644"
        }
      }
    }
  }
}

Modèles de Fichiers

# Créer des modèles par défaut
./creation_manager.sh template create "readme" "# {{NOM_PROJET}}

## Aperçu
Ce projet a été créé le {{DATE}} par {{USER}}.

## Démarrage
1. Lire cette documentation
2. Examiner la structure du code
3. Commencer le développement

## Contact
Pour toute question, contacter {{USER}}@entreprise.com
"

./creation_manager.sh template create "gitignore" "# Logs
logs
*.log
npm-debug.log*

# Données d'exécution
pids
*.pid
*.seed

# Répertoire pour les librairies instrumentées
lib-cov

# Répertoire de couverture
coverage

# Répertoires de dépendances
node_modules/

# Répertoire de cache npm optionnel
.npm

# Historique REPL optionnel
.node_repl_history
"

./creation_manager.sh template create "config_json" "{
  \"name\": \"{{NOM_PROJET}}\",
  \"version\": \"1.0.0\",
  \"description\": \"Projet créé le {{DATE}}\",
  \"author\": \"{{USER}}\",
  \"created\": \"{{DATE}} {{TIME}}\",
  \"environment\": \"development\"
}
"

Fonctionnalités de Sécurité et Conformité

Gestion des Permissions

# Définir des permissions sécurisées pour les fichiers sensibles
create_secure_file() {
    local file_path="$1"
    local content="$2"
    
    # Créer le fichier avec des permissions restrictives
    enterprise_create_file "$file_path" "" "600"
    
    # Ajouter le contenu de manière sécurisée
    echo "$content" > "$file_path"
    
    # S'assurer que seul le propriétaire peut accéder
    chmod 600 "$file_path"
}

Rapport de Conformité

# Générer un rapport de conformité pour les auditeurs
generate_compliance_report() {
    local report_file="/var/reports/creation_compliance_$(date +%Y%m%d).csv"
    
    echo "Horodatage,Utilisateur,Type,Chemin,Permissions,Modèle,Statut" > "$report_file"
    
    # Analyser le fichier de log pour les opérations de création
    grep "AUDIT.*créé :" "$LOG_FILE" | while read line; do
        # Extraire les informations pertinentes et formater en CSV
        echo "$line" | awk -F' - ' '{print $1","$2}' >> "$report_file"
    done
    
    echo "Rapport de conformité généré : $report_file"
}

Dépannage

Problèmes Courants et Solutions

Problème	Cause	Solution
Permission refusée	Privilèges insuffisants	Vérifier les permissions du répertoire parent
Le fichier existe déjà	Tentative de création en double	Utiliser des noms uniques ou vérifier l'existence d'abord
Caractères invalides	Caractères spéciaux dans le nom	Utiliser uniquement des caractères alphanumériques
Chemin trop profond	Dépasse la profondeur maximale	Réduire l'imbrication des répertoires
Modèle non trouvé	Fichier de modèle manquant	Créer le modèle ou utiliser un nom différent

Analyse des Logs

# Voir les opérations de création récentes
tail -f /var/log/roundfleet_creation_operations.log

# Rechercher les opérations échouées
grep "ERROR" /var/log/roundfleet_creation_operations.log

# Compter les opérations par type
grep -c "Fichier créé" /var/log/roundfleet_creation_operations.log
grep -c "Répertoire créé" /var/log/roundfleet_creation_operations.log

Meilleures Pratiques

Utiliser les modèles de manière cohérente pour des structures standardisées
Définir des permissions appropriées selon la sensibilité des fichiers
Valider les conventions de nommage avant la création
Surveiller régulièrement les logs de création pour les violations de politique
Tester minutieusement les modèles avant le déploiement en flotte
Utiliser les opérations en lot pour l'efficacité à grande échelle
Implémenter l'automatisation de l'espace de travail utilisateur pour l'intégration
Mises à jour régulières des modèles pour maintenir les standards

Ce système de gestion de création entreprise fournit une gestion complète des modèles, une validation de sécurité et des capacités d'automatisation tout en maintenant la simplicité des opérations de création de fichiers et répertoires de base pour une gestion efficace de flotte.

Guide

Avis important