Event 1: My way…

This year judges should focus on blogging. I’ve decided that it may be helpful to give attendees chance to return the favor – I will blog about things I like and dislike in your scripts. At the same time – I will post how I would do it. Feel free to complain, point out mistakes. I will try to post it as soon as entries are closed for submissions, so that I will do it “fresh” before I see any of your scripts – this way I won’t “steal” your ideas.

Beginner event looks relatively easy, but I see no information about existence of target folders, my assumption is that they exist, otherwise it gets far too complex for one liner. I would normally use aliases when writing one liner, but here I want to be as verbose as possible to make it easy to understand.

Get-ChildItem -Path C:\Application\Log\*\*.Log |             
    Where-Object {            
        $_.LastWriteTime -lt (Get-Date).AddDays(-90)            
    } | Move-Item -Destination {             
        "\\NASServer\Archives\{0}\" -f $_.Directory.Name             
    }            

I’ve used pretty advanced technique here – using script block for parameter that accepts value from pipeline by property name, to reflect folder structure in source folder on archived side. Obviously, I don’t expect beginners to do the same. But anyone who will – gets in my “favorite” bucket almost for certain.

Advanced event is not more than making tool out of this one liner. Tool relatively simple. Parameters should include path to source folder(s) (I thought that I would prefer tool that allows me to pass array of paths to logs), path to destination folder, and limit of days that log files age should exceed. I thought it may be useful to have also two more parameters: filter, that log files should match and force parameter. Seems obvious, that this tools should support WhatIf, Confirm, and having Force kind of make this implementation complete (so that even if ConfirmPreference is set to High – we still have an option to avoid prompting). Complete param block:

<#
    .Synopsis
        Normally I would include full help here...
#>            
            
[CmdletBinding(            
    SupportsShouldProcess = $true,            
    ConfirmImpact = 'Medium'            
)]            
param (            
    # Adding help for parameter here - you avoid issues with typos in .Parameter ParamName            
    [Parameter(            
        ValueFromPipelineByPropertyName = $true            
    )]            
    [Alias('Path','FullName')]            
    [ValidateScript({            
        if (Test-Path -PathType Container -Path $_) {            
            $true            
        } else {            
            throw "$_ is not valid directory."            
        }            
    })]            
    [string[]]$Source = @(            
        'C:\Application\Log\App1'            
        'C:\Application\Log\OtherApp'            
        'C:\Application\Log\ThisAppAlso'            
    ),            
            
    # And another parameter help...            
    [ValidateScript({            
        if (Test-Path -PathType Container -Path $_) {            
            $true            
        } else {            
            throw "$_ is not valid directory."            
        }            
    })]            
    [string]$Destination = '\\NASServer\Archives',            
            
    # Filtering files here...            
    [string]$Filter = '*.Log',            
            
    # Here we decided how old file should be.            
    [int]$Limit = 90,            
            
    # And here we force things.            
    [switch]$Force            
)            

In the begin block I configured two things: DateTime object that we will use for comparison for log files found, and parameters for Move-Item cmdlet that will be common for all moves performed:

$Max = (Get-Date).AddDays(-$Limit)            
    $MoveParams = @{            
        Confirm = $false            
        ErrorAction = 'Stop'            
    }            

In process block I perform necessary actions for each source folder: define target folder based on source’s leaf, make sure target folder exists, find all files that meet criteria (date-wise and filter-wise) and for each file found – perform move, with option to only display actions to be performed, or require confirmation for each file moved. All that with some verbose messages possible, if user will ask for them with Verbose parameter. Move can always go wrong, and we want to report it to the user – thus try/ catch with small report returned if something fails. If everything works fine – nothing is reported, as requested:

foreach ($Folder in $Source) {            
    $MoveParams.Destination = "$Destination\{0}" -f (Split-Path $Folder -Leaf)            
    try {            
        if (!(Test-Path -Path $MoveParams.Destination -PathType Container)) {            
            New-Item -ItemType Directory -Path $MoveParams.Destination -ErrorAction Stop            
        }            
        Write-Verbose "Processing folder: $Folder"            
        Get-ChildItem -Path $Folder -Filter $Filter |             
            Where-Object {            
                $_.LastWriteTime -lt $Max            
            } |            
            ForEach-Object {            
                if ($Force -or $PSCmdlet.ShouldProcess(            
                    $_.FullName,            
                    "Move to $($MoveParams.Destination)"            
                ))            
                {            
                    try {            
                        $File = $_.FullName            
                        Write-Verbose "Moving file: $File"            
                        Move-Item -Path $File @MoveParams            
                    } catch {            
                        "Problem moving file $File : $_"            
                    }            
                }            
            }            
        } catch {            
            "Problem with creating target folder: $_"            
        }            
}            

This is the way I would do it. But be sure: if you did it differently it’s still possible, that I will pick your script as my favorite one. Heck, this difference can be the reason for this decision. That’s what I love about Scripting Games: it doesn’t matter what is your “role”: attendee, spectator, judge – there is always chance to learn new things. And now – I move on to attendees entries. Can’t wait.

Advertisement