Gestion Entreprise de la Date et Heure sur macOS

Gérez les paramètres de date et heure dans votre Roundfleet avec automation de niveau entreprise, contrôles de validation et capacités de surveillance complètes.

Comprendre la Gestion Entreprise de Date et Heure

La gestion de date et heure en entreprise nécessite plus qu'un simple réglage de date, exigeant :

Validation et formatage automatisés avec gestion d'erreurs de niveau entreprise
Opérations date/heure planifiées avec intégration de logique métier
Suivi de conformité pour exigences d'audit et standards réglementaires
Surveillance en temps réel des changements date/heure et intégrité système
Capacités d'intégration avec systèmes de planification et workflow d'entreprise
Contrôles de sécurité pour empêcher manipulation temporelle non autorisée

Processus de Base de Gestion Date et Heure

Commandes de Base

Définir Date/Heure - date MMDDhhmm[[CC]YY][.ss]
Définition Paramétrée - date $1 (avec passage d'argument)

Format Date de Base

Le format suit : MMDDhhmm[[CC]YY][.ss]

MM - Mois (01-12)
DD - Jour (01-31)
hh - Heure (00-23)
mm - Minutes (00-59)
CC - Siècle (optionnel)
YY - Année (optionnel)
ss - Secondes (optionnel)

Exemples de Configuration de Base

# Réglage de date de base
date 120614302023.00  # 6 décembre 2023 14h30

# Version paramétrée
date $1  # Passer la date comme argument

Système de Gestion Date et Heure Entreprise

#!/bin/bash

# Système de Gestion Date et Heure Entreprise Roundfleet
# Gestion complète date/heure avec contrôles entreprise et surveillance

# Configuration
SCRIPT_NAME="Gestionnaire Date/Heure Roundfleet"
VERSION="1.0.0"
LOG_FILE="/var/log/roundfleet_datetime.log"
AUDIT_LOG="/var/log/roundfleet_datetime_audit.log"
CONFIG_DIR="/etc/roundfleet/datetime"
POLICIES_DIR="/etc/roundfleet/datetime/policies"
BACKUP_DIR="/var/backups/datetime"
TEMP_DIR="/tmp/roundfleet_datetime"
ORGANIZATION_NAME="Roundfleet Entreprise"
DEPLOYMENT_MODE="enterprise"
ENABLE_VALIDATION=true
ENABLE_AUDIT_LOGGING=true
ENABLE_BACKUP_RESTORE=true
MAX_TIME_DRIFT_HOURS=24
BUSINESS_HOURS_START="08:00"
BUSINESS_HOURS_END="18:00"

# Modèles de Validation Date/Heure
declare -A DATE_FORMATS=(
    ["roundfleet"]="MMDDhhmm[[CC]YY][.ss]"
    ["iso8601"]="YYYY-MM-DDTHH:MM:SS"
    ["unix"]="secondes_depuis_epoch"
    ["readable"]="Mois DD, YYYY HH:MM:SS"
)

# Politiques de Planification Entreprise
declare -A SCHEDULING_POLICIES=(
    ["immediate"]="executer_maintenant"
    ["business_hours"]="heures_ouverture_seulement"
    ["maintenance_window"]="maintenance_planifiee_seulement"
    ["emergency"]="outrepasser_toutes_restrictions"
)

# Standards de Conformité
declare -A COMPLIANCE_REQUIREMENTS=(
    ["SOX"]="piste_audit_financiere"
    ["HIPAA"]="integrite_temps_sante"
    ["PCI_DSS"]="precision_transaction_paiement"
    ["ISO27001"]="horodatage_securite_information"
)

# Créer les répertoires nécessaires
mkdir -p "$CONFIG_DIR"
mkdir -p "$POLICIES_DIR"
mkdir -p "$BACKUP_DIR"
mkdir -p "$TEMP_DIR"
mkdir -p "$(dirname "$LOG_FILE")"
mkdir -p "$(dirname "$AUDIT_LOG")"

# Définir les permissions sécurisées
chmod 755 "$CONFIG_DIR"
chmod 750 "$POLICIES_DIR"
chmod 750 "$BACKUP_DIR"
chmod 700 "$TEMP_DIR"

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

log_security_event() {
    local event_type="$1"
    local details="$2"
    local severity="$3"
    local admin_user=$(whoami)
    
    local timestamp=$(date '+%Y-%m-%d %H:%M:%S')
    local source_ip=$(who am i | awk '{print $5}' | tr -d '()')
    echo "SECURITY|$timestamp|$event_type|$severity|$admin_user|$source_ip|$details" >> "$AUDIT_LOG"
}

# Obtenir les informations actuelles de date et heure
get_current_datetime() {
    local format="${1:-all}"
    
    echo "=== Informations Date et Heure Actuelles ==="
    echo "Heure Locale : $(date '+%Y-%m-%d %H:%M:%S %Z')"
    echo "Heure UTC : $(date -u '+%Y-%m-%d %H:%M:%S UTC')"
    echo "Timestamp Unix : $(date +%s)"
    echo "Uptime : $(uptime | awk -F'up ' '{print $2}' | awk -F',' '{print $1}')"
    
    case "$format" in
        "roundfleet")
            echo "Format Roundfleet : $(date '+%m%d%H%M%Y.%S')"
            ;;
        "iso8601")
            echo "Format ISO 8601 : $(date '+%Y-%m-%dT%H:%M:%S')"
            ;;
        "detailed")
            echo ""
            echo "Informations Détaillées :"
            echo "  Année : $(date '+%Y')"
            echo "  Mois : $(date '+%m') ($(date '+%B'))"
            echo "  Jour : $(date '+%d')"
            echo "  Heure : $(date '+%H')"
            echo "  Minute : $(date '+%M')"
            echo "  Seconde : $(date '+%S')"
            echo "  Jour de la Semaine : $(date '+%A')"
            echo "  Jour de l'Année : $(date '+%j')"
            echo "  Semaine de l'Année : $(date '+%U')"
            ;;
    esac
    echo ""
}

# Valider le format date/heure
validate_datetime_format() {
    local datetime_string="$1"
    local format_type="${2:-roundfleet}"
    
    echo "=== Validation Format Date/Heure ==="
    echo "Entrée : $datetime_string"
    echo "Format Attendu : $format_type"
    echo ""
    
    case "$format_type" in
        "roundfleet")
            # Valider format Roundfleet : MMDDhhmm[[CC]YY][.ss]
            if [[ "$datetime_string" =~ ^[0-9]{8}([0-9]{4})?(\.[0-9]{2})?$ ]]; then
                local month="${datetime_string:0:2}"
                local day="${datetime_string:2:2}"
                local hour="${datetime_string:4:2}"
                local minute="${datetime_string:6:2}"
                
                # Valider les plages
                if [[ $month -ge 1 && $month -le 12 ]] && \
                   [[ $day -ge 1 && $day -le 31 ]] && \
                   [[ $hour -ge 0 && $hour -le 23 ]] && \
                   [[ $minute -ge 0 && $minute -le 59 ]]; then
                    echo "✅ Format Roundfleet valide"
                    return 0
                else
                    echo "❌ Valeurs date/heure invalides dans format Roundfleet"
                    return 1
                fi
            else
                echo "❌ Structure format Roundfleet invalide"
                echo "Attendu : MMDDhhmm[[CC]YY][.ss]"
                return 1
            fi
            ;;
        "iso8601")
            # Valider format ISO 8601
            if date -j -f "%Y-%m-%dT%H:%M:%S" "$datetime_string" &>/dev/null; then
                echo "✅ Format ISO 8601 valide"
                return 0
            else
                echo "❌ Format ISO 8601 invalide"
                return 1
            fi
            ;;
        "unix")
            # Valider timestamp Unix
            if [[ "$datetime_string" =~ ^[0-9]+$ ]] && [[ $datetime_string -gt 0 ]]; then
                echo "✅ Timestamp Unix valide"
                return 0
            else
                echo "❌ Timestamp Unix invalide"
                return 1
            fi
            ;;
        *)
            echo "❌ Type de format inconnu : $format_type"
            return 1
            ;;
    esac
}

# Convertir entre formats de date
convert_datetime_format() {
    local input_datetime="$1"
    local from_format="$2"
    local to_format="$3"
    
    echo "=== Conversion Format Date/Heure ==="
    echo "Entrée : $input_datetime"
    echo "De : $from_format"
    echo "Vers : $to_format"
    echo ""
    
    local converted_datetime
    
    case "$from_format" in
        "roundfleet")
            # Convertir depuis format Roundfleet
            local month="${input_datetime:0:2}"
            local day="${input_datetime:2:2}"
            local hour="${input_datetime:4:2}"
            local minute="${input_datetime:6:2}"
            local year_part="${input_datetime:8:4}"
            local seconds_part="${input_datetime:13:2}"
            
            # Année par défaut si non fournie
            if [[ -z "$year_part" ]]; then
                year_part=$(date '+%Y')
            fi
            
            # Secondes par défaut si non fournies
            if [[ -z "$seconds_part" ]]; then
                seconds_part="00"
            fi
            
            case "$to_format" in
                "iso8601")
                    converted_datetime="${year_part}-${month}-${day}T${hour}:${minute}:${seconds_part}"
                    ;;
                "readable")
                    converted_datetime=$(date -j "${month}${day}${hour}${minute}${year_part}.${seconds_part}" '+%B %d, %Y %H:%M:%S' 2>/dev/null)
                    ;;
                "unix")
                    converted_datetime=$(date -j "${month}${day}${hour}${minute}${year_part}.${seconds_part}" '+%s' 2>/dev/null)
                    ;;
            esac
            ;;
        "iso8601")
            # Convertir depuis format ISO 8601
            case "$to_format" in
                "roundfleet")
                    converted_datetime=$(date -j -f "%Y-%m-%dT%H:%M:%S" "$input_datetime" '+%m%d%H%M%Y.%S' 2>/dev/null)
                    ;;
                "readable")
                    converted_datetime=$(date -j -f "%Y-%m-%dT%H:%M:%S" "$input_datetime" '+%B %d, %Y %H:%M:%S' 2>/dev/null)
                    ;;
                "unix")
                    converted_datetime=$(date -j -f "%Y-%m-%dT%H:%M:%S" "$input_datetime" '+%s' 2>/dev/null)
                    ;;
            esac
            ;;
        "unix")
            # Convertir depuis timestamp Unix
            case "$to_format" in
                "roundfleet")
                    converted_datetime=$(date -r "$input_datetime" '+%m%d%H%M%Y.%S' 2>/dev/null)
                    ;;
                "iso8601")
                    converted_datetime=$(date -r "$input_datetime" '+%Y-%m-%dT%H:%M:%S' 2>/dev/null)
                    ;;
                "readable")
                    converted_datetime=$(date -r "$input_datetime" '+%B %d, %Y %H:%M:%S' 2>/dev/null)
                    ;;
            esac
            ;;
    esac
    
    if [[ -n "$converted_datetime" ]]; then
        echo "✅ Conversion réussie"
        echo "Résultat : $converted_datetime"
        echo "$converted_datetime"
        return 0
    else
        echo "❌ Conversion échouée"
        return 1
    fi
}

# Définir date et heure avec validation entreprise
set_enterprise_datetime() {
    local datetime_input="$1"
    local format_type="${2:-roundfleet}"
    local policy="${3:-business_hours}"
    local force="${4:-false}"
    local admin_user=$(whoami)
    
    log_security_event "DATETIME_CHANGE_ATTEMPT" "datetime=$datetime_input,format=$format_type,policy=$policy" "INFO"
    
    echo "=== Configuration Date/Heure Entreprise ==="
    echo "Entrée : $datetime_input"
    echo "Format : $format_type"
    echo "Politique : $policy"
    echo "Administrateur : $admin_user"
    echo "Mode Force : $force"
    echo ""
    
    # Valider le format d'entrée
    if ! validate_datetime_format "$datetime_input" "$format_type"; then
        log_operation "ERROR" "Format date/heure invalide : $datetime_input ($format_type)"
        return 1
    fi
    
    # Vérifier la politique de planification
    if [[ "$policy" == "business_hours" && "$force" != "true" ]]; then
        local current_hour=$(date '+%H')
        local business_start_hour="${BUSINESS_HOURS_START:0:2}"
        local business_end_hour="${BUSINESS_HOURS_END:0:2}"
        
        if [[ $current_hour -lt $business_start_hour || $current_hour -gt $business_end_hour ]]; then
            echo "⚠️  Opération demandée en dehors des heures d'ouverture ($BUSINESS_HOURS_START-$BUSINESS_HOURS_END)"
            echo "Utilisez force=true pour outrepasser ou attendez les heures d'ouverture"
            log_operation "WARNING" "Changement date/heure bloqué par politique heures d'ouverture"
            return 1
        fi
    fi
    
    # Sauvegarder date/heure actuelle
    local backup_file="$BACKUP_DIR/datetime_$(date +%Y%m%d_%H%M%S).backup"
    {
        echo "# Sauvegarde Date/Heure Roundfleet"
        echo "PREVIOUS_DATETIME=$(date '+%Y-%m-%d %H:%M:%S %Z')"
        echo "PREVIOUS_UTC=$(date -u '+%Y-%m-%d %H:%M:%S UTC')"
        echo "PREVIOUS_UNIX=$(date +%s)"
        echo "BACKUP_TIMESTAMP=$(date)"
        echo "CHANGED_BY=$admin_user"
        echo "NEW_DATETIME=$datetime_input"
        echo "FORMAT_TYPE=$format_type"
        echo "POLICY=$policy"
    } > "$backup_file"
    
    log_operation "INFO" "Sauvegarde date/heure créée : $backup_file"
    
    # Convertir au format approprié si nécessaire
    local roundfleet_format="$datetime_input"
    
    if [[ "$format_type" != "roundfleet" ]]; then
        echo "Conversion $format_type vers format Roundfleet..."
        roundfleet_format=$(convert_datetime_format "$datetime_input" "$format_type" "roundfleet")
        
        if [[ $? -ne 0 ]]; then
            log_operation "ERROR" "Échec conversion format date/heure"
            return 1
        fi
        
        echo "Format converti : $roundfleet_format"
    fi
    
    # Valider la dérive temporelle
    local current_unix=$(date +%s)
    local target_unix=$(convert_datetime_format "$roundfleet_format" "roundfleet" "unix")
    local time_diff=$((target_unix - current_unix))
    local time_diff_hours=$((time_diff / 3600))
    local time_diff_abs=${time_diff_hours#-}
    
    if [[ $time_diff_abs -gt $MAX_TIME_DRIFT_HOURS && "$force" != "true" ]]; then
        echo "⚠️  Grand changement de temps détecté : ${time_diff_hours} heures"
        echo "Ceci dépasse le seuil de dérive maximum de $MAX_TIME_DRIFT_HOURS heures"
        echo "Utilisez force=true pour outrepasser cette vérification de sécurité"
        log_operation "WARNING" "Grande dérive temporelle bloquée : ${time_diff_hours} heures"
        return 1
    fi
    
    # Appliquer le changement date/heure
    echo "Définition date/heure sur : $roundfleet_format"
    
    if sudo date "$roundfleet_format" &>/dev/null; then
        echo "✅ Date/heure définie avec succès"
        log_operation "INFO" "Date/heure changée vers : $roundfleet_format (format: $format_type)"
        log_security_event "DATETIME_CHANGED" "new_datetime=$roundfleet_format,drift_hours=$time_diff_hours,policy=$policy" "INFO"
        
        # Vérifier le changement
        sleep 1
        echo ""
        echo "Vérification :"
        get_current_datetime
        
        return 0
    else
        echo "❌ Échec de définition date/heure"
        log_operation "ERROR" "Échec définition date/heure : $roundfleet_format"
        log_security_event "DATETIME_CHANGE_FAILED" "datetime=$roundfleet_format,error=date_command_failed" "ERROR"
        return 1
    fi
}

# Planifier les opérations date/heure
schedule_datetime_operation() {
    local operation="$1"
    local target_datetime="$2"
    local schedule_time="$3"
    local policy="${4:-business_hours}"
    
    echo "=== Opération Date/Heure Planifiée ==="
    echo "Opération : $operation"
    echo "Date/Heure Cible : $target_datetime"
    echo "Heure Planifiée : $schedule_time"
    echo "Politique : $policy"
    echo ""
    
    # Créer fichier d'opération planifiée
    local schedule_file="$POLICIES_DIR/scheduled_$(date +%Y%m%d_%H%M%S).sh"
    
    cat > "$schedule_file" << EOF
#!/bin/bash
# Opération Date/Heure Planifiée Roundfleet
# Généré : $(date)
# Opération : $operation
# Cible : $target_datetime
# Politique : $policy

# Exécuter l'opération planifiée
case "$operation" in
    "set_datetime")
        $0 set "$target_datetime" roundfleet "$policy" true
        ;;
    "sync_time")
        sudo systemsetup -setusingnetworktime on
        ;;
    "backup_datetime")
        $0 backup
        ;;
    *)
        echo "Opération inconnue : $operation"
        exit 1
        ;;
esac
EOF
    
    chmod +x "$schedule_file"
    
    # Planifier avec commande at (si disponible)
    if command -v at &>/dev/null; then
        echo "$schedule_file" | at "$schedule_time" 2>/dev/null
        
        if [[ $? -eq 0 ]]; then
            echo "✅ Opération planifiée avec succès pour $schedule_time"
            log_operation "INFO" "Opération planifiée : $operation à $schedule_time"
            return 0
        else
            echo "❌ Échec de planification de l'opération"
            log_operation "ERROR" "Échec planification opération : $operation"
            return 1
        fi
    else
        echo "⚠️  Commande 'at' non disponible pour planification"
        echo "Fichier de planification créé : $schedule_file"
        echo "Exécutez manuellement ou intégrez avec votre système de planification"
        return 1
    fi
}

# Surveiller l'intégrité date/heure
monitor_datetime_integrity() {
    local check_type="${1:-basic}"
    local admin_user=$(whoami)
    
    echo "=== Surveillance Intégrité Date/Heure ==="
    echo "Type de Vérification : $check_type"
    echo "Surveillant : $admin_user"
    echo ""
    
    local integrity_status="HEALTHY"
    local issues=()
    
    # Vérifier horloge système vs heure réseau
    if command -v ntpdate &>/dev/null; then
        echo "Vérification synchronisation horaire..."
        
        local ntp_time=$(ntpdate -q pool.ntp.org 2>/dev/null | tail -1 | grep -o "offset [+-][0-9.]*" | awk '{print $2}')
        
        if [[ -n "$ntp_time" ]]; then
            local offset_abs=${ntp_time#-}
            
            echo "Décalage NTP : ${ntp_time}s"
            
            if (( $(echo "$offset_abs > 30" | bc -l) )); then
                integrity_status="WARNING"
                issues+=("Grand décalage NTP : ${ntp_time}s")
            else
                echo "✅ Synchronisation horaire dans plage acceptable"
            fi
        else
            integrity_status="WARNING"
            issues+=("Impossible de vérifier synchronisation NTP")
        fi
    fi
    
    # Vérifier les changements de temps récents importants
    if [[ -f "$AUDIT_LOG" ]]; then
        echo ""
        echo "Vérification changements de temps récents..."
        
        local recent_changes=$(grep "DATETIME_CHANGED" "$AUDIT_LOG" | tail -5)
        
        if [[ -n "$recent_changes" ]]; then
            echo "Changements date/heure récents trouvés :"
            echo "$recent_changes" | while read -r line; do
                echo "  $(echo "$line" | cut -d'|' -f2,6)"
            done
        else
            echo "✅ Aucun changement date/heure récent détecté"
        fi
    fi
    
    # Vérifications avancées
    if [[ "$check_type" == "comprehensive" ]]; then
        echo ""
        echo "Exécution vérifications intégrité complètes..."
        
        # Vérifier logs système pour erreurs liées au temps
        local time_errors=$(log show --predicate 'subsystem == "com.apple.time"' --last 1h 2>/dev/null | grep -i error | wc -l)
        
        if [[ $time_errors -gt 0 ]]; then
            integrity_status="WARNING"
            issues+=("Erreurs temps système détectées : $time_errors")
        fi
        
        # Vérifier les incompatibilités de fuseau horaire
        local system_tz=$(systemsetup -gettimezone 2>/dev/null | awk -F': ' '{print $2}')
        local env_tz="$TZ"
        
        if [[ -n "$env_tz" && "$env_tz" != "$system_tz" ]]; then
            integrity_status="WARNING"
            issues+=("Incompatibilité fuseau horaire : système=$system_tz, env=$env_tz")
        fi
    fi
    
    # Générer rapport d'intégrité
    echo ""
    echo "=== Rapport Intégrité Date/Heure ==="
    echo "État Global : $integrity_status"
    echo "Horodatage : $(date)"
    
    if [[ ${#issues[@]} -gt 0 ]]; then
        echo "Problèmes Trouvés :"
        printf '  - %s\n' "${issues[@]}"
    else
        echo "✅ Tous les systèmes date/heure fonctionnent normalement"
    fi
    
    # Enregistrer les résultats de surveillance
    log_operation "INFO" "Vérification intégrité date/heure terminée : $integrity_status (${#issues[@]} problèmes)"
    log_security_event "DATETIME_INTEGRITY_CHECK" "status=$integrity_status,issues=${#issues[@]}" "INFO"
    
    # Retourner le code de sortie approprié
    case "$integrity_status" in
        "HEALTHY") return 0 ;;
        "WARNING") return 1 ;;
        "CRITICAL") return 2 ;;
        *) return 3 ;;
    esac
}

# Générer rapport de gestion date/heure
generate_datetime_report() {
    local report_type="${1:-summary}"
    local admin_user=$(whoami)
    local report_file="/var/reports/datetime_report_$(date +%Y%m%d_%H%M%S).txt"
    
    mkdir -p "$(dirname "$report_file")"
    
    log_security_event "REPORT_GENERATION" "type=$report_type" "INFO"
    
    {
        echo "Rapport Gestion Date/Heure Roundfleet"
        echo "=================================="
        echo "Type de Rapport : $report_type"
        echo "Généré : $(date)"
        echo "Généré Par : $admin_user"
        echo "Nom d'hôte : $(hostname)"
        echo ""
        
        case "$report_type" in
            "summary")
                echo "== Résumé Date/Heure =="
                get_current_datetime "detailed"
                
                echo "Formats Disponibles :"
                for format in "${!DATE_FORMATS[@]}"; do
                    echo "  $format: ${DATE_FORMATS[$format]}"
                done
                ;;
            "compliance")
                echo "== Évaluation Conformité =="
                
                echo "Standards de Conformité :"
                for standard in "${!COMPLIANCE_REQUIREMENTS[@]}"; do
                    echo "  $standard: ${COMPLIANCE_REQUIREMENTS[$standard]}"
                done
                
                echo ""
                echo "Événements d'Audit Récents :"
                if [[ -f "$AUDIT_LOG" ]]; then
                    tail -10 "$AUDIT_LOG"
                else
                    echo "Aucun log d'audit disponible"
                fi
                ;;
            "audit")
                echo "== Information d'Audit =="
                if [[ -f "$AUDIT_LOG" ]]; then
                    echo "Piste d'audit complète :"
                    cat "$AUDIT_LOG"
                else
                    echo "Aucun log d'audit disponible"
                fi
                ;;
        esac
        
        echo ""
        echo "== Informations Système =="
        echo "Uptime : $(uptime)"
        echo "Charge Moyenne : $(uptime | awk -F'load average:' '{print $2}')"
        
    } > "$report_file"
    
    echo "Rapport date/heure généré : $report_file"
    log_operation "INFO" "Rapport date/heure généré : $report_file"
}

# Sauvegarder et restaurer paramètres date/heure
backup_datetime_settings() {
    local backup_type="${1:-full}"
    
    echo "=== Sauvegarde Paramètres Date/Heure ==="
    echo "Type de Sauvegarde : $backup_type"
    echo ""
    
    local backup_file="$BACKUP_DIR/datetime_settings_$(date +%Y%m%d_%H%M%S).backup"
    
    {
        echo "# Sauvegarde Paramètres Date/Heure Roundfleet"
        echo "BACKUP_DATE=$(date)"
        echo "BACKUP_TYPE=$backup_type"
        echo ""
        echo "# Paramètres Actuels"
        echo "CURRENT_DATETIME=$(date '+%Y-%m-%d %H:%M:%S %Z')"
        echo "CURRENT_UTC=$(date -u '+%Y-%m-%d %H:%M:%S UTC')"
        echo "CURRENT_UNIX=$(date +%s)"
        echo "CURRENT_TIMEZONE=$(systemsetup -gettimezone 2>/dev/null | awk -F': ' '{print $2}')"
        echo "NETWORK_TIME=$(systemsetup -getusingnetworktime 2>/dev/null | awk -F': ' '{print $2}')"
        echo "TIME_SERVER=$(systemsetup -getnetworktimeserver 2>/dev/null | awk -F': ' '{print $2}')"
        echo ""
        echo "# Informations Système"
        echo "HOSTNAME=$(hostname)"
        echo "UPTIME=$(uptime)"
        echo "BACKUP_BY=$(whoami)"
    } > "$backup_file"
    
    echo "✅ Sauvegarde créée : $backup_file"
    log_operation "INFO" "Paramètres date/heure sauvegardés : $backup_file"
}

# Fonction principale de gestion date/heure
main() {
    local action="${1:-help}"
    
    case "$action" in
        "status"|"current")
            local format="${2:-all}"
            get_current_datetime "$format"
            ;;
        "set")
            local datetime_input="$2"
            local format_type="${3:-roundfleet}"
            local policy="${4:-business_hours}"
            local force="$5"
            
            if [[ -z "$datetime_input" ]]; then
                echo "Usage : $0 set <datetime> [format] [policy] [force]"
                echo "Exemple : $0 set 120614302023.00 roundfleet business_hours"
                return 1
            fi
            
            set_enterprise_datetime "$datetime_input" "$format_type" "$policy" "$force"
            ;;
        "validate")
            local datetime_input="$2"
            local format_type="${3:-roundfleet}"
            
            if [[ -z "$datetime_input" ]]; then
                echo "Usage : $0 validate <datetime> [format]"
                return 1
            fi
            
            validate_datetime_format "$datetime_input" "$format_type"
            ;;
        "convert")
            local datetime_input="$2"
            local from_format="$3"
            local to_format="$4"
            
            if [[ -z "$datetime_input" || -z "$from_format" || -z "$to_format" ]]; then
                echo "Usage : $0 convert <datetime> <from_format> <to_format>"
                echo "Formats disponibles : roundfleet, iso8601, unix, readable"
                return 1
            fi
            
            convert_datetime_format "$datetime_input" "$from_format" "$to_format"
            ;;
        "schedule")
            local operation="$2"
            local target_datetime="$3"
            local schedule_time="$4"
            local policy="${5:-business_hours}"
            
            if [[ -z "$operation" || -z "$target_datetime" || -z "$schedule_time" ]]; then
                echo "Usage : $0 schedule <operation> <target_datetime> <schedule_time> [policy]"
                echo "Opérations : set_datetime, sync_time, backup_datetime"
                return 1
            fi
            
            schedule_datetime_operation "$operation" "$target_datetime" "$schedule_time" "$policy"
            ;;
        "monitor")
            local check_type="${2:-basic}"
            
            monitor_datetime_integrity "$check_type"
            ;;
        "backup")
            local backup_type="${2:-full}"
            
            backup_datetime_settings "$backup_type"
            ;;
        "report")
            local report_type="${2:-summary}"
            
            generate_datetime_report "$report_type"
            ;;
        "help"|*)
            echo "$SCRIPT_NAME v$VERSION"
            echo "Gestion Entreprise Date et Heure"
            echo ""
            echo "Usage : $0 <action> [options]"
            echo ""
            echo "Actions :"
            echo "  status [format]                         - Afficher informations date/heure actuelles"
            echo "  set <datetime> [format] [policy] [force] - Définir date/heure avec validation"
            echo "  validate <datetime> [format]            - Valider format date/heure"
            echo "  convert <datetime> <from> <to>          - Convertir entre formats"
            echo "  schedule <op> <datetime> <time> [policy] - Planifier opérations date/heure"
            echo "  monitor [type]                          - Surveiller intégrité date/heure"
            echo "  backup [type]                           - Sauvegarder paramètres date/heure"
            echo "  report [type]                           - Générer rapports date/heure"
            echo "  help                                    - Afficher ce message d'aide"
            echo ""
            echo "Formats Date/Heure :"
            for format in "${!DATE_FORMATS[@]}"; do
                echo "  $format: ${DATE_FORMATS[$format]}"
            done
            echo ""
            echo "Politiques de Planification :"
            for policy in "${!SCHEDULING_POLICIES[@]}"; do
                echo "  $policy: ${SCHEDULING_POLICIES[$policy]}"
            done
            echo ""
            echo "Types de Surveillance :"
            echo "  basic       - Vérifications intégrité de base"
            echo "  comprehensive - Surveillance étendue et validation"
            echo ""
            echo "Types de Rapport :"
            echo "  summary     - Aperçu date/heure (défaut)"
            echo "  compliance  - Évaluation conformité"
            echo "  audit       - Piste d'audit complète"
            echo ""
            echo "Exemples :"
            echo "  $0 set 120614302023.00                 - Définir date/heure en format Roundfleet"
            echo "  $0 set '2023-12-06T14:30:00' iso8601   - Définir avec format ISO 8601"
            echo "  $0 convert 120614302023.00 roundfleet iso8601 - Convertir formats"
            echo "  $0 schedule set_datetime 010108002024.00 '09:00 tomorrow' - Planifier opération"
            echo "  $0 monitor comprehensive               - Vérification intégrité complète"
            echo ""
            echo "Fonctionnalités :"
            echo "  • Gestion date/heure niveau entreprise"
            echo "  • Support et conversion formats multiples"
            echo "  • Application heures d'ouverture et politiques"
            echo "  • Validation complète et vérifications sécurité"
            echo "  • Journalisation audit et suivi conformité"
            echo "  • Opérations planifiées et automation"
            echo "  • Surveillance temps réel et vérifications intégrité"
            ;;
    esac
}

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

Commandes de Référence Rapide

Opérations Date/Heure de Base

# Vérifier statut date/heure actuel
./datetime_manager.sh status

# Définir date/heure avec format Roundfleet (6 déc 2023 14h30)
./datetime_manager.sh set 120614302023.00

# Définir avec format ISO 8601
./datetime_manager.sh set "2023-12-06T14:30:00" iso8601

# Valider format date/heure avant définition
./datetime_manager.sh validate 120614302023.00 roundfleet

Conversion de Format

# Convertir Roundfleet vers ISO 8601
./datetime_manager.sh convert 120614302023.00 roundfleet iso8601

# Convertir ISO 8601 vers format lisible
./datetime_manager.sh convert "2023-12-06T14:30:00" iso8601 readable

# Convertir vers timestamp Unix
./datetime_manager.sh convert 120614302023.00 roundfleet unix

Opérations Entreprise

# Définir avec application politique heures d'ouverture
./datetime_manager.sh set 120614302023.00 roundfleet business_hours

# Forcer définition en dehors heures d'ouverture
./datetime_manager.sh set 120614302023.00 roundfleet business_hours true

# Planifier opération date/heure future
./datetime_manager.sh schedule set_datetime 010108002024.00 "09:00 tomorrow"

Surveillance et Conformité

# Surveillance intégrité de base
./datetime_manager.sh monitor basic

# Surveillance complète
./datetime_manager.sh monitor comprehensive

# Générer rapport conformité
./datetime_manager.sh report compliance

# Sauvegarder paramètres actuels
./datetime_manager.sh backup full

Exemples d'Intégration

Intégration JAMF Pro

#!/bin/bash

# Script JAMF Pro pour gestion date/heure
# Paramètres : $4 = target_datetime, $5 = format, $6 = policy, $7 = force

TARGET_DATETIME="$4"
FORMAT="${5:-roundfleet}"
POLICY="${6:-business_hours}"
FORCE="$7"

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

# Définir date/heure avec contrôles entreprise
if [[ -n "$TARGET_DATETIME" ]]; then
    /usr/local/bin/roundfleet_datetime_manager.sh set \
        "$TARGET_DATETIME" "$FORMAT" "$POLICY" "$FORCE"
    
    # Rapporter statut à JAMF
    if [[ $? -eq 0 ]]; then
        echo "Date/heure définie avec succès : $TARGET_DATETIME"
        exit 0
    else
        echo "Définition date/heure échouée : $TARGET_DATETIME"
        exit 1
    fi
else
    echo "Aucune date/heure cible fournie"
    exit 1
fi

Meilleures Pratiques

Valider toutes entrées date/heure avant application des changements
Utiliser politiques heures d'ouverture pour empêcher changements non autorisés
Implémenter sauvegarde et restauration pour changements temps critiques
Surveiller dérive temporelle en continu avec alertes automatisées
Maintenir logs d'audit complets pour conformité
Tester conversions formats avant déploiement production
Coordonner avec équipes réseau pour synchronisation temporelle
Documenter toutes opérations planifiées pour conscience opérationnelle

Ce système de gestion date et heure entreprise fournit un contrôle date/heure complet avec validation, planification, suivi de conformité et capacités d'automation de niveau entreprise pour une gestion temporelle Roundfleet efficace.

Guide

Avis important