320 lines
10 KiB
PowerShell
320 lines
10 KiB
PowerShell
#
|
|
# Create-Folders.ps1
|
|
#
|
|
# By David Barrett, Microsoft Ltd. 2013. Use at your own risk. No warranties are given.
|
|
#
|
|
# DISCLAIMER:
|
|
# THIS CODE IS SAMPLE CODE. THESE SAMPLES ARE PROVIDED "AS IS" WITHOUT WARRANTY OF ANY KIND.
|
|
# MICROSOFT FURTHER DISCLAIMS ALL IMPLIED WARRANTIES INCLUDING WITHOUT LIMITATION ANY IMPLIED WARRANTIES OF MERCHANTABILITY OR OF FITNESS FOR
|
|
# A PARTICULAR PURPOSE. THE ENTIRE RISK ARISING OUT OF THE USE OR PERFORMANCE OF THE SAMPLES REMAINS WITH YOU. IN NO EVENT SHALL
|
|
# MICROSOFT OR ITS SUPPLIERS BE LIABLE FOR ANY DAMAGES WHATSOEVER (INCLUDING, WITHOUT LIMITATION, DAMAGES FOR LOSS OF BUSINESS PROFITS,
|
|
# BUSINESS INTERRUPTION, LOSS OF BUSINESS INFORMATION, OR OTHER PECUNIARY LOSS) ARISING OUT OF THE USE OF OR INABILITY TO USE THE
|
|
# SAMPLES, EVEN IF MICROSOFT HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. BECAUSE SOME STATES DO NOT ALLOW THE EXCLUSION OR LIMITATION
|
|
# OF LIABILITY FOR CONSEQUENTIAL OR INCIDENTAL DAMAGES, THE ABOVE LIMITATION MAY NOT APPLY TO YOU.
|
|
|
|
param (
|
|
[Parameter(Position=0,Mandatory=$True,HelpMessage="Specifies the mailbox to be accessed")]
|
|
[ValidateNotNullOrEmpty()]
|
|
[string]$Mailbox,
|
|
|
|
[Parameter(Position=1,Mandatory=$True,HelpMessage="Specifies the folder(s) that should be checked/created. For multiple folders, separate using semicolon")]
|
|
[ValidateNotNullOrEmpty()]
|
|
[string]$RequiredFolders,
|
|
|
|
[Parameter(Mandatory=$False,HelpMessage="The folder that should contain the subfolders (default is Inbox)")]
|
|
[string]$ParentFolder,
|
|
|
|
[Parameter(Mandatory=$False,HelpMessage="Username used to authenticate with EWS")]
|
|
[string]$AuthUsername,
|
|
|
|
[Parameter(Mandatory=$False,HelpMessage="Password used to authenticate with EWS")]
|
|
[string]$AuthPassword,
|
|
|
|
[Parameter(Mandatory=$False,HelpMessage="Domain used to authenticate with EWS")]
|
|
[string]$AuthDomain,
|
|
|
|
[Parameter(Mandatory=$False,HelpMessage="Whether we are using impersonation to access the mailbox")]
|
|
[switch]$Impersonate,
|
|
|
|
[Parameter(Mandatory=$False,HelpMessage="EWS Url (if omitted, then autodiscover is used)")]
|
|
[string]$EwsUrl,
|
|
|
|
[Parameter(Mandatory=$False,HelpMessage="Path to managed API (if omitted, a search of standard paths is performed)")]
|
|
[string]$EWSManagedApiPath = $Env:ProgramFiles + "\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll",
|
|
|
|
[Parameter(Mandatory=$False,HelpMessage="Whether to ignore any SSL errors (e.g. invalid certificate)")]
|
|
[switch]$IgnoreSSLCertificate,
|
|
|
|
[Parameter(Mandatory=$False,HelpMessage="Whether to allow insecure redirects when performing autodiscover")]
|
|
[switch]$AllowInsecureRedirection,
|
|
|
|
[Parameter(Mandatory=$False,HelpMessage="If specified, no changes will be applied")]
|
|
[switch]$WhatIf
|
|
|
|
)
|
|
write-host "Function start..."
|
|
|
|
Function SearchDll()
|
|
{
|
|
# Search for a program/library within Program Files (x64 and x86)
|
|
$path = $args[0]
|
|
$programDir = $Env:ProgramFiles
|
|
if (Get-Item -Path ($programDir + $path) -ErrorAction SilentlyContinue)
|
|
{
|
|
return $programDir + $path
|
|
}
|
|
|
|
$programDir = [environment]::GetEnvironmentVariable("ProgramFiles(x86)")
|
|
if ( [string]::IsNullOrEmpty($programDir) ) { return "" }
|
|
|
|
if (Get-Item -Path ($programDir + $path) -ErrorAction SilentlyContinue)
|
|
{
|
|
return $programDir + $path
|
|
}
|
|
}
|
|
|
|
Function LoadEWSManagedAPI()
|
|
{
|
|
# Check EWS Managed API available
|
|
|
|
if ( !(Get-Item -Path $EWSManagedApiPath -ErrorAction SilentlyContinue) )
|
|
{
|
|
#$EWSManagedApiPath = SearchDll("\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll")
|
|
$EWSManagedApiPath = "C:\Program Files\Microsoft\Exchange\Web Services\2.0\Microsoft.Exchange.WebServices.dll"
|
|
Write-Host "EWSManagedApiPath: $EWSManagedApiPath"
|
|
if ( [string]::IsNullOrEmpty($EWSManagedApiPath) )
|
|
{
|
|
$EWSManagedApiPath = SearchDll("\Microsoft\Exchange\Web Services\1.2\Microsoft.Exchange.WebServices.dll")
|
|
if ( [string]::IsNullOrEmpty($EWSManagedApiPath) )
|
|
{
|
|
$EWSManagedApiPath = SearchDll("\Microsoft\Exchange\Web Services\1.1\Microsoft.Exchange.WebServices.dll")
|
|
}
|
|
}
|
|
}
|
|
|
|
If ( ![string]::IsNullOrEmpty($EWSManagedApiPath) )
|
|
{
|
|
# Load EWS Managed API
|
|
Write-Host ([string]::Format("Using managed API found at: {0}", $EWSManagedApiPath))
|
|
Add-Type -Path $EWSManagedApiPath
|
|
return $true
|
|
}
|
|
return $false
|
|
}
|
|
|
|
Function GetFolder()
|
|
{
|
|
# Return a reference to a folder specified by path
|
|
Write-Host "Starting GetFolder function"
|
|
|
|
$RootFolder, $FolderPath = $args[0]
|
|
|
|
$Folder = $RootFolder
|
|
if ($FolderPath -ne '\')
|
|
{
|
|
$PathElements = $FolderPath -split '\\'
|
|
For ($i=0; $i -lt $PathElements.Count; $i++)
|
|
{
|
|
if ($PathElements[$i])
|
|
{
|
|
$View = New-Object Microsoft.Exchange.WebServices.Data.FolderView(2,0)
|
|
$View.PropertySet = [Microsoft.Exchange.WebServices.Data.BasePropertySet]::IdOnly
|
|
|
|
$SearchFilter = New-Object Microsoft.Exchange.WebServices.Data.SearchFilter+IsEqualTo([Microsoft.Exchange.WebServices.Data.FolderSchema]::DisplayName, $PathElements[$i])
|
|
|
|
$FolderResults = $Folder.FindFolders($SearchFilter, $View)
|
|
if ($FolderResults.TotalCount -ne 1)
|
|
{
|
|
# We have either none or more than one folder returned... Either way, we can't continue
|
|
$Folder = $null
|
|
Write-Host ([string]::Format("Failed to find {0}", $PathElements[$i]))
|
|
Write-Host ([string]::Format("Requested folder path: {0}", $FolderPath))
|
|
break
|
|
}
|
|
|
|
$Folder = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service, $FolderResults.Folders[0].Id)
|
|
}
|
|
}
|
|
}
|
|
|
|
return $Folder
|
|
}
|
|
|
|
Function CreateFolders()
|
|
{
|
|
$FolderId = $args[0]
|
|
Write-Host "Binding to folder with id $FolderId"
|
|
$folder = [Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$FolderId)
|
|
if (!$folder) { return }
|
|
|
|
foreach ($requiredFolder in $FolderCheckList)
|
|
{
|
|
Write-Host "Checking for existence of $requiredFolder"
|
|
$rf = GetFolder( $folder, $requiredFolder )
|
|
if ( $rf )
|
|
{
|
|
Write-Host "$requiredFolder already exists" -ForegroundColor Green
|
|
}
|
|
Else
|
|
{
|
|
# Create the folder
|
|
if (!$WhatIf)
|
|
{
|
|
$rf = New-Object Microsoft.Exchange.WebServices.Data.Folder($service)
|
|
$rf.DisplayName = $requiredFolder
|
|
$rf.Save($FolderId)
|
|
if ($rf.Id.UniqueId)
|
|
{
|
|
Write-Host "$requiredFolder created successfully" -ForegroundColor Green
|
|
}
|
|
}
|
|
Else
|
|
{
|
|
Write-Host "$requiredFolder would be created" -ForegroundColor Yellow
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
Function ProcessMailbox()
|
|
{
|
|
# Process mailbox
|
|
|
|
Write-Host "Processing mailbox $Mailbox" -ForegroundColor White
|
|
if ( $WhatIf )
|
|
{
|
|
Write-Host "NO CHANGES WILL BE APPLIED" -ForegroundColor Red
|
|
}
|
|
|
|
# Set EWS URL if specified, or use autodiscover if no URL specified.
|
|
Write-Host "EWS: $EwsUrl"
|
|
if ($EwsUrl)
|
|
{
|
|
|
|
$service.URL = New-Object Uri($EwsUrl)
|
|
Write-Host "EWS: $($service.URL)"
|
|
}
|
|
else
|
|
{
|
|
Write-Host "Performing autodiscover for $Mailbox"
|
|
if ( $AllowInsecureRedirection )
|
|
{
|
|
$service.AutodiscoverUrl($Mailbox, {$True})
|
|
}
|
|
else
|
|
{
|
|
$service.AutodiscoverUrl($Mailbox)
|
|
}
|
|
if ([string]::IsNullOrEmpty($service.Url))
|
|
{
|
|
Write-Host "Autodiscover failed, cannot process mailbox" -ForegroundColor Red
|
|
return
|
|
}
|
|
Write-Host ([string]::Format("EWS Url found: {0}", $service.Url))
|
|
}
|
|
|
|
Write-Host "Impersonating ?"
|
|
# Set impersonation if specified
|
|
if ($Impersonate)
|
|
{
|
|
Write-Host "Impersonating $Mailbox"
|
|
$service.ImpersonatedUserId = New-Object Microsoft.Exchange.WebServices.Data.ImpersonatedUserId([Microsoft.Exchange.WebServices.Data.ConnectingIdType]::SmtpAddress, $Mailbox)
|
|
$FolderId = [Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::Inbox
|
|
Write-Host $FolderId
|
|
}
|
|
else
|
|
{
|
|
# If we're not impersonating, we will specify the mailbox in case we are accessing a mailbox that is not the authenticating account's
|
|
Write-Host "Mailbox: $Mailbox"
|
|
$mbx = New-Object Microsoft.Exchange.WebServices.Data.Mailbox( $Mailbox )
|
|
Write-Host "MBX Object created: $mbx"
|
|
$FolderId = New-Object Microsoft.Exchange.WebServices.Data.FolderId([Microsoft.Exchange.WebServices.Data.WellKnownFolderName]::Inbox, $mbx )
|
|
Write-Host $FolderId
|
|
}
|
|
|
|
Write-Host "ParentFolder: $ParentFolder"
|
|
if ($ParentFolder)
|
|
{
|
|
Write-Host $service, $FolderId, $ParentFolder
|
|
#GetFolder
|
|
$Folder = GetFolder([Microsoft.Exchange.WebServices.Data.Folder]::Bind($service,$FolderId), $ParentFolder)
|
|
Write-Host $service, $FolderId, $ParentFolder
|
|
if (!$FolderId)
|
|
{
|
|
Write-Host "Failed to find folder $ParentFolder" -ForegroundColor Red
|
|
return
|
|
}
|
|
$FolderId = $Folder.Id
|
|
}
|
|
|
|
Write-Host "Calling CreateFolders function"
|
|
CreateFolders $FolderId
|
|
}
|
|
|
|
|
|
# The following is the main script
|
|
|
|
|
|
if (!(LoadEWSManagedAPI))
|
|
{
|
|
Write-Host "Failed to locate EWS Managed API, cannot continue" -ForegroundColor Red
|
|
Exit
|
|
}
|
|
|
|
Write-Host "Service binding.."
|
|
$service = New-Object Microsoft.Exchange.WebServices.Data.ExchangeService([Microsoft.Exchange.WebServices.Data.ExchangeVersion]::Exchange2010)
|
|
|
|
# If we are ignoring any SSL errors, set up a callback
|
|
if ($IgnoreSSLCertificate)
|
|
{
|
|
Write-Host "WARNING: Ignoring any SSL certificate errors" -ForegroundColor Yellow
|
|
[System.Net.ServicePointManager]::ServerCertificateValidationCallback = { $true }
|
|
}
|
|
|
|
# Set credentials if specified, or use logged on user.
|
|
if ($AuthUsername -and $AuthPassword)
|
|
{
|
|
Write-Host "Applying given credentials for", $AuthUsername
|
|
if ($AuthDomain)
|
|
{
|
|
$service.Credentials = New-Object Microsoft.Exchange.WebServices.Data.WebCredentials($AuthUsername,$AuthPassword,$AuthDomain)
|
|
} else {
|
|
$service.Credentials = New-Object Microsoft.Exchange.WebServices.Data.WebCredentials($AuthUsername,$AuthPassword)
|
|
}
|
|
|
|
} else {
|
|
Write-Host "Using default credentials"
|
|
$service.UseDefaultCredentials = $true
|
|
}
|
|
|
|
if ($RequiredFolders.Contains(";"))
|
|
{
|
|
# Have more than one folder to check, so convert to array
|
|
$FolderCheckList = $RequiredFolders -split ';'
|
|
}
|
|
else
|
|
{
|
|
$FolderCheckList = $RequiredFolders
|
|
}
|
|
|
|
|
|
# Check whether we have a CSV file as input...
|
|
$FileExists = Test-Path $Mailbox
|
|
If ( $FileExists )
|
|
{
|
|
# We have a CSV to process
|
|
$csv = Import-CSV $Mailbox
|
|
foreach ($entry in $csv)
|
|
{
|
|
$Mailbox = $entry.PrimarySmtpAddress
|
|
if ( [string]::IsNullOrEmpty($Mailbox) -eq $False )
|
|
{
|
|
ProcessMailbox
|
|
}
|
|
}
|
|
}
|
|
Else
|
|
{
|
|
# Process as single mailbox
|
|
ProcessMailbox
|
|
} |