Adds SystemId support for HP driver management

Enhances HP driver handling to properly track and display SystemId alongside ProductName throughout the driver workflow. Parses SystemId from HP PlatformList.xml and creates unique entries per ProductName/SystemId combination to avoid conflicts when multiple models share the same product name but different system identifiers. Updates driver lookup and metadata preservation to include SystemId, MachineType, and ProductName fields across download tasks and result processing, ensuring this information persists through JSON import/export operations. Improves display name generation to show "ProductName (SystemId)" format for HP models when both values are available, providing clearer model identification in the UI and configuration files. Standardizes driver metadata handling by replacing simple Make lookups with comprehensive driver metadata lookups that preserve all relevant fields for Dell, HP, and Lenovo vendors.
2026-06-13 18:07:20 -06:00 · 2025-11-14 19:48:22 -08:00
parent 89601efde0
commit de80ac551b
4 changed files with 270 additions and 60 deletions
@@ -4929,9 +4929,27 @@ if ($driversJsonPath -and (Test-Path $driversJsonPath) -and ($InstallDrivers -or
                        }
                    }
                    'HP' {
+                        $systemId = if ($modelEntry.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($modelEntry.SystemId)) { $modelEntry.SystemId.Trim() } else { $null }
+                        $baseName = if ($modelEntry.PSObject.Properties['ProductName'] -and -not [string]::IsNullOrWhiteSpace($modelEntry.ProductName)) { $modelEntry.ProductName } else { $modelName }
+                        if ($modelName -match '(.+?)\s*\((.+?)\)$') {
+                            if ([string]::IsNullOrWhiteSpace($baseName)) { $baseName = $matches[1].Trim() }
+                            if ([string]::IsNullOrWhiteSpace($systemId)) { $systemId = $matches[2].Trim() }
+                        }
+                        if ($baseName -match '(.+?)\s*\((.+?)\)$') {
+                            $baseName = $matches[1].Trim()
+                            if ([string]::IsNullOrWhiteSpace($systemId)) { $systemId = $matches[2].Trim() }
+                        }
+                        if ([string]::IsNullOrWhiteSpace($baseName)) { $baseName = $modelName }
+                        $displayModel = if ([string]::IsNullOrWhiteSpace($systemId)) { $baseName.Trim() } else { "$($baseName.Trim()) ($($systemId.Trim()))" }
                        $driverItem = [PSCustomObject]@{
                            Make  = $makeName
-                            Model = $modelName
+                            Model = $displayModel
+                        }
+                        if (-not [string]::IsNullOrWhiteSpace($baseName)) {
+                            $driverItem | Add-Member -NotePropertyName ProductName -NotePropertyValue $baseName.Trim()
+                        }
+                        if (-not [string]::IsNullOrWhiteSpace($systemId)) {
+                            $driverItem | Add-Member -NotePropertyName SystemId -NotePropertyValue $systemId
                        }
                    }
                    'Lenovo' {
@@ -5012,9 +5030,13 @@ if ($driversJsonPath -and (Test-Path $driversJsonPath) -and ($InstallDrivers -or
        $failedDownloads = [System.Collections.Generic.List[PSCustomObject]]::new()

        if ($null -ne $parallelResults) {
-            # Create a lookup table from the original items to get the 'Make'
-            $makeLookup = @{}
-            $driversToProcess | ForEach-Object { $makeLookup[$_.Model] = $_.Make }
+            # Create a lookup table from the original items to retain full metadata for mapping.
+            $driverLookup = @{}
+            foreach ($driver in $driversToProcess) {
+                if (-not [string]::IsNullOrWhiteSpace($driver.Model)) {
+                    $driverLookup[$driver.Model] = $driver
+                }
+            }

            foreach ($result in $parallelResults) {
                if ($null -eq $result) { continue }
@@ -5055,20 +5077,30 @@ if ($driversJsonPath -and (Test-Path $driversJsonPath) -and ($InstallDrivers -or

                if ($resultSuccess -and -not [string]::IsNullOrWhiteSpace($resultDriverPath)) {
                    $modelKey = if (-not [string]::IsNullOrWhiteSpace($lookupModelName)) { $lookupModelName } else { 'Unknown model' }
-                    $makeJson = $null
-                    if (-not [string]::IsNullOrWhiteSpace($lookupModelName) -and $makeLookup.ContainsKey($lookupModelName)) {
-                        $makeJson = $makeLookup[$lookupModelName]
+                    $driverMetadata = $null
+                    if (-not [string]::IsNullOrWhiteSpace($lookupModelName) -and $driverLookup.ContainsKey($lookupModelName)) {
+                        $driverMetadata = $driverLookup[$lookupModelName]
                    }

-                    if ($makeJson) {
-                        $successfullyDownloaded.Add([PSCustomObject]@{
-                                Make       = $makeJson
-                                Model      = $modelKey
-                                DriverPath = $resultDriverPath
-                            })
+                    if ($driverMetadata) {
+                        $driverRecord = [PSCustomObject]@{
+                            Make       = $driverMetadata.Make
+                            Model      = $modelKey
+                            DriverPath = $resultDriverPath
+                        }
+                        if ($driverMetadata.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($driverMetadata.SystemId)) {
+                            $driverRecord | Add-Member -NotePropertyName SystemId -NotePropertyValue $driverMetadata.SystemId
+                        }
+                        if ($driverMetadata.PSObject.Properties['MachineType'] -and -not [string]::IsNullOrWhiteSpace($driverMetadata.MachineType)) {
+                            $driverRecord | Add-Member -NotePropertyName MachineType -NotePropertyValue $driverMetadata.MachineType
+                        }
+                        if ($driverMetadata.PSObject.Properties['ProductName'] -and -not [string]::IsNullOrWhiteSpace($driverMetadata.ProductName)) {
+                            $driverRecord | Add-Member -NotePropertyName ProductName -NotePropertyValue $driverMetadata.ProductName
+                        }
+                        $successfullyDownloaded.Add($driverRecord)
                    }
                    else {
-                        WriteLog "Warning: Could not find 'Make' for successful download of model '$modelKey'. Skipping from DriverMapping.json."
+                        WriteLog "Warning: Could not find driver metadata for successful download of model '$modelKey'. Skipping from DriverMapping.json."
                    }
                }
                else {
@@ -243,6 +243,55 @@ function Set-UIValue {
    }
 }

+function Get-ConfigDriverBaseName {
+    param(
+        [string]$RawName
+    )
+
+    if ([string]::IsNullOrWhiteSpace($RawName)) {
+        return $RawName
+    }
+
+    if ($RawName -match '^(.*?)\s*\((.+)\)\s*$') {
+        return $matches[1].Trim()
+    }
+
+    return $RawName.Trim()
+}
+
+function Get-ConfigDriverDisplayName {
+    param(
+        [string]$Make,
+        [string]$StoredName,
+        [string]$ProductName,
+        [string]$SystemId,
+        [string]$MachineType
+    )
+
+    $baseName = if (-not [string]::IsNullOrWhiteSpace($ProductName)) { $ProductName } else { Get-ConfigDriverBaseName -RawName $StoredName }
+
+    switch ($Make) {
+        'Dell' {
+            if ([string]::IsNullOrWhiteSpace($baseName)) { $baseName = $StoredName }
+            if ([string]::IsNullOrWhiteSpace($SystemId)) { return $baseName }
+            return "{0} ({1})" -f $baseName.Trim(), $SystemId.Trim()
+        }
+        'HP' {
+            if ([string]::IsNullOrWhiteSpace($baseName)) { $baseName = $StoredName }
+            if ([string]::IsNullOrWhiteSpace($SystemId)) { return $baseName }
+            return "{0} ({1})" -f $baseName.Trim(), $SystemId.Trim()
+        }
+        'Lenovo' {
+            if ([string]::IsNullOrWhiteSpace($baseName)) { $baseName = $StoredName }
+            if ([string]::IsNullOrWhiteSpace($MachineType)) { return $baseName }
+            return "{0} ({1})" -f $baseName.Trim(), $MachineType.Trim()
+        }
+        default {
+            return $StoredName
+        }
+    }
+}
+
 function Invoke-LoadConfiguration {
    param(
        [Parameter(Mandatory = $true)]
@@ -1056,15 +1105,28 @@ function Import-ConfigSupplementalAssets {
                                if ($null -eq $modelEntry -or -not ($modelEntry.PSObject.Properties['Name'])) { continue }
                                $modelName = $modelEntry.Name
                                if ([string]::IsNullOrWhiteSpace($modelName)) { continue }
+                                $downloadStatus = if ($modelEntry.PSObject.Properties['DownloadStatus']) { $modelEntry.DownloadStatus } else { "" }
+                                $linkValue = if ($modelEntry.PSObject.Properties['Link']) { $modelEntry.Link } else { $null }
+                                $productName = if ($modelEntry.PSObject.Properties['ProductName']) { $modelEntry.ProductName } else { $null }
+                                $machineType = if ($modelEntry.PSObject.Properties['MachineType']) { $modelEntry.MachineType } else { $null }
+                                $systemId = if ($modelEntry.PSObject.Properties['SystemId']) { $modelEntry.SystemId } else { $null }
+                                $idValue = if ($modelEntry.PSObject.Properties['Id']) { $modelEntry.Id } else { $null }
+                                if ($null -eq $idValue -and -not [string]::IsNullOrWhiteSpace($systemId)) { $idValue = $systemId }
+                                if ($null -eq $idValue -and -not [string]::IsNullOrWhiteSpace($machineType)) { $idValue = $machineType }
+                                $displayModel = Get-ConfigDriverDisplayName -Make $makeName -StoredName $modelName -ProductName $productName -SystemId $systemId -MachineType $machineType
+                                if ([string]::IsNullOrWhiteSpace($displayModel)) {
+                                    $displayModel = $modelName
+                                }
                                $driverObj = [PSCustomObject]@{
                                    IsSelected     = $true
                                    Make           = $makeName
-                                    Model          = $modelName
-                                    DownloadStatus = if ($modelEntry.PSObject.Properties['DownloadStatus']) { $modelEntry.DownloadStatus } else { "" }
-                                    Link           = if ($modelEntry.PSObject.Properties['Link']) { $modelEntry.Link } else { $null }
-                                    ProductName    = if ($modelEntry.PSObject.Properties['ProductName']) { $modelEntry.ProductName } else { $null }
-                                    MachineType    = if ($modelEntry.PSObject.Properties['MachineType']) { $modelEntry.MachineType } else { $null }
-                                    Id             = if ($modelEntry.PSObject.Properties['Id']) { $modelEntry.Id } else { $null }
+                                    Model          = $displayModel
+                                    DownloadStatus = $downloadStatus
+                                    Link           = $linkValue
+                                    ProductName    = $productName
+                                    MachineType    = $machineType
+                                    SystemId       = $systemId
+                                    Id             = $idValue
                                }
                                $State.Data.allDriverModels.Add($driverObj)
                            }
@@ -66,30 +66,45 @@ function Get-HPDriversModelList {
        $settings.Async = $false # Ensure synchronous reading

        $reader = [System.Xml.XmlReader]::Create($platformListXml, $settings)
-        $uniqueModels = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::OrdinalIgnoreCase)
+        $uniqueEntries = [System.Collections.Generic.HashSet[string]]::new([System.StringComparer]::OrdinalIgnoreCase)

        while ($reader.Read()) {
            if ($reader.NodeType -eq [System.Xml.XmlNodeType]::Element -and $reader.Name -eq 'Platform') {
-                # Read the inner content of the Platform node
                $platformReader = $reader.ReadSubtree()
+                $platformNames = [System.Collections.Generic.List[string]]::new()
+                $platformSystemId = $null
+
                while ($platformReader.Read()) {
-                    if ($platformReader.NodeType -eq [System.Xml.XmlNodeType]::Element -and $platformReader.Name -eq 'ProductName') {
-                        $modelName = $platformReader.ReadElementContentAsString()
-                        if (-not [string]::IsNullOrWhiteSpace($modelName) -and $uniqueModels.Add($modelName)) {
-                            # Add to list only if it's a new unique model
-                            $modelList.Add([PSCustomObject]@{
-                                    Make  = $Make
-                                    Model = $modelName
-                                })
+                    if ($platformReader.NodeType -eq [System.Xml.XmlNodeType]::Element) {
+                        if ($platformReader.Name -eq 'ProductName') {
+                            $modelName = $platformReader.ReadElementContentAsString()
+                            if (-not [string]::IsNullOrWhiteSpace($modelName)) {
+                                $platformNames.Add($modelName.Trim())
+                            }
+                        }
+                        elseif ($platformReader.Name -eq 'SystemID') {
+                            $platformSystemId = $platformReader.ReadElementContentAsString().Trim()
                        }
                    }
                }
                $platformReader.Close()
+
+                foreach ($name in $platformNames) {
+                    $systemIdKey = if (-not [string]::IsNullOrWhiteSpace($platformSystemId)) { $platformSystemId } else { '' }
+                    $compositeKey = "$name|$systemIdKey"
+                    if ($uniqueEntries.Add($compositeKey)) {
+                        $modelList.Add([PSCustomObject]@{
+                                Make     = $Make
+                                Model    = $name
+                                SystemId = $platformSystemId
+                            })
+                    }
+                }
            }
        }
        $reader.Close()

-        WriteLog "Successfully parsed $($modelList.Count) unique HP models from PlatformList.xml."
+        WriteLog "Successfully parsed $($modelList.Count) HP model and SystemID combinations from PlatformList.xml."

    }
    catch {
@@ -97,7 +112,7 @@ function Get-HPDriversModelList {
    }

    # Sort the list alphabetically by Model name before returning
-    return $modelList | Sort-Object -Property Model
+    return $modelList | Sort-Object -Property Model, SystemId
 }
 # Function to download and extract drivers for a specific HP model (Designed for ForEach-Object -Parallel)
 function Save-HPDriversTask {
@@ -123,19 +138,34 @@ function Save-HPDriversTask {
        [bool]$PreserveSourceOnCompress = $false
    )
            
-    $modelName = $DriverItemData.Model
+    $displayModelName = if (-not [string]::IsNullOrWhiteSpace($DriverItemData.Model)) { $DriverItemData.Model } else { $DriverItemData.Id }
    $make = $DriverItemData.Make # Should be 'HP'
-    $identifier = $modelName # Unique identifier for progress updates
-    $sanitizedModelName = ConvertTo-SafeName -Name $modelName
-    if ($sanitizedModelName -ne $modelName) { WriteLog "Sanitized model name: '$modelName' -> '$sanitizedModelName'" }
+    $productName = if ($DriverItemData.PSObject.Properties['ProductName'] -and -not [string]::IsNullOrWhiteSpace($DriverItemData.ProductName)) { $DriverItemData.ProductName } else { ConvertTo-DriverBaseName -ModelString $displayModelName }
+    if ([string]::IsNullOrWhiteSpace($productName)) { $productName = $displayModelName }
+    $systemIdentifier = if ($DriverItemData.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($DriverItemData.SystemId)) { $DriverItemData.SystemId } else { $null }
+    if ([string]::IsNullOrWhiteSpace($displayModelName)) {
+        $displayModelName = if ([string]::IsNullOrWhiteSpace($systemIdentifier)) { $productName } else { Get-DriverDisplayName -BaseName $productName -Identifier $systemIdentifier }
+    }
+    $identifier = $displayModelName # Unique identifier for progress updates
+    $sanitizedModelName = ConvertTo-SafeName -Name $identifier
+    if ($sanitizedModelName -ne $identifier) { WriteLog "Sanitized model name: '$identifier' -> '$sanitizedModelName'" }
    $hpDriversBaseFolder = Join-Path -Path $DriversFolder -ChildPath $make # Changed variable name for clarity
    $platformListXml = Join-Path -Path $hpDriversBaseFolder -ChildPath "PlatformList.xml"
    $modelSpecificFolder = Join-Path -Path $hpDriversBaseFolder -ChildPath $sanitizedModelName # Sanitize model name for folder path
    $driverRelativePath = Join-Path -Path $make -ChildPath $sanitizedModelName # Relative path for the driver folder
    $finalStatus = "" # Initialize final status
    $successState = $true # Assume success unless an operation fails
+
+    if (-not (Test-Path -Path $DriversFolder -PathType Container)) {
+        WriteLog "Creating Drivers folder: $DriversFolder"
+        New-Item -Path $DriversFolder -ItemType Directory -Force | Out-Null
+    }
+    if (-not (Test-Path -Path $hpDriversBaseFolder -PathType Container)) {
+        WriteLog "Creating HP drivers folder: $hpDriversBaseFolder"
+        New-Item -Path $hpDriversBaseFolder -ItemType Directory -Force | Out-Null
+    }
    
-    if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $identifier -Status "Checking HP drivers for $modelName..." }
+    if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $identifier -Status "Checking HP drivers for $displayModelName..." }
    
    try {
        # Check for existing drivers
@@ -190,13 +220,23 @@ function Save-HPDriversTask {
            }
        }

-        # Parse PlatformList.xml to find SystemID and OSReleaseID for the specific model
-        WriteLog "Parsing $platformListXml for model '$modelName' details..."
+        # Parse the PlatformList.xml to find the SystemID based on the ProductName
+        WriteLog "Parsing $platformListXml for model '$displayModelName' (SystemID: $systemIdentifier) details..."
        [xml]$platformListContent = Get-Content -Path $platformListXml -Raw -Encoding UTF8 -ErrorAction Stop
-        $platformNode = $platformListContent.ImagePal.Platform | Where-Object { $_.ProductName.'#text' -match "^$([regex]::Escape($modelName))$" } | Select-Object -First 1
+        $platformNode = $null
+        if (-not [string]::IsNullOrWhiteSpace($systemIdentifier)) {
+            $platformNode = $platformListContent.ImagePal.Platform | Where-Object { $_.SystemID -eq $systemIdentifier } | Select-Object -First 1
+            if ($null -eq $platformNode) {
+                WriteLog "SystemID '$systemIdentifier' not found in PlatformList.xml. Falling back to ProductName search."
+            }
+        }
+        if ($null -eq $platformNode) {
+            $searchName = if (-not [string]::IsNullOrWhiteSpace($productName)) { $productName } else { $displayModelName }
+            $platformNode = $platformListContent.ImagePal.Platform | Where-Object { $_.ProductName.'#text' -match "^$([regex]::Escape($searchName))$" } | Select-Object -First 1
+        }

        if ($null -eq $platformNode) {
-            throw "Model '$modelName' not found in PlatformList.xml."
+            throw "Model '$displayModelName' (SystemID: $systemIdentifier) not found in PlatformList.xml."
        }

        $systemID = $platformNode.SystemID
@@ -289,11 +329,11 @@ function Save-HPDriversTask {
            }
            $availableVersionsString = ($allAvailableVersions | Select-Object -Unique) -join ', '
            if ([string]::IsNullOrWhiteSpace($availableVersionsString)) { $availableVersionsString = "None" }
-            throw "Could not find any suitable OS driver pack for model '$modelName' matching requested or fallback versions (Win$($WindowsRelease) $WindowsVersion). Available: $availableVersionsString"
+            throw "Could not find any suitable OS driver pack for model '$displayModelName' matching requested or fallback versions (Win$($WindowsRelease) $WindowsVersion). Available: $availableVersionsString"
        }

        $osReleaseIdFileName = $selectedOSNode.OSReleaseIdFileName -replace 'H', 'h' 
-        WriteLog "Using SystemID: $systemID and OS Info: Win$($selectedOSRelease) ($($selectedOSVersion)) for '$modelName'"
+        WriteLog "Using SystemID: $systemID and OS Info: Win$($selectedOSRelease) ($($selectedOSVersion)) for '$displayModelName'"
        $archSuffix = $WindowsArch -replace "^x", "" 
        $modelRelease = "$($systemID)_$($archSuffix)_$($selectedOSRelease).0.$($selectedOSVersion.ToLower())"
        $driverCabUrl = "https://hpia.hpcloud.hp.com/ref/$systemID/$modelRelease.cab"
@@ -312,7 +352,7 @@ function Save-HPDriversTask {
        $updates = $driverXmlContent.ImagePal.Solutions.UpdateInfo | Where-Object { $_.Category -match '^Driver' }
        $totalDrivers = ($updates | Measure-Object).Count
        $downloadedCount = 0
-        WriteLog "Found $totalDrivers driver updates for $modelName."
+        WriteLog "Found $totalDrivers driver updates for $displayModelName."
        if ($null -ne $ProgressQueue) { Invoke-ProgressUpdate -ProgressQueue $ProgressQueue -Identifier $identifier -Status "Found $totalDrivers drivers. Downloading..." }

        if (-not (Test-Path -Path $modelSpecificFolder)) {
@@ -359,7 +399,7 @@ function Save-HPDriversTask {
        }

        Remove-Item -Path $driverCabFile, $driverXmlFile -Force -ErrorAction SilentlyContinue
-        WriteLog "Cleaned up driver cab and xml files for $modelName"
+        WriteLog "Cleaned up driver cab and xml files for $displayModelName"
        
        $finalStatus = "Completed" 
        if ($CompressToWim) {
@@ -380,7 +420,7 @@ function Save-HPDriversTask {
        $successState = $true
    }
    catch {
-        $errorMessage = "Error saving HP drivers for $($modelName): $($_.Exception.Message)"
+        $errorMessage = "Error saving HP drivers for $($displayModelName): $($_.Exception.Message)"
        WriteLog $errorMessage
        $finalStatus = "Error: $($_.Exception.Message.Split([Environment]::NewLine)[0])"
        $successState = $false
@@ -69,7 +69,16 @@ function Convert-DriverItemToJsonModel {
            return $modelObject
        }
        'HP' {
-            return @{ Name = $DriverItem.Model }
+            $baseName = if ($DriverItem.PSObject.Properties['ProductName'] -and -not [string]::IsNullOrWhiteSpace($DriverItem.ProductName)) { $DriverItem.ProductName } else { ConvertTo-DriverBaseName -ModelString $DriverItem.Model }
+            if ([string]::IsNullOrWhiteSpace($baseName)) {
+                $baseName = $DriverItem.Model
+            }
+            $systemId = if ($DriverItem.PSObject.Properties['SystemId']) { $DriverItem.SystemId } else { $null }
+            $modelObject = @{ Name = $baseName.Trim() }
+            if (-not [string]::IsNullOrWhiteSpace($systemId)) {
+                $modelObject.SystemId = $systemId
+            }
+            return $modelObject
        }
        'Lenovo' {
            $machineType = $DriverItem.MachineType
@@ -174,6 +183,7 @@ function ConvertTo-StandardizedDriverModel {
    $link = $null
    $productName = $null
    $machineType = $null
+    $systemId = $null

    if ($RawDriverObject.PSObject.Properties['Link']) {
        $link = $RawDriverObject.Link
@@ -187,6 +197,17 @@ function ConvertTo-StandardizedDriverModel {
        $id = $RawDriverObject.MachineType
    }

+    # HP specific handling
+    if ($Make -eq 'HP') {
+        $productName = if ($RawDriverObject.PSObject.Properties['ProductName'] -and -not [string]::IsNullOrWhiteSpace($RawDriverObject.ProductName)) { $RawDriverObject.ProductName } else { ConvertTo-DriverBaseName -ModelString $RawDriverObject.Model }
+        if ([string]::IsNullOrWhiteSpace($productName)) { $productName = $RawDriverObject.Model }
+        if ($RawDriverObject.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($RawDriverObject.SystemId)) {
+            $systemId = $RawDriverObject.SystemId
+        }
+        $modelDisplay = if ([string]::IsNullOrWhiteSpace($systemId)) { $productName } else { Get-DriverDisplayName -BaseName $productName -Identifier $systemId }
+        $id = if ([string]::IsNullOrWhiteSpace($systemId)) { $productName } else { $systemId }
+    }
+
    # Dell-specific passthrough (needed for per-model cab workflow)
    $dellBrand = $null
    $dellModelNumber = $null
@@ -221,6 +242,9 @@ function ConvertTo-StandardizedDriverModel {
        $output | Add-Member -NotePropertyName SystemId        -NotePropertyValue $dellSystemId
        $output | Add-Member -NotePropertyName CabUrl          -NotePropertyValue $dellCabUrl
    }
+    elseif ($Make -eq 'HP' -and -not [string]::IsNullOrWhiteSpace($systemId)) {
+        $output | Add-Member -NotePropertyName SystemId -NotePropertyValue $systemId
+    }

    return $output
 }
@@ -432,6 +456,28 @@ function Import-DriversJson {
                                $importedModelObject | Add-Member -NotePropertyName SystemId -NotePropertyValue $systemId
                            }
                        }
+                        'HP' {
+                            $baseName = ConvertTo-DriverBaseName -ModelString $normalizedName
+                            if ([string]::IsNullOrWhiteSpace($baseName)) { $baseName = $normalizedName }
+                            $systemId = if ($importedModelObject.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($importedModelObject.SystemId)) { $importedModelObject.SystemId } else { $null }
+                            if ([string]::IsNullOrWhiteSpace($systemId) -and $normalizedName -match '(.+?)\s*\((.+?)\)$') {
+                                if ([string]::IsNullOrWhiteSpace($baseName)) { $baseName = $matches[1].Trim() }
+                                $systemId = $matches[2].Trim()
+                            }
+                            $normalizedName = if ([string]::IsNullOrWhiteSpace($systemId)) { $baseName.Trim() } else { Get-DriverDisplayName -BaseName $baseName -Identifier $systemId }
+                            if ($importedModelObject.PSObject.Properties['ProductName']) {
+                                $importedModelObject.ProductName = $baseName
+                            }
+                            else {
+                                $importedModelObject | Add-Member -NotePropertyName ProductName -NotePropertyValue $baseName
+                            }
+                            if ($importedModelObject.PSObject.Properties['SystemId']) {
+                                $importedModelObject.SystemId = $systemId
+                            }
+                            else {
+                                $importedModelObject | Add-Member -NotePropertyName SystemId -NotePropertyValue $systemId
+                            }
+                        }
                        default {
                            $normalizedName = $normalizedName.Trim()
                        }
@@ -454,6 +500,7 @@ function Import-DriversJson {
                    if ($null -ne $existingModel) {
                        $existingModel.IsSelected = $true
                        $existingModel.DownloadStatus = "Imported"
+                        $existingModel.Model = $importedModelNameFromObject
                    
                        if ($makeName -eq 'Microsoft' -and $importedModelObject.PSObject.Properties['Link']) {
                            if ($existingModel.Link -ne $importedModelObject.Link) {
@@ -491,6 +538,13 @@ function Import-DriversJson {
                                }
                            }
                        }
+                        elseif ($makeName -eq 'HP') {
+                            $importedProductName = if ($importedModelObject.PSObject.Properties['ProductName'] -and -not [string]::IsNullOrWhiteSpace($importedModelObject.ProductName)) { $importedModelObject.ProductName } else { ConvertTo-DriverBaseName -ModelString $importedModelNameFromObject }
+                            if ([string]::IsNullOrWhiteSpace($importedProductName)) { $importedProductName = $importedModelNameFromObject }
+                            if ($importedModelObject.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($importedModelObject.SystemId)) {
+                                $importedId = $importedModelObject.SystemId
+                            }
+                        }
                    
                        $existingModelsUpdated++
                        WriteLog "Import-DriversJson: Marked existing model '$($existingModel.Make) - $($existingModel.Model)' as imported."
@@ -548,6 +602,11 @@ function Import-DriversJson {
                                $newDriverModel | Add-Member -NotePropertyName CabUrl -NotePropertyValue $importedModelObject.CabUrl
                            }
                        }
+                        elseif ($makeName -eq 'HP') {
+                            if ($importedModelObject.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($importedModelObject.SystemId)) {
+                                $newDriverModel | Add-Member -NotePropertyName SystemId -NotePropertyValue $importedModelObject.SystemId
+                            }
+                        }
                        $State.Data.allDriverModels.Add($newDriverModel)
                        $newModelsAdded++
                        WriteLog "Import-DriversJson: Added new model '$($newDriverModel.Make) - $($newDriverModel.Model)' from import. ID: $($newDriverModel.Id), Link: $($newDriverModel.Link)"
@@ -819,11 +878,14 @@ function Invoke-DownloadSelectedDrivers {

    # Check the results from the parallel processing tasks
    if ($null -ne $parallelResults) {
-        # Create a lookup from the original selected drivers to get the 'Make' property,
-        # as the result object might only have 'Identifier' or 'Model'.
-        $makeLookup = @{}
-        $selectedDrivers | ForEach-Object { $makeLookup[$_.Model] = $_.Make }
-
+        # Create a lookup from the original selected drivers to retain full metadata for mapping.
+        $driverLookup = @{}
+        foreach ($driver in $selectedDrivers) {
+            if (-not [string]::IsNullOrWhiteSpace($driver.Model)) {
+                $driverLookup[$driver.Model] = $driver
+            }
+        }
+    
        # Filter for objects that could be results, avoiding stray log strings
        foreach ($result in ($parallelResults | Where-Object { $_ -is [hashtable] })) {
            if ($null -eq $result) { continue }
@@ -856,16 +918,30 @@ function Invoke-DownloadSelectedDrivers {
            }
            elseif (-not [string]::IsNullOrWhiteSpace($driverPath)) {
                # The task was successful and returned a driver path.
-                $make = $makeLookup[$modelName]
-                if ($make) {
-                    $successfullyDownloaded.Add([PSCustomObject]@{
-                            Make       = $make
-                            Model      = $modelName
-                            DriverPath = $driverPath
-                        })
+                $driverMetadata = $null
+                if (-not [string]::IsNullOrWhiteSpace($modelName) -and $driverLookup.ContainsKey($modelName)) {
+                    $driverMetadata = $driverLookup[$modelName]
+                }
+
+                if ($driverMetadata) {
+                    $driverRecord = [PSCustomObject]@{
+                        Make       = $driverMetadata.Make
+                        Model      = $modelName
+                        DriverPath = $driverPath
+                    }
+                    if ($driverMetadata.PSObject.Properties['SystemId'] -and -not [string]::IsNullOrWhiteSpace($driverMetadata.SystemId)) {
+                        $driverRecord | Add-Member -NotePropertyName SystemId -NotePropertyValue $driverMetadata.SystemId
+                    }
+                    if ($driverMetadata.PSObject.Properties['MachineType'] -and -not [string]::IsNullOrWhiteSpace($driverMetadata.MachineType)) {
+                        $driverRecord | Add-Member -NotePropertyName MachineType -NotePropertyValue $driverMetadata.MachineType
+                    }
+                    if ($driverMetadata.PSObject.Properties['ProductName'] -and -not [string]::IsNullOrWhiteSpace($driverMetadata.ProductName)) {
+                        $driverRecord | Add-Member -NotePropertyName ProductName -NotePropertyValue $driverMetadata.ProductName
+                    }
+                    $successfullyDownloaded.Add($driverRecord)
                }
                else {
-                    WriteLog "Warning: Could not find 'Make' for successful download of model '$modelName'. Skipping from DriverMapping.json."
+                    WriteLog "Warning: Could not find driver metadata for successful download of model '$modelName'. Skipping from DriverMapping.json."
                }
            }
            else {