{"id":51783,"date":"2009-12-16T00:01:00","date_gmt":"2009-12-16T00:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2009\/12\/16\/hey-scripting-guy-can-i-use-windows-powershell-to-create-a-new-outlook-inbox-rule\/"},"modified":"2009-12-16T00:01:00","modified_gmt":"2009-12-16T00:01:00","slug":"hey-scripting-guy-can-i-use-windows-powershell-to-create-a-new-outlook-inbox-rule","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/hey-scripting-guy-can-i-use-windows-powershell-to-create-a-new-outlook-inbox-rule\/","title":{"rendered":"Hey, Scripting Guy! Can I Use Windows PowerShell to Create a New Outlook Inbox Rule?"},"content":{"rendered":"

\"Bookmark<\/a><\/p>\n

 <\/p>\n

\"Hey,<\/font><\/p>\n

Hey Scripting Guy! I would absolutely love to see a Windows PowerShell script that would create a new inbox rule in Microsoft Outlook. I have looked all over the Internet and have come up blank. I have asked friends, and people at work and no one seems to know how to do this. I am not sure it can actually be accomplished, but I figure if anyone can do it, you can! By the way, I loved your article about creating folders in Outlook and thought it was incredibly helpful. That is what gave me the idea to write. If you don’t take requests, I completely understand. You must get thousands. <\/p>\n

— PC<\/p>\n

 <\/p>\n

\"Hey, Hello PC, <\/p>\n

Microsoft Scripting Guy Ed Wilson here. It is a wonderful day—and it will only get better. I am getting ready to go on holiday for 10 days. I have only one meeting today, and I have had time to answer a few vital e-mails and create my out of office (OOF) reply. Because it is such a great day, I took the time to write a pretty cool script for my OOF. It is called Start-Vacation.ps1 and is seen here. (You therefore get two scripts for the price of one today, an amazing holiday bargain.) <\/p>\n

Start-Vacation.ps1<\/strong><\/p>\n

Function Start-Vacation
{
 <\/span>Param($user,$start, $stop, $contact)
 <\/span>$oof = New-Object psobject
 <\/span>$oof | Add-Member -MemberType noteProperty -Name userName -Value $user
 <\/span>$oof | Add-Member -MemberType noteProperty -Name startdate -Value $start
 <\/span>$oof | Add-Member -MemberType noteProperty -Name enddate -Value $stop
 <\/span>$oof | Add-Member -MemberType noteProperty -Name ScriptCenterContact -Value $contact
 <\/span>$oof | Add-Member -MemberType noteProperty -Name Email -Value $false
 <\/span>$oof | Add-Member -MemberType noteProperty -Name Phone -Value $false
 <\/span>$oof | Add-Member -MemberType noteProperty -Name FaceBook -Value $false
 <\/span>$oof | Add-Member -MemberType noteProperty -Name Twitter -Value $false
 <\/span>$oof
} #end function Start-Vacation<\/p>\n

# *** start script ***<\/p>\n

$oof = Start-vacation -user “EdWilson” -start “12\/5\/2009” -stop “12\/15\/2009” `
     <\/span>-contact “CraigLiebendorfer”
“Microsoft Scripting Guy Ed Wilson is on vacation …”
$oof<\/font><\/p>\n

I have a function called Start-Vacation<\/b> that accepts four input parameters: the user name, start dates, stop dates, and the person to contact while I am away. Inside the Start-Vacation<\/b> function, I create a custom psobject<\/b> and add several noteProperties<\/b> to the object. The last thing I do in the function is return the custom object to the calling script. The script itself begins by calling the Start-Vacation<\/b> function, passing the appropriate parameters, and capturing the custom psobject<\/b> in the $oof<\/b> variable. The script then displays that object. The results from running the script are shown here:<\/p>\n

Microsoft Scripting Guy Ed Wilson is on vacation …<\/p>\n


userName            <\/span>: EdWilson
startdate           <\/span>: 12\/5\/2009
enddate             <\/span>: 12\/15\/2009
ScriptCenterContact : CraigLiebendorfer
Email               <\/span>: False
Phone               <\/span>: False
FaceBook            <\/span>: False
Twitter             <\/span>: False<\/font><\/p>\n

PC, a wonderful day does not automatically happen. My wonderful day actually started three days ago when I wrote the CreateOutLookRule.ps1 in answer to your question about creating Outlook rules via script. Unfortunately, when I ran the CreateOutlookRule.ps1 script on my laptop, it did not work. It kept giving me a type mismatch error when it attempted to add the rule. Therefore, I tested, revised, retested, and was getting nowhere. Finally, I caught Stephanie who is a PFE in Florida on Office Communicator and asked her to look at the script. I also sent the script to James who is a test engineer on the Windows PowerShell team in Redmond, and to George who is a PFE in Quebec. Everyone said, “Bummer it does not work” except for George who said, “Cool, it works great.” He then asked me if I was running the beta of Outlook 2010. “Of course I am,” I said. “Aren’t you?” As it turns out, he is running Office 2007 on his laptop, and the script worked perfectly. <\/p>\n

I then built an Exchange 2010 server and a client workstation running Windows 7 and Office 2007 to test his findings. As it turns out, the script does work perfectly. I then filed a bug with the Microsoft Office team. <\/p>\n

James, the consummate professional, also tested an additional scenario—Outlook 2007 with Project 2010 installed. That scenario also fails, so it seems if you have any beta Office 2010 product installed, the script will fail. Hopefully, the automation bug will get fixed before the final release because the CreateOutlookRule.ps1 script really is cool. <\/p>\n

PC, the complete CreateOutlookRule.ps1 script is seen here. <\/p>\n

CreateOutLookRule.ps1<\/strong><\/p>\n

#Requires -version 2.0
Add-Type -AssemblyName microsoft.office.interop.outlook
$olFolders = “Microsoft.Office.Interop.Outlook.OlDefaultFolders” -as [type]
$olRuleType = “Microsoft.Office.Interop.Outlook.OlRuleType” -as [type]
$outlook = New-Object -ComObject outlook.application
$namespace  <\/span>= $Outlook.GetNameSpace(“mapi”)
$inbox = $namespace.getDefaultFolder($olFolders::olFolderInbox)
$MoveTarget = $inbox.Folders.item(“FromBob”)
$rules = $outlook.session.DefaultStore.GetRules()
$rule = $rules.Create(“MyNewRule”,$olRuleType::OlRuleReceive)
$FromCondition = $rule.Conditions.From
$FromCondition.Enabled = $true
$FromCondition.Recipients.Add(“bob”)
$fromCondition.Recipients.ResolveAll()
$MoveRuleAction = $rule.actions.MoveToFolder
$MoveRuleAction.Folder = $Movetarget
$MoveRuleAction.Enabled = $true
$rules.Save()<\/font><\/p>\n

The first thing the CreateOutlookRule.ps1 script does is use the Add-Type<\/b> cmdlet to load the outlook interop assembly. Next it adds the OlDefaultFolders<\/b> and the OlRuleType<\/b> type enumerations and stores them in the $olFolders<\/b> and $olRuleType<\/b> variables. For more information about working with the Add-Type<\/b> cmdlet or type enumerations, see Monday’s Hey, Scripting Guy! article<\/a>. The code that loads the interop assembly and type enumerations is seen here:<\/p>\n

#Requires –version 2.0<\/font><\/p>\n

Add-Type -AssemblyName microsoft.office.interop.outlook <\/font><\/p>\n

$olFolders = “Microsoft.Office.Interop.Outlook.OlDefaultFolders” -as [type]<\/font><\/p>\n

$olRuleType = “Microsoft.Office.Interop.Outlook.OlRuleType” -as [type]<\/font><\/p>\n

The next thing that is done in the CreateOutlookRule.ps1 script is to load the Outlook application COM object. This is accomplished by using the New-Object<\/b> cmdlet. The returned application object is stored in the $outlook<\/b> variable. The GetNameSpace<\/b> method is used from the application object to return a namespace object that is stored in the $namespace<\/b> variable. This is shown here:<\/p>\n

$outlook = New-Object -ComObject outlook.application<\/font><\/p>\n

$namespace  <\/span>= $Outlook.GetNameSpace(“mapi”)<\/font><\/p>\n

Then the GetDefaultFolder<\/b> method from the namespace<\/b> object is used to return a folder object. The olFolderInbox<\/b> enumeration value is passed to the GetDefaultFolder<\/b> method. The resulting folder object is stored in the $inbox<\/b> variable, as seen here:<\/p>\n

$inbox = $namespace.getDefaultFolder($olFolders::olFolderInbox)<\/font><\/p>\n

After you have a folder<\/b> object, the folders<\/b> property of the folder<\/b> object is used to return a folders<\/b> collection. The folders<\/b> collection contains the item<\/b> method that takes the name of an existing folder in your Outlook profile. In this example, I used the Outlook application to create a folder named FromBob<\/b> before running the script. This made sense to me because the Outlook rule I am going to create will move e-mails from a user named Bob to the FromBob<\/b> folder. The reference to the FromBob<\/b> folder object is stored in the $MoveTarget<\/b> variable, as shown here:<\/p>\n

$MoveTarget = $inbox.Folders.item(“FromBob”)<\/font><\/p>\n

To create a new rule in Microsoft Outlook, you need to first obtain a rules<\/b> object. The easiest way to obtain a rules<\/b> object is to use the GetRules<\/b> method from a store<\/b> object. To obtain the store<\/b> object, use the DefaultStore<\/b> property from a session<\/b> object. The session<\/b> object is obtained from the Session<\/b> property of the Outlook Application<\/b> object. The rules<\/b> object is stored in the $rules<\/b> variable, as shown here:<\/p>\n

$rules = $outlook.session.DefaultStore.GetRules()<\/font><\/p>\n

After you have a rules object, you can use the Create<\/b> method to create a new rule. The Create<\/b> method requires two parameters: the first is a string that represents the name of the new rule, and the second parameter is the type of rule to create. For the CreateOutLookRule.ps1 script, I am creating a rule that is appliedwhen a new e-mail is received; therefore, I use the OlRuleReceive<\/b> enumeration from the OlRuleType<\/b> enumeration. There are many other types of rules that can be created by using a different enumeration value for this parameter. Store the new rule object that is created by the Create<\/b> method in the $rule<\/b> variable, as shown here:<\/p>\n

$rule = $rules.Create(“MyNewRule”,$olRuleType::OlRuleReceive)<\/font><\/p>\n

Now it is time to fill out the parameters for the new rule. These correspond to the parameters you can supply from the Rules and Alerts wizard that is available in Outlook 2007. Because I want the rule to be triggered when an e-mail contains a specific name in the From<\/b> property, I specify the From<\/b> condition, and store the returned Condition<\/b> object in the $FromCondition<\/b> variable. The exact configuration of condition properties that are used depends on the type of Condition<\/b> object that you create. Of course, all rules will need to be enabled by setting the Enabled<\/b> property to $true<\/b>, as seen here:<\/p>\n

$FromCondition = $rule.Conditions.From<\/font><\/p>\n

$FromCondition.Enabled = $true<\/font><\/p>\n

A recipient is added and resolved by using the Add<\/b> method and the ResolveAll<\/b> method from the Recipient<\/b> object, as seen here. <\/p>\n

$FromCondition.Recipients.Add(“bob”)<\/font><\/p>\n

$fromCondition.Recipients.ResolveAll()<\/font><\/p>\n

The MoveToFolder<\/b> action object is created and stored in the $MoveRuleAction<\/b> variable. The Folder<\/b> property is used to specify the target of the Move<\/b> operation, and it receives the Folder<\/b> object stored in the $Movetarget<\/b> variable. When this is completed, the action is enabled by setting the Enabled<\/b> property equal to $true,<\/b> as shown here:<\/p>\n

$MoveRuleAction = $rule.actions.MoveToFolder<\/font><\/p>\n

$MoveRuleAction.Folder = $Movetarget<\/font><\/p>\n

$MoveRuleAction.Enabled = $true<\/font><\/p>\n

When everything has been configured properly, the newly created rule is saved by calling the Save<\/b> method from the rules<\/b> object, as shown here:<\/p>\n

$rules.Save()<\/font><\/p>\n

The newly created rule can be seen in Microsoft Outlook 2007 by clicking Rules and Alerts<\/b> in the Tools<\/b> menu. This is shown here:<\/p>\n

\"Image<\/font><\/a><\/span><\/p>\n

\n

 <\/p>\n<\/p>\n

PC that is all there is to creating an inbox rule in Outlook using Windows PowerShell. Microsoft Outlook Week will continue tomorrow. <\/p>\n

If you want to know exactly what we will be looking at tomorrow, follow us on Twitter<\/a> or Facebook<\/a>. If you have any questions, send e-mail to us at scripter@microsoft.com<\/font><\/a> or post your questions on the Official Scripting Guys Forum<\/a>. See you tomorrow. Until then, peace.<\/p>\n

\n

 <\/p>\n<\/p>\n

Ed Wilson and Craig Liebendorfer, Scripting Guys<\/p>\n

<\/span><\/b><\/p>\n

                                                                                                                                      <\/span><\/p>\n","protected":false},"excerpt":{"rendered":"

  Hey Scripting Guy! I would absolutely love to see a Windows PowerShell script that would create a new inbox rule in Microsoft Outlook. I have looked all over the Internet and have come up blank. I have asked friends, and people at work and no one seems to know how to do this. I […]<\/p>\n","protected":false},"author":595,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[212,49,3,45],"class_list":["post-51783","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-microsoft-outlook","tag-office","tag-scripting-guy","tag-windows-powershell"],"acf":[],"blog_post_summary":"

  Hey Scripting Guy! I would absolutely love to see a Windows PowerShell script that would create a new inbox rule in Microsoft Outlook. I have looked all over the Internet and have come up blank. I have asked friends, and people at work and no one seems to know how to do this. I […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/51783","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/users\/595"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=51783"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/51783\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media\/87096"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media?parent=51783"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=51783"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=51783"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}