Afficher l'heure de dernière ouverture des applications et fichiers sur macOS

Ce guide complet démontre comment suivre quand les applications et fichiers ont été accédés pour la dernière fois sur les appareils macOS, fournissant des informations essentielles pour la gestion du parc Mac et la surveillance d'utilisation.

Aperçu

La surveillance des modèles d'accès aux applications et fichiers est cruciale pour :

Optimisation des performances : Identifier les applications gourmandes en ressources
Gestion des licences : Suivre l'utilisation des logiciels pour la conformité
Audit de sécurité : Surveiller l'accès aux fichiers pour la conformité sécuritaire
Optimisation du stockage : Trouver les applications et fichiers inutilisés
Analyse comportementale : Comprendre les habitudes de travail et la productivité

Script de base pour l'heure de dernière ouverture

Vérification simple d'application/fichier

Créez un script de base pour vérifier quand une application ou un fichier a été ouvert pour la dernière fois :

#!/bin/bash

# Script de base pour obtenir l'heure de dernière ouverture d'une app ou fichier
# Usage: ./last_opened.sh "/chemin/vers/app/ou/fichier"

if [ $# -eq 0 ]; then
    echo "Usage: $0 <chemin_fichier>"
    echo "Exemple: $0 '/Applications/Safari.app'"
    exit 1
fi

file_path="$1"

# Vérifier si le fichier existe
if [ ! -e "$file_path" ]; then
    echo "Erreur: Fichier ou application non trouvé: $file_path"
    exit 1
fi

# Obtenir l'heure de dernière ouverture avec mdls
datetime=$(mdls "$file_path" -name kMDItemLastUsedDate | awk '{print $3,$4}')

if [ "$datetime" = "(null)" ]; then
    echo "'$file_path' n'a jamais été ouvert ou l'heure de dernière ouverture n'est pas disponible"
    exit 0
fi

echo "'$file_path' a été ouvert pour la dernière fois le (UTC):"
echo "$datetime"
echo "'$file_path' a été ouvert pour la dernière fois le (Heure locale):"
echo "$(date -jf "%Y-%m-%d %H:%M:%S %z" "$datetime +0000" +"%Y-%m-%d %H:%M:%S")"

Script amélioré avec gestion d'erreurs

#!/bin/bash

# Script amélioré avec gestion d'erreurs complète et formatage
# Usage: ./enhanced_last_opened.sh "/chemin/vers/app/ou/fichier"

check_last_opened() {
    local file_path="$1"
    local file_name=$(basename "$file_path")
    
    # Valider l'entrée
    if [ -z "$file_path" ]; then
        echo "Erreur: Aucun chemin de fichier fourni"
        return 1
    fi
    
    # Vérifier si le fichier existe
    if [ ! -e "$file_path" ]; then
        echo "Erreur: Fichier non trouvé: $file_path"
        return 1
    fi
    
    # Obtenir les métadonnées
    local datetime=$(mdls "$file_path" -name kMDItemLastUsedDate 2>/dev/null | awk '{print $3,$4}')
    local creation_date=$(mdls "$file_path" -name kMDItemContentCreationDate 2>/dev/null | awk '{print $3,$4}')
    local modification_date=$(mdls "$file_path" -name kMDItemContentModificationDate 2>/dev/null | awk '{print $3,$4}')
    
    echo "=== Informations du fichier ==="
    echo "Fichier: $file_name"
    echo "Chemin: $file_path"
    echo ""
    
    # Heure de dernière ouverture
    if [ "$datetime" = "(null)" ] || [ -z "$datetime" ]; then
        echo "Dernière ouverture: Jamais ouvert ou information non disponible"
    else
        echo "Dernière ouverture (UTC): $datetime"
        local local_time=$(date -jf "%Y-%m-%d %H:%M:%S %z" "$datetime +0000" +"%Y-%m-%d %H:%M:%S" 2>/dev/null)
        if [ $? -eq 0 ]; then
            echo "Dernière ouverture (Locale): $local_time"
        else
            echo "Dernière ouverture (Locale): Impossible de convertir l'heure"
        fi
    fi
    
    # Date de création
    if [ "$creation_date" != "(null)" ] && [ -n "$creation_date" ]; then
        echo "Créé (UTC): $creation_date"
    fi
    
    # Date de modification
    if [ "$modification_date" != "(null)" ] && [ -n "$modification_date" ]; then
        echo "Modifié (UTC): $modification_date"
    fi
    
    echo "=============================="
    echo ""
}

# Exécution principale
if [ $# -eq 0 ]; then
    echo "Usage: $0 <chemin_fichier>"
    echo "Exemple: $0 '/Applications/Safari.app'"
    exit 1
fi

check_last_opened "$1"

Surveillance avancée des applications

Scanner d'applications en lot

#!/bin/bash

# Scanner d'applications en lot avec rapport détaillé
# Usage: ./bulk_app_scanner.sh

scan_applications() {
    local output_file="rapport_usage_apps_$(date +%Y%m%d_%H%M%S).txt"
    
    echo "Rapport d'utilisation des applications Roundfleet" > "$output_file"
    echo "Généré: $(date)" >> "$output_file"
    echo "Appareil: $(scutil --get ComputerName)" >> "$output_file"
    echo "Utilisateur: $(whoami)" >> "$output_file"
    echo "=======================================" >> "$output_file"
    echo "" >> "$output_file"
    
    # Scanner le dossier Applications
    echo "Scan de /Applications..."
    find /Applications -maxdepth 2 -name "*.app" -type d | while read app_path; do
        app_name=$(basename "$app_path" .app)
        
        # Obtenir l'heure de dernière ouverture
        datetime=$(mdls "$app_path" -name kMDItemLastUsedDate 2>/dev/null | awk '{print $3,$4}')
        
        if [ "$datetime" = "(null)" ] || [ -z "$datetime" ]; then
            last_opened="Jamais ouvert"
        else
            last_opened=$(date -jf "%Y-%m-%d %H:%M:%S %z" "$datetime +0000" +"%Y-%m-%d %H:%M:%S" 2>/dev/null)
            if [ $? -ne 0 ]; then
                last_opened="$datetime (UTC)"
            fi
        fi
        
        # Obtenir la version de l'app
        app_version=$(mdls "$app_path" -name kMDItemVersion 2>/dev/null | awk -F'"' '{print $2}')
        if [ "$app_version" = "(null)" ] || [ -z "$app_version" ]; then
            app_version="Inconnue"
        fi
        
        # Obtenir la taille de l'app
        app_size=$(du -sh "$app_path" 2>/dev/null | cut -f1)
        if [ -z "$app_size" ]; then
            app_size="Inconnue"
        fi
        
        echo "App: $app_name" >> "$output_file"
        echo "  Version: $app_version" >> "$output_file"
        echo "  Taille: $app_size" >> "$output_file"
        echo "  Dernière ouverture: $last_opened" >> "$output_file"
        echo "  Chemin: $app_path" >> "$output_file"
        echo "" >> "$output_file"
        
        # Indicateur de progression
        echo "Traité: $app_name"
    done
    
    echo "Rapport sauvegardé dans: $output_file"
}

# Exécuter le scan
scan_applications

Filtre des applications récemment utilisées

#!/bin/bash

# Filtrer les applications par utilisation récente
# Usage: ./recent_apps.sh [jours]

filter_recent_apps() {
    local days_threshold=${1:-7}  # Par défaut 7 jours
    local cutoff_date=$(date -v -${days_threshold}d +%Y-%m-%d)
    
    echo "Applications utilisées dans les $days_threshold derniers jours:"
    echo "Date limite: $cutoff_date"
    echo "=================================="
    
    find /Applications -maxdepth 2 -name "*.app" -type d | while read app_path; do
        app_name=$(basename "$app_path" .app)
        
        # Obtenir l'heure de dernière ouverture
        datetime=$(mdls "$app_path" -name kMDItemLastUsedDate 2>/dev/null | awk '{print $3,$4}')
        
        if [ "$datetime" != "(null)" ] && [ -n "$datetime" ]; then
            # Convertir en format comparable
            app_date=$(echo "$datetime" | cut -d' ' -f1)
            
            # Comparer les dates
            if [[ "$app_date" > "$cutoff_date" ]]; then
                local_time=$(date -jf "%Y-%m-%d %H:%M:%S %z" "$datetime +0000" +"%Y-%m-%d %H:%M:%S" 2>/dev/null)
                if [ $? -eq 0 ]; then
                    echo "$app_name - Dernière utilisation: $local_time"
                else
                    echo "$app_name - Dernière utilisation: $datetime (UTC)"
                fi
            fi
        fi
    done | sort
}

# Exécution principale
if [ $# -gt 1 ]; then
    echo "Usage: $0 [jours]"
    echo "Exemple: $0 30  # Afficher les apps utilisées dans les 30 derniers jours"
    exit 1
fi

filter_recent_apps "$1"

Surveillance des fichiers d'entreprise

Suivi d'accès aux documents

#!/bin/bash

# Suivre les modèles d'accès aux documents pour les types de fichiers courants
# Usage: ./document_tracker.sh "/chemin/vers/documents"

track_document_access() {
    local base_path=${1:-"$HOME/Documents"}
    local output_file="acces_documents_$(date +%Y%m%d_%H%M%S).json"
    
    echo "Suivi de l'accès aux documents dans: $base_path"
    
    # Créer le rapport JSON
    cat > "$output_file" << EOF
{
  "info_rapport": {
    "genere": "$(date -u +%Y-%m-%dT%H:%M:%SZ)",
    "appareil": "$(scutil --get ComputerName)",
    "utilisateur": "$(whoami)",
    "chemin_scan": "$base_path",
    "version_roundfleet": "1.0"
  },
  "documents": [
EOF
    
    local first_entry=true
    
    # Types de documents courants
    local file_types=("*.pdf" "*.doc" "*.docx" "*.xls" "*.xlsx" "*.ppt" "*.pptx" "*.txt" "*.rtf" "*.pages" "*.numbers" "*.keynote")
    
    for pattern in "${file_types[@]}"; do
        find "$base_path" -name "$pattern" -type f 2>/dev/null | while read file_path; do
            # Obtenir les métadonnées du fichier
            local filename=$(basename "$file_path")
            local extension="${filename##*.}"
            local size=$(stat -f%z "$file_path" 2>/dev/null || echo "0")
            
            # Obtenir les horodatages
            local last_used=$(mdls "$file_path" -name kMDItemLastUsedDate 2>/dev/null | awk '{print $3,$4}')
            local created=$(mdls "$file_path" -name kMDItemContentCreationDate 2>/dev/null | awk '{print $3,$4}')
            local modified=$(mdls "$file_path" -name kMDItemContentModificationDate 2>/dev/null | awk '{print $3,$4}')
            
            # Formater pour JSON
            if [ "$last_used" = "(null)" ] || [ -z "$last_used" ]; then
                last_used="null"
            else
                last_used="\"$last_used\""
            fi
            
            if [ "$created" = "(null)" ] || [ -z "$created" ]; then
                created="null"
            else
                created="\"$created\""
            fi
            
            if [ "$modified" = "(null)" ] || [ -z "$modified" ]; then
                modified="null"
            else
                modified="\"$modified\""
            fi
            
            # Ajouter une virgule si ce n'est pas la première entrée
            if [ "$first_entry" = false ]; then
                echo "," >> "$output_file"
            fi
            first_entry=false
            
            # Ajouter l'entrée du document
            cat >> "$output_file" << EOF
    {
      "nom_fichier": "$filename",
      "extension": "$extension",
      "taille_octets": $size,
      "chemin": "$file_path",
      "derniere_utilisation": $last_used,
      "cree": $created,
      "modifie": $modified
    }EOF
        done
    done
    
    # Fermer le JSON
    cat >> "$output_file" << EOF

  ]
}
EOF
    
    echo "Rapport d'accès aux documents sauvegardé dans: $output_file"
}

# Exécuter le suivi
track_document_access "$1"

Moniteur d'accès aux fichiers multi-utilisateurs

#!/bin/bash

# Surveiller l'accès aux fichiers sur plusieurs comptes utilisateurs
# Usage: ./multi_user_monitor.sh

monitor_multi_user_access() {
    local report_file="acces_multi_utilisateurs_$(date +%Y%m%d_%H%M%S).txt"
    
    echo "Rapport d'accès aux fichiers multi-utilisateurs Roundfleet" > "$report_file"
    echo "Généré: $(date)" >> "$report_file"
    echo "Appareil: $(scutil --get ComputerName)" >> "$report_file"
    echo "=========================================" >> "$report_file"
    echo "" >> "$report_file"
    
    # Obtenir tous les répertoires home des utilisateurs
    local users=($(dscl . -list /Users | grep -v "^_" | grep -v "daemon" | grep -v "nobody" | grep -v "root"))
    
    for user in "${users[@]}"; do
        local user_home=$(dscl . -read /Users/$user NFSHomeDirectory | awk '{print $2}')
        
        if [ -d "$user_home" ]; then
            echo "Utilisateur: $user ($user_home)" >> "$report_file"
            echo "--------------------------------" >> "$report_file"
            
            # Vérifier le dossier Documents
            if [ -d "$user_home/Documents" ]; then
                echo "Documents récemment accédés:" >> "$report_file"
                find "$user_home/Documents" -type f -name "*.pdf" -o -name "*.doc*" -o -name "*.xls*" -o -name "*.ppt*" 2>/dev/null | head -10 | while read file_path; do
                    local filename=$(basename "$file_path")
                    local last_used=$(mdls "$file_path" -name kMDItemLastUsedDate 2>/dev/null | awk '{print $3,$4}')
                    
                    if [ "$last_used" != "(null)" ] && [ -n "$last_used" ]; then
                        echo "  - $filename (Dernière utilisation: $last_used)" >> "$report_file"
                    fi
                done
            fi
            
            # Vérifier le dossier Téléchargements
            if [ -d "$user_home/Downloads" ]; then
                echo "Téléchargements récents:" >> "$report_file"
                find "$user_home/Downloads" -type f -mtime -7 2>/dev/null | head -5 | while read file_path; do
                    local filename=$(basename "$file_path")
                    local mod_time=$(stat -f "%Sm" -t "%Y-%m-%d %H:%M:%S" "$file_path" 2>/dev/null)
                    echo "  - $filename (Téléchargé: $mod_time)" >> "$report_file"
                done
            fi
            
            echo "" >> "$report_file"
        fi
    done
    
    echo "Rapport d'accès multi-utilisateurs sauvegardé dans: $report_file"
}

# Exécuter la surveillance
monitor_multi_user_access

Gestion distante du parc

Collecteur d'utilisation centralisé

#!/bin/bash

# Collecter les données d'utilisation pour la gestion distante du parc
# Usage: ./fleet_collector.sh

collect_fleet_data() {
    local device_id=$(system_profiler SPHardwareDataType | grep "Hardware UUID" | awk '{print $3}')
    local computer_name=$(scutil --get ComputerName)
    local timestamp=$(date -u +%Y-%m-%dT%H:%M:%SZ)
    
    # Créer un rapport complet
    local report_file="utilisation_parc_${computer_name}_$(date +%Y%m%d_%H%M%S).json"
    
    cat > "$report_file" << EOF
{
  "info_appareil": {
    "id_appareil": "$device_id",
    "nom_ordinateur": "$computer_name",
    "horodatage": "$timestamp",
    "version_os": "$(sw_vers -productVersion)",
    "duree_fonctionnement": "$(uptime | awk '{print $3,$4}' | sed 's/,//')"
  },
  "utilisation_applications": [
EOF
    
    # Collecter les principales applications
    local first_app=true
    find /Applications -maxdepth 2 -name "*.app" -type d | head -20 | while read app_path; do
        local app_name=$(basename "$app_path" .app)
        local last_used=$(mdls "$app_path" -name kMDItemLastUsedDate 2>/dev/null | awk '{print $3,$4}')
        local version=$(mdls "$app_path" -name kMDItemVersion 2>/dev/null | awk -F'"' '{print $2}')
        
        if [ "$first_app" = false ]; then
            echo "," >> "$report_file"
        fi
        first_app=false
        
        # Formater les valeurs pour JSON
        if [ "$last_used" = "(null)" ] || [ -z "$last_used" ]; then
            last_used="null"
        else
            last_used="\"$last_used\""
        fi
        
        if [ "$version" = "(null)" ] || [ -z "$version" ]; then
            version="null"
        else
            version="\"$version\""
        fi
        
        cat >> "$report_file" << EOF
    {
      "nom": "$app_name",
      "version": $version,
      "derniere_utilisation": $last_used,
      "chemin": "$app_path"
    }EOF
    done
    
    cat >> "$report_file" << EOF

  ],
  "stats_systeme": {
    "total_applications": $(find /Applications -maxdepth 2 -name "*.app" -type d | wc -l | tr -d ' '),
    "utilisation_disque": "$(df -h / | tail -1 | awk '{print $5}')",
    "utilisation_memoire": "$(vm_stat | grep "Pages active" | awk '{print $3}' | sed 's/\.//')"
  }
}
EOF
    
    echo "Données du parc collectées dans: $report_file"
    
    # Optionnel: Envoyer au serveur central
    # curl -X POST -H "Content-Type: application/json" -d @"$report_file" "https://votre-serveur-parc.com/api/utilisation"
}

# Exécuter la collecte
collect_fleet_data

Surveillance automatisée de l'utilisation

#!/bin/bash

# Surveillance automatisée de l'utilisation avec alertes
# Usage: ./usage_monitor.sh

setup_monitoring() {
    local log_file="/var/log/roundfleet_usage.log"
    local config_file="/etc/roundfleet/usage_config.conf"
    
    # Créer la configuration si elle n'existe pas
    if [ ! -f "$config_file" ]; then
        sudo mkdir -p /etc/roundfleet
        sudo cat > "$config_file" << EOF
# Configuration de surveillance d'utilisation Roundfleet
MONITOR_INTERVAL=3600  # Vérifier toutes les heures
ALERT_THRESHOLD=30     # Alerter si app inutilisée pendant 30 jours
REPORT_INTERVAL=86400  # Générer rapport quotidien
CLEANUP_THRESHOLD=90   # Marquer les apps inutilisées pendant 90 jours
EOF
    fi
    
    # Charger la configuration
    source "$config_file"
    
    # Créer le script de surveillance
    cat > "/tmp/roundfleet_monitor.sh" << EOF
#!/bin/bash

# Moniteur d'utilisation Roundfleet
log_usage() {
    local timestamp=\$(date -u +%Y-%m-%dT%H:%M:%SZ)
    local computer_name=\$(scutil --get ComputerName)
    
    echo "[\$timestamp] Début de vérification d'utilisation sur \$computer_name" >> "$log_file"
    
    # Vérifier les applications inutilisées
    find /Applications -maxdepth 2 -name "*.app" -type d | while read app_path; do
        local app_name=\$(basename "\$app_path" .app)
        local last_used=\$(mdls "\$app_path" -name kMDItemLastUsedDate 2>/dev/null | awk '{print \$3,\$4}')
        
        if [ "\$last_used" != "(null)" ] && [ -n "\$last_used" ]; then
            local days_since=\$(( (\$(date +%s) - \$(date -jf "%Y-%m-%d %H:%M:%S %z" "\$last_used +0000" +%s)) / 86400 ))
            
            if [ \$days_since -gt $ALERT_THRESHOLD ]; then
                echo "[\$timestamp] ALERTE: \$app_name inutilisée pendant \$days_since jours" >> "$log_file"
            fi
            
            if [ \$days_since -gt $CLEANUP_THRESHOLD ]; then
                echo "[\$timestamp] NETTOYAGE: \$app_name marquée pour suppression (\$days_since jours)" >> "$log_file"
            fi
        fi
    done
    
    echo "[\$timestamp] Vérification d'utilisation terminée" >> "$log_file"
}

# Exécuter la surveillance
log_usage
EOF
    
    chmod +x "/tmp/roundfleet_monitor.sh"
    
    # Configurer launchd pour la surveillance automatisée
    cat > "/tmp/com.roundfleet.usage.monitor.plist" << EOF
<?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>Label</key>
    <string>com.roundfleet.usage.monitor</string>
    <key>ProgramArguments</key>
    <array>
        <string>/tmp/roundfleet_monitor.sh</string>
    </array>
    <key>StartInterval</key>
    <integer>$MONITOR_INTERVAL</integer>
    <key>RunAtLoad</key>
    <true/>
</dict>
</plist>
EOF
    
    echo "Configuration de surveillance terminée. Utilisez 'sudo launchctl load /tmp/com.roundfleet.usage.monitor.plist' pour démarrer."
}

# Exécuter la configuration
setup_monitoring

Meilleures pratiques pour la gestion du parc Mac

1. Optimisation des performances

Surveiller les applications gourmandes en ressources
Suivre les applications qui n'ont pas été utilisées récemment
Identifier les opportunités de nettoyage d'applications
Optimiser les performances système grâce aux informations d'utilisation

2. Sécurité et conformité

Suivre l'accès aux fichiers pour les audits de sécurité
Surveiller la conformité de gestion des documents
Identifier les modèles d'accès non autorisés aux fichiers
Maintenir les journaux d'accès pour les exigences de conformité

3. Gestion des licences

Surveiller l'utilisation des logiciels pour l'optimisation des licences
Suivre l'efficacité du déploiement d'applications
Identifier les licences inutilisées pour des économies de coût
Assurer la conformité aux accords de licence logicielle

4. Expérience utilisateur

Comprendre les modèles de comportement des utilisateurs
Optimiser les stratégies de déploiement d'applications
Améliorer la productivité des utilisateurs grâce aux informations d'utilisation
Personnaliser les configurations d'appareils basées sur l'utilisation

5. Maintenance et nettoyage

Identifier les applications inutilisées pour la suppression
Nettoyer les fichiers temporaires et les caches
Optimiser l'utilisation du stockage
Programmer la maintenance régulière basée sur les modèles d'utilisation

Dépannage des problèmes courants

1. Erreurs de permissions

# Corriger les problèmes de permissions
sudo chown -R $(whoami) /Users/$(whoami)/Documents
sudo chmod -R 755 /Users/$(whoami)/Documents

2. Métadonnées non disponibles

# Vérifier si l'indexation Spotlight est activée
mdutil -s /
# Re-indexer si nécessaire
sudo mdutil -i on /
sudo mdutil -E /

3. Problèmes d'exécution de script

# Rendre le script exécutable
chmod +x nom_script.sh
# Vérifier la version bash
bash --version
# Utiliser le chemin complet pour les commandes
/usr/bin/mdls au lieu de mdls

4. Problèmes de format de date

# Gérer différents formats de date
date -jf "%Y-%m-%d %H:%M:%S %z" "2024-01-01 12:00:00 +0000" +"%Y-%m-%d %H:%M:%S"

Conclusion

La surveillance de l'utilisation des applications et fichiers est essentielle pour une gestion efficace du parc Mac. Ces scripts fournissent des informations complètes sur le comportement des utilisateurs, les performances du système et la conformité sécuritaire. Une surveillance régulière aide à optimiser les ressources, améliorer l'expérience utilisateur et maintenir les normes de sécurité à travers votre parc Mac.

N'oubliez pas de tester les scripts dans un environnement contrôlé avant de les déployer sur votre parc, et toujours suivre les politiques de sécurité et de confidentialité de votre organisation lors de la surveillance de l'activité des utilisateurs.

Guide

Avis important