WinDirOps

0.2.0-preview0001

WinDirOps.psm1

#Region './Classes/FolderDeletionResult.ps1' -1

class FolderDeletionResult {
    [string]$FolderPath
    [bool]$DeletionSuccess
    [string]$DeletionMessage
    [string]$ComputerName

    # Constructor to initialize the properties
    FolderDeletionResult([string]$folderPath, [bool]$deletionSuccess, [string]$deletionMessage, [string]$computerName) {
        $this.FolderPath = $folderPath
        $this.DeletionSuccess = $deletionSuccess
        $this.DeletionMessage = $deletionMessage
        $this.ComputerName = $computerName
    }
}
#EndRegion './Classes/FolderDeletionResult.ps1' 15
#Region './Public/Clear-Directory.ps1' -1

function Clear-Directory {
    [CmdletBinding(SupportsShouldProcess = $true, ConfirmImpact = 'High')]
    param (
        [Parameter(ValueFromPipeline = $true, Mandatory = $true)]
        [string]$Directory,

        [Parameter(ValueFromPipelineByPropertyName = $true)]
        [string]$ComputerName = $env:COMPUTERNAME  # Default to local computer
    )

    process {
        if ($PSCmdlet.ShouldProcess($Directory, "Delete directory on $ComputerName")) {
            $result = Remove-DirectoryByType -Directory $Directory -ComputerName $ComputerName
            Write-Information -MessageData $result.DeletionMessage -Tags "DeleteOperation"
            return $result
        }
    }
}
#EndRegion './Public/Clear-Directory.ps1' 19
#Region './Public/Clear-DirectoryContents.ps1' -1

function Clear-DirectoryContents {
    param (
        [string]$Directory
    )

    try {
        # Create a temporary directory
        $emptyDir = [System.IO.Path]::GetTempPath() + [System.Guid]::NewGuid().ToString()
        mkdir $emptyDir | Out-Null

        # Use robocopy to fast-delete the directory contents by syncing an empty directory
        robocopy $emptyDir $Directory /mir | Out-Null

        # Remove the target directory and the temporary directory
        Remove-Item -Path $Directory -Recurse -Force -ErrorAction SilentlyContinue
        Remove-Item -Path $emptyDir -Recurse -Force -ErrorAction SilentlyContinue

        return $true
    } catch {
        Write-Error "Failed to clear directory contents for $Directory. Error: $_"
        return $false
    }
}
#EndRegion './Public/Clear-DirectoryContents.ps1' 24
#Region './Public/Remove-DirectoryByType.ps1' -1

function Remove-DirectoryByType {
    param (
        [string]$Directory,
        [string]$ComputerName = $env:COMPUTERNAME
    )

    $isLocal = $ComputerName -eq $env:COMPUTERNAME

    if ($isLocal) {
        return Remove-LocalDirectory -Directory $Directory
    } else {
        return Remove-RemoteDirectory -Directory $Directory -ComputerName $ComputerName
    }
}
#EndRegion './Public/Remove-DirectoryByType.ps1' 15
#Region './Public/Remove-LocalDirectory.ps1' -1

function Remove-LocalDirectory {
    param (
        [string]$Directory
    )

    try {
        if (Clear-DirectoryContents -Directory $Directory) {
            return [FolderDeletionResult]::new(
                $Directory,
                $true,
                "Successfully deleted local directory '$Directory'.",
                $env:COMPUTERNAME
            )
        } else {
            return [FolderDeletionResult]::new(
                $Directory,
                $false,
                "Failed to delete local directory '$Directory'.",
                $env:COMPUTERNAME
            )
        }
    } catch {
        return [FolderDeletionResult]::new(
            $Directory,
            $false,
            "Error occurred while deleting local directory '$Directory'. $_",
            $env:COMPUTERNAME
        )
    }
}
#EndRegion './Public/Remove-LocalDirectory.ps1' 31
#Region './Public/Remove-RemoteDirectory.ps1' -1

function Remove-RemoteDirectory {
    param (
        [string]$Directory,
        [string]$ComputerName
    )

    # Get the full script block for Clear-DirectoryContents function
    $clearDirectoryFunction = Get-FunctionScriptBlock -FunctionName 'Clear-DirectoryContents'

    if (-not $clearDirectoryFunction) {
        Write-Error "Unable to retrieve Clear-DirectoryContents function."
        return
    }

    $scriptBlock = {
        param ($remoteDirectory, $clearFunction)

        # Define the function from the passed string
        Invoke-Expression $clearFunction

        # Call the Clear-DirectoryContents function
        if (Clear-DirectoryContents -Directory $remoteDirectory) {
            return @{
                Directory      = $remoteDirectory
                Success        = $true
                Message        = "Successfully deleted remote directory '$remoteDirectory'."
                ComputerName   = $env:COMPUTERNAME
            }
        } else {
            return @{
                Directory      = $remoteDirectory
                Success        = $false
                Message        = "Failed to delete remote directory '$remoteDirectory'."
                ComputerName   = $env:COMPUTERNAME
            }
        }
    }

    try {
        # Execute the script block on the remote machine, passing the function string and directory
        $rawResult = Invoke-Command -ComputerName $ComputerName -ScriptBlock $scriptBlock -ArgumentList $Directory, $clearDirectoryFunction

        # Construct the FolderDeletionResult object locally
        return [FolderDeletionResult]::new(
            $rawResult.Directory,
            $rawResult.Success,
            $rawResult.Message,
            $rawResult.ComputerName
        )
    } catch {
        return [FolderDeletionResult]::new(
            $Directory,
            $false,
            "Error occurred while deleting remote directory '$Directory'. $_",
            $ComputerName
        )
    }
}
#EndRegion './Public/Remove-RemoteDirectory.ps1' 59