$thoughts | Out-Web

Select-Multiple

2010-11-12T06:46:00.000-08:00

Where I work, we have a policy that before anyone on the team commits changes to the repository, a code review needs to be done. All the other member of my team use TortoiseSVN, so they just use the option to display modifications and then double-click on each file to show a diff with the base. I stubbornly insist on do everything from the command-line, so what I usually do is run this command, which uses WinMerge to show the differences for all of my modified files:

This usually works just fine, but it has a couple of drawbacks. The main problem is that it shows a diff for every modified file, including project files. Sometimes, even if the majority of the files are source files, my code review really only concerns a subset of the files that I have modified, but my loop above dutifully runs WinMerge for every file, forcing my colleagues to waste precious seconds while I dismiss the files they aren't interested in.

Enter the Select-Multiple script. Objects piped into Select-Multiple are displayed in a kind of selection window with a "check box" to the left of each object. The list can be navigated with the arrow keys and options can be selected with the space bar. After the list is dismissed with the enter key, the selected objects are passed through to the pipeline. Here's what it looks like in action:

If you want to display a certain property of the objects passed in to Select-Multiple, you can use the Property parameter:

Even if you use the Property parameter, the complete object is passed through the pipeline. The above example would stop the Internet Explorer process.

There are a few keyboard shortcuts to aid in selecting objects. Page up and page down will navigate long lists a page at a time. Control-A will select everything, and Control-T will toggle the selection. Holding down shift while using the up and down arrow keys will select while moving. Escape will dismiss the window without selecting anything.

Here is the complete script:

# Select-Multiple

#

# Objects piped into Select-Multiple are displayed in a kind of

# selection window with a "check box" to the left of each object.

#

# The list can be navigated with the arrow keys and options 

# can be selected with the space bar.

#

# If the Property parameter is provided, the value of that

# property is displayed in the list, rather than the string

# representation of the object.

#

# After the list is dismissed with the enter key, the selected

# objects are passed through to the pipeline.

#

# Keyboard operations:

#  Up/Down - navigate

#  Space - select current option

#  Page Up/Down - navigate long lists a page at a time

#  Ctrl-A - select all

#  Ctrl-T - toggle selection

#  Shift-Up/Down - select and move

#  Escape - exit with no objects selected

# configuration 

$script:ForegroundColor = $Host.UI.RawUI.ForegroundColor

$script:BackgroundColor = $Host.UI.RawUI.BackgroundColor

$script:BorderForegroundColor = $Host.UI.RawUI.BackgroundColor

$script:BorderBackgroundColor = $Host.UI.RawUI.ForegroundColor

$script:SelectedForegroundColor = [ConsoleColor]"White"

$script:SelectedBackgroundColor = [ConsoleColor]"Red"

$script:StatusFormatString = "[X]: {0}/{1}"

function Select-Multiple( [string] $Property )

{

    begin

    {

        $options = @()

        # leave room for the border and "check box"

        $maxLength = $Host.UI.RawUI.WindowSize.Width - 2 - 6;

        function Make-Option( [object] $object )

        {

            $object | Select-Object `

                @{ Name = "Selected"; Expression = { $false } },

                @{ Name = "Object"; Expression = { $object } },

                @{ Name = "String";

                   Expression = {

                       $string = ""

                       if ( $Property )

                       {

                           $string = ( Invoke-Expression "`$object.$Property" ).ToString()

                       }

                       else

                       {

                           $string = $object.ToString()

                       }

                       if ( $string.Length -gt $maxLength )

                       {

                            # add elipsis...

                            $string = 

                                $string.SubString( 0, $maxLength - 3 ).PadRight( $maxLength, '.' )

                       }

                       $string

                   } }

        }

    }

    process

    {

        if ( $_ )

        {

            $options += Make-Option $_

        }

    }

    end

    {

        if ( $options.Length -gt 0 )

        {

            Show-Options $options

            foreach ( $option in $options )

            {

                if ( $option.Selected )

                {

                    $option.Object

                }

            }

        }

    }

}

function Show-Options( [object[]] $options )

{

    begin

    {

        function Get-KeyboardInput( $state )

        {

            $keyOptions = [System.Management.Automation.Host.ReadKeyOptions] `

                "NoEcho, IncludeKeyDown, IncludeKeyUp"

            $done = $false

            while ( $Host.UI.RawUI.KeyAvailable )

            {

                $key = $Host.UI.RawUI.ReadKey( $keyOptions )

                if ( $key.KeyDown )

                {

                    $shiftPressed = $key.ControlKeyState.ToString() -match "ShiftPressed"

                    $controlPressed = $key.ControlKeyState.ToString() -match "CtrlPressed"

                    switch ( $key.VirtualKeyCode )

                    {

                        38 { # up arrow

                            if ( $state.SelectedIndex -gt 0 )

                            {

                                Move-Up $state $shiftPressed

                            }

                            break

                        }

                        40 { # down arrow

                            if ( $state.SelectedIndex -lt $state.TotalOptions - 1 )

                            {

                                Move-Down $state $shiftPressed

                            }

                            break

                        }

                        33 { # page up

                            Page-Up $state

                            break

                        }

                        34 { # page down

                            Page-down $state

                            break

                        }

                        65 { # 'a' - select all

                            if ( $controlPressed )

                            {

                                Select-All $state

                            }

                            break

                        }

                        84 { # 't' - toggle selection

                            if ( $controlPressed )

                            {

                                Toggle-Selection $state

                            }

                            break

                        }

                        32 { # space - toggle current option

                            Select-Current $state $true

                        }

                        13 { # enter

                            $done = $true

                        }

                        27 { # escape

                            foreach ( $option in $state.Options )

                            {

                                $option.Selected = $false

                            }

                            $done = $true

                        }

                    }

                }

            }

            $done

        }

        function Move-Up( $state, $shiftPressed )

        {

            if ( $shiftPressed )

            {

                Select-Current $state $false

            }

            Set-SelectionColors `

                $state `

                $script:ForegroundColor `

                $script:BackgroundColor

            if ( $state.SelectedIndex - $state.Offset -eq 0 )

            {

                 --$state.Offset

                 Draw-Options $state

            }

            --$state.SelectedIndex

            Set-SelectionColors `

                $state `

                $script:SelectedForegroundColor `

                $script:SelectedBackgroundColor

            if ( $shiftPressed )

            {

                Select-Current $state $false

            }

        }

        function Move-Down( $state, $shiftPressed )

        {

            if ( $shiftPressed )

            {

                Select-Current $state $false

            }

            Set-SelectionColors `

                $state `

                $script:ForegroundColor `

                $script:BackgroundColor

            if ( $state.SelectedIndex - $state.Offset -eq $state.MaxOptions )

            {

                 ++$state.Offset

                 Draw-Options $state

            }

            ++$state.SelectedIndex

            Set-SelectionColors `

                $state `

                $script:SelectedForegroundColor `

                $script:SelectedBackgroundColor

            if ( $shiftPressed )

            {

                Select-Current $state $false

            }

        }

        function Page-Up( $state )

        {

            Set-SelectionColors `

               $state `

               $script:ForegroundColor `

               $script:BackgroundColor

            if ( $state.SelectedIndex -eq $state.Offset )

            {

                $state.Offset -= $state.MaxOptions

                $state.Offset = [Math]::Max( $state.Offset, 0 )

            }

            $state.SelectedIndex = $state.Offset

            Draw-Options $state

            Set-SelectionColors `

                $state `

                $script:SelectedForegroundColor `

                $script:SelectedBackgroundColor

        }

        function Page-Down( $state )

        {

            Set-SelectionColors `

               $state `

               $script:ForegroundColor `

               $script:BackgroundColor

            if ( $state.SelectedIndex -eq $state.MaxOptions + $state.Offset )

            {

                $state.Offset += $state.MaxOptions

                $state.Offset = [Math]::Min( 

                    $state.Offset,

                    $state.TotalOptions - $state.MaxOptions - 1 )

            }

            $state.SelectedIndex = $state.MaxOptions + $state.Offset

            $state.SelectedIndex = [Math]::Min( 

                    $state.SelectedIndex,

                    $state.TotalOptions - 1 )

            Draw-Options $state

            Set-SelectionColors `

                $state `

                $script:SelectedForegroundColor `

                $script:SelectedBackgroundColor

        }

        function Select-All( $state )

        {

            foreach ( $option in $state.Options )

            {

                $option.Selected = $true

            }

            $state.SelectedOptions = $state.TotalOptions

            Draw-Options $state

            Set-SelectionColors `

                $state `

                $script:SelectedForegroundColor `

                $script:SelectedBackgroundColor

        }

        function Toggle-Selection( $state )

        {

            $state.SelectedOptions = 0

            foreach ( $option in $state.Options )

            {

                $option.Selected = -not $option.Selected

                if ( $option.Selected )

                {

                    ++$state.SelectedOptions

                }

            }

            Draw-Options $state

            Set-SelectionColors `

                $state `

                $script:SelectedForegroundColor `

                $script:SelectedBackgroundColor

        }

        function Select-Current( $state, $toggleSelection )

        {

            $option = $state.Options[ $state.SelectedIndex ]

            if ( $toggleSelection )

            {

                $option.Selected = -not $option.Selected

                if ( $option.Selected )

                {

                    ++$state.SelectedOptions

                }

                else

                {

                    --$state.SelectedOptions

                }

            }

            else

            {

                if ( -not $option.Selected )

                {

                    ++$state.SelectedOptions

                }

                $option.Selected = $true

            }

            Draw-Options $state

            Set-SelectionColors `

                $state `

                $script:SelectedForegroundColor `

                $script:SelectedBackgroundColor

        }

        function Draw-Options( $state )

        {

            $optionStrings = @( $state.Options )[ 

                $state.Offset .. 

                ( $state.MaxOptions + $state.Offset ) ] | Foreach-Object {

                    if ( $_.Selected )

                    {

                        " [X] $($_.String) ".PadRight( $state.Width ) 

                    }

                    else

                    { 

                        " [ ] $($_.String) ".PadRight( $state.Width )

                    }

                }

            $status = ( $script:StatusFormatString -f 

                $state.SelectedOptions, $state.TotalOptions ).PadRight( $state.Width )

            $statusBuffer = $Host.UI.RawUI.NewBufferCellArray(

                @( $status ),

                $script:BorderForegroundColor, $script:BorderBackgroundColor )

            $Host.UI.RawUI.SetBufferContents( $state.StatusPosition, $statusBuffer )

            $optionsBuffer = $Host.UI.RawUI.NewBufferCellArray(

                @( $optionStrings ),

                $script:ForegroundColor, $script:BackgroundColor )

            $Host.UI.RawUI.SetBufferContents( $state.OptionsPosition, $optionsBuffer )

        }

        function Set-SelectionColors( $state, $foregroundColor, $backgroundColor )

        {

            $position = $state.OptionsPosition

            $position.Y += $state.SelectedIndex - $state.Offset

            $rectangle = New-Object System.Management.Automation.Host.Rectangle `

                $position.X, $position.Y, ( $position.X + $state.Width - 1 ), $position.Y

            $optionBuffer = $Host.UI.RawUI.GetBufferContents( $rectangle )

            $contents = @( [string]::Join( "", 

                ( $optionBuffer | ForEach-Object { $_.Character } ) ) )

            $optionBuffer = $Host.UI.RawUI.NewBufferCellArray( 

                $contents, 

                $foregroundColor, 

                $backgroundColor )

            $Host.UI.RawUI.SetBufferContents( $position, $optionBuffer )

        }

    }

    end

    {

        $width = @( $options | Foreach-Object { $_.String } |

            Sort-Object Length -Descending )[ 0 ].Length + 4

        $width = [Math]::Max( 

            $width,    

            ( $script:StatusFormatString -f $options.Length, $options.Length ).Length - 2 )

        $height = $options.Length

        # create border

        $windowPosition  = $Host.UI.RawUI.WindowPosition

        $windowSize = $Host.UI.RawUI.WindowSize

        $cursorPosition = $Host.UI.RawUI.CursorPosition

        $center = [Math]::Truncate( [float]$windowSize.Height / 2 )

        $cursorOffset = $cursorPosition.Y - $windowPosition.Y

        $cursorOffsetBottom = $windowSize.Height - $cursorOffset

        $optionsBoxWidth = $width + 2

        $optionsBoxHeight = $height + 2

        $x = $cursor.X

        if ( ( $cursorOffset -gt $center ) -and ( $height -ge $cursorOffsetBottom ) )

        {

            $maxHeight = $cursorOffset

            if ( $maxHeight -lt $optionsBoxHeight )

            {

                $optionsBoxHeight = $maxHeight

            }

            $y = $cursorOffset - $optionsBoxHeight

        }

        else

        {

            $maxHeight = $cursorOffsetBottom - 1

            if ( $maxHeight -lt $optionsBoxHeight )

            {

                $optionsBoxHeight = $maxHeight

            }

            $y = $cursorOffSet + 1

        }

        $borderStrings = 1 .. ( $optionsBoxHeight ) | ForEach-Object {

            " " * ( $optionsBoxWidth + 2 )

        }

        $borderBuffer = $Host.UI.RawUI.NewBufferCellArray( 

            $borderStrings, 

            $script:BorderForegroundColor, 

            $script:BorderBackgroundColor )

        $borderPosition = $Host.UI.RawUI.WindowPosition

        $borderPosition.X += $x

        $borderPosition.Y += $y

        $borderTop = $borderBottom = $borderPosition

        $borderBottom.X += ( $borderBuffer.GetUpperBound( 1 ) )

        $borderBottom.Y += ( $borderBuffer.GetUpperBound( 0 ) )

        $borderRectangle = 

            New-Object System.Management.Automation.Host.Rectangle $borderTop, $borderBottom

        $oldContents = $Host.UI.RawUI.GetBufferContents( $borderRectangle )

        $Host.UI.RawUI.SetBufferContents( $borderTop, $borderBuffer )

        # initialize state object

        $statusPosition = $borderPosition

        $statusPosition.X += 1

        $statusPosition.Y += $optionsBoxHeight - 1

        $optionsPosition = $borderPosition

        $optionsPosition.X += 1

        $optionsPosition.Y += 1

        $state = "" | Select-Object `

            @{ Name = "Options"; Expression = { ,$options } },

            @{ Name = "SelectedIndex"; Expression = { 0 } },

            @{ Name = "Offset"; Expression = { 0 } },

            @{ Name = "StatusPosition"; Expression = { $statusPosition } },

            @{ Name = "OptionsPosition"; Expression = { $optionsPosition } },

            @{ Name = "Width"; Expression = { $optionsBoxWidth } },

            @{ Name = "Height"; Expression = { $optionsBoxHeight } },

            @{ Name = "MaxOptions"; Expression = { $maxHeight - 3 } },

            @{ Name = "SelectedOptions"; Expression = { 0 } },

            @{ Name = "TotalOptions"; Expression = { $options.Length } }

        Draw-Options $state

        Set-SelectionColors `

            $state `

            $script:SelectedForegroundColor `

            $script:SelectedBackgroundColor

        $message = ""

        do

        {

            $finished = Get-KeyboardInput $state

        }

        while ( -not $finished )

        $Host.UI.RawUI.SetBufferContents( $borderTop, $oldContents )

   }

}

Now, when I do a code review and I don't want to show every file, I run this command, which allows me to select only the files I want (I used aliases in this example to make the command shorter):

Google Account API

2009-11-05T13:07:00.001-08:00

This post isn't directly related to PowerShell, but I figured it is better to put it here than nowhere at all. I was looking at my Send-Email and Send-SMS cmdlets the other day, and I figured that the ability to send email or SMS through Gmail and Google Voice might be useful in environments other than PowerShell.

I created a C# class library that provides an API for sending an email through Gmail or an SMS through Google Voice. I added to it a very simple class for dealing with Google Contacts. Google's Contacts API is much more powerful, but I didn't want to add a dependency to my project. This is also partly inspired by my genius little brother, who has developed some similar APIs for Python.

All of the classes in this library use a custom HttpRequester class to make their requests to Google's services. This class keeps track of cookies between requests, handles redirection, and also provides a method for determining the MIME type of a file.

The Gmail class provides a simple way to create an email message and sent it, with full attachment support. Here is the updated code from my Send-Email cmdlet, which, as you can see, is much simpler than the old code:

private void SendGmailMessage()
{
    IntPtr bstr = Marshal.SecureStringToBSTR( googlePassword );
    string plainGooglePassword = Marshal.PtrToStringAuto( bstr );
    Marshal.ZeroFreeBSTR( bstr );
 
    GoogleAccount.Gmail gmailMessage = new GoogleAccount.Gmail( googleUsername, plainGooglePassword );
 
    gmailMessage.OnStatus += new GoogleAccount.Gmail.StatusEventHandler( HandleGmailStatus );
    gmailMessage.OnError += new GoogleAccount.Gmail.ErrorEventHandler( HandleGmailError );
 
    foreach ( string recipient in toArray )
    {
        gmailMessage.To.Add( recipient );
    }
 
    foreach ( string recipient in ccArray )
    {
        gmailMessage.Cc.Add( recipient );
    }
 
    foreach ( string recipient in bccArray )
    {
        gmailMessage.Bcc.Add( recipient );
    }
 
    if ( !string.IsNullOrEmpty( subject ) )
    {
        gmailMessage.Subject = subject;
    }
 
    if ( !string.IsNullOrEmpty( body ) )
    {
        gmailMessage.Body = body;
    }
 
    gmailMessage.BodyIsHtml = bodyIsHtml.IsPresent;
    gmailMessage.Timeout = timeout;
 
    foreach ( FileInfo attachment in inputAttachments )
    {
        gmailMessage.Attachments.Add( attachment );
    }
 
    if ( ShouldProcess( gmailMessage.Subject ) )
    {
        gmailMessage.Send();
    }
}

You might notice the OnStatus and OnError event handlers being set up at the beginning of the function. These are used to report errors and status messages during the several requests necessary to send an email. These handlers are used by the Send-Email cmdlet to provide proper support for the -Verbose parameter.

The SMS class is used in a very similar way. This is how I use it in my Send-SMS cmdlet:

protected override void EndProcessing()
{
    IntPtr bstr = Marshal.SecureStringToBSTR( googlePassword );
    string plainGooglePassword = Marshal.PtrToStringAuto( bstr );
    Marshal.ZeroFreeBSTR( bstr );
 
    GoogleAccount.SMS sms = new GoogleAccount.SMS( googleUsername, plainGooglePassword );
 
    sms.OnStatus += new GoogleAccount.SMS.StatusEventHandler( HandleGoogleVoiceStatus );
    sms.OnError += new GoogleAccount.SMS.ErrorEventHandler( HandleGoogleVoiceError );
 
    sms.Number = this.number;
    sms.Text = this.text;
 
    if ( ShouldProcess( sms.Text ) )
    {
        sms.Send();
    }
}

The Contacts class provides read-only access to each of your Google contacts through a Contact class that has fields for first name, last name, email address, mobile phone, and groups. I create this list by downloading a CSV file and parsing it. Yes, I know I shouldn't parse the CSV data myself, but .NET doesn't have a built-in CSV parser, and I didn't want to add a dependency to a 3rd-party library. It seems to work just fine for its simple purpose.

I wrote a small application to test the Contacts and SMS classes. It is called Mass SMS, and it allows you to choose several contacts to send one SMS message to, a service not provided on the Google Voice site. Here's how it works. First, you log in using your Google username and password:

A pretty self-explanatory dialog for choosing contacts is then displayed. This dialog allows you to filter your contacts by group, such as Family:

Once you have selected the contacts you want to receive your SMS, a dialog is displayed that allows you to specify the message:

The final dialog displays the status of each message as it is being sent:

Pretty simple, but it gets the job done. It was a fun little project to put together, and maybe I will actually use it someday! If you think you might be able to use it, please feel free.

Google Account API binary

Google Account API source

Mass SMS project

PowerShell and Google Voice

2009-07-17T14:30:00.001-07:00

After a long wait, I finally got my invitation to Google Voice this week. I haven't completely converted to it, but it looks very useful. My brother got his Google Voice number about a week earlier, and he posted a Python script on his blog that sends an SMS using his account.

I decided to create a PowerShell Cmdlet that does the same thing. It is mostly just a translation of my brother's script, but it includes code from my Send-Email Cmdlet that uses a Gmail account.

Here is the code:

using System;
using System.Text;
using System.Management.Automation;
using System.Net;
using System.IO;
using System.Web;
using System.Text.RegularExpressions;
using System.Runtime.InteropServices;
using System.Security;
 
namespace CustomCmdlets
{
    [Cmdlet( VerbsCommunications.Send, "SMS", SupportsShouldProcess = true )]
    public class SendSMS : PSCmdlet
    {
        private const string GOOGLE_VOICE_ADDRESS = "https://www.google.com/voice/";
        private const string GOOGLE_VOICE_AUTHENTICATION_ADDRESS = "https://www.google.com/accounts/ServiceLoginAuth";
        private const string GOOGLE_VOICE_SMS_ADDRESS = "https://www.google.com/voice/sms/send/";
        private CookieCollection cookieCollection;
 
        #region Parameters
 
        private string googleUsername;
 
        [ValidateNotNullOrEmpty]
        public string GoogleUsername
        {
            get
            {
                return googleUsername;
            }
            set
            {
                googleUsername = value;
            }
        }
 
        private SecureString googlePassword;
 
        [ValidateNotNullOrEmpty]
        public SecureString GooglePassword
        {
            get
            {
                return googlePassword;
            }
            set
            {
                googlePassword = value;
            }
        }
 
        private string number;
 
        [Parameter( Position = 0, Mandatory = true )]
        [ValidateNotNullOrEmpty]
        public string Number
        {
            get
            {
                return number;
            }
            set
            {
                number = value;
            }
        }
 
        private string text;
 
        [Parameter( Position = 1, Mandatory = true )]
        public string Text
        {
            get
            {
                return text;
            }
            set
            {
                text = value;
            }
        }
 
        #endregion
 
        protected override void BeginProcessing()
        {
            if ( googleUsername == null )
            {
                googleUsername = (string)GetVariableValue( "GoogleUsername", null );
            }
 
            if ( googlePassword == null )
            {
                googlePassword = (SecureString)GetVariableValue( "GooglePassword", null );
            }
 
            if ( string.IsNullOrEmpty( googleUsername ) || googlePassword == null )
            {
                this.WriteError( new ErrorRecord(
                    new Exception( "You must provide a username and password." ),
                    "Send-SMS", ErrorCategory.PermissionDenied, this ) );
            }
        }
 
        protected override void EndProcessing()
        {
            IntPtr bstr = Marshal.SecureStringToBSTR( googlePassword );
            string plainGmailPassword = Marshal.PtrToStringAuto( bstr );
            Marshal.ZeroFreeBSTR( bstr );
 
            string postDataString = "&continue=" + HttpUtility.UrlEncode( GOOGLE_VOICE_ADDRESS ) +
                                    "&Email=" + HttpUtility.UrlEncode( googleUsername ) +
                                    "&Passwd=" + HttpUtility.UrlEncode( plainGmailPassword );
 
            this.cookieCollection = new CookieCollection();
 
            this.WriteVerbose( "Sending Google Voice login request..." );
 
            MakeHttpWebRequest( GOOGLE_VOICE_AUTHENTICATION_ADDRESS, true, Encoding.UTF8.GetBytes( postDataString ) );
 
            // if we don't have this cookie, something went wrong
            if ( this.cookieCollection[ "GAUSR" ] == null )
            {
                this.WriteError( new ErrorRecord(
                    new Exception( "Could not log in to Gmail.  Please check your username and password." ),
                    "Send-SMS", ErrorCategory.PermissionDenied, this ) );
            }
            else
            {
                this.WriteVerbose( "Sending Google Voice home page request..." );
 
                string googleVoiceHomePage = MakeHttpWebRequest( GOOGLE_VOICE_ADDRESS, false, null );
 
                Match rnrSeMatch = Regex.Match( googleVoiceHomePage, @"name=""_rnr_se"".*?value=""(?<Value>[^""]+)""" );
 
                if ( rnrSeMatch.Success )
                {
                    postDataString = "&_rnr_se=" + HttpUtility.UrlEncode( rnrSeMatch.Groups[ "Value" ].Value ) +
                                     "&phoneNumber=" + HttpUtility.UrlEncode( number ) +
                                     "&text=" + HttpUtility.UrlEncode( text );
 
                    this.WriteVerbose( "Sending Google Voice SMS request..." );
 
                    string sendResult = MakeHttpWebRequest( GOOGLE_VOICE_SMS_ADDRESS, true, Encoding.UTF8.GetBytes( postDataString ) );
 
                    Match resultMatch = Regex.Match( sendResult, @"\{""ok"":(?<Success>[^,]+),""data"":\{""code"":(?<Code>\d+)\}\}" );
 
                    if ( resultMatch.Success )
                    {
                        if ( bool.Parse( resultMatch.Groups[ "Success" ].Value ) )
                        {
                            this.WriteObject( "Your SMS has been sent." );
                        }
                        else
                        {
                            this.WriteError( new ErrorRecord(
                                new Exception( "Your SMS was not sent." ),
                                "Send-SMS", ErrorCategory.NotSpecified, this ) );
                        }
                    }
                }
            }
        }
 
        private string MakeHttpWebRequest( string requestUrl, bool post, byte[] postData )
        {
            HttpWebRequest webRequest = (HttpWebRequest)WebRequest.Create( new Uri( requestUrl ) );
 
            // we need to do this ourselves
            webRequest.AllowAutoRedirect = false;
            webRequest.KeepAlive = false;
            webRequest.Credentials = CredentialCache.DefaultNetworkCredentials;
 
            webRequest.CookieContainer = new CookieContainer();
            webRequest.CookieContainer.Add( this.cookieCollection );
 
            if ( post )
            {
                webRequest.Method = "POST";
                webRequest.ContentType = "application/x-www-form-urlencoded";
 
                webRequest.ContentLength = postData.Length;
 
                Stream requestStream = null;
 
                try
                {
                    requestStream = webRequest.GetRequestStream();
                    requestStream.Write( postData, 0, postData.Length );
                }
                catch ( Exception ex )
                {
                    this.WriteError( new ErrorRecord( ex, "Send-SMS", ErrorCategory.InvalidData, this ) );
                }
                finally
                {
                    if ( requestStream != null )
                    {
                        requestStream.Close();
                    }
                }
            }
            else
            {
                webRequest.Method = "GET";
                webRequest.ContentType = "text/html";
            }
 
            HttpWebResponse webResponse = null;
            string responseString = "";
 
            try
            {
                webResponse = (HttpWebResponse)webRequest.GetResponse();
 
                cookieCollection.Add( webResponse.Cookies );
 
                StreamReader streamReader = new StreamReader( webResponse.GetResponseStream() );
 
                responseString = streamReader.ReadToEnd();
 
                streamReader.Close();
 
                // redirect if we have a Location header
                if ( webResponse.Headers[ "Location" ] != null )
                {
                    responseString = MakeHttpWebRequest( webResponse.Headers[ "Location" ], false, null );
                }
            }
            catch ( Exception ex )
            {
                this.WriteError( new ErrorRecord( ex, "Send-SMS", ErrorCategory.InvalidResult, this ) );
            }
            finally
            {
                if ( webResponse != null )
                {
                    webResponse.Close();
                }
            }
 
            return responseString;
        }
    }
}

This Cmdlet can use the Init-Gmail PowerShell function (renamed Init-Google) I wrote for the Send-Email Cmdlet, as well as a shortcut hash I created to make sending texts easier:

function Init-Google

{

    [string]$global:GoogleUsername = Read-Host "Google username"

    [System.Security.SecureString]$global:GooglePassword = Read-Host "Google password" -AsSecureString 

}

$sms = @{ "Jeff"    = "8015551234";

          "Mindy"   = "8015552345";

          "Dad"     = "8015553456";

          "Jason"   = "8015554567";

          "Scott"   = "8015555678";

          "Nate"    = "8015556789";

          "Branden" = "8015557890" }

Using the Cmdlet is very easy:

C:\

PSH$ send-sms $sms.jeff "PowerShell + Google = Awesome."

Your SMS has been sent.

This is another one that I did just for fun, but it is already turning out to be pretty useful. I can type using a real keyboard a lot faster than I can on any phone, and not having to pull my phone out of my pocket to send a quick text to my wife is very handy.

Enjoy!

PowerShell and StackOverflow.com

2008-10-17T19:50:00.001-07:00

Not long ago, I created an account on StackOverflow.com, Jeff Attwood and Joel Spolsky's new question and answer site for programmers. Asking a good question or providing a good answer will result in the other members of the communtity responding by voting for your question or answer. Users can also vote down questions or answers they don't think are useful or correct. Each positive vote increases the user's reputation, which is used to determine how much a user is "trusted" on the site. More "trust" allows the user to have more control over what is on the site; it determines what aspects of the site they can edit, wiki-style. Currently, I only have enough reputation to edit the tags associated with a question, but it is possible for a user to have enough reputation that they can edit other user's questions and even close them.
Something that was missing from the site when I signed up was the ability to figure out where your reputation points were coming from. If you had several questions or answers, it was hard to keep track of which ones were contributing to your reputation score. Another user of the site noticed this deficiency before I did, and created a Python script that will tell you what has changed with your account since the last time your ran the script. The script requires Python and SQLite. This seemed like something could be done pretty easily using PowerShell, so I put together a similar script that does pretty much the same thing:

param ( [int] $userNumber = 3950 )

[Reflection.Assembly]::LoadWithPartialName( "System.Web" ) | Out-Null

$webClient = New-Object Net.WebClient

$profile = $webClient.DownloadString( 

    "http://stackoverflow.com/users/$userNumber/myProfile.html" )

$userRegex = 'User (?<User>.*?) - Stack Overflow'

$user = [regex]::Match( $profile, $userRegex ).Groups[ "User" ].Value

$reputationRegex = '<div[^>]+class="summarycount">' + 

                   '[^\d]+(?<Reputation>[,\d]+)</div>' + 

                   '[^<]*<div[^>]+>Reputation'

$reputation = [regex]::Match( 

    $profile, $reputationRegex ).Groups[ "Reputation" ].Value -replace ","

$badgeRegex = '<div[^>]+class="summarycount"[^>]*>' + 

              '[^\d]+(?<Badges>\d+)</div>[^<]*</td>' + 

              '[^<]*<td[^>]*>[^<]*<h1[^>]*>Badges'

$badges = [regex]::Match( 

    $profile, $badgeRegex ).Groups[ "Badges" ].Value -replace ","

$profileXmlPath = Join-Path ( Get-Location ) "Profile_$userNumber.xml"

if ( !( Test-Path $profileXmlPath ) )

{

    Out-File -FilePath $profileXmlPath -InputObject @"

<Profile>

  <User>$user</User>

  <Reputation>$reputation</Reputation>

  <Badges>$badges</Badges>

  <Questions />

</Profile>    

"@

}

[xml]$profileXml = Get-Content $profileXmlPath

$existingQuestions = $profileXml.Profile.Questions.Clone()

if ( $profileXml.Profile[ "Questions" ].Question )

{

    $profileXml.Profile.Questions.RemoveAll()

}

function Process-Questions( [string] $questionRegex, [string] $questionType )

{

    $questionChangeHash = @{}

    foreach ( $questionMatch in [regex]::Matches( 

        $profile, $questionRegex, 'SingleLine' ) )

    {

        $id = $questionMatch.Groups[ "ID" ].Value

        $question = $questionMatch.Groups[ "Question" ].Value

        $votes = $questionMatch.Groups[ "Votes" ].Value

        $questionNode = $existingQuestions.Question | 

            Where-Object { $_.ID -eq $id }

        if ( $questionNode )

        {

            if ( [int]$votes -gt $questionNode.Votes )

            {

                $questionChangeHash[ $id ] = 

                    "+$( [int]$votes - $questionNode.Votes )"

            }

            elseif ( [int]$votes -lt $questionNode.Votes )

            {

                $questionChangeHash[ $id ] = [int]$votes - $questionNode.Votes

            }

            $questionNode.Votes = $votes

            $profileXml.Profile[ "Questions" ].AppendChild( 

                $questionNode ) | Out-Null

        }

        else

        {

            & {

                $script:questionNode = $profileXml.CreateElement( "Question" )

                $script:questionNode.AppendChild( 

                    $profileXml.CreateElement( "ID" ) )

                $script:questionNode.ID = $id

                $script:questionNode.AppendChild( 

                    $profileXml.CreateElement( "Type" ) )

                $script:questionNode.Type = $questionType

                $script:questionNode.AppendChild( 

                    $profileXml.CreateElement( "Question" ) )

                $script:questionNode.Question = $question

                $script:questionNode.AppendChild( 

                    $profileXml.CreateElement( "Votes" ) )

                $script:questionNode.Votes = $votes

                $profileXml.Profile[ "Questions" ].AppendChild( 

                    $script:questionNode )

            } | Out-Null

            $questionChangeHash[ $id ] = "(New)"

        }

    }

    $screenWidth = $Host.UI.RawUI.WindowSize.Width

    $elipsis = "..."

    if ( $questionChangeHash.Keys.Count -gt 0 )

    {

        $profileXml.Profile.Questions.Question | 

            Where-Object { $_.Type -eq $questionType } | 

            Select-Object `

                @{ Name = "$( $questionType )s"; 

                   Expression = {

                      $question = 

                        [System.Web.HttpUtility]::HtmlDecode( $_.Question ) 

                      $questionMaxLength = 

                        $screenWidth - ( " Votes Change ".Length )

                      if ( $question.Length -gt $questionMaxLength )

                      {

                          $question = "{0}$elipsis" -f 

                              $question.SubString( 

                                0, $questionMaxLength - $elipsis.Length ) 

                      }

                      $question

                   } 

                }, 

                Votes, 

                @{ Name = "Change"; 

                   Expression = {

                       $questionChangeHash[ $_.ID ] 

                   } 

                } | Format-Table -AutoSize

    }

    else

    {

        $profileXml.Profile.Questions.Question | 

            Where-Object { $_.Type -eq $questionType } | 

            Select-Object `

                @{ Name = "$( $questionType )s"; 

                   Expression = { 

                      $question = 

                        [System.Web.HttpUtility]::HtmlDecode( $_.Question ) 

                      $questionMaxLength = 

                        $screenWidth - ( " Votes ".Length )

                      if ( $question.Length -gt $questionMaxLength )

                      {

                          $question = "{0}$elipsis" -f 

                              $question.SubString( 

                                0, $questionMaxLength - $elipsis.Length ) 

                      }

                      $question

                   } 

                }, 

                Votes | Format-Table -AutoSize

    }    

}

$questionRegex = '<div class="question-summary narrow"[^>]+>' + 

                 '.*?<div class="mini-counts">(?<Votes>[\d,-]+).*?' + 

                 '<div class="summary">[^<]*<h3>[^<]*' + 

                 '<a\s*href="/questions/(?<ID>\d+)[^>]+>(?<Question>[^<]+)'

Process-Questions $questionRegex "Question"

$answerRegex = '<div class="answer-summary">' + 

               '<a[^>]+><div class="answer-votes[^>]+>(?<Votes>[\d,-]+)' +

               '</div></a><div class="answer-link">' + 

               '<a\s*href="/questions/(?<ID>\d+)[^>]+>(?<Question>[^<]+)'

Process-Questions $answerRegex "Answer"

$reputationChange = ""

$badgeChange = ""

if ( [int]$reputation -gt $profileXml.Profile.Reputation )

{

    $reputationChange = 

        "+$( [int]$reputation - $profileXml.Profile.Reputation )"

}

elseif ( [int]$reputation -lt $profileXml.Profile.Reputation )

{

    $reputationChange = $reputation - $profileXml.Profile.Reputation

}

if ( [int]$badges -gt $profileXml.Profile.Badges )

{

    $badgeChange = "+$( [int]$badges - $profileXml.Profile.Badges )"

}

elseif ( [int]$badges -lt $profileXml.Profile.Badges )

{

    $badgeChange = [int]$badges - $profileXml.Profile.Badges

}

$profileXml.Profile.User = $user

$profileXml.Profile.Reputation = $reputation

$profileXml.Profile.Badges = $badges

$profileXml.Profile | 

    Select-Object User,

                  @{ Name = "Reputation"; 

                     Expression = {

                         if ( $reputationChange )

                         {

                             "{0} ({1})" -f 

                                $_.Reputation, $reputationChange 

                         }

                         else

                         {

                             $_.Reputation

                         }

                     } 

                  },

                  @{ Name = "Badges"; 

                     Expression = {

                         if ( $badgeChange )

                         {

                             "{0} ({1})" -f $_.Badges, $badgeChange 

                         }

                         else

                         {

                             $_.Badges

                         }

                     } 

                  } | Format-List

$profileXml.Save( $profileXmlPath )

The results are displayed in the typical PowerShell way:

PSH$ .\Get-StackOverflowReputation.ps1 3950

Answers                                                                                       Votes

-------                                                                                       -----

What is the one programming skill you have always wanted to master but haven't had time?      30

Is there a meaningful correlation between spelling and programming ability?                   6

Factorial Algorithms in different languages                                                   6

Modal popups - usability                                                                      6

How can I uninstall an application using PowerShell?                                          5

Function pointers in C - address operator "unnecessary"                                       5

Getting developers fired up about development                                                 5

Rule you know you should follow but don't                                                     4

"Hidden Secrets" of the Visual Studio .NET debugger?                                          4

C++ Restrict Template Function                                                                4

Should a novice programmer spend time learning to write "desktop" applications these days,... 4

Parsing a log file with regular expressions                                                   3

Shortcut for commenting CSS in VS 2008                                                        3

How do I perform string operations on variables in a for loop?                                2

Expose an event handler to VBScript users of my COM object                                    2

Where do "pure virtual function call" crashes come from?                                      2

Why do C# and VB have Generics? What benefit do they provide? Generics, FTW                   2

regular expression to replace two (or more) consecutive characters by only one?               2

Anyone using a third-party Windows registry editor that they would recommend to others?       2

Transparent form on the desktop                                                               1

Test if a Font is installed                                                                   1

Using what I've learned from stackoverflow. (HTML Scraper)                                    1

How to detect the presence of a default recording device in the system?                       1

How do I add Debug Breakpoints to lines displayed in a "Find Results" window in Visual Studio 0

Regex Question - One or more spaces outside of a quote enclosed block of text                 0

User       : Jeff Hillman

Reputation : 790

Badges     : 9

StackOverflow.com has recently added a feature on the user account page that provides some information about how the user's reputation has changed, but it still doesn't give you the detail that these scripts provide.

This is just another example to me of how easy PowerShell can make tasks like this. This isn't likely to be useful for a long time, but it was fun. PowerShell is fun.