dangough / nevergreen Goto Github PK

# Get-OpenSSL.ps1

$AppName = "OpenSSL"
$ReleaseURL = 'https://openssl-library.org/source/index.html'

$Releases = @(
    @{Type = 'Gz'; Ring ='3.0'; Pattern = '(3\.0\.\d+)'}
    @{Type = 'Gz'; Ring ='3.1'; Pattern = '(3\.1\.\d+)'}
    @{Type = 'Gz'; Ring ='3.2'; Pattern = '(3\.2\.\d+)'}
    @{Type = 'Gz'; Ring ='3.3'; Pattern = '(3\.3\.\d+)'}
)

foreach ($Release in $Releases) {
	$URL = Set-UriPrefix -Uri (Get-Link -Uri $ReleaseURL -MatchProperty href -Pattern $Release.Pattern) -Prefix $ReleaseURL
    [version]$Version = Get-Version -String $URL -Pattern '(\d+\.\d+\.\d+)'

	#Obtain Release Date and convert to "yyyy-MM-dd" format
	try {
		$Content = (Invoke-WebRequest -Uri $ReleaseURL).Content

		#$ReleaseDateRegEx = "(?s)(\d{4}-\w{3}-\d{2}).*?$($Release.Pattern)\."
		$ReleaseDateRegEx = "(?s)$($Release.Pattern).*?(\d{2}\s\w{3}\s\d{4})"

		# Extract the captured groups and display them
		foreach ($match in [regex]::Matches($Content, $ReleaseDateRegEx)) {
			$ReleasedOn = $match.Groups[2].Value  # Date group
		}
	}
	catch {
		Throw "Failed to connect to ($($ReleaseUrl)) with error $_."
		Break
	}
	finally {
		# Define a regular expression pattern to match a date in the format "Year-Month-Day"
		$pattern = "\d{1,2}\s(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec|January|February|March|April|May|June|July|August|September|October|November|December)\s\d{4}"

		# Use Select-String to find the date in the text
		$matchesfound = $ReleasedOn | Select-String -Pattern $pattern

		# Extract the matched date
		if ($matchesfound) {
			# Parse the date and reformat it to "YYYY-MM-DD"
			$ReleaseDate = (Get-Date $ReleasedOn).ToString("yyyy-MM-dd")
		} else {
			Write-Verbose "Date not found in the text."
			$ReleaseDate = ""
		}
		# Success
		New-NevergreenApp -Name $AppName -Architecture 'multi' -Version $Version -ReleaseDate $ReleaseDate -Uri $URL -Type $Release.Type -Ring $Release.Ring
	}
}

# Get-GoogleWorkspaceSync.ps1

$AppName = "Google Workspace Sync"

$Apps = @(
    @{Architecture = 'x64'; Type = 'Msi'; Pattern = 'Download 64-bit edition' } # Recommended for admins
    @{Architecture = 'x86'; Type = 'Msi'; Pattern = 'Download 32-bit edition' } # Recommended for admins
    @{Architecture = 'x86'; Type = 'Exe'; Pattern = 'Download GWSMO' } # Recommended for users
)

foreach ($App in $Apps) {
    try {
		$ReleaseURL = 'https://support.google.com/a/answer/153463'
		if ($App.Type -eq 'Exe'){
			$URL = 'https://dl.google.com/google-apps-sync/googleappssyncsetup.exe'
		} else {
			$DownloadURL = 'https://tools.google.com/dlpage/gssmo'
			$URL = Get-Link -Uri $DownloadURL -MatchProperty outerHTML -Pattern $App.Pattern
		}

        $Version = Get-Version -Uri $ReleaseURL -Pattern 'Release notes for (\d+\.\d+\.\d+\.\d+)'
        New-NevergreenApp -Name $AppName -Version $Version -Uri $URL -Architecture $App.Architecture -Type $App.Type
    }
    catch {
        Write-Error "$($MyInvocation.MyCommand): $($_.Exception.Message)"
    }
}

$webRequest = Invoke-WebRequest -UseBasicParsing -Uri ("https://www.rizonesoft.com/downloads/notepad3") -SessionVariable websession
$regexURL = "https\:\/\/www\.rizonesoft\.com\/download\/\d.+/"
$regexZip = "Notepad3_\d.\d{2}.\d{3}.\d_Setup.zip"
$appURL = $webRequest.RawContent | Select-String -Pattern $regexURL -AllMatches | ForEach-Object { $_.Matches.Value } | Select-Object -First 1
$appZip = $webRequest.RawContent | Select-String -Pattern $regexZip -AllMatches | ForEach-Object { $_.Matches.Value } | Select-Object -First 1
$appVersion = $appZip.Split("_")[1]
$appSetup = "Notepad3_$($appVersion)_Setup.exe"

@{Architecture = 'x64'; Language = 'Multi'; Pattern = 'AcroRdrDCx64Upd\d{8,12}_MUI\.msp'}

Version   Uri                                                                              Architecture
-------   ---                                                                              ------------
4.9.0.504 https://ccmdl.adobe.com/AdobeProducts/KCCC/CCD/4_9/win32/ACCCx4_9_0_504.zip      x86
5.4.5.550 https://ccmdl.adobe.com/AdobeProducts/KCCC/CCD/5_4_5/win64/ACCCx5_4_5_550.zip    x64
5.4.5.550 https://ccmdl.adobe.com/AdobeProducts/KCCC/CCD/5_4_5/winarm64/ACCCx5_4_5_550.zip ARM64

# Get-DellCommandUpdate.ps1

$AppName = "Dell Command Update"
$SummaryURL = 'https://www.dell.com/support/kbdoc/en-uk/000177325/dell-command-update'
[version]$Version = Get-Version -Uri $SummaryURL -Pattern '- Dell Command \| Update (\d+\.\d+\.\d+)'
Write-Verbose "Version :: $Version"

$Platforms = @(
    @{Architecture = 'x86'; Platform = 'Windows Universal Application'; Language = 'Neutral'; Pattern = 'Dell Command \| Update Windows Universal Application'; Download = 'Dell-Command-Update-Windows-Universal-Application_.*?_WIN_.*?\.EXE'}
    @{Architecture = 'x86'; Platform = 'Windows Application (Classic)'; Language = 'Neutral'; Pattern = 'Dell Command \| Update Application \(Classic\)'; Download = 'Dell-Command-Update-Application_.*?_WIN_.*?\.EXE'}
)

foreach ($Platform in $Platforms) {
	$SearchCount = 2

	do {
		$ReleaseURL = Get-Link -Uri $SummaryURL -MatchProperty outerHTML -Pattern $Platform.Pattern
		#Write-Verbose "Release URL :: $ReleaseURL"

		$URL = Get-Link -Uri $ReleaseURL -MatchProperty href -Pattern $Platform.Download
		#Write-Verbose "Download URL :: $URL"

		if ($URL) {
			New-NevergreenApp -Name $($AppName) -Version $Version -Uri $URL -Architecture $Platform.Architecture -Platform $Platform.Platform -Language $Platform.Language -Type 'exe'
			break
		}
		$SearchCount--
	} until ($SearchCount -eq 0)

	if ($SearchCount -eq 0) {
		Write-Warning "Could not find release for $($AppName) $($Platform.Platform) $($Platform.Architecture) $($Platform.Language)"
	}
}

[cmdletbinding()]
Param()

Clear-Host
Write-Verbose "Setting Arguments" -Verbose

[Net.ServicePointManager]::SecurityProtocol = [Net.SecurityProtocolType]::Tls12

$DetectionMethod = "Webscrape"
$AppName = "TikTokEffectHouse"
$Application = "TikTok Effect House"
#$Arch = "x64"
$AppType = "EXE"
$AppInstaller = "Effect_House_Setup.exe"
$InstallPath = "$($env:LOCALAPPDATA)\Effect House\Effect House.exe"
$DownloadsURL = "https://effecthouse.tiktok.com/download"
$ReleaseNotes = "https://effecthouse.tiktok.com/latest/release-notes-latest/"

# $PSScriptRoot should always be something like C:\Users\FSmith\gitrepos\Intune\Admin\Scripts.
# Our Base folder should be 'Intune', or 2 levels up.
$BaseFolder = "$PSScriptRoot\..\.."
$AllAppsFolder = ".\Apps"
$PrepToolExe = ".\Microsoft-Win32-Content-Prep-Tool-1.8.4\IntuneWinAppUtil.exe"

$StartTime = Get-Date

Write-Verbose "Finding installed version" -Verbose
# Check if App is installed and if it is get version
if (Test-Path -Path $InstallPath) {
    [version]$InstalledVersion = (Get-ItemProperty $InstallPath).VersionInfo.FileVersion
    Write-Host "Installed version of $($Application) is: $($InstalledVersion)"
} else {
    Write-Host "WARNING :: $($Application) is not installed" -ForegroundColor Red
}

Write-Verbose "Using $($DetectionMethod) to check for latest version from: $($ReleaseNotes)..." -Verbose
try {
    # $Web = Invoke-WebRequest -UseBasicParsing -Uri $DownloadsUrl -ErrorAction SilentlyContinue
    $Web = Invoke-WebRequest -UseBasicParsing -Uri $ReleaseNotes -ErrorAction SilentlyContinue
}
catch {
    Throw "Failed to connect to URL: $ReleaseNotes with error $_."
    Break
}
finally {
# Luckily, although this web page covers a major release it only seems to have active links to the very latest update.
# So we can determine the latest version by searching for specific text in the page...
    $PageContent = ($Web.Content)
    $SearchString = "</style><h2 class=`"css-ov5iey e15xsn0a4`">v"
    $CaptureStart = $PageContent.IndexOf($SearchString) + $SearchString.Length
    $EndIndex = $PageContent.IndexOf(" (", $CaptureStart) - $CaptureStart
    $Version = ($PageContent.Substring($CaptureStart, $EndIndex).Trim()) -replace "\.","-"
    [version]$LatestVersion = ($PageContent.Substring($CaptureStart, $EndIndex).Trim()) -replace "-","."
}

Write-Output "Latest version of $($Application) is:          $($LatestVersion)"

Write-Verbose "Using $($DetectionMethod) to find latest version download from: $($DownloadsURL)..." -Verbose
try {
    # $Web = Invoke-WebRequest -UseBasicParsing -Uri $DownloadsUrl -ErrorAction SilentlyContinue
    $Download = Invoke-WebRequest -UseBasicParsing -Uri $DownloadsURL -ErrorAction SilentlyContinue
}
catch {
    Throw "Failed to connect to URL: $DownloadsURL with error $_."
    Break
}
finally {
# This web page only seems to have an active link to the very latest update - obscured by CSS.
# So we need to determine the latest version download by searching within the links on the page...
    $DownloadContent = (($Download.Links | Where-Object {$_.href -eq "/download"}).outerHTML)
    <#
    $SourceUrl = "" # To be read from page ?
    #>
    # Current Download URL for v3.3.2.87 has been obtained in a browser:
    $SourceUrl = "https://sf16-va.tiktokcdn.com/obj/eden-va2/olaa_ajlmml_zlp/ljhwZthlaukjlkulzlp/V332_External_Release_0927/Effect_House_v3.3.2.87_101_Setup.exe"
}

<#
Other code...
N.B. Includes setting path to $Outfile
#>

# New Version available, so open Release Notes
$ReleaseNotesURL = "https://effecthouse.tiktok.com/effect-platform/latest/release-notes-latest/v$($version)/?enter_method=category_card"
Write-Output ""
Write-Host "New version $($LatestVersion) has been released, Opening release notes in default browser..." -ForegroundColor DarkGreen
Start-Process $ReleaseNotesURL
Write-Output ""

# Download the latest Installer
Write-Output ""
Write-Output "Downloading $($Application) $($LatestVersion) from $($SourceUrl)..."
$ProgressPreference = 'SilentlyContinue'
Invoke-WebRequest -Uri $SourceUrl -OutFile $Outfile

# Get-Filezilla.ps1
$Platforms = @(
    @{Architecture = 'x86'; Type = 'exe'; Pattern = 'FileZilla_\d+\.\d+\.\d+_win32-setup\.exe'}
    @{Architecture = 'x64'; Type = 'exe'; Pattern = 'FileZilla_\d+\.\d+\.\d+_win64-setup\.exe'}
    @{Architecture = 'x86'; Type = 'zip'; Pattern = 'FileZilla_\d+\.\d+\.\d+_win32\.zip'}
    @{Architecture = 'x64'; Type = 'zip'; Pattern = 'FileZilla_\d+\.\d+\.\d+_win64\.zip'}
)

foreach ($Platform in $Platforms) {

    $ReleaseURL = 'https://filezilla-project.org/download.php?show_all=1'
    $SearchCount = 3

    $Headers = @{
	"Accept"="*/*"
	"Accept-Language"="en-GB,en;q=0.9,en-US;q=0.8"
	"User-Agent" = "Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:125.0) Gecko/20100101 Firefox/125.0"
        "Host" = "filezilla-project.org"
    }

    do {
        $URL = Get-Link -Uri $ReleaseURL -Headers $Headers -MatchProperty href -Pattern $Platform.Pattern
        if ($URL) {
            $Version = ($URL | Get-Version -Pattern 'FileZilla_(\d+\.\d+\.\d+)_.+(exe|zip)')
            New-NevergreenApp -Name 'FileZilla' -Version $Version -Uri $URL -Architecture $Platform.Architecture -Type $Platform.Type
            break
        }

        $SearchCount--
    } until ($SearchCount -eq 0)

    if ($SearchCount -eq 0) {
        Write-Warning "Could not find release for FileZilla $($Platform.Architecture) $($Platform.Language)"
    }

}

get-nevergreenapp RizonesoftNotepad3 -verbose
VERBOSE: GET with 0-byte payload
VERBOSE: received -1-byte response of content type text/html; charset=UTF-8

Get-NevergreenApp -Name LibreOffice
C:\Program Files\WindowsPowerShell\Modules\nevergreen\2208.1\Apps\Get-LibreOffice.ps1 : Get-LibreOffice.ps1: Cannot val
idate argument on parameter 'Uri'. The argument "" does not match the "^(http|https)://" pattern. Supply an argument th
at matches "^(http|https)://" and try the command again.
At C:\Program Files\WindowsPowerShell\Modules\nevergreen\2208.1\Public\Get-NevergreenApp.ps1:61 char:31
+                     $Output = &$Script
+                               ~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [Write-Error], WriteErrorException
    + FullyQualifiedErrorId : Microsoft.PowerShell.Commands.WriteErrorException,Get-LibreOffice.ps1

C:\Program Files\WindowsPowerShell\Modules\nevergreen\2208.1\Apps\Get-LibreOffice.ps1 : Get-LibreOffice.ps1: Cannot val
idate argument on parameter 'Uri'. The argument "" does not match the "^(http|https)://" pattern. Supply an argument th
at matches "^(http|https)://" and try the command again.
At C:\Program Files\WindowsPowerShell\Modules\nevergreen\2208.1\Public\Get-NevergreenApp.ps1:61 char:31
+                     $Output = &$Script
+                               ~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [Write-Error], WriteErrorException
    + FullyQualifiedErrorId : Microsoft.PowerShell.Commands.WriteErrorException,Get-LibreOffice.ps1



Name         : LibreOffice
Channel      : Fresh
Language     : Multi
Architecture : x86
Type         : MSI
Version      : 7.4.1
Uri          : https://download.documentfoundation.org/libreoffice/stable/7.4.1/win/x86/LibreOffice_7.4.1_Win_x86.msi

Name         : LibreOffice
Channel      : Still
Language     : Multi
Architecture : x86
Type         : MSI
Version      : 7.3.6
Uri          : https://download.documentfoundation.org/libreoffice/stable/7.3.6/win/x86/LibreOffice_7.3.6_Win_x86.msi

C:\Program Files\WindowsPowerShell\Modules\nevergreen\2311.2\Apps\Get-LibreOffice.ps1 : Get-LibreOffice.ps1: Cannot
validate argument on parameter 'Version'. The argument is null or empty. Provide an argument that is not null or
empty, and then try the command again.
At C:\Program Files\WindowsPowerShell\Modules\nevergreen\2311.2\Public\Get-NevergreenApp.ps1:61 char:31
+                     $Output = &$Script
+                               ~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [Write-Error], WriteErrorException
    + FullyQualifiedErrorId : Microsoft.PowerShell.Commands.WriteErrorException,Get-LibreOffice.ps1

C:\Program Files\WindowsPowerShell\Modules\nevergreen\2311.2\Apps\Get-LibreOffice.ps1 : Get-LibreOffice.ps1: Cannot
validate argument on parameter 'Version'. The argument is null or empty. Provide an argument that is not null or
empty, and then try the command again.
At C:\Program Files\WindowsPowerShell\Modules\nevergreen\2311.2\Public\Get-NevergreenApp.ps1:61 char:31
+                     $Output = &$Script
+                               ~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [Write-Error], WriteErrorException
    + FullyQualifiedErrorId : Microsoft.PowerShell.Commands.WriteErrorException,Get-LibreOffice.ps1

# Get-ScooterBeyondCompare.ps1

$AppName = "Scooter Beyond Compare"
$ReleaseURL = 'https://www.scootersoftware.com/download'
$Version = ((Get-Link -Uri $ReleaseURL -MatchProperty href -Pattern '\.exe$') | Get-Version -Pattern '(\d+\.\d+(\.\d+){0,2})')

#Obtain Release Date and convert to "yyyy-MM-dd" format
try {
	$Content = (Invoke-WebRequest -Uri $ReleaseURL).RawContent
	$SearchString = ", released "
	$CaptureStart = $Content.IndexOf($SearchString) + $SearchString.Length
	$EndIndex = $Content.IndexOf("</span>", $CaptureStart) - $CaptureStart
	$ReleasedOn = $Content.Substring($CaptureStart, $EndIndex).Trim()
}
catch {
	Throw "Failed to connect to ($($ReleaseUrl)) with error $_."
	Break
}
finally {
	# Define a regular expression pattern to match a date in the format "Month. Day, Year"
    $pattern = "\b(?:Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec|January|February|March|April|May|June|July|August|September|October|November|December)\.\s\d{1,2},\s\d{4}\b"

    # Use Select-String to find the date in the text
    $matchesfound = $ReleasedOn | Select-String -Pattern $pattern

    # Extract the matched date
    if ($matchesfound) {
        # Parse the date and reformat it to "YYYY-MM-DD"
        $parsedDate = Get-Date $ReleasedOn
        #Create $LatestVersion variable to create folder structure
        $ReleaseDate = $parsedDate.ToString("yyyy-MM-dd")
        #Write-Verbose "Found Date: $ReleaseDate"
    } else {
        Write-Verbose "Date not found in the text."
		$ReleaseDate = ""
    }
	# Success
}

$Platforms = @(
    @{Architecture = 'x64'; Type = 'Msi'; Platform = 'Windows'; Language = 'English'; Uri = "https://www.scootersoftware.com/files/BCompare-$($Version)_x64.msi"}
    @{Architecture = 'x86'; Type = 'Msi'; Platform = 'Windows'; Language = 'English'; Uri = "https://www.scootersoftware.com/files/BCompare-$($Version)_x86.msi"}
    @{Architecture = 'x64'; Type = 'Zip'; Platform = 'Windows'; Language = 'English'; Uri = "https://www.scootersoftware.com/files/BCompare-$($Version).zip"}
	@{Architecture = 'x64'; Type = 'Exe'; Platform = 'Windows'; Language = 'English'; Uri = "https://www.scootersoftware.com/files/BCompare-$($Version).exe"}
	@{Architecture = 'x64'; Type = 'Exe'; Platform = 'Windows'; Language = 'German'; Uri = "https://www.scootersoftware.com/files/BCompare-de-$($Version).exe"}
	@{Architecture = 'x64'; Type = 'Exe'; Platform = 'Windows'; Language = 'French'; Uri = "https://www.scootersoftware.com/files/BCompare-fr-$($Version).exe"}
	@{Architecture = 'x64'; Type = 'Exe'; Platform = 'Windows'; Language = 'Japanese'; Uri = "https://www.scootersoftware.com/files/BCompare-jp-$($Version).exe"}
	@{Architecture = 'x64'; Type = 'Exe'; Platform = 'Windows'; Language = 'Chinese (Simplified)'; Uri = "https://www.scootersoftware.com/files/BCompare-zh-$($Version).exe"}
)

foreach ($Platform in $Platforms) {

    $SearchCount = 1

	do {
		New-NevergreenApp -Name $($AppName) -Version $($Version) -ReleaseDate $($ReleaseDate) -Language $($Platform.Language) -Uri $($Platform.Uri) -Platform $($Platform.Platform) -Architecture $($Platform.Architecture) -Type $($Platform.Type)
        break

        $SearchCount--
    } until ($SearchCount -eq 0)

    if ($SearchCount -eq 0) {
        Write-Warning "Could not find release for $($AppName) $($Platform.Platform) $($Platform.Architecture)"
    }
}

# Get-SysInternalsZoomIt.ps1

$AppName = "SysInternals ZoomIt"

$Apps = @(
    @{Architecture = 'multi'; Type = 'Zip'; Pattern = 'Download ZoomIt' }
)

$ReleaseURL = 'https://learn.microsoft.com/en-us/sysinternals/downloads/zoomit'
$URL = Get-Link -Uri $ReleaseURL -MatchProperty outerHTML -Pattern $Apps.Pattern
$Version = Get-Version -Uri $ReleaseURL -Pattern 'ZoomIt v(\d+\.\d+)'

New-NevergreenApp -Name $AppName -Version $Version -Uri $URL -Architecture $Apps.Architecture -Type $Apps.Type

# Get-AzeusConvene.ps1

$AppName = "Azeus Convene Desktop"
$ReleaseURL = 'https://www.azeusconvene.com/downloads'
[version]$Version = Get-Version -Uri $ReleaseURL -Pattern '<p>Latest Version: v*?(\d+\.\d+(\.\d+){0,2})'

$Platforms = @(
    @{Architecture = 'x64'; Type = 'Exe'; Platform = 'Windows'; Uri = "https://www.azeusconvene.com/installers/winos/standard/convene_setup.$($Version)-64bit.exe"}
    @{Architecture = 'x64'; Type = 'Dmg'; Platform = 'MacOS (Intel)';  Uri = "https://www.azeusconvene.com/installers/macos/standard/Azeus%20Convene.v$($Version).dmg"}
    @{Architecture = 'ARM64'; Type = 'Dmg'; Platform = 'MacOS (Apple)';  Uri = "https://www.azeusconvene.com/installers/macos/standard/Azeus%20Convene.aarch64.v$($Version).dmg"}
)

foreach ($Platform in $Platforms) {

    $SearchCount = 3

	do {
		[version]$AppVersion = ($Platform.Uri | Get-Version -Pattern 'convene.*?(\d+\.\d+(\.\d+){0,2}).+(exe|dmg)')
		New-NevergreenApp -Name $AppName -Version $AppVersion -Uri $Platform.Uri -Platform $Platform.Platform -Architecture $Platform.Architecture -Type $Platform.Type
        break

        $SearchCount--
    } until ($SearchCount -eq 0)

    if ($SearchCount -eq 0) {
        Write-Warning "Could not find release for $($AppName) $($Platform.Platform) $($Platform.Architecture)"
    }
}

# Get-MicrosoftOLEDBDriverforSQLServer.ps1

$AppName = "Microsoft OLE DB Driver for SQL Server"
$ReleaseUrl = "https://learn.microsoft.com/en-us/sql/connect/oledb/release-notes-for-oledb-driver-for-sql-server?view=sql-server-ver16"

$RawContent = (Invoke-WebRequest -Uri $ReleaseUrl).RawContent
Write-Verbose "Obtaining $($AppName) Release Versions..."

$pattern = [regex]::new('<h2 id="\d+">(?<version>[^<]+)</h2>\s*<p>.*?<strong><a href="(?<x64>[^"]+)"[^>]*>Download x64 installer</a></strong><br>.*?<strong><a href="(?<x86>[^"]+)"[^>]*>Download x86 installer</a></strong>(<br>.*?<strong><a href="(?<arm64>[^"]+)"[^>]*>Download Arm64 installer</a></strong>)?</p>\s*<p>Released:\s*(?<date>[^<]+)</p>', [System.Text.RegularExpressions.RegexOptions]::Singleline)
$releases = $pattern.Matches($RawContent)

# Dictionary to store the latest version for each major version
$latestVersions = @{}

# Process matches
foreach ($release in $releases) {
    $ThisVersion = [version]$release.Groups['version'].Value
    $majorVersion = $ThisVersion.Major
    $x64Url = $release.Groups['x64'].Value
    $x86Url = $release.Groups['x86'].Value
    $arm64Url = $release.Groups['arm64'].Value
    $releaseDate = $release.Groups['date'].Value

    # Update the latest version for the major version if needed
    if (-not $latestVersions.ContainsKey($majorVersion) -or $ThisVersion -gt $latestVersions[$majorVersion].Version) {
        $latestVersions[$majorVersion] = @{
            Version = $ThisVersion
            x64Url = $x64Url
            x86Url = $x86Url
            arm64Url = $arm64Url
            ReleaseDate = $releaseDate
        }
    }
}

# Filter to keep only v19.x and v18.x major versions
$majorVersionsToKeep = @(18, 19)

# Process the latest versions
foreach ($majorVersion in $majorVersionsToKeep) {
    if ($latestVersions.ContainsKey($majorVersion)) {
        $latestVersion = $latestVersions[$majorVersion]
        $ThisVersion = $latestVersion.Version
        $x64Url = $latestVersion.x64Url
        $x86Url = $latestVersion.x86Url
        $arm64Url = $latestVersion.arm64Url
        $releaseDate = $latestVersion.ReleaseDate

        $AppVersions = @(
            @{Version = $ThisVersion; Ring = $ThisVersion.Major; Type = 'msi'; Architecture = 'x86'; Uri = $x86Url}
            @{Version = $ThisVersion; Ring = $ThisVersion.Major; Type = 'msi'; Architecture = 'x64'; Uri = $x64Url}
            @{Version = $ThisVersion; Ring = $ThisVersion.Major; Type = 'msi'; Architecture = 'ARM64'; Uri = $arm64Url}
        )

        $AppLanguages = @(
            @{Language = 'Chinese (Simplified)'; Pattern = '&clcid=0x804'}
            @{Language = 'Chinese (Traditional)'; Pattern = '&clcid=0x404'}
            @{Language = 'English'; Pattern = '&clcid=0x409'} # N.B this is 'English  (United States)'
            @{Language = 'French'; Pattern = '&clcid=0x40c'}
            @{Language = 'German'; Pattern = '&clcid=0x407'}
            @{Language = 'Italian'; Pattern = '&clcid=0x410'}
            @{Language = 'Japanese'; Pattern = '&clcid=0x411'}
            @{Language = 'Korean'; Pattern = '&clcid=0x412'}
            @{Language = 'Portuguese (Brazil)'; Pattern = '&clcid=0x416'}
            @{Language = 'Russian'; Pattern = '&clcid=0x419'}
            @{Language = 'Spanish'; Pattern = '&clcid=0x40a'}
        )

        foreach ($AppVersion in $AppVersions) {
            foreach ($AppLanguage in $AppLanguages) {
                $SearchCount = 2 # This may need increasing as future versions are released
                $Version = $AppVersion.Version
                $Uri = $AppVersion.Uri
                if ($NULL -ne $Uri) {
                    do {
                        if ($Uri) {
                            $Uri = (Resolve-Uri -Uri "$($AppVersion.Uri)$($AppLanguage.Pattern)").Uri
                            Write-Verbose "New $($AppLanguage.Language) URI : $Uri"
                            # Build each link with Platform specific versions
                            New-NevergreenApp -Name $AppName -Version $Version -Ring $AppVersion.Ring -Uri $Uri -Architecture $AppVersion.Architecture -Type $AppVersion.Type -Language $AppLanguage.Language -ReleaseDate $releaseDate
                            break
                        }

                        $SearchCount--
                    } until ($SearchCount -eq 0)

                    if ($SearchCount -eq 0) {
                        Write-Warning "Could not find $($AppLanguage.Language) release for $($AppName) $($Version) ($($AppVersion.Architecture))"
                    }
                }
            }
        }
    }
}

$appURLVersion = "https://www.antidote.info/en/assistance/mises-a-jour/historique/antidote-10/windows"
$webRequest = Invoke-WebRequest -UseBasicParsing -Uri ($appURLVersion) -SessionVariable websession
$regexAppVersion = "Antidote \d\d v\d.+ Windows"
$webVersion = $webRequest.RawContent | Select-String -Pattern $regexAppVersion -AllMatches | ForEach-Object { $_.Matches.Value } | Select-Object -First 1
$appShortVersion = ($webVersion).Split(" ")[1]
$appPatchVersion = ($webVersion).Trim("Andidote $appShortVersion v").Trim(" Windows").Replace(" ", "")
$appVersion = "$appShortVersion.$appPatchVersion"
$appURLPatch = "https://telechargement12.druide.com/Win/antidote_$appShortVersion/Diff_Antidote_$($appShortVersion)_C_$($appShortVersion).$appPatchVersion.msp"
$appURLPatch2 = "https://telechargement12.druide.com/Win/antidote_$appShortVersion/Diff_Antidote_$($appShortVersion)_Module_F_$($appShortVersion).$appPatchVersion.msp"
$appURLPatch3 = "https://telechargement12.druide.com/Win/antidote_$appShortVersion/Diff_Antidote_$($appShortVersion)_Module_E_$($appShortVersion).$appPatchVersion.msp"
$appURLPatch4 = "https://telechargement12.druide.com/Win/antidote_$appShortVersion/Diff_Connectix_$($appShortVersion)_C_$($appShortVersion).$appPatchVersion.msp"
$appURLMultiMgr = "https://telechargement.druide.com/telecharger/Reseau/antidote_$appShortVersion/GestionnaireMultiposte_Antidote$appShortVersion.exe"
$appPatch = $appURLPatch.Split("/")[5]
$appPatch2 = $appURLPatch2.Split("/")[5]
$appPatch3 = $appURLPatch3.Split("/")[5]
$appPatch4 = $appURLPatch4.Split("/")[5]

Get-NevergreenApp -Name MicrosoftPowerBIDesktop
Get-Version : Unable to query URL 'https://www.microsoft.com/download/details.aspx?id=58494': The remote server returned an error: (404) Not Found.

$URL64 = (Resolve-Uri -Uri 'https://aka.ms/ssmsfullsetup').Uri
$Version = Get-Version -Uri 'https://docs.microsoft.com/en-us/sql/ssms/download-sql-server-management-studio-ssms' -Pattern 'Release number: ((?:\d+\.)+\d+)'
New-NevergreenApp -Name 'Microsoft SSMS' -Version $Version -Uri $URL64 -Architecture 'x64' -Type 'Exe'

# Get-SSMS.ps1

# Define AppName
$AppName = "Microsoft SQL Server Management Studio"

# Main script to fetch and process links
$ReleaseURL = "https://learn.microsoft.com/en-us/sql/ssms/release-notes-ssms?view=sql-server-ver16"  # Replace with the URL of the web page you want to process

Write-Verbose "Obtaining $($AppName) Release Versions...`n=============================================================================`n"
# Fetch the HTML content of the webpage
$htmlContent = Invoke-WebRequest -Uri $ReleaseUrl

# Define the RegEx pattern to match the links and capture the version number and BaseURI
$pattern = '<a[^>]*href="([^"]*)"[^>]*>\s*Download SSMS ([\d.]+)\s*</a>'

$SearchCount = ([regex]::Matches($htmlContent.RawContent, $pattern)).Count

Write-Verbose "$($AppName) Release Versions found: $($SearchCount)`n-------------------------------------------------------------------------`n"

do {
	# Use RegEx to find matches
	foreach ($patternmatch in [regex]::Matches($htmlContent.Content, $pattern)) {
		# Extract the URI and version number
		$ThisVersionUri = $patternmatch.Groups[1].Value
		[version]$ThisVersion = $patternmatch.Groups[2].Value
		$BaseVersion = $($ThisVersion.Major)

		# Regular expression to match the release information
		$regex = "<li>Release number: $($ThisVersion)</li>`n<li>Build number: (.*?)</li>`n<li>Release date: (.*?)</li>"
		
		$BuildCount = ([regex]::Matches($htmlContent.RawContent, $regex)).Count
		foreach ($regexmatch in [regex]::Matches($htmlContent.RawContent, $regex)) {
			#$ReleaseVersion = $regexmatch.Groups[1].Value
			[version]$BuildNumber = $regexmatch.Groups[1].Value
			$ReleaseDate = $regexmatch.Groups[2].Value

			do {
				$AppVersions = @(
					@{Version = $ThisVersion; BuildNumber = $BuildNumber; ReleaseDate = $ReleaseDate; Language = 'Chinese (Simplified)'; Pattern = '&clcid=0x804'}
					@{Version = $ThisVersion; BuildNumber = $BuildNumber; ReleaseDate = $ReleaseDate; Language = 'Chinese (Traditional)'; Pattern = '&clcid=0x404'}
					@{Version = $ThisVersion; BuildNumber = $BuildNumber; ReleaseDate = $ReleaseDate; Language = 'English'; Pattern = '&clcid=0x409'}
					@{Version = $ThisVersion; BuildNumber = $BuildNumber; ReleaseDate = $ReleaseDate; Language = 'French'; Pattern = '&clcid=0x40c'}
					@{Version = $ThisVersion; BuildNumber = $BuildNumber; ReleaseDate = $ReleaseDate; Language = 'German'; Pattern = '&clcid=0x407'}
					@{Version = $ThisVersion; BuildNumber = $BuildNumber; ReleaseDate = $ReleaseDate; Language = 'Italian'; Pattern = '&clcid=0x410'}
					@{Version = $ThisVersion; BuildNumber = $BuildNumber; ReleaseDate = $ReleaseDate; Language = 'Japanese'; Pattern = '&clcid=0x411'}
					@{Version = $ThisVersion; BuildNumber = $BuildNumber; ReleaseDate = $ReleaseDate; Language = 'Korean'; Pattern = '&clcid=0x412'}
					@{Version = $ThisVersion; BuildNumber = $BuildNumber; ReleaseDate = $ReleaseDate; Language = 'Portuguese (Brazil)'; Pattern = '&clcid=0x416'}
					@{Version = $ThisVersion; BuildNumber = $BuildNumber; ReleaseDate = $ReleaseDate; Language = 'Russian'; Pattern = '&clcid=0x419'}
					@{Version = $ThisVersion; BuildNumber = $BuildNumber; ReleaseDate = $ReleaseDate; Language = 'Spanish'; Pattern = '&clcid=0x40a'}
				)

				foreach ($AppVersion in $AppVersions) {
					if ($ThisVersionUri) {
						#Build each link with Language specific versions
						$URL = (Resolve-Uri -Uri "$($ThisVersionUri)$($AppVersion.Pattern)").Uri
						New-NevergreenApp -Name $AppName -Ring $BaseVersion -Version $AppVersion.Version -BuildNumber $AppVersion.BuildNumber -ReleaseDate $AppVersion.ReleaseDate -Uri $URL -Architecture 'x64' -Language $AppVersion.Language -Type 'Exe'
						#break
					}
				}
				$BuildCount--
			} until ($BuildCount -eq 0)
		}
		$SearchCount--
	}
} until ($SearchCount -eq 0)

function New-NevergreenApp {
    <#
    .SYNOPSIS
        Returns a PSCustomObject to output.

    .DESCRIPTION
        Returns a PSCustomObject to output.

    .NOTES
        Site: https://packageology.com
        Author: Dan Gough
        Twitter: @packageologist

    .LINK
        https://github.com/DanGough/Nevergreen

    .PARAMETER Name
        Mandatory. The name of the application.

    .PARAMETER Uri
        Mandatory. The download URI for the application.

    .PARAMETER Version
        Mandatory. The application version.

    .PARAMETER Architecture
        Mandatory. Must match x86, x64, ARM32, ARM64 or Multi.

    .PARAMETER Type
        Mandatory. Must match Msi, Msp, Exe, Zip, Msix, AppX, AppV, 7z if supplied.

    .PARAMETER Language
        Optional. The language of the application installer, e.g. 'en'.

    .PARAMETER Ring
        Optional. The deployment ring, e.g. 'General', 'Preview'.

    .PARAMETER Channel
        Optional. The channel, e.g. 'Enterprise'.

    .PARAMETER Platform
        Optional. The platform, e.g. 'Windows Server'.

    .PARAMETER BuildNumber
        Optional. The Build Version (used where available - example SSMS).

    .PARAMETER ReleaseDate
        Optional. The Date the version was released.

    .PARAMETER MD5
        Optional. The MD5 hash of the file.

    .PARAMETER SHA256
        Optional. The SHA256 hash of the file.

    .EXAMPLE
        New-NevergreenApp -Uri 'http://somewhere.com/something.exe' -Version '1.0' -Architecture 'x64' -Type 'Exe'

        Description:
        Outputs a PSCustomObject with the chosen properties.
    #>
    [CmdletBinding(SupportsShouldProcess = $False)]
    param (
        [Parameter(
            Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [String] $Name,
        [Parameter(
            Mandatory = $true)]
        [ValidateNotNullOrEmpty()]
        [String] $Version,
        [Parameter(
            Mandatory = $true)]
        [ValidatePattern('^(http|https)://')]
        [Alias('Url')]
        [String] $Uri,
        [Parameter(
            Mandatory = $true)]
        [ValidateSet('x86', 'x64', 'ARM32', 'ARM64', 'Multi')]
        [String] $Architecture,
        [Parameter(
            Mandatory = $true)]
        [ValidateSet('Msi', 'Msp', 'Exe', 'Zip', 'Msix', 'AppX', 'AppV', '7z')]
        [String] $Type,
        [Parameter(
            Mandatory = $false)]
        [ValidateNotNullOrEmpty()]
        [String] $Language,
        [Parameter(
            Mandatory = $false)]
        [ValidateNotNullOrEmpty()]
        [String] $Ring,
        [Parameter(
            Mandatory = $false)]
        [ValidateNotNullOrEmpty()]
        [String] $Channel,
        [Parameter(
            Mandatory = $false)]
        [ValidateNotNullOrEmpty()]
        [String] $Platform,
        [Parameter(
            Mandatory = $false)]
        [ValidateNotNullOrEmpty()]
        [String] $BuildNumber,
        [Parameter(
            Mandatory = $false)]
        [ValidateNotNullOrEmpty()]
        [String] $ReleaseDate,
        [Parameter(
            Mandatory = $false)]
        [ValidateNotNullOrEmpty()]
        [String] $MD5,
        [Parameter(
            Mandatory = $false)]
        [ValidateNotNullOrEmpty()]
        [String] $SHA256
    )

    $Output = [PSCustomObject]@{
        Name    = $Name
    }

    if ($Ring) {
        Add-Member -InputObject $Output -MemberType NoteProperty -Name 'Ring' -Value $Ring
    }

    if ($Channel) {
        Add-Member -InputObject $Output -MemberType NoteProperty -Name 'Channel' -Value $Channel
    }

    if ($Language) {
        Add-Member -InputObject $Output -MemberType NoteProperty -Name 'Language' -Value $Language
    }

    if ($BuildNumber) {
        Add-Member -InputObject $Output -MemberType NoteProperty -Name 'BuildNumber' -Value $BuildNumber
    }

    if ($ReleaseDate) {
        Add-Member -InputObject $Output -MemberType NoteProperty -Name 'ReleaseDate' -Value $ReleaseDate
    }

    if ($Platform) {
        Add-Member -InputObject $Output -MemberType NoteProperty -Name 'Platform' -Value $Platform
    }

    if ($Architecture) {
        Add-Member -InputObject $Output -MemberType NoteProperty -Name 'Architecture' -Value $Architecture
    }

    if ($Type) {
        Add-Member -InputObject $Output -MemberType NoteProperty -Name 'Type' -Value $Type
    }

    Add-Member -InputObject $Output -MemberType NoteProperty -Name 'Version' -Value $Version
    Add-Member -InputObject $Output -MemberType NoteProperty -Name 'Uri' -Value $Uri

    if ($MD5) {
        Add-Member -InputObject $Output -MemberType NoteProperty -Name 'MD5' -Value $MD5
    }

    if ($SHA256) {
        Add-Member -InputObject $Output -MemberType NoteProperty -Name 'SHA256' -Value $SHA256
    }

    $Output
}

Get-Link : Get-Link: The remote server returned an error: (403) Forbidden.
At C:\Users\jonathan\Documents\WindowsPowerShell\Modules\Nevergreen\2110.1\Apps\Get-zoom.ps1:29 char:23
+ ... wnloadURL = Get-Link -Uri 'https://support.zoom.us/hc/en-us/sections/ ...
+                 ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : NotSpecified: (:) [Write-Error], WriteErrorException
    + FullyQualifiedErrorId : Microsoft.PowerShell.Commands.WriteErrorException,Get-Link
 
WARNING: Unable to get results for Zoom VDI downloads: Cannot validate argument on parameter 'Uri'. The argument is null or empty. Provide an argument that is not null or empty, and then try the command again.

Invoke-WebRequest -Uri "https://support.zoom.us/hc/en-us/sections/360011509631-VDI-Downloads"
Invoke-WebRequest : The remote server returned an error: (403) Forbidden.
At line:1 char:1
+ Invoke-WebRequest -Uri "https://support.zoom.us/hc/en-us/sections/360 ...
+ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    + CategoryInfo          : InvalidOperation: (System.Net.HttpWebRequest:HttpWebRequest) [Invoke-WebRequest], WebException
    + FullyQualifiedErrorId : WebCmdletWebResponseException,Microsoft.PowerShell.Commands.InvokeWebRequestCommand