function New-SystemUser {
    [CmdletBinding(SupportsShouldProcess)]
    param(
        [Parameter(Mandatory, ValueFromPipelineByPropertyName)]
        [ValidateLength(3, 20)]
        [ValidatePattern('^[a-zA-Z0-9_-]+$', ErrorMessage = "Username can only contain letters, numbers, underscores, and hyphens")]
        [string]$Username,
 
        [Parameter(Mandatory, ValueFromPipelineByPropertyName)]
        [ValidatePattern('^[\w.+-]+@[\w.-]+\.\w+$')]
        [string]$Email,
 
        [Parameter(ValueFromPipelineByPropertyName)]
        [ValidateSet("Admin", "User", "Guest")]
        [string]$Role = "User"
    )
 
    begin {
        Write-Verbose "Starting user creation process..."
    }
 
    process {
        if ($PSCmdlet.ShouldProcess("User: $Username", "Create system user")) {
            Write-Verbose "Creating user '$Username' with role '$Role'..."
 
            # Simulate user creation
            $user = [PSCustomObject]@{
                Username     = $Username
                Email        = $Email
                Role         = $Role
                CreatedDate  = Get-Date
                Status       = "Active"
                ID           = [guid]::NewGuid().ToString()
            }
 
            Write-Host "✓ Created user: $Username ($Role)" -ForegroundColor Green
 
            # Output the user object
            $user
        }
    }
 
    end {
        Write-Verbose "User creation process completed"
    }
}
 
# Test with single user
New-SystemUser -Username "jdoe" -Email "jdoe@example.com" -Role "Admin" -Verbose
 
# Test with pipeline input
@(
    @{Username="alice"; Email="alice@example.com"; Role="Admin"}
    @{Username="bob"; Email="bob@example.com"; Role="User"}
    @{Username="charlie"; Email="charlie@example.com"}
) | ForEach-Object { [PSCustomObject]$_ } | New-SystemUser -Verbose
 
# Test -WhatIf
New-SystemUser -Username "testuser" -Email "test@example.com" -WhatIf
 

<#
.SYNOPSIS
    Analyzes log files and provides statistics.
 
.DESCRIPTION
    Parses structured log files, counts log levels, and identifies recent errors.
 
.PARAMETER LogPath
    Path to the log file to analyze.
 
.PARAMETER FilterLevel
    Optional filter to show only specific log levels.
 
.EXAMPLE
    .\Analyze-Logs.ps1 -LogPath "C:\Logs\app.log"
 
.EXAMPLE
    .\Analyze-Logs.ps1 -LogPath "C:\Logs\app.log" -FilterLevel ERROR -Verbose
#>
 
[CmdletBinding()]
param(
    [Parameter(Mandatory)]
    [ValidateScript({
        if (Test-Path $_ -PathType Leaf) { $true }
        else { throw "Log file '$_' does not exist" }
    })]
    [string]$LogPath,
 
    [Parameter()]
    [ValidateSet("INFO", "WARNING", "ERROR")]
    [string]$FilterLevel
)
 
Write-Verbose "Analyzing log file: $LogPath"
 
# Read and parse log file
$logEntries = Get-Content $LogPath | ForEach-Object {
    if ($_ -match '\[(.+?)\]\s+\[(.+?)\]\s+(.+)') {
        [PSCustomObject]@{
            Timestamp = [datetime]::Parse($Matches[1])
            Level     = $Matches[2]
            Message   = $Matches[3]
        }
    }
}
 
Write-Verbose "Parsed $($logEntries.Count) log entries"
 
# Apply filter if specified
if ($FilterLevel) {
    $logEntries = $logEntries | Where-Object { $_.Level -eq $FilterLevel }
    Write-Verbose "Filtered to $($logEntries.Count) $FilterLevel entries"
}
 
# Count by level
$levelCounts = $logEntries | Group-Object Level | Sort-Object Count -Descending
 
# Find most recent error
$lastError = $logEntries | Where-Object { $_.Level -eq "ERROR" } | Sort-Object Timestamp -Descending | Select-Object -First 1
 
# Display summary
Write-Host ""
Write-Host "=== Log Analysis Summary ===" -ForegroundColor Cyan
Write-Host "File: $LogPath" -ForegroundColor White
Write-Host "Total entries: $($logEntries.Count)" -ForegroundColor White
Write-Host ""
 
Write-Host "Entries by level:" -ForegroundColor Cyan
$levelCounts | ForEach-Object {
    $color = switch ($_.Name) {
        "ERROR"   { "Red" }
        "WARNING" { "Yellow" }
        default   { "Green" }
    }
    Write-Host "  $($_.Name): $($_.Count)" -ForegroundColor $color
}
 
if ($lastError) {
    Write-Host ""
    Write-Host "Most recent error:" -ForegroundColor Red
    Write-Host "  Time: $($lastError.Timestamp)" -ForegroundColor White
    Write-Host "  Message: $($lastError.Message)" -ForegroundColor White
}
 
# Output structured results
[PSCustomObject]@{
    LogFile      = $LogPath
    TotalEntries = $logEntries.Count
    LevelCounts  = $levelCounts
    LastError    = $lastError
}
 

$sampleLog = @"
[2025-01-15 10:00:00] [INFO] Application started
[2025-01-15 10:05:30] [INFO] User logged in: alice
[2025-01-15 10:10:45] [WARNING] High memory usage detected
[2025-01-15 10:15:22] [ERROR] Database connection failed
[2025-01-15 10:16:05] [INFO] Retrying database connection
[2025-01-15 10:16:30] [INFO] Database connection restored
[2025-01-15 10:20:10] [ERROR] File not found: config.xml
[2025-01-15 10:25:00] [INFO] Processing completed
"@
 
$sampleLog | Out-File "C:\temp\sample.log"
 
# Test the script
.\Analyze-Logs.ps1 -LogPath "C:\temp\sample.log" -Verbose
.\Analyze-Logs.ps1 -LogPath "C:\temp\sample.log" -FilterLevel ERROR
 

# File: StringUtilities.psm1
 
function ConvertTo-TitleCase {
    <#
    .SYNOPSIS
        Converts a string to Title Case.
    .EXAMPLE
        ConvertTo-TitleCase "hello world"    # Hello World
    #>
    [CmdletBinding()]
    param(
        [Parameter(Mandatory, ValueFromPipeline)]
        [string]$Text
    )
 
    process {
        $textInfo = (Get-Culture).TextInfo
        $textInfo.ToTitleCase($Text.ToLower())
    }
}
 
function Remove-SpecialCharacters {
    <#
    .SYNOPSIS
        Removes all non-alphanumeric characters from a string.
    .EXAMPLE
        Remove-SpecialCharacters "Hello, World! @2025"    # HelloWorld2025
    #>
    [CmdletBinding()]
    param(
        [Parameter(Mandatory, ValueFromPipeline)]
        [string]$Text,
 
        [Parameter()]
        [switch]$KeepSpaces
    )
 
    process {
        if ($KeepSpaces) {
            $Text -replace '[^a-zA-Z0-9 ]', ''
        } else {
            $Text -replace '[^a-zA-Z0-9]', ''
        }
    }
}
 
function Get-StringHash {
    <#
    .SYNOPSIS
        Computes SHA256 hash of a string.
    .EXAMPLE
        Get-StringHash "password123"
    #>
    [CmdletBinding()]
    param(
        [Parameter(Mandatory, ValueFromPipeline)]
        [string]$Text,
 
        [Parameter()]
        [ValidateSet("SHA1", "SHA256", "SHA512", "MD5")]
        [string]$Algorithm = "SHA256"
    )
 
    process {
        $bytes = [System.Text.Encoding]::UTF8.GetBytes($Text)
        $hasher = [System.Security.Cryptography.HashAlgorithm]::Create($Algorithm)
        $hashBytes = $hasher.ComputeHash($bytes)
 
        $hashString = ($hashBytes | ForEach-Object { $_.ToString("x2") }) -join ''
 
        [PSCustomObject]@{
            Text      = $Text
            Algorithm = $Algorithm
            Hash      = $hashString
        }
    }
}
 
# Export module members
Export-ModuleMember -Function ConvertTo-TitleCase, Remove-SpecialCharacters, Get-StringHash
 

New-ModuleManifest -Path StringUtilities.psd1 `
    -Author "Your Name" `
    -Description "Utility functions for string manipulation" `
    -ModuleVersion "1.0.0" `
    -RootModule "StringUtilities.psm1" `
    -FunctionsToExport @("ConvertTo-TitleCase", "Remove-SpecialCharacters", "Get-StringHash")
 

# Import module
Import-Module .\StringUtilities.psd1 -Force
 
# Test ConvertTo-TitleCase
"hello world from powershell" | ConvertTo-TitleCase
# Output: Hello World From Powershell
 
# Test Remove-SpecialCharacters
"User@123: John-Doe!" | Remove-SpecialCharacters
# Output: User123JohnDoe
 
"User@123: John-Doe!" | Remove-SpecialCharacters -KeepSpaces
# Output: User123 JohnDoe
 
# Test Get-StringHash
"mypassword" | Get-StringHash
Get-StringHash -Text "mypassword" -Algorithm SHA1
 
# Test pipeline
@("test1", "test2", "test3") | Get-StringHash | Format-Table
 
# Check exported functions
Get-Command -Module StringUtilities
 

$modulePath = "$HOME\Documents\PowerShell\Modules\StringUtilities"
New-Item $modulePath -ItemType Directory -Force
Copy-Item StringUtilities.* $modulePath\
 
# Now available from anywhere
Import-Module StringUtilities