ProfilePal

1.0.0

ProfilePal.psm1

<#
.SYNOPSIS
    ProfilePal Module contains functions that help create and edit PowerShell profiles, as well as some other functions which can easily re-used across all PowerShell profiles
.DESCRIPTION
    ProfilePal.psm1 - Stores common functions for customizing PowerShell profiles for Console AND ISE Hosts
.NOTES
    File Name : ProfilePal.psm1
    Author : Bryan Dady
    Link Note : Some functions originally inspired by zerrouki
    Thanks zerrouki for the inspiration! http://www.zerrouki.com/powershell-profile-example/
.LINK
    http://bryan.dady.us/profilepal/
    https://github.com/bcdady/profilepal
#>
#========================================
#Requires -Version 3.0

# Define script scope variables we might need later
[Boolean]$FrameTitleDefault;
[String]$defaultFrameTitle;

function Get-WindowTitle {
<#
.SYNOPSIS
Stores the default PowerShell host window title
.DESCRIPTION
Supports Set-WindowTitle and Reset-WindowTitle functions
#>
    if ($FrameTitleDefault) { $defaultFrameTitle = $Host.UI.RawUI.WindowTitle }
    $FrameTitleDefault = $true;
}

function Set-WindowTitle {
<#
.SYNOPSIS
    Customizes Host window title, to show version start date/time, and starting path.
.DESCRIPTION
    For use in customizing PowerShell Hostlook and feel, in conjunction with a customized prompt function
    With the path in the title, we can leave it out of the prompt; customized in another function within this module
#>
    Get-WindowTitle
    $hosttime = (Get-ChildItem -Path $pshome\PowerShell.exe).creationtime;
    [String[]]$hostVersion = $Host.version;
    [String[]]$titlePWD    = Get-Location;
    $Host.UI.RawUI.WindowTitle = "PowerShell $hostVersion - $titlePWD [$hosttime]";
    $FrameTitleDefault = $false;
}

function Reset-WindowTitle {
<#
.SYNOPSIS
    Restores default PowerShell host window title, as captured by Get-WindowTitle
.DESCRIPTION
    Provided to make it easy to reset the default window frame title, but presumes that Get-WindowTitle was previously run
#>
    Write-Debug -InputObject $defaultFrameTitle; 
    Write-Debug -InputObject "FrameTitle length: $($defaultFrameTitle.length)";
    if ($defaultFrameTitle.length -gt 1) {
        $Host.UI.RawUI.WindowTitle = $defaultFrameTitle;
    }
# [console]::Title=$defaultFrameTitle;
}

function prompt {
<#
.SYNOPSIS
From about_Prompts: "The Windows PowerShell prompt is determined by the built-in Prompt function. You can customize the prompt by creating your own Prompt function and saving it in your Windows PowerShell profile".
.DESCRIPTION
From about_Prompts:
    The Prompt function determines the appearance of the Windows PowerShell prompt. Windows PowerShell comes with a built-in Prompt function, but you can override it by defining your own Prompt function.
     
    The Prompt function has the following syntax:
 
        function Prompt { <function-body> }
 
#>
    $identity = [Security.Principal.WindowsIdentity]::GetCurrent()
    $principal = [Security.Principal.WindowsPrincipal] $identity

    $(  if ($PSDebugContext)
            { '[DEBUG] ' }

        elseif($principal.IsInRole([Security.Principal.WindowsBuiltInRole] 'Administrator'))
            { '[ADMIN] ' }

        else { '' }
    ) + 'PS .\' + $(if ($nestedpromptlevel -ge 1) { ' >> ' }) + '> '
}

function Open-AdminConsole {
<#
.SYNOPSIS
    Launch a new console window from the command line, with optional -NoProfile support
.DESCRIPTION
    Simplifies opening a PowerShell console host, with Administrative permissions, by enabling the same result from the keyboard, instead of having to grab the mouse to Right-Click and select 'Run as Administrator'
The following aliases are also provided:
    Open-AdminHost
    Start-AdminConsole
    Start-AdminHost
    New-AdminConsole
    New-AdminHost
    Request-AdminConsole
    Request-AdminHost
    sudo
 
#>
    # Aliases added below
    Param( [Switch]$noprofile )

    if ($Variable:noprofile) {
        Start-Process -FilePath "$PSHOME\powershell.exe" -ArgumentList '-NoProfile' -Verb RunAs -WindowStyle Normal;
    } else {
        Start-Process -FilePath "$PSHOME\powershell.exe" -Verb RunAs -WindowStyle Normal;
    }
}

New-Alias -Name Open-AdminHost -Value Open-AdminConsole -ErrorAction Ignore;

New-Alias -Name Start-AdminConsole -Value Open-AdminConsole -ErrorAction Ignore;

New-Alias -Name Start-AdminHost -Value Open-AdminConsole -ErrorAction Ignore;

New-Alias -Name New-AdminConsole -Value Open-AdminConsole -ErrorAction Ignore;

New-Alias -Name New-AdminHost -Value Open-AdminConsole -ErrorAction Ignore;

New-Alias -Name Request-AdminConsole -Value Open-AdminConsole -ErrorAction Ignore;

New-Alias -Name Request-AdminHost -Value Open-AdminConsole -ErrorAction Ignore;

New-Alias -Name sudo -Value Open-AdminConsole -ErrorAction Ignore;

function Get-Profile {
<#
.SYNOPSIS
Returns corresponding PowerShell profile name, path, and status (whether it's script file exists or not)
.DESCRIPTION
Can be passed a parameter for a profile by Name or Path, and returns a summary object
.PARAMETER Name
    Accepts 'AllProfiles', 'CurrentUserCurrentHost', 'CurrentUserAllHosts', 'AllUsersCurrentHost' or 'AllUsersAllHosts'
.EXAMPLE
PS .\> Get-Profile
 
Name Path Exists
----------- ----------- --------------
CurrentUserCurrentHost C:\Users\BDady\Documents\WindowsPowerSh... True
 
.EXAMPLE
PS .\> Get-Profile -Name AllUsersCurrentHost | Format-Table -AutoSize
 
Name Path Exists
----------- ----------- --------------
AllUsersCurrentHost C:\Windows\System32\WindowsPowerShell\v1.0\Microsoft.PowerShell_profile.ps1 False
 
.NOTES
NAME : Get-Profile
LAST UPDATED: 4/27/2015
AUTHOR : Bryan Dady
.INPUTS
None
.OUTPUTS
Profile Object
#>
    [CmdletBinding()]
    Param (
        # Specifies which profile to check; if not specified, presumes default result from $PROFILE
        [Parameter(Mandatory=$false,
            Position=0,
            ValueFromPipeline=$false,
            ValueFromPipelineByPropertyName=$false,
            HelpMessage='Specify $PROFILE by Name, such as CurrenUserCurrentHost')]
        [ValidateSet('AllProfiles','CurrentUserCurrentHost', 'CurrentUserAllHosts', 'AllUsersCurrentHost', 'AllUsersAllHosts')]
        [string]
        $Name = 'AllProfiles'
    )

    # Define empty array to add profile return objects to
    [array]$outputobj = @();

    # Build a hashtable to easily enumerate PowerShell profile contexts / names and their scripts
    [hashtable]$hashProfiles = @{
        CurrentUserCurrentHost = $PROFILE.CurrentUserCurrentHost;
        CurrentUserAllHosts    = $PROFILE.CurrentUserAllHosts
        AllUsersCurrentHost    = $PROFILE.AllUsersCurrentHost;
        AllUsersAllHosts       = $PROFILE.AllUsersAllHosts;
    };

    # Check if a $PROFILE script is found on the file system, for the profile specified by the Name parameter, then return details for that profile script
    Switch ($Name) {
        'AllProfiles' {
            $hashProfiles.Keys | ForEach-Object {
                 if (Test-Path -Path $hashProfiles.$PSItem -ErrorAction SilentlyContinue)
                    {
                        $ProfileExists = $true
                    } else {
                        $ProfileExists = $false
                    }

                    $properties = @{'Name'=$PSItem; 'Path'=$hashProfiles.$PSItem; 'Exists'=$ProfileExists;}
                    $object = New-Object –TypeName PSObject –Prop $properties;

                    # Add this resulting object to the array object to be returned by this function
                    $outputobj += $object

                    # cleanup properties variable
                    Set-Variable -Name properties
            }
        }
        Default {
            if (Test-Path -Path $hashProfiles.$Name -ErrorAction SilentlyContinue)
            {
                $ProfileExists = $true
            } else {
                $ProfileExists = $false
            }

            #'Optimize New-Object invokation, based on Don Jones' recommendation: https://technet.microsoft.com/en-us/magazine/hh750381.aspx
            $properties = @{'Name'=$Name; 'Path'=$hashProfiles.$Name; 'Exists'=$ProfileExists; }
            $object = New-Object –TypeName PSObject –Prop $properties

            # Add this resulting object to the array object to be returned by this function
            $outputobj = $object
        }
    }

    return $outputobj;
}

function Edit-Profile {
<#
.Synopsis
   Open a PowerShell Profile script in the ISE editor
.DESCRIPTION
   Edit-Profile will attempt to open any existing PowerShell Profile scripts, and if none are found, will offer to invoke the New-Profile cmdlet to build one
   Both New-Profile and Edit-Profile can open any of the 4 contexts of PowerShell Profile scripts.
.PARAMETER ProfileName
    Accepts 'CurrentUserCurrentHost', 'CurrentUserAllHosts', 'AllUsersCurrentHost' or 'AllUsersAllHosts'
.EXAMPLE
   Edit-Profile
   Opens the default $profile script file, if it exists
.EXAMPLE
   Edit-Profile CurrentUserAllHosts
   Opens the specified CurrentUserAllHosts $profile script file, which applies to both Console and ISE hosts, for the current user
#>
    [CmdletBinding()]
    [OutputType([int])]
    Param (
        # Specifies which profile to edit; if not specified, ise presumes $profile means Microsoft.PowerShellISE_profile.ps1
        [Parameter(Mandatory=$false,
                   ValueFromPipelineByPropertyName=$true,
                   Position=0,
                   HelpMessage='Specify the PowerShell Profile to modify. <optional>'
        )]
        [ValidateSet('AllUsersAllHosts','AllUsersCurrentHost','CurrentUserAllHosts','CurrentUserCurrentHost')]
        [String[]]
        $profileName
    )

    [String]$openProfile='';

    if ($profileName) {
        # check if the profile file exists
        Write-Debug "Testing existence of $profileName profile: $($PROFILE.$profileName)";
        if (Test-Path -Path $PROFILE.$profileName) {
            # file exists, so we can pass it on to be opened
            $openProfile = $PROFILE.$profileName;
        } else {
            # Specified file doesn't exist. Fortunatley we also have a function to help with that
            write-output -InputObject "`n$profileName profile not found.";
            write-output -InputObject 'Preparing to create a starter profile script, using the New-Profile function.';
            New-Profile -profileName $profileName;
            # Check if the $profile exists, using the get-profile function
            if ((Get-Profile -Name "$profileName").Exists) {
                $openProfile = $PROFILE.$profileName;
            } else {
                $openProfile = $null;
            }
        }

    # otherwise, test for an existing profile, in order of most specific, to most general scope
    } elseif (Test-Path -Path $PROFILE.CurrentUserCurrentHost) {
        $openProfile = $PROFILE.CurrentUserCurrentHost;
    } elseif (Test-Path -Path $PROFILE.CurrentUserAllHosts) {
        $openProfile = $PROFILE.CurrentUserAllHosts;
    } elseif (Test-Path -Path $PROFILE.AllUsersCurrentHost) {
        $openProfile = $PROFILE.AllUsersCurrentHost;
    } elseif (Test-Path -Path $PROFILE.AllUsersAllHosts) {
        $openProfile = $PROFILE.AllUsersAllHosts;
    }

    # if a profile is specified, and found, then we open it.
    if ($openProfile) {
        & powershell_ise.exe -File $openProfile;
    } else {
        Write-Warning -Message 'No existing PowerShell profile was found. Consider running New-Profile to create a ready-to-use profile script.';
    }

}

function New-Profile {
<#
.Synopsis
   Create a new PowerShell profile script
.DESCRIPTION
   The PowerShell profile script can be created in any 1 of the 4 default contexts, and if not specified, defaults to the most common CurrentUserCurrentHost.
   If this function is called from within PowerShell ISE, the *CurrentHost* profiles will be created with the requisite PowerShellISE_profile prefix
   In order to create new AllUsers profile scripts, this function must be called with elevated (admin) priveleges.
.PARAMETER ProfileName
    Accepts 'CurrentUserCurrentHost', 'CurrentUserAllHosts', 'AllUsersCurrentHost' or 'AllUsersAllHosts'
.EXAMPLE
PS .\> New-Profile
 
Creates a new starter profile script for the context Current User / Current [PowerShell] Host
 
    Starter profile CurrentUserCurrentHost has been created. To review and/or modify (in the PowerShell ISE), try the Edit-Profile function.
    For example, run: Edit-Profile -profileName CurrentUserCurrentHost
 
        Directory: C:\Users\[username]\Documents\WindowsPowerShell
 
 
    Mode LastWriteTime Length Name
    ---- ------------- ------ ----
    -a--- 4/27/2015 10:54 AM 2381 Microsoft.PowerShell_profile.ps1
 
.EXAMPLE
PS .\> New-Profile -profileName CurrentUserAllHosts
 
Creates a new starter profile script for the context Current User / Current [PowerShell] Host
 
    Starter profile CurrentUserAllHosts has been created. To review and/or modify (in the PowerShell ISE), try the Edit-Profile function.
    For example, run: Edit-Profile -profileName CurrentUserAllHosts
 
        Directory: C:\Users\[username]\Documents\WindowsPowerShell
 
    Mode LastWriteTime Length Name
    ---- ------------- ------ ----
    -a--- 4/27/2015 10:57 AM 2378 profile.ps1
 
#>
    [CmdletBinding()]
    [OutputType([int])]
    Param (
        # Specifies which profile to edit; if not specified, ise presumes $profile means Microsoft.PowerShellISE_profile.ps1
        [Parameter(Mandatory=$false,
                   ValueFromPipelineByPropertyName=$true,
                   Position=0)]
        [ValidateSet('AllUsersAllHosts','AllUsersCurrentHost','CurrentUserAllHosts','CurrentUserCurrentHost')]
        [String[]]
        $ProfileName = 'CurrentUserCurrentHost'
    )

# pre-define new profile script content, which utilizes functions of this module
$profile_string_content = @"
# PowerShell `$Profile
# Created by New-Profile function of ProfilePal module
 
`$startingPath = `$pwd; # capture starting path so we can go back after other things below might move around
 
# -Optional- Specify custom font colors
# Uncomment the following if block to tweak the colors of your console; the 'if' statement is to make sure we leave the ISE host alone
# To Uncomment the following block, delete the `<#` from the next line as well as the matching `#`> a few lines down
<#
if (`$host.Name -eq 'ConsoleHost') {
    `$host.ui.rawui.backgroundcolor = 'gray';
    `$host.ui.rawui.foregroundcolor = 'darkblue'; # blue on gray work well in Console
    Clear-Host; # clear-host refreshes the background of the console host to the new color scheme
    Start-Sleep -Seconds 1; # wait a second for the clear command to refresh
    # write to consolehost a copy of the 'Logo' text displayed when one starts a typical powershell.exe session.
    # This is added in becuase we'd otherwise not see it, after customizing console colors, and then calling clear-host to refresh the console view
    Write-Output @'
Windows PowerShell [Customized by ProfilePal]
Copyright (C) 2013 Microsoft Corporation. All rights reserved.
'@
 
}
#>
 
Write-Output "``n``tLoading PowerShell ```$Profile`: $profileName``n";
 
# Load profile functions module; includes a customized prompt function
# In case you'd like to edit it, open ProfilePal.psm1 in ise, and review the function prompt {}
# for more info on prompt customization, you can run get-help about_Prompts
write-output ' # loading ProfilePal Module #'; Import-Module -Name ProfilePal; # -Verbose;
 
# Here's an example of how convenient aliases can be added to your PS profile
New-Alias -Name rdp -Value Start-RemoteDesktop -ErrorAction Ignore; # Add -ErrorAction Ignore, in case that alias is already defined
 
# In case any intermediaary scripts or module loads change our current directory, restore original path, before it's locked into the window title by Set-WindowTitle
Set-Location `$startingPath;
 
# Call Set-WindowTitle function from ProfilePal module
Set-WindowTitle;
 
# Display execution policy; for convenience
write-output "``nCurrent PS execution policy is: "; Get-ExecutionPolicy;
 
write-output "``n ** To view additional available modules, run: Get-Module -ListAvailable";
write-output "``n ** To view cmdlets available in a given module, run: Get-Comand -Module <ModuleName>`n";
 
"@

Write-Debug $profile_string_content;

    # Check if the $profile exists, using the get-profile function
    if ((Get-Profile -Name "$profileName").Exists) {
        Write-Warning -Message "$($profile.$profileName) already exists";
    } else {
        # Since a $profile's not created yet, create the file
        # check if we're attempting to create a system context profile
        if ($profileName -like 'AllUsers*') {
            # then we need admin permissions
            if (Test-AdminPerms) {
                $new_profile = new-item -type file -path $profile.$profileName;
                # write the profile content into the new file
                Add-Content -Value $profile_string_content -Path $new_profile;
            } else {
                Write-Warning 'Insufficient priveleges to create an AllUsers profile script.'
                Write-Output 'Please try again with an Admin console (see function Open-AdminConsole), or create a CurrentUser profile instead.'
            } # end Test-AdminPerms
        } else {
            $new_profile = new-item -type file -path $profile.$profileName;
            # write the profile content into the new file
            Add-Content -Value $profile_string_content -Path $new_profile;
        } # end profileName
    } # end Get-Profile

    # Check / confirm that the $profile exists, using the get-profile function
    if ((Get-Profile -Name "$profileName").Exists) {
        Write-Output "`nStarter profile $profileName has been created."
        Write-Output ' To review and/or modify (in the PowerShell ISE), try the Edit-Profile function.'
        Write-Output " For example, run: Edit-Profile -profileName $profileName";

        return $new_profile;
    } else {
        return $false;
    }

} # end function

New-Alias -Name Initialize-Profile -Value New-Profile -ErrorAction:SilentlyContinue;

function Reset-Profile {
<#
.SYNOPSIS
Reload the profile (`$PROFILE), by using dot-source invokation
.DESCRIPTION
Essentially an alias for PS .\>. $Profile
#>
    . $Profile
}

function Test-AdminPerms {
<#
.SYNOPSIS
Test if you have Admin Permissions; returns simple boolean result
.DESCRIPTION
([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole(`
        [Security.Principal.WindowsBuiltInRole] 'Administrator')
#>
([Security.Principal.WindowsPrincipal] [Security.Principal.WindowsIdentity]::GetCurrent()).IsInRole(`
        [Security.Principal.WindowsBuiltInRole] 'Administrator')
}

function Start-RemoteDesktop {
<#
    .SYNOPSIS
        Launch a Windows Remote Desktop admin session to a specified computername, with either FullScreen, or sized window
    .DESCRIPTION
        Start-RemoteDesktop calls the mstsc.exe process installed on the local instance of Windows.
        By default, Start-RemoteDesktop specifies the optional arguments of /admin, and /fullscreen.
        Start-RemoteDesktop also provides a -ScreenSize parameter, which supports optional window resolution specifications of 1440 x 1050, 1280 x 1024, and 1024 x 768.
        I first made this because I was tired of my last mstsc session hanging on to my last resolution (which would change between when I was docked at my desk, or working from the smaller laptop screen); so this could always 'force' /fullscreen.
    .PARAMETER ComputerName
        Specifies the DNS name or IP address of the computer / server to connect to.
    .PARAMETER ScreenSize
        Specifies the window resolution. If not specified, defaults to Full Screen.
    .PARAMETER Control
        Optionall specifies if the remote session should function in Admin, RestrictedAdmin, or Control mode [default in this function].
    .PARAMETER FullScreen
        Unambiguously specifies that the RDP window open to full screen size.
    .PARAMETER PipelineVariable
        Accepts property ComputerName.
    .EXAMPLE
        PS C:\> Start-RemoteDesktop remotehost
        Invokes mstsc.exe /v:remotehost /control
    .EXAMPLE
        PS C:\> Start-RemoteDesktop -ComputerName <IP Address> -ScreenSize 1280x1024 -Control RestrictedAdmin
        Invokes mstsc.exe /v:<IP Address> /RestrictedAdmin /w:1280 /h:1024
    .NOTES
        NAME : Start-RemoteDesktop
        VERSION : 1.7
        LAST UPDATED: 4/4/2015
        AUTHOR : Bryan Dady; @bcdady; http://bryan.dady.us
    .INPUTS
        ComputerName
    .OUTPUTS
        None
#>
    [cmdletbinding()]
    param (
        [Parameter(Mandatory=$true,
                   ValueFromPipelineByPropertyName=$true,
                   Position=0)]
        [ValidateNotNullOrEmpty]
        [String[]]
        $ComputerName,

        [Parameter(Position=1)]
        [ValidateSet('FullAdmin','RestrictedAdmin')]
        [Switch]
        $Control,

        [Switch]
        $FullScreen,

        [ValidateSet('FullScreen','1440x1050','1280x1024','1024x768')]
        [String[]]
        $ScreenSize = 'FullScreen'
    )
    Write-Output 'Starting '+$PSCmdlet.MyInvocation.MyCommand.Name

    if (Test-Connection -ComputerName $ComputerName -Count 1 -Quiet) {
        Write-Output "Confirmed network availability of ComputerName $ComputerName";
    } else {
        Write-Output "Unable to confirm network availability of ComputerName $ComputerName [Test-Connection failed]";
        break;
    }

    switch ($Control) {
        'FullAdmin'  { $Control = '/admin' }
        'RestrictedAdmin'  { $Control = '/RestrictedAdmin'}
        Default      { $Control = '/Control'}
    }

    if ($FullScreen) { $Resolution = '/fullscreen' }
    else {
        switch ($ScreenSize) {
            'FullScreen' { $Resolution = '/fullscreen' }
            '1440x1050'  { $Resolution = '/w:1440 /h:1050'}
            '1280x1024'  { $Resolution = '/w:1280 /h:1024'}
            '1024x768'   { $Resolution = '/w:1024 /h:768'}
            Default      { $Resolution = '/fullscreen' }
        }
    }

    Write-Debug "Start-Process -FilePath mstsc.exe -ArgumentList ""/v:$ComputerName $Control $Resolution"""; 
    
    Start-Process -FilePath mstsc.exe -ArgumentList "/v:$ComputerName $Control $Resolution"; 

    Write-Output 'Exiting '+$PSCmdlet.MyInvocation.MyCommand.Name;
}

function Test-Port {
<#
.SYNOPSIS
Test-Port is effectively a PowerShell replacement for telnet, to support testing of a specified IP port of a remote computer
.DESCRIPTION
Test-Port enables testing for any answer or open indication from a remote network port.
.PARAMETER Target
DNS name or IP address of a remote computer or network device to test response from.
.PARAMETER Port
IP port number to test on the TARGET.
.PARAMETER Timeout
Time-to-live (TTL) parameter for how long to wait for a response from the TARGET PORT.
.EXAMPLE
PS C:\> Test-Port RemoteHost 9997
Tests if the remote host is open on the default Splunk port.
.NOTES
NAME : Test-Port
VERSION : 1.1
LAST UPDATED: 4/4/2015
AUTHOR : Bryan Dady
.INPUTS
None
.OUTPUTS
None
#>
    [cmdletbinding()]
    param(
        [parameter(mandatory=$true,
            position=0)]
        [String[]]$Target,

        [parameter(mandatory=$true,
            position=1)]
            [ValidateRange(1,50000)]
        [int32]$Port=80,

        [int32]$Timeout=2000
    )
    $outputobj=New-Object -TypeName PSobject;
    $outputobj | Add-Member -MemberType NoteProperty -Name TargetHostName -Value $Target;
    if(Test-Connection -ComputerName $Target -Count 2) {
        $outputobj | Add-Member -MemberType NoteProperty -Name TargetHostStatus -Value 'ONLINE';
    } else {
        $outputobj | Add-Member -MemberType NoteProperty -Name TargetHostStatus -Value 'OFFLINE';
    } 
    $outputobj | Add-Member -MemberType NoteProperty -Name PortNumber -Value $Port;
    $Socket=New-Object System.Net.Sockets.TCPClient;
    $Connection=$Socket.BeginConnect($Target,$Port,$null,$null);
    $Connection.AsyncWaitHandle.WaitOne($timeout,$false) | Out-Null;
    if($Socket.Connected -eq $true) {$outputobj | Add-Member -MemberType NoteProperty -Name ConnectionStatus -Value 'Success';
    } else {
        $outputobj | Add-Member -MemberType NoteProperty -Name ConnectionStatus -Value 'Failed';
    }
    $Socket.Close | Out-Null;
    $outputobj | Select-Object TargetHostName, TargetHostStatus, PortNumber, Connectionstatus | Format-Table -AutoSize;
}

New-Alias -Name telnet -Value Test-Port -ErrorAction Ignore;
 
function Get-UserName {
<#
.SYNOPSIS
    Get-UserName returns user's account info in the format of DOMAIN\AccountName
.DESCRIPTION
    [System.Security.Principal.WindowsIdentity]::GetCurrent().Name;
.EXAMPLE
    PS C:\> Get-UserName;
    Returns DomainName\UserName
.EXAMPLE
    PS C:\> whoami
    Linux friendly alias invokes Get-UserName
.NOTES
    NAME : Get-UserName
    VERSION : 1.1
    LAST UPDATED: 3/4/2015
#>

[System.Security.Principal.WindowsIdentity]::GetCurrent().Name;
}

New-Alias -Name whoami -Value Get-UserName -ErrorAction Ignore;

Export-ModuleMember -function * -alias *