Gérez et suivez efficacement les applications App Store sur vos appareils Roundfleet avec des outils d'inventaire complets. Ce tutoriel couvre la découverte d'applications, la conformité des licences, l'analyse d'utilisation et les rapports de niveau entreprise pour les applications Mac App Store.

Comprendre la Gestion des Applications App Store

Les applications App Store sur macOS contiennent des identifiants uniques et des reçus qui permettent le suivi d'entreprise :

Composants Principaux

• Reçus MAS - Reçus numériques stockés dans les bundles d'applications pour vérification
• Identifiants Bundle - Identification unique d'application dans l'écosystème App Store
• Suivi Version - Gestion version d'application et conformité mise à jour
• Gestion Licence - Surveillance allocation et conformité licence d'entreprise
• Analyse Utilisation - Modèles d'utilisation d'application et métriques d'adoption

Avantages Entreprise

• Gestion Actifs Logiciels - Inventaire complet des applications App Store
• Conformité Licence - Suivi licences et allocations d'applications d'entreprise
• Surveillance Sécurité - Identifier applications non autorisées ou non conformes
• Optimisation Coûts - Optimiser dépenses App Store et utilisation licences
• Application Politique - Assurer conformité avec politiques d'applications d'entreprise

Découverte Basique des Applications App Store

Liste Simple Applications App Store

#!/bin/bash

# Découverte basique applications App Store
echo "📱 Découverte Applications App Store"
echo "===================================="
echo ""

app_store_apps=$(find /Applications -path '*Contents/_MASReceipt/receipt' -maxdepth 4 -print | \
    sed 's#.app/Contents/_MASReceipt/receipt#.app#g; s#/Applications/##')

if [[ -n "$app_store_apps" ]]; then
    echo "Applications App Store Trouvées :"
    echo "$app_store_apps" | sort
    
    local app_count=$(echo "$app_store_apps" | wc -l | xargs)
    echo ""
    echo "Total applications App Store : $app_count"
else
    echo "Aucune application App Store trouvée dans /Applications"
fi

Découverte Améliorée avec Détails

#!/bin/bash

# Découverte complète applications App Store avec métadonnées
discover_app_store_apps() {
    echo "🔍 Découverte Complète Applications App Store"
    echo "============================================="
    echo ""
    
    local apps_found=0
    local total_size=0
    
    # Trouver toutes applications App Store avec reçus
    while IFS= read -r -d '' app_path; do
        if [[ -n "$app_path" ]]; then
            local app_name=$(basename "$app_path" .app)
            local app_bundle_id=""
            local app_version=""
            local app_size=""
            local install_date=""
            
            # Obtenir identifiant bundle
            if [[ -f "$app_path/Contents/Info.plist" ]]; then
                app_bundle_id=$(defaults read "$app_path/Contents/Info.plist" CFBundleIdentifier 2>/dev/null || echo "Inconnu")
                app_version=$(defaults read "$app_path/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null || echo "Inconnue")
            fi
            
            # Obtenir taille application
            if [[ -d "$app_path" ]]; then
                app_size=$(du -sh "$app_path" 2>/dev/null | cut -f1 || echo "Inconnue")
                # Convertir taille en octets pour totalisation
                local size_bytes=$(du -s "$app_path" 2>/dev/null | cut -f1 || echo "0")
                total_size=$((total_size + size_bytes))
            fi
            
            # Obtenir date installation/modification
            if [[ -f "$app_path/Contents/_MASReceipt/receipt" ]]; then
                install_date=$(stat -f "%Sm" -t "%Y-%m-%d %H:%M:%S" "$app_path/Contents/_MASReceipt/receipt" 2>/dev/null || echo "Inconnue")
            fi
            
            echo "App : $app_name"
            echo "  ID Bundle : $app_bundle_id"
            echo "  Version : $app_version"
            echo "  Taille : $app_size"
            echo "  Date Installation : $install_date"
            echo "  Chemin : $app_path"
            echo ""
            
            ((apps_found++))
        fi
    done < <(find /Applications -name "*.app" -path '*Contents/_MASReceipt/receipt' -exec dirname {} \; 2>/dev/null | \
             sed 's|/Contents/_MASReceipt||' | sort -u | tr '\n' '\0')
    
    # Statistiques résumé
    echo "=== Résumé Découverte ==="
    echo "Total applications App Store trouvées : $apps_found"
    echo "Espace disque total utilisé : $(echo "scale=2; $total_size / 1024 / 1024" | bc 2>/dev/null || echo "Inconnu") MB"
    echo "Taille moyenne application : $(echo "scale=2; $total_size / $apps_found / 1024 / 1024" | bc 2>/dev/null || echo "Inconnue") MB"
    echo "Scan terminé : $(date)"
    
    return $apps_found
}

# Exécuter découverte
discover_app_store_apps

Gestion d'Inventaire d'Applications d'Entreprise

Script d'Inventaire Complet

#!/bin/bash

# Gestion inventaire App Store d'entreprise
generate_app_store_inventory() {
    local output_format="${1:-json}"
    local include_metadata="${2:-true}"
    local export_path="${3:-/tmp}"
    
    echo "📊 Génération Inventaire App Store d'Entreprise"
    echo "==============================================="
    echo "Format sortie : $output_format"
    echo "Inclure métadonnées : $include_metadata"
    echo ""
    
    local timestamp=$(date +"%Y%m%d_%H%M%S")
    local hostname=$(hostname)
    local report_file="$export_path/app_store_inventory_${hostname}_${timestamp}"
    
    # Informations système
    local device_info=$(system_profiler SPHardwareDataType | grep -E "(Model Name|Serial Number)" | \
                        awk -F': ' '{print $2}' | xargs | tr ' ' '_')
    local macos_version=$(sw_vers -productVersion)
    local current_user=$(stat -f%Su /dev/console 2>/dev/null || echo "$USER")
    
    # Initialiser structure données inventaire
    local inventory_data=""
    local app_count=0
    local total_size_bytes=0
    
    echo "Scan applications..."
    
    # Découvrir toutes applications App Store
    while IFS= read -r -d '' app_path; do
        if [[ -d "$app_path" && -f "$app_path/Contents/_MASReceipt/receipt" ]]; then
            local app_name=$(basename "$app_path" .app)
            local bundle_id=""
            local version=""
            local build_version=""
            local size_bytes=0
            local size_human=""
            local install_date=""
            local last_modified=""
            local executable_path=""
            local app_category=""
            local developer_name=""
            local app_store_url=""
            
            # Extraire métadonnées application
            if [[ -f "$app_path/Contents/Info.plist" ]]; then
                bundle_id=$(defaults read "$app_path/Contents/Info.plist" CFBundleIdentifier 2>/dev/null || echo "inconnu")
                version=$(defaults read "$app_path/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null || echo "inconnue")
                build_version=$(defaults read "$app_path/Contents/Info.plist" CFBundleVersion 2>/dev/null || echo "inconnue")
                executable_path=$(defaults read "$app_path/Contents/Info.plist" CFBundleExecutable 2>/dev/null || echo "inconnu")
                app_category=$(defaults read "$app_path/Contents/Info.plist" LSApplicationCategoryType 2>/dev/null || echo "inconnue")
            fi
            
            # Obtenir taille application
            size_bytes=$(du -sk "$app_path" 2>/dev/null | cut -f1 || echo "0")
            size_bytes=$((size_bytes * 1024))  # Convertir KB en octets
            size_human=$(du -sh "$app_path" 2>/dev/null | cut -f1 || echo "inconnue")
            total_size_bytes=$((total_size_bytes + size_bytes))
            
            # Obtenir horodatages
            install_date=$(stat -f "%Sm" -t "%Y-%m-%d %H:%M:%S" "$app_path/Contents/_MASReceipt/receipt" 2>/dev/null || echo "inconnue")
            last_modified=$(stat -f "%Sm" -t "%Y-%m-%d %H:%M:%S" "$app_path" 2>/dev/null || echo "inconnue")
            
            # Essayer d'extraire métadonnées supplémentaires si demandé
            if [[ "$include_metadata" == "true" ]]; then
                # Chercher identifiant équipe
                local team_id=""
                if command -v codesign >/dev/null 2>&1; then
                    team_id=$(codesign -dv "$app_path" 2>&1 | grep "TeamIdentifier" | awk -F'=' '{print $2}' || echo "inconnu")
                fi
                
                # Vérifier si application en cours d'exécution
                local is_running="false"
                if pgrep -f "$app_name" >/dev/null 2>&1; then
                    is_running="true"
                fi
                
                # Obtenir permissions application (vérification simplifiée)
                local has_camera_permission="inconnue"
                local has_microphone_permission="inconnue"
                local has_location_permission="inconnue"
                
                if [[ -f "$app_path/Contents/Info.plist" ]]; then
                    if defaults read "$app_path/Contents/Info.plist" NSCameraUsageDescription >/dev/null 2>&1; then
                        has_camera_permission="demandee"
                    else
                        has_camera_permission="non_demandee"
                    fi
                    
                    if defaults read "$app_path/Contents/Info.plist" NSMicrophoneUsageDescription >/dev/null 2>&1; then
                        has_microphone_permission="demandee"
                    else
                        has_microphone_permission="non_demandee"
                    fi
                    
                    if defaults read "$app_path/Contents/Info.plist" NSLocationUsageDescription >/dev/null 2>&1; then
                        has_location_permission="demandee"
                    else
                        has_location_permission="non_demandee"
                    fi
                fi
            fi
            
            # Formater sortie basée sur format demandé
            case "$output_format" in
                "json")
                    local app_json="{
                        \"nom_app\": \"$app_name\",
                        \"bundle_id\": \"$bundle_id\",
                        \"version\": \"$version\",
                        \"version_build\": \"$build_version\",
                        \"taille_octets\": $size_bytes,
                        \"taille_humaine\": \"$size_human\",
                        \"date_installation\": \"$install_date\",
                        \"derniere_modification\": \"$last_modified\",
                        \"chemin_app\": \"$app_path\",
                        \"chemin_executable\": \"$executable_path\",
                        \"categorie\": \"$app_category\""
                    
                    if [[ "$include_metadata" == "true" ]]; then
                        app_json="$app_json,
                        \"id_equipe\": \"$team_id\",
                        \"en_cours_execution\": $is_running,
                        \"permission_camera\": \"$has_camera_permission\",
                        \"permission_microphone\": \"$has_microphone_permission\",
                        \"permission_localisation\": \"$has_location_permission\""
                    fi
                    
                    app_json="$app_json}"
                    
                    if [[ $app_count -gt 0 ]]; then
                        inventory_data="$inventory_data,$app_json"
                    else
                        inventory_data="$app_json"
                    fi
                    ;;
                    
                "csv")
                    if [[ $app_count -eq 0 ]]; then
                        # En-tête CSV
                        if [[ "$include_metadata" == "true" ]]; then
                            inventory_data="Nom App,Bundle ID,Version,Version Build,Taille (Octets),Taille (Humaine),Date Installation,Dernière Modification,Chemin App,Catégorie,ID Équipe,En Cours Exécution,Permission Caméra,Permission Microphone,Permission Localisation"
                        else
                            inventory_data="Nom App,Bundle ID,Version,Version Build,Taille (Octets),Taille (Humaine),Date Installation,Dernière Modification,Chemin App,Catégorie"
                        fi
                    fi
                    
                    local csv_line="\"$app_name\",\"$bundle_id\",\"$version\",\"$build_version\",$size_bytes,\"$size_human\",\"$install_date\",\"$last_modified\",\"$app_path\",\"$app_category\""
                    
                    if [[ "$include_metadata" == "true" ]]; then
                        csv_line="$csv_line,\"$team_id\",$is_running,\"$has_camera_permission\",\"$has_microphone_permission\",\"$has_location_permission\""
                    fi
                    
                    inventory_data="$inventory_data\n$csv_line"
                    ;;
                    
                "text"|*)
                    inventory_data="$inventory_data
App : $app_name
  Bundle ID : $bundle_id
  Version : $version ($build_version)
  Taille : $size_human ($size_bytes octets)
  Date Installation : $install_date
  Dernière Modification : $last_modified
  Chemin : $app_path
  Catégorie : $app_category"
                    
                    if [[ "$include_metadata" == "true" ]]; then
                        inventory_data="$inventory_data
  ID Équipe : $team_id
  Actuellement En Cours : $is_running
  Permission Caméra : $has_camera_permission
  Permission Microphone : $has_microphone_permission
  Permission Localisation : $has_location_permission"
                    fi
                    
                    inventory_data="$inventory_data
"
                    ;;
            esac
            
            ((app_count++))
        fi
    done < <(find /Applications -name "*.app" -type d -print0 2>/dev/null)
    
    # Générer rapport final
    local total_size_human=$(echo "scale=2; $total_size_bytes / 1024 / 1024 / 1024" | bc 2>/dev/null || echo "inconnue")
    
    case "$output_format" in
        "json")
            local final_report="{
                \"metadonnees_rapport\": {
                    \"horodatage\": \"$(date -u +"%Y-%m-%dT%H:%M:%SZ")\",
                    \"nom_hote\": \"$hostname\",
                    \"info_appareil\": \"$device_info\",
                    \"version_macos\": \"$macos_version\",
                    \"utilisateur_actuel\": \"$current_user\",
                    \"total_apps\": $app_count,
                    \"taille_totale_octets\": $total_size_bytes,
                    \"taille_totale_gb\": \"$total_size_human GB\"
                },
                \"applications\": [$inventory_data]
            }"
            
            echo "$final_report" > "${report_file}.json"
            echo "✅ Rapport JSON sauvegardé dans : ${report_file}.json"
            ;;
            
        "csv")
            echo -e "$inventory_data" > "${report_file}.csv"
            echo "✅ Rapport CSV sauvegardé dans : ${report_file}.csv"
            ;;
            
        "text"|*)
            {
                echo "Rapport d'Inventaire App Store Roundfleet"
                echo "======================================="
                echo "Généré : $(date)"
                echo "Nom d'hôte : $hostname"
                echo "Appareil : $device_info"
                echo "Version macOS : $macos_version"
                echo "Utilisateur Actuel : $current_user"
                echo "Total Apps : $app_count"
                echo "Taille Totale : $total_size_human GB"
                echo ""
                echo "Applications :"
                echo "============="
                echo "$inventory_data"
            } > "${report_file}.txt"
            echo "✅ Rapport texte sauvegardé dans : ${report_file}.txt"
            ;;
    esac
    
    # Sortie résumé
    echo ""
    echo "=== Résumé Inventaire ==="
    echo "Apps découvertes : $app_count"
    echo "Taille totale : $total_size_human GB"
    echo "Format rapport : $output_format"
    echo "Emplacement rapport : $report_file"
    echo ""
    
    return $app_count
}

# Exemples d'utilisation
echo "📊 Gestion d'Inventaire App Store d'Entreprise"
echo ""
echo "1. Générer inventaire JSON avec métadonnées"
generate_app_store_inventory "json" "true" "/tmp"
echo ""

echo "2. Générer inventaire CSV (basique)"
generate_app_store_inventory "csv" "false" "/tmp"
echo ""

echo "3. Générer inventaire texte avec métadonnées"
generate_app_store_inventory "text" "true" "/tmp"

Analyse Conformité et Sécurité Applications

#!/bin/bash

# Analyse conformité et sécurité applications App Store
analyze_app_compliance() {
    echo "🔒 Analyse Conformité Applications App Store"
    echo "==========================================="
    echo ""
    
    local compliance_issues=0
    local security_concerns=0
    local policy_violations=0
    
    # Définir règles politique d'entreprise
    local blocked_apps=("Jeux" "Réseaux Sociaux" "Rencontres")  # Exemples catégories
    local required_apps=("Microsoft Word" "Microsoft Excel" "Slack")  # Exemples apps requises
    local max_app_age_days=365  # Apps plus anciennes que 1 an signalées
    local min_security_permissions=("Caméra" "Microphone" "Localisation")
    
    echo "Analyse applications App Store pour conformité..."
    echo ""
    
    # Suivre applications requises
    local found_required_apps=()
    local missing_required_apps=()
    
    # Analyser chaque application App Store
    while IFS= read -r -d '' app_path; do
        if [[ -d "$app_path" && -f "$app_path/Contents/_MASReceipt/receipt" ]]; then
            local app_name=$(basename "$app_path" .app)
            local bundle_id=""
            local version=""
            local category=""
            local install_date=""
            local days_since_install=""
            
            echo "Analyse : $app_name"
            
            # Obtenir métadonnées application
            if [[ -f "$app_path/Contents/Info.plist" ]]; then
                bundle_id=$(defaults read "$app_path/Contents/Info.plist" CFBundleIdentifier 2>/dev/null || echo "inconnu")
                version=$(defaults read "$app_path/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null || echo "inconnue")
                category=$(defaults read "$app_path/Contents/Info.plist" LSApplicationCategoryType 2>/dev/null || echo "inconnue")
            fi
            
            # Obtenir date installation et calculer âge
            if [[ -f "$app_path/Contents/_MASReceipt/receipt" ]]; then
                install_date=$(stat -f "%Sm" -t "%Y-%m-%d" "$app_path/Contents/_MASReceipt/receipt" 2>/dev/null || echo "inconnue")
                if [[ "$install_date" != "inconnue" ]]; then
                    local install_epoch=$(date -j -f "%Y-%m-%d" "$install_date" "+%s" 2>/dev/null || echo "0")
                    local current_epoch=$(date "+%s")
                    days_since_install=$(( (current_epoch - install_epoch) / 86400 ))
                fi
            fi
            
            # Vérifier contre applications/catégories bloquées
            local is_blocked=false
            for blocked_category in "${blocked_apps[@]}"; do
                if [[ "$category" =~ "$blocked_category" ]] || [[ "$app_name" =~ "$blocked_category" ]]; then
                    echo "  ❌ VIOLATION POLITIQUE : Catégorie app '$category' est bloquée"
                    is_blocked=true
                    ((policy_violations++))
                    break
                fi
            done
            
            # Vérifier âge application
            if [[ -n "$days_since_install" && "$days_since_install" -gt "$max_app_age_days" ]]; then
                echo "  ⚠️ CONFORMITÉ : App plus ancienne que $max_app_age_days jours ($days_since_install jours)"
                ((compliance_issues++))
            fi
            
            # Vérifier permissions sécurité
            local permission_count=0
            if [[ -f "$app_path/Contents/Info.plist" ]]; then
                if defaults read "$app_path/Contents/Info.plist" NSCameraUsageDescription >/dev/null 2>&1; then
                    echo "  🔒 SÉCURITÉ : App demande accès caméra"
                    ((permission_count++))
                fi
                
                if defaults read "$app_path/Contents/Info.plist" NSMicrophoneUsageDescription >/dev/null 2>&1; then
                    echo "  🔒 SÉCURITÉ : App demande accès microphone"
                    ((permission_count++))
                fi
                
                if defaults read "$app_path/Contents/Info.plist" NSLocationUsageDescription >/dev/null 2>&1; then
                    echo "  🔒 SÉCURITÉ : App demande accès localisation"
                    ((permission_count++))
                fi
                
                if [[ "$permission_count" -gt 2 ]]; then
                    echo "  ⚠️ PRÉOCCUPATION SÉCURITÉ : App demande permissions sensibles multiples"
                    ((security_concerns++))
                fi
            fi
            
            # Vérifier contre applications requises
            for required_app in "${required_apps[@]}"; do
                if [[ "$app_name" =~ "$required_app" ]]; then
                    found_required_apps+=("$required_app")
                fi
            done
            
            # Vérification signature code
            if command -v codesign >/dev/null 2>&1; then
                if ! codesign -v "$app_path" >/dev/null 2>&1; then
                    echo "  ❌ SÉCURITÉ : Signature code invalide"
                    ((security_concerns++))
                fi
            fi
            
            echo "  ✅ Analyse terminée"
            echo ""
        fi
    done < <(find /Applications -name "*.app" -type d -print0 2>/dev/null)
    
    # Vérifier applications requises manquantes
    for required_app in "${required_apps[@]}"; do
        local found=false
        for found_app in "${found_required_apps[@]}"; do
            if [[ "$found_app" == "$required_app" ]]; then
                found=true
                break
            fi
        done
        
        if [[ "$found" == "false" ]]; then
            missing_required_apps+=("$required_app")
        fi
    done
    
    # Générer rapport conformité
    echo "=== Rapport Analyse Conformité ==="
    echo "Violations politique : $policy_violations"
    echo "Problèmes conformité : $compliance_issues"
    echo "Préoccupations sécurité : $security_concerns"
    echo ""
    
    if [[ ${#missing_required_apps[@]} -gt 0 ]]; then
        echo "Applications requises manquantes :"
        for missing_app in "${missing_required_apps[@]}"; do
            echo "  - $missing_app"
        done
        echo ""
    fi
    
    if [[ ${#found_required_apps[@]} -gt 0 ]]; then
        echo "Applications requises trouvées :"
        for found_app in "${found_required_apps[@]}"; do
            echo "  ✅ $found_app"
        done
        echo ""
    fi
    
    # Score conformité global
    local total_issues=$((policy_violations + compliance_issues + security_concerns + ${#missing_required_apps[@]}))
    if [[ "$total_issues" -eq 0 ]]; then
        echo "🎉 STATUT CONFORMITÉ : ENTIÈREMENT CONFORME"
    elif [[ "$total_issues" -le 3 ]]; then
        echo "⚠️ STATUT CONFORMITÉ : PROBLÈMES MINEURS ($total_issues problèmes)"
    else
        echo "❌ STATUT CONFORMITÉ : PROBLÈMES MAJEURS ($total_issues problèmes)"
    fi
    
    return $total_issues
}

# Exécuter analyse conformité
analyze_app_compliance

Gestion Flotte et Rapports

Gestion Applications Flotte d'Entreprise

#!/bin/bash

# Gestion App Store flotte d'entreprise
manage_fleet_app_inventory() {
    local operation="${1:-discover}"  # discover, report, compliance, update
    local fleet_config_file="${2:-/etc/roundfleet/app_config.json}"
    local output_dir="${3:-/var/log/roundfleet}"
    
    echo "🚀 Gestion App Store Entreprise Roundfleet"
    echo "======================================="
    echo "Opération : $operation"
    echo "Fichier config : $fleet_config_file"
    echo "Répertoire sortie : $output_dir"
    echo ""
    
    # Assurer que répertoire sortie existe
    mkdir -p "$output_dir"
    
    # Identification appareil
    local device_id=$(system_profiler SPHardwareDataType | grep "Serial Number" | awk -F': ' '{print $2}' | xargs)
    local device_name=$(hostname)
    local timestamp=$(date +"%Y%m%d_%H%M%S")
    local report_file="$output_dir/fleet_app_report_${device_id}_${timestamp}.json"
    
    case "$operation" in
        "discover")
            echo "🔍 Mode Découverte Flotte"
            echo "========================="
            
            # Générer inventaire application complet
            local app_data=$(generate_comprehensive_app_data)
            
            # Créer rapport flotte
            local fleet_report="{
                \"info_appareil\": {
                    \"id_appareil\": \"$device_id\",
                    \"nom_appareil\": \"$device_name\",
                    \"horodatage\": \"$(date -u +"%Y-%m-%dT%H:%M:%SZ")\",
                    \"version_macos\": \"$(sw_vers -productVersion)\",
                    \"utilisateur_actuel\": \"$(stat -f%Su /dev/console 2>/dev/null || echo "$USER")\"
                },
                \"inventaire_apps\": $app_data,
                \"operation\": \"decouverte_flotte\"
            }"
            
            echo "$fleet_report" > "$report_file"
            echo "✅ Rapport découverte flotte sauvegardé : $report_file"
            ;;
            
        "compliance")
            echo "📋 Vérification Conformité Flotte"
            echo "================================="
            
            # Exécuter analyse conformité
            local compliance_result=$(analyze_fleet_compliance)
            
            # Créer rapport conformité
            local compliance_report="{
                \"info_appareil\": {
                    \"id_appareil\": \"$device_id\",
                    \"nom_appareil\": \"$device_name\",
                    \"horodatage\": \"$(date -u +"%Y-%m-%dT%H:%M:%SZ")\"
                },
                \"resultats_conformite\": $compliance_result,
                \"operation\": \"verification_conformite\"
            }"
            
            echo "$compliance_report" > "$report_file"
            echo "✅ Rapport conformité sauvegardé : $report_file"
            ;;
            
        "report")
            echo "📊 Mode Rapports Flotte"
            echo "======================="
            
            # Générer tous formats rapport
            echo "Génération rapports flotte complets..."
            
            generate_app_store_inventory "json" "true" "$output_dir"
            generate_app_store_inventory "csv" "true" "$output_dir"
            generate_app_store_inventory "text" "true" "$output_dir"
            
            echo "✅ Tous rapports flotte générés dans : $output_dir"
            ;;
            
        "update")
            echo "🔄 Vérification Mise à Jour Flotte"
            echo "==================================="
            
            # Vérifier mises à jour applications
            check_app_store_updates
            ;;
            
        *)
            echo "❌ Opération inconnue : $operation"
            echo "Opérations disponibles : discover, report, compliance, update"
            return 1
            ;;
    esac
    
    return 0
}

# Fonction auxiliaire pour générer données applications complètes
generate_comprehensive_app_data() {
    local apps_json="["
    local first_app=true
    
    while IFS= read -r -d '' app_path; do
        if [[ -d "$app_path" && -f "$app_path/Contents/_MASReceipt/receipt" ]]; then
            local app_name=$(basename "$app_path" .app)
            local bundle_id=$(defaults read "$app_path/Contents/Info.plist" CFBundleIdentifier 2>/dev/null || echo "inconnu")
            local version=$(defaults read "$app_path/Contents/Info.plist" CFBundleShortVersionString 2>/dev/null || echo "inconnue")
            local size_bytes=$(du -sk "$app_path" 2>/dev/null | cut -f1 || echo "0")
            size_bytes=$((size_bytes * 1024))
            
            if [[ "$first_app" == "false" ]]; then
                apps_json="$apps_json,"
            fi
            
            apps_json="$apps_json{
                \"nom\": \"$app_name\",
                \"bundle_id\": \"$bundle_id\",
                \"version\": \"$version\",
                \"taille_octets\": $size_bytes,
                \"chemin\": \"$app_path\"
            }"
            
            first_app=false
        fi
    done < <(find /Applications -name "*.app" -type d -print0 2>/dev/null)
    
    apps_json="$apps_json]"
    echo "$apps_json"
}

# Vérifier mises à jour App Store
check_app_store_updates() {
    echo "Vérification mises à jour App Store disponibles..."
    
    # Utiliser softwareupdate pour vérifier mises à jour disponibles
    local updates_available=$(softwareupdate -l 2>/dev/null | grep -i "app store" || echo "")
    
    if [[ -n "$updates_available" ]]; then
        echo "📦 Mises à jour App Store disponibles :"
        echo "$updates_available"
    else
        echo "✅ Toutes applications App Store sont à jour"
    fi
    
    # Vérifier aussi Mac App Store directement si disponible
    if command -v mas >/dev/null 2>&1; then
        echo ""
        echo "Vérification avec mas-cli..."
        mas outdated 2>/dev/null || echo "mas-cli non disponible ou aucune mise à jour trouvée"
    fi
}

# Exemples d'utilisation
echo "Exemples Gestion Flotte :"
echo "========================="
echo ""

echo "1. Mode découverte :"
manage_fleet_app_inventory "discover"
echo ""

echo "2. Vérification conformité :"
manage_fleet_app_inventory "compliance"
echo ""

echo "3. Générer tous rapports :"
manage_fleet_app_inventory "report"

Intégration App Store Connect

Gestion Applications d'Entreprise avec App Store Connect

#!/bin/bash

# Intégration App Store Connect d'entreprise pour gestion licences
manage_app_store_licenses() {
    echo "📄 Gestion Licences App Store Connect"
    echo "====================================="
    echo ""
    
    # Note : Ceci nécessite accès App Store Connect d'entreprise
    # et configuration appropriée identifiants API
    
    local license_report_file="/tmp/app_store_licenses_$(date +%Y%m%d_%H%M%S).json"
    
    echo "Analyse licences applications App Store..."
    echo ""
    
    # Suivre applications nécessitant potentiellement licences business
    local business_apps=()
    local consumer_apps=()
    local unknown_apps=()
    
    while IFS= read -r -d '' app_path; do
        if [[ -d "$app_path" && -f "$app_path/Contents/_MASReceipt/receipt" ]]; then
            local app_name=$(basename "$app_path" .app)
            local bundle_id=$(defaults read "$app_path/Contents/Info.plist" CFBundleIdentifier 2>/dev/null || echo "inconnu")
            
            # Catégories nécessitant typiquement licences business
            local business_categories=("Outils Développeur" "Business" "Productivité" "Graphisme & Design")
            local is_business_app=false
            
            # Vérifier si application est orientée business
            if [[ -f "$app_path/Contents/Info.plist" ]]; then
                local category=$(defaults read "$app_path/Contents/Info.plist" LSApplicationCategoryType 2>/dev/null || echo "inconnue")
                
                for biz_cat in "${business_categories[@]}"; do
                    if [[ "$category" =~ "$biz_cat" ]]; then
                        is_business_app=true
                        break
                    fi
                done
                
                # Vérifier aussi modèles applications business communes
                if [[ "$app_name" =~ (Microsoft|Adobe|Slack|Zoom|Teams|Office) ]]; then
                    is_business_app=true
                fi
            fi
            
            if [[ "$is_business_app" == "true" ]]; then
                business_apps+=("$app_name ($bundle_id)")
                echo "💼 Application business détectée : $app_name"
            else
                # Applications consommateur potentiellement acceptables
                if [[ "$app_name" =~ (Calculatrice|TextEdit|Safari|Mail|Photos) ]]; then
                    consumer_apps+=("$app_name ($bundle_id)")
                    echo "👤 Application consommateur : $app_name"
                else
                    unknown_apps+=("$app_name ($bundle_id)")
                    echo "❓ Catégorie inconnue : $app_name"
                fi
            fi
        fi
    done < <(find /Applications -name "*.app" -type d -print0 2>/dev/null)
    
    # Générer rapport conformité licence
    {
        echo "{"
        echo "  \"analyse_licence\": {"
        echo "    \"horodatage\": \"$(date -u +"%Y-%m-%dT%H:%M:%SZ")\","
        echo "    \"id_appareil\": \"$(system_profiler SPHardwareDataType | grep "Serial Number" | awk -F': ' '{print $2}' | xargs)\","
        echo "    \"apps_business\": ["
        
        local first=true
        for app in "${business_apps[@]}"; do
            if [[ "$first" == "false" ]]; then echo ","; fi
            echo "      \"$app\""
            first=false
        done
        
        echo "    ],"
        echo "    \"apps_consommateur\": ["
        
        first=true
        for app in "${consumer_apps[@]}"; do
            if [[ "$first" == "false" ]]; then echo ","; fi
            echo "      \"$app\""
            first=false
        done
        
        echo "    ],"
        echo "    \"apps_inconnues\": ["
        
        first=true
        for app in "${unknown_apps[@]}"; do
            if [[ "$first" == "false" ]]; then echo ","; fi
            echo "      \"$app\""
            first=false
        done
        
        echo "    ],"
        echo "    \"resume\": {"
        echo "      \"total_apps_business\": ${#business_apps[@]},"
        echo "      \"total_apps_consommateur\": ${#consumer_apps[@]},"
        echo "      \"total_apps_inconnues\": ${#unknown_apps[@]},"
        echo "      \"necessite_revision_licence\": $([[ ${#business_apps[@]} -gt 0 || ${#unknown_apps[@]} -gt 0 ]] && echo "true" || echo "false")"
        echo "    }"
        echo "  }"
        echo "}"
    } > "$license_report_file"
    
    echo ""
    echo "=== Résumé Analyse Licence ==="
    echo "Applications business trouvées : ${#business_apps[@]}"
    echo "Applications consommateur trouvées : ${#consumer_apps[@]}"
    echo "Applications inconnues trouvées : ${#unknown_apps[@]}"
    echo ""
    
    if [[ ${#business_apps[@]} -gt 0 || ${#unknown_apps[@]} -gt 0 ]]; then
        echo "⚠️ Révision licence requise pour applications business/inconnues"
        echo "📄 Rapport licence sauvegardé : $license_report_file"
    else
        echo "✅ Aucune préoccupation licence business détectée"
    fi
    
    return 0
}

# Exécuter gestion licence
manage_app_store_licenses

Notes Importantes

Fonctionnalités Gestion Entreprise

• Inventaire Complet - Découverte et suivi complets applications App Store
• Surveillance Conformité - Application politique et analyse sécurité
• Gestion Licence - Intégration App Store Connect d'entreprise
• Rapports Flotte - Rapports multi-format (JSON, CSV, texte) avec métadonnées
• Analyse Sécurité - Audit permissions et vérification signature code
• Gestion Mise à Jour - Détection et gestion mises à jour App Store

Système Reçu App Store

• Reçus MAS - Preuve numérique achat App Store située dans Contents/_MASReceipt/receipt
• Identification Bundle - Suivi application unique via CFBundleIdentifier
• Suivi Version - Gestion version application et numéro build
• Métadonnées Installation - Suivi date installation et modification
• Vérification Licence - Conformité et allocation licence d'entreprise

Sécurité et Conformité

• Audit Permissions - Surveillance accès caméra, microphone, localisation
• Vérification Signature Code - Valider intégrité et authenticité application
• Application Politique - Validation catégories applications bloquées et applications requises
• Analyse Âge - Identifier applications obsolètes nécessitant mises à jour
• Suivi Identifiant Équipe - Identification équipe développeur pour politiques entreprise

Exemples d'Utilisation

# Découverte basique applications App Store
find /Applications -path '*Contents/_MASReceipt/receipt' -maxdepth 4 -print | \
    sed 's#.app/Contents/_MASReceipt/receipt#.app#g; s#/Applications/##'

# Inventaire entreprise avec sortie JSON
generate_app_store_inventory "json" "true" "/tmp"

# Analyse conformité
analyze_app_compliance

# Gestion flotte - mode découverte
manage_fleet_app_inventory "discover"

# Gestion licence
manage_app_store_licenses

Contrôlez et gérez les mises à jour automatiques de l'App Store sur vos appareils Roundfleet pour optimiser l'utilisation de la bande passante, gérer les mises à jour de sécurité et maintenir la stabilité du système. Ce tutoriel couvre les politiques de mise à jour, la configuration d'entreprise et les stratégies complètes de gestion des mises à jour.

Comprendre les Mises à Jour Automatiques de l'App Store macOS

Les mises à jour automatiques de l'App Store sur macOS téléchargent et installent automatiquement les mises à jour d'applications depuis le Mac App Store. Cette fonctionnalité affecte :

• Mises à Jour d'Applications - Installation automatique des mises à jour d'applications
• Stockage Système - Les mises à jour téléchargées consomment de l'espace disque
• Bande Passante Réseau - Les mises à jour se téléchargent en arrière-plan
• Stabilité Système - Les nouvelles mises à jour peuvent introduire des bugs ou des problèmes de compatibilité

Considérations d'Entreprise

La gestion des mises à jour automatiques est cruciale pour les environnements d'entreprise :

• Contrôle de la Bande Passante - Prévenir l'utilisation réseau inattendue
• Gestion de la Sécurité - Contrôler quand les mises à jour de sécurité sont appliquées
• Stabilité Système - Tester les mises à jour avant le déploiement
• Gestion du Stockage - Prévenir les problèmes de stockage sur les appareils à espace limité
• Exigences de Conformité - Certaines industries nécessitent un déploiement contrôlé des mises à jour

Contrôle de Base des Mises à Jour de l'App Store

Désactiver les Mises à Jour Automatiques

#!/bin/bash

# Désactiver les mises à jour automatiques de l'App Store
sudo defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool FALSE

echo "Mises à jour automatiques de l'App Store désactivées"
exit 0

Activer les Mises à Jour Automatiques

#!/bin/bash

# Activer les mises à jour automatiques de l'App Store
sudo defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool TRUE

echo "Mises à jour automatiques de l'App Store activées"
exit 0

Vérifier le Statut Actuel des Mises à Jour Automatiques

#!/bin/bash

# Vérifier le paramètre actuel de mise à jour automatique
auto_update_status=$(defaults read /Library/Preferences/com.apple.commerce.plist AutoUpdate 2>/dev/null || echo "Non Défini")

if [[ "$auto_update_status" == "1" ]]; then
    echo "Mises à Jour Automatiques de l'App Store : ACTIVÉES"
elif [[ "$auto_update_status" == "0" ]]; then
    echo "Mises à Jour Automatiques de l'App Store : DÉSACTIVÉES"
else
    echo "Mises à Jour Automatiques de l'App Store : PAR DÉFAUT (généralement activées)"
fi

Gestion Avancée des Mises à Jour

Configuration Complète de Politique de Mise à Jour

#!/bin/bash

# Gestion avancée des mises à jour de l'App Store avec validation
configure_app_store_updates() {
    local policy="$1"
    local schedule="$2"
    local dry_run="${3:-false}"
    
    # Valider les privilèges administrateur
    if [[ $EUID -ne 0 ]]; then
        echo "Erreur : Ce script nécessite des privilèges administrateur"
        echo "Veuillez exécuter avec sudo : sudo $0"
        exit 1
    fi
    
    echo "=== Configuration de la Politique de Mise à Jour de l'App Store : $policy ==="
    
    if [[ "$dry_run" == "true" ]]; then
        echo "MODE TEST - Aucun changement ne sera appliqué"
        return 0
    fi
    
    case "$policy" in
        "enterprise_controlled")
            echo "Application de la politique de mise à jour contrôlée d'entreprise..."
            
            # Désactiver les mises à jour automatiques pour un environnement contrôlé
            defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool FALSE
            
            # Désactiver le téléchargement automatique des mises à jour
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticDownload -bool FALSE
            
            # Désactiver l'installation des mises à jour critiques
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist CriticalUpdateInstall -bool FALSE
            
            echo "✓ Politique contrôlée d'entreprise appliquée"
            ;;
        "security_only")
            echo "Application de la politique de mise à jour sécurité uniquement..."
            
            # Désactiver les mises à jour générales d'applications
            defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool FALSE
            
            # Activer uniquement les mises à jour de sécurité critiques
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist CriticalUpdateInstall -bool TRUE
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticDownload -bool TRUE
            
            echo "✓ Politique sécurité uniquement appliquée"
            ;;
        "scheduled_updates")
            echo "Application de la politique de mise à jour programmée..."
            
            # Désactiver les mises à jour immédiates
            defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool FALSE
            
            # Configurer la vérification programmée des mises à jour
            setup_scheduled_updates "$schedule"
            
            echo "✓ Politique de mise à jour programmée appliquée"
            ;;
        "bandwidth_conscious")
            echo "Application de la politique de mise à jour consciente de la bande passante..."
            
            # Désactiver les téléchargements automatiques
            defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool FALSE
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticDownload -bool FALSE
            
            # Activer la vérification des mises à jour mais pas l'installation automatique
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticCheckEnabled -bool TRUE
            
            echo "✓ Politique consciente de la bande passante appliquée"
            ;;
        "full_auto")
            echo "Application de la politique de mise à jour entièrement automatique..."
            
            # Activer toutes les mises à jour automatiques
            defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool TRUE
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticDownload -bool TRUE
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticCheckEnabled -bool TRUE
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist CriticalUpdateInstall -bool TRUE
            
            echo "✓ Politique de mise à jour entièrement automatique appliquée"
            ;;
        "disabled")
            echo "Désactivation de toutes les mises à jour automatiques..."
            
            # Désactiver toutes les fonctionnalités de mise à jour automatique
            defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool FALSE
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticDownload -bool FALSE
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticCheckEnabled -bool FALSE
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist CriticalUpdateInstall -bool FALSE
            
            echo "✓ Toutes les mises à jour automatiques désactivées"
            ;;
        *)
            echo "Erreur : Politique inconnue '$policy'"
            echo "Politiques disponibles : enterprise_controlled, security_only, scheduled_updates, bandwidth_conscious, full_auto, disabled"
            return 1
            ;;
    esac
    
    # Vérifier la configuration
    verify_update_settings
}

# Vérifier les paramètres actuels de mise à jour
verify_update_settings() {
    echo ""
    echo "=== Configuration Actuelle des Mises à Jour ==="
    
    # Vérifier les mises à jour automatiques de l'App Store
    local app_store_auto=$(defaults read /Library/Preferences/com.apple.commerce.plist AutoUpdate 2>/dev/null || echo "Défaut")
    echo "Mises à Jour Automatiques App Store : $([ "$app_store_auto" == "1" ] && echo "Activées" || [ "$app_store_auto" == "0" ] && echo "Désactivées" || echo "Défaut (Activées)")"
    
    # Vérifier les paramètres de Software Update
    local auto_download=$(defaults read /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticDownload 2>/dev/null || echo "Défaut")
    echo "Téléchargement Automatique : $([ "$auto_download" == "1" ] && echo "Activé" || [ "$auto_download" == "0" ] && echo "Désactivé" || echo "Défaut")"
    
    local auto_check=$(defaults read /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticCheckEnabled 2>/dev/null || echo "Défaut")
    echo "Vérification Automatique : $([ "$auto_check" == "1" ] && echo "Activée" || [ "$auto_check" == "0" ] && echo "Désactivée" || echo "Défaut")"
    
    local critical_updates=$(defaults read /Library/Preferences/com.apple.SoftwareUpdate.plist CriticalUpdateInstall 2>/dev/null || echo "Défaut")
    echo "Mises à Jour Critiques : $([ "$critical_updates" == "1" ] && echo "Activées" || [ "$critical_updates" == "0" ] && echo "Désactivées" || echo "Défaut")"
}

# Exemples d'utilisation
configure_app_store_updates "enterprise_controlled" "weekly"

Système de Gestion des Mises à Jour d'Entreprise App Store

#!/bin/bash

# Outil de Gestion des Mises à Jour de l'App Store Roundfleet
# Gestion complète des politiques de mise à jour et surveillance pour les appareils de flotte

# Configuration
SCRIPT_VERSION="1.0.0"
LOG_FILE="/var/log/roundfleet_appstore_updates.log"
REPORT_DIR="/etc/roundfleet/reports/updates"
CONFIG_DIR="/etc/roundfleet/updates"
POLICY_DIR="/etc/roundfleet/policies/updates"

# Créer les répertoires s'ils n'existent pas
mkdir -p "$REPORT_DIR" "$CONFIG_DIR" "$POLICY_DIR"

# Modèles de politiques de mise à jour
declare -A UPDATE_POLICIES=(
    ["enterprise_strict"]="app_updates_disabled,system_updates_manual,security_updates_auto,bandwidth_priority_high"
    ["enterprise_balanced"]="app_updates_scheduled,system_updates_auto,security_updates_immediate,bandwidth_priority_medium"
    ["enterprise_liberal"]="app_updates_auto,system_updates_auto,security_updates_immediate,bandwidth_priority_low"
    ["kiosk_mode"]="app_updates_disabled,system_updates_disabled,security_updates_manual,bandwidth_priority_high"
    ["development"]="app_updates_auto,system_updates_prompt,security_updates_auto,bandwidth_priority_low"
    ["education"]="app_updates_scheduled,system_updates_scheduled,security_updates_auto,bandwidth_priority_medium"
    ["healthcare"]="app_updates_manual,system_updates_manual,security_updates_immediate,bandwidth_priority_high"
    ["financial"]="app_updates_disabled,system_updates_manual,security_updates_immediate,bandwidth_priority_high"
    ["retail"]="app_updates_scheduled,system_updates_auto,security_updates_auto,bandwidth_priority_medium"
    ["remote_work"]="app_updates_auto,system_updates_prompt,security_updates_auto,bandwidth_priority_medium"
)

# Plannings de mise à jour pour différents scénarios
declare -A UPDATE_SCHEDULES=(
    ["business_hours"]="weekdays_evening,09:00-17:00_block"
    ["maintenance_window"]="weekend_only,saturday_2am"
    ["off_peak"]="overnight,02:00-05:00"
    ["immediate"]="real_time,no_delay"
    ["weekly_batch"]="sunday_night,sunday_23:00"
    ["monthly_patch"]="first_sunday,monthly_02:00"
)

# Profils de gestion de bande passante
declare -A BANDWIDTH_PROFILES=(
    ["conservative"]="max_5mbps,off_peak_only,cellular_disabled"
    ["balanced"]="max_20mbps,business_hours_limited,cellular_security_only"
    ["unlimited"]="no_throttle,anytime,cellular_enabled"
    ["emergency_only"]="max_1mbps,security_updates_only,cellular_emergency"
)

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

# Application avancée des politiques de mise à jour
enforce_update_policy() {
    local policy_name="$1"
    local environment_type="${2:-enterprise}"
    local bandwidth_profile="${3:-balanced}"
    local dry_run="${4:-false}"
    
    log_action "Application de la politique de mise à jour : $policy_name (environnement : $environment_type, bande passante : $bandwidth_profile, dry_run : $dry_run)"
    
    if [[ -z "${UPDATE_POLICIES[$policy_name]}" ]]; then
        log_action "ERREUR : Politique inconnue '$policy_name'"
        echo "Politiques disponibles : ${!UPDATE_POLICIES[*]}"
        return 1
    fi
    
    # Analyser la configuration de politique
    IFS=',' read -ra POLICY_PARTS <<< "${UPDATE_POLICIES[$policy_name]}"
    local app_updates="${POLICY_PARTS[0]}"
    local system_updates="${POLICY_PARTS[1]}"
    local security_updates="${POLICY_PARTS[2]}"
    local bandwidth_priority="${POLICY_PARTS[3]}"
    
    echo "=== Application de la Politique de Mise à Jour : $policy_name ==="
    echo "Mises à Jour d'Applications : $app_updates"
    echo "Mises à Jour Système : $system_updates"
    echo "Mises à Jour de Sécurité : $security_updates"
    echo "Priorité Bande Passante : $bandwidth_priority"
    echo "Environnement : $environment_type"
    
    if [[ "$dry_run" == "true" ]]; then
        echo "MODE TEST - Aucun changement ne sera appliqué"
        return 0
    fi
    
    # Appliquer les paramètres de mise à jour d'applications
    apply_app_update_policy "$app_updates"
    
    # Appliquer les paramètres de mise à jour système
    apply_system_update_policy "$system_updates"
    
    # Appliquer les paramètres de mise à jour de sécurité
    apply_security_update_policy "$security_updates"
    
    # Appliquer la gestion de bande passante
    apply_bandwidth_management "$bandwidth_profile"
    
    # Configurer les paramètres spécifiques à l'environnement
    configure_environment_settings "$environment_type"
    
    # Générer un rapport de conformité de politique
    local report_file="$REPORT_DIR/policy_enforcement_${policy_name}_$(date +%Y%m%d_%H%M%S).json"
    generate_comprehensive_report "$policy_name" "$report_file"
    
    log_action "Application de politique de mise à jour terminée : $report_file"
    echo "$report_file"
}

# Appliquer les paramètres de politique de mise à jour d'applications
apply_app_update_policy() {
    local policy="$1"
    
    case "$policy" in
        "app_updates_disabled")
            defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool FALSE
            echo "✓ Mises à jour automatiques de l'App Store désactivées"
            ;;
        "app_updates_auto")
            defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool TRUE
            echo "✓ Mises à jour automatiques de l'App Store activées"
            ;;
        "app_updates_scheduled")
            defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool FALSE
            setup_scheduled_app_updates "weekly"
            echo "✓ Mises à jour de l'App Store programmées pour la fenêtre de maintenance hebdomadaire"
            ;;
        "app_updates_manual")
            defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool FALSE
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticCheckEnabled -bool TRUE
            echo "✓ Mises à jour de l'App Store définies en manuel avec vérification automatique"
            ;;
    esac
}

# Appliquer les paramètres de politique de mise à jour système
apply_system_update_policy() {
    local policy="$1"
    
    case "$policy" in
        "system_updates_disabled")
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticCheckEnabled -bool FALSE
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticDownload -bool FALSE
            echo "✓ Mises à jour système complètement désactivées"
            ;;
        "system_updates_auto")
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticCheckEnabled -bool TRUE
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticDownload -bool TRUE
            echo "✓ Mises à jour système entièrement automatisées"
            ;;
        "system_updates_manual")
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticCheckEnabled -bool TRUE
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticDownload -bool FALSE
            echo "✓ Mises à jour système définies en installation manuelle"
            ;;
        "system_updates_prompt")
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticCheckEnabled -bool TRUE
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticDownload -bool TRUE
            # Configurer les invites utilisateur pour l'installation
            echo "✓ Mises à jour système définies pour inviter l'utilisateur à l'installation"
            ;;
        "system_updates_scheduled")
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticCheckEnabled -bool TRUE
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticDownload -bool TRUE
            setup_scheduled_system_updates "monthly"
            echo "✓ Mises à jour système programmées pour la maintenance mensuelle"
            ;;
    esac
}

# Appliquer les paramètres de politique de mise à jour de sécurité
apply_security_update_policy() {
    local policy="$1"
    
    case "$policy" in
        "security_updates_immediate")
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist CriticalUpdateInstall -bool TRUE
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticCheckEnabled -bool TRUE
            echo "✓ Mises à jour de sécurité définies en installation immédiate"
            ;;
        "security_updates_auto")
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist CriticalUpdateInstall -bool TRUE
            echo "✓ Mises à jour de sécurité activées pour installation automatique"
            ;;
        "security_updates_manual")
            defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist CriticalUpdateInstall -bool FALSE
            echo "✓ Mises à jour de sécurité définies en installation manuelle"
            ;;
    esac
}

# Surveiller la conformité des mises à jour à travers la flotte
monitor_fleet_update_compliance() {
    local compliance_type="${1:-standard}"
    
    echo "=== Moniteur de Conformité des Mises à Jour de Flotte ==="
    
    # Vérifier le statut global de conformité
    local policy_violations=0
    local total_checks=0
    
    # Vérifier les paramètres de l'App Store
    local app_store_setting=$(defaults read /Library/Preferences/com.apple.commerce.plist AutoUpdate 2>/dev/null || echo "default")
    ((total_checks++))
    
    # Vérifier les mises à jour en attente qui violent la politique
    local pending_updates=$(softwareupdate -l 2>/dev/null | grep -c "recommended" || echo "0")
    
    if [[ "$pending_updates" -gt 0 && "$compliance_type" == "strict" ]]; then
        ((policy_violations++))
        echo "⚠️ Violation de Politique : Mises à jour en attente trouvées en mode de conformité strict"
    fi
    
    # Calculer le score de conformité
    local compliance_score=$((100 - (policy_violations * 100 / total_checks)))
    
    echo "Score de Conformité : $compliance_score%"
    echo "Violations de Politique : $policy_violations"
    echo "Vérifications Totales : $total_checks"
    echo "Mises à Jour en Attente : $pending_updates"
}

# Fonction d'exécution principale
main() {
    local action="${1:-status}"
    local param1="${2:-}"
    local param2="${3:-}"
    local param3="${4:-}"
    local param4="${5:-}"
    
    log_action "=== Gestion des Mises à Jour de l'App Store Roundfleet Démarrée ==="
    log_action "Action : $action"
    
    # Assurer les privilèges requis pour les changements de configuration
    if [[ "$action" != "status" && "$action" != "help" && "$action" != "report" && $EUID -ne 0 ]]; then
        echo "Erreur : Cette action nécessite des privilèges administrateur"
        echo "Veuillez exécuter avec sudo : sudo $0 $*"
        exit 1
    fi
    
    case "$action" in
        "policy")
            if [[ -z "$param1" ]]; then
                echo "Politiques disponibles : ${!UPDATE_POLICIES[*]}"
                exit 1
            fi
            enforce_update_policy "$param1" "$param2" "$param3" "$param4"
            ;;
        "enable")
            defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool TRUE
            echo "✓ Mises à jour automatiques de l'App Store activées"
            ;;
        "disable")
            defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool FALSE
            echo "✓ Mises à jour automatiques de l'App Store désactivées"
            ;;
        "check")
            echo "Vérification des mises à jour disponibles..."
            softwareupdate -l
            ;;
        "install")
            if [[ -n "$param1" ]]; then
                echo "Installation de la mise à jour spécifique : $param1"
                softwareupdate -i "$param1"
            else
                echo "Installation de toutes les mises à jour disponibles..."
                softwareupdate -i -a
            fi
            ;;
        "status")
            verify_update_settings
            ;;
        "compliance")
            monitor_fleet_update_compliance "$param1"
            ;;
        "reset")
            echo "Réinitialisation des paramètres de mise à jour de l'App Store aux valeurs par défaut..."
            defaults delete /Library/Preferences/com.apple.commerce.plist AutoUpdate 2>/dev/null || true
            defaults delete /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticDownload 2>/dev/null || true
            defaults delete /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticCheckEnabled 2>/dev/null || true
            defaults delete /Library/Preferences/com.apple.SoftwareUpdate.plist CriticalUpdateInstall 2>/dev/null || true
            echo "✓ Paramètres de mise à jour réinitialisés aux valeurs système par défaut"
            ;;
        "help")
            echo "Usage : $0 [action] [options...]"
            echo "Actions :"
            echo "  policy <nom_politique> [environnement] [bande_passante] [dry_run] - Appliquer une politique de mise à jour"
            echo "  enable - Activer les mises à jour automatiques de l'App Store"
            echo "  disable - Désactiver les mises à jour automatiques de l'App Store"
            echo "  check - Vérifier les mises à jour disponibles"
            echo "  install [nom_mise_à_jour] - Installer les mises à jour (toutes ou spécifique)"
            echo "  status - Afficher la configuration actuelle des mises à jour"
            echo "  compliance [type] - Vérifier la conformité de la flotte"
            echo "  reset - Réinitialiser aux valeurs système par défaut"
            echo "  help - Afficher cette aide"
            echo ""
            echo "Politiques : ${!UPDATE_POLICIES[*]}"
            echo "Plannings : ${!UPDATE_SCHEDULES[*]}"
            echo "Profils Bande Passante : ${!BANDWIDTH_PROFILES[*]}"
            ;;
        *)
            log_action "ERREUR : Action inconnue : $action"
            echo "Utilisez '$0 help' pour les informations d'utilisation"
            exit 1
            ;;
    esac
    
    log_action "=== Gestion des mises à jour de l'App Store terminée ==="
}

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

Sécurité et Conformité des Mises à Jour

Conformité Santé/HIPAA

#!/bin/bash

# Configurer la gestion des mises à jour conforme HIPAA
configure_hipaa_update_compliance() {
    echo "=== Configuration de la Conformité HIPAA des Mises à Jour ==="
    
    # Désactiver les mises à jour automatiques pour le contrôle de conformité
    defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool FALSE
    defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticDownload -bool FALSE
    
    # Activer uniquement les mises à jour de sécurité
    defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist CriticalUpdateInstall -bool TRUE
    
    # Configurer la journalisation d'audit
    setup_update_audit_logging "hipaa"
    
    echo "✓ Conformité HIPAA des mises à jour configurée"
}

configure_hipaa_update_compliance

Conformité Services Financiers

#!/bin/bash

# Configurer la conformité des mises à jour pour les services financiers
configure_financial_update_compliance() {
    echo "=== Configuration de la Conformité des Services Financiers ==="
    
    # Contrôle strict des mises à jour pour la conformité financière
    defaults write /Library/Preferences/com.apple.commerce.plist AutoUpdate -bool FALSE
    defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticDownload -bool FALSE
    defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist AutomaticCheckEnabled -bool TRUE
    
    # Mises à jour de sécurité uniquement avec approbation manuelle
    defaults write /Library/Preferences/com.apple.SoftwareUpdate.plist CriticalUpdateInstall -bool FALSE
    
    echo "✓ Conformité des services financiers configurée"
}

configure_financial_update_compliance

Dépannage et Maintenance

Vérification de l'État du Système de Mise à Jour

#!/bin/bash

# Vérification complète de l'état du système de mise à jour
perform_update_health_check() {
    echo "=== Vérification de l'État du Système de Mise à Jour ==="
    
    # Vérifier le statut du service de mise à jour
    local update_service_status
    update_service_status=$(launchctl list | grep -c "com.apple.softwareupdated" || echo "0")
    echo "Service de Mise à Jour Logicielle : $([ "$update_service_status" -gt 0 ] && echo "En Cours" || echo "Arrêté")"
    
    # Vérifier le cache de mise à jour
    local cache_path="/Library/Updates"
    if [[ -d "$cache_path" ]]; then
        local cache_size=$(du -sh "$cache_path" | cut -f1)
        local cache_files=$(find "$cache_path" -type f | wc -l | tr -d ' ')
        echo "Cache de Mise à Jour : $cache_size ($cache_files fichiers)"
    else
        echo "Cache de Mise à Jour : Non présent"
    fi
    
    # Vérifier les préférences corrompues
    local commerce_plist="/Library/Preferences/com.apple.commerce.plist"
    local softwareupdate_plist="/Library/Preferences/com.apple.SoftwareUpdate.plist"
    
    if plutil -lint "$commerce_plist" &>/dev/null; then
        echo "Préférences Commerce : Valides"
    else
        echo "⚠️ Préférences Commerce : Corrompues ou manquantes"
    fi
    
    if plutil -lint "$softwareupdate_plist" &>/dev/null; then
        echo "Préférences Software Update : Valides"
    else
        echo "⚠️ Préférences Software Update : Corrompues ou manquantes"
    fi
    
    # Vérifier la connectivité réseau pour les mises à jour
    if curl -s --connect-timeout 5 "https://swscan.apple.com/" &>/dev/null; then
        echo "Serveurs de Mise à Jour Apple : Accessibles"
    else
        echo "⚠️ Serveurs de Mise à Jour Apple : Non accessibles"
    fi
}

perform_update_health_check

Notes Importantes

• Privilèges administrateur requis pour les changements de configuration de mise à jour
• Exigences de redémarrage - Certains paramètres prennent effet après redémarrage
• Impact réseau - Considérer l'utilisation de bande passante pour les mises à jour automatiques
• Implications de sécurité - Équilibrer l'automatisation avec le contrôle de sécurité
• Exigences de conformité - Certaines industries nécessitent une approbation manuelle des mises à jour
• Considérations de stockage - Les mises à jour téléchargées consomment de l'espace disque
• Recommandations de test - Tester les politiques de mise à jour sur des appareils de test d'abord
• Importance de surveillance - La vérification régulière de conformité prévient la dérive de politique

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"