<#
	.SYNOPSIS
		script that can run against local folder structure to move 
		program logs older than specified time to specified location.
		The script will keep the folder structure intact, creating
		subfolders as needed to match the folder structure of the source.
 
	.DESCRIPTION
		Advanced 1 4-29-13
		Dr. Scripto is in a tizzy! It seems that someone has allowed a
		series of application log files to pile up for around two years,
		and they’re starting to put the pinch on free disk space on a
		server.  Your job is to help get the old files off to a new location.
		Actually, this happened last week, too. You might as well create a
		tool to do the archiving.
		The current set of log files are located in C:\Application\Log. There
		are three applications that write logs here, and each uses its own
		subfolder.  For example, C:\Application\Log\App1, C:\Application\Log\OtherApp,
		and C:\Application\Log\ThisAppAlso.  Within those subfolders, the
		filenames are random GUIDs with a .LOG filename extension. Once created
		on disk, the files are never touched again by the applications. Your
		goal is to grab all of the files older than 90 days and move them to
		\\NASServer\Archives ‐ although that path will change from time to time.
		You need to maintain the subfolder structure, so that files from
		C:\Application\Log\App1 get moved to \\NASServer\Archives\App1, and
		so forth.  Make those paths parameters, so that Dr. Scripto can just
		run this tool with whatever paths are appropriate at the time.
		The 90 ‐day period should be a parameter too.  You want to ensure that
		any errors that happen during the move are clearly displayed to whoever
		is running your command. If no errors occur, your command doesn’t need
		to display any output – “no news is good news.”
 
		.EXAMPLE
	Advanced_1.ps1
		This will move the logs from the source folder to the default destination folder
		"\\NASServer\Archives\" with the default time period of 90 days or older.
 
	Advanced_1.ps1 -d RemoteLocation
		This will move the logs from the source folder to the specified destination folder
		with the default time period of 90 days.  The path should have a trailing backslash.
 
	Advanced_1.ps1 -t FilesOlderThanThisNumber
		This will move the logs from the source folder to the default destination folder
		"\\NASServer\Archives\" with the specified time period.  This number should be
		represented by a negative number.
 
	Advanced_1.ps1 -d RemoteLocation -t FilesOlderThanThisNumber
		This will move the logs from the source folder to the specified destination folder
		with the specified time period.
#>
 
Param(
	[alias("d")][string]$RootDestination="\\scanbox\workstation\archive\",
	[alias("t")][string]$TimePeriod="-90"
	)
 
GCI C:\Application\Log -Recurse -Filter "*.log" | `
?{$_.LastWriteTime -lt (get-date).AddDays($TimePeriod)} | `
%{$Dest=$_.Directory.Name;`
If(-not(Test-Path -Path $RootDestination$Dest))`
{NI -itemtype directory $RootDestination$Dest | Out-Null};`
MV -Path $_.FullName -Destination $RootDestination$Dest}

function Move-LogFile {
 
<#
.SYNOPSIS
Move files with a .log extension from the SourcePath to the DestinationPath that are older than Days. 
.DESCRIPTION
Move-LogFile is a function that moves files with a .log extension from the first level subfolders that are specified via
the SourcePath parameter to the same subfolder name in the DestinationPath parameter that are older than the number of days
specified in the Days parameter. If a subfolder does not exist in the destination with the same name as the source, it will
be created. This function requires PowerShell version 3.
.PARAMETER SourcePath
The parent path of the subfolders where the log files reside. Log files in the actual SourcePath folder will not be archived,
only first level subfolders of the specified SourcePath location.
.PARAMETER DestinationPath
Parent Path of the Destination folder to archive the log files. The name of the original subfolder where the log files reside
will be created if it doesn't already exist in the Destination folder. Destination subfolders are only created if one or more
files need to be archived based on the days parameter. Empty subfolders are not created until needed.
.PARAMETER Days
Log files not written to in more than the number of days specified in this parameter are moved to the destination folder location.
.PARAMETER Force
Switch parameter that when specified overwrites destination files if they already exist.
.EXAMPLE
Move-LogFile -SourcePath 'C:\Application\Log' -DestinationPath '\\NASServer\Archives' -Days 90
.EXAMPLE
Move-LogFile -SourcePath 'C:\Application\Log' -DestinationPath '\\NASServer\Archives' -Days 90 -Force
#>
 
    [CmdletBinding()]
    param (
        [string]$SourcePath = 'C:\Application\Log',
        [string]$DestinationPath = '\\NASServer\Archives',
        [int]$Days = 90,
        [switch]$Force
    )
 
    BEGIN {        
        Write-Verbose "Retrieving a list of files to be archived that are older than $($Days) days"
        try {
            $files = Get-ChildItem -Path (Join-Path -Path $SourcePath -ChildPath '*\*.log') -ErrorAction Stop |
                     Where-Object LastWriteTime -lt (Get-Date).AddDays(-$days)
        }
        catch {
            Write-Warning $_.Exception.Message
        }
 
        $folders = $files.directory.name | Select-Object -Unique
        Write-Verbose "A total of $($files.Count) files have been found in $($folders.Count) folders that require archival"
    }
 
    PROCESS {
        foreach ($folder in $folders) {
 
            $problem = $false
            $ArchiveDestination = Join-Path -Path $DestinationPath -ChildPath $folder
            $ArchiveSource = Join-Path -Path $SourcePath -ChildPath $folder
            $ArchiveFiles = $files | Where-Object directoryname -eq $ArchiveSource
 
            if (-not (Test-Path $ArchiveDestination)) {
                Write-Verbose "Creating a directory named $($folder) in $($DestinationPath)"
                try {
                    New-Item -ItemType directory -Path $ArchiveDestination -ErrorAction Stop | Out-Null
                }
                catch {
                    $problem = $true
                    Write-Warning $_.Exception.Message
                }
            }
 
            if (-not $problem) {
                Write-Verbose "Archiving $($ArchiveFiles.Count) files from $($ArchiveSource) to $($ArchiveDestination)"
                try {
                    If ($Force) {
                        $ArchiveFiles | Move-Item -Destination $ArchiveDestination -Force -ErrorAction Stop
                    }
                    Else {
                        $ArchiveFiles | Move-Item -Destination $ArchiveDestination -ErrorAction Stop
                    }
                }
                catch {
                    Write-Warning $_.Exception.Message
                }
            }
 
        }
    }
 
    END {
        Remove-Variable -Name SourcePath, DestinationPath, Days, Force, files, folders, folder,
        problem, ArchiveDestination, ArchiveSource, ArchiveFiles -ErrorAction SilentlyContinue
    }
 
}

Get-ChildItem -Path 'C:\Application\Log' -Recurse | Where-Object {
$_.LastWriteTime -lt (Get-Date).AddDays(-90)
} | Move-Item -Force -Destination '\\NASServer\Archives'

<#
.SYNOPSIS
    Moves application log files that are older than 90 days to \\NASServer\Archives.
.DESCRIPTION
    This script was originally written for Event 1 of the 2013 Scripting Games (Beginners Track).
.EXAMPLE
    C:\Scripts\Move-LogFiles.ps1  
#>
 
$files = Get-ChildItem –Path  “C:\Application\Log” -Filter *.log  –Recurse | Where-Object -FilterScript {$_.CreationTime –lt (Get-Date).AddDays(-90)} 
 
foreach($file in $files)
{
    if(!(Test-Path -LiteralPath "\\NASServer\Archives\$($file.Directory.Name)"))
    {
            New-Item -Path "\\NASServer\Archives\$($file.Directory.Name)" -ItemType Directory -ErrorAction Stop | Out-Null
    }
 
    Move-Item -Path $file.FullName -Destination "\\NASServer\Archives\$($file.Directory.Name)\$($file.Name)"
}