powershellblog.com – Page 9 – Mastering PowerShell: Tips, Tricks, and Best Practices

Latest News

Why Am I Starting a PowerShell Blog? A Funny Tale

Well, folks, I think it’s time I let you in on a little secret about why I decided to start a PowerShell blog. My story is not only educational but will hopefully put a smile on your faces too!

Advanced Template Module Generator Tool

11/08/2024/0 Comments/in Modules/by Laszlo Bocso

<#
.SYNOPSIS
Advanced Template Module Generator Tool

.DESCRIPTION
This script provides an interactive tool to generate a comprehensive structure for a PowerShell module,
including advanced features like dependency management, script analyzer settings, and extensive testing setup.

.NOTES
File Name      : AdvancedTemplateModuleGenerator.ps1
Author         : [Your Name]
Prerequisite   : PowerShell V5.1 or later
Version        : 1.0
Date           : [Current Date]

.EXAMPLE
.\AdvancedTemplateModuleGenerator.ps1
#>

function Show-Menu {
    Clear-Host
    Write-Host "=== Advanced Template Module Generator Tool ===" -ForegroundColor Cyan
    Write-Host "1. Set Module Details"
    Write-Host "2. Add Public Function"
    Write-Host "3. Add Private Function"
    Write-Host "4. Add Module Dependencies"
    Write-Host "5. Configure Build Settings"
    Write-Host "6. Configure Test Settings"
    Write-Host "7. Generate Module Files"
    Write-Host "8. Exit"
}

function Set-ModuleDetails {
    $script:moduleName = Read-Host "Enter the name of the module"
    $script:moduleDescription = Read-Host "Enter a brief description of the module"
    $script:moduleAuthor = Read-Host "Enter the author's name"
    $script:moduleVersion = Read-Host "Enter the module version (e.g., 1.0.0)"
    $script:moduleLicense = Read-Host "Enter the module license (e.g., MIT)"
    $script:moduleProjectUri = Read-Host "Enter the project URI (optional)"
    Write-Host "Module details set successfully." -ForegroundColor Green
}

function Add-PublicFunction {
    $functionName = Read-Host "Enter the name of the public function"
    $script:publicFunctions += $functionName
    Write-Host "Public function '$functionName' added." -ForegroundColor Green
}

function Add-PrivateFunction {
    $functionName = Read-Host "Enter the name of the private function"
    $script:privateFunctions += $functionName
    Write-Host "Private function '$functionName' added." -ForegroundColor Green
}

function Add-ModuleDependencies {
    do {
        $dependencyName = Read-Host "Enter the name of the module dependency (or press Enter to finish)"
        if ($dependencyName -ne "") {
            $dependencyVersion = Read-Host "Enter the required version (leave blank for any version)"
            $script:moduleDependencies += [PSCustomObject]@{
                Name = $dependencyName
                Version = $dependencyVersion
            }
            Write-Host "Dependency added: $dependencyName $dependencyVersion" -ForegroundColor Green
        }
    } while ($dependencyName -ne "")
}

function Set-BuildSettings {
    $script:usePSScriptAnalyzer = (Read-Host "Use PSScriptAnalyzer for code analysis? (Y/N)") -eq 'Y'
    $script:useplatyPS = (Read-Host "Use platyPS for documentation generation? (Y/N)") -eq 'Y'
    Write-Host "Build settings configured." -ForegroundColor Green
}

function Set-TestSettings {
    $script:usePester = (Read-Host "Use Pester for testing? (Y/N)") -eq 'Y'
    $script:useCodeCoverage = (Read-Host "Include code coverage in tests? (Y/N)") -eq 'Y'
    Write-Host "Test settings configured." -ForegroundColor Green
}

function Generate-ModuleFiles {
    if ([string]::IsNullOrWhiteSpace($script:moduleName)) {
        Write-Host "Please set module details first." -ForegroundColor Yellow
        return
    }

    $modulePath = Join-Path -Path $PWD -ChildPath $script:moduleName
    New-Item -Path $modulePath -ItemType Directory -Force | Out-Null

    # Create module manifest
    $manifestPath = Join-Path -Path $modulePath -ChildPath "$($script:moduleName).psd1"
    $manifestParams = @{
        Path = $manifestPath
        RootModule = "$($script:moduleName).psm1"
        ModuleVersion = $script:moduleVersion
        Author = $script:moduleAuthor
        Description = $script:moduleDescription
        FunctionsToExport = $script:publicFunctions
        PowerShellVersion = '5.1'
    }
    if ($script:moduleLicense) { $manifestParams['LicenseUri'] = $script:moduleLicense }
    if ($script:moduleProjectUri) { $manifestParams['ProjectUri'] = $script:moduleProjectUri }
    if ($script:moduleDependencies) {
        $manifestParams['RequiredModules'] = $script:moduleDependencies | ForEach-Object {
            if ($_.Version) { @{ModuleName = $_.Name; ModuleVersion = $_.Version} } else { $_.Name }
        }
    }
    New-ModuleManifest @manifestParams

    # Create module script file
    $modulePSM1Path = Join-Path -Path $modulePath -ChildPath "$($script:moduleName).psm1"
    $modulePSM1Content = @"
# Dot source public/private functions
`$public = @(Get-ChildItem -Path `$PSScriptRoot\Public\*.ps1 -ErrorAction SilentlyContinue)
`$private = @(Get-ChildItem -Path `$PSScriptRoot\Private\*.ps1 -ErrorAction SilentlyContinue)

foreach (`$import in @(`$public + `$private)) {
    try {
        . `$import.FullName
    } catch {
        Write-Error -Message "Failed to import function `$(`$import.FullName): `$_"
    }
}

# Export public functions
Export-ModuleMember -Function `$public.BaseName
"@
    Set-Content -Path $modulePSM1Path -Value $modulePSM1Content

    # Create Public and Private folders
    New-Item -Path (Join-Path -Path $modulePath -ChildPath "Public") -ItemType Directory -Force | Out-Null
    New-Item -Path (Join-Path -Path $modulePath -ChildPath "Private") -ItemType Directory -Force | Out-Null

    # Create function files
    foreach ($function in $script:publicFunctions) {
        $functionPath = Join-Path -Path $modulePath -ChildPath "Public\$function.ps1"
        $functionContent = @"
function $function {
    <#
    .SYNOPSIS
    Brief description of $function

    .DESCRIPTION
    Detailed description of $function

    .PARAMETER Param1
    Description of Param1

    .EXAMPLE
    $function -Param1 Value
    Explanation of the example

    .NOTES
    Additional notes about the function
    #>
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=`$true)]
        [string]`$Param1
    )

    begin {
        # Initialize any prerequisites
    }

    process {
        # Main function logic
    }

    end {
        # Cleanup or final actions
    }
}
"@
        Set-Content -Path $functionPath -Value $functionContent
    }

    foreach ($function in $script:privateFunctions) {
        $functionPath = Join-Path -Path $modulePath -ChildPath "Private\$function.ps1"
        $functionContent = @"
function $function {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=`$true)]
        [string]`$Param1
    )

    # Function logic here
}
"@
        Set-Content -Path $functionPath -Value $functionContent
    }

    # Create tests folder and files
    $testsFolderPath = Join-Path -Path $modulePath -ChildPath "Tests"
    New-Item -Path $testsFolderPath -ItemType Directory -Force | Out-Null

    if ($script:usePester) {
        $testFilePath = Join-Path -Path $testsFolderPath -ChildPath "$($script:moduleName).Tests.ps1"
        $testFileContent = @"
`$ModuleName = '$($script:moduleName)'
`$ModuleManifestPath = "`$PSScriptRoot\..\`$ModuleName.psd1"

Describe "`$ModuleName Module Tests" {
    BeforeAll {
        `$Module = Import-Module `$ModuleManifestPath -PassThru -Force
    }

    It "Module manifest is valid" {
        Test-ModuleManifest -Path `$ModuleManifestPath | Should -Not -BeNullOrEmpty
        `$? | Should -Be `$true
    }

    It "Module can be imported" {
        `$Module | Should -Not -BeNullOrEmpty
    }

    Context "Function Tests" {
        # Add tests for each function
        $(foreach ($function in $script:publicFunctions) {
@"
        It "$function exists" {
            Get-Command $function -Module `$ModuleName | Should -Not -BeNullOrEmpty
        }

"@
        })
    }
}
"@
        Set-Content -Path $testFilePath -Value $testFileContent
    }

    # Create build configuration
    $buildFolderPath = Join-Path -Path $modulePath -ChildPath "Build"
    New-Item -Path $buildFolderPath -ItemType Directory -Force | Out-Null

    $buildFilePath = Join-Path -Path $buildFolderPath -ChildPath "build.ps1"
    $buildFileContent = @"
param (
    [switch]`$Test,
    [switch]`$Analyze,
    [switch]`$Documentation
)

`$ModuleName = '$($script:moduleName)'
`$ModuleRoot = "`$PSScriptRoot\.."
`$OutputPath = "`$ModuleRoot\Output"

# Clean and create output directory
if (Test-Path -Path `$OutputPath) {
    Remove-Item -Path `$OutputPath -Recurse -Force
}
New-Item -Path `$OutputPath -ItemType Directory -Force | Out-Null

# Copy module files to output directory
Copy-Item -Path "`$ModuleRoot\`$ModuleName.psd1" -Destination `$OutputPath
Copy-Item -Path "`$ModuleRoot\`$ModuleName.psm1" -Destination `$OutputPath
Copy-Item -Path "`$ModuleRoot\Public" -Destination `$OutputPath -Recurse
Copy-Item -Path "`$ModuleRoot\Private" -Destination `$OutputPath -Recurse

if (`$Test) {
    # Run Pester tests
    `$testResults = Invoke-Pester -Path "`$ModuleRoot\Tests" -PassThru
    if (`$testResults.FailedCount -gt 0) {
        throw "One or more tests failed."
    }
}

if (`$Analyze) {
    # Run PSScriptAnalyzer
    `$analysisResults = Invoke-ScriptAnalyzer -Path `$OutputPath -Recurse
    if (`$analysisResults) {
        `$analysisResults | Format-Table
        throw "PSScriptAnalyzer found one or more issues."
    }
}

if (`$Documentation) {
    # Generate documentation using platyPS
    Import-Module platyPS
    New-MarkdownHelp -Module `$ModuleName -OutputFolder "`$OutputPath\docs" -Force
}

Write-Host "Build completed successfully." -ForegroundColor Green
"@
    Set-Content -Path $buildFilePath -Value $buildFileContent

    # Create PSScriptAnalyzer settings file
    if ($script:usePSScriptAnalyzer) {
        $analyzerSettingsPath = Join-Path -Path $modulePath -ChildPath "PSScriptAnalyzerSettings.psd1"
        $analyzerSettingsContent = @"
@{
    Severity = @('Error', 'Warning')
    ExcludeRules = @('PSUseShouldProcessForStateChangingFunctions')
    Rules = @{
        PSAvoidUsingCmdletAliases = @{
            Whitelist = @('Where', 'Select')
        }
    }
}
"@
        Set-Content -Path $analyzerSettingsPath -Value $analyzerSettingsContent
    }

    Write-Host "Module files generated successfully at: $modulePath" -ForegroundColor Green
}

# Initialize variables
$script:moduleName = ""
$script:moduleDescription = ""
$script:moduleAuthor = ""
$script:moduleVersion = ""
$script:moduleLicense = ""
$script:moduleProjectUri = ""
$script:publicFunctions = @()
$script:privateFunctions = @()
$script:moduleDependencies = @()
$script:usePSScriptAnalyzer = $false
$script:useplatyPS = $false
$script:usePester = $false
$script:useCodeCoverage = $false

# Main program loop
do {
    Show-Menu
    $choice = Read-Host "`nEnter your choice (1-8)"

    switch ($choice) {
        "1" { Set-ModuleDetails }
        "2" { Add-PublicFunction }
        "3" { Add-PrivateFunction }
        "4" { Add-ModuleDependencies }
        "5" { Set-BuildSettings }
        "6" { Set-TestSettings }
        "7" { Generate-ModuleFiles }
        "8" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

    if ($choice -ne "8") {
        Read-Host "`nPress Enter to continue..."
    }
} while ($choice -ne "8")

This Advanced Template Module Generator Tool includes:

A menu-driven interface for easy navigation.
Enhanced functions to:
- Set detailed module information (including license and project URI)
- Add public and private functions
- Specify module dependencies
- Configure build and test settings

Key features:

Advanced Module Manifest Generation:
- Includes more detailed module information
- Supports specifying module dependencies
Comprehensive Module Structure:
- Creates a more robust folder structure including build and test directories
Enhanced Function File Generation:
- Generates more detailed function templates
Build Script Generation:
- Creates a build.ps1 script for module building, testing, and documentation generation
Test Configuration:
- Sets up Pester tests with placeholders for each public function
- Optionally includes code coverage settings
PSScriptAnalyzer Integration:
- Generates a PSScriptAnalyzer settings file
- Includes PSScriptAnalyzer in the build process
Documentation Support:
- Optionally sets up platyPS for documentation generation
Dependency Management:
- Allows specifying module dependencies with version requirements

This tool is particularly useful for:

Experienced PowerShell module developers
Teams working on larger PowerShell projects
Developers who want to follow best practices in module development

To use this script effectively:

Run the script in PowerShell
Use the menu options to:
- Set detailed module information
- Add public and private functions
- Specify dependencies and configure build/test settings
- Generate the module files
Review the generated module structure and customize as needed

This advanced script provides a more comprehensive starting point for PowerShell module development, incorporating best practices and tools commonly used in professional PowerShell module projects.

Template Module Generator Tool

11/08/2024/0 Comments/in Modules/by Laszlo Bocso

<#
.SYNOPSIS
Template Module Generator Tool

.DESCRIPTION
This script provides an interactive tool to generate a basic structure for a PowerShell module,
including the module manifest, public and private function files, and a basic test file.

.NOTES
File Name      : TemplateModuleGenerator.ps1
Author         : [Your Name]
Prerequisite   : PowerShell V5.1 or later
Version        : 1.0
Date           : [Current Date]

.EXAMPLE
.\TemplateModuleGenerator.ps1
#>

function Show-Menu {
    Clear-Host
    Write-Host "=== Template Module Generator Tool ===" -ForegroundColor Cyan
    Write-Host "1. Set Module Details"
    Write-Host "2. Add Public Function"
    Write-Host "3. Add Private Function"
    Write-Host "4. Generate Module Files"
    Write-Host "5. Exit"
}

function Set-ModuleDetails {
    $script:moduleName = Read-Host "Enter the name of the module"
    $script:moduleDescription = Read-Host "Enter a brief description of the module"
    $script:moduleAuthor = Read-Host "Enter the author's name"
    $script:moduleVersion = Read-Host "Enter the module version (e.g., 1.0.0)"
    Write-Host "Module details set successfully." -ForegroundColor Green
}

function Add-PublicFunction {
    $functionName = Read-Host "Enter the name of the public function"
    $script:publicFunctions += $functionName
    Write-Host "Public function '$functionName' added." -ForegroundColor Green
}

function Add-PrivateFunction {
    $functionName = Read-Host "Enter the name of the private function"
    $script:privateFunctions += $functionName
    Write-Host "Private function '$functionName' added." -ForegroundColor Green
}

function Generate-ModuleFiles {
    if ([string]::IsNullOrWhiteSpace($script:moduleName)) {
        Write-Host "Please set module details first." -ForegroundColor Yellow
        return
    }

    $modulePath = Join-Path -Path $PWD -ChildPath $script:moduleName
    New-Item -Path $modulePath -ItemType Directory -Force | Out-Null

    # Create module manifest
    $manifestPath = Join-Path -Path $modulePath -ChildPath "$($script:moduleName).psd1"
    New-ModuleManifest -Path $manifestPath `
        -RootModule "$($script:moduleName).psm1" `
        -ModuleVersion $script:moduleVersion `
        -Author $script:moduleAuthor `
        -Description $script:moduleDescription `
        -FunctionsToExport $script:publicFunctions

    # Create module script file
    $modulePSM1Path = Join-Path -Path $modulePath -ChildPath "$($script:moduleName).psm1"
    $modulePSM1Content = @"
# Dot source public/private functions
`$public = @(Get-ChildItem -Path `$PSScriptRoot\Public\*.ps1 -ErrorAction SilentlyContinue)
`$private = @(Get-ChildItem -Path `$PSScriptRoot\Private\*.ps1 -ErrorAction SilentlyContinue)

foreach (`$import in @(`$public + `$private)) {
    try {
        . `$import.FullName
    } catch {
        Write-Error -Message "Failed to import function `$(`$import.FullName): `$_"
    }
}

# Export public functions
Export-ModuleMember -Function `$public.BaseName
"@
    Set-Content -Path $modulePSM1Path -Value $modulePSM1Content

    # Create Public and Private folders
    New-Item -Path (Join-Path -Path $modulePath -ChildPath "Public") -ItemType Directory -Force | Out-Null
    New-Item -Path (Join-Path -Path $modulePath -ChildPath "Private") -ItemType Directory -Force | Out-Null

    # Create function files
    foreach ($function in $script:publicFunctions) {
        $functionPath = Join-Path -Path $modulePath -ChildPath "Public\$function.ps1"
        $functionContent = @"
function $function {
    <#
    .SYNOPSIS
    Brief description of $function

    .DESCRIPTION
    Detailed description of $function

    .PARAMETER Param1
    Description of Param1

    .EXAMPLE
    $function -Param1 Value
    Explanation of the example

    .NOTES
    Additional notes about the function
    #>
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=`$true)]
        [string]`$Param1
    )

    begin {
        # Initialize any prerequisites
    }

    process {
        # Main function logic
    }

    end {
        # Cleanup or final actions
    }
}
"@
        Set-Content -Path $functionPath -Value $functionContent
    }

    foreach ($function in $script:privateFunctions) {
        $functionPath = Join-Path -Path $modulePath -ChildPath "Private\$function.ps1"
        $functionContent = @"
function $function {
    [CmdletBinding()]
    param (
        [Parameter(Mandatory=`$true)]
        [string]`$Param1
    )

    # Function logic here
}
"@
        Set-Content -Path $functionPath -Value $functionContent
    }

    # Create a basic test file
    $testsFolderPath = Join-Path -Path $modulePath -ChildPath "Tests"
    New-Item -Path $testsFolderPath -ItemType Directory -Force | Out-Null
    $testFilePath = Join-Path -Path $testsFolderPath -ChildPath "$($script:moduleName).Tests.ps1"
    $testFileContent = @"
`$ModuleName = '$($script:moduleName)'
`$ModuleManifestPath = "`$PSScriptRoot\..\`$ModuleName.psd1"

Describe "`$ModuleName Module Tests" {
    It "Module manifest is valid" {
        Test-ModuleManifest -Path `$ModuleManifestPath | Should -Not -BeNullOrEmpty
        `$? | Should -Be `$true
    }

    It "Module can be imported" {
        Import-Module `$ModuleManifestPath
        Get-Module `$ModuleName | Should -Not -BeNullOrEmpty
    }

    # Add more tests for your functions here
}
"@
    Set-Content -Path $testFilePath -Value $testFileContent

    Write-Host "Module files generated successfully at: $modulePath" -ForegroundColor Green
}

# Initialize variables
$script:moduleName = ""
$script:moduleDescription = ""
$script:moduleAuthor = ""
$script:moduleVersion = ""
$script:publicFunctions = @()
$script:privateFunctions = @()

# Main program loop
do {
    Show-Menu
    $choice = Read-Host "`nEnter your choice (1-5)"

    switch ($choice) {
        "1" { Set-ModuleDetails }
        "2" { Add-PublicFunction }
        "3" { Add-PrivateFunction }
        "4" { Generate-ModuleFiles }
        "5" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

    if ($choice -ne "5") {
        Read-Host "`nPress Enter to continue..."
    }
} while ($choice -ne "5")

This Template Module Generator Tool includes:

A menu-driven interface for easy navigation.
Functions to:
- Set module details (name, description, author, version)
- Add public functions
- Add private functions
- Generate module files

Key features:

Module Manifest Generation:
- Creates a .psd1 file with basic module information
Module Script File (.psm1) Generation:
- Creates a .psm1 file that dot-sources public and private functions
Function File Generation:
- Creates separate .ps1 files for each public and private function
- Generates a basic function template with comment-based help for public functions
Directory Structure Creation:
- Creates a module folder with Public and Private subfolders
Basic Test File Generation:
- Creates a simple Pester test file for the module

This tool is particularly useful for:

PowerShell module developers starting new projects
Anyone learning to create PowerShell modules
Developers who want to quickly scaffold a new module structure

To use this script effectively:

Run the script in PowerShell
Use the menu options to:
- Set the module details
- Add public and private functions as needed
- Generate the module files
Review the generated module structure in the specified directory

This script provides a quick and easy way to create a basic PowerShell module structure, following best practices for module organization. It saves time in setting up the initial files and folders, allowing developers to focus on writing the actual module functionality.

CSV File Validator Tool

11/08/2024/0 Comments/in CSV/by Laszlo Bocso

<#
.SYNOPSIS
CSV File Validator Tool

.DESCRIPTION
This script provides a tool to validate CSV files, check for structural issues,
analyze data types, and provide detailed information about the CSV content.

.NOTES
File Name      : CSVValidator.ps1
Author         : [Your Name]
Prerequisite   : PowerShell V5.1 or later
Version        : 1.0
Date           : [Current Date]

.EXAMPLE
.\CSVValidator.ps1
#>

function Show-Menu {
    Clear-Host
    Write-Host "=== CSV File Validator Tool ===" -ForegroundColor Cyan
    Write-Host "1. Validate CSV File"
    Write-Host "2. Analyze CSV Structure"
    Write-Host "3. Check for Data Inconsistencies"
    Write-Host "4. Generate CSV Summary"
    Write-Host "5. Compare Two CSV Files"
    Write-Host "6. Exit"
}

function Validate-CSVFile {
    $filePath = Read-Host "Enter the path to the CSV file"
    if (-not (Test-Path $filePath)) {
        Write-Host "File not found." -ForegroundColor Red
        return
    }

    try {
        $csv = Import-Csv $filePath
        $rowCount = $csv.Count
        $columnCount = ($csv | Get-Member -MemberType NoteProperty).Count

        Write-Host "CSV is valid." -ForegroundColor Green
        Write-Host "Number of rows: $rowCount"
        Write-Host "Number of columns: $columnCount"

        $headers = ($csv | Get-Member -MemberType NoteProperty).Name
        Write-Host "Headers: $($headers -join ', ')"

        $size = (Get-Item $filePath).Length
        Write-Host "File Size: $size bytes"
    }
    catch {
        Write-Host "Invalid CSV. Error details:" -ForegroundColor Red
        Write-Host $_.Exception.Message
    }
}

function Analyze-CSVStructure {
    $filePath = Read-Host "Enter the path to the CSV file"
    if (-not (Test-Path $filePath)) {
        Write-Host "File not found." -ForegroundColor Red
        return
    }

    try {
        $csv = Import-Csv $filePath
        $headers = ($csv | Get-Member -MemberType NoteProperty).Name

        Write-Host "CSV Structure Analysis:" -ForegroundColor Yellow
        foreach ($header in $headers) {
            $values = $csv.$header | Where-Object { $_ -ne "" }
            $dataType = Guess-DataType $values
            $uniqueValues = ($values | Select-Object -Unique).Count
            $nullCount = ($csv.$header | Where-Object { $_ -eq "" }).Count

            Write-Host "`nColumn: $header"
            Write-Host "  Data Type: $dataType"
            Write-Host "  Unique Values: $uniqueValues"
            Write-Host "  Null/Empty Values: $nullCount"
            Write-Host "  Sample Values: $($values | Select-Object -First 5 -Unique)"
        }
    }
    catch {
        Write-Host "Error analyzing CSV structure: $_" -ForegroundColor Red
    }
}

function Guess-DataType($values) {
    $sampleSize = [Math]::Min($values.Count, 100)
    $sample = $values | Select-Object -First $sampleSize

    $isNumeric = $sample | ForEach-Object { $_ -as [double] } | Where-Object { $_ -ne $null }
    $isDate = $sample | ForEach-Object { $_ -as [datetime] } | Where-Object { $_ -ne $null }

    if ($isNumeric.Count -eq $sampleSize) { return "Numeric" }
    elseif ($isDate.Count -eq $sampleSize) { return "Date" }
    else { return "String" }
}

function Check-DataInconsistencies {
    $filePath = Read-Host "Enter the path to the CSV file"
    if (-not (Test-Path $filePath)) {
        Write-Host "File not found." -ForegroundColor Red
        return
    }

    try {
        $csv = Import-Csv $filePath
        $headers = ($csv | Get-Member -MemberType NoteProperty).Name

        Write-Host "Checking for Data Inconsistencies:" -ForegroundColor Yellow
        foreach ($header in $headers) {
            $values = $csv.$header
            $dataType = Guess-DataType $values

            $inconsistencies = @()
            switch ($dataType) {
                "Numeric" {
                    $inconsistencies = $values | Where-Object { $_ -ne "" -and ($_ -as [double]) -eq $null }
                }
                "Date" {
                    $inconsistencies = $values | Where-Object { $_ -ne "" -and ($_ -as [datetime]) -eq $null }
                }
            }

            if ($inconsistencies.Count -gt 0) {
                Write-Host "`nInconsistencies found in column '$header' (Expected $dataType):"
                Write-Host ($inconsistencies | Select-Object -First 5) -ForegroundColor Red
                if ($inconsistencies.Count -gt 5) {
                    Write-Host "... and $($inconsistencies.Count - 5) more."
                }
            }
        }
    }
    catch {
        Write-Host "Error checking data inconsistencies: $_" -ForegroundColor Red
    }
}

function Generate-CSVSummary {
    $filePath = Read-Host "Enter the path to the CSV file"
    if (-not (Test-Path $filePath)) {
        Write-Host "File not found." -ForegroundColor Red
        return
    }

    try {
        $csv = Import-Csv $filePath
        $rowCount = $csv.Count
        $headers = ($csv | Get-Member -MemberType NoteProperty).Name

        Write-Host "CSV Summary:" -ForegroundColor Yellow
        Write-Host "File: $filePath"
        Write-Host "Total Rows: $rowCount"
        Write-Host "Total Columns: $($headers.Count)"
        Write-Host "`nColumn Summary:"

        foreach ($header in $headers) {
            $values = $csv.$header
            $nonEmptyValues = $values | Where-Object { $_ -ne "" }
            $uniqueValues = ($nonEmptyValues | Select-Object -Unique).Count
            $nullCount = ($values | Where-Object { $_ -eq "" }).Count
            $dataType = Guess-DataType $nonEmptyValues

            Write-Host "`n$header:"
            Write-Host "  Data Type: $dataType"
            Write-Host "  Unique Values: $uniqueValues"
            Write-Host "  Null/Empty Count: $nullCount"
            Write-Host "  Fill Rate: $([math]::Round(($rowCount - $nullCount) / $rowCount * 100, 2))%"

            if ($dataType -eq "Numeric") {
                $numericValues = $nonEmptyValues | ForEach-Object { $_ -as [double] }
                $min = ($numericValues | Measure-Object -Minimum).Minimum
                $max = ($numericValues | Measure-Object -Maximum).Maximum
                $avg = ($numericValues | Measure-Object -Average).Average
                Write-Host "  Min: $min"
                Write-Host "  Max: $max"
                Write-Host "  Average: $([math]::Round($avg, 2))"
            }
        }
    }
    catch {
        Write-Host "Error generating CSV summary: $_" -ForegroundColor Red
    }
}

function Compare-CSVFiles {
    $filePath1 = Read-Host "Enter the path to the first CSV file"
    $filePath2 = Read-Host "Enter the path to the second CSV file"

    if (-not (Test-Path $filePath1) -or -not (Test-Path $filePath2)) {
        Write-Host "One or both files not found." -ForegroundColor Red
        return
    }

    try {
        $csv1 = Import-Csv $filePath1
        $csv2 = Import-Csv $filePath2

        $headers1 = ($csv1 | Get-Member -MemberType NoteProperty).Name
        $headers2 = ($csv2 | Get-Member -MemberType NoteProperty).Name

        Write-Host "Comparing CSV Files:" -ForegroundColor Yellow
        Write-Host "File 1: $filePath1"
        Write-Host "File 2: $filePath2"

        Write-Host "`nColumn Comparison:"
        $commonHeaders = $headers1 | Where-Object { $headers2 -contains $_ }
        $uniqueHeaders1 = $headers1 | Where-Object { $headers2 -notcontains $_ }
        $uniqueHeaders2 = $headers2 | Where-Object { $headers1 -notcontains $_ }

        Write-Host "Common Columns: $($commonHeaders -join ', ')"
        Write-Host "Columns only in File 1: $($uniqueHeaders1 -join ', ')"
        Write-Host "Columns only in File 2: $($uniqueHeaders2 -join ', ')"

        Write-Host "`nRow Count Comparison:"
        Write-Host "File 1 Row Count: $($csv1.Count)"
        Write-Host "File 2 Row Count: $($csv2.Count)"

        Write-Host "`nData Comparison for Common Columns:"
        foreach ($header in $commonHeaders) {
            $diff = Compare-Object $csv1.$header $csv2.$header
            if ($diff) {
                Write-Host "Differences found in column '$header':"
                Write-Host "  Values only in File 1: $($diff | Where-Object { $_.SideIndicator -eq '<=' } | Select-Object -ExpandProperty InputObject)"
                Write-Host "  Values only in File 2: $($diff | Where-Object { $_.SideIndicator -eq '=>' } | Select-Object -ExpandProperty InputObject)"
            }
            else {
                Write-Host "No differences found in column '$header'"
            }
        }
    }
    catch {
        Write-Host "Error comparing CSV files: $_" -ForegroundColor Red
    }
}

# Main program loop
do {
    Show-Menu
    $choice = Read-Host "`nEnter your choice (1-6)"

    switch ($choice) {
        "1" { Validate-CSVFile }
        "2" { Analyze-CSVStructure }
        "3" { Check-DataInconsistencies }
        "4" { Generate-CSVSummary }
        "5" { Compare-CSVFiles }
        "6" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

    if ($choice -ne "6") {
        Read-Host "`nPress Enter to continue..."
    }
} while ($choice -ne "6")

This CSV File Validator Tool includes:

A menu-driven interface for easy navigation.
Functions to perform various CSV-related tasks:
- Validate CSV files and provide basic statistics
- Analyze and display the structure of CSV files
- Check for data inconsistencies
- Generate a comprehensive summary of the CSV content
- Compare two CSV files

Key features:

CSV Validation:
- Checks if the CSV is valid and can be parsed
- Provides row count, column count, headers, and file size
CSV Structure Analysis:
- Analyzes each column for data type, unique values, and null/empty values
- Provides sample values for each column
Data Inconsistency Check:
- Identifies values that don’t match the expected data type for each column
CSV Summary Generation:
- Provides a comprehensive summary of the CSV, including data types, unique values, fill rates, and basic statistics for numeric columns
CSV Comparison:
- Compares two CSV files for structural differences and data discrepancies

This tool is particularly useful for:

Data analysts validating CSV datasets
QA engineers checking CSV file integrity
Developers working with CSV data imports/exports
Anyone needing to quickly analyze or compare CSV files

To use this script effectively:

Run the script in PowerShell
Use the menu options to select the desired function
Provide the path to the CSV file(s) when prompted
Review the output for validation results, structure analysis, inconsistencies, summaries, or file comparisons

This script provides a comprehensive set of tools for working with CSV files, making it easier to validate, understand, and compare CSV data without having to manually inspect the files or use multiple tools.

CSV Generator Tool

11/08/2024/0 Comments/in CSV, Program/by Laszlo Bocso

<#
.SYNOPSIS
CSV Generator Tool

.DESCRIPTION
This script provides an interactive tool to create CSV structures, add columns and rows,
and export the resulting CSV to a file.

.NOTES
File Name      : CSVGenerator.ps1
Author         : [Your Name]
Prerequisite   : PowerShell V5.1 or later
Version        : 1.0
Date           : [Current Date]

.EXAMPLE
.\CSVGenerator.ps1
#>

# Global variables
$script:csvData = @()
$script:columns = @()
$script:csvFilePath = "$env:USERPROFILE\Desktop\Generated_CSV_$(Get-Date -Format 'yyyyMMdd_HHmmss').csv"

function Show-Menu {
    Clear-Host
    Write-Host "=== CSV Generator Tool ===" -ForegroundColor Cyan
    Write-Host "1. Define Columns"
    Write-Host "2. Add Row"
    Write-Host "3. View Current CSV Structure"
    Write-Host "4. Import Data from JSON"
    Write-Host "5. Generate Sample Data"
    Write-Host "6. Export CSV to File"
    Write-Host "7. Exit"
}

function Define-Columns {
    $script:columns = @()
    do {
        $columnName = Read-Host "Enter column name (or press Enter to finish)"
        if ($columnName -ne "") {
            $script:columns += $columnName
        }
    } while ($columnName -ne "")

    Write-Host "Columns defined: $($script:columns -join ', ')" -ForegroundColor Green
}

function Add-Row {
    if ($script:columns.Count -eq 0) {
        Write-Host "Please define columns first." -ForegroundColor Yellow
        return
    }

    $row = @{}
    foreach ($column in $script:columns) {
        $value = Read-Host "Enter value for '$column'"
        $row[$column] = $value
    }

    $script:csvData += [PSCustomObject]$row
    Write-Host "Row added successfully." -ForegroundColor Green
}

function View-CurrentCSV {
    if ($script:csvData.Count -eq 0) {
        Write-Host "No data available. Please add some rows first." -ForegroundColor Yellow
        return
    }

    $script:csvData | Format-Table -AutoSize
}

function Import-FromJSON {
    $jsonPath = Read-Host "Enter the path to the JSON file"
    if (-not (Test-Path $jsonPath)) {
        Write-Host "File not found." -ForegroundColor Red
        return
    }

    try {
        $jsonData = Get-Content $jsonPath -Raw | ConvertFrom-Json
        
        if ($jsonData -is [Array]) {
            $script:columns = $jsonData[0].PSObject.Properties.Name
            $script:csvData = $jsonData
        }
        else {
            $script:columns = $jsonData.PSObject.Properties.Name
            $script:csvData = @($jsonData)
        }

        Write-Host "Data imported successfully from JSON." -ForegroundColor Green
        Write-Host "Columns: $($script:columns -join ', ')" -ForegroundColor Green
        Write-Host "Number of rows: $($script:csvData.Count)" -ForegroundColor Green
    }
    catch {
        Write-Host "Error importing JSON: $_" -ForegroundColor Red
    }
}

function Generate-SampleData {
    if ($script:columns.Count -eq 0) {
        Write-Host "Please define columns first." -ForegroundColor Yellow
        return
    }

    $rowCount = Read-Host "Enter the number of sample rows to generate"
    if (-not [int]::TryParse($rowCount, [ref]$null)) {
        Write-Host "Invalid number. Please enter a valid integer." -ForegroundColor Red
        return
    }

    $script:csvData = @()

    for ($i = 1; $i -le [int]$rowCount; $i++) {
        $row = @{}
        foreach ($column in $script:columns) {
            $row[$column] = Get-SampleValue $column $i
        }
        $script:csvData += [PSCustomObject]$row
    }

    Write-Host "$rowCount sample rows generated successfully." -ForegroundColor Green
}

function Get-SampleValue($columnName, $rowNumber) {
    switch -Regex ($columnName.ToLower()) {
        "id|number" { return $rowNumber }
        "name" { return "Name$rowNumber" }
        "date" { return (Get-Date).AddDays($rowNumber).ToString("yyyy-MM-dd") }
        "email" { return "user$rowNumber@example.com" }
        "phone" { return "555-0$rowNumber" }
        "address" { return "$rowNumber Main St" }
        "city" { return "City$rowNumber" }
        "country" { return "Country$rowNumber" }
        "amount|price" { return [math]::Round((Get-Random -Minimum 10 -Maximum 1000), 2) }
        default { return "Value$rowNumber" }
    }
}

function Export-CSVToFile {
    if ($script:csvData.Count -eq 0) {
        Write-Host "No data to export. Please add some rows first." -ForegroundColor Yellow
        return
    }

    try {
        $script:csvData | Export-Csv -Path $script:csvFilePath -NoTypeInformation
        Write-Host "CSV exported successfully to: $script:csvFilePath" -ForegroundColor Green
    }
    catch {
        Write-Host "Error exporting CSV: $_" -ForegroundColor Red
    }
}

# Main program loop
do {
    Show-Menu
    $choice = Read-Host "`nEnter your choice (1-7)"

    switch ($choice) {
        "1" { Define-Columns }
        "2" { Add-Row }
        "3" { View-CurrentCSV }
        "4" { Import-FromJSON }
        "5" { Generate-SampleData }
        "6" { Export-CSVToFile }
        "7" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

    if ($choice -ne "7") {
        Read-Host "`nPress Enter to continue..."
    }
} while ($choice -ne "7")

This CSV Generator Tool includes:

A menu-driven interface for easy navigation.
Functions to interactively build CSV structures:
- Define columns
- Add rows manually
- View the current CSV structure
- Import data from JSON
- Generate sample data
- Export the CSV to a file

Key features:

Column Definition:
- Allows users to define custom column names
Manual Data Entry:
- Supports adding rows manually with guided input for each column
Data Visualization:
- Provides a view of the current CSV structure in a tabular format
JSON Import:
- Allows importing data from a JSON file to quickly populate the CSV
Sample Data Generation:
- Automatically generates sample data based on column names
- Supports common data types like IDs, names, dates, emails, etc.
CSV Export:
- Exports the generated data to a CSV file

This tool is particularly useful for:

Developers needing to create test data in CSV format
Data analysts creating sample datasets
QA engineers generating CSV files for testing
Anyone needing to quickly create structured CSV data

To use this script effectively:

Run the script in PowerShell
Use the menu options to build your CSV structure:
- Start by defining columns
- Add rows manually, import from JSON, or generate sample data
- View the current structure at any time
When finished, export the CSV to a file

This script provides a user-friendly way to create CSV structures without having to manually write CSV syntax or use spreadsheet software. It’s especially helpful for creating test data or sample datasets quickly and easily.

XML File Validator Tool

11/08/2024/0 Comments/in XML/by Laszlo Bocso

<#
.SYNOPSIS
XML File Validator Tool

.DESCRIPTION
This script provides a tool to validate XML files, check for syntax errors,
analyze the structure, and perform various XML-related tasks.

.NOTES
File Name      : XMLValidator.ps1
Author         : [Your Name]
Prerequisite   : PowerShell V5.1 or later
Version        : 1.0
Date           : [Current Date]

.EXAMPLE
.\XMLValidator.ps1
#>

Add-Type -AssemblyName System.Xml.Linq

function Show-Menu {
    Clear-Host
    Write-Host "=== XML File Validator Tool ===" -ForegroundColor Cyan
    Write-Host "1. Validate XML File"
    Write-Host "2. Analyze XML Structure"
    Write-Host "3. Search XML"
    Write-Host "4. Compare Two XML Files"
    Write-Host "5. Validate Against XSD Schema"
    Write-Host "6. Exit"
}

function Validate-XMLFile {
    $filePath = Read-Host "Enter the path to the XML file"
    if (-not (Test-Path $filePath)) {
        Write-Host "File not found." -ForegroundColor Red
        return
    }

    try {
        [xml]$xml = Get-Content $filePath
        Write-Host "XML is valid." -ForegroundColor Green

        $size = (Get-Item $filePath).Length
        $elementCount = $xml.SelectNodes("//*").Count
        $attributeCount = $xml.SelectNodes("//@*").Count

        Write-Host "File Size: $size bytes"
        Write-Host "Number of Elements: $elementCount"
        Write-Host "Number of Attributes: $attributeCount"
    }
    catch [System.Xml.XmlException] {
        Write-Host "Invalid XML. Error details:" -ForegroundColor Red
        Write-Host $_.Exception.Message
    }
}

function Analyze-XMLStructure {
    $filePath = Read-Host "Enter the path to the XML file"
    if (-not (Test-Path $filePath)) {
        Write-Host "File not found." -ForegroundColor Red
        return
    }

    try {
        [xml]$xml = Get-Content $filePath
        $structure = Get-XMLStructure $xml.DocumentElement
        Write-Host "XML Structure:" -ForegroundColor Yellow
        $structure | ForEach-Object { Write-Host $_ }
    }
    catch {
        Write-Host "Error analyzing XML structure: $_" -ForegroundColor Red
    }
}

function Get-XMLStructure($element, $indent = "") {
    $output = @()
    $output += "$indent$($element.Name)"
    
    if ($element.Attributes.Count -gt 0) {
        $attributes = $element.Attributes | ForEach-Object { "$($_.Name)='$($_.Value)'" }
        $output += "$indent  Attributes: $($attributes -join ', ')"
    }
    
    foreach ($child in $element.ChildNodes) {
        if ($child.NodeType -eq [System.Xml.XmlNodeType]::Element) {
            $output += Get-XMLStructure $child "$indent  "
        }
        elseif ($child.NodeType -eq [System.Xml.XmlNodeType]::Text) {
            $output += "$indent  Text: $($child.Value.Trim())"
        }
    }
    
    return $output
}

function Search-XML {
    $filePath = Read-Host "Enter the path to the XML file"
    if (-not (Test-Path $filePath)) {
        Write-Host "File not found." -ForegroundColor Red
        return
    }

    $searchTerm = Read-Host "Enter the search term (element or attribute name)"

    try {
        [xml]$xml = Get-Content $filePath
        $results = $xml.SelectNodes("//*[local-name()='$searchTerm'] | //@*[local-name()='$searchTerm']")
        
        if ($results.Count -eq 0) {
            Write-Host "No results found for: $searchTerm" -ForegroundColor Yellow
        }
        else {
            Write-Host "Search Results:" -ForegroundColor Green
            foreach ($result in $results) {
                Write-Host "XPath: $($result.XPath)"
                if ($result.NodeType -eq [System.Xml.XmlNodeType]::Element) {
                    Write-Host "Element Value: $($result.InnerXml)"
                }
                elseif ($result.NodeType -eq [System.Xml.XmlNodeType]::Attribute) {
                    Write-Host "Attribute Value: $($result.Value)"
                }
                Write-Host "---"
            }
        }
    }
    catch {
        Write-Host "Error searching XML: $_" -ForegroundColor Red
    }
}

function Compare-XMLFiles {
    $filePath1 = Read-Host "Enter the path to the first XML file"
    $filePath2 = Read-Host "Enter the path to the second XML file"

    if (-not (Test-Path $filePath1) -or -not (Test-Path $filePath2)) {
        Write-Host "One or both files not found." -ForegroundColor Red
        return
    }

    try {
        $xml1 = [System.Xml.Linq.XDocument]::Load($filePath1)
        $xml2 = [System.Xml.Linq.XDocument]::Load($filePath2)

        $differences = Compare-XmlDocs $xml1 $xml2

        if ($differences.Count -eq 0) {
            Write-Host "The XML files are identical." -ForegroundColor Green
        }
        else {
            Write-Host "Differences found:" -ForegroundColor Yellow
            foreach ($diff in $differences) {
                Write-Host "XPath: $($diff.XPath)"
                Write-Host "File 1 Value: $($diff.Value1)"
                Write-Host "File 2 Value: $($diff.Value2)"
                Write-Host "---"
            }
        }
    }
    catch {
        Write-Host "Error comparing XML files: $_" -ForegroundColor Red
    }
}

function Compare-XmlDocs($doc1, $doc2) {
    $differences = @()
    $elements1 = $doc1.Descendants()
    $elements2 = $doc2.Descendants()

    foreach ($element in $elements1) {
        $xpath = $element.XPathSelectElement($element.GetAbsoluteXPath())
        $otherElement = $doc2.XPathSelectElement($xpath.GetAbsoluteXPath())

        if ($null -eq $otherElement) {
            $differences += @{XPath = $xpath.GetAbsoluteXPath(); Value1 = $element.Value; Value2 = "Element not found"}
        }
        elseif ($element.Value -ne $otherElement.Value) {
            $differences += @{XPath = $xpath.GetAbsoluteXPath(); Value1 = $element.Value; Value2 = $otherElement.Value}
        }

        foreach ($attr in $element.Attributes()) {
            $otherAttr = $otherElement?.Attribute($attr.Name)
            if ($null -eq $otherAttr) {
                $differences += @{XPath = "$($xpath.GetAbsoluteXPath())/@$($attr.Name)"; Value1 = $attr.Value; Value2 = "Attribute not found"}
            }
            elseif ($attr.Value -ne $otherAttr.Value) {
                $differences += @{XPath = "$($xpath.GetAbsoluteXPath())/@$($attr.Name)"; Value1 = $attr.Value; Value2 = $otherAttr.Value}
            }
        }
    }

    foreach ($element in $elements2) {
        $xpath = $element.XPathSelectElement($element.GetAbsoluteXPath())
        $otherElement = $doc1.XPathSelectElement($xpath.GetAbsoluteXPath())

        if ($null -eq $otherElement) {
            $differences += @{XPath = $xpath.GetAbsoluteXPath(); Value1 = "Element not found"; Value2 = $element.Value}
        }

        foreach ($attr in $element.Attributes()) {
            $otherAttr = $otherElement?.Attribute($attr.Name)
            if ($null -eq $otherAttr) {
                $differences += @{XPath = "$($xpath.GetAbsoluteXPath())/@$($attr.Name)"; Value1 = "Attribute not found"; Value2 = $attr.Value}
            }
        }
    }

    return $differences
}

function Validate-XMLAgainstXSD {
    $xmlPath = Read-Host "Enter the path to the XML file"
    $xsdPath = Read-Host "Enter the path to the XSD schema file"

    if (-not (Test-Path $xmlPath) -or -not (Test-Path $xsdPath)) {
        Write-Host "One or both files not found." -ForegroundColor Red
        return
    }

    try {
        $xmlReader = [System.Xml.XmlReader]::Create($xmlPath)
        $schemaReader = [System.Xml.XmlReader]::Create($xsdPath)
        $schema = [System.Xml.Schema.XmlSchema]::Read($schemaReader, $null)

        $settings = New-Object System.Xml.XmlReaderSettings
        $settings.ValidationType = [System.Xml.ValidationType]::Schema
        $settings.Schemas.Add($schema) | Out-Null

        $settings.ValidationEventHandler = {
            param($sender, $e)
            Write-Host "Validation Error: $($e.Message)" -ForegroundColor Red
        }

        $validatingReader = [System.Xml.XmlReader]::Create($xmlPath, $settings)
        while ($validatingReader.Read()) { }

        Write-Host "XML is valid according to the XSD schema." -ForegroundColor Green
    }
    catch {
        Write-Host "Error validating XML against XSD: $_" -ForegroundColor Red
    }
    finally {
        if ($null -ne $xmlReader) { $xmlReader.Close() }
        if ($null -ne $schemaReader) { $schemaReader.Close() }
        if ($null -ne $validatingReader) { $validatingReader.Close() }
    }
}

# Extension method to get absolute XPath
Add-Type @"
using System.Xml.Linq;
using System.Linq;

public static class XElementExtensions
{
    public static string GetAbsoluteXPath(this XElement element)
    {
        if (element == null)
            return string.Empty;

        var ancestors = element.AncestorsAndSelf().Reverse().ToList();
        return "/" + string.Join("/", ancestors.Select(e => e.Name.LocalName));
    }
}
"@

# Main program loop
do {
    Show-Menu
    $choice = Read-Host "`nEnter your choice (1-6)"

    switch ($choice) {
        "1" { Validate-XMLFile }
        "2" { Analyze-XMLStructure }
        "3" { Search-XML }
        "4" { Compare-XMLFiles }
        "5" { Validate-XMLAgainstXSD }
        "6" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

    if ($choice -ne "6") {
        Read-Host "`nPress Enter to continue..."
    }
} while ($choice -ne "6")

This XML File Validator Tool includes:

A menu-driven interface for easy navigation.
Functions to perform various XML-related tasks:
- Validate XML files and provide basic statistics
- Analyze and display the structure of XML files
- Search for specific elements or attributes within XML files
- Compare two XML files and highlight differences
- Validate XML against an XSD schema

Key features:

XML Validation:
- Checks if the XML is syntactically valid
- Provides file size, number of elements, and number of attributes
XML Structure Analysis:
- Displays a hierarchical view of the XML structure
- Shows element names, attributes, and text content
XML Search:
- Allows searching for specific elements or attributes within the XML
- Displays the XPath and value of found elements/attributes
XML Comparison:
- Compares two XML files
- Highlights differences, including added, removed, or modified elements and attributes
XSD Schema Validation:
- Validates an XML file against an XSD schema
- Reports any validation errors

This tool is particularly useful for:

Developers working with XML data
QA engineers validating XML outputs
Data analysts examining XML structures
Anyone needing to quickly validate, analyze, or compare XML files

To use this script effectively:

Run the script in PowerShell
Use the menu options to select the desired function
Provide the path to the XML file(s) when prompted
Review the output for validation results, structure analysis, search results, file comparisons, or schema validation

This script provides a comprehensive set of tools for working with XML files, making it easier to validate, understand, and compare XML data without having to manually parse the files or use multiple tools.

JSON File Validator Tool

11/08/2024/0 Comments/in JSON, Program/by Laszlo Bocso

<#
.SYNOPSIS
JSON File Validator Tool

.DESCRIPTION
This script provides a tool to validate JSON files, check for syntax errors,
and provide detailed information about the JSON structure.

.NOTES
File Name      : JSONValidator.ps1
Author         : [Your Name]
Prerequisite   : PowerShell V5.1 or later
Version        : 1.0
Date           : [Current Date]

.EXAMPLE
.\JSONValidator.ps1
#>

function Show-Menu {
    Clear-Host
    Write-Host "=== JSON File Validator Tool ===" -ForegroundColor Cyan
    Write-Host "1. Validate JSON File"
    Write-Host "2. Analyze JSON Structure"
    Write-Host "3. Search JSON"
    Write-Host "4. Compare Two JSON Files"
    Write-Host "5. Exit"
}

function Validate-JSONFile {
    $filePath = Read-Host "Enter the path to the JSON file"
    if (-not (Test-Path $filePath)) {
        Write-Host "File not found." -ForegroundColor Red
        return
    }

    try {
        $content = Get-Content $filePath -Raw
        $json = ConvertFrom-Json $content -ErrorAction Stop
        Write-Host "JSON is valid." -ForegroundColor Green

        $size = (Get-Item $filePath).Length
        $objectCount = ($content | Select-String -Pattern "{" -AllMatches).Matches.Count
        $arrayCount = ($content | Select-String -Pattern "\[" -AllMatches).Matches.Count

        Write-Host "File Size: $size bytes"
        Write-Host "Number of Objects: $objectCount"
        Write-Host "Number of Arrays: $arrayCount"
    }
    catch {
        Write-Host "Invalid JSON. Error details:" -ForegroundColor Red
        Write-Host $_.Exception.Message
    }
}

function Analyze-JSONStructure {
    $filePath = Read-Host "Enter the path to the JSON file"
    if (-not (Test-Path $filePath)) {
        Write-Host "File not found." -ForegroundColor Red
        return
    }

    try {
        $json = Get-Content $filePath -Raw | ConvertFrom-Json
        $structure = Get-JSONStructure $json
        Write-Host "JSON Structure:" -ForegroundColor Yellow
        $structure | ForEach-Object { Write-Host $_ }
    }
    catch {
        Write-Host "Error analyzing JSON structure: $_" -ForegroundColor Red
    }
}

function Get-JSONStructure($obj, $path = "", $depth = 0) {
    $output = @()
    $indent = "  " * $depth

    if ($obj -is [System.Management.Automation.PSCustomObject]) {
        $output += "$indent$path {}"
        $obj.PSObject.Properties | ForEach-Object {
            $newPath = if ($path) { "$path.$($_.Name)" } else { $_.Name }
            $output += Get-JSONStructure $_.Value $newPath ($depth + 1)
        }
    }
    elseif ($obj -is [Array]) {
        $output += "$indent$path []"
        if ($obj.Count -gt 0) {
            $output += Get-JSONStructure $obj[0] "$path[0]" ($depth + 1)
        }
    }
    else {
        $type = if ($null -eq $obj) { "null" } else { $obj.GetType().Name }
        $output += "$indent$path : $type"
    }

    return $output
}

function Search-JSON {
    $filePath = Read-Host "Enter the path to the JSON file"
    if (-not (Test-Path $filePath)) {
        Write-Host "File not found." -ForegroundColor Red
        return
    }

    $searchKey = Read-Host "Enter the key to search for"

    try {
        $json = Get-Content $filePath -Raw | ConvertFrom-Json
        $results = Search-JSONRecursive $json $searchKey
        
        if ($results.Count -eq 0) {
            Write-Host "No results found for key: $searchKey" -ForegroundColor Yellow
        }
        else {
            Write-Host "Search Results:" -ForegroundColor Green
            $results | ForEach-Object {
                Write-Host "Path: $($_.Path)"
                Write-Host "Value: $($_.Value)"
                Write-Host "---"
            }
        }
    }
    catch {
        Write-Host "Error searching JSON: $_" -ForegroundColor Red
    }
}

function Search-JSONRecursive($obj, $searchKey, $currentPath = "") {
    $results = @()

    if ($obj -is [System.Management.Automation.PSCustomObject]) {
        $obj.PSObject.Properties | ForEach-Object {
            $newPath = if ($currentPath) { "$currentPath.$($_.Name)" } else { $_.Name }
            if ($_.Name -eq $searchKey) {
                $results += @{Path = $newPath; Value = $_.Value}
            }
            $results += Search-JSONRecursive $_.Value $searchKey $newPath
        }
    }
    elseif ($obj -is [Array]) {
        for ($i = 0; $i -lt $obj.Count; $i++) {
            $newPath = "${currentPath}[$i]"
            $results += Search-JSONRecursive $obj[$i] $searchKey $newPath
        }
    }

    return $results
}

function Compare-JSONFiles {
    $filePath1 = Read-Host "Enter the path to the first JSON file"
    $filePath2 = Read-Host "Enter the path to the second JSON file"

    if (-not (Test-Path $filePath1) -or -not (Test-Path $filePath2)) {
        Write-Host "One or both files not found." -ForegroundColor Red
        return
    }

    try {
        $json1 = Get-Content $filePath1 -Raw | ConvertFrom-Json
        $json2 = Get-Content $filePath2 -Raw | ConvertFrom-Json

        $differences = Compare-ObjectRecursive $json1 $json2

        if ($differences.Count -eq 0) {
            Write-Host "The JSON files are identical." -ForegroundColor Green
        }
        else {
            Write-Host "Differences found:" -ForegroundColor Yellow
            $differences | ForEach-Object {
                Write-Host "Path: $($_.Path)"
                Write-Host "File 1 Value: $($_.Value1)"
                Write-Host "File 2 Value: $($_.Value2)"
                Write-Host "---"
            }
        }
    }
    catch {
        Write-Host "Error comparing JSON files: $_" -ForegroundColor Red
    }
}

function Compare-ObjectRecursive($obj1, $obj2, $path = "") {
    $differences = @()

    if ($obj1 -is [System.Management.Automation.PSCustomObject] -and $obj2 -is [System.Management.Automation.PSCustomObject]) {
        $allProperties = $obj1.PSObject.Properties.Name + $obj2.PSObject.Properties.Name | Select-Object -Unique
        foreach ($prop in $allProperties) {
            $newPath = if ($path) { "$path.$prop" } else { $prop }
            if ($obj1.PSObject.Properties.Name -notcontains $prop) {
                $differences += @{Path = $newPath; Value1 = ""; Value2 = $obj2.$prop}
            }
            elseif ($obj2.PSObject.Properties.Name -notcontains $prop) {
                $differences += @{Path = $newPath; Value1 = $obj1.$prop; Value2 = ""}
            }
            else {
                $differences += Compare-ObjectRecursive $obj1.$prop $obj2.$prop $newPath
            }
        }
    }
    elseif ($obj1 -is [Array] -and $obj2 -is [Array]) {
        $maxLength = [Math]::Max($obj1.Length, $obj2.Length)
        for ($i = 0; $i -lt $maxLength; $i++) {
            $newPath = "${path}[$i]"
            if ($i -ge $obj1.Length) {
                $differences += @{Path = $newPath; Value1 = ""; Value2 = $obj2[$i]}
            }
            elseif ($i -ge $obj2.Length) {
                $differences += @{Path = $newPath; Value1 = $obj1[$i]; Value2 = ""}
            }
            else {
                $differences += Compare-ObjectRecursive $obj1[$i] $obj2[$i] $newPath
            }
        }
    }
    elseif ($obj1 -ne $obj2) {
        $differences += @{Path = $path; Value1 = $obj1; Value2 = $obj2}
    }

    return $differences
}

# Main program loop
do {
    Show-Menu
    $choice = Read-Host "`nEnter your choice (1-5)"

    switch ($choice) {
        "1" { Validate-JSONFile }
        "2" { Analyze-JSONStructure }
        "3" { Search-JSON }
        "4" { Compare-JSONFiles }
        "5" { Write-Host "Exiting program..." -ForegroundColor Yellow; break }
        default { Write-Host "Invalid choice. Please try again." -ForegroundColor Red }
    }

    if ($choice -ne "5") {
        Read-Host "`nPress Enter to continue..."
    }
} while ($choice -ne "5")

This JSON File Validator Tool includes:

A menu-driven interface for easy navigation.
Functions to perform various JSON-related tasks:
- Validate JSON files and provide basic statistics
- Analyze and display the structure of JSON files
- Search for specific keys within JSON files
- Compare two JSON files and highlight differences

Key features:

JSON Validation:
- Checks if the JSON is syntactically valid
- Provides file size, number of objects, and number of arrays
JSON Structure Analysis:
- Displays a hierarchical view of the JSON structure
- Shows types of values (object, array, string, number, etc.)
JSON Search:
- Allows searching for specific keys within the JSON
- Displays the path and value of found keys
JSON Comparison:
- Compares two JSON files
- Highlights differences, including added, removed, or modified values

This tool is particularly useful for:

Developers working with JSON data
QA engineers validating JSON outputs
Data analysts examining JSON structures
Anyone needing to quickly validate, analyze, or compare JSON files

To use this script effectively:

Run the script in PowerShell
Use the menu options to select the desired function
Provide the path to the JSON file(s) when prompted
Review the output for validation results, structure analysis, search results, or file comparisons

This script provides a comprehensive set of tools for working with JSON files, making it easier to validate, understand, and compare JSON data without having to manually parse the files or use multiple tools.

Latest News

Advanced Template Module Generator Tool

Template Module Generator Tool

CSV File Validator Tool

CSV Generator Tool

XML File Validator Tool

JSON File Validator Tool

Windows PowerShell

Links

Contact

Sitemap