Public/Get-RemovableFile.ps1

<#
 
# Get-RemovableFile
 
Nicht benötigte Dateien finden mit dem Zweck diese zu löschen.
 
- **Hashtags** UserCmdlet File Cleanup
- **Version** 2020.01.26
 
#>


Set-StrictMode -Version Latest

[System.Flags()]
enum CleanUpFileType {
    All                   = 0
    RecycleBin            = 1
    SystemTemp            = 2
    SoftwareDistribution  = 4
    UserTemp              = 6
}

class CleanUpFile {
    [CleanUpFileType]$CleanUpFileType
    [String]$Name
    [long]$Length
    [String]$Path
    CleanUpFile([CleanUpFileType]$cleanUpFileType, [String]$name, [long]$length, [String]$path) {
        $this.CleanUpFileType = $cleanUpFileType
        $this.Name        = $name
        $this.Length      = $length
        $this.Path        = $path
    }
    [string]ToString(){
        return ("{0}" -f $this.Name)
    }
}

function Get-RemovableFile {
    <#
    .SYNOPSIS
        Überflüssige Dateien ermitteln.
    .EXAMPLE
        Get-RemovableFile -FileType All -Verbose
        Zeigt eine Übersicht der nicht benötigten Dateien.
    .EXAMPLE
        Get-RemovableFile -FileType All | Remove-Item -Force -Recurse -ErrorAction Ignore
        Löscht die überflüssigen Dateien.
    .PARAMETER FileType
        Gültige werde gem [CleanUpFileType]-Enum.
    .PARAMETER Verbose
        Zeigt Analyse-Daten an.
    .OUTPUTS
        <CleanUpFile>-Objekte
    #>

    [CmdletBinding(SupportsShouldProcess = $false,
                   ConfirmImpact         = [System.Management.Automation.ConfirmImpact]::Low)]
    [OutputType([CleanUpFile])]
    param(
        [Parameter(Mandatory = $true)]
        [ValidateSet("All", "RecycleBin", "SystemTemp", "SoftwareDistribution", "UserTemp")]
        [CleanUpFileType[]]
        $FileType
    )

    begin {
        $stopWatch = [System.Diagnostics.Stopwatch]::StartNew()
        $UselessContentPaths = @()
        switch ($FileType)
        {
            {$_ -cin [CleanUpFileType]::RecycleBin, [CleanUpFileType]::All} {
                $UselessContentPaths += [PSCustomObject]@{
                    CleanUpFileType = [CleanUpFileType]::RecycleBin
                    Path            = (Join-Path -Path $env:SystemDrive -ChildPath  '\$RECYCLE.BIN')
                }
            }
            {$_ -cin [CleanUpFileType]::SystemTemp, [CleanUpFileType]::All} {
                $UselessContentPaths += [PSCustomObject]@{
                    CleanUpFileType = [CleanUpFileType]::SystemTemp
                    Path            = (Join-Path -Path $env:SystemDrive -ChildPath  '\Temp')
                }
                $UselessContentPaths += [PSCustomObject]@{
                    CleanUpFileType = [CleanUpFileType]::SystemTemp
                    Path            = (Join-Path -Path $env:SystemRoot  -ChildPath  '\Temp')
                }
            }
            {$_ -cin [CleanUpFileType]::SoftwareDistribution, [CleanUpFileType]::All} {
                $UselessContentPaths += [PSCustomObject]@{
                    CleanUpFileType = [CleanUpFileType]::SoftwareDistribution
                    Path            = (Join-Path -Path $env:SystemRoot  -ChildPath  '\SoftwareDistribution')
                }
            }
            {$_ -cin [CleanUpFileType]::UserTemp, [CleanUpFileType]::All} {
                $UselessContentPaths += [PSCustomObject]@{
                    CleanUpFileType = [CleanUpFileType]::UserTemp
                    Path            = (Join-Path -Path $env:USERPROFILE -ChildPath  '\AppData\Local\Temp')
                }
                $UselessContentPaths += [PSCustomObject]@{
                    CleanUpFileType = [CleanUpFileType]::UserTemp
                    Path            = (Join-Path -Path $env:USERPROFILE -ChildPath  '\AppData\LocalLow\Temp')
                }
            }
        }
        $UselessContentPaths | ForEach-Object -Process {
            "PATH EXIST: {0} | FILETYPE: {1} | PATH: {2}" -f ($PSItem.Path | Test-Path), $PSItem.CleanUpFileType, $PSItem.Path | Write-Verbose
        }
    }

    process {
        $Analysis = @()

        $UselessContentPaths | ForEach-Object -Process {
            $fileStats = [PSCustomObject]@{
                "CleanUpFileType" = $PSItem.CleanUpFileType
                "Count"           = 0
                "LengthInMb"      = 0
            }
            "To analyse $($fileStats.CleanUpFileType)File-Typ in $($PSItem.Path)" | Write-Verbose
            $PSItem | Get-ChildItem -Recurse -File -Force -ErrorAction Ignore | ForEach-Object -Process {
                $fileStats.Count++
                $fileStats.LengthInMb += $_.Length
                return [CleanUpFile]::new($fileStats.CleanUpFileType, $_.Name, $_.Length, $_.FullName)
            }
            $fileStats.LengthInMb = [int]($fileStats.LengthInMb / 1MB)

            if($Analysis.Count -gt 0 -and $fileStats.CleanUpFileType -in $Analysis.CleanUpFileType){
                $Analysis | Where-Object CleanUpFileType -CEQ $fileStats.CleanUpFileType | Select-Object -First 1 | ForEach-Object -Process {
                    $PSItem.Count      += $fileStats.Count
                    $PSItem.LengthInMb += $fileStats.LengthInMb
                }
            } else {
                $Analysis += $fileStats
            }
        }
    }

    end {
        $stopWatch.Stop()
        if ($PSBoundParameters['Verbose']) {
            "- - - - - - - - - - - Evaluation Overview - - - - - - - - - - -" | Write-Verbose
            "{0,-25} | {1,15} | {2,23}" -f "CleanUp-FileType", "Quantity Files", "Summary Length (MByte)" | Write-Verbose
            "{0,-25}+{1,15}+{2,23}" -f "--------------------------", "-----------------", "------------------------" | Write-Verbose
            $Analysis | Sort-Object -Property LengthInMb -Descending | ForEach-Object -Process {
                "{0,-25} | {1,15} | {2,23}" -f $_.CleanUpFileType, $_.Count, $_.LengthInMb | Write-Verbose
            }
            "Total Duration (HH:mm:ss): $($stopWatch.Elapsed)" | Write-Verbose
        }
    }
}