Jump to content

Script per "Computername" speichern

nowayout

Von nowayout
in Windows Forum — Scripting

Der letzte Beitrag zu diesem Thema ist mehr als 180 Tage alt. Bitte erstelle einen neuen Beitrag zu Deiner Anfrage!

Empfohlene Beiträge

nowayout Apprentice

nowayout   0

Geschrieben
Geschrieben

hallo habe leider zu wenig ahnung mit Scripten ...

ich möchte gerne wissen:

Name des Computers, WindowsVersion, und osbuildnumber, und eine abfrage ob dieser pc Windows 11 tauglich ist.

soweit hab ich es mir zusammen gesucht.

 

mein problem:

ich will das ganze per GPO ausführen, und die datei am server mit dem computer namen abspeichern.

wie kann ich das im Script hinterlegen?

 

kann ich auch die ausgabe minimieren? da die ausgabe:

CsCaption OsName  OsBuildNumber 

{"returnCode":1,"returnReason":"TPM, Processor, ","logging":"Storage: OSDiskSize=238GB. PASS; Memory: System_Memory=8GB. PASS; TPM: TPMVersion=1.2, 2, 3. FAIL; Processor: {AddressWidth=64; MaxClockSpeed=2594; NumberOfLogicalCores=4; Manufacturer=GenuineIntel; Caption=Intel64 Family 6 Model 61 Stepping 4; }. FAIL; SecureBoot: Capable. PASS; ","returnResult":"NOT CAPABLE"}

 

ist.

mit würde reichen

CsCaption OsName                                  OsBuildNumber     Win11
NB06         Microsoft Windows 10 Pro      19044                   CAPABLE / NOT CAPABLE

 

hier das script:

 

danke danke für die hilfe.

lg

Gerald

 

  

Get-ComputerInfo | ft CsCaption,OsName,OsBuildNumber

$exitCode = 0

[int]$MinOSDiskSizeGB = 64
[int]$MinMemoryGB = 4
[Uint32]$MinClockSpeedMHz = 1000
[Uint32]$MinLogicalCores = 2
[Uint16]$RequiredAddressWidth = 64

$PASS_STRING = "PASS"
$FAIL_STRING = "FAIL"
$FAILED_TO_RUN_STRING = "FAILED TO RUN"
$UNDETERMINED_CAPS_STRING = "UNDETERMINED"
$UNDETERMINED_STRING = "Undetermined"
$CAPABLE_STRING = "Capable"
$NOT_CAPABLE_STRING = "Not capable"
$CAPABLE_CAPS_STRING = "CAPABLE"
$NOT_CAPABLE_CAPS_STRING = "NOT CAPABLE"
$STORAGE_STRING = "Storage"
$OS_DISK_SIZE_STRING = "OSDiskSize"
$MEMORY_STRING = "Memory"
$SYSTEM_MEMORY_STRING = "System_Memory"
$GB_UNIT_STRING = "GB"
$TPM_STRING = "TPM"
$TPM_VERSION_STRING = "TPMVersion"
$PROCESSOR_STRING = "Processor"
$SECUREBOOT_STRING = "SecureBoot"
$I7_7820HQ_CPU_STRING = "i7-7820hq CPU"

# 0=name of check, 1=attribute checked, 2=value, 3=PASS/FAIL/UNDETERMINED
$logFormat = '{0}: {1}={2}. {3}; '

# 0=name of check, 1=attribute checked, 2=value, 3=unit of the value, 4=PASS/FAIL/UNDETERMINED
$logFormatWithUnit = '{0}: {1}={2}{3}. {4}; '

# 0=name of check.
$logFormatReturnReason = '{0}, '

# 0=exception.
$logFormatException = '{0}; '

# 0=name of check, 1= attribute checked and its value, 2=PASS/FAIL/UNDETERMINED
$logFormatWithBlob = '{0}: {1}. {2}; '

# return returnCode is -1 when an exception is thrown. 1 if the value does not meet requirements. 0 if successful. -2 default, script didn't run.
$outObject = @{ returnCode = -2; returnResult = $FAILED_TO_RUN_STRING; returnReason = ""; logging = "" }

# NOT CAPABLE(1) state takes precedence over UNDETERMINED(-1) state
function Private:UpdateReturnCode {
    param(
        [Parameter(Mandatory = $true)]
        [ValidateRange(-2, 1)]
        [int] $ReturnCode
    )

    Switch ($ReturnCode) {

        0 {
            if ($outObject.returnCode -eq -2) {
                $outObject.returnCode = $ReturnCode
            }
        }
        1 {
            $outObject.returnCode = $ReturnCode
        }
        -1 {
            if ($outObject.returnCode -ne 1) {
                $outObject.returnCode = $ReturnCode
            }
        }
    }
}

$Source = @"
using Microsoft.Win32;
using System;
using System.Runtime.InteropServices;

    public class CpuFamilyResult
    {
        public bool IsValid { get; set; }
        public string Message { get; set; }
    }

    public class CpuFamily
    {
        [StructLayout(LayoutKind.Sequential)]
        public struct SYSTEM_INFO
        {
            public ushort ProcessorArchitecture;
            ushort Reserved;
            public uint PageSize;
            public IntPtr MinimumApplicationAddress;
            public IntPtr MaximumApplicationAddress;
            public IntPtr ActiveProcessorMask;
            public uint NumberOfProcessors;
            public uint ProcessorType;
            public uint AllocationGranularity;
            public ushort ProcessorLevel;
            public ushort ProcessorRevision;
        }

        [DllImport("kernel32.dll")]
        internal static extern void GetNativeSystemInfo(ref SYSTEM_INFO lpSystemInfo);

        public enum ProcessorFeature : uint
        {
            ARM_SUPPORTED_INSTRUCTIONS = 34
        }

        [DllImport("kernel32.dll")]
        [return: MarshalAs(UnmanagedType.Bool)]
        static extern bool IsProcessorFeaturePresent(ProcessorFeature processorFeature);

        private const ushort PROCESSOR_ARCHITECTURE_X86 = 0;
        private const ushort PROCESSOR_ARCHITECTURE_ARM64 = 12;
        private const ushort PROCESSOR_ARCHITECTURE_X64 = 9;

        private const string INTEL_MANUFACTURER = "GenuineIntel";
        private const string AMD_MANUFACTURER = "AuthenticAMD";
        private const string QUALCOMM_MANUFACTURER = "Qualcomm Technologies Inc";

        public static CpuFamilyResult Validate(string manufacturer, ushort processorArchitecture)
        {
            CpuFamilyResult cpuFamilyResult = new CpuFamilyResult();

            if (string.IsNullOrWhiteSpace(manufacturer))
            {
                cpuFamilyResult.IsValid = false;
                cpuFamilyResult.Message = "Manufacturer is null or empty";
                return cpuFamilyResult;
            }

            string registryPath = "HKEY_LOCAL_MACHINE\\Hardware\\Description\\System\\CentralProcessor\\0";
            SYSTEM_INFO sysInfo = new SYSTEM_INFO();
            GetNativeSystemInfo(ref sysInfo);

            switch (processorArchitecture)
            {
                case PROCESSOR_ARCHITECTURE_ARM64:

                    if (manufacturer.Equals(QUALCOMM_MANUFACTURER, StringComparison.OrdinalIgnoreCase))
                    {
                        bool isArmv81Supported = IsProcessorFeaturePresent(ProcessorFeature.ARM_SUPPORTED_INSTRUCTIONS);

                        if (!isArmv81Supported)
                        {
                            string registryName = "CP 4030";
                            long registryValue = (long)Registry.GetValue(registryPath, registryName, -1);
                            long atomicResult = (registryValue >> 20) & 0xF;

                            if (atomicResult >= 2)
                            {
                                isArmv81Supported = true;
                            }
                        }

                        cpuFamilyResult.IsValid = isArmv81Supported;
                        cpuFamilyResult.Message = isArmv81Supported ? "" : "Processor does not implement ARM v8.1 atomic instruction";
                    }
                    else
                    {
                        cpuFamilyResult.IsValid = false;
                        cpuFamilyResult.Message = "The processor isn't currently supported for Windows 11";
                    }

                    break;

                case PROCESSOR_ARCHITECTURE_X64:
                case PROCESSOR_ARCHITECTURE_X86:

                    int cpuFamily = sysInfo.ProcessorLevel;
                    int cpuModel = (sysInfo.ProcessorRevision >> 8) & 0xFF;
                    int cpuStepping = sysInfo.ProcessorRevision & 0xFF;

                    if (manufacturer.Equals(INTEL_MANUFACTURER, StringComparison.OrdinalIgnoreCase))
                    {
                        try
                        {
                            cpuFamilyResult.IsValid = true;
                            cpuFamilyResult.Message = "";

                            if (cpuFamily >= 6 && cpuModel <= 95 && !(cpuFamily == 6 && cpuModel == 85))
                            {
                                cpuFamilyResult.IsValid = false;
                                cpuFamilyResult.Message = "";
                            }
                            else if (cpuFamily == 6 && (cpuModel == 142 || cpuModel == 158) && cpuStepping == 9)
                            {
                                string registryName = "Platform Specific Field 1";
                                int registryValue = (int)Registry.GetValue(registryPath, registryName, -1);

                                if ((cpuModel == 142 && registryValue != 16) || (cpuModel == 158 && registryValue != 8))
                                {
                                    cpuFamilyResult.IsValid = false;
                                }
                                cpuFamilyResult.Message = "PlatformId " + registryValue;
                            }
                        }
                        catch (Exception ex)
                        {
                            cpuFamilyResult.IsValid = false;
                            cpuFamilyResult.Message = "Exception:" + ex.GetType().Name;
                        }
                    }
                    else if (manufacturer.Equals(AMD_MANUFACTURER, StringComparison.OrdinalIgnoreCase))
                    {
                        cpuFamilyResult.IsValid = true;
                        cpuFamilyResult.Message = "";

                        if (cpuFamily < 23 || (cpuFamily == 23 && (cpuModel == 1 || cpuModel == 17)))
                        {
                            cpuFamilyResult.IsValid = false;
                        }
                    }
                    else
                    {
                        cpuFamilyResult.IsValid = false;
                        cpuFamilyResult.Message = "Unsupported Manufacturer: " + manufacturer + ", Architecture: " + processorArchitecture + ", CPUFamily: " + sysInfo.ProcessorLevel + ", ProcessorRevision: " + sysInfo.ProcessorRevision;
                    }

                    break;

                default:
                    cpuFamilyResult.IsValid = false;
                    cpuFamilyResult.Message = "Unsupported CPU category. Manufacturer: " + manufacturer + ", Architecture: " + processorArchitecture + ", CPUFamily: " + sysInfo.ProcessorLevel + ", ProcessorRevision: " + sysInfo.ProcessorRevision;
                    break;
            }
            return cpuFamilyResult;
        }
    }
"@

# Storage
try {
    $osDrive = Get-WmiObject -Class Win32_OperatingSystem | Select-Object -Property SystemDrive
    $osDriveSize = Get-WmiObject -Class Win32_LogicalDisk -filter "DeviceID='$($osDrive.SystemDrive)'" | Select-Object @{Name = "SizeGB"; Expression = { $_.Size / 1GB -as [int] } }  

    if ($null -eq $osDriveSize) {
        UpdateReturnCode -ReturnCode 1
        $outObject.returnReason += $logFormatReturnReason -f $STORAGE_STRING
        $outObject.logging += $logFormatWithBlob -f $STORAGE_STRING, "Storage is null", $FAIL_STRING
        $exitCode = 1
    }
    elseif ($osDriveSize.SizeGB -lt $MinOSDiskSizeGB) {
        UpdateReturnCode -ReturnCode 1
        $outObject.returnReason += $logFormatReturnReason -f $STORAGE_STRING
        $outObject.logging += $logFormatWithUnit -f $STORAGE_STRING, $OS_DISK_SIZE_STRING, ($osDriveSize.SizeGB), $GB_UNIT_STRING, $FAIL_STRING
        $exitCode = 1
    }
    else {
        $outObject.logging += $logFormatWithUnit -f $STORAGE_STRING, $OS_DISK_SIZE_STRING, ($osDriveSize.SizeGB), $GB_UNIT_STRING, $PASS_STRING
        UpdateReturnCode -ReturnCode 0
    }
}
catch {
    UpdateReturnCode -ReturnCode -1
    $outObject.logging += $logFormat -f $STORAGE_STRING, $OS_DISK_SIZE_STRING, $UNDETERMINED_STRING, $UNDETERMINED_CAPS_STRING
    $outObject.logging += $logFormatException -f "$($_.Exception.GetType().Name) $($_.Exception.Message)"
    $exitCode = 1
}

# Memory (bytes)
try {
    $memory = Get-WmiObject Win32_PhysicalMemory | Measure-Object -Property Capacity -Sum | Select-Object @{Name = "SizeGB"; Expression = { $_.Sum / 1GB -as [int] } }

    if ($null -eq $memory) {
        UpdateReturnCode -ReturnCode 1
        $outObject.returnReason += $logFormatReturnReason -f $MEMORY_STRING
        $outObject.logging += $logFormatWithBlob -f $MEMORY_STRING, "Memory is null", $FAIL_STRING
        $exitCode = 1
    }
    elseif ($memory.SizeGB -lt $MinMemoryGB) {
        UpdateReturnCode -ReturnCode 1
        $outObject.returnReason += $logFormatReturnReason -f $MEMORY_STRING
        $outObject.logging += $logFormatWithUnit -f $MEMORY_STRING, $SYSTEM_MEMORY_STRING, ($memory.SizeGB), $GB_UNIT_STRING, $FAIL_STRING
        $exitCode = 1
    }
    else {
        $outObject.logging += $logFormatWithUnit -f $MEMORY_STRING, $SYSTEM_MEMORY_STRING, ($memory.SizeGB), $GB_UNIT_STRING, $PASS_STRING
        UpdateReturnCode -ReturnCode 0
    }
}
catch {
    UpdateReturnCode -ReturnCode -1
    $outObject.logging += $logFormat -f $MEMORY_STRING, $SYSTEM_MEMORY_STRING, $UNDETERMINED_STRING, $UNDETERMINED_CAPS_STRING
    $outObject.logging += $logFormatException -f "$($_.Exception.GetType().Name) $($_.Exception.Message)"
    $exitCode = 1
}

# TPM
try {
    $tpm = Get-Tpm

    if ($null -eq $tpm) {
        UpdateReturnCode -ReturnCode 1
        $outObject.returnReason += $logFormatReturnReason -f $TPM_STRING
        $outObject.logging += $logFormatWithBlob -f $TPM_STRING, "TPM is null", $FAIL_STRING
        $exitCode = 1
    }
    elseif ($tpm.TpmPresent) {
        $tpmVersion = Get-WmiObject -Class Win32_Tpm -Namespace root\CIMV2\Security\MicrosoftTpm | Select-Object -Property SpecVersion

        if ($null -eq $tpmVersion.SpecVersion) {
            UpdateReturnCode -ReturnCode 1
            $outObject.returnReason += $logFormatReturnReason -f $TPM_STRING
            $outObject.logging += $logFormat -f $TPM_STRING, $TPM_VERSION_STRING, "null", $FAIL_STRING
            $exitCode = 1
        }

        $majorVersion = $tpmVersion.SpecVersion.Split(",")[0] -as [int]
        if ($majorVersion -lt 2) {
            UpdateReturnCode -ReturnCode 1
            $outObject.returnReason += $logFormatReturnReason -f $TPM_STRING
            $outObject.logging += $logFormat -f $TPM_STRING, $TPM_VERSION_STRING, ($tpmVersion.SpecVersion), $FAIL_STRING
            $exitCode = 1
        }
        else {
            $outObject.logging += $logFormat -f $TPM_STRING, $TPM_VERSION_STRING, ($tpmVersion.SpecVersion), $PASS_STRING
            UpdateReturnCode -ReturnCode 0
        }
    }
    else {
        if ($tpm.GetType().Name -eq "String") {
            UpdateReturnCode -ReturnCode -1
            $outObject.logging += $logFormat -f $TPM_STRING, $TPM_VERSION_STRING, $UNDETERMINED_STRING, $UNDETERMINED_CAPS_STRING
            $outObject.logging += $logFormatException -f $tpm
        }
        else {
            UpdateReturnCode -ReturnCode  1
            $outObject.returnReason += $logFormatReturnReason -f $TPM_STRING
            $outObject.logging += $logFormat -f $TPM_STRING, $TPM_VERSION_STRING, ($tpm.TpmPresent), $FAIL_STRING
        }
        $exitCode = 1
    }
}
catch {
    UpdateReturnCode -ReturnCode -1
    $outObject.logging += $logFormat -f $TPM_STRING, $TPM_VERSION_STRING, $UNDETERMINED_STRING, $UNDETERMINED_CAPS_STRING
    $outObject.logging += $logFormatException -f "$($_.Exception.GetType().Name) $($_.Exception.Message)"
    $exitCode = 1
}

# CPU Details
$cpuDetails;
try {
    $cpuDetails = @(Get-WmiObject -Class Win32_Processor)[0]

    if ($null -eq $cpuDetails) {
        UpdateReturnCode -ReturnCode 1
        $exitCode = 1
        $outObject.returnReason += $logFormatReturnReason -f $PROCESSOR_STRING
        $outObject.logging += $logFormatWithBlob -f $PROCESSOR_STRING, "CpuDetails is null", $FAIL_STRING
    }
    else {
        $processorCheckFailed = $false

        # AddressWidth
        if ($null -eq $cpuDetails.AddressWidth -or $cpuDetails.AddressWidth -ne $RequiredAddressWidth) {
            UpdateReturnCode -ReturnCode 1
            $processorCheckFailed = $true
            $exitCode = 1
        }

        # ClockSpeed is in MHz
        if ($null -eq $cpuDetails.MaxClockSpeed -or $cpuDetails.MaxClockSpeed -le $MinClockSpeedMHz) {
            UpdateReturnCode -ReturnCode 1;
            $processorCheckFailed = $true
            $exitCode = 1
        }

        # Number of Logical Cores
        if ($null -eq $cpuDetails.NumberOfLogicalProcessors -or $cpuDetails.NumberOfLogicalProcessors -lt $MinLogicalCores) {
            UpdateReturnCode -ReturnCode 1
            $processorCheckFailed = $true
            $exitCode = 1
        }

        # CPU Family
        Add-Type -TypeDefinition $Source
        $cpuFamilyResult = [CpuFamily]::Validate([String]$cpuDetails.Manufacturer, [uint16]$cpuDetails.Architecture)

        $cpuDetailsLog = "{AddressWidth=$($cpuDetails.AddressWidth); MaxClockSpeed=$($cpuDetails.MaxClockSpeed); NumberOfLogicalCores=$($cpuDetails.NumberOfLogicalProcessors); Manufacturer=$($cpuDetails.Manufacturer); Caption=$($cpuDetails.Caption); $($cpuFamilyResult.Message)}"

        if (!$cpuFamilyResult.IsValid) {
            UpdateReturnCode -ReturnCode 1
            $processorCheckFailed = $true
            $exitCode = 1
        }

        if ($processorCheckFailed) {
            $outObject.returnReason += $logFormatReturnReason -f $PROCESSOR_STRING
            $outObject.logging += $logFormatWithBlob -f $PROCESSOR_STRING, ($cpuDetailsLog), $FAIL_STRING
        }
        else {
            $outObject.logging += $logFormatWithBlob -f $PROCESSOR_STRING, ($cpuDetailsLog), $PASS_STRING
            UpdateReturnCode -ReturnCode 0
        }
    }
}
catch {
    UpdateReturnCode -ReturnCode -1
    $outObject.logging += $logFormat -f $PROCESSOR_STRING, $PROCESSOR_STRING, $UNDETERMINED_STRING, $UNDETERMINED_CAPS_STRING
    $outObject.logging += $logFormatException -f "$($_.Exception.GetType().Name) $($_.Exception.Message)"
    $exitCode = 1
}

# SecureBooot
try {
    $isSecureBootEnabled = Confirm-SecureBootUEFI
    $outObject.logging += $logFormatWithBlob -f $SECUREBOOT_STRING, $CAPABLE_STRING, $PASS_STRING
    UpdateReturnCode -ReturnCode 0
}
catch [System.PlatformNotSupportedException] {
    # PlatformNotSupportedException "Cmdlet not supported on this platform." - SecureBoot is not supported or is non-UEFI computer.
    UpdateReturnCode -ReturnCode 1
    $outObject.returnReason += $logFormatReturnReason -f $SECUREBOOT_STRING
    $outObject.logging += $logFormatWithBlob -f $SECUREBOOT_STRING, $NOT_CAPABLE_STRING, $FAIL_STRING
    $exitCode = 1
}
catch [System.UnauthorizedAccessException] {
    UpdateReturnCode -ReturnCode -1
    $outObject.logging += $logFormatWithBlob -f $SECUREBOOT_STRING, $UNDETERMINED_STRING, $UNDETERMINED_CAPS_STRING
    $outObject.logging += $logFormatException -f "$($_.Exception.GetType().Name) $($_.Exception.Message)"
    $exitCode = 1
}
catch {
    UpdateReturnCode -ReturnCode -1
    $outObject.logging += $logFormatWithBlob -f $SECUREBOOT_STRING, $UNDETERMINED_STRING, $UNDETERMINED_CAPS_STRING
    $outObject.logging += $logFormatException -f "$($_.Exception.GetType().Name) $($_.Exception.Message)"
    $exitCode = 1
}

# i7-7820hq CPU
try {
    $supportedDevices = @('surface studio 2', 'precision 5520')
    $systemInfo = @(Get-WmiObject -Class Win32_ComputerSystem)[0]

    if ($null -ne $cpuDetails) {
        if ($cpuDetails.Name -match 'i7-7820hq cpu @ 2.90ghz'){
            $modelOrSKUCheckLog = $systemInfo.Model.Trim()
            if ($supportedDevices -contains $modelOrSKUCheckLog){
                $outObject.logging += $logFormatWithBlob -f $I7_7820HQ_CPU_STRING, $modelOrSKUCheckLog, $PASS_STRING
                $outObject.returnCode = 0
                $exitCode = 0
            }
        }
    }
}
catch {
    if ($outObject.returnCode -ne 0){
        UpdateReturnCode -ReturnCode -1
        $outObject.logging += $logFormatWithBlob -f $I7_7820HQ_CPU_STRING, $UNDETERMINED_STRING, $UNDETERMINED_CAPS_STRING
        $outObject.logging += $logFormatException -f "$($_.Exception.GetType().Name) $($_.Exception.Message)"
        $exitCode = 1
    }
}

Switch ($outObject.returnCode) {

    0 { $outObject.returnResult = $CAPABLE_CAPS_STRING }
    1 { $outObject.returnResult = $NOT_CAPABLE_CAPS_STRING }
    -1 { $outObject.returnResult = $UNDETERMINED_CAPS_STRING }
    -2 { $outObject.returnResult = $FAILED_TO_RUN_STRING }
}

$outObject | ConvertTo-Json -Compress

 

Link zu diesem Kommentar
nowayout Apprentice

nowayout   0

Geschrieben
  • Autor
Geschrieben

Hallo, ja das script ist readiness-powershell-script/, ich habe nur die abfrage 

Get-ComputerInfo | ft CsCaption,OsName,OsBuildNumber

reingegeben.

wie ich es in die GPO einbau weiß ich, ich möchte nur wissen wie ich die ausgabe in ein CSV mache.

da ich mit

$computername= get-computerinfo cscaption

Out-File -FilePath C:\temp\$computername.txt

leider den gewünschten erfolg nicht bekomme :( und alles leer ist.

 

und auch nicht weiß wo genau ich das hinschreiben muss. :(

 

danke für eure hilfe

lg und ein schönen WE.

Link zu diesem Kommentar
MurdocX Veteran

MurdocX   950

Geschrieben
Geschrieben

Du hast eigentlich alle Teile schon beinander die du benötigst. Die Ausgabe über FT kannst du dir sparen, denn das wandelt es nur in eine Ansicht um. Du möchtest aber mit den Objekten weiterarbeiten. Eine Auswahl triffst du mit: 

Select-Object CsCaption,OsName,OsBuildNumber

 

danach noch die Daten in das gewünschte Format Konvertieren: 

ConvertTo-Csv -Delimiter ";" -NoTypeInformation

 

$computername gibts nicht. Nimm stattdessen: 

$env:Computername

 

Als letzten Schritt musst du nur die Ausgabe in eine Datei dran hängen. Das solltest du hin bekommen ;-) 

vor 18 Stunden schrieb daabm:

Ich mach mal einen auf Spielverderber :-)

Den gibt es in jeder Gruppe :D 

 

vor 18 Stunden schrieb daabm:

GPO, Startskript, zentrale Speicherung

Riecht förmlich danach 👃

Link zu diesem Kommentar
  • 2 Wochen später...
nowayout Apprentice

nowayout   0

Geschrieben
  • Autor
Geschrieben

Hallo,

 

bin nun endlich zum testen gekommen: habe jetzt eingefügt:

 

Get-ComputerInfo | Select-Object CsCaption,OsName,OsBuildNumber | Export-Csv -Path "C:\Temp\Win11_Readyness.csv" -Delimiter ";" -NoTypeInformation

 

leider kommt der output vom eigendlichem Skript nicht in die csv :(

 

alles was ich bekomme:

"CsCaption";"OsName";"OsBuildNumber"
"NB06";"Microsoft Windows 10 Pro";"19044"

 

also mir fehlt:

{"returnCode":1,"returnReason":"TPM, Processor, ","logging":"Storage: OSDiskSize=238GB. PASS; Memory: System_Memory=8GB. PASS; TPM: TPMVersion=1.2, 2, 3. FAIL; Processor: {AddressWidth=64; MaxClockSpeed=2594; NumberOfLogicalCores=4; Manufacturer=GenuineIntel; Caption=Intel64 Family 6 Model 61 Stepping 4; }. FAIL; SecureBoot: Capable. PASS; ","returnResult":"NOT CAPABLE"}

im csv.

am liebsten wäre mir nur der NOT CAPABLE oder CAPABLE. als weitere spalte im csv.

wunsch z.b. : "NB06";"Microsoft Windows 10 Pro";"19044" NOT CAPABLE

bitte und danke für die hilfe ;)

 

lg

gerald

 

 

 

Link zu diesem Kommentar
BOfH_666 Veteran

BOfH_666   577

Geschrieben
Geschrieben (bearbeitet)
vor 22 Minuten schrieb nowayout:

am liebsten wäre mir nur der NOT CAPABLE oder CAPABLE. als weitere spalte im csv.

wunsch z.b. : "NB06";"Microsoft Windows 10 Pro";"19044" NOT CAPABLE

 

Ich würde eigentlich eher den umgekehrten Weg empfehlen. Anstatt die fragile Logik, zu beurteilen, ob eine Komponente Windows 11 tauglich ist oder nicht, in das Script zu packen, wäre es vermutlich deutlich einfacher, nur die entsprechenden Daten einzusammeln und die Bewertung später mit den dann verfügbaren - idealerweise tabellarisch aufbereiteten - Daten durchzuführen.

 

Du brauchst ja quasi nur CPU, RAM-Größe, HDD/SSD-Größe, UEFI ja/nein, TPM-Version, Grafikkarte und Bildschirm-Größe und -Auflösung.  

 

 

bearbeitet von BOfH_666
  • Like 1
Link zu diesem Kommentar
nowayout Apprentice

nowayout   0

Geschrieben
  • Autor
Geschrieben
vor 5 Minuten schrieb BOfH_666:

 

Ich würde eigentlich eher den umgekehrten Weg empfehlen. Anstatt die fragile Logik, zu beurteilen, ob eine Komponente Windows 11 tauglich ist oder nicht, in das Script zu packen, wäre es vermutlich deutlich einfacher, nur die entsprechenden Daten einzusammeln und die Bewertung später mit den dann verfügbaren - idealerweise tabellarisch aufbereiteten - Daten durchzuführen.

 

Du brauchst ja quasi nur CPU, RAM-Größe, HDD/SSD-Größe, UEFI ja/nein, TPM-Version, Grafikkarte und Bildschirm-Größe und -Auflösung.  

 

 

das habe ich ja e vom "HauptSkript"

{"returnCode":1,"returnReason":"TPM, Processor, ","logging":"Storage: OSDiskSize=238GB. PASS; Memory: System_Memory=8GB. PASS; TPM: TPMVersion=1.2, 2, 3. FAIL; Processor: {AddressWidth=64; MaxClockSpeed=2594; NumberOfLogicalCores=4; Manufacturer=GenuineIntel; Caption=Intel64 Family 6 Model 61 Stepping 4; }. FAIL; SecureBoot: Capable. PASS; ","returnResult":"NOT CAPABLE"}

 

aber wie gesagt durch die erste abfrage Get-ComputerInfo | Select-Object CsCaption,OsName,OsBuildNumber | Export-Csv -Path "C:\Temp\Win11_Readyness.csv" -Delimiter ";" -NoTypeInformation

 bekomme ich den output nicht in das csv. rein.

 

 

Link zu diesem Kommentar
BOfH_666 Veteran

BOfH_666   577

Geschrieben
Geschrieben
vor 28 Minuten schrieb nowayout:

das habe ich ja e vom "HauptSkript"

{"returnCode":1,"returnReason":"TPM, Processor, ","logging":"Storage: OSDiskSize=238GB. PASS; Memory: System_Memory=8GB. PASS; TPM: TPMVersion=1.2, 2, 3. FAIL; Processor: {AddressWidth=64; MaxClockSpeed=2594; NumberOfLogicalCores=4; Manufacturer=GenuineIntel; Caption=Intel64 Family 6 Model 61 Stepping 4; }. FAIL; SecureBoot: Capable. PASS; ","returnResult":"NOT CAPABLE"}

 

Du hättest gern erwähnen dürfen, dass das Script von MSFT für die Windows-11-Tauglichkeitsprüfung veröffentlich wurde. :aha2:  Die Daten, die das Script zurück liefert sind JSON-codiert und enthalten bereits das Ergebnis dieser Prüfung.

 

Wie hier:

https://techcommunity.microsoft.com/t5/microsoft-intune-blog/understanding-readiness-for-windows-11-with-microsoft-endpoint/ba-p/2770866

nachzulesen ist, kann man anhand der Rückgabewerte des Scripts erkennen, ob ein System Windows 11 ready ist oder nicht.  Siehe returnCode und returnReason!!!

 

Die Daten, die Du hier als Beispiel gepostest hast, sagen aus, dass Dein System NICHT Windows 11 ready ist, weil TPM und Prozessor nicht den Anforderungen entsprechen.

 

Link zu diesem Kommentar
daabm Grand Master

daabm   1.354

Geschrieben
Geschrieben

Mit Deinem Get-ComputerInfo zerstörst Du das Objektmodell - das liefert nämlich was völlig anderes als der Rest vom Skript, das paßt dann nicht zusammen und läßt sich daher nicht gemeinsam exportieren.

Das ganze wäre super einfach, wenn Du diese Zeile

$outObject | ConvertTo-Json -Compress

(490 im Original)

so umbaust, daß sie direkt das von Dir Gewünschte macht.

 

So als Idee... 

$CompInfo = Get-ComputerInfo
$OutObject['Computername'] = $CompInfo.CsCaption
$outObject['OsBuildNumber'] = $CompInfo.OsBuildNumber
$outObject['OsName'] = $CompInfo.OsName

$outObject | ConvertTo-Csv "blah.csv"

 

Link zu diesem Kommentar
nowayout Apprentice

nowayout   0

Geschrieben
  • Autor
Geschrieben
vor 14 Stunden schrieb BOfH_666:

 

Du hättest gern erwähnen dürfen, dass das Script von MSFT für die Windows-11-Tauglichkeitsprüfung veröffentlich wurde. :aha2:  Die Daten, die das Script zurück liefert sind JSON-codiert und enthalten bereits das Ergebnis dieser Prüfung.

 

Wie hier:

https://techcommunity.microsoft.com/t5/microsoft-intune-blog/understanding-readiness-for-windows-11-with-microsoft-endpoint/ba-p/2770866

nachzulesen ist, kann man anhand der Rückgabewerte des Scripts erkennen, ob ein System Windows 11 ready ist oder nicht.  Siehe returnCode und returnReason!!!

 

Die Daten, die Du hier als Beispiel gepostest hast, sagen aus, dass Dein System NICHT Windows 11 ready ist, weil TPM und Prozessor nicht den Anforderungen entsprechen.

 

in einen meiner ersten posts hab ich geschrieben das es das skript ist :( sorry das es nicht genau erklärt habe.

 

ja und ich will das script erweitern damit ich auch zuordnen kann welcher pc, und bei der gelegenheit auch welches update drauf ist z.b. 19044.

vor 14 Stunden schrieb daabm:

Mit Deinem Get-ComputerInfo zerstörst Du das Objektmodell - das liefert nämlich was völlig anderes als der Rest vom Skript, das paßt dann nicht zusammen und läßt sich daher nicht gemeinsam exportieren.

Das ganze wäre super einfach, wenn Du diese Zeile

$outObject | ConvertTo-Json -Compress

(490 im Original)

so umbaust, daß sie direkt das von Dir Gewünschte macht.

 

So als Idee... 

$CompInfo = Get-ComputerInfo
$OutObject['Computername'] = $CompInfo.CsCaption
$outObject['OsBuildNumber'] = $CompInfo.OsBuildNumber
$outObject['OsName'] = $CompInfo.OsName

$outObject | ConvertTo-Csv "blah.csv"

 

 

 

super danke, werde es mir anschauen und dann berichten :)

lg

gerald aus wien

Also meine aufgabenstellung war:

finde heraus welche windows version auf den PC`s istalliert ist, und ist der pc windows 11 tauglich.

dann hab ich gesucht und das skript für die windows 11 überprüfung gefunden.

und denn rest hab ich selbst reingedoktort :) (leider ned so wie ich das haben möchte)

 

meine idee im kopf war halt bei meinen kunden einfach das skript auszuführen und dann am server eine csv finden die mit die daten zeigt.

und ich sie dann pro Kunde in eine excel reingebe :)

so wollte ich es haben: pro PC: 

"NB06";"Microsoft Windows 10 Pro";"19044" NOT CAPABLE

"NB07";"Microsoft Windows 10 Pro";"19044" CAPABLE

"NB08";"Microsoft Windows 10 Pro";"19044" NOT CAPABLE

 

hoffe das ich es jetzt erklärt habe das man es versteht.

bin gerne für andere ideen offen die meine umsetzung unterstützen.

lg aus wien

gerald

 

 

 

 

Link zu diesem Kommentar
Der letzte Beitrag zu diesem Thema ist mehr als 180 Tage alt. Bitte erstelle einen neuen Beitrag zu Deiner Anfrage!

Schreibe einen Kommentar

Du kannst jetzt antworten und Dich später registrieren. Falls Du bereits ein Mitglied bist, logge Dich jetzt ein.

Gast
Auf dieses Thema antworten...

×   Du hast formatierten Text eingefügt.   Formatierung jetzt entfernen

  Only 75 emoji are allowed.

×   Dein Link wurde automatisch eingebettet.   Einbetten rückgängig machen und als Link darstellen

×   Dein vorheriger Inhalt wurde wiederhergestellt.   Editor-Fenster leeren

×   Du kannst Bilder nicht direkt einfügen. Lade Bilder hoch oder lade sie von einer URL.

×
Zurück zur Übersicht


×
×
  • Neu erstellen...