Come inviare notifiche con opzioni di snooze e rimozione attraverso PowerShell

Una comunicazione efficiente è una pietra angolare della gestione IT, soprattutto nei servizi gestiti e negli ambienti enterprise. Le notifiche e gli avvisi svolgono un ruolo fondamentale per tenere informati i team e garantire l’affidabilità del sistema. In questo articolo analizzeremo un versatile script PowerShell che consente ai professionisti IT di creare e inviare notifiche toast con opzioni di snooze (sospensione) e rimozione personalizzabili. Questa funzionalità è particolarmente utile per i fornitori di servizi gestiti (MSP) e per i team IT che cercano modi leggeri e facili per trasmettere messaggi critici agli utenti finali.

Contesto

In Windows 10 e oltre, le notifiche toast sono un modo moderno per avvisare gli utenti direttamente all’interno del sistema operativo. Anche se gli strumenti di terze parti possono offrire funzionalità simili, spesso comportano costi di licenza, spese generali inutili o una personalizzazione limitata. Questo script PowerShell offre un’alternativa semplificata e conveniente, consentendo ai professionisti IT di inserire opzioni di snooze e rimozione nelle notifiche in modo personalizzato per le esigenze specifiche.

Gli MSP e gli amministratori IT traggono notevoli vantaggi da questo strumento. Che si tratti di ricordare agli utenti gli aggiornamenti in corso, di notificare loro le interruzioni critiche o di fornire aggiornamenti sullo stato durante la manutenzione del sistema, la possibilità di inviare messaggi utili migliora direttamente l’efficienza operativa e il coinvolgimento degli utenti.

Lo script per inviare notifiche con opzioni di snooze:

#Requires -Version 5.1

<#
.SYNOPSIS
    Sends a toast snooze/dismiss notification to the currently signed in user. Please run as the Current Logged-on User. The script defaults to using NinjaOne's logo if none is provided.
.DESCRIPTION
    Sends a toast snooze/dismiss notification to the currently signed in user. Please run as 'Current Logged on User'.
    This defaults to using NinjaOne's logo in the Toast Message, but you can specify any png formatted image from a url.
    You can also specify the "ApplicationId" to any string. The default is "NinjaOne RMM".

    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".
        PathToImageFile: Downloads a png image for the icon in the toast message/notification.
        SnoozeTimeOptionsInMinutes: Adds a dropdown to the toast message/notification with options for snoozing the message.
.OUTPUTS
    None
.NOTES
    If you want to change the defaults then with in the param block.
    ImagePath uses C:\Users\Public\ as that is accessible by all users.
    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: Renamed script, Updated Script Variables
#>

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

begin {
    $Base64 = 'iVBORw0KGgoAAAANSUhEUgAAAIAAAACACAMAAAD04JH5AAAAJFBMVEUARF0Apc0AmL8ApM0Aos0Aps7///8Am8ia1ug9rtLd8/jw+/2tMDHwAAAABXRSTlMBrBTIcce4nvwAAAIeSURBVHic7dvrcoMgEAXgiOAivv/7Fm+JBpCLwk7bsz86rcNkPw+Y0Gl5vd4lGtbLKSG7vmF18mwQnWpe3YcghP2Z1svU8OtbIOihm8op25M2gWBov9UqYJj/vSRzAGsEkhMglxngWINbdbxLAAAAAAAAAAAAAKAI8Oz2KRtApPWThEyAbT8NZwDZGpeav6sLIKXNMBwAtuGotTGTvTpMRms9qkxEBsDe/dz+A7B3rufeS/utrCKPkAywzfYmK8BeOHY+lBkzBImALfwDgA4XnNLphCTA4e43AKmL9vNMJD8pCQAna20nP5D+SfkQgJyp1qS9PYsEKQDnpVP627WYJCgBmGj+GRmUAFIraSXWBAwDcwJJk1AXMIzcgHgElQHxCGoDohHcBsybgIvPpei70S2A0csuaNkTBRBTbA7uAOb271E0+gWxOSgHfG87yD+wGsCz7fGONNf9iwGTb89DnlkwkUVQCPD2t1sXz9A6gMDT5YsgsggKARljI/vTMkDo7cU3B1USCL+oOwdVAMGF5RlcAxB+tBoBwq/JDlDcAPYEAGgDuPiNBwkgASSABJAAEkACSAAJIAEkgASQABL4JwlcA9w/9N4GTOZcl1OQMTgRoEannhv9O/+PCAAAAAAAAAAAAACAPwhgP+7HeOCR1jOfjBHI9dBrz9W/34/d9jyHLvvPweP2GdCx/3zyvLlAfZ8+l13LktJzAJ+nfgAP50EVLvPsRgAAAABJRU5ErkJggg=='
    [string]$ImagePath = "$($env:SystemDrive)\Users\Public\PowerShellToastSnoozeImage.png"

    # 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 ($env:pathToImageFile -and $env:pathToImageFile -notlike "null") { $PathToImageFile = $env:pathToImageFile }
    if ($env:snoozeTimeOptionsInMinutes -and $env:snoozeTimeOptionsInMinutes -notlike "null") { $SnoozeTimeOptionsInMinutes = $env:snoozeTimeOptionsInMinutes }

    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 82) {
        Write-Host "[Warn] The Title is longer than 82 characters. The title will be truncated by the Windows API to 82 characters."
    }
    if ($Message.Length -gt 160) {
        Write-Host "[Warn] The Message is longer than 160 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 ConvertFrom-Base64 {
        param(
            $Base64,
            $Path
        )
        $bytes = [Convert]::FromBase64String($Base64)

        $ErrorActionPreference = [System.Management.Automation.ActionPreference]::SilentlyContinue
        [IO.File]::WriteAllBytes($Path, $bytes)
        $ErrorActionPreference = [System.Management.Automation.ActionPreference]::Continue
    }

    # Utility function for downloading files.
    function Invoke-Download {
        param(
            [Parameter()]
            [String]$URL,
            [Parameter()]
            [String]$Path,
            [Parameter()]
            [int]$Attempts = 3,
            [Parameter()]
            [Switch]$SkipSleep
        )
        Write-Host "[Info] Used $PathToImageFile for the image and saving to $ImagePath"

        $SupportedTLSversions = [enum]::GetValues('Net.SecurityProtocolType')
        if ( ($SupportedTLSversions -contains 'Tls13') -and ($SupportedTLSversions -contains 'Tls12') ) {
            [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.ServicePointManager]::SecurityProtocol::Tls13 -bor [System.Net.SecurityProtocolType]::Tls12
        }
        elseif ( $SupportedTLSversions -contains 'Tls12' ) {
            [System.Net.ServicePointManager]::SecurityProtocol = [System.Net.SecurityProtocolType]::Tls12
        }
        else {
            # Not everything requires TLS 1.2, but we'll try anyways.
            Write-Host "[Warn] TLS 1.2 and or TLS 1.3 isn't supported on this system. This download may fail!"
            if ($PSVersionTable.PSVersion.Major -lt 3) {
                Write-Host "[Warn] PowerShell 2 / .NET 2.0 doesn't support TLS 1.2."
            }
        }

        $i = 1
        While ($i -le $Attempts) {
            # Some cloud services have rate-limiting
            if (-not ($SkipSleep)) {
                $SleepTime = Get-Random -Minimum 1 -Maximum 7
                Write-Host "[Info] Waiting for $SleepTime seconds."
                Start-Sleep -Seconds $SleepTime
            }
            if ($i -ne 1) { Write-Host "" }
            Write-Host "[Info] Download Attempt $i"

            $PreviousProgressPreference = $ProgressPreference
            $ProgressPreference = 'SilentlyContinue'
            try {
                # Invoke-WebRequest is preferred because it supports links that redirect, e.g., https://t.ly
                # Standard options
                $WebRequestArgs = @{
                    Uri                = $URL
                    MaximumRedirection = 10
                    UseBasicParsing    = $true
                    OutFile            = $Path
                }

                # Download The File
                Invoke-WebRequest @WebRequestArgs

                $ProgressPreference = $PreviousProgressPreference
                $File = Test-Path -Path $Path -ErrorAction SilentlyContinue
            }
            catch {
                Write-Host "[Error] An error has occurred while downloading!"
                Write-Warning $_.Exception.Message

                if (Test-Path -Path $Path -ErrorAction SilentlyContinue) {
                    Remove-Item $Path -Force -Confirm:$false -ErrorAction SilentlyContinue
                }

                $File = $False
            }

            if ($File) {
                $i = $Attempts
            }
            else {
                Write-Host "[Error] File failed to download."
                Write-Host ""
            }

            $i++
        }

        if (-not (Test-Path $Path)) {
            Write-Host "[Error] Failed to download file!"
            exit 1
        }
        else {
            return $Path
        }
    }

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

        # 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 the xml for the snooze options
        $IsFirst = $true
        if ($($SnoozeOptions -split ',').Count -gt 5) {
            Write-Host "[Error] Too many snooze options provided. Maximum is 5."
            exit 1
        }
        $SnoozeXml = $SnoozeOptions -split ',' | ForEach-Object {
            # Trim whitespace
            $Option = "$_".Trim()
            if ($IsFirst) {
                # Add the input and default selection
                "<input id='snoozeTime' type='selection' defaultInput='$Option'>"
                $IsFirst = $false
            }
            # Check if the option is a number
            if ([int]::TryParse($Option, [ref]$null)) {
                # Convert the number to an integer
                $Option = [int]$Option
            }
            else {
                # If not a number, exit with an error
                Write-Host "[Error] Invalid snooze time option '$Option' provided."
                exit 1
            }
            # Add the selection
            if ($Option -ge 60) {
                # Get the number of hours and minutes
                # Round the number of hours to the nearest hour
                $Hours = [math]::Round($Option / 60, 0)
                # Get the number of minutes
                $MinutesMod = $Option % 60
                # Format the number of minutes
                $Minutes = if ($MinutesMod -eq 0) {
                    # If the number of minutes is 0, don't display anything
                    ""
                }
                elseif ($MinutesMod -gt 1) {
                    # If the number of minutes is greater than 1, format it as ' 2 Minutes'
                    " $MinutesMod Minutes"
                }
                elseif ($MinutesMod -eq 1) {
                    # If the number of minutes is 1, format it as ' 1 Minute'
                    " $MinutesMod Minute"
                }
                # Format the number of hours
                $Unit = if ($Hours -gt 1) { 'Hours' }else { 'Hour' }
                "<selection id='$($Option)' content='$($Hours) $($Unit)$($Minutes)'/>"
            }
            elseif ($Option -lt 60) {
                # Format the number of minutes when it's less than 60 minutes
                $Minutes = $Option
                $Unit = if ($Minutes -gt 1) { 'Minutes' }else { 'Minute' }
                "<selection id='$($Option)' content='$($Minutes) $($Unit)'/>"
            }
        }

        # Create a new toast notification
        $RawXml = [xml] @"
<toast>
    <visual>
        <binding template='ToastGeneric'>
            <image placement='appLogoOverride' src='$ImagePath'/>
            <text id='1'>$ToastTitle</text>
            <text id='2'>$ToastText</text>
        </binding>
    </visual>
    <actions>
        $SnoozeXml
        </input>
        <action activationType="system" arguments="snooze" hint-inputId="snoozeTime" content="" />
        <action activationType="system" arguments="dismiss" content=""/>
    </actions>
</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"

        # Show our message to the user
        $ToastNotifier.Show($Toast)
    }
}
process {
    Write-Host "ApplicationID: $ApplicationId"

    if (-not $(Split-Path -Path $ImagePath -Parent | Test-Path -ErrorAction SilentlyContinue)) {
        try {
            New-Item "$(Split-Path -Path $ImagePath -Parent)" -ItemType Directory -ErrorAction Stop
            Write-Host "[Info] Created folder: $(Split-Path -Path $ImagePath -Parent)"
        }
        catch {
            Write-Host "[Error] Failed to create folder: $(Split-Path -Path $ImagePath -Parent)"
            exit 1
        }
    }

    $DownloadArguments = @{
        URL  = $PathToImageFile
        Path = $ImagePath
    }

    Set-RegKey -Path "HKCU:\SOFTWARE\Classes\AppUserModelId\$($ApplicationId -replace '\s+','.')" -Name "DisplayName" -Value $ApplicationId -PropertyType String
    if ($PathToImageFile -like "http*") {
        Invoke-Download @DownloadArguments
    }
    elseif ($PathToImageFile -match "^[a-zA-Z]:\\" -and $(Test-Path -Path $PathToImageFile -ErrorAction SilentlyContinue)) {
        Write-Host "[Info] Image is a local file, copying to $ImagePath"
        Copy-Item -Path $PathToImageFile -Destination $ImagePath
    }
    elseif ($PathToImageFile -match "^[a-zA-Z]:\\" -and -not $(Test-Path -Path $PathToImageFile -ErrorAction SilentlyContinue)) {
        Write-Host "[Error] Image does not exist at $PathToImageFile"
        exit 1
    }
    else {
        Write-Host "[Info] No image given, converting base64 on line 43 and saving to $ImagePath."
        Write-Host "[Info] Image will be used for the toast message."
        ConvertFrom-Base64 -Base64 $Base64 -Path $ImagePath
    }

    Set-RegKey -Path "HKCU:\SOFTWARE\Classes\AppUserModelId\$($ApplicationId -replace '\s+','.')" -Name "IconUri" -Value "$ImagePath" -PropertyType String

    Write-Host "[Info] System is ready to send Toast Messages to the currently logged on user."

    try {
        Write-Host "[Info] Attempting to send message to user..."
        $NotificationParams = @{
            ToastTitle    = $Title
            ToastText     = $Message
            ApplicationId = "$($ApplicationId -replace '\s+','.')"
            SnoozeOptions = $SnoozeTimeOptionsInMinutes
        }
        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 {
    
    
    
}

 

Analisi dettagliata

Lo script PowerShell per inviare notifiche con opzioni di snooze fornito comprende diversi componenti chiave progettati per garantire flessibilità e funzionalità. Ecco una spiegazione passo per passo di come funziona:

1. Inizializzazione e parametri

• Lo script per inviare notifiche con opzioni di snooze accetta parametri per il titolo della notifica, il messaggio, l’ID dell’applicazione, le opzioni di snooze (sospensione) e un percorso opzionale del file immagine.
• Convalida l’input e imposta i valori predefiniti quando i parametri non sono forniti. Per esempio, l’ApplicationId predefinito è “NinjaOne RMM”, per garantire la coerenza dell’identificazione nel centro notifiche di Windows.

2. Convalida dell’utente

• Lo script per inviare notifiche con opzioni di snooze controlla se viene eseguito come “Utente correntemente connesso”. In questo modo si garantisce che le notifiche raggiungano il destinatario previsto, anziché essere eseguite in un contesto di sistema elevato in cui le notifiche toast non sono supportate.

3. Configurazione del registro

• Utilizzando la funzione Set-RegKey, lo script crea o aggiorna le voci di registro per registrare l’ID dell’applicazione toast e associare un’icona alla notifica.

4. Gestione delle immagini

Le notifiche possono includere un’immagine personalizzata. Lo script per inviare notifiche con opzioni di snooze supporta tre scenari:

• Un URL per scaricare un’immagine.
• Un percorso di file locale da copiare.
• Un logo NinjaOne predefinito codificato in base64, convertito e salvato come file immagine se non viene fornita un’immagine personalizzata.

5. Generazione di notifiche XML

• Lo script per inviare notifiche con opzioni di snooze genera un codice XML che definisce la struttura del messaggio di toast, compresi titolo, testo, immagine e opzioni di snooze. La funzione Mostra notifica utilizza l’API di Windows Runtime per visualizzare la notifica del toast.

6. Funzionalità di snooze (sospensione) e rimozione

• Gli utenti possono sospendere le notifiche per un periodo di tempo preconfigurato o eliminarle del tutto. Queste opzioni sono definite nell’XML e consentono all’utente di interagire direttamente dalla notifica.

Casi d’uso potenziali

Caso di studio: notifiche di aggiornamento del sistema

Immagina che un amministratore IT in un ambiente aziendale stia pianificando di distribuire un aggiornamento critico del sistema durante la notte. Per assicurarsi che gli utenti siano informati, utilizza questo script per inviare una notifica toast intitolata “Notifica di manutenzione del sistema” con il messaggio “Il sistema si riavvierà alle 2:00 del mattino per aggiornamenti. Clicca per sospendere o per rimuovere.”

• Personalizzazione: La notifica include il logo dell’organizzazione.
• Opzioni di snooze: Gli utenti possono ritardare il promemoria di 15, 30 o 60 minuti.
• Risultato: Il team si assicura che gli utenti siano ben informati senza dover ricorrere a controlli manuali.

Confronti

Metodi alternativi:

1. Strumenti di notifica di terze parti: Pur essendo affidabili, possono mancare di capacità di integrazione e comportare costi.
2. Notifiche tramite i criteri di gruppo di Windows: Personalizzazione limitata e nessuna funzione di snooze.

Rispetto a questi metodi, questo script PowerShell per inviare notifiche con opzioni di snooze offre:

• Maggiore personalizzazione grazie al supporto delle immagini.
• Esperienza utente migliorata con le opzioni di snooze e di rimozione.
• Efficienza dei costi, sfruttando le API native di Windows.

Domande frequenti

D: Lo script per inviare notifiche con opzioni di snooze può essere eseguito come amministratore?

No, per visualizzare correttamente le notifiche deve essere eseguito come utente attualmente connesso.

D: Cosa succede se non viene fornita alcuna immagine?

Viene utilizzato il logo predefinito di NinjaOne, per garantire che ogni notifica abbia il suo marchio.

D: Come sono configurate le opzioni di snooze?

I tempi di sospensione sono definiti come un elenco separato da virgole (per esempio, “15,30,60” per 15, 30 e 60 minuti).

D: È compatibile con le edizioni di Windows IoT?

No, a causa della mancanza di una shell nelle edizioni IoT.

Implicazioni

Grazie a questo script per inviare notifiche con opzioni di snooze, i team IT possono standardizzare l’invio delle notifiche, assicurandosi che i messaggi siano efficaci e pertinenti. Negli ambienti più grandi, questo migliora la consapevolezza degli utenti e riduce i tempi di inattività causati da avvisi mancati. Inoltre, le opzioni di personalizzazione aiutano gli MSP a rafforzare la propria identità mantenendo la professionalità.

Raccomandazioni

• Testa in un ambiente non di produzione: Convalida il comportamento dello script per inviare notifiche con opzioni di snooze in un ambiente controllato prima di distribuirlo ampiamente.
• Personalizza gli ID delle applicazioni: Utilizza identificatori specifici per l’organizzazione per una migliore gestione e visibilità.
• Monitora i feedback degli utenti: Raccogli input per perfezionare le opzioni di snooze e il contenuto delle notifiche per ottenere il massimo coinvolgimento degli utenti.

Considerazioni finali

Questo script per inviare notifiche con opzioni di snooze è un esempio del modo in cui NinjaOne e altre soluzioni di gestione IT simili possono potenziare il lavoro dei professionisti IT. Combinando semplicità e personalizzazione avanzata, lo script consente una comunicazione efficiente e migliora l’esperienza dell’utente. Che tu sia un MSP o faccia parte di un team IT interno, l’utilizzo di strumenti come questo ti permetterà di allinearti con le best practice per la gestione delle operazioni IT.

Per soluzioni più personalizzate, NinjaOne offre una suite di strumenti progettati per semplificare i flussi di lavoro IT e ottimizzare l’affidabilità del sistema.