Powershell Abfrage Computername, OS, Notebook oder Workstation, Office Version

Import-Module ActiveDirectory

Function Get-OfficeVersion {
    <#
    .Synopsis
    Gets the Office Version installed on the computer
    .DESCRIPTION
    This function will query the local or a remote computer and return the information about Office Products installed on the computer
    .NOTES   
    Name: Get-OfficeVersion
    Version: 1.0.5
    DateCreated: 2015-07-01
    DateUpdated: 2016-07-20
    .LINK
    https://github.com/OfficeDev/Office-IT-Pro-Deployment-Scripts
    .PARAMETER ComputerName
    The computer or list of computers from which to query 
    .PARAMETER ShowAllInstalledProducts
    Will expand the output to include all installed Office products
    .EXAMPLE
    Get-OfficeVersion
    Description:
    Will return the locally installed Office product
    .EXAMPLE
    Get-OfficeVersion -ComputerName client01,client02
    Description:
    Will return the installed Office product on the remote computers
    .EXAMPLE
    Get-OfficeVersion | select *
    Description:
    Will return the locally installed Office product with all of the available properties
    #>
    [CmdletBinding(SupportsShouldProcess=$true)]
    param(
        [Parameter(ValueFromPipeline=$true,ValueFromPipelineByPropertyName=$true, Position=0)]
        [string[]]$ComputerName = $env:COMPUTERNAME,
        [switch]$ShowAllInstalledProducts,
        [System.Management.Automation.PSCredential]$Credentials
    )

    begin {
        $HKLM = [UInt32] "0x80000002"  
        $HKCR = [UInt32] "0x80000000"  

        $excelKeyPath = "Excel\DefaultIcon"  
        $wordKeyPath = "Word\DefaultIcon"  
   
        $installKeys = 'SOFTWARE\Microsoft\Windows\CurrentVersion\Uninstall',  
                       'SOFTWARE\Wow6432Node\Microsoft\Windows\CurrentVersion\Uninstall'  

        $officeKeys = 'SOFTWARE\Microsoft\Office',  
                      'SOFTWARE\Wow6432Node\Microsoft\Office'  

        $defaultDisplaySet = 'DisplayName','Version', 'ComputerName'  

        $defaultDisplayPropertySet = New-Object System.Management.Automation.PSPropertySet(‘DefaultDisplayPropertySet’,[string[]]$defaultDisplaySet)
        $PSStandardMembers = [System.Management.Automation.PSMemberInfo[]]@($defaultDisplayPropertySet)
    }

    process {

     $results = new-object PSObject 0;

     foreach ($computer in $ComputerName) {
        if ($Credentials) {
           $os=Get-WMIObject win32_operatingsystem -computername $computer -Credential $Credentials
        } else {
           $os=Get-WMIObject win32_operatingsystem -computername $computer
        }

        $osArchitecture = $os.OSArchitecture

        if ($Credentials) {
           $regProv = Get-Wmiobject -list "StdRegProv" -namespace root\default -computername $computer -Credential $Credentials  
        } else {
           $regProv = Get-Wmiobject -list "StdRegProv" -namespace root\default -computername $computer  
        }

        [System.Collections.ArrayList]$VersionList = New-Object -TypeName System.Collections.ArrayList
        [System.Collections.ArrayList]$PathList = New-Object -TypeName System.Collections.ArrayList
        [System.Collections.ArrayList]$PackageList = New-Object -TypeName System.Collections.ArrayList
        [System.Collections.ArrayList]$ClickToRunPathList = New-Object -TypeName System.Collections.ArrayList
        [System.Collections.ArrayList]$ConfigItemList = New-Object -TypeName  System.Collections.ArrayList
        $ClickToRunList = new-object PSObject 0;

        foreach ($regKey in $officeKeys) {
           $officeVersion = $regProv.EnumKey($HKLM, $regKey)
           foreach ($key in $officeVersion.sNames) {
              if ($key -match "\d{2}\.\d") {  
                if (!$VersionList.Contains($key)) {
                  $AddItem = $VersionList.Add($key)
                }

                $path = join-path $regKey $key

                $configPath = join-path $path "Common\Config"  
                $configItems = $regProv.EnumKey($HKLM, $configPath)
                if ($configItems) {
                   foreach ($configId in $configItems.sNames) {
                     if ($configId) {
                        $Add = $ConfigItemList.Add($configId.ToUpper())
                     }
                   }
                }

                $cltr = New-Object -TypeName PSObject
                $cltr | Add-Member -MemberType NoteProperty -Name InstallPath -Value ""  
                $cltr | Add-Member -MemberType NoteProperty -Name UpdatesEnabled -Value $false
                $cltr | Add-Member -MemberType NoteProperty -Name UpdateUrl -Value ""  
                $cltr | Add-Member -MemberType NoteProperty -Name StreamingFinished -Value $false
                $cltr | Add-Member -MemberType NoteProperty -Name Platform -Value ""  
                $cltr | Add-Member -MemberType NoteProperty -Name ClientCulture -Value ""  
            
                $packagePath = join-path $path "Common\InstalledPackages"  
                $clickToRunPath = join-path $path "ClickToRun\Configuration"  
                $virtualInstallPath = $regProv.GetStringValue($HKLM, $clickToRunPath, "InstallationPath").sValue  

                [string]$officeLangResourcePath = join-path  $path "Common\LanguageResources"  
                $mainLangId = $regProv.GetDWORDValue($HKLM, $officeLangResourcePath, "SKULanguage").uValue  
                if ($mainLangId) {
                    $mainlangCulture = [globalization.cultureinfo]::GetCultures("allCultures") | where {$_.LCID -eq $mainLangId}  
                    if ($mainlangCulture) {
                        $cltr.ClientCulture = $mainlangCulture.Name
                    }
                }

                [string]$officeLangPath = join-path  $path "Common\LanguageResources\InstalledUIs"  
                $langValues = $regProv.EnumValues($HKLM, $officeLangPath);
                if ($langValues) {
                   foreach ($langValue in $langValues) {
                      $langCulture = [globalization.cultureinfo]::GetCultures("allCultures") | where {$_.LCID -eq $langValue}  
                   } 
                }

                if ($virtualInstallPath) {

                } else {
                  $clickToRunPath = join-path $regKey "ClickToRun\Configuration"  
                  $virtualInstallPath = $regProv.GetStringValue($HKLM, $clickToRunPath, "InstallationPath").sValue  
                }

                if ($virtualInstallPath) {
                   if (!$ClickToRunPathList.Contains($virtualInstallPath.ToUpper())) {
                      $AddItem = $ClickToRunPathList.Add($virtualInstallPath.ToUpper())
                   }

                   $cltr.InstallPath = $virtualInstallPath
                   $cltr.StreamingFinished = $regProv.GetStringValue($HKLM, $clickToRunPath, "StreamingFinished").sValue  
                   $cltr.UpdatesEnabled = $regProv.GetStringValue($HKLM, $clickToRunPath, "UpdatesEnabled").sValue  
                   $cltr.UpdateUrl = $regProv.GetStringValue($HKLM, $clickToRunPath, "UpdateUrl").sValue  
                   $cltr.Platform = $regProv.GetStringValue($HKLM, $clickToRunPath, "Platform").sValue  
                   $cltr.ClientCulture = $regProv.GetStringValue($HKLM, $clickToRunPath, "ClientCulture").sValue  
                   $ClickToRunList += $cltr
                }

                $packageItems = $regProv.EnumKey($HKLM, $packagePath)
                $officeItems = $regProv.EnumKey($HKLM, $path)

                foreach ($itemKey in $officeItems.sNames) {
                  $itemPath = join-path $path $itemKey
                  $installRootPath = join-path $itemPath "InstallRoot"  

                  $filePath = $regProv.GetStringValue($HKLM, $installRootPath, "Path").sValue  
                  if (!$PathList.Contains($filePath)) {
                      $AddItem = $PathList.Add($filePath)
                  }
                }

                foreach ($packageGuid in $packageItems.sNames) {
                  $packageItemPath = join-path $packagePath $packageGuid
                  $packageName = $regProv.GetStringValue($HKLM, $packageItemPath, "").sValue  
            
                  if (!$PackageList.Contains($packageName)) {
                    if ($packageName) {
                       $AddItem = $PackageList.Add($packageName.Replace(' ', '').ToLower())  
                    }
                  }
                }

              }
           }
        }

    

        foreach ($regKey in $installKeys) {
            $keyList = new-object System.Collections.ArrayList
            $keys = $regProv.EnumKey($HKLM, $regKey)

            foreach ($key in $keys.sNames) {
               $path = join-path $regKey $key
               $installPath = $regProv.GetStringValue($HKLM, $path, "InstallLocation").sValue  
               if (!($installPath)) { continue }
               if ($installPath.Length -eq 0) { continue }

               $buildType = "64-Bit"  
               if ($osArchitecture -eq "32-bit") {  
                  $buildType = "32-Bit"  
               }

               if ($regKey.ToUpper().Contains("Wow6432Node".ToUpper())) {  
                  $buildType = "32-Bit"  
               }

               if ($key -match "{.{8}-.{4}-.{4}-1000-0000000FF1CE}") {  
                  $buildType = "64-Bit"   
               }

               if ($key -match "{.{8}-.{4}-.{4}-0000-0000000FF1CE}") {  
                  $buildType = "32-Bit"   
               }

               if ($modifyPath) {
                   if ($modifyPath.ToLower().Contains("platform=x86")) {  
                      $buildType = "32-Bit"  
                   }

                   if ($modifyPath.ToLower().Contains("platform=x64")) {  
                      $buildType = "64-Bit"  
                   }
               }

               $primaryOfficeProduct = $false
               $officeProduct = $false
               foreach ($officeInstallPath in $PathList) {
                 if ($officeInstallPath) {
                    $installReg = "^" + $installPath.Replace('\', '\\')  
                    $installReg = $installReg.Replace('(', '\(')  
                    $installReg = $installReg.Replace(')', '\)')  
                    if ($officeInstallPath -match $installReg) { $officeProduct = $true }
                 }
               }

               if (!$officeProduct) { continue };
           
               $name = $regProv.GetStringValue($HKLM, $path, "DisplayName").sValue            

               if ($ConfigItemList.Contains($key.ToUpper()) -and $name.ToUpper().Contains("MICROSOFT OFFICE") -and $name.ToUpper() -notlike "*MUI*" -and $name.ToUpper() -notlike "*VISIO*" -and $name.ToUpper() -notlike "*PROJECT*") {  
                  $primaryOfficeProduct = $true
               }

               $clickToRunComponent = $regProv.GetDWORDValue($HKLM, $path, "ClickToRunComponent").uValue  
               $uninstallString = $regProv.GetStringValue($HKLM, $path, "UninstallString").sValue  
               if (!($clickToRunComponent)) {
                  if ($uninstallString) {
                     if ($uninstallString.Contains("OfficeClickToRun")) {  
                         $clickToRunComponent = $true
                     }
                  }
               }

               $modifyPath = $regProv.GetStringValue($HKLM, $path, "ModifyPath").sValue   
               $version = $regProv.GetStringValue($HKLM, $path, "DisplayVersion").sValue  

               $cltrUpdatedEnabled = $NULL
               $cltrUpdateUrl = $NULL
               $clientCulture = $NULL;

               [string]$clickToRun = $false

               if ($clickToRunComponent) {
                   $clickToRun = $true
                   if ($name.ToUpper().Contains("MICROSOFT OFFICE")) {  
                      $primaryOfficeProduct = $true
                   }

                   foreach ($cltr in $ClickToRunList) {
                     if ($cltr.InstallPath) {
                       if ($cltr.InstallPath.ToUpper() -eq $installPath.ToUpper()) {
                           $cltrUpdatedEnabled = $cltr.UpdatesEnabled
                           $cltrUpdateUrl = $cltr.UpdateUrl
                           if ($cltr.Platform -eq 'x64') {  
                               $buildType = "64-Bit"   
                           }
                           if ($cltr.Platform -eq 'x86') {  
                               $buildType = "32-Bit"   
                           }
                           $clientCulture = $cltr.ClientCulture
                       }
                     }
                   }
               }
           
               if (!$primaryOfficeProduct) {
                  if (!$ShowAllInstalledProducts) {
                      continue
                  }
               }

               $object = New-Object PSObject -Property @{DisplayName = $name; Version = $version; InstallPath = $installPath; ClickToRun = $clickToRun; 
                         Bitness=$buildType; ComputerName=$computer; ClickToRunUpdatesEnabled=$cltrUpdatedEnabled; ClickToRunUpdateUrl=$cltrUpdateUrl;
                         ClientCulture=$clientCulture }
               $object | Add-Member MemberSet PSStandardMembers $PSStandardMembers
               $results += $object

            }
        }

      }

      $results = Get-Unique -InputObject $results 

      return $results;
    }
}

$chassistypes = @{1 = "Other";2 = "Unknown";3 = "Desktop";4 = "Low Profile Desktop";5 = "Pizza Box";6 = "Mini Tower";7 = "Tower";8 = "Portable";9 = "Laptop";10 = "Notebook";11 = "HandHeld";12 = "Docking Station";13 = "All in One";14 = "Sub Notebook";15 = "Space-Saving";16 = "Lunch Box";17 = "Main System Chassis";18 = "Expansion Chassis";19 = "SubChassis";20 = "Bus Expansion Chassis";21 = "Peripheral Chassis";22 = "Storage Chassis";23 = "Rack Mount Chassis";24 = "Sealed-Case PC"}  
Get-ADComputer -Filter * -Properties OperatingSystem,OperatingSystemVersion,DNSHostName | select Name,OperatingSystem,OperatingSystemVersion,@{n='Type';e={(gwmi Win32_SystemEnclosure -ComputerName $_.DNSHostName -EA SilentlyContinue).ChassisTypes | %{$chassistypes[[int]$_]}}},@{n='Office-Version';e={Get-OfficeVersion $_.DNSHostname | select -Expand Version}} | ft -AutoSize