{"id":54513,"date":"2009-01-28T21:01:00","date_gmt":"2009-01-28T21:01:00","guid":{"rendered":"https:\/\/blogs.technet.microsoft.com\/heyscriptingguy\/2009\/01\/28\/hey-scripting-guy-how-can-i-notify-users-of-the-space-their-deleted-items-folder-is-using\/"},"modified":"2009-01-28T21:01:00","modified_gmt":"2009-01-28T21:01:00","slug":"hey-scripting-guy-how-can-i-notify-users-of-the-space-their-deleted-items-folder-is-using","status":"publish","type":"post","link":"https:\/\/devblogs.microsoft.com\/scripting\/hey-scripting-guy-how-can-i-notify-users-of-the-space-their-deleted-items-folder-is-using\/","title":{"rendered":"Hey, Scripting Guy! How Can I Notify Users of the Space Their Deleted Items Folder Is Using?"},"content":{"rendered":"

\"Hey, <\/h2>\n

Hey, Scripting Guy! My users seem to think that once they delete an e-mail message, it is gone. Most do not have the concept of going and emptying their Deleted Items folder. Using Windows PowerShell on Exchange, I can easily obtain a report from the server about how much space this stuff is taking up. I would like a script the users can run that would tell them how much space they are using. We have strict quotas set on their mailboxes, and I would like to notify them, perhaps via logon script, of the space used in their Deleted Items folder. I do not want to just arbitrarily empty the contents of that folder because some of the users actually use their deleted items folder for storage and often refer back to those deleted e-mail messages. Can you help me?<\/p>\n

– JH<\/p>\n

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

Hi JH,<\/p>\n

Of course we can help you. The Deleted Items folder is just a folder, like any other Office Outlook folder. In fact, here is a VBScript article<\/a> that talks about obtaining the size and number of items in a folder. Careful examination of that article will reveal several points of similarity between it and today\u2019s script, ReportSpaceUsedByDeletedItems.ps1<\/b> script.<\/p>\n\n<\/thead>\n\n\n
\n

This week we are looking at scripting Office Outlook. Interestingly enough, the Office Outlook object model is not as rich as you might suspect. Certainly Office Word and Office Excel have far more capability for automation than Office Outlook. This having been said, a basic familiarity with Office Outlook automation can lend rich results for the enterprising network administrator, consultant, or power user. <\/p>\n

If you are interested in VBScript examples of working with Office Outlook, start with the “Hey, Scripting Guy!” archive<\/a>, and then move on to the Office Space archive<\/a>. Finally, you would probably like to see some examples of scripts for automating Office Outlook. You are in luck here because we have dozens of well-written scripts in the Community-Submitted Scripts Center<\/a>. Read on, this is going to be a cool week. If you need help with Windows PowerShell, you can find download links and getting started information in the Windows PowerShell technology hub<\/a>.<\/p>\n<\/td>\n<\/tr>\n<\/tbody>\n<\/table>\n

<\/div>\n

In the ReportSpaceUsedByDeletedItems.ps1<\/b> script, we create an instance of the Outlook.Application<\/b> object, make a collection that points to the Deleted Items folder, and walk through the collection of items while adding up their size. Here is today\u2019s script: <\/p>\n

ReportSpaceUsedByDeletedItems.ps1<\/b><\/p>\n

[Reflection.Assembly]::LoadWithPartialname(\"Microsoft.Office.Interop.Outlook\") |\nout-null\n$i = $size = $null\n$olFolders = \"Microsoft.Office.Interop.Outlook.OlDefaultFolders\" -as [type]\n$outlook = new-object -comobject outlook.application\n$namespace = $outlook.GetNameSpace(\"MAPI\")\n$folder = $namespace.getDefaultFolder($olFolders::olFolderDeletedItems)\n$items = $folder.items\nWrite-Host -ForeGroundColor Green \"There are $($items.count) items in the deleted items folder\"\n$folder.items |\nForeach-Object {\n Write-Progress -Activity \"Talleying size of Deleted items\" -Status \"Adding them up ...\" -PercentComplete ($i\/$items.count*100)\n $size += $_.size\n $i ++\n}\n$size = \"{0:N2}\" -f ($size\/1024)\nWrite-Host -foregroundcolor Red \"The deleted items are consuming $Size kilobytes of space\"\n<\/pre>\n
The first thing we need to do is to load the Office Outlook interop assembly. This will give us the ability to load the Office Outlook folder enumerations for the default folder names. It will also give us the ability to use other things from the Office Outlook automation model. To load the Microsoft.Office.Interop.Outlook<\/b> assembly, we use the static LoadWithPartialName<\/b> method from the reflection.assembly<\/b> .NET Framework class as seen here (in Windows PowerShell 2.0 we will be able to use a cmdlet to load the assembly, and the process will be a bit less cryptic if not actually easier):<\/p>\n
[Reflection.Assembly]::LoadWithPartialname(\"Microsoft.Office.Interop.Outlook\") |\nout-null\n<\/pre>\n
Now we need to initialize variables. There are actually three variables here. The first two are user defined, $i<\/b> and $size<\/b>. We are saying we want them to be equal to the same thing the $null<\/b> automatic variable is equal to, which of course is null. This is a nice tight syntax that makes it easy to initialize our variables. As a best practice for Windows PowerShell (and even for VBScript), one should always initialize variables before using them. In this way, we know exactly what the value of the variable is when the script runs:<\/p>\n
$i = $size = $null<\/pre>\n
When we are done initializing our variables, we want to load the olDefaultFolders<\/b> enumeration. The olDefaultFolders<\/b> enumeration is documented on MSDN<\/a>. To load the olDefaultFolders<\/b> enumeration, we place the enumeration name in quotation marks (making it a string) and then we use the \u2013as<\/b> operator to cast the string as a type. This sounds much worse than it is. Here is the code:<\/p>\n
$olFolders = \"Microsoft.Office.Interop.Outlook.OlDefaultFolders\" -as [type]<\/pre>\n
Then we create an instance of the Outlook.Application<\/b> object. The Outlook.Application<\/b> object is the main object to use when working with Office Outlook automation. The Outlook.Application<\/b> object is documented on MSDN<\/a>. To create the object, we use the New-Object<\/b> cmdlet with the comobject<\/b> parameter. The program ID is Outlook.Application<\/b>. We store the returned object in the $outlook<\/b> variable as seen here: <\/p>\n
$outlook = new-object -comobject outlook.application<\/pre>\n
It is time to create the namespace<\/b> object. To do this, we use the GetNameSpace<\/b> method. We tell it to use MAPI because this is the only constructor that will work for this method. And because the GetNameSpace<\/b> method is a method, we need to use parentheses when we are passing a value to the method. All methods in Windows PowerShell use parentheses. This is seen here:<\/p>\n
$namespace = $outlook.GetNameSpace(\"MAPI\")<\/pre>\n
Now we want to connect to the Deleted Items folder. To connect to a folder, we use the GetDefaultFolder<\/b> method and give it one of the olDefaultFolders<\/b> enumeration values. If you are unsure which enumeration values are allowed, you can either look them up on MSDN or use the technique we talked about in yesterday’s article<\/a>. When using one of the olDefaultFolders<\/b> enumeration values, we use double colons to separate the variable containing the enumeration type from the name of the enumeration (think about accessing a static property):<\/p>\n
$folder = $namespace.getDefaultFolder($olFolders::olFolderDeletedItems)<\/pre>\n
Then we use the items<\/b> property from the folder<\/b> object to obtain a collection of items from the Deleted Items folder: <\/p>\n
$items = $folder.items<\/pre>\n
We now print out a status message that tells the user how many items are in the Deleted Items folder. This is easy to do and happens nearly immediately. In this line of code, we are using the Write-Host<\/b> cmdlet to print to the screen. Normally, we do not need to use Write-Host<\/b> cmdlet, but we want the text to appear in green. We can use any color that is documented in the System.ConsoleColor<\/b> enumeration class. If you do not want to look the enumeration up on MSDN, you can use the GetNames<\/b> static method from the System.Enum<\/b> .NET Framework class. This is seen here:<\/p>\n
PS C:\\> [enum]::GetNames(\"System.ConsoleColor\")\nBlack\nDarkBlue\nDarkGreen\nDarkCyan\nDarkRed\nDarkMagenta\nDarkYellow\nGray\nDarkGray\nBlue\nGreen\nCyan\nRed\nMagenta\nYellow\nWhite\n<\/pre>\n
The other thing we do is print out the number of items in the items<\/b> collection. To do this, we need to evaluate the count<\/b> property. To force the count<\/b> property to be evaluated prior to returning the number of items, we use the subexpression $() <\/b>to surround the property (if we did not use the subexpression, the object would unravel inside our string and fill the screen with gobbledygook<\/a>): <\/p>\n
Write-Host -ForeGroundColor Green \"There are $($items.count) items in the deleted items folder\"<\/pre>\n
Next we want to add up the size of all the messages in the Deleted Items folder. This will take a bit of time, but we can use pipelining to help it to go more efficiently. We take the items<\/b> collection and pipeline it to the next part of the code by using the pipeline symbol (“|”):<\/p>\n
$folder.items |<\/pre>\n
We pipeline the collection of items to the ForEach-Object<\/b> cmdlet to allow us to work with individual items from the collection:<\/p>\n
ForEach-Object {<\/pre>\n
As this operation is happening, we use the Write-Progress<\/b> cmdlet to display feedback to the user. Depending on the number of deleted items, the operation could take a substantial amount of time. We specify three parameters for the Write-Progress<\/b> cmdlet: the activity<\/b>, the status<\/b>, and the percentcomplete<\/b>. This is seen here:<\/p>\n
Write-Progress -Activity \"Talleying size of Deleted items\" -Status \"Adding them up ...\" -PercentComplete ($i\/$items.count*100)<\/pre>\n
We now want to maintain a running tally of the size of the deleted items. To do this, we use the size<\/b> property of the object and add it to the $size<\/b> variable. To take the current value and add the new value to it, we use the +=<\/b> operator: <\/p>\n
 $size += $_.size<\/pre>\n
We increment the $i<\/b> variable because it is the one we are using to track our progress and to provide feedback to the user via the Write-Progress<\/b> cmdlet: <\/p>\n
 $i ++\n}\n<\/pre>\n
Now want to format the number that is displayed. To format the number, we use the .NET Framework standard format strings which are documented on MSDN<\/a>. In our example, N<\/b> means we are formatting a number; the 2<\/b> means we will use two decimal places; and the 0<\/b> means to format it with the default pattern: <\/p>\n
$size = \"{0:N2}\" -f ($size\/1024)<\/pre>\n
The last thing we need to do is to report the total size of deleted items. We once again use the Write-Host<\/b> cmdlet and this time we make the color of the text red. Because the $size<\/b> variable is a simple variable, and not an object or a method or property that needs to be evaluated, we do not need to use a subexpression when printing out the value. This is seen here: <\/p>\n
Write-Host -foregroundcolor Red \"The deleted items are consuming $Size kilobytes of space\"<\/pre>\n
The result from running the ReportSpaceUsedByDeletedItems.ps1<\/b> script is seen here:<\/p>\n
\"Image<\/p>\n
 <\/p>\n
Well, JH, that is it for the ReportSpaceUsedByDeletedItems.ps1<\/b> script. I hope you have enjoyed the article and that you will find the script useful. Stay tuned tomorrow, when we continue with Office Outlook Week. See you then.<\/p>\n
 <\/p>\n
Ed Wilson and Craig Liebendorfer, Scripting Guys<\/b><\/p>\n","protected":false},"excerpt":{"rendered":"
Hey, Scripting Guy! My users seem to think that once they delete an e-mail message, it is gone. Most do not have the concept of going and emptying their Deleted Items folder. Using Windows PowerShell on Exchange, I can easily obtain a report from the server about how much space this stuff is taking up. […]<\/p>\n","protected":false},"author":595,"featured_media":87096,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"_acf_changed":false,"footnotes":""},"categories":[1],"tags":[212,49,3,45],"class_list":["post-54513","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-scripting","tag-microsoft-outlook","tag-office","tag-scripting-guy","tag-windows-powershell"],"acf":[],"blog_post_summary":"
Hey, Scripting Guy! My users seem to think that once they delete an e-mail message, it is gone. Most do not have the concept of going and emptying their Deleted Items folder. Using Windows PowerShell on Exchange, I can easily obtain a report from the server about how much space this stuff is taking up. […]<\/p>\n","_links":{"self":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/54513","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/users\/595"}],"replies":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/comments?post=54513"}],"version-history":[{"count":0,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/posts\/54513\/revisions"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media\/87096"}],"wp:attachment":[{"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/media?parent=54513"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/categories?post=54513"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/devblogs.microsoft.com\/scripting\/wp-json\/wp\/v2\/tags?post=54513"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}