Rationaliser les notifications toast importantes à l’aide d’un script PowerShell 

Introduction

Une communication efficace avec les utilisateurs finaux est la clé de vopute des opérations informatiques, en particulier pour les fournisseurs de services gérés (MSP) et les professionnels de l’informatique qui gèrent des environnements à grande échelle. S’assurer que les messages critiques sont vus rapidement peut faire la différence entre une résolution sans faille et des opérations perturbées. Ce script PowerShell offre un moyen efficace d’envoyer des notifications toast importantes directement à l’utilisateur connecté sur un système Windows.

Contexte

Les notifications toast sont devenues un élément essentiel des flux de travail informatiques modernes, car elles constituent un moyen non intrusif mais immédiat de communiquer des informations. Qu’il s’agisse d’alerter les utilisateurs sur une mise à jour critique, un changement de politique de sécurité ou une fenêtre de maintenance imminente, ces notifications assurent la visibilité sans interrompre le flux de travail. Les approches traditionnelles font souvent appel à des e-mails en masse ou à des fenêtres contextuelles, qui sont soit trop dérangeants, soit faciles à ignorer. Ce script répond à ces limitations en tirant parti du système de notification natif de Windows pour envoyer des messages ciblés et personnalisables.

Le script :

#Requires -Version 5.1

<#
.SYNOPSIS
    Sends an important toast notification to the currently signed in user. Please run as the Current Logged-on User.
.DESCRIPTION
    Sends an important toast notification to the currently signed in user. Please run as 'Current Logged on User'.
    You can also specify the "ApplicationId" to any string.
    The default ApplicationId is your company name found in the NINJA_COMPANY_NAME environment variable, but will fallback to "NinjaOne RMM" if it happens to not be set.

    By using this script, you indicate your acceptance of the following legal terms as well as our Terms of Use at https://www.ninjaone.com/terms-of-use.
    Ownership Rights: NinjaOne owns and will continue to own all right, title, and interest in and to the script (including the copyright). NinjaOne is giving you a limited license to use the script in accordance with these legal terms. 
    Use Limitation: You may only use the script for your legitimate personal or internal business purposes, and you may not share the script with another party. 
    Republication Prohibition: Under no circumstances are you permitted to re-publish the script in any script library or website belonging to or under the control of any other software provider. 
    Warranty Disclaimer: The script is provided “as is” and “as available”, without warranty of any kind. NinjaOne makes no promise or guarantee that the script will be free from defects or that it will meet your specific needs or expectations. 
    Assumption of Risk: Your use of the script is at your own risk. You acknowledge that there are certain inherent risks in using the script, and you understand and assume each of those risks. 
    Waiver and Release: You will not hold NinjaOne responsible for any adverse or unintended consequences resulting from your use of the script, and you waive any legal or equitable rights or remedies you may have against NinjaOne relating to your use of the script. 
    EULA: If you are a NinjaOne customer, your use of the script is subject to the End User License Agreement applicable to you (EULA).

.EXAMPLE
    -Title "My Title Here" -Message "My Message Here"
    Sends the title "My Title Here" and message "My Message Here" as a Toast message/notification to the currently signed in user.
.EXAMPLE
    -Title "My Title Here" -Message "My Message Here" -ApplicationId "MyCompany"
    Sends the title "My Title Here" and message "My Message Here" as a Toast message/notification to the currently signed in user.
        ApplicationId: Creates a registry entry for your toasts called "MyCompany".
.OUTPUTS
    None
.NOTES
    If you want to change the defaults then with in the param block.
    If you want to customize the application name to show your company name,
        then look for $ApplicationId and change the content between the double quotes.

    Minimum OS Architecture Supported: Windows 10 (IoT editions are not supported due to lack of shell)
    Release Notes: Initial Release
#>

[CmdletBinding()]
param
(
    [string]$Title,
    [string]$Message,
    [string]$ApplicationId
)

begin {
    # Set the default ApplicationId if it's not provided. Use the Company Name if available, otherwise use the default.
    $ApplicationId = if ($env:NINJA_COMPANY_NAME) { $env:NINJA_COMPANY_NAME } else { "NinjaOne RMM" }

    Write-Host "[Info] Using ApplicationId: $($ApplicationId -replace '\s+','.')"

    if ($env:title -and $env:title -notlike "null") { $Title = $env:title }
    if ($env:message -and $env:message -notlike "null") { $Message = $env:message }
    if ($env:applicationId -and $env:applicationId -notlike "null") { $ApplicationId = $env:applicationId }

    if ([String]::IsNullOrWhiteSpace($Title)) {
        Write-Host "[Error] A Title is required."
        exit 1
    }
    if ([String]::IsNullOrWhiteSpace($Message)) {
        Write-Host "[Error] A Message is required."
        exit 1
    }

    if ($Title.Length -gt 42) {
        Write-Host "[Warn] The Title is longer than 42 characters. The title will be truncated by the Windows API to 42 characters."
    }
    if ($Message.Length -gt 254) {
        Write-Host "[Warn] The Message is longer than 254 characters. The message might get truncated by the Windows API."
    }

    function Test-IsSystem {
        $id = [System.Security.Principal.WindowsIdentity]::GetCurrent()
        return $id.Name -like "NT AUTHORITY*" -or $id.IsSystem
    }

    if (Test-IsSystem) {
        Write-Host "[Error] Please run this script as 'Current Logged on User'."
        Exit 1
    }

    function Set-RegKey {
        param (
            $Path,
            $Name,
            $Value,
            [ValidateSet("DWord", "QWord", "String", "ExpandedString", "Binary", "MultiString", "Unknown")]
            $PropertyType = "DWord"
        )
        if (-not $(Test-Path -Path $Path)) {
            # Check if path does not exist and create the path
            New-Item -Path $Path -Force | Out-Null
        }
        if ((Get-ItemProperty -Path $Path -Name $Name -ErrorAction Ignore)) {
            # Update property and print out what it was changed from and changed to
            $CurrentValue = (Get-ItemProperty -Path $Path -Name $Name -ErrorAction Ignore).$Name
            try {
                Set-ItemProperty -Path $Path -Name $Name -Value $Value -Force -Confirm:$false -ErrorAction Stop | Out-Null
            }
            catch {
                Write-Host "[Error] Unable to Set registry key for $Name please see below error!"
                Write-Host "$($_.Exception.Message)"
                exit 1
            }
            Write-Host "[Info] $Path\$Name changed from:"
            Write-Host " $CurrentValue to:"
            Write-Host " $($(Get-ItemProperty -Path $Path -Name $Name -ErrorAction Ignore).$Name)"
        }
        else {
            # Create property with value
            try {
                New-ItemProperty -Path $Path -Name $Name -Value $Value -PropertyType $PropertyType -Force -Confirm:$false -ErrorAction Stop | Out-Null
            }
            catch {
                Write-Host "[Error] Unable to Set registry key for $Name please see below error!"
                Write-Host "$($_.Exception.Message)"
                exit 1
            }
            Write-Host "[Info] Set $Path\$Name to:"
            Write-Host " $($(Get-ItemProperty -Path $Path -Name $Name -ErrorAction Ignore).$Name)"
        }
    }

    function Show-Notification {
        [CmdletBinding()]
        Param (
            [string]
            $ApplicationId,
            [string]
            $ToastTitle,
            [string]
            [Parameter(ValueFromPipeline)]
            $ToastText
        )

        # Import all the needed libraries
        [Windows.UI.Notifications.ToastNotificationManager, Windows.UI.Notifications, ContentType = WindowsRuntime] > $null
        [Windows.UI.Notifications.ToastNotification, Windows.UI.Notifications, ContentType = WindowsRuntime] > $null
        [Windows.System.User, Windows.System, ContentType = WindowsRuntime] > $null
        [Windows.System.UserType, Windows.System, ContentType = WindowsRuntime] > $null
        [Windows.System.UserAuthenticationStatus, Windows.System, ContentType = WindowsRuntime] > $null
        [Windows.Storage.ApplicationData, Windows.Storage, ContentType = WindowsRuntime] > $null

        # Make sure that we can use the toast manager, also checks if the service is running and responding
        try {
            $ToastNotifier = [Windows.UI.Notifications.ToastNotificationManager]::CreateToastNotifier("$ApplicationId")
        }
        catch {
            Write-Host "$($_.Exception.Message)"
            Write-Host "[Error] Failed to create notification."
        }

        # Create a new toast notification
        $RawXml = [xml] @"
<toast scenario='urgent'>
    <visual>
    <binding template='ToastGeneric'>
        <text hint-maxLines='1'>$ToastTitle</text>
        <text>$ToastText</text>
    </binding>
    </visual>
</toast>
"@

        # Serialized Xml for later consumption
        $SerializedXml = New-Object Windows.Data.Xml.Dom.XmlDocument
        $SerializedXml.LoadXml($RawXml.OuterXml)

        # Setup how are toast will act, such as expiration time
        $Toast = $null
        $Toast = [Windows.UI.Notifications.ToastNotification]::new($SerializedXml)
        $Toast.Tag = "PowerShell"
        $Toast.Group = "PowerShell"
        $Toast.ExpirationTime = [DateTimeOffset]::Now.AddMinutes(1)

        # Show our message to the user
        $ToastNotifier.Show($Toast)
    }
}
process {
    # Create an object to store the ApplicationId and DisplayName
    $Application = [PSCustomObject]@{
        DisplayName = $ApplicationId
        # Replace any spaces with a period in the ApplicationId
        AppId       = $($ApplicationId -replace '\s+', '.')
    }
    Write-Host "Display Name: $($Application.DisplayName)"
    Write-Host "Application ID: $($Application.AppId)"

    Set-RegKey -Path "HKCU:\SOFTWARE\Classes\AppUserModelId\$($Application.AppId)" -Name "DisplayName" -Value $Application.DisplayName -PropertyType String
    Set-RegKey -Path "HKCU:\Software\Microsoft\Windows\CurrentVersion\Notifications\Settings\$($Application.AppId)" -Name "AllowUrgentNotifications" -Value 1 -PropertyType DWord

    try {
        Write-Host "[Info] Attempting to send message to user..."
        $NotificationParams = @{
            ToastTitle    = $Title
            ToastText     = $Message
            ApplicationId = $Application.AppId
        }
        Show-Notification @NotificationParams -ErrorAction Stop
        Write-Host "[Info] Message sent to user."
    }
    catch {
        Write-Host "[Error] Failed to send message to user."
        Write-Host "$($_.Exception.Message)"
        exit 1
    }
    exit 0
}
end {
    
    
    
}

 

Description détaillée

Ce script est conçu pour envoyer des notifications toasts urgentes à l’utilisateur actuellement connecté. Voici une description étape par étape :

1. Définition des paramètres par défaut de l’application 

Le script vérifie la présence d’une variable d’environnement NINJA_COMPANY_NAME pour définir l’ApplicationId par défaut. S’il n’est pas disponible, il revient à “NinjaOne RMM” Cette flexibilité permet aux prestataires de services de gestion des marques de notifier leurs clients.

2. Entrées de paramètres 

Le script accepte trois paramètres clés :

a. Titre : le titre de la notification.

b. Message : le corps du texte de la notification.

c. ApplicationId : Un identifiant facultatif pour le marquage ou le suivi.

3. Validation des entrées

Il valide les entrées pour s’assurer que le titre et le message ne sont pas vides. Si les longueurs dépassent les limites de l’API Windows (42 caractères pour le titre et 254 pour le message), des avertissements s’affichent.

4. Vérification du système

Le script comprend une sauvegarde pour s’assurer qu’il est exécuté par l’utilisateur connecté et non en tant que processus au niveau du système, ce qui empêcherait l’affichage des notifications.

5. Configuration du registre

Des entrées de registre personnalisées sont créées pour le nom d’affichage de la notification et pour activer les notifications urgentes. Ces modifications garantissent un bon fonctionnement et une bonne expérience de l’utilisateur.

6. Création d’une notification

En s’appuyant sur l’API Windows UI Notifications, le script construit et affiche une notification toast. Le message est étiqueté et regroupé pour une meilleure traçabilité.

7. Gestion des erreurs

La gestion complète des erreurs garantit que les problèmes de configuration ou d’exécution sont enregistrés, ce qui facilite la résolution des problèmes.

Cas d’utilisation potentiels

Étude de cas : Alerte informatique en cas de période d’inactivité programmée

Imaginez une entreprise MSP qui gère l’infrastructure informatique d’une entreprise de taille moyenne. L’équipe informatique prévoit d’effectuer une maintenance du système en demandant aux utilisateurs de sauvegarder leur travail avant une période d’inactivité programmée. À l’aide de ce script, elle envoie une notification toast intitulée “Alerte de maintenance programmée” avec le message suivant : “Veuillez sauvegarder votre travail. La maintenance commence à 20 heures”

Cette approche permet de s’assurer que les utilisateurs sont informés immédiatement, sans se base sur un e-mail, qui risque de ne pas être lu à temps.

Comparaisons

Par rapport aux méthodes de notification traditionnelles :

• E-mails : Dépendent des utilisateurs qui consultent leur boîte de réception, ce qui peut retarder des actions critiques.
• Pop-Ups : Souvent perçus comme intrusifs et rapidement rejetés.
• Ce script : Propose un compromis idéal : notifications urgentes, visibles, mais non perturbatrices, tirant parti de l’écosystème Windows.

FAQ

Q : Ce script peut-il fonctionner sous Windows 7 ?

Non, le système d’exploitation minimum pris en charge est Windows 10, car il s’appuie sur des API de notification modernes.

Q : Que se passe-t-il si le script est exécuté en tant que SYSTEM ?

Le script détecte et empêche l’exécution dans un contexte système, exigeant qu’il soit exécuté par l’utilisateur connecté.

Q : La notification est-elle persistante ?

Non, la notification toast expire au bout d’une minute, sauf si l’utilisateur l’interrompt plus tôt.

Q : L’identifiant de l’application peut-il être personnalisé ?

Oui, soit via le paramètre ApplicationId, soit en modifiant la valeur par défaut dans le script.

Implications

L’utilisation de ce script améliore la communication informatique en garantissant que les notifications critiques sont vues rapidement. Toutefois, une utilisation excessive des notifications urgentes pourrait entraîner une “lassitude face aux alertes”, réduisant ainsi leur efficacité. Les équipes informatiques doivent utiliser cet outil de manière judicieuse pour maintenir son impact.

Recommandations

• Test : testez toujours le script dans un environnement de non-production pour confirmer sa fonctionnalité.
• Expérience utilisateur : évitez les titres et les messages trop longs : veillez à ce qu’ils soient concis et exploitables.
• Image de marque : utilisez un identifiant d’application significatif pour créer un climat de confiance et de reconnaissance parmi les utilisateurs.
• Sécurité : limitez l’accès aux scripts au personnel autorisé afin d’éviter toute utilisation abusive.

Conclusion

Ce script PowerShell est un complément puissant à la boîte à outils d’un professionnel de l’informatique, offrant des capacités de notification précises, personnalisables et efficaces. Pour les MSP et les équipes informatiques utilisant NinjaOne, l’intégration de ce script dans des flux de travail plus larges s’aligne sur l’accent mis par la plateforme sur une gestion informatique rationalisée et proactive.