Beschreibung

Skript

param(
    [Parameter(Mandatory=$true)]
    [string]$SourcePath,

    [string]$TargetPath,

    [int]$MaxDepth = 3,

    [int]$OlderThanYears = 5,

    [ValidateSet("DryRun", "Copy", "Move")]
    [string]$Mode = "DryRun",

    [ValidateSet("StructureOnly", "WithFiles")]
    [string]$ArchiveContent = "WithFiles",

    [switch]$CalculateSize,

    [string[]]$ExcludePaths = @(),

    [string]$CsvPath = ".\ArchivAnalyse.csv"
)

$CutoffDate = (Get-Date).AddYears(-$OlderThanYears)

if (($Mode -eq "Copy" -or $Mode -eq "Move") -and [string]::IsNullOrWhiteSpace($TargetPath)) {
    throw "TargetPath muss bei Copy oder Move angegeben werden."
}

if (-not (Test-Path $SourcePath)) {
    throw "SourcePath wurde nicht gefunden: $SourcePath"
}

function Test-IsExcludedPath {
    param(
        [string]$Path,
        [string[]]$ExcludePaths
    )

    foreach ($ExcludePath in $ExcludePaths) {
        $NormalizedExclude = $ExcludePath.TrimEnd("\")
        $NormalizedPath = $Path.TrimEnd("\")

        if ($NormalizedPath.Equals($NormalizedExclude, [System.StringComparison]::OrdinalIgnoreCase) -or
            $NormalizedPath.StartsWith($NormalizedExclude + "\", [System.StringComparison]::OrdinalIgnoreCase)) {
            return $true
        }
    }

    return $false
}

function Get-FoldersAtExactDepth {
    param(
        [string]$Path,
        [int]$CurrentDepth,
        [int]$MaxDepth
    )

    Get-ChildItem -Path $Path -Directory -Force -ErrorAction SilentlyContinue | ForEach-Object {
        if (-not (Test-IsExcludedPath -Path $_.FullName -ExcludePaths $ExcludePaths)) {
            if ($CurrentDepth -eq $MaxDepth) {
                $_
            }
            else {
                Get-FoldersAtExactDepth -Path $_.FullName -CurrentDepth ($CurrentDepth + 1) -MaxDepth $MaxDepth
            }
        }
    }
}

$Folders = Get-FoldersAtExactDepth -Path $SourcePath -CurrentDepth 1 -MaxDepth $MaxDepth
$Results = @()

foreach ($Folder in $Folders) {

    if (Test-IsExcludedPath -Path $Folder.FullName -ExcludePaths $ExcludePaths) {
        Write-Host "Überspringe ausgeschlossenen Pfad: $($Folder.FullName)"
        continue
    }

    Write-Host "Prüfe: $($Folder.FullName)"

    $Files = Get-ChildItem -Path $Folder.FullName -File -Recurse -Force -ErrorAction SilentlyContinue |
        Where-Object {
            -not (Test-IsExcludedPath -Path $_.FullName -ExcludePaths $ExcludePaths)
        }

    if ($Files.Count -eq 0) {
        $NewestDate = $null
        $TotalBytes = $null
        $IsOlder = $false
    }
    else {
        $NewestDate = ($Files | Sort-Object LastWriteTime -Descending | Select-Object -First 1).LastWriteTime
        $IsOlder = $NewestDate -lt $CutoffDate

        if ($CalculateSize) {
            $TotalBytes = ($Files | Measure-Object Length -Sum).Sum
        }
        else {
            $TotalBytes = $null
        }
    }

    $RelativePath = $Folder.FullName.Substring($SourcePath.Length).TrimStart("\")
    $Destination = if ($TargetPath) { Join-Path $TargetPath $RelativePath } else { "" }

    $Action = if ($IsOlder) { $Mode } else { "Skip" }

    $Results += [PSCustomObject]@{
        SourcePath       = $Folder.FullName
        TargetPath       = $Destination
        NewestFileDate   = $NewestDate
        CutoffDate       = $CutoffDate
        OlderThanLimit   = $IsOlder
        FileCount        = $Files.Count
        SizeBytes        = $TotalBytes
        SizeGB           = if ($TotalBytes -ne $null) { [math]::Round($TotalBytes / 1GB, 2) } else { "" }
        Mode             = $Mode
        ArchiveContent   = $ArchiveContent
        Action           = $Action
    }

    if ($IsOlder -and $Mode -ne "DryRun") {

        if ($ArchiveContent -eq "StructureOnly") {
            New-Item -Path $Destination -ItemType Directory -Force | Out-Null

            Get-ChildItem -Path $Folder.FullName -Directory -Recurse -Force -ErrorAction SilentlyContinue |
                Where-Object {
                    -not (Test-IsExcludedPath -Path $_.FullName -ExcludePaths $ExcludePaths)
                } |
                ForEach-Object {
                    $SubRelative = $_.FullName.Substring($Folder.FullName.Length).TrimStart("\")
                    $TargetDir = Join-Path $Destination $SubRelative
                    New-Item -Path $TargetDir -ItemType Directory -Force | Out-Null
                }
        }

        if ($ArchiveContent -eq "WithFiles") {
            if ($Mode -eq "Copy") {
                robocopy $Folder.FullName $Destination /E /COPY:DAT /DCOPY:DAT /R:2 /W:5
            }

            if ($Mode -eq "Move") {
                robocopy $Folder.FullName $Destination /E /MOVE /COPY:DAT /DCOPY:DAT /R:2 /W:5
            }
        }
    }
}

$Results | Export-Csv -Path $CsvPath -NoTypeInformation -Encoding UTF8 -Delimiter ";"

$ArchiveCandidates = $Results | Where-Object { $_.OlderThanLimit -eq $true }

Write-Host ""
Write-Host "Fertig."
Write-Host "CSV: $CsvPath"
Write-Host ""
Write-Host "Geprüfte Ordner:      $($Results.Count)"
Write-Host "Archivierungswürdig:  $($ArchiveCandidates.Count)"
Write-Host "Stichtag:             $CutoffDate"

if ($CalculateSize) {
    $TotalArchiveBytes = ($ArchiveCandidates | Measure-Object SizeBytes -Sum).Sum
    Write-Host "Benötigter Speicher:  $([math]::Round($TotalArchiveBytes / 1GB, 2)) GB"
}
else {
    Write-Host "Benötigter Speicher:  Nicht berechnet"
}