Email Validation Toolkit

# Email Validation Toolkit

# Function to validate email using a simple regex pattern
function Test-EmailSimple {
    param (
        [Parameter(Mandatory=$true)]
        [string]$Email
    )
    
    $regex = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
    return $Email -match $regex
}

# Function to validate email using a more comprehensive regex pattern
function Test-EmailComprehensive {
    param (
        [Parameter(Mandatory=$true)]
        [string]$Email
    )
    
    $regex = "^(?!\.)(""([^""\r\\]|\\[""\r\\])*""|([-a-z0-9!#$%&'*+/=?^_`{|}~]|(?<!\.)\.)*)(?<!\.)@[a-z0-9][\w\.-]*[a-z0-9]\.[a-z][a-z\.]*[a-z]$"
    return $Email -match $regex
}

# Function to validate email with domain check
function Test-EmailWithDomain {
    param (
        [Parameter(Mandatory=$true)]
        [string]$Email
    )
    
    $regex = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
    if ($Email -match $regex) {
        $domain = ($Email -split "@")[1]
        if (Resolve-DnsName -Name $domain -ErrorAction SilentlyContinue) {
            return $true
        }
    }
    return $false
}

# Function to validate multiple emails
function Test-MultipleEmails {
    param (
        [Parameter(Mandatory=$true)]
        [string[]]$Emails,
        [Parameter(Mandatory=$false)]
        [ValidateSet("Simple", "Comprehensive", "WithDomain")]
        [string]$Method = "Simple"
    )
    
    $results = @()
    foreach ($email in $Emails) {
        switch ($Method) {
            "Simple" { $isValid = Test-EmailSimple -Email $email }
            "Comprehensive" { $isValid = Test-EmailComprehensive -Email $email }
            "WithDomain" { $isValid = Test-EmailWithDomain -Email $email }
        }
        $results += [PSCustomObject]@{
            Email = $email
            IsValid = $isValid
        }
    }
    return $results
}

# Function to extract emails from text
function Get-EmailsFromText {
    param (
        [Parameter(Mandatory=$true)]
        [string]$Text
    )
    
    $regex = "\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\.[A-Z|a-z]{2,}\b"
    return $Text | Select-String -Pattern $regex -AllMatches | ForEach-Object { $_.Matches.Value }
}

# Example usage
$testEmails = @(
    "user@example.com",
    "invalid.email@",
    "another.user@example.co.uk",
    "not_an_email"
)

Write-Host "Simple Validation:"
Test-MultipleEmails -Emails $testEmails -Method Simple | Format-Table

Write-Host "`nComprehensive Validation:"
Test-MultipleEmails -Emails $testEmails -Method Comprehensive | Format-Table

Write-Host "`nValidation with Domain Check:"
Test-MultipleEmails -Emails $testEmails -Method WithDomain | Format-Table

$sampleText = "Contact us at support@example.com or sales@company.co.uk for more information."
Write-Host "`nExtracting emails from text:"
Get-EmailsFromText -Text $sampleText

This toolkit includes the following functions:

1. Test-EmailSimple: Uses a simple regex pattern to validate email addresses.
2. Test-EmailComprehensive: Uses a more comprehensive regex pattern for stricter validation.
3. Test-EmailWithDomain: Validates the email format and checks if the domain exists.
4. Test-MultipleEmails: Validates multiple email addresses using one of the above methods.
5. Get-EmailsFromText: Extracts email addresses from a given text.

To use this toolkit, you can copy and paste the entire script into a PowerShell file (e.g., EmailValidationToolkit.ps1) and then dot-source it in your PowerShell session:

. .\EmailValidationToolkit.ps1