$OS = Get-CimInstance Win32_OperatingSystem
$CPU = Get-CimInstance Win32_Processor | Select-Object -First 1
$RAM = [math]::Round($OS.TotalVisibleMemorySize / 1MB, 2)
$Disks = Get-CimInstance Win32_LogicalDisk -Filter "DriveType=3" |
    Select-Object DeviceID, VolumeName,
        @{Name='SizeGB';Expression={[math]::Round($_.Size / 1GB, 2)}},
        @{Name='FreeGB';Expression={[math]::Round($_.FreeSpace / 1GB, 2)}}

$IPs = Get-NetIPAddress -AddressFamily IPv4 |
    Where-Object {$_.IPAddress -notlike '169.254*' -and $_.IPAddress -ne '127.0.0.1'} |
    Select-Object InterfaceAlias, IPAddress, PrefixLength

[PSCustomObject]@{
    ComputerName = $env:COMPUTERNAME
    OS = $OS.Caption
    Version = $OS.Version
    LastBoot = $OS.LastBootUpTime
    UptimeDays = [math]::Round(((Get-Date) - $OS.LastBootUpTime).TotalDays, 1)
    CPU = $CPU.Name
    RAMGB = $RAM
}

$Disks
$IPs

$CriticalServices = 'WinRM', 'W32Time', 'EventLog', 'LanmanServer'
$MinFreeGB = 15

$OS = Get-CimInstance Win32_OperatingSystem
$Disks = Get-CimInstance Win32_LogicalDisk -Filter "DriveType=3" | ForEach-Object {
    [PSCustomObject]@{
        Drive = $_.DeviceID
        FreeGB = [math]::Round($_.FreeSpace / 1GB, 2)
        SizeGB = [math]::Round($_.Size / 1GB, 2)
        Status = if (($_.FreeSpace / 1GB) -lt $MinFreeGB) { 'LOW' } else { 'OK' }
    }
}

$Services = foreach ($ServiceName in $CriticalServices) {
    $S = Get-Service -Name $ServiceName -ErrorAction SilentlyContinue
    [PSCustomObject]@{
        Service = $ServiceName
        Status = if ($S) { $S.Status } else { 'NotFound' }
    }
}

$Errors24h = Get-WinEvent -FilterHashtable @{
    LogName='System'; Level=2; StartTime=(Get-Date).AddDays(-1)
} -ErrorAction SilentlyContinue | Measure-Object

$PendingReboot = (Test-Path 'HKLM:\SOFTWARE\Microsoft\Windows\CurrentVersion\WindowsUpdate\Auto Update\RebootRequired')

[PSCustomObject]@{
    ComputerName = $env:COMPUTERNAME
    UptimeDays = [math]::Round(((Get-Date) - $OS.LastBootUpTime).TotalDays, 1)
    SystemErrors24h = $Errors24h.Count
    PendingReboot = $PendingReboot
}

$Disks
$Services

$Paths = @($env:TEMP, 'C:\Windows\Temp')
$Days = 7

foreach ($Path in $Paths) {
    if (Test-Path $Path) {
        Get-ChildItem $Path -Recurse -Force -ErrorAction SilentlyContinue |
            Where-Object { $_.LastWriteTime -lt (Get-Date).AddDays(-$Days) } |
            Remove-Item -Recurse -Force -ErrorAction SilentlyContinue -WhatIf
    }
}

# После проверки уберите -WhatIf.

$Root = 'C:\'
$Output = 'C:\Temp\large-files.csv'
$MinSizeMB = 500

Get-ChildItem $Root -Recurse -File -ErrorAction SilentlyContinue |
    Where-Object { $_.Length -gt ($MinSizeMB * 1MB) } |
    Select-Object FullName, LastWriteTime, @{Name='SizeMB';Expression={[math]::Round($_.Length / 1MB, 2)}} |
    Sort-Object SizeMB -Descending |
    Export-Csv $Output -NoTypeInformation -Encoding UTF8

Write-Host "Отчет сохранен: $Output"

$Target = 'server01.company.local'
$Ports = 80, 443, 445, 3389, 5985

$Results = foreach ($Port in $Ports) {
    $Test = Test-NetConnection -ComputerName $Target -Port $Port -WarningAction SilentlyContinue
    [PSCustomObject]@{
        Target = $Target
        Port = $Port
        TcpOpen = $Test.TcpTestSucceeded
        RemoteAddress = $Test.RemoteAddress
    }
}

$Results | Format-Table -AutoSize

$ServiceName = 'Spooler'
$LogPath = 'C:\Temp\service-watch.log'

$Service = Get-Service -Name $ServiceName -ErrorAction SilentlyContinue

if (-not $Service) {
    "$(Get-Date) Service $ServiceName not found" | Out-File $LogPath -Append -Encoding UTF8
    exit 1
}

if ($Service.Status -ne 'Running') {
    Start-Service -Name $ServiceName
    "$(Get-Date) Service $ServiceName was stopped and has been started" | Out-File $LogPath -Append -Encoding UTF8
} else {
    "$(Get-Date) Service $ServiceName is running" | Out-File $LogPath -Append -Encoding UTF8
}

$Paths = @(
 'HKLM:\Software\Microsoft\Windows\CurrentVersion\Uninstall\*',
 'HKLM:\Software\WOW6432Node\Microsoft\Windows\CurrentVersion\Uninstall\*'
)

Get-ItemProperty $Paths -ErrorAction SilentlyContinue |
    Where-Object DisplayName |
    Select-Object DisplayName, DisplayVersion, Publisher, InstallDate |
    Sort-Object DisplayName |
    Export-Csv 'C:\Temp\installed-software.csv' -NoTypeInformation -Encoding UTF8

$Events = Get-WinEvent -FilterHashtable @{
    LogName = 'Security'
    Id = 4625
    StartTime = (Get-Date).AddDays(-1)
} -ErrorAction SilentlyContinue

$Results = foreach ($Event in $Events) {
    $Xml = [xml]$Event.ToXml()
    $Data = @{}
    foreach ($Node in $Xml.Event.EventData.Data) {
        $Data[$Node.Name] = $Node.'#text'
    }

    [PSCustomObject]@{
        TimeCreated = $Event.TimeCreated
        Account = $Data['TargetUserName']
        Workstation = $Data['WorkstationName']
        IpAddress = $Data['IpAddress']
        FailureReason = $Data['FailureReason']
    }
}

$Results |
    Group-Object Account, IpAddress |
    Sort-Object Count -Descending |
    Select-Object Count, Name

$Source = 'D:\Data'
$Destination = '\\backup-server\backup\Data'
$Log = 'C:\Temp\robocopy-backup.log'

$Args = @(
    $Source,
    $Destination,
    '/MIR',
    '/R:2',
    '/W:5',
    '/Z',
    '/FFT',
    "/LOG:$Log",
    '/TEE'
)

Start-Process -FilePath 'robocopy.exe' -ArgumentList $Args -Wait -NoNewWindow
Write-Host "Backup finished. Log: $Log"

$Days = 30

Get-ChildItem Cert:\LocalMachine\My |
    Where-Object { $_.NotAfter -lt (Get-Date).AddDays($Days) } |
    Select-Object Subject, Issuer, NotAfter, Thumbprint |
    Sort-Object NotAfter

$Path = 'C:\Temp\server-report.html'

$Disks = Get-CimInstance Win32_LogicalDisk -Filter "DriveType=3" |
    Select-Object DeviceID,
        @{Name='SizeGB';Expression={[math]::Round($_.Size/1GB,1)}},
        @{Name='FreeGB';Expression={[math]::Round($_.FreeSpace/1GB,1)}} |
    ConvertTo-Html -Fragment -PreContent '
Disks
'

$Services = Get-Service |
    Where-Object Status -ne 'Running' |
    Select-Object Name, DisplayName, Status |
    ConvertTo-Html -Fragment -PreContent '
Stopped Services
'

$Html = @"







Server Report: $env:COMPUTERNAME
Generated: $(Get-Date)
$Disks
$Services


"@

$Html | Out-File $Path -Encoding UTF8
Invoke-Item $Path

$Servers = Get-Content 'C:\Temp\servers.txt'

Invoke-Command -ComputerName $Servers -ScriptBlock {
    $Disk = Get-CimInstance Win32_LogicalDisk -Filter "DeviceID='C:'"
    [PSCustomObject]@{
        ComputerName = $env:COMPUTERNAME
        Drive = $Disk.DeviceID
        SizeGB = [math]::Round($Disk.Size / 1GB, 1)
        FreeGB = [math]::Round($Disk.FreeSpace / 1GB, 1)
        FreePercent = [math]::Round(($Disk.FreeSpace / $Disk.Size) * 100, 1)
    }
} | Export-Csv 'C:\Temp\servers-disk-space.csv' -NoTypeInformation -Encoding UTF8

Import-Module ActiveDirectory

$GroupName = 'Domain Admins'
$Output = 'C:\Temp\domain-admins.csv'

Get-ADGroupMember -Identity $GroupName -Recursive |
    Where-Object objectClass -eq 'user' |
    Get-ADUser -Properties Department, Title, Mail, Enabled |
    Select-Object Name, SamAccountName, Enabled, Department, Title, Mail |
    Export-Csv $Output -NoTypeInformation -Encoding UTF8

Import-Module ActiveDirectory

Search-ADAccount -LockedOut -UsersOnly |
    Select-Object Name, SamAccountName, DistinguishedName

# Разблокировка конкретного пользователя:
# Unlock-ADAccount -Identity ivanov

$CheckpointName = "Before maintenance $(Get-Date -Format 'yyyy-MM-dd HH-mm')"

Get-VM | Where-Object State -eq 'Running' | ForEach-Object {
    Checkpoint-VM -Name $_.Name -SnapshotName $CheckpointName
    Write-Host "Checkpoint created for $($_.Name)"
}

Import-Module WebAdministration

$AppPool = 'DefaultAppPool'
$State = (Get-WebAppPoolState -Name $AppPool).Value

if ($State -ne 'Started') {
    Start-WebAppPool -Name $AppPool
    Write-Host "AppPool $AppPool был $State и теперь запущен"
} else {
    Write-Host "AppPool $AppPool работает нормально"
}

$RunKeys = @(
 'HKCU:\Software\Microsoft\Windows\CurrentVersion\Run',
 'HKLM:\Software\Microsoft\Windows\CurrentVersion\Run',
 'HKLM:\Software\WOW6432Node\Microsoft\Windows\CurrentVersion\Run'
)

foreach ($Key in $RunKeys) {
    if (Test-Path $Key) {
        Write-Host "=== $Key ==="
        Get-ItemProperty $Key |
            Select-Object * -ExcludeProperty PSPath, PSParentPath, PSChildName, PSDrive, PSProvider
    }
}

Write-Host "=== Startup folders ==="
$StartupFolders = @(
    "$env:APPDATA\Microsoft\Windows\Start Menu\Programs\Startup",
    "$env:ProgramData\Microsoft\Windows\Start Menu\Programs\Startup"
)

foreach ($Folder in $StartupFolders) {
    if (Test-Path $Folder) {
        Get-ChildItem $Folder -Force
    }
}

$Path = 'C:\ImportantFiles'
$Manifest = 'C:\Temp\hash-manifest.csv'

Get-ChildItem $Path -Recurse -File |
    Get-FileHash -Algorithm SHA256 |
    Select-Object Path, Hash, Algorithm |
    Export-Csv $Manifest -NoTypeInformation -Encoding UTF8

Write-Host "Manifest saved: $Manifest"