# Define the MSP name [string]$Global:MSPName = "Emberkom" # This section will define several global variables that can be used in scripts that source this one [string]$Global:RootDirectory [string]$Global:ScriptsDirectory [string]$Global:OutputDirectory [string]$Global:ToolsDirectory [string]$Global:LogsDirectory [string]$Global:LogFile # Define the root path for the MSP in the Windows Registry [string]$Global:MSPRegistryRoot = "HKEY_LOCAL_MACHINE\SOFTWARE\${MSPName}" # Create a global variable to keep a ticket and billing related variables if they are needed later $Global:TicketNumber = $null $Global:TimeAttributedToUser = "" # Setup the MSP management directories Function Setup-MSPDirectories { If ( Test-Path ${Env:ProgramData} ) { $Global:RootDirectory = "${Env:ProgramData}\${MSPName}" } Else { $Global:RootDirectory = "${Env:SystemDrive}\${MSPName}" } $Global:ScriptsDirectory = "${RootDirectory}\Scripts" $Global:OutputDirectory = "${RootDirectory}\Output" $Global:ToolsDirectory = "${RootDirectory}\Tools" $Global:LogsDirectory = "${RootDirectory}\Logs" # Make sure all the management directories exist $RootDirectory, $ScriptsDirectory, $OutputDirectory, $ToolsDirectory, $LogsDirectory | ForEach-Object { If ( !(Test-Path $_) ) { Try { New-Item -Path $_ -ItemType Directory -Force -ErrorAction SilentlyContinue | Out-Null } Catch { Write-Output $_.Exception.Message } } } } # Function to get a datestamp for right now in a long format Function Get-LongDateTime { Return $(Get-Date -Format "yyyyMMddHHmmssffff") } # Function to get a datestanp for the current day Function Get-LongDate { Return $(Get-Date -Format "yyyyMMdd") } # Setup the log file for messages generated when this script is run Function Setup-LogFile { $LogFilePrefix = "ManagementScript" $LogFilePostfix = Get-LongDateTime $Global:LogFile = "${LogsDirectory}\${LogFilePrefix}_${LogFilePostfix}.log" # Delete log files older than 120 days $LogFileAllowedAge = (Get-Date).AddDays(-120) Try { Get-ChildItem -Path "${LogsDirectory}\${LogFilePrefix}_*.*" -Filter '*.log' | ` Where-Object {$_.LastWriteTime -lt $LogFileAllowedAge} | ` Remove-Item -Force -ErrorAction SilentlyContinue | Out-Null } Catch { Write-Output $_.Exception.Message } Try { If ( !(Test-Path $LogFile) ) { New-Item -Path $LogFile -ItemType File -Force | Out-Null } } Catch { Write-Output $_.Exception.Message } } # Log a message to the log file # IMPORTANT: In Powershell 'echo' is an alias for Write-Output, which is overriden when this Tools.ps1 file is called before your script. # To prevent unwanted behavior, if you need to echo something do the following instead: # Start-Process "cmd.exe" -ArgumentList '/C echo y | some-command' Function Write-Output { param([Parameter(Mandatory=$true,ValueFromPipeline=$true)][string]$Message) Add-Content -Path $Global:LogFile -Value "$(Get-Date -Format "yyyy-MM-dd HH:mm:ss") - ${Message}" Microsoft.Powershell.Utility\Write-Output $Message } # Log an error to the log file Function Write-Error { param([Parameter(Mandatory=$true,ValueFromPipeline=$true)][string]$Message) Add-Content -Path $Global:LogFile -Value "$(Get-Date -Format "yyyy-MM-dd HH:mm:ss") - Error: ${Message}" Microsoft.Powershell.Utility\Write-Error $Message } # Function to determine if the current user context is an Administrator Function IsAdmin { If ( ([Security.Principal.WindowsPrincipal][Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole([Security.Principal.WindowsBuiltInRole]::Administrator) ) { Return $true } Else { Return $false } } # Run a script from the live repo or from a local path Function Run-Script { param( # Parameters for live-ps scripts [Parameter(Mandatory=$false,ParameterSetName='live-ps')] [string]$Type='management-scripts', [Parameter(Mandatory=$true,ParameterSetName='live-ps')] [string]$LivePSScript, # Parameters for local scripts [Parameter(Mandatory=$true,ParameterSetName='local')] [string]$Path, ### $NoWait will prevent waiting for the specified script to finish running [Parameter(Mandatory=$false,ParameterSetName='local')] [switch]$NoWait=$false, # Parameters for all scripts [Parameter(Mandatory=$false,ParameterSetName='live-ps')] [Parameter(Mandatory=$false,ParameterSetName='local')] [string]$Arguments='null', ### $HaltIfRunning is a collection of app names which, if running, will prevent the script from running [Parameter(Mandatory=$false,ParameterSetName='live-ps')] [Parameter(Mandatory=$false,ParameterSetName='local')] [string[]]$HaltIfRunning='null', ### $ForceClose will forcefully close all apps specified in $HaltIfRunning [Parameter(Mandatory=$false,ParameterSetName='live-ps')] [Parameter(Mandatory=$false,ParameterSetName='local')] [switch]$ForceClose=$false ) If ( $Arguments -eq "null" ) { $Arguments = $null } If ( $HaltIfRunning -eq "null" ) { $HaltIfRunning = $null } If ( $LivePSScript ) { $URL = "https://dev.emberkom.com/emberkom/${Type}/raw/branch/master/${LivePSScript}.ps1" If ( !(IsURLValid -URL $URL) ) { Write-Output "The specified script does not exist: ${LivePSScript}" ; Exit } } If ( $Path ) { If ( !(Test-Path $Path) ) { Write-Output "The specified script does not exist: ""${Path}""" ; Exit } } If ( ($null -ne $HaltIfRunning ) -and ($ForceClose) -and ( !(IsAdmin) ) ) { Write-Output "Cannot close dependent apps because this task does not have administrative privileges" ; Exit } If ( $HaltIfRunning ) { $Halt = $false Write-Output "Checking for running instances of the following dependent apps:" ForEach ( $name in $HaltIfRunning) { $RunningInstances = Get-Process | Where-Object { $_.Name -like "${name}" } If ( $RunningInstances ) { If ( $ForceClose -eq $true ) { Try { $name | Stop-Process -Force ; Write-Output " ""${name}"" (force closed)" } Catch { Write-Error $_.Exception.Message ; Exit } } Else { $Halt = $true ; Write-Output " ""${name}"" (running)" } } Else { Write-Output " ""${name}"" (not running)" } } If ( $Halt -eq $true ) { Write-Output "Dependent apps are currently in use and are preventing the specified script from running" ; Exit } } switch ($PSCmdlet.ParameterSetName) { 'live-ps' { Write-Output "Retrieving : ${LivePSScript}.ps1" If ( $null -eq $Arguments ) { $ScriptFile = Download-File -URL $URL Write-Output "Sourcing: ${LivePSScript}.ps1" . $ScriptFile If ( Test-Path $ScriptFile ) { Remove-Item $ScriptFile -Force -ErrorAction SilentlyContinue } } Else { Try { $ScriptBlock = [Scriptblock]::Create((New-Object Net.WebClient).DownloadString($URL)) } Catch { Write-Error $_.Exception.Message ; Exit } Write-Output "Executing: ${LivePSScript}.ps1 ${Arguments}" Try { Invoke-Command -ScriptBlock $ScriptBlock -ArgumentList $Arguments } Catch { Write-Error $_.Exception.Message ; Exit } } } 'local' { Write-Output "Executing: ${Path} ${Arguments}" If ( $NoWait ) { Try { Start-Process "${Path}" -ArgumentList "{$Arguments}" } Catch { Write-Error $_.Exception.Message } } Else { Write-Output " Waiting for script to finish..." Try { Start-Process "${Path}" -ArgumentList "{$Arguments}" -Wait } Catch { Write-Error $_.Exception.Message } Write-Output " Finished" } } } } # Return a Powershell version object from a string Function Get-Version { param([Parameter(Mandatory=$true)][string]$Version) [int]$Sets = 4 $VersionArray = $Version.Split('.') If ( $VersionArray.Count -le $Sets ) { $Sets = $VersionArray.Count } For ($i = 0; $i -le ($Sets - 1); $i++) { $Return = '{0}.{1}' -f $Return, $VersionArray[$i] } Return [version]$Return.Trim('.') } # Determines whether a URL is valid Function IsURLValid { param([Parameter(Mandatory=$true,ValueFromPipeline=$true)][string]$URL) Try { $status = [System.Net.WebRequest]::Create($URL).GetResponse().StatusCode } Catch { Write-Error $_.Exception.Message ; Return $false } If ( $status -eq 404 ) { Return $false } Return $true } Function IsURL { param([Parameter(Mandatory=$true,ValueFromPipeline=$true)][string]$Value) Return $value -match "https?:\/\/" } # Downloads a file from a URL Function Download-File { param( [Parameter(Mandatory=$true,ValueFromPipeline=$true)][string]$URL, [Parameter(Mandatory=$false,ValueFromPipeline=$false)][string]$File ) $URI = Get-AbsoluteURI -URL $URL If ( $null -eq $URI ) { Return } If ( [string]::IsNullOrEmpty($File) ) { $File = '{0}{1}' -f (Get-TempPath), (Split-Path $URI -Leaf) } #Try { (New-Object System.Net.WebClient).DownloadFile($URI,$File) } Try { Start-BitsTransfer -Source $URI -Destination $File } Catch { Write-Error $_.Exception.Message ; Return } Return $File } # Upload a file to a LiquidFiles Filedrop and submit its notification message. Function Upload-File { <# .SYNOPSIS Uploads a file to the Emberkom LiquidFiles Filedrop. .DESCRIPTION Uses the LiquidFiles 3.7+ JSON API with bounded binary chunks, including in 32-bit Windows PowerShell 5. The local file is retained. Returns a receipt only after the Filedrop accepts the final message for delivery. Uploads run synchronously. Allow enough time in the RMM for the entire transfer; the temporary Filedrop API key expires after 24 hours. Failed chunks are retried within this call, but restarting the script starts a new transfer. Final message submission is not retried automatically, because a lost response could otherwise cause duplicate notifications. .PARAMETER Path Literal path of one completed file. Also accepts -File or a pipeline path. .PARAMETER From Optional sender override. Defaults to the computer's fully qualified host name at ek-upload.net (or its host name when no DNS suffix is configured). .PARAMETER ChunkSizeMB Maximum upload buffer size in MiB; defaults to 10 regardless of file size. .PARAMETER TimeoutSeconds Timeout for each HTTP request, not for the entire transfer. .EXAMPLE Upload-File -Path $DsaResultPath .EXAMPLE Upload-File -File 'C:\Reports\report.zip' -Subject 'Diagnostic report' -Verbose .LINK https://docs.liquidfiles.com/api/v4.3/filedrop/ .LINK https://docs.liquidfiles.com/api/v4.3/attachments/chunks.html #> [CmdletBinding()] param( [Parameter(Mandatory=$true,ValueFromPipeline=$true,ValueFromPipelineByPropertyName=$true)] [Alias('File','FullName')][ValidateNotNullOrEmpty()][string]$Path, [ValidateNotNullOrEmpty()][string]$FileDropUrl = 'https://xfer.emberkom.com/filedrop/cmd', [string]$From, [string]$Subject, [string]$Message, [ValidateRange(1,100)][int]$ChunkSizeMB = 10, [ValidateRange(1,3600)][int]$TimeoutSeconds = 900, [ValidateRange(0,10)][int]$RetryCount = 3 ) PROCESS { $UploadUri = [uri]$FileDropUrl If ( !$UploadUri.IsAbsoluteUri -or $UploadUri.Scheme -ne 'https' -or $UploadUri.UserInfo -or $UploadUri.Query -or $UploadUri.Fragment ) { Throw 'FileDropUrl must be an absolute HTTPS Filedrop URL without credentials, query, or fragment.' } $UploadBaseUrl = $UploadUri.AbsoluteUri.TrimEnd('/') $UploadFile = Get-Item -LiteralPath $Path -Force -ErrorAction Stop If ( $UploadFile -isnot [System.IO.FileInfo] ) { Throw 'Upload-File requires a file, not a directory.' } $UploadHostInfo = [System.Net.NetworkInformation.IPGlobalProperties]::GetIPGlobalProperties() $UploadHostName = $UploadHostInfo.HostName If ( [string]::IsNullOrWhiteSpace($UploadHostName) ) { $UploadHostName = [Environment]::MachineName } $UploadDnsSuffix = $UploadHostInfo.DomainName.Trim('.') If ( $UploadDnsSuffix -and !$UploadHostName.EndsWith(".${UploadDnsSuffix}", [StringComparison]::OrdinalIgnoreCase) ) { $UploadHostName = "${UploadHostName}.${UploadDnsSuffix}" } $UploadSender = $From If ( [string]::IsNullOrWhiteSpace($UploadSender) ) { $UploadSender = $UploadHostName.ToLowerInvariant() + '@ek-upload.net' } Try { $UploadSender = ([System.Net.Mail.MailAddress]::new($UploadSender)).Address } Catch { Throw 'From must be a valid sender email address.' } $UploadSubject = $Subject If ( [string]::IsNullOrWhiteSpace($UploadSubject) ) { $UploadSubject = "File upload from ${UploadHostName}: $($UploadFile.Name)" } $UploadMessage = $Message If ( [string]::IsNullOrWhiteSpace($UploadMessage) ) { $UploadMessage = "Uploaded by ${UploadHostName}." } Add-Type -AssemblyName System.Net.Http -ErrorAction Stop $UploadClient = $null $UploadHandler = $null $UploadStream = $null $UploadApiKey = $null # Keep the same HTTP client (and cookies) for every chunk in this session. Function Invoke-FileDropRequest { param( [string]$Method, [string]$Uri, [byte[]]$Data, [int]$Count = 0, [string]$ContentType, [int]$Retries = $RetryCount ) For ( $UploadAttempt = 0; $UploadAttempt -le $Retries; $UploadAttempt++ ) { $UploadRequest = $null $UploadResponse = $null $UploadStatus = 0 Try { $UploadRequest = [System.Net.Http.HttpRequestMessage]::new([System.Net.Http.HttpMethod]::new($Method), $Uri) If ( $Method -eq 'POST' ) { $UploadRequest.Content = [System.Net.Http.ByteArrayContent]::new($Data, 0, $Count) If ( $ContentType ) { $UploadRequest.Content.Headers.ContentType = [System.Net.Http.Headers.MediaTypeHeaderValue]::Parse($ContentType) } } $UploadResponse = $UploadClient.SendAsync($UploadRequest).GetAwaiter().GetResult() $UploadStatus = [int]$UploadResponse.StatusCode $UploadResponseText = $UploadResponse.Content.ReadAsStringAsync().GetAwaiter().GetResult() If ( !$UploadResponse.IsSuccessStatusCode ) { # Do not include authentication tokens in errors or RMM logs. If ( $UploadApiKey ) { $UploadResponseText = $UploadResponseText.Replace($UploadApiKey, '[redacted]') } If ( $UploadResponseText.Length -gt 1000 ) { $UploadResponseText = $UploadResponseText.Substring(0, 1000) } Throw "Filedrop returned HTTP ${UploadStatus}: ${UploadResponseText}" } If ( [string]::IsNullOrWhiteSpace($UploadResponseText) ) { Return $null } $UploadResponseData = ConvertFrom-Json -InputObject $UploadResponseText -ErrorAction Stop If ( $UploadResponseData.errors ) { Throw ('Filedrop rejected the request: ' + ($UploadResponseData.errors -join '; ')) } Return $UploadResponseData } Catch { $UploadCanRetry = $UploadStatus -eq 0 -or $UploadStatus -in @(408,429,500,502,503,504) If ( !$UploadCanRetry -or $UploadAttempt -ge $Retries ) { Throw } Write-Verbose "Retrying Filedrop request after a connection error or HTTP ${UploadStatus}." } Finally { If ( $null -ne $UploadResponse ) { $UploadResponse.Dispose() } If ( $null -ne $UploadRequest ) { $UploadRequest.Dispose() } } Start-Sleep -Seconds ([Math]::Min(30, [Math]::Pow(2, $UploadAttempt + 1))) } } Try { # Deny writes while reading so retried chunks always contain the same bytes. $UploadStream = [System.IO.File]::Open($UploadFile.FullName, [System.IO.FileMode]::Open, [System.IO.FileAccess]::Read, [System.IO.FileShare]::Read) [long]$UploadLength = $UploadStream.Length $UploadHandler = [System.Net.Http.HttpClientHandler]::new() $UploadHandler.AllowAutoRedirect = $false $UploadClient = New-Object -TypeName System.Net.Http.HttpClient -ArgumentList $UploadHandler $UploadClient.Timeout = [TimeSpan]::FromSeconds($TimeoutSeconds) $UploadClient.DefaultRequestHeaders.Accept.ParseAdd('application/json') $UploadInfo = (Invoke-FileDropRequest -Method GET -Uri $UploadBaseUrl).filedrop $UploadApiKey = [string]$UploadInfo.api_key If ( [string]::IsNullOrWhiteSpace($UploadApiKey) ) { Throw 'The Filedrop did not provide an API key. Check its URL, password, and email-validation requirements.' } If ( $UploadInfo.max_upload_size -gt 0 -and $UploadLength -gt ([long]$UploadInfo.max_upload_size * 1MB) ) { Throw "The file exceeds the Filedrop limit of $($UploadInfo.max_upload_size) MiB." } $UploadExtension = $UploadFile.Extension.TrimStart('.').ToLowerInvariant() $UploadPermitted = $UploadInfo.permitted_extensions If ( !$UploadPermitted ) { $UploadPermitted = $UploadInfo.limited_extensions } $UploadAllowedExtensions = @(([string]$UploadPermitted -split '[,\s]+') | ForEach-Object { $_.TrimStart('.') } | Where-Object { $_ }) $UploadBlockedExtensions = @(([string]$UploadInfo.blocked_extensions -split '[,\s]+') | ForEach-Object { $_.TrimStart('.') } | Where-Object { $_ }) If ( ($UploadAllowedExtensions.Count -gt 0 -and $UploadExtension -notin $UploadAllowedExtensions) -or $UploadExtension -in $UploadBlockedExtensions ) { Throw "The Filedrop does not permit the file extension '$UploadExtension'." } $UploadAuth = [Convert]::ToBase64String([Text.Encoding]::UTF8.GetBytes($UploadApiKey + ':x')) $UploadClient.DefaultRequestHeaders.Authorization = [System.Net.Http.Headers.AuthenticationHeaderValue]::new('Basic', $UploadAuth) [int]$UploadChunkSize = $ChunkSizeMB * 1MB [long]$UploadChunks = [Math]::Max(1, [Math]::Ceiling($UploadLength / [double]$UploadChunkSize)) $UploadBuffer = [byte[]]::new([int][Math]::Min($UploadChunkSize, [Math]::Max(1, $UploadLength))) $UploadEncodedName = [uri]::EscapeDataString($UploadFile.Name) $UploadAttachment = $null Write-Verbose "Uploading $($UploadFile.Name) ($UploadLength bytes) in $UploadChunks chunk(s) as ${UploadSender}." For ( [long]$UploadChunk = 0; $UploadChunk -lt $UploadChunks; $UploadChunk++ ) { [int]$UploadBytesNeeded = [Math]::Min($UploadChunkSize, $UploadLength - $UploadStream.Position) [int]$UploadBytesRead = 0 While ( $UploadBytesRead -lt $UploadBytesNeeded ) { $UploadRead = $UploadStream.Read($UploadBuffer, $UploadBytesRead, $UploadBytesNeeded - $UploadBytesRead) If ( $UploadRead -eq 0 ) { Throw 'The local file ended before all expected bytes were read.' } $UploadBytesRead += $UploadRead } $UploadChunkUrl = "${UploadBaseUrl}/attachments/upload?filename=${UploadEncodedName}&chunk=${UploadChunk}&chunks=${UploadChunks}" $UploadChunkResult = Invoke-FileDropRequest -Method POST -Uri $UploadChunkUrl -Data $UploadBuffer -Count $UploadBytesRead If ( $UploadChunkResult.attachment.id ) { $UploadAttachment = $UploadChunkResult.attachment } Write-Progress -Activity "Uploading $($UploadFile.Name)" -Status "Chunk $($UploadChunk + 1) of ${UploadChunks}" ` -PercentComplete ([int](100 * ($UploadChunk + 1) / $UploadChunks)) } If ( !$UploadAttachment.id ) { Throw 'The upload did not return an attachment ID; the Filedrop message was not submitted.' } If ( $null -ne $UploadAttachment.size -and [long]$UploadAttachment.size -ne $UploadLength ) { Throw 'The uploaded attachment size does not match the local file; the Filedrop message was not submitted.' } If ( $UploadAttachment.content_blocked ) { Throw 'LiquidFiles blocked this attachment; the Filedrop message was not submitted.' } $UploadBody = @{ message = @{ from = $UploadSender subject = $UploadSubject message = $UploadMessage attachments = @([string]$UploadAttachment.id) } } | ConvertTo-Json -Depth 4 -Compress $UploadBodyBytes = [Text.Encoding]::UTF8.GetBytes($UploadBody) Try { $UploadReceipt = Invoke-FileDropRequest -Method POST -Uri $UploadBaseUrl -Data $UploadBodyBytes ` -Count $UploadBodyBytes.Length -ContentType 'application/json; charset=utf-8' -Retries 0 If ( [string]::IsNullOrWhiteSpace([string]$UploadReceipt.message.status) ) { Throw 'The server did not return a Filedrop submission confirmation.' } } Catch { Throw "Filedrop submission was not confirmed. Check the Filedrop before retrying to avoid duplicate notifications. $($_.Exception.Message)" } [pscustomobject]@{ Path = $UploadFile.FullName FileDropUrl = $UploadBaseUrl From = $UploadSender AttachmentId = [string]$UploadAttachment.id Size = $UploadLength Status = [string]$UploadReceipt.message.status } } Finally { Write-Progress -Activity "Uploading $($UploadFile.Name)" -Completed If ( $null -ne $UploadStream ) { $UploadStream.Dispose() } If ( $null -ne $UploadClient ) { $UploadClient.Dispose() } ElseIf ( $null -ne $UploadHandler ) { $UploadHandler.Dispose() } $UploadApiKey = $null } } } # Install a program from a provided path Function Install-Program { param( [Parameter(Mandatory=$true,ValueFromPipeline=$true)][string]$Path, [Parameter(Mandatory=$false)][string]$Arguments = '', [Parameter(Mandatory=$false)][switch]$Delete = $false ) If ( Test-Path "${Path}" ) { Write-Output "Running installer: ""${Path}"" ${Arguments}" Try { If ( $Arguments -eq '' ) { Start-Process "${Path}" -Wait } Else { Start-Process "${Path}" -ArgumentList "${Arguments}" -Wait } } Catch { Write-Error $_.Exception.Message } Write-Output "Installer finished" If ( $Delete ) { Write-Output "Deleting installer: ""${Path}""" Try { Remove-Item -Path "${Path}" -Force } Catch { Write-Error $_.Exception.Message } } } Else { Write-Output "The specified file could not be found: ""${Path}""" } } # Function to silently install an MSI package either locally or after downloading it from a URL Function Install-MSI { param( [Parameter(Mandatory=$true,ValueFromPipeline=$true)][string]$Path, [Parameter(Mandatory=$false)][System.Collections.ArrayList]$Properties = @(), [Parameter(Mandatory=$false)][string]$Log = $Global:LogFile, [Parameter(Mandatory=$false)][switch]$DeleteMSI = $false, [Parameter(Mandatory=$false)][int]$MaxRunTimeSeconds = 594 ) # If $Path is a URL, then try to download the file If ( IsURL -Value $Path ) { $Path = Download-File -URL $Path } # Make sure $FilePath exists If ( !(Test-Path $Path ) ) { Write-Error "The specified file doesn't exist: ""${Path}""" ; Return } # Make sure $MaxRuntimeMinutes is a positive integer If ( $MaxRunTimeSeconds -lt 0 ) { $MaxRunTimeSeconds = 594 Write-Output "The specified maximum run time is invalid and has been changed to ${MaxRunTimeSeconds} seconds" } # Build the install command [System.Collections.ArrayList]$MSIParameters = @('/i',"""${Path}""") If ( ![string]::IsNullOrEmpty($Log) ) { If ( Test-Path $Log ) { $MSIParameters.Add('/l+!*') | Out-Null } Else { $MSIParameters.Add('/l!*') | Out-Null } $MSIParameters.Add("""${Log}""") | Out-Null } If ( ![string]::IsNullOrEmpty($Properties) ) { $MSIParameters.Add($Properties) | Out-Null } # Run a job to install the MSI Write-Output "Waiting ${MaxRunTimeSeconds} seconds for the following command: msiexec.exe ${MSIParameters}" $InstallMSI = Start-Job -ScriptBlock { PROCESS{ msiexec.exe $_ } } -InputObject $MSIParameters # Wait for the job to end or the timeout to be reached $endTime = (Get-Date).AddSeconds($MaxRunTimeSeconds) While ( $(Get-Date) -le $endTime ) { If ( (Get-Job -Name $InstallMSI.Name).JobStateInfo.State -eq "Completed" ) { Break } Start-Sleep -Seconds 1 } # Stop the installation if it's still running If ( (Get-Job -Name $InstallMSI.Name).JobStateInfo.State -ne "Completed" ) { Write-Output "Timeout reached, stopping installation process" Stop-Job -Job $InstallMSI } # Clean up the job $result = Receive-Job -Job $InstallMSI Remove-Job -Job $InstallMSI -Force If ( [string]::IsNullOrEmpty($result) ) { Write-Output "Installation finished!" } Else { Write-Output "Installation finished with the following output:`n${result}" } # Delete the MSI If ( $DeleteMSI ) { Write-Output "Deleting ""${Path}""" Try { Remove-Item -Path $Path -Force -ErrorAction SilentlyContinue } Catch { Write-Error $_.Exception.Message } } } # Compare current Windows version with a supplied version # The value supplied must be a string and must include at least 1 decimal Function IsWindowsVersion { param( [Parameter(Mandatory=$true,ParameterSetName='gt')][string]$gt, [Parameter(Mandatory=$true,ParameterSetName='ge')][string]$ge, [Parameter(Mandatory=$true,ParameterSetName='lt')][string]$lt, [Parameter(Mandatory=$true,ParameterSetName='le')][string]$le, [Parameter(Mandatory=$true,ParameterSetName='eq')][string]$eq ) [version]$WindowsVersion = [System.Environment]::OSVersion.Version switch ($PSCmdlet.ParameterSetName) { 'gt' { If ( $WindowsVersion -gt (Get-Version $gt) ) { Return $true } Else { Return $false } } 'ge' { If ( $WindowsVersion -ge (Get-Version $ge) ) { Return $true } Else { Return $false } } 'lt' { If ( $WindowsVersion -lt (Get-Version $lt) ) { Return $true } Else { Return $false } } 'le' { If ( $WindowsVersion -le (Get-Version $le) ) { Return $true } Else { Return $false } } 'eq' { If ( $WindowsVersion -eq (Get-Version $eq) ) { Return $true } Else { Return $false } } } } # Compare current Windows build with a supplied version # The value supplied must be an int Function IsWindowsBuild { param( [Parameter(Mandatory=$true,ParameterSetName='gt')][int]$gt, [Parameter(Mandatory=$true,ParameterSetName='ge')][int]$ge, [Parameter(Mandatory=$true,ParameterSetName='lt')][int]$lt, [Parameter(Mandatory=$true,ParameterSetName='le')][int]$le, [Parameter(Mandatory=$true,ParameterSetName='eq')][int]$eq ) [int]$WindowsBuild = [System.Environment]::OSVersion.Version.Build switch ($PSCmdlet.ParameterSetName) { 'gt' { If ( $WindowsBuild -gt $gt ) { Return $true } Else { Return $false } } 'ge' { If ( $WindowsBuild -ge $ge ) { Return $true } Else { Return $false } } 'lt' { If ( $WindowsBuild -lt $lt ) { Return $true } Else { Return $false } } 'le' { If ( $WindowsBuild -le $le ) { Return $true } Else { Return $false } } 'eq' { If ( $WindowsBuild -eq $eq ) { Return $true } Else { Return $false } } } } # Get the path to the TEMP folder (context dependent) Function Get-TempPath { Return [System.IO.Path]::GetTempPath() } # Get a random file name with random extension Function Get-RandomFileName { Return [System.IO.Path]::GetRandomFileName() } # Create a new temp file in the current TEMP folder Function New-TemporaryFile { $file = [System.IO.Path]::Combine($(Get-TempPath), $(Get-RandomFileName)) New-Item -Path $file -ItemType File -Force -ErrorAction SilentlyContinue | Out-Null Return Get-Item -Path $file } # Create a new temp directory in the current TEMP folder Function New-TemporaryDirectory { $directory = [System.IO.Path]::Combine($(Get-TempPath), $(Get-RandomFileName)) New-Item -Path $directory -ItemType Directory -Force -ErrorAction SilentlyContinue | Out-Null Return Get-Item -Path $directory } # Determine if the system is 64-bit or not Function Is64bit { switch ( $(Get-CimInstance -ClassName Win32_OperatingSystem -Property OSArchitecture | Select-Object -ExpandProperty OSArchitecture) ) { '64-bit' { Return $true } '32-bit' { Return $false } } } # Determine if the Powershell process is 64-bit or not Function Is64bitShell { If ( [System.Environment]::Is64BitProcess ) { Return $true } Else { Return $false } } # Determine if a user is in a built-in role or specified group Function IsMemberOf { param( [Parameter(Mandatory=$false)] [switch]$Builtin=$false, [Parameter(Mandatory=$true,ValueFromPipeline=$true)] [string]$Group ) If ( $Builtin ) { Switch ( $Group ) { ("Administrator" -or "Administrators") { $Group = [System.Security.Principal.WindowsBuiltInRole]::Administrator ; Break } ("Backup Operator" -or "Backup Operators" -or "BackupOperator" -or "BackupOperators") { $Group = [System.Security.Principal.WindowsBuiltInRole]::BackupOperator ; Break } ("System Operator" -or "System Operators" -or "SystemOperator" -or "SystemOperators") { $Group = [System.Security.Principal.WindowsBuiltInRole]::SystemOperator ; Break } ("Account Operator" -or "Account Operators" -or "AccountOperator" -or "AccountOperators") { $Group = [System.Security.Principal.WindowsBuiltInRole]::AccountOperator ; Break } ("Print Operator" -or "Print Operators" -or "PrintOperator" -or "PrintOperators") { $Group = [System.Security.Principal.WindowsBuiltInRole]::PrintOperator ; Break } ("Replicator" -or "Replicators") { $Group = [System.Security.Principal.WindowsBuiltInRole]::Replicator ; Break } ("Power User" -or "Power Users" -or "PowerUser" -or "PowerUsers") { $Group = [System.Security.Principal.WindowsBuiltInRole]::PowerUser ; Break } ("User" -or "Users") { $Group = [System.Security.Principal.WindowsBuiltInRole]::User ; Break } ("Guest" -or "Guests") { $Group = [System.Security.Principal.WindowsBuiltInRole]::Guest ; Break } default { ; Break } } } Return ([Security.Principal.WindowsPrincipal][System.Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole($Group) } # Start, stop, restart, or delete a list of services Function Control-Service { param( [Parameter(Mandatory=$true,ParameterSetName='start')] [switch]$Start, [Parameter(Mandatory=$true,ParameterSetName='stop')] [switch]$Stop, [Parameter(Mandatory=$true,ParameterSetName='restart')] [switch]$Restart, [Parameter(Mandatory=$true,ParameterSetName='delete')] [switch]$Delete, [Parameter(Mandatory=$true,ParameterSetName='disable')] [switch]$Disable, [Parameter(Mandatory=$true,ValueFromPipeline=$true,ParameterSetName='start')] [Parameter(Mandatory=$true,ValueFromPipeline=$true,ParameterSetName='stop')] [Parameter(Mandatory=$true,ValueFromPipeline=$true,ParameterSetName='restart')] [Parameter(Mandatory=$true,ValueFromPipeline=$true,ParameterSetName='delete')] [Parameter(Mandatory=$true,ValueFromPipeline=$true,ParameterSetName='disable')] [string[]]$Name, [Parameter(Mandatory=$false,ParameterSetName='start')] [Parameter(Mandatory=$false,ParameterSetName='stop')] [Parameter(Mandatory=$false,ParameterSetName='restart')] [Parameter(Mandatory=$false,ParameterSetName='delete')] [Parameter(Mandatory=$false,ParameterSetName='disable')] [switch]$Match=$false ) switch ($PSCmdlet.ParameterSetName) { 'start' { $statuscondition = 'Running' $verb = 'start' $verbing = 'Starting' } 'stop' { $statuscondition = 'Stopped' $verb = 'stop' $verbing = 'Stopping' } 'restart' { $ArgString = $MyInvocation.Line $StopCmd = $ArgString -replace ' -Restart ', ' -Stop ' $StartCmd = $ArgString -replace ' -Restart ', ' -Start ' Invoke-Expression $StopCmd Invoke-Expression $StartCmd Exit } 'delete' { # Delete the service } 'disable' { $ArgString = $MyInvocation.Line $StopCmd = $ArgString -replace ' -Disable ', ' -Stop ' Invoke-Expression $StopCmd $statuscondition = 'Disabled' $verb = 'disable' $verbing = 'Disabling' } } ForEach ( $item in $Name ) { $service = Get-Service -Name $item -ErrorAction SilentlyContinue If ( !($service) ) { Write-Output "Cannot find the service '${item}'" If ( $Match ) { Write-Output "Attempting to match '${item}' to service display names" ForEach ( $svc in ((Get-Service | Where-Object { $_.DisplayName -match $item }).Name) ) { Switch ( $verb) { 'start' { Control-Service -Start -Name $svc } 'stop' { Control-Service -Stop -Name $svc } 'disable' { Control-Service -Disable -Name $svc } } } } } Else { $name = $service.Name $fullname = $service.DisplayName If ( ([string]::IsNullOrEmpty($fullname)) -or ($fullname -eq $name) ) { $displayname = "'${name}'" } Else { $displayname = """${fullname}"" (${name})" } If ( $service.Status -ne $statuscondition ) { Write-Output "${verbing} ${displayname}" Try { Switch ( $verb) { 'start' { Start-Service -Name $name } 'stop' { Stop-Service -Name $name -Force } 'disable' { Set-Service -Name "${name}" -StartupType Disabled } } } Catch { Write-Error $_.Exception.Message } } } } } # Stop a process Function End-Process { param( [Parameter(Mandatory=$true,ValueFromPipeline=$true)][string[]]$Name, [Parameter(Mandatory=$false)][switch]$Match=$false, [Parameter(Mandatory=$false)][switch]$Force=$false ) ForEach ( $item in $Name ) { $process = Get-Process -Name $item -ErrorAction SilentlyContinue If ( !($process) ) { Write-Output "Cannot find the process '${item}'" If ( $Match ) { Write-Output "Attempting to match '${item}' to all running process names" ForEach ( $proc in ((Get-Process | Where-Object { $_.Name -match $item }).Name) ) { If ( $Force ) { End-Process -Name $proc -Force } Else { End-Process -Name $proc } } } } Else { $name = $process.Name If ( $Force ) { Write-Output "Forcefully stopping '${name}' process" Stop-Process $process -Force -ErrorAction SilentlyContinue } Else { Write-Output "Attempting to gracefully close '${name}' process" $process.CloseMainWindow() | Out-Null } } } } Function New-Shortcut { param( [Parameter(Mandatory=$true)][string]$Path, [Parameter(Mandatory=$true)][string]$TargetPath, [Parameter(Mandatory=$false)][string]$Arguments, [Parameter(Mandatory=$false)][string]$Description, [Parameter(Mandatory=$false)][string]$Icon = '', [Parameter(Mandatory=$false)][string]$WorkingDirectory = '' ) If ( Test-Path $TargetPath ) { If ( Test-Path $Path ) { Write-Output "Deleting existing shortcut at ""${Path}""" Try { Remove-Item $Path -Force -ErrorAction SilentlyContinue } Catch { Write-Error $_.Exception.Message } } If ( $WorkingDirectory -eq '' ) { $WorkingDirectory = Split-Path $TargetPath -Parent } If ( $Icon -eq '' ) { $Icon = "${TargetPath}, 0" } $WshShell = New-Object -ComObject WScript.Shell $Shortcut = $WshShell.CreateShortcut($Path) $Shortcut.Arguments = $Arguments $Shortcut.Description = $Description $Shortcut.IconLocation = $Icon $Shortcut.WorkingDirectory = $WorkingDirectory $Shortcut.TargetPath = $TargetPath Write-Output "Creating shortcut to ""${TargetPath}"" at ""${Path}""" Try { $Shortcut.Save() } Catch { Write-Error $_.Exception.Message } } Else { Write-Output "Cannot create shortcut because the target path does not exist" } } # Enable a Windows Event Log Function Enable-Log { param ([Parameter(Mandatory = $true,ValueFromPipeline=$true)][string]$Name) Try { $log = New-Object System.Diagnostics.Eventing.Reader.EventLogConfiguration $Name Write-Output "Enabing ${Name} event log" $log.IsEnabled = $true $log.SaveChanges() } Catch { Write-Error $_.Exception.Message } } # Disable a Windows Event Log Function Disable-Log { param ([Parameter(Mandatory = $true,ValueFromPipeline=$true)][string]$Name) Try { $log = New-Object System.Diagnostics.Eventing.Reader.EventLogConfiguration $Name Write-Output "Disabing ${Name} event log" $log.IsEnabled = $false $log.SaveChanges() } Catch { Write-Error $_.Exception.Message } } # Function to install the MSP360 Powershell module Function Import-MSP360Module { Try { $Module = Get-Module -ListAvailable -Name MSP360,msp360 | Sort-Object Version -Descending | Select-Object -First 1 If ( $Module ) { Import-Module -Name $Module.Name -Force -ErrorAction Stop ; Return } If ( -not (IsAdmin) ) { Write-Output "The MSP360 Powershell module needs to be installed, but the current account is not an administrative user" ; Return } Write-Output "Installing MSP360 Powershell module" Set-ExecutionPolicy -ExecutionPolicy Unrestricted -Scope Process -Force [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12 Invoke-Expression (New-Object System.Net.WebClient).DownloadString('https://raw.githubusercontent.com/msp360/MSP360-PSModule/master/private/Install-MSP360Module.ps1') Install-MSP360Module Import-Module -Name MSP360 -Force -ErrorAction Stop } Catch { Write-Error "Could not import or install MSP360 PowerShell module: $($_.Exception.Message)" } } # Function to ZIP a file or directory, returns the newly created zip file # TODO: updating an archive with files that already exist inside will create duplicates and cause problems during extraction Function Compress-Archive { param( [Parameter(ValueFromPipeline=$true,Mandatory=$true)][string]$Path, [Parameter(ValueFromPipeline=$false,Mandatory=$false)][string]$DestinationPath, [Parameter(ValueFromPipeline=$false,Mandatory=$false)][switch]$Force=$false ) BEGIN { If ( !(Test-Path $Path ) ) { Write-Error "The specified path does not exist: ""${Path}""" ; Exit } If ( [string]::IsNullOrEmpty($DestinationPath) ) { Switch ( Get-Item -Path $Path ) { {$_ -is [System.IO.DirectoryInfo]} { $DestinationPath = '{0}.zip' -f ($Path.TrimEnd('\'))} {$_ -is [System.IO.FileInfo]} { $DestinationPath = '{0}\{1}.zip' -f (Split-Path $Path -Parent), ([System.IO.Path]::GetFileNameWithoutExtension($Path)) } } } If ( ($Force) -and (Test-Path $DestinationPath) ) { Write-Output "Deleting existing archive: ""${DestinationPath}""" Remove-Item -Path $DestinationPath -Force -ErrorAction Stop } } PROCESS { If ( !($Force) -and (Test-Path $DestinationPath) ) { $CreateNewArchive = $false } Else { $CreateNewArchive = $true } Try { Add-Type -Assembly "System.IO.Compression" Add-Type -Assembly "System.IO.Compression.FileSystem" Switch ( $(Get-Item -Path $Path) ) { {$_ -is [System.IO.DirectoryInfo]} { If ( $CreateNewArchive ) { Write-Output "Creating new zip archive: ""${DestinationPath}""" [System.IO.Compression.ZipFile]::CreateFromDirectory($Path, $DestinationPath, [System.IO.Compression.CompressionLevel]::Optimal, $true) } Else { If ( (Get-Command Microsoft.Powershell.Archive\Compress-Archive -ErrorAction SilentlyContinue) ) { Write-Output "Calling Microsoft util" Microsoft.Powershell.Archive\Compress-Archive -Path $Path -DestinationPath $DestinationPath -Update -CompressionLevel Optimal } Else { Write-Error "Updating an existing zip archive with a folder structure is not currently supported" } } } {$_ -is [System.IO.FileInfo]} { If ( $CreateNewArchive ) { Write-Output "Creating new zip archive: ""${DestinationPath}""" $ArchiveMode = [System.IO.Compression.ZipArchiveMode]::Create } Else { $ArchiveMode = [System.IO.Compression.ZipArchiveMode]::Update } [System.IO.Compression.ZipArchive]$DestinationArchive = [System.IO.Compression.ZipFile]::Open($DestinationPath, $ArchiveMode) [System.IO.Compression.ZipFileExtensions]::CreateEntryFromFile($DestinationArchive, $Path, (Split-Path $Path -Leaf)) | Out-Null } } } Catch { Write-Error $_.Exception.Message } Finally { If ( $DestinationArchive ) { $DestinationArchive.Dispose() } } } END { If ( !$CreateNewArchive ) { Write-Output "Finished updating existing archive: ""${DestinationPath}""" } If ( Test-Path $DestinationPath ) { Return Get-Item -Path $DestinationPath } Else { Return $null } } } # Function to unzip a file or directory # TODO: extracting an archive will fail if the destination file(s) already exists Function Expand-Archive { param( [Parameter(ValueFromPipeline=$true,Mandatory=$true)][string]$Path, [Parameter(ValueFromPipeline=$false,Mandatory=$false)][string]$DestinationPath, [Parameter(ValueFromPipeline=$false,Mandatory=$false)][switch]$Force=$false ) If ( !(Test-Path $Path) ) { Write-Output "The specified zip archive does not exist: ""${Path}""" ; Exit } If ( [System.IO.Path]::GetExtension($Path) -ne ".zip" ) { Write-Output "The path specified is not a zip file: ""${Path}""" ; Exit } If ( [string]::IsNullOrEmpty($DestinationPath) ) { $DestinationPath = Split-Path -Parent $Path } Try { Add-Type -Assembly "System.IO.Compression" Add-Type -Assembly "System.IO.Compression.FileSystem" Write-Output "Extracting ""${Path}"" to ""${DestinationPath}""" [System.IO.Compression.ZipArchive]$SourceArchive = [System.IO.Compression.ZipFile]::Open($Path, [System.IO.Compression.ZipArchiveMode]::Read) [System.IO.Compression.ZipFileExtensions]::ExtractToDirectory($SourceArchive, $DestinationPath) } Catch { Write-Error $_.Exception.Message } Finally { If ( $SourceArchive ) { $SourceArchive.Dispose() } } } # Function to get a copy of the LiquidFiles CLI agent Function Get-LiquidFilesCLI { $url = 'https://lfupdate.s3.amazonaws.com/clients/windows_cli/LiquidFilesCLI-2.0.128.zip' $zip_filename = Split-Path -Leaf $url $zip_path = "${Global:ToolsDirectory}\${zip_filename}" $exe_path = '{0}\{1}.exe' -f $Global:ToolsDirectory,[System.IO.Path]::GetFileNameWithoutExtension($zip_filename) If ( Test-Path $zip_path ) { Write-Output "Deleting existing zip archive: ${zip_path}" Try { Remove-Item -Path $zip_path -Force } Catch { Write-Error $_.Exception.Message } } If ( Test-Path $exe_path ) { Write-Output "Deleting existing file: ${exe_path}" Try { Remove-Item -Path $exe_path -Force } Catch { Write-Error $_.Exception.Message } } Download-File -URL $url -File $zip_path | Out-Null Expand-Archive $zip_path Return $exe_path } # Function to determine if an app is running Function IsRunning ([Parameter(ValueFromPipeline=$true)][string]$Name) { $RunningInstances = Get-Process | Where-Object { $_.Name -ilike $Name } If ( $RunningInstances ) { Return $true } Else { Return $false } } # Function to create a local user account Function New-LocalAccount { param( [Parameter(Mandatory=$true)][string]$Username, [Parameter(Mandatory=$true)][string]$Password, [Parameter(Mandatory=$true)][string]$FullName, [Parameter(Mandatory=$true)][string]$Description, [Parameter(Mandatory=$false)][switch]$MakeAdmin=$false, [Parameter(Mandatory=$false)][switch]$Hide=$false ) $SecurePassword = ConvertTo-SecureString -String $Password -AsPlainText -Force $Password = $null If ( -not (IsAdmin) ) { Write-Output "Cannot create or modify a local account without administrative privileges" Return } If ( $(Get-CimInstance -ClassName Win32_OperatingSystem -Property ProductType | Select-Object -ExpandProperty ProductType) -eq "2" ) { Write-Output "Cannot create or modify local accounts on a domain controller" Return } If ( $(Get-LocalUser -Name $Username -ErrorAction SilentlyContinue) ) { Write-Output "Updating user: ${Username}" Try { Set-LocalUser -Name "${Username}" -Password $SecurePassword -FullName "${FullName}" -Description "${Description}" -AccountNeverExpires -PasswordNeverExpires | Out-Null } Catch { Write-Error "Could not update user`n"+$_.Exception.Message ; Exit } } Else { Write-Output "Creating user: ${Username}" Try { New-LocalUser -Name "${Username}" -Password $SecurePassword -FullName "${FullName}" -Description "${Description}" -AccountNeverExpires -PasswordNeverExpires | Out-Null } Catch { Write-Error "Could not create user`n"+$_.Exception.Message ; Exit } } If ( (-not($(Get-LocalGroupMember -Group "Administrators" -Member $Username -ErrorAction SilentlyContinue))) -and $MakeAdmin ) { Write-Output "Adding ""${Username}"" to local Administrators group" Try { Add-LocalGroupMember -Name "Administrators" -Member $(Get-LocalUser -Name "${Username}") } Catch { Write-Error "Could not add user to Administrators group`n"+$_.Exception.Message ; Exit } } If ( $Hide ) { $RegPath = "HKLM:SOFTWARE\Microsoft\Windows NT\CurrentVersion\Winlogon\SpecialAccounts\UserList" $HideUser = $true If ( -not (Test-Path $RegPath) ) { New-Item -Path $RegPath -Force | Out-Null } Else { $UserList = Get-ItemProperty -Path $RegPath ForEach ( $User in $UserList.PSObject.Properties ) { If ( $User.Name -ieq $Username ) { Write-Output "The user ""${Username}"" is already hidden from the login screen" $HideUser = $false Break } } } If ( $HideUser ) { New-ItemProperty -Path $RegPath -Name $Username -Value 0 -PropertyType DWord -Force | Out-Null } } } # Returns the number of MB a process is consuming Function Get-MemoryUsage ([string]$AppName) { [math]::Round((Get-Process -Name $AppName -ErrorAction SilentlyContinue | Measure-Object -Property WorkingSet -Sum).Sum / 1MB) } # Kills a process if it's using more than the specified amount of memory Function Stop-MemoryHog ([string]$AppName,[int]$MemoryLimit) { $MemoryUsed = (Get-MemoryUsage -AppName $AppName) If ( $MemoryUsed -gt $MemoryLimit ) { $MemoryDifference = $MemoryUsed - $MemoryLimit Write-Output "Killing ""${AppName}"" for using ${MemoryDifference}MB over the limit of ${MemoryLimit}MB" Try { Get-Process -Name $AppName -ErrorAction SilentlyContinue | Stop-Process -Force } Catch { Write-Error $_.Exception.Message } } } # Returns a formatted list of the largest or smallest files in a directory Function Get-FileSizes { param( [Parameter(ValueFromPipeline=$true)][string]$Path, [switch]$Recurse, [switch]$IncludeHidden, [Parameter(ParameterSetName="largest")][int]$Largest, [Parameter(ParameterSetName="smallest")][int]$Smallest, [string]$Units, [int]$Precision=2 ) # Fix drive case so output looks nicer Switch ( $Path.Length ) { 1 { $Path = $Path.ToUpper() } { $_ -gt 1 } { $split = $Path.Split(":") $Path = $split[0].ToUpper() + ":" If ( $split[1] ) { $Path += $split[1] } } } # If no path is specified, set $Path to the directory containing user profiles If (-not $Path ) { $Path = (Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList' -Name ProfilesDirectory).ProfilesDirectory $Recurse = $true $IncludeHidden = $false } # If the path is not an absolute path, make it so ElseIf ( -not (Test-Path $Path) ) { $NewPath = $Path[0] + ":\" If ( -not (Test-Path $NewPath) ) { Write-Error "Could not find path: ${Path}" Return } $Path = $NewPath } # Change the sort order depending on which parameter set was specified Switch ( $PSCmdlet.ParameterSetName ) { "largest" { $SortOrder = $true ; $Quantity = $Largest } "smallest" { $SortOrder = $false ; $Quantity = $Smallest } } # Set the units to show sizes in output Switch ( $Units.ToUpper() ) { "KB" { $UnitLabel = "Kilobytes (KB)" ; $Divisor = 1KB } "MB" { $UnitLabel = "Megabytes (MB)" ; $Divisor = 1MB } "GB" { $UnitLabel = "Gigabytes (GB)" ; $Divisor = 1GB } "TB" { $UnitLabel = "Terabytes (TB)" ; $Divisor = 1TB } default { $UnitLabel = "Bytes" ; $Divisor = 1 } } # Get the file paths and sizes as specified $FileSizes = Get-ChildItem -LiteralPath "\\?\${Path}" -Recurse:$Recurse -Force:$IncludeHidden -ErrorAction SilentlyContinue | ` Where-Object { ! $_.PSIsContainer -and ($_.FullName.Length -lt 260)} | ` Sort-Object -Descending:$SortOrder -Property Length | ` Select-Object -First $Quantity @{Name="File Path";Expression={[IO.Path]::Combine($_.DirectoryName, $_.Name)}}, @{Name=$UnitLabel;Expression={[Math]::Round($_.Length / $Divisor, $Precision)}} # Set output prefix $prefix = "The ${Quantity} " + $PSCmdlet.ParameterSetName + " files found at ""${Path}""" # Output to console $constr = "${prefix}" + $($FileSizes | Out-String) Microsoft.Powershell.Utility\Write-Output $constr # Output to log file $logstr = "${prefix}" + $($FileSizes | Format-List | Out-String) Write-Output $logstr } # Function to write text to a file in UTF8 encoding without BOM Function WriteToFile_UTF8NoBOM { param( [Parameter(ValueFromPipeline=$false)][string]$FilePath, [Parameter(ValueFromPipeline=$true)][string]$Value ) $UTF8NoBOM = New-Object System.Text.UTF8Encoding $false Try { [IO.File]::WriteAllText($FilePath, $CONFIG, $UTF8NoBOM) } Catch { Write-Error $_.Exception.Message } } # Function to enumerate all user profile folders Function Get-UserProfiles { $ProfilePath = (Get-ItemProperty -Path 'HKLM:\SOFTWARE\Microsoft\Windows NT\CurrentVersion\ProfileList' -Name ProfilesDirectory).ProfilesDirectory $UserProfilePaths = @() ForEach ( $userProfile in (Get-ChildItem -Path $ProfilePath | Where-Object { $_.PSIsContainer }) ) { $UserProfilePaths += ,@($userProfile.FullName) } Return $UserProfilePaths } # Function to test for the presense of a Registry property Function Test-RegistryProperty { param( [Parameter(Mandatory=$true)][string]$Path, [Parameter(Mandatory=$true)][string]$Name ) Try { Get-ItemProperty -Path $Path | Select-Object -ExpandProperty $Name -ErrorAction Stop | Out-Null Return $true } Catch { Return $false } } ## Function to format a quantity of bytes into a denomination #Function Format-ByteQuantity { # param( # [int64]$TotalBytes, # [int]$Precision=2, # [string]$Units, # [switch]$WithUnitLabel # ) # Switch ( $Units.ToUpper() ) { # "KB" { $UnitLabel = "KB" ; $Divisor = 1KB } # "MB" { $UnitLabel = "MB" ; $Divisor = 1MB } # "GB" { $UnitLabel = "GB" ; $Divisor = 1GB } # "TB" { $UnitLabel = "TB" ; $Divisor = 1TB } # default { $UnitLabel = "bytes" ; $Divisor = 1 } # } # Switch ( $WithUnitLabel ) { # $true { Return (ZeroPad-Decimal -Amount $([Math]::Round($TotalBytes / $Divisor,$Precision)) -NeededDecimalPlaces $Precision) + "${UnitLabel}" } # $false { Return (ZeroPad-Decimal -Amount $([Math]::Round($TotalBytes / $Divisor,$Precision)) -NeededDecimalPlaces $Precision) } # } #} # ## Function to pad zeros onto the end of a decimal number #Function ZeroPad-Decimal { # param( # $Amount, # $NeededDecimalPlaces # ) # $splitNumbers = $Amount.ToString().Split('.') # $paddedDecimal = $splitNumbers[1].PadRight($NeededDecimalPlaces, '0') # Return $splitNumbers[0] + '.' + $paddedDecimal #} # Function to follow a URL and return the absolute URI of the result (whether redirected or not) Function Get-AbsoluteURI { param([string]$URL) If ( !(IsURLValid $URL) ) { Return } Return [System.Net.HttpWebRequest]::Create($URL).GetResponse().ResponseUri.AbsoluteUri } Function Get-GUIDFromMSIUninstallString ([string]$str) { $start = $str.IndexOf('{') + 1 $end = $str.IndexOf('}') $retval = $str.Substring($start, $end - $start) If ( $retval.Length -ne 36 ) { $retval = $null } Return $retval } Function Get-GUIDFromMSIUninstallString ([string]$str) { $start = $str.IndexOf('{') + 1 $end = $str.IndexOf('}') $retval = $str.Substring($start, $end - $start) If ( $retval.Length -ne 36 ) { $retval = $null } Return $retval } # Function to uninstall an MSI package based on it's name Function Uninstall-MSI { param( [Parameter(ValueFromPipeline=$true,Mandatory=$true)][string[]]$APP_NAMES, [Parameter(ValueFromPipeline=$false,Mandatory=$false)][switch]$Match, [Parameter(ValueFromPipeline=$false,Mandatory=$false)][switch]$IncludeNonMSI ) BEGIN { # Get all of the uninstall registry keys $UNINSTALL_KEYS = Get-ChildItem -Path HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall -ErrorAction SilentlyContinue $UNINSTALL_KEYS += Get-ChildItem -Path HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall -ErrorAction SilentlyContinue # Exit if we can't find any software at all If ( $UNINSTALL_KEYS.Length -eq 0 ) { Write-Error "Could not find any installed apps in the Windows Registry" ; Return } # Array to store custom objects about each installed MSI app $INSTALLED_APPS = @() Foreach ( $reg in $UNINSTALL_KEYS ) { # Get the uninstall key $REG_PROPERTY = Get-ItemProperty -Path $reg.PSPath # Skip apps missing both the UninstallString and ModifyPath If ( [string]::IsNullOrEmpty($REG_PROPERTY.UninstallString) -and [string]::IsNullOrEmpty($REG_PROPERTY.ModifyPath) ) { Continue } # Determine if the app is installed via MSI If ( $REG_PROPERTY.WindowsInstaller -eq 1 ) { $MSI = $true # Get the product code from the UninstallString If ( ![string]::IsNullOrEmpty($REG_PROPERTY.UninstallString) ) { $PRODUCT_CODE = $(Get-GUIDFromMSIUninstallString -str $REG_PROPERTY.UninstallString) } # Get the product code from the ModifyPath ElseIf ( ![string]::IsNullOrEmpty($REG_PROPERTY.ModifyPath) ) { $PRODUCT_CODE = $(Get-GUIDFromMSIUninstallString -str $REG_PROPERTY.ModifyPath) } # Don't add an app with an unknown product code If ( [string]::IsNullOrEmpty($PRODUCT_CODE) ) { Continue } } Else { $MSI = $false } # Get a usable name for the entry If ( ![string]::IsNullOrEmpty($REG_PROPERTY.DisplayName) ) { $AppName = $REG_PROPERTY.DisplayName } ElseIf ( ![string]::IsNullOrEmpty($REG_PROPERTY.Name) ) { $AppName = $REG_PROPERTY.DisplayName } Else { $AppName = '[unknown]' } $customObject = [PSCustomObject]@{ MSI = $MSI DisplayName = $AppName UninstallString = $REG_PROPERTY.UninstallString ModifyPath = $REG_PROPERTY.ModifyPath ProductCode = $PRODUCT_CODE } # TODO: Cleanup object properties $INSTALLED_APPS += $customObject } } PROCESS { Foreach ( $app in $APP_NAMES ) { Foreach ( $installed_app in $INSTALLED_APPS ) { $uninstall = $false # Do not add apps whose name does not match the one we're looking for Switch ( $Match ) { $true { If ( $installed_app.DisplayName -match $app ) { $uninstall = $true } } $false { If ( $installed_app.DisplayName -ilike $app ) { $uninstall = $true } } } # Print out uninstall string for unsupported apps If ( ($uninstall) -and ($installed_app.MSI -eq $false) ) { # Skip apps that have no display name or uninstall string If ( ([string]::IsNullOrEmpty($DisplayName)) -and ([string]::IsNullOrEmpty($UninstallString)) ) { $uninstall = $false ; Continue } Write-Output "Cannot uninstall ""${DisplayName}""`n UninstallString: ${UninstallString}" $uninstall = $false } If ( $uninstall ) { $DisplayName = $installed_app.DisplayName $UninstallString = $installed_app.UninstallString $ProductCode = $installed_app.ProductCode # Uninstall the app Write-Output "Uninstalling ""${DisplayName}"" with product code: ${ProductCode}" $arguments = '/X{' + $ProductCode + '} /qn /norestart' Try { Start-Process -FilePath "msiexec.exe" -ArgumentList $arguments -Wait } Catch { Write-Error $_.Exception.Message } } } } } } # Reboot an endpoint based on the amount of time it has been running without a reboot Function Restart-EndpointOnUptime ([timespan]$MaxUptime) { # Get the length of time the endpoint has been running without restart Try { $LastBootTime = (Get-CimInstance -ClassName Win32_OperatingSystem -ErrorAction Stop).LastBootUpTime } Catch { Write-Error $_.Exception.Message ; Exit } # Get the difference between the endpoint uptime and the current time $Delta = New-TimeSpan -Start $LastBootTime -End $(Get-Date) # Stop the function if the endpoint has not exceeded $MaxUptime If ( $Delta -lt $MaxUptime ) { Exit } # Reboot the endpoint Try { Restart-Computer -Force -ErrorAction Stop } Catch { Write-Error $_.Exception.Message } } # Function to download and install local tools used by scripts Function Install-LocalTools () { param( [Parameter(ValueFromPipeline=$false,Mandatory=$false)][switch]$Force=$false ) $ToolURLs = @( 'https://xfer.emberkom.com/shares/tools/folders/9b9988fb-c53a-4833-a4ad-68d01a3021bb/files/bluescreenview-x64-exe/download/BlueScreenView-x64.exe' 'https://xfer.emberkom.com/shares/tools/folders/9b9988fb-c53a-4833-a4ad-68d01a3021bb/files/bluescreenview-x86-exe/download/BlueScreenView-x86.exe' 'https://xfer.emberkom.com/shares/tools/folders/9b9988fb-c53a-4833-a4ad-68d01a3021bb/files/etl2pcapng-exe/download/etl2pcapng.exe' ) Foreach ( $ToolURL in $ToolURLs ) { $ToolName = Split-Path -Leaf $ToolURL $ToolPath = $Global:ToolsDirectory + '\' + $ToolName If ( (Test-Path $ToolPath) -and ($Force -eq $false) ) { Continue } Write-Output "Installing ${ToolName}" Download-File -URL $ToolURL -File $ToolPath } } Function Source-PSScript ([string]$ScriptName) { If ( $ScriptName.StartsWith('http://') -or $ScriptName.StartsWith('https://') ) { $URL = $ScriptName } Else { $URL = "https://dev.emberkom.com/emberkom/management-scripts/raw/branch/master/${ScriptName}.ps1" } $ScriptFile = Download-File -URL $URL Write-Output "Sourcing ${ScriptFile}" . $ScriptFile If ( Test-Path $ScriptFile ) { Write-Output "Removing ${ScriptFile}" ; Remove-Item $ScriptFile -Force -ErrorAction SilentlyContinue } } # Forcefully maps a network drive but requires user's credentials to already exist in Credential Manager Function Create-NetworkDrive { param ( [Parameter(Mandatory)] [ValidatePattern("^[A-Z]:$")] [string]$DriveLetter, [Parameter(Mandatory)] [string]$Path, [Parameter(Mandatory)] [string]$Label ) $existingDrive = Get-CimInstance Win32_LogicalDisk | Where-Object { $_.DeviceID -eq $DriveLetter } if (-not $existingDrive) { Write-Output "Mapping ${Path} to drive letter ${DriveLetter}" cmd.exe /c "net use $DriveLetter $Path /persistent:yes" | Out-Null } elseif ($existingDrive.ProviderName -ne $Path) { Write-Output "Drive exists but points to a different path. Remapping..." cmd.exe /c "net use $DriveLetter /delete /y" | Out-Null cmd.exe /c "net use $DriveLetter $Path /persistent:yes" | Out-Null } else { Write-Verbose "Drive already mapped correctly." } Start-Sleep -Seconds 2 try { $dl = $DriveLetter.TrimEnd(':') $vol = Get-Volume -DriveLetter $dl -ErrorAction Stop if ($vol.FileSystemLabel -ne $Label) { Write-Output "Setting ${DriveLetter} drive label to ""${Label}""" Set-Volume -DriveLetter $dl -NewFileSystemLabel $Label } } catch { Write-Verbose "Could not set volume label (possibly unsupported context)." } } function Install-SystemFont { [CmdletBinding(SupportsShouldProcess=$true)] param ( [Parameter(Mandatory=$true)] [ValidateNotNullOrEmpty()] [string]$FontPath ) try { $fontFile = Get-Item -LiteralPath $FontPath -ErrorAction Stop } catch { Write-Error "Font file '$FontPath' could not be found or accessed: $($_.Exception.Message)" return } if ($fontFile.PSIsContainer) { Write-Error "Font path '$FontPath' points to a directory. Specify a .otf or .ttf file." return } $extension = $fontFile.Extension.ToLowerInvariant() if ($extension -notin @('.otf', '.ttf')) { Write-Error "Only .otf and .ttf font files are supported." return } # Read the font's embedded family and face names instead of relying on # language- and Windows-version-dependent Shell property column numbers. try { Add-Type -AssemblyName PresentationCore -ErrorAction Stop $glyphTypeface = New-Object System.Windows.Media.GlyphTypeface ([Uri]$fontFile.FullName) $englishLanguage = [System.Globalization.CultureInfo]::GetCultureInfo('en-US') $fontFamily = $null $fontFace = $null if (-not $glyphTypeface.FamilyNames.TryGetValue($englishLanguage, [ref]$fontFamily)) { $fontFamily = $glyphTypeface.FamilyNames.Values | Select-Object -First 1 } if (-not $glyphTypeface.FaceNames.TryGetValue($englishLanguage, [ref]$fontFace)) { $fontFace = $glyphTypeface.FaceNames.Values | Select-Object -First 1 } if ([string]::IsNullOrWhiteSpace($fontFamily)) { throw "The font does not contain a readable family name." } if ([string]::IsNullOrWhiteSpace($fontFace) -or $fontFace -in @('Normal', 'Regular')) { $fontName = $fontFamily } else { $fontName = "$fontFamily $fontFace" } } catch { Write-Error "Font metadata could not be read from '$($fontFile.FullName)': $($_.Exception.Message)" return } $fileName = $fontFile.Name $fontsDirectory = Join-Path $env:SystemRoot 'Fonts' $destinationPath = Join-Path $fontsDirectory $fileName $registryValueName = if ($extension -eq '.otf') { "$fontName (OpenType)" } else { "$fontName (TrueType)" } try { if (-not ('Emberkom.NativeFontMethods' -as [type])) { Add-Type -TypeDefinition @' using System; using System.Runtime.InteropServices; namespace Emberkom { public static class NativeFontMethods { [DllImport("gdi32.dll", CharSet = CharSet.Unicode, SetLastError = true)] public static extern int AddFontResource(string fileName); [DllImport("user32.dll", CharSet = CharSet.Unicode, SetLastError = true)] public static extern IntPtr SendMessageTimeout( IntPtr windowHandle, uint message, UIntPtr wParam, IntPtr lParam, uint flags, uint timeout, out UIntPtr result ); } } '@ -ErrorAction Stop } } catch { Write-Error "Windows font installation support could not be initialized: $($_.Exception.Message)" return } if (-not $PSCmdlet.ShouldProcess($destinationPath, "Install system font '$fontName'")) { return } try { $copyRequired = $true if (Test-Path -LiteralPath $destinationPath) { $sourceHash = (Get-FileHash -LiteralPath $fontFile.FullName -Algorithm SHA256 -ErrorAction Stop).Hash $destinationHash = (Get-FileHash -LiteralPath $destinationPath -Algorithm SHA256 -ErrorAction Stop).Hash $copyRequired = $sourceHash -ne $destinationHash if (-not $copyRequired) { Write-Output "Font file '$fileName' is already present in '$fontsDirectory'." } } if ($copyRequired) { Copy-Item -LiteralPath $fontFile.FullName -Destination $destinationPath -Force -ErrorAction Stop Write-Output "Copied font file '$fileName' to '$fontsDirectory'." } $fontRegistryKey = [Microsoft.Win32.Registry]::LocalMachine.OpenSubKey( 'SOFTWARE\Microsoft\Windows NT\CurrentVersion\Fonts', $true ) if ($null -eq $fontRegistryKey) { throw "The system Fonts registry key could not be opened for writing." } try { $fontRegistryKey.SetValue( $registryValueName, $fileName, [Microsoft.Win32.RegistryValueKind]::String ) } finally { $fontRegistryKey.Dispose() } Write-Output "Registered '$registryValueName' as a system font." $fontsAdded = [Emberkom.NativeFontMethods]::AddFontResource($destinationPath) if ($fontsAdded -eq 0) { throw "Windows did not load '$destinationPath' into the current session." } Write-Output "Loaded '$fontName' into the current Windows session." # Notify applications in this session without allowing a hung window to # block an unattended RMM script indefinitely. $broadcastHandle = [IntPtr]0xffff $fontChangeMessage = 0x001D $abortIfHung = 0x0002 $messageResult = [UIntPtr]::Zero $notificationSent = [Emberkom.NativeFontMethods]::SendMessageTimeout( $broadcastHandle, $fontChangeMessage, [UIntPtr]::Zero, [IntPtr]::Zero, $abortIfHung, 1000, [ref]$messageResult ) if ($notificationSent -eq [IntPtr]::Zero) { Write-Output "Installed system font '$fontName', but no application acknowledged the font-change notification." return } Write-Output "Installed system font '$fontName' successfully." } catch { Write-Error "Failed to install font '$($fontFile.FullName)': $($_.Exception.Message)" } } # Usage Example: # Install-SystemFont -FontPath "C:\Path\To\YourFont.otf" # Function to import the Syncro Module Function Import-RMMModule () { Try { Import-Module $env:SyncroModule -WarningAction SilentlyContinue -ErrorAction Stop } Catch { Write-Error $_.Exception.Message ; Return } } # Function to create a new ticket Function New-RMMTicket () { param( [Parameter(ValueFromPipeline=$false,Mandatory=$true)][string]$Subject, [Parameter(ValueFromPipeline=$false,Mandatory=$false)][string]$IssueType="Remote Support", [Parameter(ValueFromPipeline=$false,Mandatory=$true)][string]$InitialIssue ) If ( !(Get-Command Create-Syncro-Ticket -ErrorAction SilentlyContinue) ) { Import-RMMModule} Try { $Ticket = Create-Syncro-Ticket -Subject $Subject -IssueType $IssueType -Status "New" } Catch { Write-Error $_.Exception.Message ; Return } $Global:TicketNumber = $Ticket.ticket.id New-TicketComment -TicketID $Global:TicketNumber -Subject "Issue" -Comment $InitialIssue -Hidden -DoNotEmail } # Function to create a new comment on a ticket Function New-TicketComment () { param( [Parameter(ValueFromPipeline=$false,Mandatory=$false)]$TicketID=$null, [Parameter(ValueFromPipeline=$false,Mandatory=$false)][string]$Subject="Update", [Parameter(ValueFromPipeline=$true,Mandatory=$true)][string]$Comment, [Parameter(ValueFromPipeline=$false,Mandatory=$false)][switch]$Hidden=$false, [Parameter(ValueFromPipeline=$false,Mandatory=$false)][switch]$DoNotEmail=$false ) If ( !(Get-Command Create-Syncro-Ticket-Comment -ErrorAction SilentlyContinue) ) { Import-RMMModule} If ( ($null -eq $TicketID) -and ($null -eq $Global:TicketNumber) ) { Return } If ( ($null -eq $TicketID) -and ($null -ne $Global:TicketNumber) ) { $TicketID = $Global:TicketNumber } Try { Create-Syncro-Ticket-Comment -TicketIdOrNumber $TicketID -Subject $Subject -Body $Comment -Hidden $Hidden -DoNotEmail $DoNotEmail } Catch { Write-Error $_.Exception.Message ; Return } } # Function to create a new billable time entry on a ticket Function New-TicketTimerEntry () { param( [Parameter(ValueFromPipeline=$false,Mandatory=$false)]$TicketID=$null, [Parameter(ValueFromPipeline=$false,Mandatory=$false)][int]$BillableMinutes=15, [Parameter(ValueFromPipeline=$true,Mandatory=$true)][string]$Comment, [Parameter(ValueFromPipeline=$false,Mandatory=$false)][string]$BillableUser=$Global:TimeAttributedToUser, [Parameter(ValueFromPipeline=$false,Mandatory=$false)][switch]$ChargeLater=$false ) If ( $BillableUser -eq "" ) { Write-Error "Billable user not specified" ; Return } If ( !(Get-Command Create-Syncro-Ticket-TimerEntry -ErrorAction SilentlyContinue) ) { Import-RMMModule} If ( $ChargeLater -eq $true ) { $ChargeTime = "false" } Else { $ChargeTime = "true" } $StartAt = (Get-Date).AddMinutes(-$BillableMinutes).ToString("o") Create-Syncro-Ticket-TimerEntry -TicketIdOrNumber $TicketID -StartTime $StartAt -DurationMinutes $BillableMinutes -Notes $Comment -UserIdOrEmail $BillableUser -ChargeTime $ChargeTime } # Function to get the SHA256 hash of a string Function Get-StringHash() { param([Parameter(Mandatory=$true,ValueFromPipeline=$true)][string]$String) $stream = [IO.MemoryStream]::new([byte[]][char[]]$String) $hashObj = Get-FileHash -InputStream $stream -Algorithm SHA256 $hashObj.Hash } # Function to enable or disable the profile prompt when launching Outlook Function Set-OutlookProfilePrompt () { param( [Parameter(ValueFromPipeline=$false,Mandatory=$true,ParameterSetName='enable')][switch]$Enable, [Parameter(ValueFromPipeline=$false,Mandatory=$true,ParameterSetName='disable')][switch]$Disable ) If ( $Enable ) { $val = '1' ; $action = "Enabling"} If ( $Disable ) { $val = '0' ; $action = "Disabling"} Write-Output "${action} profile picker on Outlook launch" [Microsoft.Win32.Registry]::SetValue('HKEY_CURRENT_USER\SOFTWARE\Microsoft\Exchange\Client\Options','PickLogonProfile',$val,[Microsoft.Win32.RegistryValueKind]::String) $Profiles = (Get-ChildItem -Path 'HKCU:\SOFTWARE\Microsoft\Office\16.0\Outlook\Profiles' | Select-Object -ExpandProperty Name | Split-Path -Leaf | Sort-Object) -join "`n" Write-Output "Available Outlook profiles:`n${Profiles}" } # Function to install and run script using Powershell 7 # Provided by j.mcbride from https://community.syncromsp.com/t/powershell-7-2/7425/5 Function Start-ScriptInPowershell7 () { # Check for required PowerShell version (7+) If (!($PSVersionTable.PSVersion.Major -ge 7)) { Try { # Install PowerShell 7 if missing If (!(Test-Path "$env:SystemDrive\Program Files\PowerShell\7")) { Write-Output 'Installing PowerShell version 7...' Invoke-Expression "& { $(Invoke-RestMethod https://aka.ms/install-powershell.ps1) } -UseMSI -Quiet" } # Refresh PATH $Env:Path = [System.Environment]::GetEnvironmentVariable('Path', 'Machine') + ';' + [System.Environment]::GetEnvironmentVariable('Path', 'User') # Restart script in PowerShell 7 pwsh -File "`"$PSCommandPath`"" @PSBoundParameters } Catch { Write-Error $_.Exception.Message } Finally { Exit $LASTEXITCODE } } # Input the actual script below this line } # Upgrade default TLS version to 1.2 Try { [Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12 } Catch { Write-Error $_.Exception.Message } # Initial setup of the MSP management directories and log file Setup-MSPDirectories Setup-LogFile # Install the local tools #Install-LocalTools # Check the RMM runtime variable to see if a billable user was specified, if so then set the $TimeAttributedToUser If ( $TimeAttributedToUser ) { If ( $TimeAttributedToUser.Trim().Length -ge 6 ) { $Global:TimeAttributedToUser = $TimeAttributedToUser.Trim().ToLower() } } # Check the RMM runtime variable to see if a ticket number was specified, if so then set the $TicketID If ( $TicketNumber ) { If ( $TicketNumber.Trim().Length -gt 1 ) { $Global:TicketNumber = $TicketNumber.Trim() } }