Glen's Exchange and Office 365 Dev Blog

If you want to send a VoiceMail via EWS and have the UM controls appear in Outlook and OWA so it appears the same as it was generated from Exchange UM you need to set a number of different extended properties on an Email Message when you send it. The full list of properties is documented in the following Exchange Protocol document .

While some of these properties are optional the most important is to the set the PidTagVoiceMessageAttachmentOrder http://msdn.microsoft.com/en-us/library/ee202885%28v=exchg.80%29.aspx property which needs to be set to the name of the attachment. You also need to make sure you set the ItemClass to IPM.Note.Microsoft.Voicemail.UM.CA .

The following is a sample of sending a mp3 voicemail as a message with powershell, I've put a download of this script here .

## Get the Mailbox to Access from the 1st commandline argument
$MailboxName = $args[0]
#MessageProperties
$VoiceMailSuject = "Voice Mail from .."
$Mp3FileName = "c:\temp\vmMail.mp3"
$duration = 30
$voiceMailFrom = "FirstName LastName"
$callerId = "1234"
$jobTitle = "Tech"
$Company = "CompanyName"
$workNumber = "11111-11111"
$emailAddress = "test@domain.com"
$SipAddress = "sip:test@domain.com"
$ToAddress = "user@domain.com"
$fileInfo = Get-Item $Mp3FileName
$BodyHtml = "<html><head><META HTTP-EQUIV=`"Content-Type`" CONTENT=`"text/html; charset=us-ascii`">"
$BodyHtml += "<style type=`"text/css`"> a:link { color: #3399ff; } a:visited { color: #3366cc; } a:active { color: #ff9900; } </style>"
$BodyHtml += "</head><body><style type=`"text/css`"> a:link { color: #3399ff; } a:visited { color: #3366cc; } a:active { color: #ff9900; } </style>"
$BodyHtml += "<div style=`"font-family: Tahoma; background-color: #ffffff; color: #000000; font-size:10pt;`"><div id=`"UM-call-info`" lang=`"en`">"
$BodyHtml += "<div style=`"font-family: Arial; font-size: 10pt; color:#000066; font-weight: bold;`">You received a voice mail from " + $voiceMailFrom + " at " + $callerId + "</div>"
$BodyHtml += "<br><table border=`"0`" width=`"100%`"><tr><td width=`"12px`"></td><td width=`"28%`" nowrap=`"`" style=`"font-family: Tahoma; color: #686a6b; font-size:10pt;border-width: 0in;`">"
$BodyHtml += "Caller-Id:</td><td width=`"72%`" style=`"font-family: Tahoma; background-color: #ffffff; color: #000000; font-size:10pt;`">"
$BodyHtml += "<a style=`"color: #3399ff; `" dir=`"ltr`" href=`"tel:" + $callerId + "`">" + $callerId + "</a></td></tr><tr><td width=`"12px`"></td><td width=`"28%`" nowrap=`"`" style=`"font-family: Tahoma; color: #686a6b; font-size:10pt;border-width: 0in;`">"
$BodyHtml += "Job Title:</td><td width=`"72%`" style=`"font-family: Tahoma; background-color: #ffffff; color: #000000; font-size:10pt;`">"
$BodyHtml += $jobTitle + "</td></tr><tr><td width=`"12px`"></td><td width=`"28%`" nowrap=`"`" style=`"font-family: Tahoma; color: #686a6b; font-size:10pt;border-width: 0in;`">"
$BodyHtml += "Company:</td><td width=`"72%`" style=`"font-family: Tahoma; background-color: #ffffff; color: #000000; font-size:10pt;`">"
$BodyHtml += $Company + "</td></tr><tr><td width=`"12px`"></td><td width=`"28%`" nowrap=`"`" style=`"font-family: Tahoma; color: #686a6b; font-size:10pt;border-width: 0in;`">"
$BodyHtml += "Work:</td><td width=`"72%`" style=`"font-family: Tahoma; background-color: #ffffff; color: #000000; font-size:10pt;`">"
$BodyHtml += "<a style=`"color: #3399ff; `" dir=`"ltr`" href=`"tel:+" + $workNumber + "`">+" + $workNumber + "</a></td></tr><tr><td width=`"12px`"></td><td width=`"28%`" nowrap=`"`" style=`"font-family: Tahoma; color: #686a6b; font-size:10pt;border-width: 0in;`">"
$BodyHtml += "E-mail:</td><td width=`"72%`" style=`"font-family: Tahoma; background-color: #ffffff; color: #000000; font-size:10pt;`">"
$BodyHtml += "<a style=`"color: #3399ff; `" href=`"mailto:" + $emailAddress + "`">" + $voiceMailFrom + "</a></td></tr><tr><td width=`"12px`">"
$BodyHtml += "</td><td width=`"28%`" nowrap=`"`" style=`"font-family: Tahoma; color: #686a6b; font-size:10pt;border-width: 0in;`">IM Address:</td>"
$BodyHtml += "<td width=`"72%`" style=`"font-family: Tahoma; background-color: #ffffff; color: #000000; font-size:10pt;`">"
$BodyHtml += "<a style=`"color: #3399ff; `" href=`"" + $SipAddress + "`">" + $emailAddress + "</a></td></tr></table></div></div></body></html>"
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2010_SP2
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
$service.AutodiscoverUrl($MailboxName,{$true})
"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://192.168.0.6/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
#Extended Prop Definition
$PidTagVoiceMessageAttachmentOrder = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6805, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::String)
$PstnCallbackTelephoneNumberVal = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition([Microsoft.Exchange.WebServices.Data.DefaultExtendedPropertySet]::UnifiedMessaging,"PstnCallbackTelephoneNumber", [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::String)
$PidTagSIPAddress = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x5FE5, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::String)
$PidTagCallIdVal = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6806, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::String)
$PidTagSenderTelephoneNumber = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6802, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::String)
$PidTagVoiceMessageDuration = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6801, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer)
$PidTagVoiceMessageSenderName = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6803, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::String)
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)
$EmailMessage = New-Object Microsoft.Exchange.WebServices.Data.EmailMessage -ArgumentList $service
$EmailMessage.Subject = $VoiceMailSuject
#Add Recipients
$EmailMessage.ToRecipients.Add($ToAddress)
$EmailMessage.Body = New-Object Microsoft.Exchange.WebServices.Data.MessageBody
$EmailMessage.Body.BodyType = [Microsoft.Exchange.WebServices.Data.BodyType]::HTML
$EmailMessage.Body.Text = $BodyHtml
$EmailMessage.ItemClass = "IPM.Note.Microsoft.Voicemail.UM.CA"
$vmAttachment = $EmailMessage.Attachments.AddFileAttachment($Mp3FileName)
$vmAttachment.ContentType = "audio/mp3";
$EmailMessage.SetExtendedProperty($PidTagVoiceMessageAttachmentOrder,$fileInfo.Name)
$EmailMessage.SetExtendedProperty($PstnCallbackTelephoneNumberVal,$workNumber)
$EmailMessage.SetExtendedProperty($PidTagSIPAddress,$SipAddress)
$EmailMessage.SetExtendedProperty($PidTagCallIdVal,$callerId)
$EmailMessage.SetExtendedProperty($PidTagSenderTelephoneNumber,$workNumber)
$EmailMessage.SetExtendedProperty($PidTagVoiceMessageDuration,$duration)
$EmailMessage.SetExtendedProperty($PidTagVoiceMessageSenderName,$voiceMailFrom)
$EmailMessage.SendAndSaveCopy()

As Public Folders are now new again in Exchange 2013, I thought I'd put together a post that covered how you can go about accessing and doing certain things with Public folders via EWS and Powershell. Although the underlying way in which Public Folders are now delivered in Exchange 2013 is vastly different from previous version of Exchange the way in which you access them Programmatically in EWS hasn't changed since Exchange 2007. So if your worried about your 2007 EWS code not working against 2013 don't only some minor changes maybe needed. (although if you have WebDAV code your going to need to rewrite this).

Choosing the Right API Method for what you want to do

The big thing when your considering creating a Public Folder application is to understand and choose the correct API for what you want to do. Eg if you want to write an application that is going to manage Public Folders eg Size/creation/deletion/Mail-Enable and folders permissions then EWS or MAPI are not the correct API to use as these are client API's. For any admin style applications you should be using the Exchange Management Shell cmdlets which give you a fully functional entry point to do administration tasks and also more importantly the ability to assert Delegated Exchange Admin Rights. Which means you can manage the folder without the need to have explicit client permissions on the folders. When you using a client API like EWS or MAPI you will only be able to perform client based actions where you have rights granted on the DACL of that particular folder (or inherited client permissions from the Parent). Unlike WebDAV in 2003,2007 there is no Virtual Admin root with EWS where Delegated Admin rights can be asserted so the EMS cmdlets via Remote Powershell is the best solution for Admin Apps.

EWS Public Folder operations

There are no dedicated Public Folder operations in EWS, so everything you do is with a Subset of the existing Mailbox operations. There is a full list of EWS Operations that work with Public Folder and notes around the restriction in http://msdn.microsoft.com/en-us/library/exchange/jj945067%28v=exchg.150%29.aspx. One of the big improvements in 2013 is now the ability to use Content Indexes to query Public Folder content which includes the ability to scan Attachment content where an IFilter is available for that attachment type.

Getting the Public Folder Hierarchy

When you want to return the full folder hierarchy of a Mailbox with EWS you use a FindFolder operation where you set the FolderView to tell the server to perform a deep traversal which means that all folders and subfolder will be queried. If you had more then 1000 folders in a Mailbox you would need to make multiple request to get all the folders back paged 1000 at a time to ensure you stayed under the throttling limits. With Public Folders because Deep Traversals aren't supported in a FindFolder operation it presents a challenge to getting the Full folder hierarchy.Those people who are migrating from a MAPI application where they have used "GetHierarchyTable" in MAPI, may find EWS a little irritating as there is no easy way of quickly returning a full folder hierarchy in a short time amount of time like MAPI. However its not all bad news, one example of how to get the hierarchy is the method used in OWA in 2013 which makes use of multiple FindFolder operations to show the Public Folder tree. OWA just does an on demand query when the user clicks each client node which means there is a slight pause while the operation completes. It just means living with a slightly less responsive UI.

In Powershell if you want to get the Full Folder hierarchy you would need to do multiple shallow traversals like the following example

function ConvertToString($ipInputString){
$Val1Text = ""
for ($clInt=0;$clInt -lt $ipInputString.length;$clInt++){
$Val1Text = $Val1Text + [Convert]::ToString([Convert]::ToChar([Convert]::ToInt32($ipInputString.Substring($clInt,2),16)))
$clInt++
}
return $Val1Text
}
function GetPublicFolders{
param (
$RootFolderId = "$( throw 'FolderId is a mandatory Parameter' )"
)
process{
$RootFolderId
$folderCollection = @()
#Define Extended properties
$PR_FOLDER_TYPE = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(13825,[Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer);
#Define the FolderView used for Export should not be any larger then 1000 folders due to throttling
$fvFolderView = New-Object Microsoft.Exchange.WebServices.Data.FolderView(1000)
#Deep Transval will ensure all folders in the search path are returned
$fvFolderView.Traversal = [Microsoft.Exchange.WebServices.Data.FolderTraversal]::Shallow;
$psPropertySet = new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::FirstClassProperties)
$PR_Folder_Path = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(26293, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::String);
#Add Properties to the Property Set
$psPropertySet.Add($PR_Folder_Path);
$fvFolderView.PropertySet = $psPropertySet;
#The Search filter will exclude any Search Folders
$sfSearchFilter = new-object Microsoft.Exchange.WebServices.Data.SearchFilter+IsEqualTo($PR_FOLDER_TYPE,"1")
$fiResult = $null
do {
$fiResult = $Service.FindFolders($RootFolderId,$sfSearchFilter,$fvFolderView)
foreach($ffFolder in $fiResult.Folders){
$foldpathval = $null
$folderCollection += $ffFolder
#Try to get the FolderPath Value and then covert it to a usable String
if ($ffFolder.TryGetProperty($PR_Folder_Path,[ref] $foldpathval))
{
$binarry = [Text.Encoding]::UTF8.GetBytes($foldpathval)
$hexArr = $binarry | ForEach-Object { $_.ToString("X2") }
$hexString = $hexArr -join ''
$hexString = $hexString.Replace("FEFF", "5C00")
$fpath = ConvertToString($hexString)
}
"FolderPath : " + $fpath
if($ffFolder.ChildFolderCount -gt 0){
$Childfolders = GetPublicFolders -RootFolderId $ffFolder.Id
foreach($Childfolder in $Childfolders){
$folderCollection += $Childfolder
}
}
}
$fvFolderView.Offset += $fiResult.Folders.Count
}while($fiResult.MoreAvailable -eq $true)
return $folderCollection
}
}
$pfRoot = new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::PublicFoldersRoot)
$folderHi = GetPublicFolders -RootFolderId $pfRoot
#Example Use
foreach($fld in $folderHi){
$fld.DisplayName
}

Binding to a specific Public folder

If you want to bind to a specific public folder given a path as \FolderLevel1\Level2\Level3\Target you need to know the particular folders EWSId. There are a few ways of getting the FolderId if your using Outlook you could take the HexEntryId can get from OWA and convert that into an EWSId eg the following is an example of using the AlternatePublicFolderId to covert the HexEntryId to an EWSId

function ConvertId{
param (
$HexId = "$( throw 'HexId is a mandatory Parameter' )"
)
process{
$aiItem = New-Object Microsoft.Exchange.WebServices.Data.AlternatePublicFolderId
$aiItem.FolderId = $HexId
$aiItem.Format = [Microsoft.Exchange.WebServices.Data.IdFormat]::HexEntryId
$convertedId = $service.ConvertId($aiItem, [Microsoft.Exchange.WebServices.Data.IdFormat]::EwsId)
return $convertedId.UniqueId
}
}

The other method you can use is to search for your target Folder using multi find folder operations and by splitting the path you want to search for eg.

function FolderIdFromPath{
param (
$FolderPath = "$( throw 'Folder Path is a mandatory Parameter' )"
)
process{
## Find and Bind to Folder based on Path
#Define the path to search should be seperated with \
#Bind to the MSGFolder Root
$folderid = new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::PublicFoldersRoot)
$tfTargetFolder = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$folderid)
#Split the Search path into an array
$fldArray = $FolderPath.Split("\")
#Loop through the Split Array and do a Search for each level of folder
for ($lint = 1; $lint -lt $fldArray.Length; $lint++) {
#Perform search based on the displayname of each folder level
$fvFolderView = new-object Microsoft.Exchange.WebServices.Data.FolderView(1)
$SfSearchFilter = new-object Microsoft.Exchange.WebServices.Data.SearchFilter+IsEqualTo([Microsoft.Exchange.WebServices.Data.FolderSchema]::DisplayName,$fldArray[$lint])
$findFolderResults = $service.FindFolders($tfTargetFolder.Id,$SfSearchFilter,$fvFolderView)
if ($findFolderResults.TotalCount -gt 0){
foreach($folder in $findFolderResults.Folders){
$tfTargetFolder = $folder
}
}
else{
"Error Folder Not Found"
$tfTargetFolder = $null
break
}
}
if($tfTargetFolder -ne $null){
return $tfTargetFolder.Id.UniqueId.ToString()
}
}
}
#Example use
$fldId = FolderIdFromPath -FolderPath "\firstlevel\secondlevel\target"
$SubFolderId = new-object Microsoft.Exchange.WebServices.Data.FolderId($fldId)
$PubFolder = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$SubFolderId)
$PubFolder

Once you have bound to the Folder you can then perform any of the normal Item operations which I covered in the following post

In Part 2 I'll go into some more depth some of the harder aspects of Public Folders.

The following script is a combination of a couple of other scripts I've posted in the past, what it does is compiles statistics of the messages with and without attachments in a Mailbox and then produces a report. To do this in EWS you need to look at every Item in the mailbox, if the item has attachments it determines how large these attachments are and keeps a running tab of the largest attachment in the mailbox. In Exchange there are a number of different attachment types but EWS divides them into two distinct types, File Attachments and ItemAttachment which are basically attached Exchange Items. This script compile statistics around these two distinct types but doesn't process down to the embeeded attachment level. The results of all the requests are added together to produce a final report that reflects the attachment statistics for the entire mailbox. A picture is worth a thousand words so it produces a report like

To get the information about the Items in the Mailbox the FindItem Operation is used, however as FindItem doesn't return detailed information about attachments the LoadPropertiesForItems method is used which does a batch GetItem request on a collection of results. One thing to note is the AttachmentSize information isn't returned by EWS in Exchange 2007 so this script will only work for Exchange 2010 up.

This script will prompt for what security credentials you want to use and these creds need full access to the Mailboxes your scanning (an alternative would be to use Impersonation but that would require the script to be changed).

You need to feed the script with a CSV file like

smtpaddress
user1@domain.com
user2@domain.com

I've put a download of this script here the script itself looks like.

$Script:rptCollection = @()
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2010_SP2
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
#$service.AutodiscoverUrl($MailboxName,{$true})
#"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)
function Process-Mailbox{
param (
$SmtpAddress = "$( throw 'SMTPAddress is a mandatory Parameter' )"
)
process{
$rptObj = "" | select MailboxName,TotalItem,TotalItemSize,TotalItemsNoAttach,TotalItemsNoAttachSize,TotalItemsAttach,TotalItemsAttachSize,TotalFileAttachments,TotalFileAttachmentsSize,TotalItemAttachments,TotalItemAttachmentsSize,LargestAttachmentSize,LargestAttachmentName
$rptObj.MailboxName = $SmtpAddress
$rptObj.TotalItem = 0
$rptObj.TotalItemSize = [Int64]0
$rptObj.TotalItemsNoAttach = 0
$rptObj.TotalItemsNoAttachSize = [Int64]0
$rptObj.TotalItemsAttach = 0
$rptObj.TotalItemsAttachSize = [Int64]0
$rptObj.TotalFileAttachments = 0
$rptObj.TotalFileAttachmentsSize = [Int64]0
$rptObj.TotalItemAttachments = 0
$rptObj.TotalItemAttachmentsSize = [Int64]0
$rptObj.LargestAttachmentSize = [Int64]0
$rptObj.LargestAttachmentName = ""
"Processing Mailbox : " + $SmtpAddress
#check Anchor header for Exchange 2013/Office365
if($service.HttpHeaders.ContainsKey("X-AnchorMailbox")){
$service.HttpHeaders["X-AnchorMailbox"] = $SmtpAddress
}else{
$service.HttpHeaders.Add("X-AnchorMailbox", $SmtpAddress);
}
"AnchorMailbox : " + $service.HttpHeaders["X-AnchorMailbox"]
#Define ItemView to retrive just 1000 Items
$ivItemView = New-Object Microsoft.Exchange.WebServices.Data.ItemView(1000)
$psPropset= new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::IdOnly)
$psPropset.Add([Microsoft.Exchange.WebServices.Data.ItemSchema]::Size)
$psPropset.Add([Microsoft.Exchange.WebServices.Data.ItemSchema]::DateTimeReceived)
$psPropset.Add([Microsoft.Exchange.WebServices.Data.ItemSchema]::DateTimeCreated)
$ivItemView.PropertySet = $psPropset
$TotalSize = 0
$TotalItemCount = 0
#Define Function to convert String to FolderPath
function ConvertToString($ipInputString){
$Val1Text = ""
for ($clInt=0;$clInt -lt $ipInputString.length;$clInt++){
$Val1Text = $Val1Text + [Convert]::ToString([Convert]::ToChar([Convert]::ToInt32($ipInputString.Substring($clInt,2),16)))
$clInt++
}
return $Val1Text
}
#Define Extended properties
$PR_FOLDER_TYPE = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(13825,[Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer);
$folderidcnt = new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::MsgFolderRoot,$SmtpAddress)
#Define the FolderView used for Export should not be any larger then 1000 folders due to throttling
$fvFolderView = New-Object Microsoft.Exchange.WebServices.Data.FolderView(1000)
#Deep Transval will ensure all folders in the search path are returned
$fvFolderView.Traversal = [Microsoft.Exchange.WebServices.Data.FolderTraversal]::Deep;
$psPropertySet = new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::FirstClassProperties)
$PR_Folder_Path = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(26293, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::String);
#Add Properties to the Property Set
$psPropertySet.Add($PR_Folder_Path);
$fvFolderView.PropertySet = $psPropertySet;
#The Search filter will exclude any Search Folders
$sfSearchFilter = new-object Microsoft.Exchange.WebServices.Data.SearchFilter+IsEqualTo($PR_FOLDER_TYPE,"1")
$fiResult = $null
#The Do loop will handle any paging that is required if there are more the 1000 folders in a mailbox
do {
$fiResult = $Service.FindFolders($folderidcnt,$sfSearchFilter,$fvFolderView)
foreach($ffFolder in $fiResult.Folders){
$foldpathval = $null
#Try to get the FolderPath Value and then covert it to a usable String
if ($ffFolder.TryGetProperty($PR_Folder_Path,[ref] $foldpathval))
{
$binarry = [Text.Encoding]::UTF8.GetBytes($foldpathval)
$hexArr = $binarry | ForEach-Object { $_.ToString("X2") }
$hexString = $hexArr -join ''
$hexString = $hexString.Replace("FEFF", "5C00")
$fpath = ConvertToString($hexString)
}
$totalItemCnt = 1
if($ffFolder.TotalCount -ne $null){
$totalItemCnt = $ffFolder.TotalCount
"Processing FolderPath : " + $fpath + " Item Count " + $totalItemCnt
}
else{
"Processing FolderPath : " + $fpath
}
if($totalItemCnt -gt 0){
#Define ItemView to retrive just 1000 Items
$ivItemView = New-Object Microsoft.Exchange.WebServices.Data.ItemView(1000)
$psPropset= new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::IdOnly)
$psPropset.Add([Microsoft.Exchange.WebServices.Data.ItemSchema]::Size)
$psPropset.Add([Microsoft.Exchange.WebServices.Data.ItemSchema]::DateTimeReceived)
$psPropset.Add([Microsoft.Exchange.WebServices.Data.ItemSchema]::DateTimeCreated)
$psPropset.Add([Microsoft.Exchange.WebServices.Data.ItemSchema]::Attachments)
$psPropset.Add([Microsoft.Exchange.WebServices.Data.ItemSchema]::HasAttachments)
$fipsPropset= new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::IdOnly)
$ivItemView.PropertySet = $fipsPropset
$fiItems = $null
do{
$fiItems = $service.FindItems($ffFolder.Id,$ivItemView)
if($fiItems.Items.Count -gt 0){
[Void]$service.LoadPropertiesForItems($fiItems,$psPropset)
"processing : " + $fiItems.Items.Count + " Items"
foreach($Item in $fiItems.Items){
$rptObj.TotalItem +=1
$rptObj.TotalItemSize += [Int64]$Item.Size
if($Item.Attachments.Count -gt 0){
$rptObj.TotalItemsAttach +=1
$rptObj.TotalItemsAttachSize += [Int64]$Item.Size
foreach($Attachment in $Item.Attachments){
if($Attachment -is [Microsoft.Exchange.WebServices.Data.FileAttachment]){
$rptObj.TotalFileAttachments +=1
$rptObj.TotalFileAttachmentsSize += $Attachment.Size
$attachSize = [Math]::Round($Attachment.Size/1MB,2)
if($attachSize -gt $rptobj.LargestAttachmentSize){
$rptobj.LargestAttachmentSize = $attachSize
$rptobj.LargestAttachmentName = $Attachment.Name
}
}
else{
$rptObj.TotalItemAttachments +=1
$rptObj.TotalItemAttachmentsSize += $Attachment.Size
}
}
}
else{
$rptObj.TotalItemsNoAttach +=1
$rptObj.TotalItemsNoAttachSize += [Int64]$Item.Size
}
}
}
$ivItemView.Offset += $fiItems.Items.Count
}while($fiItems.MoreAvailable -eq $true)
}
}
$fvFolderView.Offset += $fiResult.Folders.Count
}while($fiResult.MoreAvailable -eq $true)
#convert Sizes to MB
if($rptObj.TotalItemSize -ne 0){
$rptObj.TotalItemSize = [Math]::Round($rptObj.TotalItemSize/1MB)
}
if($rptObj.TotalItemsNoAttachSize -ne 0){
$rptObj.TotalItemsNoAttachSize = [Math]::Round($rptObj.TotalItemsNoAttachSize/1MB)
}
if($rptObj.TotalItemsAttachSize -ne 0){
$rptObj.TotalItemsAttachSize = [Math]::Round($rptObj.TotalItemsAttachSize/1MB)
}
if($rptObj.TotalFileAttachmentsSize -ne 0){
$rptObj.TotalFileAttachmentsSize = [Math]::Round($rptObj.TotalFileAttachmentsSize/1MB)
}
if($rptObj.TotalItemAttachmentsSize -ne 0){
$rptObj.TotalItemAttachmentsSize = [Math]::Round($rptObj.TotalItemAttachmentsSize/1MB)
}
$Script:rptCollection += $rptObj
}
}
Import-Csv -Path $args[0] | ForEach-Object{
if($service.url -eq $null){
$service.AutodiscoverUrl($_.SmtpAddress,{$true})
"Using CAS Server : " + $Service.url
}
Try{
Process-Mailbox -SmtpAddress $_.SmtpAddress
}
catch{
LogWrite("Error processing Mailbox : " + $_.SmtpAddress + $_.Exception.Message.ToString())
}
}
$Script:rptCollection | Export-Csv -NoTypeInformation -Path c:\temp\mbAttachReport.csv

Dealing with Junk Email is kind of like doing the dishes, it's dirty work but somebodies got to do it. While Spam filters are improving we know by the constant updates these filters require its an invisible war that's always going on. Also software being what it is, things don't always go to plan like this http://support.microsoft.com/kb/2885002/en-us

So it can be good to check in on what's happening in your User's JunkEmail folders from time to time and EWS is great for doing this so.

The following EWS script scans all the messages in the JunkEmail folder of a Mailbox (or Mailboxes) and looks at the SCL value of each of the Messages which is held in the

PidTagContentFilterSpamConfidenceLevel property

And also looks at the

PidLidSpamOriginalFolder property which contains the original folder a Message was moved from, which only gets set when the Outlook Junk Email Filter takes an action on a message vs the Server Side action (where this properties doesn't get set)

This script produces a report that shows the number of message for each SCL levels, total number of messages in the JunkEmail folder and the number of Messages move just by just Outlook Filter eg.

To run the script you need to feed it with a CSV with the mailbox you want to run it against something like

SmtpAddress
user@domain.com
user2@domain.com

Then use .\sclReport.pst .\users.csv

I've put a download of the script here

The script looks like

$Script:rptCollection = @()
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2010_SP2
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $SmtpAddress)
function Process-Mailbox{
param (
$SmtpAddress = "$( throw 'SMTPAddress is a mandatory Parameter' )"
)
process{
Write-Host ("Processing Mailbox : " + $SmtpAddress)
$rptObj = "" | select MailboxName,TotalItems,MovedByOutlook,NoSCL,SCLneg1,SCL0,SCL1,SCL2,SCL3,SCL4,SCL5,SCL6,SCL7,SCL8,SCL9
$rptObj.MovedByOutlook = 0
$rptObj.NoSCL = 0
$rptObj.SCLneg1 = 0
$rptObj.SCL0 = 0
$rptObj.SCL1 = 0
$rptObj.SCL2 = 0
$rptObj.SCL3 = 0
$rptObj.SCL4 = 0
$rptObj.SCL5 = 0
$rptObj.SCL6 = 0
$rptObj.SCL7 = 0
$rptObj.SCL8 = 0
$rptObj.SCL9 = 0
# Bind to the Junk Email Folder
$folderid= new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::JunkEmail,$SmtpAddress)
$JunkEmail = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$folderid)
$rptObj.MailboxName = $SmtpAddress
$rptObj.TotalItems = $JunkEmail.TotalCount
$psPropset= new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::FirstClassProperties)
$PidTagContentFilterSpamConfidenceLevel = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x4076, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer)
$PidLidSpamOriginalFolder = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition([Microsoft.Exchange.WebServices.Data.DefaultExtendedPropertySet]::Common,0x859C, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$psPropset.Add($PidTagContentFilterSpamConfidenceLevel)
$psPropset.Add($PidLidSpamOriginalFolder)
#Define ItemView to retrive just 1000 Items
$ivItemView = New-Object Microsoft.Exchange.WebServices.Data.ItemView(1000)
$ivItemView.PropertySet = $psPropset
$fiItems = $null
do{
$fiItems = $service.FindItems($JunkEmail.Id,$ivItemView)
#[Void]$service.LoadPropertiesForItems($fiItems,$psPropset)
foreach($Item in $fiItems.Items){
$OrigFldVal = $null
if($Item.TryGetProperty($PidLidSpamOriginalFolder,[ref]$OrigFldVal)){
$rptObj.MovedByOutlook +=1
}
$SCLVal = $null;
if($Item.TryGetProperty($PidTagContentFilterSpamConfidenceLevel,[ref]$SCLVal)){
switch($SCLVal){
{$_ -lt 0}{$rptObj.SCLneg1 += 1}
0 { $rptObj.SCL0 += 1 }
1 { $rptObj.SCL1 += 1 }
2 { $rptObj.SCL2 += 1 }
3 { $rptObj.SCL3 += 1 }
4 { $rptObj.SCL4 += 1 }
5 { $rptObj.SCL5 += 1 }
6 { $rptObj.SCL6 += 1 }
7 { $rptObj.SCL7 += 1 }
8 { $rptObj.SCL8 += 1 }
9 { $rptObj.SCL9 += 1 }
}
}
else{
$rptObj.NoSCL +=1
}
}
$ivItemView.Offset += $fiItems.Items.Count
}while($fiItems.MoreAvailable -eq $true)
$Script:rptCollection += $rptObj
}
}
Import-Csv -Path $args[0] | ForEach-Object{
if($service.url -eq $null){
$service.AutodiscoverUrl($_.SmtpAddress,{$true})
"Using CAS Server : " + $Service.url
}
Try{
Process-Mailbox -SmtpAddress $_.SmtpAddress
}
catch{
LogWrite("Error processing Mailbox : " + $_.SmtpAddress + $_.Exception.Message.ToString())
}
}
$Script:rptCollection | Export-Csv -NoTypeInformation -Path c:\temp\sclReport.csv

Sometimes when your writing an Automation script you might want to parse a certain URL from the Body of a Message. One example would be the Lync Meeting URL from an Online Meeting invitation or another might but a DropBox URL for a shared file.

To grab the Body of a Message in the EWS Managed API you need to use either Load() or LoadPropertiesForItems() if you have a number of messages your processing. Using these methods will do a GetItem (or batch GetItem) in EWS.

To parse the URL's from the HTML body markup that EWS returns you can use some RegEx to separate out all the links. Then you can use the URI class from .net to parse the matches further and identify the hosts in the URL to see if its the URL your looking for. The following sample will loop through the last 100 emails in a mailbox's and parse any Lync Meeting URL's (for Office365) or Dropbox URL's.

I've put a download of this script here

The code looks like

## Get the Mailbox to Access from the 1st commandline argument
$MailboxName = $args[0]
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2010_SP2
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
$service.AutodiscoverUrl($MailboxName,{$true})
"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
$psPropset= new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::FirstClassProperties)
# Bind to the Inbox Folder
$folderid= new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::Inbox,$MailboxName)
$Inbox = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$folderid)
#Define ItemView to retrive just 1000 Items
$ivItemView = New-Object Microsoft.Exchange.WebServices.Data.ItemView(100)
$fiItems = $service.FindItems($Inbox.Id,$ivItemView)
[Void]$service.LoadPropertiesForItems($fiItems,$psPropset)
foreach($Item in $fiItems.Items){
#Process Item
"Processing : " + $Item.Subject
$dupChk = @{}
$RegExHtmlLinks = "<a href=\`"(.*?)\`">"
$matchedItems = [regex]::matches($Item.Body, $RegExHtmlLinks,[system.Text.RegularExpressions.RegexOptions]::Singleline)
foreach($Match in $matchedItems){
$SplitVal = $Match.Value.Split('"')
if($SplitVal.Count -gt 0){
$ParsedURI=[system.URI]$SplitVal[1]
if($ParsedURI.Host -eq "meet.lync.com"){
if(!$dupChk.Contains($ParsedURI.AbsoluteUri)){
Write-Host -ForegroundColor Green "LyncURL : " + $ParsedURI.AbsoluteUri
$dupChk.add($ParsedURI.AbsoluteUri,0)
}
}
if($ParsedURI.Host -eq "www.dropbox.com"){
if(!$dupChk.Contains($ParsedURI.AbsoluteUri)){
Write-Host -ForegroundColor Blue "DropBox : " + $ParsedURI.AbsoluteUri
$dupChk.add($ParsedURI.AbsoluteUri,0)
}
}
}
}
}

The following script creates a CSV export of Automatically generated contacts that have been saved in any of the 3 following auto contact locations

Suggested Contacts Folder which is Outlook feature that automatically creates a Contact for each address you send an email to - http://office.microsoft.com/en-au/outlook-help/automatically-add-contacts-for-everyone-that-you-send-an-email-message-HA101874367.aspx

OWA Autocomplete Cache - This is OWA version of the NickName cache, its stored in a UserConfiguration object in the Root of the Mailbox. The Addresses are stored inside an XML Streaming Property.

Recipeints Cache Folder - This is a new Exchange 2013 folder which is a hidden sub folder of the Contacts folder with a mailbox and it's purpose isn't really documented at the moment, but contains like the AutoComplete cache, Addresses for Sent Emails.

So this script just create a CSV file with the Source, DisplayName and Email-address of any entries from these 3 locations.

I've put a download of this script here

The code looks like

## Get the Mailbox to Access from the 1st commandline argument
$MailboxName = $args[0]
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2013
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
$service.AutodiscoverUrl($MailboxName,{$true})
"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)
$ExportCollection = @()
Write-Host "Process Recipient Cache"
$folderid= new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::RecipientCache,$MailboxName)
$RecipientCache = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$folderid)
$psPropset= new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::FirstClassProperties)
#Define ItemView to retrive just 1000 Items
$ivItemView = New-Object Microsoft.Exchange.WebServices.Data.ItemView(1000)
$fiItems = $null
do{
$fiItems = $service.FindItems($RecipientCache.Id,$ivItemView)
[Void]$service.LoadPropertiesForItems($fiItems,$psPropset)
foreach($Item in $fiItems.Items){
if($Item -is [Microsoft.Exchange.WebServices.Data.Contact]){
$expObj = "" | select Source,DisplayName,Email1DisplayName,Email1Type,Email1EmailAddress
$expObj.Source = "RecipientCache"
$expObj.DisplayName = $Item.DisplayName
if($Item.EmailAddresses.Contains([Microsoft.Exchange.WebServices.Data.EmailAddressKey]::EmailAddress1)){
$expObj.Email1DisplayName = $Item.EmailAddresses[[Microsoft.Exchange.WebServices.Data.EmailAddressKey]::EmailAddress1].Name
$expObj.Email1Type = $Item.EmailAddresses[[Microsoft.Exchange.WebServices.Data.EmailAddressKey]::EmailAddress1].RoutingType
$expObj.Email1EmailAddress = $Item.EmailAddresses[[Microsoft.Exchange.WebServices.Data.EmailAddressKey]::EmailAddress1].Address
}
$ExportCollection += $expObj
}
}
$ivItemView.Offset += $fiItems.Items.Count
}while($fiItems.MoreAvailable -eq $true)
Write-Host "Process Suggested Contacts"
$folderid = new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::MsgFolderRoot,$MailboxName)
$fvFolderView = new-object Microsoft.Exchange.WebServices.Data.FolderView(1)
$SfSearchFilter = new-object Microsoft.Exchange.WebServices.Data.SearchFilter+IsEqualTo([Microsoft.Exchange.WebServices.Data.FolderSchema]::DisplayName,"Suggested Contacts")
$findFolderResults = $service.FindFolders($folderid,$SfSearchFilter,$fvFolderView)
if($findFolderResults.Folders.Count -gt 0){
$psPropset= new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::FirstClassProperties)
#Define ItemView to retrive just 1000 Items
$ivItemView = New-Object Microsoft.Exchange.WebServices.Data.ItemView(1000)
$fiItems = $null
do{
$fiItems = $service.FindItems($findFolderResults.Folders[0].Id,$ivItemView)
[Void]$service.LoadPropertiesForItems($fiItems,$psPropset)
foreach($Item in $fiItems.Items){
if($Item -is [Microsoft.Exchange.WebServices.Data.Contact]){
$expObj = "" | select Source,DisplayName,Email1DisplayName,Email1Type,Email1EmailAddress
$expObj.Source = "Suggested Contacts"
$expObj.DisplayName = $Item.DisplayName
if($Item.EmailAddresses.Contains([Microsoft.Exchange.WebServices.Data.EmailAddressKey]::EmailAddress1)){
$expObj.Email1DisplayName = $Item.EmailAddresses[[Microsoft.Exchange.WebServices.Data.EmailAddressKey]::EmailAddress1].Name
$expObj.Email1Type = $Item.EmailAddresses[[Microsoft.Exchange.WebServices.Data.EmailAddressKey]::EmailAddress1].RoutingType
$expObj.Email1EmailAddress = $Item.EmailAddresses[[Microsoft.Exchange.WebServices.Data.EmailAddressKey]::EmailAddress1].Address
}
$ExportCollection += $expObj
}
}
$ivItemView.Offset += $fiItems.Items.Count
}while($fiItems.MoreAvailable -eq $true)
}
Write-Host "Process OWA AutocompleteCache"
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)$folderid = new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::Root,$MailboxName)
$folderid= new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::Root,$MailboxName)
#Specify the Calendar folder where the FAI Item is
$UsrConfig = [Microsoft.Exchange.WebServices.Data.UserConfiguration]::Bind($service, "OWA.AutocompleteCache", $folderid, [Microsoft.Exchange.WebServices.Data.UserConfigurationProperties]::All)
#Get the XML in String Format
$acXML = [System.Text.Encoding]::UTF8.GetString($UsrConfig.XmlData)
#Deal with the first character being a Byte Order Mark
$boMark = $acXML.SubString(0,1)
#Parse the XML
[XML]$acXML = $acXML.SubString(1)
foreach($AcEnt in $acXML.AutoCompleteCache.Entry){
$expObj = "" | select Source,DisplayName,Email1DisplayName,Email1Type,Email1EmailAddress
$expObj.Source = "OWA AutocompleteCache"
$expObj.DisplayName = $AcEnt.displayName
$expObj.Email1DisplayName= $AcEnt.displayName
$expObj.Email1Type= "SMTP"
$expObj.Email1EmailAddress= $AcEnt.smtpAddr
$ExportCollection +=$expObj
}
$fnFileName = "c:\temp\" + $MailboxName + "AC-CacheExport.csv"
$ExportCollection | Export-Csv -NoTypeInformation -Path $fnFileName
"Exported to " + $fnFileName

Shared Calendar Shortcuts eg

are an Outlook and OWA feature that can be handy to automate if you need to deploy a number of these to new (or existing) mailboxes and you don't want to go through the invitation/accept procedure or manually adding each shortcut.

While there are no supported operations in EWS for creating these type of objects, it can be achieved by setting the Extended MAPI properties that constitute the shortcut. The downside of this is that it wouldn't ever be considered supported if it all goes horribly wrong. The properties involved in the shortcut are documented in the following protocol document http://msdn.microsoft.com/en-us/library/ee157359(v=exchg.80).aspx.

For a couple of these properties the values you need to get can't be obtained directly in EWS so some others tricks are needed.

The PidTagWlinkAddressBookEID property contains the MAPI address Book EntryId for the shared Calendar your connecting to. The Address Book EntryID format is documented here http://msdn.microsoft.com/en-us/library/ee160588%28v=exchg.80%29.aspx so to construct this in EWS you need to get the LegacyExchangeDN from AutoDiscover and then appended the ProviderUID,Flag and Type information which for a normal user will be the same. (Note if you are trying to connect to an object other then a user mailbox.

The PidTagWlinkAddressBookStoreEID proeprty contains the MAPI StoreEntryID of the users where your creating the ShortCut. While you can get this property in EWS the value you get isn't correct because EWS uses different wrapper and providerID values. So instead using the format documented in http://msdn.microsoft.com/en-us/library/ee203516%28v=exchg.80%29.aspx you can construct this which involves getting the LegacyExchangeDN and the ServerName for Autodiscover and then building the identifier.

The other properties are pretty static for shared calendars.

The ShortCuts them selves are saved in a Non_IPM_Subtree folder called common views

(Special thanks also to Neil Doody for helping with property definitions in this post and script)

So the following script takes two commandline parameter the first is the Mailbox where you want the shortcut to be created and the second is the Mailbox which has the Calendar you want the shortcut to point to so you would run it like

./createWBarCal.ps1 user@domain.com target@domain.com

The script will check the CommonViews folder to see if a SharedFolder shortcut already exists for the target Mailbox AddressId and FolderType and if no ShortCut exists and it will attempt to create one.

As i mentioned before as this script is completely unsupported and for the most part untested and should only be considered safe for testing in a development\test environment. It also assume you have Autodiscover working if not your this isn't going to work well.

I've put a download of the script here the code itself looks like

## Get the Mailbox to Access from the 1st commandline argument
$TargetCalendarMailbox = $args[1]
$MailboxName = $args[0]
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2010_SP2
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
$service.AutodiscoverUrl($MailboxName,{$true})
"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)
function GetAutoDiscoverSettings{
param (
$adEmailAddress = "$( throw 'emailaddress is a mandatory Parameter' )",
$Credentials = "$( throw 'Credentials is a mandatory Parameter' )"
)
process{
$adService = New-Object Microsoft.Exchange.WebServices.AutoDiscover.AutodiscoverService($ExchangeVersion);
$adService.Credentials = $Credentials
$adService.EnableScpLookup = $false;
$adService.RedirectionUrlValidationCallback = {$true}
$UserSettings = new-object Microsoft.Exchange.WebServices.Autodiscover.UserSettingName[] 3
$UserSettings[0] = [Microsoft.Exchange.WebServices.Autodiscover.UserSettingName]::UserDN
$UserSettings[1] = [Microsoft.Exchange.WebServices.Autodiscover.UserSettingName]::InternalRpcClientServer
$UserSettings[2] = [Microsoft.Exchange.WebServices.Autodiscover.UserSettingName]::UserDisplayName
$adResponse = $adService.GetUserSettings($adEmailAddress , $UserSettings);
return $adResponse
}
}
function GetAddressBookId{
param (
$AutoDiscoverSettings = "$( throw 'AutoDiscoverSettings is a mandatory Parameter' )"
)
process{
$userdnString = $AutoDiscoverSettings.Settings[[Microsoft.Exchange.WebServices.Autodiscover.UserSettingName]::UserDN]
$userdnHexChar = $userdnString.ToCharArray();
foreach ($element in $userdnHexChar) {$userdnStringHex = $userdnStringHex + [System.String]::Format("{0:X}", [System.Convert]::ToUInt32($element))}
$Provider = "00000000DCA740C8C042101AB4B908002B2FE1820100000000000000"
$userdnStringHex = $Provider + $userdnStringHex + "00"
return $userdnStringHex
}
}
function GetStoreId{
param (
$AutoDiscoverSettings = "$( throw 'AutoDiscoverSettings is a mandatory Parameter' )"
)
process{
$userdnString = $AutoDiscoverSettings.Settings[[Microsoft.Exchange.WebServices.Autodiscover.UserSettingName]::UserDN]
$userdnHexChar = $userdnString.ToCharArray();
foreach ($element in $userdnHexChar) {$userdnStringHex = $userdnStringHex + [System.String]::Format("{0:X}", [System.Convert]::ToUInt32($element))}
$serverNameString = $AutoDiscoverSettings.Settings[[Microsoft.Exchange.WebServices.Autodiscover.UserSettingName]::InternalRpcClientServer]
$serverNameHexChar = $serverNameString.ToCharArray();
foreach ($element in $serverNameHexChar) {$serverNameStringHex = $serverNameStringHex + [System.String]::Format("{0:X}", [System.Convert]::ToUInt32($element))}
$flags = "00000000"
$ProviderUID = "38A1BB1005E5101AA1BB08002B2A56C2"
$versionFlag = "0000"
$DLLFileName = "454D534D44422E444C4C00000000"
$WrappedFlags = "00000000"
$WrappedProviderUID = "1B55FA20AA6611CD9BC800AA002FC45A"
$WrappedType = "0C000000"
$StoredIdStringHex = $flags + $ProviderUID + $versionFlag + $DLLFileName + $WrappedFlags + $WrappedProviderUID + $WrappedType + $serverNameStringHex + "00" + $userdnStringHex + "00"
return $StoredIdStringHex
}
}
function hex2binarray($hexString){
$i = 0
[byte[]]$binarray = @()
while($i -le $hexString.length - 2){
$strHexBit = ($hexString.substring($i,2))
$binarray += [byte]([Convert]::ToInt32($strHexBit,16))
$i = $i + 2
}
return ,$binarray
}
function ConvertId($EWSid){
$aiItem = New-Object Microsoft.Exchange.WebServices.Data.AlternateId
$aiItem.Mailbox = $MailboxName
$aiItem.UniqueId = $EWSid
$aiItem.Format = [Microsoft.Exchange.WebServices.Data.IdFormat]::EWSId;
return $service.ConvertId($aiItem, [Microsoft.Exchange.WebServices.Data.IdFormat]::StoreId)
}
#PropDefs
$pidTagStoreEntryId = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(4091, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagNormalizedSubject = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x0E1D,[Microsoft.Exchange.WebServices.Data.MapiPropertyType]::String);
$PidTagWlinkType = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6849, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer)
$PidTagWlinkFlags = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x684A, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer)
$PidTagWlinkOrdinal = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x684B, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkFolderType = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x684F, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkSection = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6852, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer)
$PidTagWlinkGroupHeaderID = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6842, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkSaveStamp = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6847, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer)
$PidTagWlinkGroupName = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6851, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::String)
$PidTagWlinkStoreEntryId = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x684E, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkGroupClsid = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6850, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkEntryId = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x684C, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkRecordKey = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x684D, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkCalendarColor = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6853, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer)
$PidTagWlinkAddressBookEID = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6854,[Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkROGroupType = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6892,[Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer)
$PidTagWlinkAddressBookStoreEID = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6891,[Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
#Get the TargetUsers Calendar
# Bind to the Calendar Folder
$fldPropset = new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::FirstClassProperties)
$fldPropset.Add($pidTagStoreEntryId);
$folderid= new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::Calendar,$TargetCalendarMailbox)
$TargetCalendar = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$folderid,$fldPropset)
#Check for existing ShortCut for TargetMailbox
#Get AddressBook Id for TargetUser
Write-Host ("Getting Autodiscover Settings Target")
Write-Host ("Getting Autodiscover Settings Mailbox")
$adset = GetAutoDiscoverSettings -adEmailAddress $MailboxName -Credentials $creds
$storeID = ""
if($adset -is [Microsoft.Exchange.WebServices.Autodiscover.AutodiscoverResponse]){
Write-Host ("Get StoreId")
$storeID = GetStoreId -AutoDiscoverSettings $adset
}
$adset = $null
$abTargetABEntryId = ""
$adset = GetAutoDiscoverSettings -adEmailAddress $TargetCalendarMailbox -Credentials $creds
if($adset -is [Microsoft.Exchange.WebServices.Autodiscover.AutodiscoverResponse]){
Write-Host ("Get AB Id")
$abTargetABEntryId = GetAddressBookId -AutoDiscoverSettings $adset
$SharedUserDisplayName = $adset.Settings[[Microsoft.Exchange.WebServices.Autodiscover.UserSettingName]::UserDisplayName]
}
Write-Host ("Getting CommonVeiwFolder")
#Get CommonViewFolder
$folderid = new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::Root,$MailboxName)
$tfTargetFolder = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$folderid)
$fvFolderView = new-object Microsoft.Exchange.WebServices.Data.FolderView(1)
$SfSearchFilter = new-object Microsoft.Exchange.WebServices.Data.SearchFilter+IsEqualTo([Microsoft.Exchange.WebServices.Data.FolderSchema]::DisplayName,"Common Views")
$findFolderResults = $service.FindFolders($tfTargetFolder.Id,$SfSearchFilter,$fvFolderView)
if ($findFolderResults.TotalCount -gt 0){
$ExistingShortCut = $false
$cvCommonViewsFolder = $findFolderResults.Folders[0]
#Define ItemView to retrive just 1000 Items
#Find Items that are unread
$psPropset= new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::FirstClassProperties)
$psPropset.add($PidTagWlinkAddressBookEID)
$psPropset.add($PidTagWlinkFolderType)
$ivItemView = New-Object Microsoft.Exchange.WebServices.Data.ItemView(1000)
$ivItemView.Traversal = [Microsoft.Exchange.WebServices.Data.ItemTraversal]::Associated
$ivItemView.PropertySet = $psPropset
$fiItems = $service.FindItems($cvCommonViewsFolder.Id,$ivItemView)
foreach($Item in $fiItems.Items){
$aeidVal = $null
if($Item.TryGetProperty($PidTagWlinkAddressBookEID,[ref]$aeidVal)){
$fldType = $null
if($Item.TryGetProperty($PidTagWlinkFolderType,[ref]$fldType)){
if([System.BitConverter]::ToString($fldType).Replace("-","") -eq "0278060000000000C000000000000046"){
if([System.BitConverter]::ToString($aeidVal).Replace("-","") -eq $abTargetABEntryId){
$ExistingShortCut = $true
Write-Host "Found existing Shortcut"
###$Item.Delete([Microsoft.Exchange.WebServices.Data.DeleteMode]::SoftDelete)
}
}
}
}
}
if($ExistingShortCut -eq $false){
If($storeID.length -gt 5 -band $abTargetABEntryId.length -gt 5){
$objWunderBarLink = New-Object Microsoft.Exchange.WebServices.Data.EmailMessage -ArgumentList $service
$objWunderBarLink.Subject = $SharedUserDisplayName
$objWunderBarLink.ItemClass = "IPM.Microsoft.WunderBar.Link"
$objWunderBarLink.SetExtendedProperty($PidTagWlinkAddressBookEID,(hex2binarray $abTargetABEntryId))
$objWunderBarLink.SetExtendedProperty($PidTagWlinkAddressBookStoreEID,(hex2binarray $storeID))
$objWunderBarLink.SetExtendedProperty($PidTagWlinkCalendarColor,-1)
$objWunderBarLink.SetExtendedProperty($PidTagWlinkFlags,0)
$objWunderBarLink.SetExtendedProperty($PidTagWlinkGroupName,"Shared Calendars")
$objWunderBarLink.SetExtendedProperty($PidTagWlinkFolderType,(hex2binarray "0278060000000000C000000000000046"))
$objWunderBarLink.SetExtendedProperty($PidTagWlinkGroupClsid,(hex2binarray "B9F0060000000000C000000000000046"))
$objWunderBarLink.SetExtendedProperty($PidTagWlinkROGroupType,-1)
$objWunderBarLink.SetExtendedProperty($PidTagWlinkSection,3)
$objWunderBarLink.SetExtendedProperty($PidTagWlinkType,2)
$objWunderBarLink.IsAssociated = $true
$objWunderBarLink.Save($findFolderResults.Folders[0].Id)
Write-Host ("ShortCut Created for - " + $SharedUserDisplayName)
}
else{
Write-Host ("Error with Id's")
}
}
}

Exchange 2013 and Exchange Online has a cool new feature in OWA to let you control the Reading pane setting on all folders in your Mailbox in OWA eg. (in previous versions you had to manage it yourself per folder).

When you set this setting in OWA and check the "Apply to all folders" box, in your mailbox it sets a configuration setting called GlobalReadingPanePosition in the OWA.UserOptions FAI (Folder Associated Item) in the Non_IPM Root of your Mailbox. The following values control the position of the Reading Pane on all folders

0 - Hides the Reading Pane
1 - Shows the Reading Pane on the Rights (this is the default)
2 - Shows the Reading Pane at the bottom

To Access this FAI Item in EWS you use the UserConfiguration class which makes accessing the Roaming Dictionary structure where this particular value is held really easy. Eg the following script will turn the Reading pane off on all Folders in the mailbox its ran against. I've put a download of this script here the code itself looks like

## Get the Mailbox to Access from the 1st commandline argument
$MailboxName = $args[0]
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2010_SP2
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
$service.AutodiscoverUrl($MailboxName,{$true})
"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)
$folderid= new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::Root,$MailboxName)
#Specify the Root folder where the FAI Item is
$UsrConfig = [Microsoft.Exchange.WebServices.Data.UserConfiguration]::Bind($service, "OWA.UserOptions", $folderid, [Microsoft.Exchange.WebServices.Data.UserConfigurationProperties]::All)
if($UsrConfig.Dictionary.ContainsKey("GlobalReadingPanePosition")){
$UsrConfig.Dictionary["GlobalReadingPanePosition"] = 0
}
else{
$UsrConfig.Dictionary.Add("GlobalReadingPanePosition",0)
}
$UsrConfig.Update()
"Item updated"

RSS feeds in Outlook is a nice feature that was added in Outlook, but for some organizations it may not be a desirable feature. While you can't delete the RSS Feeds folder itself as its on of Outlooks default folders you can easily remove each of the feeds and items from these folders using EWS's Empty folder operation http://msdn.microsoft.com/en-us/library/exchange/ff797574(v=exchg.80).aspx. A couple of months back I posted a Language independent way of getting the RSS feeds folder using the PidTagAdditionalRenEntryIdsEx property http://gsexdev.blogspot.com.au/2013/01/using-pidtagadditionalrenentryidsex.html . This script can be easily modified to Empty the RSSFeeds folder eg the following script binds to the RSS Feeds folder and use the Empty Operation with the parameter to also delete all sub folders under the RSS Feeds Folder. - I've put a download of this script here.

## Get the Mailbox to Access from the 1st commandline argument
$MailboxName = $args[0]
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\1.2\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2010_SP2
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
$service.AutodiscoverUrl($MailboxName,{$true})
"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)
$PidTagAdditionalRenEntryIdsEx = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x36D9, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$psPropset = new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::FirstClassProperties)
$psPropset.Add($PidTagAdditionalRenEntryIdsEx)
# Bind to the NON_IPM_ROOT Root folder
$folderid= new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::Root,$MailboxName)
$NON_IPM_ROOT = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$folderid,$psPropset)
$binVal = $null;
$AdditionalRenEntryIdsExCol = @{}
if($NON_IPM_ROOT.TryGetProperty($PidTagAdditionalRenEntryIdsEx,[ref]$binVal)){
$hexVal = [System.BitConverter]::ToString($binVal).Replace("-","");
##Parse Binary Value first word is Value type Second word is the Length of the Entry
$Sval = 0;
while(($Sval+8) -lt $hexVal.Length){
$PtypeVal = $hexVal.SubString($Sval,4)
$PtypeVal = $PtypeVal.SubString(2,2) + $PtypeVal.SubString(0,2)
$Sval +=12;
$PropLengthVal = $hexVal.SubString($Sval,4)
$PropLengthVal = $PropLengthVal.SubString(2,2) + $PropLengthVal.SubString(0,2)
$PropLength = [Convert]::ToInt64($PropLengthVal, 16)
$Sval +=4;
$ProdIdEntry = $hexVal.SubString($Sval,($PropLength*2))
$Sval += ($PropLength*2)
#$PtypeVal + " : " + $ProdIdEntry
$AdditionalRenEntryIdsExCol.Add($PtypeVal,$ProdIdEntry)
}
}
function ConvertFolderid($hexId){
$aiItem = New-Object Microsoft.Exchange.WebServices.Data.AlternateId
$aiItem.Mailbox = $MailboxName
$aiItem.UniqueId = $hexId
$aiItem.Format = [Microsoft.Exchange.WebServices.Data.IdFormat]::HexEntryId;
return $service.ConvertId($aiItem, [Microsoft.Exchange.WebServices.Data.IdFormat]::EWSId)
}
#Define Function to convert String to FolderPath
function ConvertToString($ipInputString){
$Val1Text = ""
for ($clInt=0;$clInt -lt $ipInputString.length;$clInt++){
$Val1Text = $Val1Text + [Convert]::ToString([Convert]::ToChar([Convert]::ToInt32($ipInputString.Substring($clInt,2),16)))
$clInt++
}
return $Val1Text
}
if($AdditionalRenEntryIdsExCol.ContainsKey("8001")){
$siId = ConvertFolderid($AdditionalRenEntryIdsExCol["8001"])
$RSSFolderID = new-object Microsoft.Exchange.WebServices.Data.FolderId($siId.UniqueId.ToString())
$RSSFolder = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$RSSFolderID)
if($RSSFolder -ne $null){
"Deleteing : " + $RSSFolder.ChildFolderCount.ToString() + " Feeds"
$RSSFolder.Empty([Microsoft.Exchange.WebServices.Data.DeleteMode]::SoftDelete, $true);
}
}

I came across an interesting Blog post this week from Jim Martin

http://blogs.technet.com/b/tips_from_the_inside/archive/2013/06/17/activesync-mapping-a-collection-id-to-a-mailbox-folder.aspx

which explains how the ActiveSync Folders located under the device folder in ExchangeSyncData folder tree map back to the real Mailbox folder that is being synchronized or accessed via ActiveSync. This information is pretty useful for a number of things so I thought it would be useful to put a script together to automate and create a report of these folder mapping using EWS and Powershell.

How it works is the ExchangeSyncData is located in the NON_IPM_Subtree of a mailbox so a few FindFolder calls are needed to find this folder and then get all the Folders associated with any ActiveSync devices for the Mailbox. The 0x7C030102 property is set on ActiveSync Collection folder and as in Jim's post if you take the first byte and last byte off the value from this property you have the HexEntryId of the folder. In EWS you can then use convertId to covert it to the ewsID of the Folder and then bind to the FolderId to work out which folder is being synced. Basically what you end up with is a report that looks like this

The LastModified column is the time the ActiveSync folder was last modified which should relate to the last time the folder was accessed over ActiveSync (from my observation anyway). The Device column just comes from the DisplayName of the Root folder from the device

I've put a download of this script here the code itself looks like

## Get the Mailbox to Access from the 1st commandline argument
$MailboxName = $args[0]
$AsFolderReport = @()
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2010_SP2
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
$service.AutodiscoverUrl($MailboxName,{$true})
"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)
# Bind to the MsgFolderRoot folder
$folderid= new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::Root,$MailboxName)
$MsgRoot = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$folderid)
function ConvertId{
param (
$HexId = "$( throw 'HexId is a mandatory Parameter' )"
)
process{
$aiItem = New-Object Microsoft.Exchange.WebServices.Data.AlternateId
$aiItem.Mailbox = $MailboxName
$aiItem.UniqueId = $HexId
$aiItem.Format = [Microsoft.Exchange.WebServices.Data.IdFormat]::HexEntryId
$convertedId = $service.ConvertId($aiItem, [Microsoft.Exchange.WebServices.Data.IdFormat]::EwsId)
return $convertedId.UniqueId
}
}
function GetFolderPath{
param (
$EWSFolder = "$( throw 'Folder is a mandatory Parameter' )"
)
process{
$foldpathval = $null
$PR_Folder_Path = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(26293, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::String);
if ($EWSFolder.TryGetProperty($PR_Folder_Path,[ref] $foldpathval))
{
$binarry = [Text.Encoding]::UTF8.GetBytes($foldpathval)
$hexArr = $binarry | ForEach-Object { $_.ToString("X2") }
$hexString = $hexArr -join ''
$hexString = $hexString.Replace("EFBFBE", "5C")
$fpath = ConvertToString($hexString)
return $fpath
}
}
}
$fldMappingHash = @{}
#Define the FolderView used for Export should not be any larger then 1000 folders due to throttling
$fvFolderView = New-Object Microsoft.Exchange.WebServices.Data.FolderView(1)
#Deep Transval will ensure all folders in the search path are returned
$fvFolderView.Traversal = [Microsoft.Exchange.WebServices.Data.FolderTraversal]::Shallow;
#The Search filter will exclude any Search Folders
$sfSearchFilter = new-object Microsoft.Exchange.WebServices.Data.SearchFilter+IsEqualTo([Microsoft.Exchange.WebServices.Data.FolderSchema]::DisplayName,"ExchangeSyncData")
$asFolderRoot = $Service.FindFolders($MsgRoot.Id,$sfSearchFilter,$fvFolderView)
if($asFolderRoot.Folders.Count -eq 1){
#Define Function to convert String to FolderPath
function ConvertToString($ipInputString){
$Val1Text = ""
for ($clInt=0;$clInt -lt $ipInputString.length;$clInt++){
$Val1Text = $Val1Text + [Convert]::ToString([Convert]::ToChar([Convert]::ToInt32($ipInputString.Substring($clInt,2),16)))
$clInt++
}
return $Val1Text
}
#Define Extended properties
$PR_FOLDER_TYPE = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(13825,[Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer);
#Define the FolderView used for Export should not be any larger then 1000 folders due to throttling
$fvFolderView = New-Object Microsoft.Exchange.WebServices.Data.FolderView(1000)
#Deep Transval will ensure all folders in the search path are returned
$fvFolderView.Traversal = [Microsoft.Exchange.WebServices.Data.FolderTraversal]::Deep;
$psPropertySet = new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::FirstClassProperties)
$PR_Folder_Path = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(26293, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::String);
$CollectionIdProp = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x7C03, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$LastModifiedTime = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x3008, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::SystemTime)
#Add Properties to the Property Set
$psPropertySet.Add($PR_Folder_Path);
$psPropertySet.Add($CollectionIdProp);
$psPropertySet.Add($LastModifiedTime);
$fvFolderView.PropertySet = $psPropertySet;
#The Search filter will exclude any Search Folders
$sfSearchFilter = new-object Microsoft.Exchange.WebServices.Data.SearchFilter+IsEqualTo($PR_FOLDER_TYPE,"1")
$fiResult = $null
#The Do loop will handle any paging that is required if there are more the 1000 folders in a mailbox
do {
$fiResult = $Service.FindFolders($asFolderRoot.Folders[0].Id,$sfSearchFilter,$fvFolderView)
foreach($ffFolder in $fiResult.Folders){
if(!$fldMappingHash.ContainsKey($ffFolder.Id.UniqueId)){
$fldMappingHash.Add($ffFolder.Id.UniqueId,$ffFolder)
}
$asFolderPath = ""
$asFolderPath = (GetFolderPath -EWSFolder $ffFolder)
"FolderPath : " + $asFolderPath
$collectVal = $null
if($ffFolder.TryGetProperty($CollectionIdProp,[ref]$collectVal)){
$HexEntryId = [System.BitConverter]::ToString($collectVal).Replace("-","").Substring(2)
$ewsFolderId = ConvertId -HexId ($HexEntryId.SubString(0,($HexEntryId.Length-2)))
try{
$fldReport = "" | Select Mailbox,Device,AsFolderPath,MailboxFolderPath,LastModified
$fldReport.Mailbox = $MailboxName
$fldReport.Device = $fldMappingHash[$ffFolder.ParentFolderId.UniqueId].DisplayName
$fldReport.AsFolderPath = $asFolderPath
$folderMapId= new-object Microsoft.Exchange.WebServices.Data.FolderId($ewsFolderId)
$MappedFolder = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$folderMapId,$psPropertySet)
$MappedFolderPath = (GetFolderPath -EWSFolder $MappedFolder)
$fldReport.MailboxFolderPath = $MappedFolderPath
$LastModifiedVal = $null
if($ffFolder.TryGetProperty($LastModifiedTime,[ref]$LastModifiedVal)){
Write-Host ("Last-Modified : " + $LastModifiedVal.ToLocalTime().ToString())
$fldReport.LastModified = $LastModifiedVal.ToLocalTime().ToString()
}
Write-Host $MappedFolderPath
$AsFolderReport += $fldReport
}
catch{
}
$ewsFolderId
}
#Process folder here
}
$fvFolderView.Offset += $fiResult.Folders.Count
}while($fiResult.MoreAvailable -eq $true)
}
$reportFile = "c:\temp\$MailboxName-asFolders.csv"
$AsFolderReport | Export-Csv -NoTypeInformation -Path $reportFile
Write-Host ("Report wrtten to " + $reportFile)

Sender Flags are an Outlook Feature that allow you to set a follow up flag on Message when your sending it as well as being able to set a Recipient Followup flag if you want to. (eg)

What happens in Exchange when you set a Sender Flag on a Message is documented in the Informational Flagging Protocol document http://msdn.microsoft.com/en-us/library/cc433487(v=exchg.80).aspx . If you want to do the same thing to a Message your sending in EWS there is nothing in the strongly typed classes to help out so you need to manually set two of the extended properties that are documented in that protocol document before you send the message and the Store will do the rest on submit. (More specifically what happens with the properties involved is documented here http://msdn.microsoft.com/en-us/library/ee217246(v=exchg.80).aspx )

The important properties that are involved with sender flags are the PidTagSwappedToDoData which is used to Store the information about what sender flags your want (eg in Outlook configured via the above dialogue box). This is a binary property containing an number of Flags, The text for the Message Flags and the DateTime values for the Start and DueDate. The full structure of the property is documented in http://msdn.microsoft.com/en-us/library/ee201575(v=exchg.80).aspx

The DateTime values used in this Property are stored as a 4-byte integer that are expressed as the number of minutes since 00:00:00 on January 1, 1601, in UTC. To get this Integer the method I used is a TimeSpan between the Date you want and January 1, 1601, in UTC, you can then get the TotalMinutes for the timespan as an Integer.

TimeSpan ts = new DateTime(2013,12,01,0,0,0,0,DateTimeKind.Utc) - new DateTime(1601, 1, 1, 0, 0, 0, 0, DateTimeKind.Utc);

The other important property is the PidTagSwappedToDoStore which is used by the Store after the Message is submitted. To use this is EWS you need to construct it based on the format documented in http://msdn.microsoft.com/en-us/library/ee203516%28v=exchg.80%29.aspx . The information necessary for this can be obtain through AutoDiscover.

I've created a Powershell and EWS Sample for setting a Sender Flag on a Message with a Start and DueDate. I've put a download of this script here the code itself looks like

## Get the Mailbox to Access from the 1st commandline argument
$MailboxName = $args[0]
$SenderFlagText = "This is a Test Blah Blah"
$FlagStartDate = (Get-Date).AddDays(1)
$FlagDueDate = (Get-Date).AddDays(7)
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2010_SP2
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
$service.AutodiscoverUrl($MailboxName,{$true})
"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
function hex2binarray($hexString){
$i = 0
[byte[]]$binarray = @()
while($i -le $hexString.length - 2){
$strHexBit = ($hexString.substring($i,2))
$binarray += [byte]([Convert]::ToInt32($strHexBit,16))
$i = $i + 2
}
return ,$binarray
}
function GetAutoDiscoverSettings{
param (
$adEmailAddress = "$( throw 'emailaddress is a mandatory Parameter' )",
$Credentials = "$( throw 'Credentials is a mandatory Parameter' )"
)
process{
$adService = New-Object Microsoft.Exchange.WebServices.AutoDiscover.AutodiscoverService($ExchangeVersion);
$adService.Credentials = $Credentials
$adService.EnableScpLookup = $false;
$adService.RedirectionUrlValidationCallback = {$true}
$UserSettings = new-object Microsoft.Exchange.WebServices.Autodiscover.UserSettingName[] 3
$UserSettings[0] = [Microsoft.Exchange.WebServices.Autodiscover.UserSettingName]::UserDN
$UserSettings[1] = [Microsoft.Exchange.WebServices.Autodiscover.UserSettingName]::InternalRpcClientServer
$UserSettings[2] = [Microsoft.Exchange.WebServices.Autodiscover.UserSettingName]::UserDisplayName
$adResponse = $adService.GetUserSettings($adEmailAddress , $UserSettings);
return $adResponse
}
}
function GetAddressBookId{
param (
$AutoDiscoverSettings = "$( throw 'AutoDiscoverSettings is a mandatory Parameter' )"
)
process{
$userdnString = $AutoDiscoverSettings.Settings[[Microsoft.Exchange.WebServices.Autodiscover.UserSettingName]::UserDN]
$userdnHexChar = $userdnString.ToCharArray();
foreach ($element in $userdnHexChar) {$userdnStringHex = $userdnStringHex + [System.String]::Format("{0:X}", [System.Convert]::ToUInt32($element))}
$Provider = "00000000DCA740C8C042101AB4B908002B2FE1820100000000000000"
$userdnStringHex = $Provider + $userdnStringHex + "00"
return $userdnStringHex
}
}
function GetStoreId{
param (
$AutoDiscoverSettings = "$( throw 'AutoDiscoverSettings is a mandatory Parameter' )"
)
process{
$userdnString = $AutoDiscoverSettings.Settings[[Microsoft.Exchange.WebServices.Autodiscover.UserSettingName]::UserDN]
$userdnHexChar = $userdnString.ToCharArray();
foreach ($element in $userdnHexChar) {$userdnStringHex = $userdnStringHex + [System.String]::Format("{0:X}", [System.Convert]::ToUInt32($element))}
$serverNameString = $AutoDiscoverSettings.Settings[[Microsoft.Exchange.WebServices.Autodiscover.UserSettingName]::InternalRpcClientServer]
$serverNameHexChar = $serverNameString.ToCharArray();
foreach ($element in $serverNameHexChar) {$serverNameStringHex = $serverNameStringHex + [System.String]::Format("{0:X}", [System.Convert]::ToUInt32($element))}
$flags = "00000000"
$ProviderUID = "38A1BB1005E5101AA1BB08002B2A56C2"
$versionFlag = "0000"
$DLLFileName = "454D534D44422E444C4C00000000"
$WrappedFlags = "00000000"
$WrappedProviderUID = "1B55FA20AA6611CD9BC800AA002FC45A"
$WrappedType = "0C000000"
$StoredIdStringHex = $flags + $ProviderUID + $versionFlag + $DLLFileName + $WrappedFlags + $WrappedProviderUID + $WrappedType + $serverNameStringHex + "00" + $userdnStringHex + "00"
return $StoredIdStringHex
}
}
function GetPidTagSwappedToDoData {
param (
$FlagText = "$( throw 'FlagText is a mandatory Parameter' )",
$StartTime = "$( throw 'StartTime is a mandatory Parameter' )",
$DueTime = "$( throw 'DueTime is a mandatory Parameter' )"
)
process{
$todoTimeFlagged = "01000000";
$PidLidFlagRequest = ""
$PidLidFlagRequestHexChar = $FlagText.ToCharArray();
$PidLidFlagRequest = [System.BitConverter]::ToString([System.Text.UnicodeEncoding]::Unicode.GetBytes($FlagText)).Replace("-","")
#Pad Flag to 512 Bytes
for ($padCnt = $PidLidFlagRequest.Length / 2; $padCnt -lt 512; $padCnt++) {
$PidLidFlagRequest = $PidLidFlagRequest + "00";
}
$stime = New-Object System.DateTime $StartTime.Year,$StartTime.Month,$StartTime.Day,0,0,0,0,Utc
$dtime = New-Object System.DateTime $DueTime.Year,$DueTime.Month,$DueTime.Day,0,0,0,0,Utc
$etime = New-Object System.DateTime 1601, 1, 1, 0, 0, 0, 0,Utc
[System.TimeSpan]$StartDateTimets = $stime - $etime
[System.TimeSpan]$DateDueTimets = $dtime - $etime
$HexDateStartTime = [System.Convert]::ToInt64($StartDateTimets.TotalMinutes).ToString("X8");
$HexDateStartTime = $HexDateStartTime.Substring(6, 2) + $HexDateStartTime.Substring(4, 2) + $HexDateStartTime.Substring(2, 2) + $HexDateStartTime.Substring(0, 2);
$HexDateDueTime = [System.Convert]::ToInt64($DateDueTimets.TotalMinutes).ToString("X8");
$HexDateDueTime = $HexDateDueTime.Substring(6, 2) + $HexDateDueTime.Substring(4, 2) + $HexDateDueTime.Substring(2, 2) + $HexDateDueTime.Substring(0, 2);
$ulVersion = "01000000";
$dwFlags = "79000000"; #dwToDoItem,rtmStartDate,rtmDueDate ,wszFlagTo ,fReminderSet
$dwToDoItem = $todoTimeFlagged;
$wszFlagTo = $PidLidFlagRequest;
$rtmStartDate = $HexDateStartTime;
$rtmDueDate = $HexDateDueTime;
$rtmReminder = "00000000";
$fReminderSet = "00000000";
return ($ulVersion + $dwFlags + $dwToDoItem + $wszFlagTo + $rtmStartDate + $rtmDueDate + $rtmReminder + $fReminderSet);
}
}
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)
$SenderFlagEmail = New-Object Microsoft.Exchange.WebServices.Data.EmailMessage -ArgumentList $service
$SenderFlagEmail.ToRecipients.Add("glenscales@yahoo.com");
$SenderFlagEmail.Subject = "test";
$SenderFlagEmail.Body = New-Object Microsoft.Exchange.WebServices.Data.MessageBody([Microsoft.Exchange.WebServices.Data.BodyType]::HTML,"test");
$PR_SWAPPED_TODO_DATA = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x0E2D,[Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary);
$PR_SWAPPED_TODO_STORE = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x0E2C,[Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary);
$adset = GetAutoDiscoverSettings -adEmailAddress $MailboxName -Credentials $creds
$storeID = ""
if($adset -is [Microsoft.Exchange.WebServices.Autodiscover.AutodiscoverResponse]){
Write-Host ("Get StoreId")
$storeID = GetStoreId -AutoDiscoverSettings $adset
}
$senderFlagHex = GetPidTagSwappedToDoData -FlagText $SenderFlagText -StartTime $FlagStartDate -DueTime $FlagDueDate
$SenderFlagEmail.SetExtendedProperty($PR_SWAPPED_TODO_DATA,(hex2binarray $senderFlagHex));
$SenderFlagEmail.SetExtendedProperty($PR_SWAPPED_TODO_STORE,(hex2binarray $storeID));
$SenderFlagEmail.SendAndSaveCopy();
Write-Host ("Message Sent")

Somebody asked a couple of weeks ago about creating Post Items using EWS and Powershell which I haven't posted a sample for previously. Given its the first day of the year an example of a post about how to create a post to wish everybody happy new year seems like good idea.

Creating a POST item using the EWS Managed API is pretty straight forward as their is a PostItem Class you can use. To create a post is a folder you just need to know the ewsID of the folder you want to create the POST in. So in EWS you need some code that will either search and find the Folder in the Mailbox you want to post to or the Public Folder you want to post to. I've created two sample one show how to create a post in Mailbox folders and the other in a Public folder. I've posted a download of the two sample here . The code for creating a POST in a Public folder looks like

## Get the Mailbox to Access from the 1st commandline argument
$MailboxName = $args[0]
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2010_SP2
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
$service.AutodiscoverUrl($MailboxName,{$true})
"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)
function FolderIdFromPath{
param (
$FolderPath = "$( throw 'Folder Path is a mandatory Parameter' )"
)
process{
## Find and Bind to Folder based on Path
#Define the path to search should be seperated with \
#Bind to the MSGFolder Root
$folderid = new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::PublicFoldersRoot)
$tfTargetFolder = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$folderid)
#Split the Search path into an array
$fldArray = $FolderPath.Split("\")
#Loop through the Split Array and do a Search for each level of folder
for ($lint = 1; $lint -lt $fldArray.Length; $lint++) {
#Perform search based on the displayname of each folder level
$fvFolderView = new-object Microsoft.Exchange.WebServices.Data.FolderView(1)
$SfSearchFilter = new-object Microsoft.Exchange.WebServices.Data.SearchFilter+IsEqualTo([Microsoft.Exchange.WebServices.Data.FolderSchema]::DisplayName,$fldArray[$lint])
$findFolderResults = $service.FindFolders($tfTargetFolder.Id,$SfSearchFilter,$fvFolderView)
if ($findFolderResults.TotalCount -gt 0){
foreach($folder in $findFolderResults.Folders){
$tfTargetFolder = $folder
}
}
else{
"Error Folder Not Found"
$tfTargetFolder = $null
break
}
}
if($tfTargetFolder -ne $null){
return $tfTargetFolder.Id.UniqueId.ToString()
}
}
}
#Example use
$fldId = FolderIdFromPath -FolderPath "\aaaa\bbbb"
if($fldId -ne "Error Folder Not Found"){
$SubFolderId = new-object Microsoft.Exchange.WebServices.Data.FolderId($fldId)
$SubFolder = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$SubFolderId)
$NewPost = New-Object Microsoft.Exchange.WebServices.Data.PostItem -ArgumentList $service
$NewPost.Subject = "Happy New Year"
$NewPost.Body = New-Object Microsoft.Exchange.WebServices.Data.MessageBody
$NewPost.Body.BodyType = [Microsoft.Exchange.WebServices.Data.BodyType]::HTML
$NewPost.Body.Text = "Happy New Year"
$NewPost.Save($SubFolder.Id)
Write-Host ("Created Post")
}

eDiscovery is one of the new features in Exchange 2013 aimed at both improving the search experience and also helping deal with Big Data in a mailbox or mailboxes (which is kind of like the Sun in that its just keeps getting bigger and will one day consume us all).

With eDiscovery in EWS you can perform two types of searches a

Estimate Query - Which will return information about the number of hits for a particular KQL query.
Preview Query - Will return your query hits as PreviewItems which you can then use to show more information about each hit.

If your doing a Preview Query with a very generic search predicate that is going to be returning many preview Items and because of the size of these results they will returned as separate paged results sets. This will mean you will need to make multiple search requests to navigate thought the result set pages.

To tell the server you want the next Page in the Results set you need to use the PageItemReference . The PageItemReference value needs to be set to the SortValue of the Last Preview-item returned by the previous page.

I've put together a couple of Managed API samples for this one is a C# example and the other is a Template Powershell script you can use to do a eDiscovery on one mailbox. These sample pages items back in lots of 100, you can adjust this value but I wouldn't go much over 1000. I've put a download of the code here, the script looks like.

## Get the Mailbox to Access from the 1st commandline argument
$MailboxName = $args[0]
$KQL = "Subject:test";
$SearchableMailboxString = $MailboxName;
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2013
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
$service.AutodiscoverUrl($MailboxName,{$true})
"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)
$gsMBResponse = $service.GetSearchableMailboxes($SearchableMailboxString, $false);
$gsMBResponse
$msbScope = New-Object Microsoft.Exchange.WebServices.Data.MailboxSearchScope[] $gsMBResponse.SearchableMailboxes.Length
$mbCount = 0;
foreach ($sbMailbox in $gsMBResponse.SearchableMailboxes)
{
$msbScope[$mbCount] = New-Object Microsoft.Exchange.WebServices.Data.MailboxSearchScope($sbMailbox.ReferenceId, [Microsoft.Exchange.WebServices.Data.MailboxSearchLocation]::All);
$mbCount++;
}
$smSearchMailbox = New-Object Microsoft.Exchange.WebServices.Data.SearchMailboxesParameters
$mbq = New-Object Microsoft.Exchange.WebServices.Data.MailboxQuery($KQL, $msbScope);
$mbqa = New-Object Microsoft.Exchange.WebServices.Data.MailboxQuery[] 1
$mbqa[0] = $mbq
$smSearchMailbox.SearchQueries = $mbqa;
$smSearchMailbox.PageSize = 100;
$smSearchMailbox.PageDirection = [Microsoft.Exchange.WebServices.Data.SearchPageDirection]::Next;
$smSearchMailbox.PerformDeduplication = $false;
$smSearchMailbox.ResultType = [Microsoft.Exchange.WebServices.Data.SearchResultType]::PreviewOnly;
$srCol = $service.SearchMailboxes($smSearchMailbox);
if ($srCol[0].Result -eq [Microsoft.Exchange.WebServices.Data.ServiceResult]::Success)
{
if ($srCol[0].SearchResult.ItemCount -gt 0)
{
do
{
$smSearchMailbox.PageItemReference = $srCol[0].SearchResult.PreviewItems[$srCol[0].SearchResult.PreviewItems.Length - 1].SortValue;
foreach ($PvItem in $srCol[0].SearchResult.PreviewItems) {
Write-Host ($PvItem.Subject);
}
$srCol = $service.SearchMailboxes($smSearchMailbox);
Write-Host("Items Remaining : " + $srCol[0].SearchResult.ItemCount);
} while ($srCol[0].SearchResult.ItemCount-gt 0 );
}
}

A while back I posted a sample of creating a Shortcut to a Shared Calendar folder using EWS here . In this post I'll look at how you can do the inverse which is reading and accessing the folders associated with these shortcuts. A users Shared Contacts folder's will appear like the following in Outlook

These Shortcuts are special items that are saved in the Common Views folder in the Non_IPM_Subtree of a mailbox. The data for the shortcut item is saved in a number of properties which are documented in the following Exchange protocol document http://msdn.microsoft.com/en-us/library/ee157359(v=exchg.80).aspx

So to access these shortcuts from EWS requires a few different operations, the first is you need to use a FindFolder operation on the Root of the Mailbox to located the CommonViews Folder. Once you have the CommonViews FolderId you then use the FindItems operation to find any of the Items where the PidTagWlinkGroupName is set to Shared Contacts, which will effectively filter the items returned just to the shared contacts (note at this point if you are using a localized version of Outlook you need to use the localized text name for the node).

Once you have access to the ShortCut Items the next step is to read the PidTagWlinkStoreEntryId property from the ShortCut item. To get the mailbox that this shortcut refers to you can extract the X500 address from StoreId format which is documented here . You can resolve the X500 Address to an SMTP address using the resolveName operation and then use the SMTP address bind to the shared Contacts folder normally in EWS.

I've posted a sample powershell script to access and query all the Shared Contact folders in a Mailbox here the code itself looks like

## Get the Mailbox to Access from the 1st commandline argument
$MailboxName = $args[0]
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2010_SP2
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
$service.AutodiscoverUrl($MailboxName,{$true})
"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
#PropDefs
$pidTagStoreEntryId = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(4091, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagNormalizedSubject = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x0E1D,[Microsoft.Exchange.WebServices.Data.MapiPropertyType]::String);
$PidTagWlinkType = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6849, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer)
$PidTagWlinkFlags = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x684A, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer)
$PidTagWlinkOrdinal = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x684B, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkFolderType = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x684F, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkSection = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6852, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer)
$PidTagWlinkGroupHeaderID = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6842, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkSaveStamp = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6847, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer)
$PidTagWlinkGroupName = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6851, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::String)
$PidTagWlinkStoreEntryId = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x684E, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkGroupClsid = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6850, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkEntryId = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x684C, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkRecordKey = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x684D, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkCalendarColor = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6853, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer)
$PidTagWlinkAddressBookEID = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6854,[Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$PidTagWlinkROGroupType = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6892,[Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer)
$PidTagWlinkAddressBookStoreEID = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(0x6891,[Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Binary)
$SharedFolders = @{}
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)
Write-Host ("Getting CommonVeiwFolder")
#Get CommonViewFolder
$folderid = new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::Root,$MailboxName)
$tfTargetFolder = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$folderid)
$fvFolderView = new-object Microsoft.Exchange.WebServices.Data.FolderView(1)
$SfSearchFilter = new-object Microsoft.Exchange.WebServices.Data.SearchFilter+IsEqualTo([Microsoft.Exchange.WebServices.Data.FolderSchema]::DisplayName,"Common Views")
$findFolderResults = $service.FindFolders($tfTargetFolder.Id,$SfSearchFilter,$fvFolderView)
if ($findFolderResults.TotalCount -gt 0){
$ExistingShortCut = $false
$cvCommonViewsFolder = $findFolderResults.Folders[0]
#Define ItemView to retrive just 1000 Items
#Find Items that are unread
$psPropset= new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::FirstClassProperties)
$psPropset.add($PidTagWlinkStoreEntryId)
$psPropset.add($PidTagWlinkFolderType)
$cntSearch = New-Object Microsoft.Exchange.WebServices.Data.SearchFilter+IsEqualTo($PidTagWlinkGroupName, "Shared Contacts");
$ivItemView = New-Object Microsoft.Exchange.WebServices.Data.ItemView(1000)
$ivItemView.Traversal = [Microsoft.Exchange.WebServices.Data.ItemTraversal]::Associated
$ivItemView.PropertySet = $psPropset
$fiItems = $service.FindItems($cvCommonViewsFolder.Id,$cntSearch,$ivItemView)
foreach($Item in $fiItems.Items){
$idVal = $null
if($Item.TryGetProperty($PidTagWlinkStoreEntryId,[ref]$idVal)){
Write-Host("Processing " + $Item.Subject)
$ssStoreID = $idVal;
$leLegDnStart = 0;
$lnLegDN = "";
for ($ssArraynum=($ssStoreID.Length - 2);$ssArraynum -ne 0; $ssArraynum--)
{
if ($ssStoreID[$ssArraynum] -eq 0)
{
$leLegDnStart = $ssArraynum;
$lnLegDN = [System.Text.ASCIIEncoding]::ASCII.GetString($ssStoreID, $leLegDnStart + 1, ($ssStoreID.Length - ($leLegDnStart + 2)));
$ssArraynum = 1;
}
}
Write-Host($lnLegDN)
$ncCol = $service.ResolveName($lnLegDN, [Microsoft.Exchange.WebServices.Data.ResolveNameSearchLocation]::DirectoryOnly, $true);
if ($ncCol.Count -gt 0)
{
try
{
$SharedContactsId = new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::Contacts, $ncCol[0].Mailbox.Address);
$SharedContactFolder = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service, $SharedContactsId);
$SharedFolders.Add($ncCol[0].Mailbox.Address, $SharedContactFolder);
}
catch {
Write-Host "Error getting Shared Folder"
}
}
}
}
}
if($SharedFolders.Keys.Count -ne 0){
foreach($mbFolder in $SharedFolders.Keys){
#Define ItemView to retrive just 1000 Items
$ivItemView = New-Object Microsoft.Exchange.WebServices.Data.ItemView(1000)
$fiItems = $null
do{
$fiItems = $service.FindItems($SharedFolders[$mbFolder].Id,$ivItemView)
#[Void]$service.LoadPropertiesForItems($fiItems,$psPropset)
foreach($Item in $fiItems.Items){
Write-Host ("Mailbox : " + $mbFolder)
Write-Host ("Contact : " + $Item.Subject + " : " + $Item.EmailAddresses[[Microsoft.Exchange.WebServices.Data.EmailAddressKey]::EmailAddress1])
}
$ivItemView.Offset += $fiItems.Items.Count
}while($fiItems.MoreAvailable -eq $true)
}
}

MEC the Microsoft Exchange Conference is on again this year in April and is shaping up to be a not to be missed event if your interested in Exchange. Unlike other conferences MEC doesn't come around every year which adds to the charm and freshness of the content you can expect to hear. Also the Exchange community are pretty awesome so it is not just the technology that makes this event but rather the people you can meet and listen to.

If your a developer or interested in coding on Exchange there is an Exchange Extensibility track http://www.mecisback.com/Sessions.aspx which covers among other things some of the new things you can do with Exchange 2013 and Exchange Online. As with many of the sessions at MEC a lot these are being delivered by the people at Microsoft who are responsible for designing and delivering these features, so its one of the only places you can get those hard questions answered or put some feedback forward. The future look sessions also look pretty interesting to get glimpse of the near future.

I'm also really excited about the session I'll be giving at MEC on "Using Exchange as a platform for Innovation"http://www.mecisback.com/SessionDetail.aspx?id=14161 . My session content will be a bit out of the box and different, it might be a bit of an 11 on the technical side as i have a pretty broad scope to cover, I'll be talking on both hardware and software and how you can build Mailbox centric solutions on unconventional devices. So if your interested in what you can do with a Raspberry Pi connecting to an Exchange Mailbox with EWS or interesting in learning how the Maker movement may start interfacing with Exchange then this is the session for you. I hope to have a least 3 unique prototypes to show and a little bit of usually blog type scripts at the end.

You can get all the other details on MEC at http://www.mecisback.com/

The ability to add a shared Mailbox Folders was a feature that was introduced in Exchange 2010 and carried over into 2013. When an additional Mailbox folder is added this updates an XML configuration documented in the OWA.OtherMailbox FAI Item for this Mailbox.

In Exchange 2010 this includes an Id to the Folder but in Exchange2013/OWA it just includes the PrimarySMTP of the Mailbox your adding while the folderId is left blank. Due to this reason this script won't work on a Exchange 2010 server.

Note : Its important to point out even on 2013/Office365 this type of script that modifies the configuration item would also not be supported as it may inadvertently corrupt the config document so it's provided as is for testing only.

The script to do this looks like

## Get the Mailbox to Access from the 1st commandline argument
$MailboxName = $args[0]
$maMailboxToAdd = $args[1]
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2013
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
$service.AutodiscoverUrl($MailboxName,{$true})
"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)
$exists = $false;
$updated = $false;
# Bind to the MsgFolderRoot folder
$folderid= new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::Root,$MailboxName)
$Root = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$folderid)
#Check for existing Item
$SfSearchFilter = new-object Microsoft.Exchange.WebServices.Data.SearchFilter+IsEqualTo([Microsoft.Exchange.WebServices.Data.ItemSchema]::ItemClass,"IPM.Configuration.OWA.OtherMailbox")
$ivItemView = New-Object Microsoft.Exchange.WebServices.Data.ItemView(1)
$ivItemView.Traversal = [Microsoft.Exchange.WebServices.Data.ItemTraversal]::Associated
$fiResults = $service.FindItems($Root.Id,$SfSearchFilter,$ivItemView)
if($fiResults.Items.Count -eq 0){
Write-Host ("No Config Item found, create new Item")
$UMConfig = New-Object Microsoft.Exchange.WebServices.Data.UserConfiguration -ArgumentList $service
$UMConfig.Save("OWA.OtherMailbox",$Root.Id)
}
else{
Write-Host ("Existing Config Item Found");
}
$owaOtherMailbox = [Microsoft.Exchange.WebServices.Data.UserConfiguration]::Bind($service, "OWA.OtherMailbox", $Root.Id, [Microsoft.Exchange.WebServices.Data.UserConfigurationProperties]::All);
#Make sure the server is running 2013 this script doesn't work on Exchange 2010
if($service.service.ServerInfo.MajorVersion -ge 15){
$xmlConfig = New-Object System.Xml.XmlDocument
if ($owaOtherMailbox.XmlData -eq $null)
{
$xmlConfig.LoadXml("<OtherMailbox></OtherMailbox>");
}
else
{
$xmlConfig.LoadXml([System.Text.UTF8Encoding]::UTF8.GetString($owaOtherMailbox.XmlData));
}
if($xmlConfig.OtherMailbox.entry -ne $null){
foreach($obMailbox in $xmlConfig.OtherMailbox.entry){
Write-host ("Processing Mailbox : " + $obMailbox.principalSMTPAddress);
if($obMailbox.principalSMTPAddress -eq $maMailboxToAdd.ToLower()){
$exists = $true;
}
}
}
if (!$exists)
{
$ncCol = $service.ResolveName($maMailboxToAdd,[Microsoft.Exchange.WebServices.Data.ResolveNameSearchLocation]::DirectoryOnly,$true);
if ($ncCol.Count -gt 0)
{
$newmb = $xmlConfig.CreateElement("entry");
$newmb.SetAttribute("displayName", $ncCol[0].Contact.DisplayName);
$newmb.SetAttribute("rootFolderId", "");
$newmb.SetAttribute("principalSMTPAddress", $ncCol[0].Mailbox.Address);
$newmb.InnerText = "";
$xmlConfig.DocumentElement.AppendChild($newmb);
$updated = $true;
}
}
else
{
write-host ("Mailbox already added");
}
if ($updated) {
$xmlbytes = [System.Text.UTF8Encoding]::UTF8.GetBytes($xmlConfig.OuterXml);
$owaOtherMailbox.XmlData = $xmlbytes;
$owaOtherMailbox.Update();
write-host ("Config updated")
}
}

Somebody asked last week about exporting contacts from Exchange via EWS to a CSV file and I realised I didn't have a basic sample for doing this. Contacts are one of the more richer exchange datatypes and can hold a lot of different information which you may or may not want to capture in a CSV export. In this sample script I'll show you how you can export data from the normal contact strongly typed properties like GivenName and Surname and the Indexed properties which are used to store the EmailAddresses, PhoneNumbers and Address details and also any extended properties like the Gender property which there are no strongly typed property for.

As I mentioned Contacts have a lot of properties so this script doesn't export everything just a subsection to show how to export properties from each of the different subgroups I talked about. To add other properties to script eg like the JobTitle you need to make the following modifications

Add the property to the Custom object

$expObj = "" | select DisplayName,GivenName,Surname,Gender,Email1DisplayName,Email1Type,Email1EmailAddress,BusinessPhone,MobilePhone,HomePhone,BusinessStreet,BusinessCity,BusinessState,HomeStreet,HomeCity,HomeState,JobTitle

Then set the property within the Item Iteration

$expObj.JobTitle = $item.JobTitle

I've put a download of this script here the code looks like

## Get the Mailbox to Access from the 1st commandline argument
$MailboxName = $args[0]
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2010_SP2
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
$service.AutodiscoverUrl($MailboxName,{$true})
"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)
$ExportCollection = @()
Write-Host "Process Contacts"
$folderid= new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::Contacts,$MailboxName)
$Contacts = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$folderid)
$psPropset = new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::FirstClassProperties)
$PR_Gender = New-Object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(14925,[Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Short)
$psPropset.Add($PR_Gender)
#Define ItemView to retrive just 1000 Items
$ivItemView = New-Object Microsoft.Exchange.WebServices.Data.ItemView(1000)
$fiItems = $null
do{
$fiItems = $service.FindItems($Contacts.Id,$ivItemView)
[Void]$service.LoadPropertiesForItems($fiItems,$psPropset)
foreach($Item in $fiItems.Items){
if($Item -is [Microsoft.Exchange.WebServices.Data.Contact]){
$expObj = "" | select DisplayName,GivenName,Surname,Gender,Email1DisplayName,Email1Type,Email1EmailAddress,BusinessPhone,MobilePhone,HomePhone,BusinessStreet,BusinessCity,BusinessState,HomeStreet,HomeCity,HomeState
$expObj.DisplayName = $Item.DisplayName
$expObj.GivenName = $Item.GivenName
$expObj.Surname = $Item.Surname
$expObj.Gender = ""
$Gender = $null
if($item.TryGetProperty($PR_Gender,[ref]$Gender)){
if($Gender -eq 2){
$expObj.Gender = "Male"
}
if($Gender -eq 1){
$expObj.Gender = "Female"
}
}
$BusinessPhone = $null
$MobilePhone = $null
$HomePhone = $null
if($Item.PhoneNumbers -ne $null){
if($Item.PhoneNumbers.TryGetValue([Microsoft.Exchange.WebServices.Data.PhoneNumberKey]::BusinessPhone,[ref]$BusinessPhone)){
$expObj.BusinessPhone = $BusinessPhone
}
if($Item.PhoneNumbers.TryGetValue([Microsoft.Exchange.WebServices.Data.PhoneNumberKey]::MobilePhone,[ref]$MobilePhone)){
$expObj.MobilePhone = $MobilePhone
}
if($Item.PhoneNumbers.TryGetValue([Microsoft.Exchange.WebServices.Data.PhoneNumberKey]::HomePhone,[ref]$HomePhone)){
$expObj.HomePhone = $HomePhone
}
}
if($Item.EmailAddresses.Contains([Microsoft.Exchange.WebServices.Data.EmailAddressKey]::EmailAddress1)){
$expObj.Email1DisplayName = $Item.EmailAddresses[[Microsoft.Exchange.WebServices.Data.EmailAddressKey]::EmailAddress1].Name
$expObj.Email1Type = $Item.EmailAddresses[[Microsoft.Exchange.WebServices.Data.EmailAddressKey]::EmailAddress1].RoutingType
$expObj.Email1EmailAddress = $Item.EmailAddresses[[Microsoft.Exchange.WebServices.Data.EmailAddressKey]::EmailAddress1].Address
}
$HomeAddress = $null
$BusinessAddress = $null
if($item.PhysicalAddresses -ne $null){
if($item.PhysicalAddresses.TryGetValue([Microsoft.Exchange.WebServices.Data.PhysicalAddressKey]::Home,[ref]$HomeAddress)){
$expObj.HomeStreet = $HomeAddress.Street
$expObj.HomeCity = $HomeAddress.City
$expObj.HomeState = $HomeAddress.State
}
if($item.PhysicalAddresses.TryGetValue([Microsoft.Exchange.WebServices.Data.PhysicalAddressKey]::Business,[ref]$BusinessAddress)){
$expObj.BusinessStreet = $BusinessAddress.Street
$expObj.BusinessCity = $BusinessAddress.City
$expObj.BusinessState = $BusinessAddress.State
}
}
$ExportCollection += $expObj
}
}
$ivItemView.Offset += $fiItems.Items.Count
}while($fiItems.MoreAvailable -eq $true)
$fnFileName = "c:\temp\" + $MailboxName + "-ContactsExport.csv"
$ExportCollection | Export-Csv -NoTypeInformation -Path $fnFileName
"Exported to " + $fnFileName

This blog has been a little quiet over the last month as I've been putting all my efforts into my MEC Talk which is now only a week away, but I should have a number of new posts soon after that.

In addition to this talk I am going to be moderating the Experts Unplugged: Exchange Extensibility session at MEC. If your interested in Exchange extensibility in any way this should be a really good session to attend, as we will be able to discuss exchange extensibility as a whole across EWS, Transport, Apps and Powershell and not just the individual components. The Panel for this session is made up of Subject matter experts from Microsoft who are responsible for designing,building, and directing the future of extensibility in Exchange. So this will be great opportunity for the community to come together and discuss where we are at with extensibility, some of new exciting stuff in SP1 and where we are going in the future. More importantly its your opportunity if you are attending MEC to give some feedback to the panel.

If you aren't able to get to MEC or you can't get to this session and you have a really good question (or piece of feedback) or something you would really like to see in Exchange extensibility. Please Email me glenscales@yahoo.com or post your question as a comment on this blog entry and I'll try to include this in the discussion and get back to you with an answer of some sort. If you are going to attend this session and are a bit shy about asking questions you can also let me know your questions.

If you haven't heard already Exchange 2013 SP1 both (onPrem and Online) has been released bearing extensibility gifts, here are some pre reading links for some of the new SP1 bits and new Exchange Online bits that are worth reading on your way to MEC.

Compose Apps
EWS what's new in 2013 SP1 (and the new EWS Managed API 2.1)
(Exchange On-line and the new OData API)

Overview of Office 365 APIs Preview

Using the Mail, Calendar, and Contact REST APIs to work with emails, calendar items, and contacts

Authentication and authorization using Common Consent Framework

This is the first of the sample scripts I included in my MEC talk last Monday. This script uses 3 of the new operations in EWS in Exchange 2013 to export all the address list entries of a particular Addresslist to individual Vcards (including the user photo) using just EWS. None of these operations are included in the EWS Managed API, so to use these operations I'm using some Raw SOAP and posting the EWS request using the standard httpwebrequest class in .Net and processing the response in XML.

The FindPeople Operation is used firstly to page through all the entries in an Address list in groups of 100 entries at a time. To use this operation you first need to get the GUID for the address list you want to export and hard code this in the $ABGUID variable eg.

$ABGUID = "6c118670-2f72-4213-944c-ab1e97d63f9b";

To get the GUID for your Global Address List you need to use the Get-GlobalAddressList Cmdlet http://technet.microsoft.com/en-us/library/aa996579%28v=exchg.150%29.aspx or if you want to export one of the other Address lists you can use the Get-AddressList cmdlet http://technet.microsoft.com/en-us/library/aa996782(v=exchg.150).aspx .

eg

To use these cmdlet's in Office365 you need to make sure you are assigned the Address Lists Role in RBAC

eg run

New-ManagementRoleAssignment -Role 'Address Lists' -User username

The FindPeople operation returns the PersonaId for each of the AddressList entries so the next part of the script uses the GetPersona Operation to get all the Address list entries details. Personas are a different way of representing contact data this is outlined in http://msdn.microsoft.com/en-us/library/office/jj190895(v=exchg.150).aspx . This particular script just uses this operation to grab the contact details stored in Active Directory (or Azure AD) for the particular persona (or Address list Entry in question). Currently I haven't worked out a way to batch this operation in EWS (if anyone knows please ping me) so its executing one OP per entry(which is kind of slow).

The last operation the script uses is the GerUserPhoto operation which is just a REST endpoint so it's nice and easy to use. It returns a ByteArray which then gets converted to a Base64 string with LineBreaks so its properly formatted in the VCard file.

To run this script you need to pass it in a Mailbox to run as and as I mentioned before you need to hardcode the GUID of the AddressList you want to export. While none of the operations used to do the export are in the Managed API, I've included in the usually Managed API Autodiscovery routines. You can also set the location of the export directory in

$exportFolder = "c:\temp\"

I've put a download of this script here the code itself looks like

## Get the Mailbox to Access from the 1st commandline argument
$MailboxName = $args[0]
$exportFolder = "c:\temp\"
$ABGUID = "6c118670-2f72-4213-944c-ab1e97d63f9b";
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2010_SP2
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
$service.AutodiscoverUrl($MailboxName,{$true})
"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
#$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)
function getPeopleRequest($offset){
$request = @"
<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:xsd="http://www.w3.org/2001/XMLSchema">
<soap:Header>
<RequestServerVersion Version="Exchange2013" xmlns="http://schemas.microsoft.com/exchange/services/2006/types" />
</soap:Header><soap:Body>
<FindPeople xmlns="http://schemas.microsoft.com/exchange/services/2006/messages"><PersonaShape>
<BaseShape xmlns="http://schemas.microsoft.com/exchange/services/2006/types">Default</BaseShape>
</PersonaShape><IndexedPageItemView MaxEntriesReturned="100" Offset="$offset" BasePoint="Beginning" />
<ParentFolderId>
<AddressListId Id="$ABGUID" xmlns="http://schemas.microsoft.com/exchange/services/2006/types" />
</ParentFolderId></FindPeople></soap:Body></soap:Envelope>
"@
return $request
}
function getPersonaRequest($PersonalId){
$request = @"
<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:t="http://schemas.microsoft.com/exchange/services/2006/types">
<soap:Header>
<t:RequestServerVersion Version="Exchange2013"/>
</soap:Header>
<soap:Body xmlns="http://schemas.microsoft.com/exchange/services/2006/messages">
<GetPersona>
<PersonaId Id="$PersonalId"/>
</GetPersona>
</soap:Body>
</soap:Envelope>
"@
return $request
}
function AutoDiscoverPhotoURL{
param (
$EmailAddress="$( throw 'Email is a mandatory Parameter' )",
$Credentials="$( throw 'Credentials is a mandatory Parameter' )"
)
process{
$version= [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2013
$adService= New-Object Microsoft.Exchange.WebServices.Autodiscover.AutodiscoverService($version);
$adService.Credentials = $Credentials
$adService.EnableScpLookup=$false;
$adService.RedirectionUrlValidationCallback= {$true}
$adService.PreAuthenticate=$true;
$UserSettings= new-object Microsoft.Exchange.WebServices.Autodiscover.UserSettingName[] 1
$UserSettings[0] = [Microsoft.Exchange.WebServices.Autodiscover.UserSettingName]::ExternalPhotosUrl
$adResponse=$adService.GetUserSettings($EmailAddress, $UserSettings)
$PhotoURI= $adResponse.Settings[[Microsoft.Exchange.WebServices.Autodiscover.UserSettingName]::ExternalPhotosUrl]
return $PhotoURI.ToString()
}
}
$Script:PhotoURL = AutoDiscoverPhotoURL -EmailAddress $MailboxName -Credentials $creds
Write-host ("Photo URL : " + $Script:PhotoURL)
function ProcessPersona($PersonalId){
$personalRequest = getPersonaRequest ($PersonalId)
$mbMailboxFolderURI = New-Object System.Uri($service.url)
$wrWebRequest = [System.Net.WebRequest]::Create($mbMailboxFolderURI)
$wrWebRequest.CookieContainer = New-Object System.Net.CookieContainer
$wrWebRequest.KeepAlive = $false;
$wrWebRequest.Headers.Set("Pragma", "no-cache");
$wrWebRequest.Headers.Set("Translate", "f");
$wrWebRequest.Headers.Set("Depth", "0");
$wrWebRequest.ContentType = "text/xml";
$wrWebRequest.ContentLength = $expRequest.Length;
$wrWebRequest.Timeout = 90000;
$wrWebRequest.Method = "POST";
$wrWebRequest.Credentials = $creds
$wrWebRequest.UserAgent = "EWS Script"
$bqByteQuery = [System.Text.Encoding]::ASCII.GetBytes($personalRequest);
$wrWebRequest.ContentLength = $bqByteQuery.Length;
$rsRequestStream = $wrWebRequest.GetRequestStream();
$rsRequestStream.Write($bqByteQuery, 0, $bqByteQuery.Length);
$rsRequestStream.Close();
$wrWebResponse = $wrWebRequest.GetResponse();
$rsResponseStream = $wrWebResponse.GetResponseStream()
$sr = new-object System.IO.StreamReader($rsResponseStream);
$rdResponseDocument = New-Object System.Xml.XmlDocument
$rdResponseDocument.LoadXml($sr.ReadToEnd());
$Persona =@($rdResponseDocument.getElementsByTagName("Persona"))
$Persona
$DisplayName = "";
if($Persona.DisplayName -ne $null){
$DisplayName = $Persona.DisplayName."#text"
}
$fileName = $exportFolder + $DisplayName + "-" + [Guid]::NewGuid().ToString() + ".vcf"
add-content -path $filename "BEGIN:VCARD"
add-content -path $filename "VERSION:2.1"
$givenName = ""
if($Persona.GivenName -ne $null){
$givenName = $Persona.GivenName."#text"
}
$surname = ""
if($Persona.Surname -ne $null){
$surname = $Persona.Surname."#text"
}
add-content -path $filename ("N:" + $surname + ";" + $givenName)
add-content -path $filename ("FN:" + $Persona.DisplayName."#text")
$Department = "";
if($Persona.Department -ne $null){
$Department = $Persona.Department."#text"
}
if($Persona.EmailAddress -ne $null){
add-content -path $filename ("EMAIL;PREF;INTERNET:" + $Persona.EmailAddress.EmailAddress)
}
$CompanyName = "";
if($Persona.CompanyName -ne $null){
$CompanyName = $Persona.CompanyName."#text"
}
add-content -path $filename ("ORG:" + $CompanyName + ";" + $Department)
if($Persona.Titles -ne $null){
add-content -path $filename ("TITLE:" + $Persona.Titles.StringAttributedValue.Value)
}
if($Persona.MobilePhones -ne $null){
add-content -path $filename ("TEL;CELL;VOICE:" + $Persona.MobilePhones.PhoneNumberAttributedValue.Value.Number)
}
if($Persona.HomePhones -ne $null){
add-content -path $filename ("TEL;HOME;VOICE:" + $Persona.HomePhones.PhoneNumberAttributedValue.Value.Number)
}
if($Persona.BusinessPhoneNumbers -ne $null){
add-content -path $filename ("TEL;WORK;VOICE:" + $Persona.BusinessPhoneNumbers.PhoneNumberAttributedValue.Value.Number)
}
if($Persona.WorkFaxes -ne $null){
add-content -path $filename ("TEL;WORK;FAX:" + $Persona.WorkFaxes.PhoneNumberAttributedValue.Value.Number)
}
if($Persona.BusinessHomePages -ne $null){
add-content -path $filename ("URL;WORK:" + $Persona.BusinessHomePages.StringAttributedValue.Value)
}
if($Persona.BusinessAddresses -ne $null){
$Country = $Persona.BusinessAddresses.PostalAddressAttributedValue.Value.Country
$City = $Persona.BusinessAddresses.PostalAddressAttributedValue.Value.City
$Street = $Persona.BusinessAddresses.PostalAddressAttributedValue.Value.Street
$State = $Persona.BusinessAddresses.PostalAddressAttributedValue.Value.State
$PCode = $Persona.BusinessAddresses.PostalAddressAttributedValue.Value.PostalCode
$addr = "ADR;WORK;PREF:;" + $Country + ";" + $Street + ";" +$City + ";" + $State + ";" + $PCode + ";" + $Country
add-content -path $filename $addr
}
try{
$PhotoSize = "HR96x96"
$PhotoURL= $Script:PhotoURL + "/GetUserPhoto?email=" + $Persona.EmailAddress.EmailAddress + "&size=" + $PhotoSize;
$wbClient = new-object System.Net.WebClient
$wbClient.Credentials = $creds
$photoBytes = $wbClient.DownloadData($PhotoURL);
add-content -path $filename "PHOTO;ENCODING=BASE64;TYPE=JPEG:"
$ImageString = [System.Convert]::ToBase64String($photoBytes,[System.Base64FormattingOptions]::InsertLineBreaks)
add-content -path $filename $ImageString
add-content -path $filename "`r`n"
}
catch{
}
add-content -path $filename "END:VCARD"
}
$peopleCollection = @()
$offset = 0;
do{
$mbMailboxFolderURI = New-Object System.Uri($service.url)
$wrWebRequest = [System.Net.WebRequest]::Create($mbMailboxFolderURI)
$wrWebRequest.CookieContainer = New-Object System.Net.CookieContainer
$wrWebRequest.KeepAlive = $false;
$wrWebRequest.Useragent = "EWS Script"
$wrWebRequest.Headers.Set("Pragma", "no-cache");
$wrWebRequest.Headers.Set("Translate", "f");
$wrWebRequest.Headers.Set("Depth", "0");
$wrWebRequest.ContentType = "text/xml";
$wrWebRequest.ContentLength = $expRequest.Length;
$wrWebRequest.Timeout = 60000;
$wrWebRequest.Method = "POST";
$wrWebRequest.Credentials = $creds
$fpRequest = getPeopleRequest ($offset)
$bqByteQuery = [System.Text.Encoding]::ASCII.GetBytes($fpRequest);
$wrWebRequest.ContentLength = $bqByteQuery.Length;
$rsRequestStream = $wrWebRequest.GetRequestStream();
$rsRequestStream.Write($bqByteQuery, 0, $bqByteQuery.Length);
$rsRequestStream.Close();
$wrWebResponse = $wrWebRequest.GetResponse();
$rsResponseStream = $wrWebResponse.GetResponseStream()
$sr = new-object System.IO.StreamReader($rsResponseStream);
$rdResponseDocument = New-Object System.Xml.XmlDocument
$rdResponseDocument.LoadXml($sr.ReadToEnd());
$totalCount = @($rdResponseDocument.getElementsByTagName("TotalNumberOfPeopleInView"))
$Personas =@($rdResponseDocument.getElementsByTagName("Persona"))
Write-Host ("People Count : " + $Personas.Count)
$offset += $Personas.Count
foreach($persona in $Personas){
if($persona.PersonaType -eq "Person"){
ProcessPersona($persona.PersonaId.Id.ToString())
}
}
[Int32]$tc = $totalCount."#text"
Write-Host ("Offset: " + $offset)
Write-Host ("Total count: " + $tc)
}while($tc -gt $offset)

This is the second of the Powershell script samples from my MEC talk last week. The idea behind this script is to track the movement of Items in a Mailbox between folders using Pull Notifications in EWS, you can read more about how Pull notifications work here . This script takes advantage of the fact that when you enable Single Item Recovery any deletes you make in a Mailbox (hard or soft) the Items aren't deleted rather moved to the Dumpster v2 RecoverableItems folders. So if you track all the move notification events you can track both the movement of Messages by rules, users or deletes. eg the results look like

I've created two different versions of this script, the first version subscribes to all folders in a Mailbox and runs continuously against the Mailbox and does a GetEvents request every minute to retrieve the latest events from all folders in a Mailbox and then logs that to file.

The second version just subscribes to the Inbox folder and saves the subscription information out to file when you run it the first time. Then the next time you run the script it will use the saved SubscriptionId and Watermark value to get all the events since the script was last run. Pull Subscriptions have a timeout of 1440 minutes (which is 1 day) so if you are going to run this version you need to run it with a maximum gap of 1 day. The idea of this second version was just to track inbox fan-out of messages rather then subscribing to all folders like the first version.

Both of these scripts use EWS Impersonation which must be configured for the account your going to run the script as. When you run the script you need to pass in the Mailbox to run against and the timeout value in minutes for subscription which needs to between 1 and 1440 eg

./pullSubTrackWm.ps1 jcool@msgdevelop.onmicrosoft.com 1440

I've put a download of both scripts here the code itself looks like

## Get the Mailbox to Access from the 1st commandline argument
$MailboxName = $args[0]
$duration = $args[1]
$sw = [system.diagnostics.stopwatch]::startNew()
$Error.Clear()
$Script:changeLog = "c:\temp\ChangeLog-$(get-date -f yyyy-MM-dd).csv";
if(-Not(Test-Path -Path $Script:changeLog)){
Add-Content -Path $Script:changeLog ("EventTime,MessageDateTimeReceived,Subject,MovedFrom,MovedTo,LastModifiedName")
}
#Add-Content -Path $Script:changeLog ("Start Log" + (Get-Date).ToString())
## Load Managed API dll
Add-Type -Path "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
Add-Type -AssemblyName System.Runtime.Serialization
## Set Exchange Version
$ExchangeVersion = [Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2010_SP2
## Create Exchange Service Object
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService($ExchangeVersion)
## Set Credentials to use two options are availible Option1 to use explict credentials or Option 2 use the Default (logged On) credentials
#Credentials Option 1 using UPN for the windows Account
$psCred = Get-Credential
$creds = New-Object System.Net.NetworkCredential($psCred.UserName.ToString(),$psCred.GetNetworkCredential().password.ToString())
$service.Credentials = $creds
#Credentials Option 2
#service.UseDefaultCredentials = $true
## Choose to ignore any SSL Warning issues caused by Self Signed Certificates
## Code From http://poshcode.org/624
## Create a compilation environment
$Provider=New-Object Microsoft.CSharp.CSharpCodeProvider
$Compiler=$Provider.CreateCompiler()
$Params=New-Object System.CodeDom.Compiler.CompilerParameters
$Params.GenerateExecutable=$False
$Params.GenerateInMemory=$True
$Params.IncludeDebugInformation=$False
$Params.ReferencedAssemblies.Add("System.DLL") | Out-Null
$TASource=@'
namespace Local.ToolkitExtensions.Net.CertificatePolicy{
public class TrustAll : System.Net.ICertificatePolicy {
public TrustAll() {
}
public bool CheckValidationResult(System.Net.ServicePoint sp,
System.Security.Cryptography.X509Certificates.X509Certificate cert,
System.Net.WebRequest req, int problem) {
return true;
}
}
}
'@
$TAResults=$Provider.CompileAssemblyFromSource($Params,$TASource)
$TAAssembly=$TAResults.CompiledAssembly
## We now create an instance of the TrustAll and attach it to the ServicePointManager
$TrustAll=$TAAssembly.CreateInstance("Local.ToolkitExtensions.Net.CertificatePolicy.TrustAll")
[System.Net.ServicePointManager]::CertificatePolicy=$TrustAll
## end code from http://poshcode.org/624
## Set the URL of the CAS (Client Access Server) to use two options are availbe to use Autodiscover to find the CAS URL or Hardcode the CAS to use
#CAS URL Option 1 Autodiscover
$service.AutodiscoverUrl($MailboxName,{$true})
"Using CAS Server : " + $Service.url
#CAS URL Option 2 Hardcoded
#$uri=[system.URI] "https://casservername/ews/exchange.asmx"
#$service.Url = $uri
## Optional section for Exchange Impersonation
$service.ImpersonatedUserId = new-object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $MailboxName)
#check Anchor header for Exchange 2013/Office365
if($service.HttpHeaders.ContainsKey("X-AnchorMailbox")){
$service.HttpHeaders["X-AnchorMailbox"] = $MailboxName
}else{
$service.HttpHeaders.Add("X-AnchorMailbox", $MailboxName);
$service.HttpHeaders.Add("X-PreferServerAffinity","true");
}
"AnchorMailbox : " + $service.HttpHeaders["X-AnchorMailbox"]
$FolderCollection = New-Object System.Collections.Hashtable
#Define Function to convert String to FolderPath
function ConvertToString($ipInputString){
$Val1Text = ""
for ($clInt=0;$clInt -lt $ipInputString.length;$clInt++){
$Val1Text = $Val1Text + [Convert]::ToString([Convert]::ToChar([Convert]::ToInt32($ipInputString.Substring($clInt,2),16)))
$clInt++
}
return $Val1Text
}
#Define Extended properties
$PR_FOLDER_TYPE = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(13825,[Microsoft.Exchange.WebServices.Data.MapiPropertyType]::Integer);
$folderidcnt = new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::MsgFolderRoot,$MailboxName)
#Define the FolderView used for Export should not be any larger then 1000 folders due to throttling
$fvFolderView = New-Object Microsoft.Exchange.WebServices.Data.FolderView(1000)
#Deep Transval will ensure all folders in the search path are returned
$fvFolderView.Traversal = [Microsoft.Exchange.WebServices.Data.FolderTraversal]::Deep;
$psPropertySet = new-object Microsoft.Exchange.WebServices.Data.PropertySet([Microsoft.Exchange.WebServices.Data.BasePropertySet]::FirstClassProperties)
$PR_Folder_Path = new-object Microsoft.Exchange.WebServices.Data.ExtendedPropertyDefinition(26293, [Microsoft.Exchange.WebServices.Data.MapiPropertyType]::String);
#Add Properties to the Property Set
$psPropertySet.Add($PR_Folder_Path);
$fvFolderView.PropertySet = $psPropertySet;
#The Search filter will exclude any Search Folders
$sfSearchFilter = new-object Microsoft.Exchange.WebServices.Data.SearchFilter+IsEqualTo($PR_FOLDER_TYPE,"1")
$fiResult = $null
#The Do loop will handle any paging that is required if there are more the 1000 folders in a mailbox
do {
$fiResult = $Service.FindFolders($folderidcnt,$sfSearchFilter,$fvFolderView)
foreach($ffFolder in $fiResult.Folders){
$foldpathval = $null
#Try to get the FolderPath Value and then covert it to a usable String
if ($ffFolder.TryGetProperty($PR_Folder_Path,[ref] $foldpathval))
{
$binarry = [Text.Encoding]::UTF8.GetBytes($foldpathval)
$hexArr = $binarry | ForEach-Object { $_.ToString("X2") }
$hexString = $hexArr -join ''
$hexString = $hexString.Replace("FEFF", "5C00")
$fpath = ConvertToString($hexString)
}
"FolderPath : " + $fpath
$FolderCollection.Add($ffFolder.Id.UniqueId,$fpath)
}
$fvFolderView.Offset += $fiResult.Folders.Count
}while($fiResult.MoreAvailable -eq $true)
function GetEventsRequest{
param (
$SubscriptionId="$( throw 'SubscriptionId is a mandatory Parameter' )",
$Watermark="$( throw 'Credentials is a mandatory Parameter' )",
$ImpersonationHeader="$( throw 'ImpersonationHeader is a mandatory Parameter' )"
)
process{
Write-Host($SubscriptionId)
$request = @"
<?xml version="1.0" encoding="utf-8"?>
<soap:Envelope xmlns:soap="http://schemas.xmlsoap.org/soap/envelope/"
xmlns:t="http://schemas.microsoft.com/exchange/services/2006/types">
<soap:Header>
<t:RequestServerVersion Version="Exchange2010_SP2"/>
<t:ExchangeImpersonation>
<t:ConnectingSID>
<t:SmtpAddress>$ImpersonationHeader</t:SmtpAddress>
</t:ConnectingSID>
</t:ExchangeImpersonation>
</soap:Header>
<soap:Body>
<GetEvents xmlns="http://schemas.microsoft.com/exchange/services/2006/messages">
<SubscriptionId>$SubscriptionId</SubscriptionId>
<Watermark>$Watermark</Watermark>
</GetEvents>
</soap:Body>
</soap:Envelope>
"@
return $request
}
}
$DeletionsID = new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::RecoverableItemsDeletions,$MailboxName);
$Deletions = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$DeletionsID)
$evEvents = new-object Microsoft.Exchange.WebServices.Data.EventType[] 6
$evEvents[0] = [Microsoft.Exchange.WebServices.Data.EventType]::Copied
$evEvents[1] = [Microsoft.Exchange.WebServices.Data.EventType]::Created
$evEvents[2] = [Microsoft.Exchange.WebServices.Data.EventType]::Deleted
$evEvents[3] = [Microsoft.Exchange.WebServices.Data.EventType]::Modified
$evEvents[4] = [Microsoft.Exchange.WebServices.Data.EventType]::Moved
$evEvents[5] = [Microsoft.Exchange.WebServices.Data.EventType]::NewMail
$psSub = ""
if(Test-Path -Path ("c:\temp\" + $MailboxName + "PullSubWM.wm")){
$psSub = Import-Csv -Path ("c:\temp\" + $MailboxName + "PullSubWM.wm")
$request = GetEventsRequest -SubscriptionId $psSub.SubscriptionID -Watermark $psSub.Watermark -ImpersonationHeader $MailboxName
$mbMailboxFolderURI = New-Object System.Uri($service.url)
$wrWebRequest = [System.Net.WebRequest]::Create($mbMailboxFolderURI)
$wrWebRequest.CookieContainer = New-Object System.Net.CookieContainer
$wrWebRequest.KeepAlive = $false;
$wrWebRequest.Useragent = "EWS Script"
$wrWebRequest.Headers.Set("Pragma", "no-cache");
$wrWebRequest.Headers.Set("Translate", "f");
$wrWebRequest.Headers.Set("Depth", "0");
$wrWebRequest.ContentType = "text/xml";
$wrWebRequest.ContentLength = $expRequest.Length;
$wrWebRequest.Timeout = 60000;
$wrWebRequest.Method = "POST";
$wrWebRequest.Credentials = $creds
$bqByteQuery = [System.Text.Encoding]::ASCII.GetBytes($request);
$wrWebRequest.ContentLength = $bqByteQuery.Length;
$rsRequestStream = $wrWebRequest.GetRequestStream();
$rsRequestStream.Write($bqByteQuery, 0, $bqByteQuery.Length);
$rsRequestStream.Close();
$wrWebResponse = $wrWebRequest.GetResponse();
$rsResponseStream = $wrWebResponse.GetResponseStream()
$sr = new-object System.IO.StreamReader($rsResponseStream);
$rdResponseDocument = New-Object System.Xml.XmlDocument
$rdResponseDocument.LoadXml($sr.ReadToEnd());
$rdResponseDocument.Envelope.Body.GetEventsResponse.ResponseMessages.GetEventsResponseMessage.ResponseClass
if($rdResponseDocument.Envelope.Body.GetEventsResponse.ResponseMessages.GetEventsResponseMessage.ResponseClass -eq "Error"){
$rdResponseDocument.Envelope.Body.GetEventsResponse.ResponseMessages.GetEventsResponseMessage | fl
Remove-Item ("c:\temp\" + $MailboxName + "PullSubWM.wm")
Write-Host ("Removed old watermarkFile")
}
else{
if($rdResponseDocument.Envelope.Body.GetEventsResponse.ResponseMessages.GetEventsResponseMessage.ResponseClass -eq "Success"){
$pullSubSav = "" | Select Watermark,SubscriptionID
$wmark2 = $rdResponseDocument.getElementsByTagName("t:Watermark")
$pullSubSav.Watermark = $wmark2.Item(($wmark2.Count-1))."#text"
$pullSubSav.SubscriptionID = $rdResponseDocument.Envelope.Body.GetEventsResponse.ResponseMessages.GetEventsResponseMessage.Notification.SubscriptionId
$pullSubSav | Export-Csv -Path ("c:\temp\" + $MailboxName + "PullSubWM.wm") -NoTypeInformation
Write-Host "Subscription saved"
$movedEvents = $rdResponseDocument.getElementsByTagName("t:MovedEvent")
if($movedEvents.Count -gt 0){
try{
for($intmc=0;$intmc -lt $movedEvents.Count;$intmc++){
$item = [Microsoft.Exchange.WebServices.Data.Item]::Bind($service, $movedEvents.Item($intmc).ItemId.Id);
$ItemEvt = "" | Select EventTime,MessageDateTimeReceived,Subject,MovedFrom,MovedTo,LastModifiedName
$ItemEvt.EventTime = $movedEvents.Item($intmc).TimeStamp
Write-Host ("Processing : " + $item.Subject)
write-host ("Last Modified by :" + $item.LastModifiedName)
$ItemEvt.Subject = $item.Subject
$ItemEvt.LastModifiedName = $item.LastModifiedName
$ItemEvt.MessageDateTimeReceived = $item.DateTimeReceived
#$movedEvents.Item($intmc).OldItemId.Id
if($FolderCollection.containsKey($movedEvents.Item($intmc).OldParentFolderId.Id)){
Write-Host ("Moved From Folder " + $FolderCollection[$movedEvents.Item($intmc).OldParentFolderId.Id])
$ItemEvt.MovedFrom = $FolderCollection[$movedEvents.Item($intmc).OldParentFolderId.Id]
}
if($FolderCollection.containsKey($movedEvents.Item($intmc).ParentFolderId.Id)){
Write-Host ("Moved To Folder " + $FolderCollection[$movedEvents.Item($intmc).ParentFolderId.Id])
$ItemEvt.MovedTo = $FolderCollection[$movedEvents.Item($intmc).ParentFolderId.Id]
}
else{
if ($movedEvents.Item($intmc).ParentFolderId.Id -eq $Deletions.Id.UniqueId)
{
Write-Host ("Moved to Recoverable Items - Deleted Items");
}
$ItemEvt.MovedTo = "Moved to Recoverable Items - Deleted Items"
}
Add-Content -Path $Script:changeLog ($ItemEvt.EventTime + ",`"" + $ItemEvt.MessageDateTimeReceived + "`",`"" + $ItemEvt.Subject + "`"," + $ItemEvt.MovedFrom + "," + $ItemEvt.MovedTo + "," + $ItemEvt.LastModifiedName)
}
}
catch{
Write-Host ($Error | fl)
$Error.Clear()
}
}
}
}
}
else{
$InboxId = new-object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::Inbox,$MailboxName)
$fldArray = new-object Microsoft.Exchange.WebServices.Data.FolderId[] 1
$fldArray[0] = $InboxId
$pullsub = $service.SubscribeToPullNotifications($fldArray,$duration, $WaterMark, $evEvents);
$gEvents = $pullsub.GetEvents();
$pullSubSav = "" | Select Watermark,SubscriptionID
$pullSubSav.Watermark = $pullsub.Watermark
$pullSubSav.SubscriptionID = $pullsub.Id
$pullSubSav | Export-Csv -Path ("c:\temp\" + $MailboxName + "PullSubWM.wm") -NoTypeInformation
Write-Host "Subscription saved"
}

Sending a VoiceMail using EWS and Powershell

Public Folder EWS How-To rollup Part 1

Exchange Attachment statistics reporting with EWS and Powershell

Junk Email SCL report using EWS and Powershell

Parsing out URL's in the body of a Message with EWS and Powershell

Exporting the Suggested Contacts, OWA Auto-complete Cache and Recipient Cache in Exchange 2013 with EWS and PowerShell

Creating a Shared Calendar Shortcut (WunderBar Link) with EWS and Powershell

Turning off the Reading / Preview Pane on all folders in OWA in Exchange 2013 and Exchange Online in EWS with Powershell

Clearing the RSS Feeds folder in Exchange using EWS and Powershell

Mapping what Folders are in use in ActiveSync with EWS and Powershell

Using Sender Flags in EWS

Create a Public Folder (or Mailbox folder) Post using EWS and Powershell

Paging eDiscovery results with the EWS Managed API in Exchange 2013

Accessing a User's Shared Contacts Folders in EWS

MEC is back again this year

Adding an additional/Shared Mailbox to OWA with EWS and Powershell in Exchange 2013

Exporting Contacts to a CSV file using the EWS Managed API and Powershell

Looking for your questions on Exchange extensibility for MEC

Export the GAL or Address list with EWS to Vcards in 2013 MEC sample 1

Pull Subscription Mailbox Item move tracking script MEC sample 2