Create Dynamic Application Packages with PowerShell

Detection

Lets start by looking at the way we obtain the latest version and check it again the version in the registry.

As you can see from the image below, there is a version table right at the top of the web page.

If you press F12 and open the developer options, you can click through the HTML sections in the Elements tab and find the table like below;

As you can see from the snippet below we have to use a `HTMLContent` **COM** object to parse the HTML data so we can interact with the tables.

In it’s simplest form we get the RawContent and then write it to the IHTMLDocument2 object with the COM object, giving us the functionality work with the tables.

Copy to Clipboard

function Get-LatestVersion {
    [String]$URL = "https://docs.microsoft.com/en-us/windows-server/remote/remote-desktop-services/clients/windowsdesktop-whatsnew"
    $WebResult = Invoke-WebRequest -Uri $URL -UseBasicParsing 
    $WebResultHTML = $WebResult.RawContent

$HTML = New-Object -Com "HTMLFile"
    $HTML.IHTMLDocument2_write($WebResultHTML)

$Tables = @($html.all.tags('table'))
    $LatestVer = $null
    [System.Collections.ArrayList]$LatestVer = New-Object -TypeName psobject
    for ($i = 0; $i -le $tables.count; $i++) {
        $table = $tables[0] 
        $titles = @()
        $rows = @($table.Rows)
        ## Go through all of the rows in the table
        foreach ($row in $rows) {
            $cells = @($row.Cells)
    
            ## If we've found a table header, remember its titles
            if ($cells[0].tagName -eq "TH") {
                $titles = @($cells | ForEach-Object {
                        ("" + $_.InnerText).Trim()
                    })
                continue
            }
            $resultObject = [Ordered] @{}
            $counter = 0
            foreach ($cell in $cells) {
                $title = $titles[$counter]
                if (-not $title) { continue }
                $resultObject[$title] = ("" + $cell.InnerText).Trim()
                $Counter++
            }
            #$Version_Data = @()
            $Version_Data = [PSCustomObject]@{
                'LatestVersion'          = $resultObject.'Latest version'
            }
            $LatestVer.Add($Version_Data) | Out-null 
        }
    }
    $LatestVer
}

Let’s take a closer look at the interaction with the tables, as you can see the variable $Tables uses the the $HTML variable which contains the COM object data to select everything with the tag of table (`$Tables = @($html.all.tags(‘table’))`). From this point it uses a for loop to gather the table data, until finally we decide which part of the table we want to use.

For example, We are focusing on the latest version, so if you run the for loop manually and look at $resultObjectin PowerShell it will return something like this;

From this point you can create a PSCustomObject with the table header you want. Now this is kind of over complicating it for this example as you could just return `$resultObject.’Latest version’` however, I use this loop for other methods and keeping it in this format helps me standardise the way I work, but it also gives you the ability to use if for other things too.

All of this is wrapped inside a function (`Get-LatestVersion`) as I plan on using the same script for the detection method as for the install, but I also like to re-check in my install script that the application definitely is not installed before the install action executes. If you look at the `Detect-Application` function you can see that I check both the 64-bit and 32-bit registry locations with an IF statement based on the variables below;

Copy to Clipboard

The IF statement uses an `-or` operator, meaning if one of the conditions matches then run the code within the brackets below. As you can see from the variables the `$LatestVersion` uses the `Get-LatestVersion` function which is used to match the display version in the registry.

This the fundamental foundation of the operation, as we can now detect the application without using any additional modules in the next section we will look at the download and installation of the app.

Download Link

Download & Install

Before we look at the install function, lets look at the logic that calls the install.

Lets just assume you called the script with the Install execution type (`.`) or launched it without any parameters.

Lets look inside the default section (lines 17-27) below, firstly it will check if the latest version of the application is not installed using an IF statement, ELSE return that it is already installed.

If the application is not installed it then proceeds to attempt the installation in a `try{} catch{}` statement. The basics of this is as it says, it will try the install, if it fails it will catch it and throw back the `Write-Error` text.

Copy to Clipboard

Lets take a look at the `Install-Application` function that is called in the statement.

Lets Break it down into stages.

Checks if the `$DownloadPath` exists, if not it will try to create it.
Download the installer from the Link to the Download folder (`$DownloadPath`)
Install the MSI with the additional command line arguments `“$DownloadPath$InstallerName”” /qn /norestart /l* “”$DownloadPathRDINSTALL$(get-Date -format yyyy-MM-dd).log””`

Tip

When using double quotes (“) inside double quotes you must double them up.

For Example “The file is located: “”$VariablePath.txt”””

Copy to Clipboard

$LatestVersion = ((Get-LatestVersion | Get-Unique | Sort-Object $_.LatestVersion)[0]).LatestVersion
$InstallerName = "RemoteDesktop-$LatestVersion-$Arch.msi"

function Install-Application {
    IF (!(Test-Path $DownloadPath)) {
        try {
            Write-Verbose "$DownloadPath Does not exist, Creating the folder"
            MKDIR $DownloadPath -ErrorAction Stop | Out-Null
        } catch {
            Write-Verbose "Failed to create folder $DownloadPath"
        }
    }
    
    try {
        Write-Verbose "Attempting client download"
        Invoke-WebRequest -Usebasicparsing -URI $DownloadLink -Outfile "$DownloadPath\$InstallerName" -ErrorAction Stop
    }
    catch {
        Write-Error "Failed to download $AppName"
    }
    
    try {
        "Installing $AppName v$($LatestVersion)"
        Start-Process "MSIEXEC.exe" -ArgumentList "/I ""$DownloadPath\$InstallerName"" /qn /norestart /l* ""$DownloadPath\RDINSTALL$(get-Date -format yyyy-MM-dd).log""" -Wait
    }
    catch {
        Write-Error "failed to Install $AppName"
    }
}
```
{{< /collapse >}}

As we have a dynamic installation, we want the same for the uninstall right?

Well this is also achievable, take a look the the `Uninstall-Application` function below;

```posh
$UninstallKey = "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\"
$UninstallKeyWow6432Node = "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\"
$AppName = "Remote Desktop"

function Uninstall-Application {
    try {
        "Uninstalling $AppName"

IF (Get-ChildItem -Path $UninstallKey | Get-ItemProperty | Where-Object {$_.DisplayName -like "*$AppName*"} -ErrorAction SilentlyContinue) {
            "Uninstalling $AppName"
            $UninstallGUID = (Get-ChildItem -Path $UninstallKey | Get-ItemProperty | Where-Object {$_.DisplayName -like "*$AppName*"}).PSChildName
            $UninstallArgs = "/X " + $UninstallGUID + " /qn"
            Start-Process "MSIEXEC.EXE" -ArgumentList $UninstallArgs -Wait
        }      
        
        IF (Get-ChildItem -Path $UninstallKeyWow6432Node | Get-ItemProperty | Where-Object {$_.DisplayName -like "*$AppName*"} -ErrorAction SilentlyContinue) {
            "Uninstalling $AppName" 
            $UninstallGUID = (Get-ChildItem -Path $UninstallKeyWow6432Node | Get-ItemProperty | Where-Object {$_.DisplayName -like "*$AppName*"}).UninstallString
            $UninstallArgs = "/X " + $UninstallGUID + " /qn"
            Start-Process "MSIEXEC.EXE" -ArgumentList $UninstallArgs -Wait
        }

} catch {
        Write-Error "failed to Uninstall $AppName"
    }
}

```

This is using some of the same logic as the **Detection** method, It checks both the 64-bit and the 32-bit registry keys to see if an application that is like the display name of our application.

If a registry entry is detected, it will obtain the **Key Name** in this case as we are dealing with an MSI. This is because the MSI Key name is the **GUID**, it will then build up the **MSIEXEC** arguments for the uninstall. After it has completed both steps it will then process with the uninstallation.

If you compile all of the sections together with a little bit of formatting you will end up with a script like the one below.

#####  Examples

To Install the 64-Bit version
`.\Dynamic-RemoteDesktopClient.ps1`

To Install the 32-Bit version
`.\Dynamic-RemoteDesktopClient.ps1 -Arch '32-bit'`

To detect the installation only
`.\Dynamic-RemoteDesktopClient.ps1 -ExecutionType Detect`

To uninstall the application
`.\Dynamic-RemoteDesktopClient.ps1 -ExecutionType Uninstall`

You will need to change the param block variable for `$ExecutionType` to `$ExecutionType = Detect` when using this as a detection method within Intune or ConfigMGR.

```posh
<#
.SYNOPSIS
  This is a script to Dynamically Detect, Install and Uninstall the Microsoft Remote Desktop Client for Windows.
  
  https://docs.microsoft.com/en-us/windows-server/remote/remote-desktop-services/clients/windowsdesktop

.DESCRIPTION
  Use this script to detect, install or uninstall the Microsoft Remote Desktop client for Windows

.PARAMETER Arch
    Select the architecture you would like to install, select from the following
    - 64-bit (Default)
    - 32-bit
    - ARM64

.PARAMETER ExecutionType
    Select the Execution type, this determines if you will be detecting, installing uninstalling the application.
    
    The options are as follows;
    - Install (Default)
    - Detect
    - Uninstall

.Parameter DownloadPath
    The location you would like the downloaded installer to go.

Default: $env:TEMP\RDInstaller

.NOTES
  Version:        1.2
  Author:         David Brook
  Creation Date:  21/02/2021
  Purpose/Change: Initial script development
  
#>

param (
    [ValidateSet('64-bit','32-bit','ARM64')]
    [String]$Arch = '64-bit',
    [ValidateSet('Install','Uninstall',"Detect")]
    [string]$ExecutionType,
    [string]$DownloadPath = "$env:Temp\RDInstaller\"
)

function Get-LatestVersion {
    [String]$URL = "https://docs.microsoft.com/en-us/windows-server/remote/remote-desktop-services/clients/windowsdesktop-whatsnew"
    $WebResult = Invoke-WebRequest -Uri $URL -UseBasicParsing 
    $WebResultHTML = $WebResult.RawContent

$HTML = New-Object -Com "HTMLFile"
    $HTML.IHTMLDocument2_write($WebResultHTML)

$Tables = @($html.all.tags('table'))
    $LatestVer = $null
    [System.Collections.ArrayList]$LatestVer = New-Object -TypeName psobject
    for ($i = 0; $i -le $tables.count; $i++) {
        $table = $tables[0] 
        $titles = @()
        $rows = @($table.Rows)
        ## Go through all of the rows in the table
        foreach ($row in $rows) {
            $cells = @($row.Cells)
    
            ## If we've found a table header, remember its titles
            if ($cells[0].tagName -eq "TH") {
                $titles = @($cells | ForEach-Object {
                        ("" + $_.InnerText).Trim()
                    })
                continue
            }
            $resultObject = [Ordered] @{}
            $counter = 0
            foreach ($cell in $cells) {
                $title = $titles[$counter]
                if (-not $title) { continue }
                $resultObject[$title] = ("" + $cell.InnerText).Trim()
                $Counter++
            }
            #$Version_Data = @()
            $Version_Data = [PSCustomObject]@{
                'LatestVersion'          = $resultObject.'Latest version'
            }
            $LatestVer.Add($Version_Data) | Out-null 
        }
    }
    $LatestVer
}
function Get-DownloadLink {
    $URL = "https://docs.microsoft.com/en-us/windows-server/remote/remote-desktop-services/clients/windowsdesktop"
    $WebResult = Invoke-WebRequest -Uri $URL -UseBasicParsing 
    $WebResultHTML = $WebResult.RawContent

$HTML = New-Object -Com "HTMLFile"
    $HTML.IHTMLDocument2_write($WebResultHTML)

($HTML.links | Where-Object {$_.InnerHTMl -Like "*$Arch*"}).href        
}
function Detect-Application {
    IF (((Get-ChildItem -Path $UninstallKey | Get-ItemProperty | Where-Object {$_.DisplayName -like "*$AppName*"}).DisplayVersion -Match $LatestVersion) -or ((Get-ChildItem -Path $UninstallKeyWow6432Node | Get-ItemProperty | Where-Object {$_.DisplayName -like "*$AppName*"}).DisplayVersion -Match $LatestVersion))
    {
        $True
    }
}
function Install-Application {
    IF (!(Test-Path $DownloadPath)) {
        try {
            Write-Verbose "$DownloadPath Does not exist, Creating the folder"
            MKDIR $DownloadPath -ErrorAction Stop | Out-Null
        } catch {
            Write-Verbose "Failed to create folder $DownloadPath"
        }
    }
    
    try {
        Write-Verbose "Attempting client download"
        Invoke-WebRequest -Usebasicparsing -URI $DownloadLink -Outfile "$DownloadPath\$InstallerName" -ErrorAction Stop
    }
    catch {
        Write-Error "Failed to download $AppName"
    }
    
    try {
        "Installing $AppName v$($LatestVersion)"
        Start-Process "MSIEXEC.exe" -ArgumentList "/I ""$DownloadPath\$InstallerName"" /qn /norestart /l* ""$DownloadPath\RDINSTALL$(get-Date -format yyyy-MM-dd).log""" -Wait
    }
    catch {
        Write-Error "failed to Install $AppName"
    }
}

function Uninstall-Application {
    try {
        "Uninstalling $AppName"

IF (Get-ChildItem -Path $UninstallKey | Get-ItemProperty | Where-Object {$_.DisplayName -like "*$AppName*"} -ErrorAction SilentlyContinue) {
            "Uninstalling $AppName"
            $UninstallGUID = (Get-ChildItem -Path $UninstallKey | Get-ItemProperty | Where-Object {$_.DisplayName -like "*$AppName*"}).PSChildName
            $UninstallArgs = "/X " + $UninstallGUID + " /qn"
            Start-Process "MSIEXEC.EXE" -ArgumentList $UninstallArgs -Wait
        }      
        
        IF (Get-ChildItem -Path $UninstallKeyWow6432Node | Get-ItemProperty | Where-Object {$_.DisplayName -like "*$AppName*"} -ErrorAction SilentlyContinue) {
            "Uninstalling $AppName" 
            $UninstallGUID = (Get-ChildItem -Path $UninstallKeyWow6432Node | Get-ItemProperty | Where-Object {$_.DisplayName -like "*$AppName*"}).UninstallString
            $UninstallArgs = "/X " + $UninstallGUID + " /qn"
            Start-Process "MSIEXEC.EXE" -ArgumentList $UninstallArgs -Wait
        }

} catch {
        Write-Error "failed to Uninstall $AppName"
    }
}

$UninstallKey = "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\"
$UninstallKeyWow6432Node = "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\"
$LatestVersion = ((Get-LatestVersion | Get-Unique | Sort-Object $_.LatestVersion)[0]).LatestVersion
$InstallerName = "RemoteDesktop-$LatestVersion-$Arch.msi"
$AppName = "Remote Desktop"
$DownloadLink = Get-DownloadLink

switch ($ExecutionType) {
    Detect { 
        Detect-Application 
    }
    Uninstall {
        try {
                Uninstall-Application -ErrorAction Stop
                "Uninstallation Complete"
        } 
        catch {
            Write-Error "Failed to Install $AppName"
        }
    }
    Default {
        IF (!(Detect-Application)) {
            try {
                "The latest version is not installed, Attempting install"
                Install-Application -ErrorAction Stop
                "Installation Complete"
            } catch {
                Write-Error "Failed to Install $AppName"
            }
        } ELSE {
            "The Latest Version ($LatestVersion) of $AppName is already installed"
        }
    }
}

Uninstall

As we have a dynamic installation, we want the same for the uninstall right?

Well this is also achievable, take a look the the `Uninstall-Application` function below;

Copy to Clipboard

$UninstallKey = "HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall\"
$UninstallKeyWow6432Node = "HKLM:\SOFTWARE\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\"
$AppName = "Remote Desktop"

function Uninstall-Application {
    try {
        "Uninstalling $AppName"

IF (Get-ChildItem -Path $UninstallKey | Get-ItemProperty | Where-Object {$_.DisplayName -like "*$AppName*"} -ErrorAction SilentlyContinue) {
            "Uninstalling $AppName"
            $UninstallGUID = (Get-ChildItem -Path $UninstallKey | Get-ItemProperty | Where-Object {$_.DisplayName -like "*$AppName*"}).PSChildName
            $UninstallArgs = "/X " + $UninstallGUID + " /qn"
            Start-Process "MSIEXEC.EXE" -ArgumentList $UninstallArgs -Wait
        }      
        
        IF (Get-ChildItem -Path $UninstallKeyWow6432Node | Get-ItemProperty | Where-Object {$_.DisplayName -like "*$AppName*"} -ErrorAction SilentlyContinue) {
            "Uninstalling $AppName" 
            $UninstallGUID = (Get-ChildItem -Path $UninstallKeyWow6432Node | Get-ItemProperty | Where-Object {$_.DisplayName -like "*$AppName*"}).UninstallString
            $UninstallArgs = "/X " + $UninstallGUID + " /qn"
            Start-Process "MSIEXEC.EXE" -ArgumentList $UninstallArgs -Wait
        }

} catch {
        Write-Error "failed to Uninstall $AppName"
    }
}

This is using some of the same logic as the **Detection** method, It checks both the 64-bit and the 32-bit registry keys to see if an application that is like the display name of our application.

If a registry entry is detected, it will obtain the Key Name in this case as we are dealing with an MSI. This is because the MSI Key name is the GUID, it will then build up the MSIEXEC arguments for the uninstall. After it has completed both steps it will then process with the uninstallation.

Finished Script

To Install the 64-Bit version

`.Dynamic-RemoteDesktopClient.ps1`

To Install the 32-Bit version

`.Dynamic-RemoteDesktopClient.ps1 -Arch ’32-bit’`

To detect the installation only

`.Dynamic-RemoteDesktopClient.ps1 -ExecutionType Detect`

To uninstall the application

`.Dynamic-RemoteDesktopClient.ps1 -ExecutionType Uninstall`

Note

You will need to change the param block variable for `$ExecutionType` to `$ExecutionType = Detect` when using this as a detection method within Intune or ConfigMGR.

Copy to Clipboard

<#
.SYNOPSIS
  This is a script to Dynamically Detect, Install and Uninstall the Microsoft Remote Desktop Client for Windows.
  
  https://docs.microsoft.com/en-us/windows-server/remote/remote-desktop-services/clients/windowsdesktop