/// <summary>
/// Creates a request for the SyncFolderHierarchy operation.
/// </summary>
/// <param name="folder">A default folder name.</param>
/// <param name="defaultShapeNames">Standard sets of properties to return.</param>
/// <param name="isSyncFolderIdPresent">A Boolean value indicates whether the SyncFolderId element present in the request.</param>
/// <param name="isSyncStatePresent">A Boolean value indicates whether the SyncState element present in the request.</param>
/// <returns>An instance of SyncFolderHierarchyType used by the SyncFolderHierarchy operation.</returns>
public static SyncFolderHierarchyType CreateSyncFolderHierarchyRequest(
DistinguishedFolderIdNameType folder,
DefaultShapeNamesType defaultShapeNames,
bool isSyncFolderIdPresent,
bool isSyncStatePresent)
{
// Create an instance of SyncFolderHierarchyType
SyncFolderHierarchyType request = new SyncFolderHierarchyType();
request.FolderShape = new FolderResponseShapeType();
request.FolderShape.BaseShape = defaultShapeNames;
// Set the value of SyncFolderId if this element is present in the request.
if (isSyncFolderIdPresent)
{
request.SyncFolderId = new TargetFolderIdType();
DistinguishedFolderIdType distinguishedFolderId = new DistinguishedFolderIdType();
distinguishedFolderId.Id = folder;
request.SyncFolderId.Item = distinguishedFolderId;
}
// Set the value of SyncState element if this element is present in the request.
if (isSyncStatePresent)
{
request.SyncState = string.Empty;
}
return(request);
}
public PXSyncMovingMessageCondition(ExchangeEmailsSyncCommand command, DistinguishedFolderIdNameType parent, bool incomming, bool outgoing)
: base(parent)
{
Incomming = incomming;
Outgoing = outgoing;
Command = command;
}
public FolderIdType FindFolderID(ExchangeServiceBinding service, DistinguishedFolderIdNameType folder)
{
FindFolderType requestFindFolder = new FindFolderType();
requestFindFolder.Traversal = FolderQueryTraversalType.Deep;
DistinguishedFolderIdType[] folderIDArray = new DistinguishedFolderIdType[1];
folderIDArray[0] = new DistinguishedFolderIdType();
folderIDArray[0].Id = folder;
FolderResponseShapeType itemProperties = new FolderResponseShapeType();
itemProperties.BaseShape = DefaultShapeNamesType.AllProperties;
requestFindFolder.ParentFolderIds = folderIDArray;
requestFindFolder.FolderShape = itemProperties;
//requestFindFolder.FolderShape.BaseShape = DefaultShapeNamesType.AllProperties;
FindFolderResponseType objFindFolderResponse = service.FindFolder(requestFindFolder);
foreach (ResponseMessageType responseMsg in objFindFolderResponse.ResponseMessages.Items)
{
if (responseMsg.ResponseClass == ResponseClassType.Success)
{
FindFolderResponseMessageType objFindResponse = responseMsg as FindFolderResponseMessageType;
foreach (BaseFolderType objFolderType in objFindResponse.RootFolder.Folders)
{
return(objFolderType.FolderId);
}
}
}
return(null);
}
/// <summary>
/// Log on to a mailbox with a specified user account and find the specified folder, then delete it if it is found.
/// </summary>
/// <param name="userName">Name of the user.</param>
/// <param name="userPassword">Password of the user.</param>
/// <param name="userDomain">Domain of the user.</param>
/// <param name="parentFolderName">Name of the parent folder.</param>
/// <param name="subFolderName">Name of the folder which will be updated.</param>
/// <returns>If the folder is deleted successfully, return true; otherwise, return false.</returns>
public bool FindAndDeleteSubFolder(string userName, string userPassword, string userDomain, string parentFolderName, string subFolderName)
{
// Switch to specified user mailbox.
bool isSwitched = AdapterHelper.SwitchUser(userName, userPassword, userDomain, this.exchangeServiceBinding, this.Site);
Site.Assert.IsTrue(
isSwitched,
string.Format("Log on mailbox with the UserName: {0}, Password: {1}, Domain: {2} should be successful.", userName, userPassword, userDomain));
// Parse the parent folder name to DistinguishedFolderIdNameType.
DistinguishedFolderIdNameType parentFolderIdName = (DistinguishedFolderIdNameType)Enum.Parse(typeof(DistinguishedFolderIdNameType), parentFolderName, true);
DeleteFolderType deleteFolderRequest = new DeleteFolderType();
deleteFolderRequest.DeleteType = DisposalType.HardDelete;
deleteFolderRequest.FolderIds = new BaseFolderIdType[1];
deleteFolderRequest.FolderIds[0] = this.FindSubFolder(parentFolderIdName, subFolderName);
// Invoke the DeleteFolder operation and get the response.
DeleteFolderResponseType deleteFolderResponse = this.exchangeServiceBinding.DeleteFolder(deleteFolderRequest);
bool isDeleted = false;
if (deleteFolderResponse != null && deleteFolderResponse.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Success)
{
// If the DeleteFolder operation succeeds, return true.
isDeleted = true;
}
return(isDeleted);
}
/// <summary>
/// Log on to a mailbox with a specified user account and check whether the specified calendar item is cancelled or not.
/// </summary>
/// <param name="userName">Name of the user.</param>
/// <param name="userPassword">Password of the user.</param>
/// <param name="userDomain">Domain of the user.</param>
/// <param name="folderName">Name of the folder which should be searched for the specified meeting message.</param>
/// <param name="itemSubject">Subject of the meeting message which should exist.</param>
/// <returns>If the specified calendar item exists and is canceled, return true, otherwise return false.</returns>
public bool IsCalendarItemCanceled(string userName, string userPassword, string userDomain, string folderName, string itemSubject)
{
// Parse the parent folder name to DistinguishedFolderIdNameType.
DistinguishedFolderIdNameType parentFolderIdName = (DistinguishedFolderIdNameType)Enum.Parse(typeof(DistinguishedFolderIdNameType), folderName, true);
// Switch to specified user mailbox.
bool isSwitched = AdapterHelper.SwitchUser(userName, userPassword, userDomain, this.exchangeServiceBinding, this.Site);
Site.Assert.IsTrue(
isSwitched,
string.Format("Log on mailbox with the UserName: {0}, Password: {1}, Domain: {2} should be successful.", userName, userPassword, userDomain));
// Loop to find the meeting message
ItemType item = this.LoopToFindItem(parentFolderIdName, itemSubject, Item.CalendarItem);
if (item != null)
{
CalendarItemType calendarItem = item as CalendarItemType;
// If the IsCancelled property of the item is true, return true
if (calendarItem.IsCancelled == true)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
/// <summary>
/// Log on to a mailbox with a specified user account and find the specified item then delete it.
/// </summary>
/// <param name="userName">Name of the user.</param>
/// <param name="userPassword">Password of the user.</param>
/// <param name="userDomain">Domain of the user.</param>
/// <param name="folderName">Name of the folder which should be searched for the specified item.</param>
/// <param name="itemSubject">Subject of the item which should be deleted.</param>
/// <param name="itemType">Type of the item which should be deleted.</param>
/// <returns>If the specified item is deleted successfully, return true; otherwise, return false.</returns>
public bool FindAndDeleteItem(string userName, string userPassword, string userDomain, string folderName, string itemSubject, string itemType)
{
// Switch to specified user mailbox.
bool isSwitched = AdapterHelper.SwitchUser(userName, userPassword, userDomain, this.exchangeServiceBinding, this.Site);
Site.Assert.IsTrue(
isSwitched,
string.Format("Log on mailbox with the UserName: {0}, Password: {1}, Domain: {2} should be successful.", userName, userPassword, userDomain));
// Parse the parent folder name to DistinguishedFolderIdNameType.
DistinguishedFolderIdNameType parentFolderIdName = (DistinguishedFolderIdNameType)Enum.Parse(typeof(DistinguishedFolderIdNameType), folderName, true);
Item item = (Item)Enum.Parse(typeof(Item), itemType, true);
ItemType type = this.LoopToFindItem(parentFolderIdName, itemSubject, item);
bool isDeleted = false;
if (type != null)
{
DeleteItemType deleteItemRequest = new DeleteItemType();
deleteItemRequest.ItemIds = new BaseItemIdType[] { type.ItemId };
// Invoke the delete item operation and get the response.
DeleteItemResponseType response = this.exchangeServiceBinding.DeleteItem(deleteItemRequest);
if (response != null && response.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Success)
{
// If delete operation succeeds, return true
isDeleted = true;
}
}
return(isDeleted);
}
/// <summary>
/// Find all the items in the specified folder.
/// </summary>
/// <param name="folderName">Name of the specified folder.</param>
/// <returns>An array of found items.</returns>
private ItemType[] FindAllItems(DistinguishedFolderIdNameType folderName)
{
// Create an array of ItemType.
ItemType[] items = null;
// Create an instance of FindItemType.
FindItemType findItemRequest = new FindItemType();
findItemRequest.ParentFolderIds = new BaseFolderIdType[1];
DistinguishedFolderIdType parentFolder = new DistinguishedFolderIdType();
parentFolder.Id = folderName;
findItemRequest.ParentFolderIds[0] = parentFolder;
// Get properties that are defined as the default for the items.
findItemRequest.ItemShape = new ItemResponseShapeType();
findItemRequest.ItemShape.BaseShape = DefaultShapeNamesType.Default;
// Invoke the FindItem operation.
FindItemResponseType findItemResponse = this.exchangeServiceBinding.FindItem(findItemRequest);
if (findItemResponse != null && findItemResponse.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Success)
{
// Get the found items from the response.
FindItemResponseMessageType findItemMessage = findItemResponse.ResponseMessages.Items[0] as FindItemResponseMessageType;
ArrayOfRealItemsType findItems = findItemMessage.RootFolder.Item as ArrayOfRealItemsType;
items = findItems.Items;
}
return(items);
}
/// <summary>
/// Find all the sub folders in the specified folder.
/// </summary>
/// <param name="parentFolderName">Name of the specified parent folder.</param>
/// <returns>An array of found sub folders.</returns>
private BaseFolderType[] FindAllSubFolders(DistinguishedFolderIdNameType parentFolderName)
{
// Create an array of BaseFolderType.
BaseFolderType[] folders = null;
// Create the request and specify the traversal type.
FindFolderType findFolderRequest = new FindFolderType();
findFolderRequest.Traversal = FolderQueryTraversalType.Deep;
// Define the properties to be returned in the response.
FolderResponseShapeType responseShape = new FolderResponseShapeType();
responseShape.BaseShape = DefaultShapeNamesType.Default;
findFolderRequest.FolderShape = responseShape;
// Identify which folders to search.
DistinguishedFolderIdType[] folderIDArray = new DistinguishedFolderIdType[1];
folderIDArray[0] = new DistinguishedFolderIdType();
folderIDArray[0].Id = parentFolderName;
// Add the folders to search to the request.
findFolderRequest.ParentFolderIds = folderIDArray;
FindFolderResponseType findFolderResponse = this.exchangeServiceBinding.FindFolder(findFolderRequest);
FindFolderResponseMessageType findFolderResponseMessageType = new FindFolderResponseMessageType();
if (findFolderResponse != null && findFolderResponse.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Success)
{
findFolderResponseMessageType = findFolderResponse.ResponseMessages.Items[0] as FindFolderResponseMessageType;
folders = findFolderResponseMessageType.RootFolder.Folders;
}
return(folders);
}
protected PXSyncMovingMessageCondition(ExchangeEmailsSyncCommand command, DistinguishedFolderIdNameType parent, BaseFolderIdType folder, bool incomming, bool outgoing)
: base(parent, folder)
{
Incomming = incomming;
Outgoing = outgoing;
Command = command;
}
public PXSyncFolderSpecification(string name, DistinguishedFolderIdNameType type, PXEmailSyncDirection.Directions direction, bool categorized, params PXSyncMovingCondition[] moveTo)
{
Name = name;
Type = type;
Categorized = categorized;
Direction = direction;
MoveTo = moveTo;
}
/// <summary>
/// Loop to find the item with the specified subject.
/// </summary>
/// <param name="folderName">Name of the specified folder.</param>
/// <param name="itemSubject">Subject of the specified item.</param>
/// <param name="itemType">Type of the specified item.</param>
/// <returns>Item with the specified subject.</returns>
private ItemType LoopToFindItem(DistinguishedFolderIdNameType folderName, string itemSubject, Item itemType)
{
ItemType[] items = null;
ItemType firstFoundItem = null;
int sleepTimes = 0;
// Get the query sleep delay and times from ptfconfig file.
int queryDelay = int.Parse(Common.GetConfigurationPropertyValue("WaitTime", this.Site));
int queryTimes = int.Parse(Common.GetConfigurationPropertyValue("RetryCount", this.Site));
// Loop to find the item, in case that the sent item has still not been received.
do
{
Thread.Sleep(queryDelay);
items = this.FindAllItems(folderName);
sleepTimes++;
}while (items == null && sleepTimes < queryTimes);
ItemType type = null;
switch (itemType)
{
case Item.MeetingRequest:
type = new MeetingRequestMessageType();
break;
case Item.MeetingResponse:
type = new MeetingResponseMessageType();
break;
case Item.MeetingCancellation:
type = new MeetingCancellationMessageType();
break;
case Item.CalendarItem:
type = new CalendarItemType();
break;
}
if (items != null)
{
// Find the item with the specified subject and store its ID.
for (int i = 0; i < items.Length; i++)
{
if (items[i].Subject.Contains(itemSubject) && items[i].GetType().ToString() == type.ToString())
{
firstFoundItem = items[i];
break;
}
}
}
return(firstFoundItem);
}
/// <summary>
/// Log on to a mailbox with a specified user account and find the specified meeting message in the Inbox folder, then accept it.
/// </summary>
/// <param name="userName">Name of the user.</param>
/// <param name="userPassword">Password of the user.</param>
/// <param name="userDomain">Domain of the user.</param>
/// <param name="itemSubject">Subject of the meeting message which should be accepted.</param>
/// <param name="itemType">Type of the item which should be accepted.</param>
/// <returns>If the specified meeting message is accepted successfully, return true; otherwise, return false.</returns>
public bool FindAndAcceptMeetingMessage(string userName, string userPassword, string userDomain, string itemSubject, string itemType)
{
// Define the Inbox folder as parent folder.
DistinguishedFolderIdNameType parentFolderIdName = DistinguishedFolderIdNameType.inbox;
// Switch to specified user mailbox.
bool isSwitched = AdapterHelper.SwitchUser(userName, userPassword, userDomain, this.exchangeServiceBinding, this.Site);
Site.Assert.IsTrue(
isSwitched,
string.Format("Log on mailbox with the UserName: {0}, Password: {1}, Domain: {2} should be successful.", userName, userPassword, userDomain));
Item item = (Item)Enum.Parse(typeof(Item), itemType, true);
// Loop to find the specified item in the specified folder.
ItemType type = this.LoopToFindItem(parentFolderIdName, itemSubject, item);
bool isAccepted = false;
if (type != null)
{
MeetingRequestMessageType message = type as MeetingRequestMessageType;
// Create a request for the CreateItem operation.
CreateItemType createItemRequest = new CreateItemType();
// Add the CalendarItemType item to the items to be created.
createItemRequest.Items = new NonEmptyArrayOfAllItemsType();
// Create an AcceptItemType item to reply to a meeting request.
AcceptItemType acceptItem = new AcceptItemType();
// Set the related meeting request.
acceptItem.ReferenceItemId = message.ItemId;
createItemRequest.Items.Items = new ItemType[] { acceptItem };
// Set the MessageDisposition property to SendOnly.
createItemRequest.MessageDisposition = MessageDispositionType.SendOnly;
createItemRequest.MessageDispositionSpecified = true;
// Invoke the CreateItem operation.
CreateItemResponseType createItemResponse = this.exchangeServiceBinding.CreateItem(createItemRequest);
if (createItemResponse != null && createItemResponse.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Success)
{
isAccepted = true;
}
}
return(isAccepted);
}
/// <summary>
/// Log on to a mailbox with a specified user account and find the specified folder then update the folder name of it.
/// </summary>
/// <param name="userName">Name of the user.</param>
/// <param name="userPassword">Password of the user.</param>
/// <param name="userDomain">Domain of the user.</param>
/// <param name="parentFolderName">Name of the parent folder.</param>
/// <param name="currentFolderName">Current name of the folder which will be updated.</param>
/// <param name="newFolderName">New name of the folder which will be updated to.</param>
/// <returns>If the name of the folder is updated successfully, return true; otherwise, return false.</returns>
public bool FindAndUpdateFolderName(string userName, string userPassword, string userDomain, string parentFolderName, string currentFolderName, string newFolderName)
{
// Switch to specified user mailbox.
bool isSwitched = AdapterHelper.SwitchUser(userName, userPassword, userDomain, this.exchangeServiceBinding, this.Site);
Site.Assert.IsTrue(
isSwitched,
string.Format("Log on mailbox with the UserName: {0}, Password: {1}, Domain: {2} should be successful.", userName, userPassword, userDomain));
// Parse the parent folder name to DistinguishedFolderIdNameType.
DistinguishedFolderIdNameType parentFolderIdName = (DistinguishedFolderIdNameType)Enum.Parse(typeof(DistinguishedFolderIdNameType), parentFolderName, true);
// Create UpdateFolder request
UpdateFolderType updateFolderRequest = new UpdateFolderType();
updateFolderRequest.FolderChanges = new FolderChangeType[1];
updateFolderRequest.FolderChanges[0] = new FolderChangeType();
updateFolderRequest.FolderChanges[0].Item = this.FindSubFolder(parentFolderIdName, currentFolderName);
// Identify the field to update and the value to set for it.
SetFolderFieldType displayName = new SetFolderFieldType();
PathToUnindexedFieldType displayNameProp = new PathToUnindexedFieldType();
displayNameProp.FieldURI = UnindexedFieldURIType.folderDisplayName;
FolderType updatedFolder = new FolderType();
updatedFolder.DisplayName = newFolderName;
displayName.Item = displayNameProp;
updatedFolder.DisplayName = newFolderName;
displayName.Item1 = updatedFolder;
// Add a single element into the array of changes.
updateFolderRequest.FolderChanges[0].Updates = new FolderChangeDescriptionType[1];
updateFolderRequest.FolderChanges[0].Updates[0] = displayName;
bool isFolderNameUpdated = false;
// Invoke the UpdateFolder operation and get the response.
UpdateFolderResponseType updateFolderResponse = this.exchangeServiceBinding.UpdateFolder(updateFolderRequest);
if (updateFolderResponse != null && ResponseClassType.Success == updateFolderResponse.ResponseMessages.Items[0].ResponseClass)
{
isFolderNameUpdated = true;
}
return(isFolderNameUpdated);
}
private ResponseMessageType[] GetFolderItems(ExchangeServiceBinding svc, DistinguishedFolderIdNameType folder)
{
// Form the FindItem request.
FindItemType findItemRequest = new FindItemType();
findItemRequest.Traversal = ItemQueryTraversalType.Shallow;
// Define which item properties are returned in the response.
ItemResponseShapeType itemProperties = new ItemResponseShapeType();
itemProperties.BaseShape = DefaultShapeNamesType.AllProperties;
//Define propriedade que armazena antigo ID
PathToExtendedFieldType netShowUrlPath = new PathToExtendedFieldType();
netShowUrlPath.PropertyTag = "0x3A4D";
netShowUrlPath.PropertyType = MapiPropertyTypeType.String;
//Adiciona propriedade na busca
itemProperties.AdditionalProperties = new BasePathToElementType[1];
itemProperties.AdditionalProperties[0] = netShowUrlPath;
// Add properties shape to the request.
findItemRequest.ItemShape = itemProperties;
// Identify which folders to search to find items.
DistinguishedFolderIdType[] folderIDArray = new DistinguishedFolderIdType[2];
folderIDArray[0] = new DistinguishedFolderIdType();
folderIDArray[0].Id = folder;
// Add folders to the request.
findItemRequest.ParentFolderIds = folderIDArray;
// Send the request and get the response.
FindItemResponseType findItemResponse = svc.FindItem(findItemRequest);
// Get the response messages.
ResponseMessageType[] rmta = findItemResponse.ResponseMessages.Items;
return(rmta);
}
/// <summary>
/// Find the specified sub folder.
/// </summary>
/// <param name="parentFolderName">Name of the specified parent folder.</param>
/// <param name="subFolderName">Name of the specified sub folder.</param>
/// <returns>Id of the folder.</returns>
private FolderIdType FindSubFolder(DistinguishedFolderIdNameType parentFolderName, string subFolderName)
{
FolderIdType folderId = new FolderIdType();
// Find all sub folders in the specified parent folder.
BaseFolderType[] folders = this.FindAllSubFolders(parentFolderName);
Site.Assert.IsNotNull(folders, "There should be at least one folder in the '{0}' folder.", parentFolderName);
// Find the item with the specified subject.
foreach (BaseFolderType currentFolder in folders)
{
if (currentFolder.DisplayName == subFolderName)
{
folderId = currentFolder.FolderId;
break;
}
}
Site.Assert.IsNotNull(folderId.Id, "There should be at least one folder with the specified subject '{0}'.", subFolderName);
return(folderId);
}
public BaseFolderType GetFolder(DistinguishedFolderIdNameType folderType)
{
var binding = ChannelHelper.BuildChannel(hostname, username, password);
var getFolderType = new GetFolderType
{
FolderIds = new[] { new DistinguishedFolderIdType {
Id = folderType
} },
FolderShape = new FolderResponseShapeType {
BaseShape = DefaultShapeNamesType.AllProperties
}
};
var getFolderResponse = binding.GetFolder(getFolderType);
if (getFolderResponse.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Error)
{
throw new Exception(getFolderResponse.ResponseMessages.Items[0].MessageText);
}
return(((FolderInfoResponseMessageType)getFolderResponse.ResponseMessages.Items[0]).Folders[0]);
}
/// <summary>
/// Generate the request message for operation "CreateFolder".
/// </summary>
/// <param name="parentFolderId">The folder identifier for the parent folder.</param>
/// <param name="folderNames">An array of display name of the folders to be created.</param>
/// <param name="folderClasses">An array of folder class value of the folders to be created.</param>
/// <param name="permissionSet">An array of permission set value of the folder.</param>
/// <returns>Create folder request instance that will send to server.</returns>
protected CreateFolderType GetCreateFolderRequest(string parentFolderId, string[] folderNames, string[] folderClasses, PermissionSetType[] permissionSet)
{
CreateFolderType createFolderRequest = new CreateFolderType();
createFolderRequest.ParentFolderId = new TargetFolderIdType();
DistinguishedFolderIdType distinguishedFolderId = new DistinguishedFolderIdType();
DistinguishedFolderIdNameType distinguishedFolderIdName = new DistinguishedFolderIdNameType();
bool isSuccess = Enum.TryParse<DistinguishedFolderIdNameType>(parentFolderId, true, out distinguishedFolderIdName);
if (isSuccess)
{
distinguishedFolderId.Id = distinguishedFolderIdName;
createFolderRequest.ParentFolderId.Item = distinguishedFolderId;
}
else
{
FolderIdType id = new FolderIdType();
id.Id = parentFolderId;
createFolderRequest.ParentFolderId.Item = id;
}
createFolderRequest = this.ConfigureFolderProperty(folderNames, folderClasses, permissionSet, createFolderRequest);
return createFolderRequest;
}
/// <summary>
/// Create item within a specific folder.
/// </summary>
/// <param name="toAddress">To address of created item</param>
/// <param name="folderId">Parent folder id of the created item.</param>
/// <param name="subject">Subject of the item.</param>
/// <returns>Id of created item.</returns>
protected ItemIdType CreateItem(string toAddress, string folderId, string subject)
{
CreateItemType createItemRequest = new CreateItemType();
createItemRequest.MessageDispositionSpecified = true;
createItemRequest.MessageDisposition = MessageDispositionType.SaveOnly;
createItemRequest.SendMeetingInvitations = CalendarItemCreateOrDeleteOperationType.SendToAllAndSaveCopy;
createItemRequest.SendMeetingInvitationsSpecified = true;
createItemRequest.SavedItemFolderId = new TargetFolderIdType();
DistinguishedFolderIdType distinguishedFolderId = new DistinguishedFolderIdType();
DistinguishedFolderIdNameType distinguishedFolderIdName = new DistinguishedFolderIdNameType();
bool isSuccess = Enum.TryParse<DistinguishedFolderIdNameType>(folderId, true, out distinguishedFolderIdName);
if (isSuccess)
{
distinguishedFolderId.Id = distinguishedFolderIdName;
createItemRequest.SavedItemFolderId.Item = distinguishedFolderId;
}
else
{
FolderIdType id = new FolderIdType();
id.Id = folderId;
createItemRequest.SavedItemFolderId.Item = id;
}
MessageType message = new MessageType();
message.Subject = subject;
EmailAddressType address = new EmailAddressType();
address.EmailAddress = toAddress;
// Set this message to unread.
message.IsRead = false;
message.IsReadSpecified = true;
message.ToRecipients = new EmailAddressType[1];
message.ToRecipients[0] = address;
BodyType body = new BodyType();
body.Value = Common.GenerateResourceName(this.Site, "Test Mail Body");
message.Body = body;
createItemRequest.Items = new NonEmptyArrayOfAllItemsType();
createItemRequest.Items.Items = new ItemType[1];
createItemRequest.Items.Items[0] = message;
CreateItemResponseType createItemResponse = this.COREAdapter.CreateItem(createItemRequest);
ItemInfoResponseMessageType itemInfo = (ItemInfoResponseMessageType)createItemResponse.ResponseMessages.Items[0];
// Return item id.
if (itemInfo.Items.Items != null)
{
return itemInfo.Items.Items[0].ItemId;
}
else
{
return null;
}
}
/// <summary>
/// Create an item in the specified folder.
/// </summary>
/// <param name="parentFolderType">Type of the parent folder.</param>
/// <param name="parentFolderId">ID of the parent folder.</param>
/// <param name="itemSubject">Subject of the item which should be created.</param>
/// <returns>ID of the created item.</returns>
protected ItemIdType CreateItem(DistinguishedFolderIdNameType parentFolderType, string parentFolderId, string itemSubject)
{
// Create a request for the CreateItem operation and initialize the ItemType instance.
CreateItemType createItemRequest = new CreateItemType();
ItemType item = null;
// Get different values for item based on different parent folder type.
switch (parentFolderType)
{
case DistinguishedFolderIdNameType.contacts:
ContactItemType contact = new ContactItemType();
contact.Subject = itemSubject;
contact.FileAs = itemSubject;
item = contact;
break;
case DistinguishedFolderIdNameType.calendar:
// Set the sendMeetingInvitations property.
CalendarItemCreateOrDeleteOperationType sendMeetingInvitations = CalendarItemCreateOrDeleteOperationType.SendToNone;
createItemRequest.SendMeetingInvitations = (CalendarItemCreateOrDeleteOperationType)sendMeetingInvitations;
createItemRequest.SendMeetingInvitationsSpecified = true;
CalendarItemType calendar = new CalendarItemType();
calendar.Subject = itemSubject;
item = calendar;
break;
case DistinguishedFolderIdNameType.inbox:
MessageType message = new MessageType();
message.Subject = itemSubject;
item = message;
break;
case DistinguishedFolderIdNameType.tasks:
TaskType taskItem = new TaskType();
taskItem.Subject = itemSubject;
item = taskItem;
break;
default:
Site.Assert.Fail("The parent folder type '{0}' is invalid and the valid folder types are: contacts, calendar, inbox and tasks.", parentFolderType.ToString());
break;
}
// Set the MessageDisposition property.
MessageDispositionType messageDisposition = MessageDispositionType.SaveOnly;
createItemRequest.MessageDisposition = (MessageDispositionType)messageDisposition;
createItemRequest.MessageDispositionSpecified = true;
// Specify the folder in which new items are saved.
createItemRequest.SavedItemFolderId = new TargetFolderIdType();
FolderIdType folderId = new FolderIdType();
folderId.Id = parentFolderId;
createItemRequest.SavedItemFolderId.Item = folderId;
// Specify the collection of items to be created.
createItemRequest.Items = new NonEmptyArrayOfAllItemsType();
createItemRequest.Items.Items = new ItemType[] { item };
// Initialize the ID of the created item.
ItemIdType createdItemId = null;
// Invoke the create item operation and get the response.
CreateItemResponseType createItemResponse = this.COREAdapter.CreateItem(createItemRequest);
if (createItemResponse != null && createItemResponse.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Success)
{
ItemInfoResponseMessageType info = createItemResponse.ResponseMessages.Items[0] as ItemInfoResponseMessageType;
Site.Assert.IsNotNull(info, "The items in CreateItem response should not be null.");
// Get the ID of the created item.
createdItemId = info.Items.Items[0].ItemId;
}
return(createdItemId);
}
/// <summary>
/// Create a sub folder in the specified parent folder.
/// </summary>
/// <param name="parentFolderType">Type of the parent folder.</param>
/// <param name="subFolderName">Name of the folder which should be created.</param>
/// <returns>ID of the new created sub folder.</returns>
protected string CreateSubFolder(DistinguishedFolderIdNameType parentFolderType, string subFolderName)
{
// Variable to specified the created sub folder ID and the folder class name.
string subFolderId = null;
string folderClassName = null;
// Set the folder's class name according to the type of parent folder.
switch (parentFolderType)
{
case DistinguishedFolderIdNameType.contacts:
folderClassName = "IPF.Contact";
break;
case DistinguishedFolderIdNameType.calendar:
folderClassName = "IPF.Appointment";
break;
case DistinguishedFolderIdNameType.tasks:
folderClassName = "IPF.Task";
break;
case DistinguishedFolderIdNameType.inbox:
folderClassName = "IPF.Note";
break;
default:
Site.Assert.Fail(@"The parent folder type '{0}' is invalid.The valid folder types are: contacts, calendar, tasks and inbox", parentFolderType);
break;
}
// Initialize the create folder request.
CreateFolderType createFolderRequest = new CreateFolderType();
FolderType folderProperties = new FolderType();
// Set parent folder id.
createFolderRequest.ParentFolderId = new TargetFolderIdType();
DistinguishedFolderIdType parentFolder = new DistinguishedFolderIdType();
parentFolder.Id = parentFolderType;
createFolderRequest.ParentFolderId.Item = parentFolder;
// Set Display Name and Folder Class for the folder to be created.
folderProperties.DisplayName = subFolderName;
folderProperties.FolderClass = folderClassName;
// Set permission.
folderProperties.PermissionSet = new PermissionSetType();
folderProperties.PermissionSet.Permissions = new PermissionType[1];
folderProperties.PermissionSet.Permissions[0] = new PermissionType();
folderProperties.PermissionSet.Permissions[0].CanCreateItems = true;
folderProperties.PermissionSet.Permissions[0].CanCreateSubFolders = true;
folderProperties.PermissionSet.Permissions[0].PermissionLevel = new PermissionLevelType();
folderProperties.PermissionSet.Permissions[0].PermissionLevel = PermissionLevelType.Editor;
folderProperties.PermissionSet.Permissions[0].UserId = new UserIdType();
string primaryUserName = Common.GetConfigurationPropertyValue("UserName", this.Site);
string primaryDomain = Common.GetConfigurationPropertyValue("Domain", this.Site);
folderProperties.PermissionSet.Permissions[0].UserId.PrimarySmtpAddress = primaryUserName + "@" + primaryDomain;
createFolderRequest.Folders = new BaseFolderType[1];
createFolderRequest.Folders[0] = folderProperties;
// Invoke CreateFolder operation and get the response.
CreateFolderResponseType createFolderResponse = this.FOLDAdapter.CreateFolder(createFolderRequest);
if (createFolderResponse != null && createFolderResponse.ResponseMessages.Items[0].ResponseClass.ToString() == ResponseClassType.Success.ToString())
{
FolderIdType folderId = ((FolderInfoResponseMessageType)createFolderResponse.ResponseMessages.Items[0]).Folders[0].FolderId;
subFolderId = folderId.Id;
FolderType created = new FolderType()
{
DisplayName = folderProperties.DisplayName, FolderClass = folderClassName, FolderId = folderId, ParentFolderId = new FolderIdType()
{
Id = parentFolder.Id.ToString()
}
};
this.CreatedFolders.Add(created);
}
return(subFolderId);
}
/// <summary>
/// Find the specified sub folder.
/// </summary>
/// <param name="parentFolderName">Name of the specified parent folder.</param>
/// <param name="subFolderName">Name of the specified sub folder.</param>
/// <returns>Id of the folder.</returns>
private FolderIdType FindSubFolder(DistinguishedFolderIdNameType parentFolderName, string subFolderName)
{
FolderIdType folderId = new FolderIdType();
// Find all sub folders in the specified parent folder.
BaseFolderType[] folders = this.FindAllSubFolders(parentFolderName);
Site.Assert.IsNotNull(folders, "There should be at least one folder in the '{0}' folder.", parentFolderName);
// Find the item with the specified subject.
foreach (BaseFolderType currentFolder in folders)
{
if (currentFolder.DisplayName == subFolderName)
{
folderId = currentFolder.FolderId;
break;
}
}
Site.Assert.IsNotNull(folderId.Id, "There should be at least one folder with the specified subject '{0}'.", subFolderName);
return folderId;
}
/// <summary>
/// Constructor for sanity's sake
/// </summary>
/// <param name="folderName">Folder id enum to indicate which distinguished folder we are dealing
/// with</param>
/// <param name="primarySmtpAddress">Primary Smtp Address of the mailbox we are trying to
/// access</param>
///
public DistinguishedFolderIdType(DistinguishedFolderIdNameType folderName, string primarySmtpAddress)
: this(folderName)
{
this.mailboxField = new EmailAddressType();
this.mailboxField.EmailAddress = primarySmtpAddress;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="id">Distinguished folder id enum value</param>
/// <param name="mailboxPrimarySmtpAddress">Primary smtp of the mailbox owner</param>
///
public TargetFolderIdType(
DistinguishedFolderIdNameType id,
string mailboxPrimarySmtpAddress)
{
this.Item = new DistinguishedFolderIdType(id, mailboxPrimarySmtpAddress);
}
private void MigrateItens(ref DataGridViewRow row, ExchangeServiceBinding srcService, ExchangeServiceBinding tgtService, DistinguishedFolderIdNameType folder, string srcUserMail, string tgtUserMail)
{
ResponseMessageType[] itemsResponse = this.GetFolderItems(srcService, folder);
ExportItemsType exExportItems = new ExportItemsType();
foreach (ResponseMessageType responseMessage in itemsResponse)
{
FindItemResponseMessageType firmt = responseMessage as FindItemResponseMessageType;
FindItemParentType fipt = firmt.RootFolder;
object obj = fipt.Item;
int count = 0;
// FindItem contains an array of items.
if (obj is ArrayOfRealItemsType)
{
ArrayOfRealItemsType items = (obj as ArrayOfRealItemsType);
exExportItems.ItemIds = new ItemIdType[(items.Items.Count() + 1)];
foreach (ItemType it in items.Items)
{
exExportItems.ItemIds[count] = new ItemIdType();
exExportItems.ItemIds[count].Id = it.ItemId.Id;
count++;
}
}
}
ExportItemsResponseType exResponse = srcService.ExportItems(exExportItems);
ResponseMessageType[] rmResponses = exResponse.ResponseMessages.Items;
UploadItemsType upUploadItems = new UploadItemsType();
upUploadItems.Items = new UploadItemType[(rmResponses.Length + 1)];
Int32 icItemCount = 0;
foreach (ResponseMessageType rmReponse in rmResponses)
{
if (rmReponse.ResponseClass == ResponseClassType.Success)
{
ExportItemsResponseMessageType exExportedItem = (ExportItemsResponseMessageType)rmReponse;
Byte[] messageBytes = exExportedItem.Data;
UploadItemType upUploadItem = new UploadItemType();
upUploadItem.CreateAction = CreateActionType.UpdateOrCreate;
upUploadItem.Data = messageBytes;
upUploadItem.IsAssociatedSpecified = true;
upUploadItem.IsAssociated = false;
upUploadItems.Items[icItemCount] = upUploadItem;
FolderIdManager folderIdMgr = new FolderIdManager();
FolderIdType folderId = new FolderIdType();
folderId.Id = folderIdMgr.GetFolderId(tgtUserMail, Microsoft.Exchange.WebServices.Data.WellKnownFolderName.Contacts, Microsoft.Exchange.WebServices.Data.ExchangeVersion.Exchange2010_SP2);
upUploadItem.ParentFolderId = folderId;
icItemCount += 1;
}
}
//Erro de Internal Server Error nessa etapa
UploadItemsResponseType upLoadResponse = tgtService.UploadItems(upUploadItems);
Int32 Success = 0;
Int32 Failure = 0;
foreach (ResponseMessageType upResponse in upLoadResponse.ResponseMessages.Items)
{
if (upResponse.ResponseClass == ResponseClassType.Success)
{
Success++;
}
if (upResponse.ResponseClass == ResponseClassType.Error)
{
Failure++;
}
}
string resTask = string.Format("Items Copied Sucessfull : {0} - Failure: {1}", Success, Failure);
Tools.SetRowValue(ref row, EColumns.results, resTask);
//iv.Offset += fiItems.Items.Count;
}
/// <summary>
/// Find all the items in the specified folder.
/// </summary>
/// <param name="folderName">Name of the specified folder.</param>
/// <returns>An array of found items.</returns>
private ItemType[] FindAllItems(DistinguishedFolderIdNameType folderName)
{
// Create an array of ItemType.
ItemType[] items = null;
// Create an instance of FindItemType.
FindItemType findItemRequest = new FindItemType();
findItemRequest.ParentFolderIds = new BaseFolderIdType[1];
DistinguishedFolderIdType parentFolder = new DistinguishedFolderIdType();
parentFolder.Id = folderName;
findItemRequest.ParentFolderIds[0] = parentFolder;
// Get properties that are defined as the default for the items.
findItemRequest.ItemShape = new ItemResponseShapeType();
findItemRequest.ItemShape.BaseShape = DefaultShapeNamesType.Default;
// Invoke the FindItem operation.
FindItemResponseType findItemResponse = this.exchangeServiceBinding.FindItem(findItemRequest);
if (findItemResponse != null && findItemResponse.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Success)
{
// Get the found items from the response.
FindItemResponseMessageType findItemMessage = findItemResponse.ResponseMessages.Items[0] as FindItemResponseMessageType;
ArrayOfRealItemsType findItems = findItemMessage.RootFolder.Item as ArrayOfRealItemsType;
items = findItems.Items;
}
return items;
}
protected PXSyncMovingCondition(DistinguishedFolderIdNameType parent, BaseFolderIdType folder)
{
ParentFolder = parent;
FolderId = folder;
}
/// <summary>
/// Find all the sub folders in the specified folder.
/// </summary>
/// <param name="parentFolderName">Name of the specified parent folder.</param>
/// <returns>An array of found sub folders.</returns>
private BaseFolderType[] FindAllSubFolders(DistinguishedFolderIdNameType parentFolderName)
{
// Create an array of BaseFolderType.
BaseFolderType[] folders = null;
// Create the request and specify the traversal type.
FindFolderType findFolderRequest = new FindFolderType();
findFolderRequest.Traversal = FolderQueryTraversalType.Deep;
// Define the properties to be returned in the response.
FolderResponseShapeType responseShape = new FolderResponseShapeType();
responseShape.BaseShape = DefaultShapeNamesType.Default;
findFolderRequest.FolderShape = responseShape;
// Identify which folders to search.
DistinguishedFolderIdType[] folderIDArray = new DistinguishedFolderIdType[1];
folderIDArray[0] = new DistinguishedFolderIdType();
folderIDArray[0].Id = parentFolderName;
// Add the folders to search to the request.
findFolderRequest.ParentFolderIds = folderIDArray;
FindFolderResponseType findFolderResponse = this.exchangeServiceBinding.FindFolder(findFolderRequest);
FindFolderResponseMessageType findFolderResponseMessageType = new FindFolderResponseMessageType();
if (findFolderResponse != null && findFolderResponse.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Success)
{
findFolderResponseMessageType = findFolderResponse.ResponseMessages.Items[0] as FindFolderResponseMessageType;
folders = findFolderResponseMessageType.RootFolder.Folders;
}
return folders;
}
/// <summary>
/// Deletes all items and sub folders from the specified folder.
/// </summary>
/// <param name="folderName">Name of the specified parent folder.</param>
/// <param name="needVerify">If need to verify the subfolders,when false,it will cleanup all the folders without verify</param>
/// <returns>If the specified folder is cleaned up successfully, return true; otherwise, return false.</returns>
private bool CleanupFolder(DistinguishedFolderIdNameType folderName, bool needVerify = true)
{
bool isAllItemsAndFoldersDeleted = false;
ItemType[] items = this.FindAllItems(folderName);
// Create a request for the DeleteItem operation.
DeleteItemType deleteItemRequest = new DeleteItemType();
// The item is permanently removed from the store.
deleteItemRequest.DeleteType = DisposalType.HardDelete;
// Do not send meeting cancellations.
deleteItemRequest.SendMeetingCancellations = CalendarItemCreateOrDeleteOperationType.SendToNone;
deleteItemRequest.SendMeetingCancellationsSpecified = true;
if (items != null)
{
foreach (ItemType currentItem in items)
{
if (currentItem.GetType() == typeof(TaskType))
{
deleteItemRequest.AffectedTaskOccurrencesSpecified = true;
deleteItemRequest.AffectedTaskOccurrences = AffectedTaskOccurrencesType.AllOccurrences;
}
deleteItemRequest.ItemIds = new BaseItemIdType[] { currentItem.ItemId };
// Invoke the delete item operation.
DeleteItemResponseType response = this.exchangeServiceBinding.DeleteItem(deleteItemRequest);
Site.Assert.AreEqual <ResponseClassType>(
ResponseClassType.Success,
response.ResponseMessages.Items[0].ResponseClass,
"The delete item operation should execute successfully.");
}
}
// Find all sub folders in the specified folder.
BaseFolderType[] folders = this.FindAllSubFolders(folderName);
if (folders.Length != 0)
{
foreach (BaseFolderType currentFolder in folders)
{
if (needVerify)
{
bool isCreatedByCase = false;
AdapterHelper.CreatedFolders.ForEach(r =>
{
if (r.FolderId.Id == currentFolder.FolderId.Id)
{
isCreatedByCase = true;
}
});
if (!isCreatedByCase)
{
continue;
}
}
FolderIdType responseFolderId = currentFolder.FolderId;
FolderIdType folderId = new FolderIdType();
folderId.Id = responseFolderId.Id;
DeleteFolderType deleteFolderRequest = new DeleteFolderType();
deleteFolderRequest.DeleteType = DisposalType.HardDelete;
deleteFolderRequest.FolderIds = new BaseFolderIdType[1];
deleteFolderRequest.FolderIds[0] = folderId;
// Send the request and get the response.
DeleteFolderResponseType deleteFolderResponse = this.exchangeServiceBinding.DeleteFolder(deleteFolderRequest);
// Delete folder operation should return response info.
if (deleteFolderResponse.ResponseMessages.Items[0] != null)
{
Site.Assert.AreEqual <ResponseClassType>(
ResponseClassType.Success,
deleteFolderResponse.ResponseMessages.Items[0].ResponseClass,
"The delete folder operation should be successful.");
}
}
}
// Invoke the FindItem operation.
items = this.FindAllItems(folderName);
// Invoke the FindFolder operation.
folders = this.FindAllSubFolders(folderName);
// If neither items and sub folders could be found, the folder has been cleaned up successfully.
bool allFoldersBelongstoSys = true;
foreach (BaseFolderType folder in folders)
{
bool find = false;
AdapterHelper.CreatedFolders.ForEach(r =>
{
if (r.FolderId.Id == folder.FolderId.Id)
{
find = true;
}
});
if (find)
{
allFoldersBelongstoSys = false;
break;
}
}
if (items == null && (folders.Length == 0 || allFoldersBelongstoSys))
{
isAllItemsAndFoldersDeleted = true;
}
return(isAllItemsAndFoldersDeleted);
}
/// <summary>
/// Deletes all items and sub folders from the specified folder.
/// </summary>
/// <param name="folderName">Name of the specified parent folder.</param>
/// <param name="needVerify">If need to verify the subfolders,when false,it will cleanup all the folders without verify</param>
/// <returns>If the specified folder is cleaned up successfully, return true; otherwise, return false.</returns>
private bool CleanupFolder(DistinguishedFolderIdNameType folderName, bool needVerify = true)
{
bool isAllItemsAndFoldersDeleted = false;
ItemType[] items = this.FindAllItems(folderName);
// Create a request for the DeleteItem operation.
DeleteItemType deleteItemRequest = new DeleteItemType();
// The item is permanently removed from the store.
deleteItemRequest.DeleteType = DisposalType.HardDelete;
// Do not send meeting cancellations.
deleteItemRequest.SendMeetingCancellations = CalendarItemCreateOrDeleteOperationType.SendToNone;
deleteItemRequest.SendMeetingCancellationsSpecified = true;
if (items != null)
{
foreach (ItemType currentItem in items)
{
if (currentItem.GetType() == typeof(TaskType))
{
deleteItemRequest.AffectedTaskOccurrencesSpecified = true;
deleteItemRequest.AffectedTaskOccurrences = AffectedTaskOccurrencesType.AllOccurrences;
}
deleteItemRequest.ItemIds = new BaseItemIdType[] { currentItem.ItemId };
// Invoke the delete item operation.
DeleteItemResponseType response = this.exchangeServiceBinding.DeleteItem(deleteItemRequest);
Site.Assert.AreEqual<ResponseClassType>(
ResponseClassType.Success,
response.ResponseMessages.Items[0].ResponseClass,
"The delete item operation should execute successfully.");
}
}
// Find all sub folders in the specified folder.
BaseFolderType[] folders = this.FindAllSubFolders(folderName);
if (folders.Length != 0)
{
foreach (BaseFolderType currentFolder in folders)
{
if (needVerify)
{
bool isCreatedByCase = false;
AdapterHelper.CreatedFolders.ForEach(r =>
{
if (r.FolderId.Id == currentFolder.FolderId.Id)
{
isCreatedByCase = true;
}
});
if (!isCreatedByCase)
{
continue;
}
}
FolderIdType responseFolderId = currentFolder.FolderId;
FolderIdType folderId = new FolderIdType();
folderId.Id = responseFolderId.Id;
DeleteFolderType deleteFolderRequest = new DeleteFolderType();
deleteFolderRequest.DeleteType = DisposalType.HardDelete;
deleteFolderRequest.FolderIds = new BaseFolderIdType[1];
deleteFolderRequest.FolderIds[0] = folderId;
// Send the request and get the response.
DeleteFolderResponseType deleteFolderResponse = this.exchangeServiceBinding.DeleteFolder(deleteFolderRequest);
// Delete folder operation should return response info.
if (deleteFolderResponse.ResponseMessages.Items[0] != null)
{
Site.Assert.AreEqual<ResponseClassType>(
ResponseClassType.Success,
deleteFolderResponse.ResponseMessages.Items[0].ResponseClass,
"The delete folder operation should be successful.");
}
}
}
// Invoke the FindItem operation.
items = this.FindAllItems(folderName);
// Invoke the FindFolder operation.
folders = this.FindAllSubFolders(folderName);
// If neither items and sub folders could be found, the folder has been cleaned up successfully.
bool allFoldersBelongstoSys = true;
foreach (BaseFolderType folder in folders)
{
bool find = false;
AdapterHelper.CreatedFolders.ForEach(r =>
{
if (r.FolderId.Id == folder.FolderId.Id)
{
find = true;
}
});
if (find)
{
allFoldersBelongstoSys = false;
break;
}
}
if (items == null && (folders.Length == 0 || allFoldersBelongstoSys))
{
isAllItemsAndFoldersDeleted = true;
}
return isAllItemsAndFoldersDeleted;
}
/// <summary>
/// Generate the request message for operation "CopyFolder".
/// </summary>
/// <param name="toFolderId">A target folder for operations that copy folders.</param>
/// <param name="folderIds">An array of folder identifier of the folders need to be copied.</param>
/// <returns>Copy folder request instance that will send to server.</returns>
protected CopyFolderType GetCopyFolderRequest(string toFolderId, params BaseFolderIdType[] folderIds)
{
Site.Assert.IsNotNull(folderIds, "Folders id should not be null!");
Site.Assert.AreNotEqual<int>(0, folderIds.Length, "Folders id should contains at least one id!");
// CopyFolder request.
CopyFolderType copyFolderRequest = new CopyFolderType();
int folderCount = folderIds.Length;
// Identify the folders to be copied.
copyFolderRequest.FolderIds = new BaseFolderIdType[folderCount];
for (int folderIdIndex = 0; folderIdIndex < folderCount; folderIdIndex++)
{
copyFolderRequest.FolderIds[folderIdIndex] = folderIds[folderIdIndex];
}
// Identify the destination folder.
copyFolderRequest.ToFolderId = new TargetFolderIdType();
DistinguishedFolderIdType distinguishedFolderId = new DistinguishedFolderIdType();
DistinguishedFolderIdNameType distinguishedFolderIdName = new DistinguishedFolderIdNameType();
bool isSuccess = Enum.TryParse<DistinguishedFolderIdNameType>(toFolderId, true, out distinguishedFolderIdName);
if (isSuccess)
{
distinguishedFolderId.Id = distinguishedFolderIdName;
copyFolderRequest.ToFolderId.Item = distinguishedFolderId;
}
else
{
FolderIdType id = new FolderIdType();
id.Id = toFolderId;
copyFolderRequest.ToFolderId.Item = id;
}
return copyFolderRequest;
}
/// <summary>
/// Constructor for sanity's sake
/// </summary>
/// <param name="folderName">Folder id enum to indicate which distinguished folder we
/// are dealing with</param>
///
public DistinguishedFolderIdType(DistinguishedFolderIdNameType folderName)
{
this.idField = folderName;
}
/// <summary>
/// Create a sub folder in the specified parent folder.
/// </summary>
/// <param name="parentFolderType">Type of the parent folder.</param>
/// <param name="subFolderName">Name of the folder which should be created.</param>
/// <returns>ID of the new created sub folder.</returns>
protected string CreateSubFolder(DistinguishedFolderIdNameType parentFolderType, string subFolderName)
{
// Variable to specified the created sub folder ID and the folder class name.
string subFolderId = null;
string folderClassName = null;
// Set the folder's class name according to the type of parent folder.
switch (parentFolderType)
{
case DistinguishedFolderIdNameType.contacts:
folderClassName = "IPF.Contact";
break;
case DistinguishedFolderIdNameType.calendar:
folderClassName = "IPF.Appointment";
break;
case DistinguishedFolderIdNameType.tasks:
folderClassName = "IPF.Task";
break;
case DistinguishedFolderIdNameType.inbox:
folderClassName = "IPF.Note";
break;
default:
Site.Assert.Fail(@"The parent folder type '{0}' is invalid.The valid folder types are: contacts, calendar, tasks and inbox", parentFolderType);
break;
}
// Initialize the create folder request.
CreateFolderType createFolderRequest = new CreateFolderType();
FolderType folderProperties = new FolderType();
// Set parent folder id.
createFolderRequest.ParentFolderId = new TargetFolderIdType();
DistinguishedFolderIdType parentFolder = new DistinguishedFolderIdType();
parentFolder.Id = parentFolderType;
createFolderRequest.ParentFolderId.Item = parentFolder;
// Set Display Name and Folder Class for the folder to be created.
folderProperties.DisplayName = subFolderName;
folderProperties.FolderClass = folderClassName;
// Set permission.
folderProperties.PermissionSet = new PermissionSetType();
folderProperties.PermissionSet.Permissions = new PermissionType[1];
folderProperties.PermissionSet.Permissions[0] = new PermissionType();
folderProperties.PermissionSet.Permissions[0].CanCreateItems = true;
folderProperties.PermissionSet.Permissions[0].CanCreateSubFolders = true;
folderProperties.PermissionSet.Permissions[0].PermissionLevel = new PermissionLevelType();
folderProperties.PermissionSet.Permissions[0].PermissionLevel = PermissionLevelType.Editor;
folderProperties.PermissionSet.Permissions[0].UserId = new UserIdType();
string primaryUserName = Common.GetConfigurationPropertyValue("UserName", this.Site);
string primaryDomain = Common.GetConfigurationPropertyValue("Domain", this.Site);
folderProperties.PermissionSet.Permissions[0].UserId.PrimarySmtpAddress = primaryUserName + "@" + primaryDomain;
createFolderRequest.Folders = new BaseFolderType[1];
createFolderRequest.Folders[0] = folderProperties;
// Invoke CreateFolder operation and get the response.
CreateFolderResponseType createFolderResponse = this.FOLDAdapter.CreateFolder(createFolderRequest);
if (createFolderResponse != null && createFolderResponse.ResponseMessages.Items[0].ResponseClass.ToString() == ResponseClassType.Success.ToString())
{
FolderIdType folderId = ((FolderInfoResponseMessageType)createFolderResponse.ResponseMessages.Items[0]).Folders[0].FolderId;
subFolderId = folderId.Id;
FolderType created = new FolderType() { DisplayName = folderProperties.DisplayName, FolderClass = folderClassName, FolderId = folderId, ParentFolderId = new FolderIdType() { Id = parentFolder.Id.ToString() } };
this.CreatedFolders.Add(created);
}
return subFolderId;
}
public PXSyncFolderSpecification(string name, DistinguishedFolderIdNameType type)
: this(name, type, PXEmailSyncDirection.Directions.Full, true)
{
}
/// <summary>
/// Create an item in the specified folder.
/// </summary>
/// <param name="parentFolderType">Type of the parent folder.</param>
/// <param name="parentFolderId">ID of the parent folder.</param>
/// <param name="itemSubject">Subject of the item which should be created.</param>
/// <returns>ID of the created item.</returns>
protected ItemIdType CreateItem(DistinguishedFolderIdNameType parentFolderType, string parentFolderId, string itemSubject)
{
// Create a request for the CreateItem operation and initialize the ItemType instance.
CreateItemType createItemRequest = new CreateItemType();
ItemType item = null;
// Get different values for item based on different parent folder type.
switch (parentFolderType)
{
case DistinguishedFolderIdNameType.contacts:
ContactItemType contact = new ContactItemType();
contact.Subject = itemSubject;
contact.FileAs = itemSubject;
item = contact;
break;
case DistinguishedFolderIdNameType.calendar:
// Set the sendMeetingInvitations property.
CalendarItemCreateOrDeleteOperationType sendMeetingInvitations = CalendarItemCreateOrDeleteOperationType.SendToNone;
createItemRequest.SendMeetingInvitations = (CalendarItemCreateOrDeleteOperationType)sendMeetingInvitations;
createItemRequest.SendMeetingInvitationsSpecified = true;
CalendarItemType calendar = new CalendarItemType();
calendar.Subject = itemSubject;
item = calendar;
break;
case DistinguishedFolderIdNameType.inbox:
MessageType message = new MessageType();
message.Subject = itemSubject;
item = message;
break;
case DistinguishedFolderIdNameType.tasks:
TaskType taskItem = new TaskType();
taskItem.Subject = itemSubject;
item = taskItem;
break;
default:
Site.Assert.Fail("The parent folder type '{0}' is invalid and the valid folder types are: contacts, calendar, inbox and tasks.", parentFolderType.ToString());
break;
}
// Set the MessageDisposition property.
MessageDispositionType messageDisposition = MessageDispositionType.SaveOnly;
createItemRequest.MessageDisposition = (MessageDispositionType)messageDisposition;
createItemRequest.MessageDispositionSpecified = true;
// Specify the folder in which new items are saved.
createItemRequest.SavedItemFolderId = new TargetFolderIdType();
FolderIdType folderId = new FolderIdType();
folderId.Id = parentFolderId;
createItemRequest.SavedItemFolderId.Item = folderId;
// Specify the collection of items to be created.
createItemRequest.Items = new NonEmptyArrayOfAllItemsType();
createItemRequest.Items.Items = new ItemType[] { item };
// Initialize the ID of the created item.
ItemIdType createdItemId = null;
// Invoke the create item operation and get the response.
CreateItemResponseType createItemResponse = this.COREAdapter.CreateItem(createItemRequest);
if (createItemResponse != null && createItemResponse.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Success)
{
ItemInfoResponseMessageType info = createItemResponse.ResponseMessages.Items[0] as ItemInfoResponseMessageType;
Site.Assert.IsNotNull(info, "The items in CreateItem response should not be null.");
// Get the ID of the created item.
createdItemId = info.Items.Items[0].ItemId;
}
return createdItemId;
}
public PXSyncMovingCondition(DistinguishedFolderIdNameType parent)
{
ParentFolder = parent;
}
/// <summary>
/// Log on a mailbox with a specified user account and check whether the specified item exists.
/// </summary>
/// <param name="userName">Name of the user.</param>
/// <param name="userPassword">Password of the user.</param>
/// <param name="userDomain">Domain of the user.</param>
/// <param name="folderName">Name of the folder which should be searched for the specified item.</param>
/// <param name="itemSubject">Subject of the item which should exist.</param>
/// <param name="itemType">Type of the item which should exist.</param>
/// <returns>If the item exists, return true; otherwise, return false.</returns>
public bool IsItemExisting(string userName, string userPassword, string userDomain, string folderName, string itemSubject, string itemType)
{
bool isExisting = false;
// Parse the parent folder name to DistinguishedFolderIdNameType.
DistinguishedFolderIdNameType parentFolderIdName = (DistinguishedFolderIdNameType)Enum.Parse(typeof(DistinguishedFolderIdNameType), folderName, true);
// Switch to specified user mailbox.
bool isSwitched = AdapterHelper.SwitchUser(userName, userPassword, userDomain, this.exchangeServiceBinding, this.Site);
Site.Assert.IsTrue(
isSwitched,
string.Format("Log on mailbox with the UserName: {0}, Password: {1}, Domain: {2} should be successful.", userName, userPassword, userDomain));
Item item = (Item)Enum.Parse(typeof(Item), itemType, true);
// Loop to find the specified item
ItemType type = this.LoopToFindItem(parentFolderIdName, itemSubject, item);
if (type != null)
{
switch (item)
{
case Item.MeetingRequest:
MeetingRequestMessageType requestMessage = type as MeetingRequestMessageType;
if (requestMessage != null)
{
isExisting = true;
}
break;
case Item.MeetingResponse:
MeetingResponseMessageType responseMessage = type as MeetingResponseMessageType;
if (responseMessage != null)
{
isExisting = true;
}
break;
case Item.MeetingCancellation:
MeetingCancellationMessageType cancellationMessage = type as MeetingCancellationMessageType;
if (cancellationMessage != null)
{
isExisting = true;
}
break;
case Item.CalendarItem:
CalendarItemType calendarItem = type as CalendarItemType;
if (calendarItem != null)
{
isExisting = true;
}
break;
}
}
return(isExisting);
}
/// <summary>
/// Define general CreateItem request message
/// </summary>
/// <param name="messageDisposition">A value specifies how a message item is handled after it is created or updated</param>
/// <param name="savedTargetFolderName">The folder in which new items are saved</param>
/// <returns>A request to create an item</returns>
protected CreateItemType GetCreateItemType(MessageDispositionType messageDisposition, DistinguishedFolderIdNameType savedTargetFolderName)
{
CreateItemType createItemRequest = new CreateItemType
{
MessageDisposition = messageDisposition,
MessageDispositionSpecified = true,
SavedItemFolderId = new TargetFolderIdType
{
Item = new DistinguishedFolderIdType
{
Id = savedTargetFolderName
}
},
Items = new NonEmptyArrayOfAllItemsType
{
Items = new MessageType[]
{
new MessageType
{
Sender = new SingleRecipientType
{
Item = new EmailAddressType
{
EmailAddress = this.sender
}
},
ToRecipients = new EmailAddressType[]
{
new EmailAddressType
{
EmailAddress = this.recipient1
}
},
Subject = this.subject,
}
}
},
};
return createItemRequest;
}
/// <summary>
/// Loop to find the item with the specified subject.
/// </summary>
/// <param name="folderName">Name of the specified folder.</param>
/// <param name="itemSubject">Subject of the specified item.</param>
/// <param name="itemType">Type of the specified item.</param>
/// <returns>Item with the specified subject.</returns>
private ItemType LoopToFindItem(DistinguishedFolderIdNameType folderName, string itemSubject, Item itemType)
{
ItemType[] items = null;
ItemType firstFoundItem = null;
int sleepTimes = 0;
// Get the query sleep delay and times from ptfconfig file.
int queryDelay = int.Parse(Common.GetConfigurationPropertyValue("WaitTime", this.Site));
int queryTimes = int.Parse(Common.GetConfigurationPropertyValue("RetryCount", this.Site));
// Loop to find the item, in case that the sent item has still not been received.
do
{
Thread.Sleep(queryDelay);
items = this.FindAllItems(folderName);
sleepTimes++;
}
while (items == null && sleepTimes < queryTimes);
ItemType type = null;
switch (itemType)
{
case Item.MeetingRequest:
type = new MeetingRequestMessageType();
break;
case Item.MeetingResponse:
type = new MeetingResponseMessageType();
break;
case Item.MeetingCancellation:
type = new MeetingCancellationMessageType();
break;
case Item.CalendarItem:
type = new CalendarItemType();
break;
}
if (items != null)
{
// Find the item with the specified subject and store its ID.
for (int i = 0; i < items.Length; i++)
{
if (items[i].Subject.Contains(itemSubject) && items[i].GetType().ToString() == type.ToString())
{
firstFoundItem = items[i];
break;
}
}
}
return firstFoundItem;
}
/// <summary>
/// Log on to a mailbox with a specified user account and delete all the subfolders from the specified folder.
/// </summary>
/// <param name="userName">Name of the user.</param>
/// <param name="userPassword">Password of the user.</param>
/// <param name="userDomain">Domain of the user.</param>
/// <param name="folderName">Name of the folder which should be cleaned up.</param>
/// <param name="destFolderName">The name of the destination folder which will be deleted.</param>
/// <returns>If the folder is cleaned up successfully, return true; otherwise, return false.</returns>
public bool CleanupFolder(string userName, string userPassword, string userDomain, string folderName, string destFolderName)
{
// Log on mailbox with specified user mailbox.
this.exchangeServiceBinding.Credentials = new NetworkCredential(userName, userPassword, userDomain);
#region Delete all sub folders and the items in these sub folders in the specified parent folder.
// Parse the parent folder name.
DistinguishedFolderIdNameType parentFolderName = (DistinguishedFolderIdNameType)Enum.Parse(typeof(DistinguishedFolderIdNameType), folderName, true);
// Create an array of BaseFolderType.
BaseFolderType[] folders = null;
// Create the request and specify the traversal type.
FindFolderType findFolderRequest = new FindFolderType();
findFolderRequest.Traversal = FolderQueryTraversalType.Deep;
// Define the properties to be returned in the response.
FolderResponseShapeType responseShape = new FolderResponseShapeType();
responseShape.BaseShape = DefaultShapeNamesType.Default;
findFolderRequest.FolderShape = responseShape;
// Identify which folders to search.
DistinguishedFolderIdType[] folderIDArray = new DistinguishedFolderIdType[1];
folderIDArray[0] = new DistinguishedFolderIdType();
folderIDArray[0].Id = parentFolderName;
// Add the folders to search to the request.
findFolderRequest.ParentFolderIds = folderIDArray;
// Invoke FindFolder operation and get the response.
FindFolderResponseType findFolderResponse = this.exchangeServiceBinding.FindFolder(findFolderRequest);
// If there are folders found under the specified folder, delete all of them.
if (findFolderResponse != null && findFolderResponse.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Success)
{
// Get the folders from the response.
FindFolderResponseMessageType findFolderResponseMessageType = findFolderResponse.ResponseMessages.Items[0] as FindFolderResponseMessageType;
Site.Assert.IsNotNull(findFolderResponseMessageType, "The items in FindFolder response should not be null.");
folders = findFolderResponseMessageType.RootFolder.Folders;
if (folders.Length != 0)
{
////Indicates whether the destination folder was found and removed.
bool found = false;
// Loop to delete all the found folders.
foreach (BaseFolderType currentFolder in folders)
{
if (string.Compare(currentFolder.DisplayName, destFolderName, StringComparison.InvariantCultureIgnoreCase) != 0)
{
continue;
}
FolderIdType responseFolderId = currentFolder.FolderId;
FolderIdType folderId = new FolderIdType();
folderId.Id = responseFolderId.Id;
DeleteFolderType deleteFolderRequest = new DeleteFolderType();
deleteFolderRequest.DeleteType = DisposalType.HardDelete;
deleteFolderRequest.FolderIds = new BaseFolderIdType[1];
deleteFolderRequest.FolderIds[0] = folderId;
// Invoke DeleteFolder operation and get the response.
DeleteFolderResponseType deleteFolderResponse = this.exchangeServiceBinding.DeleteFolder(deleteFolderRequest);
Site.Assert.AreEqual <ResponseClassType>(
ResponseClassType.Success,
deleteFolderResponse.ResponseMessages.Items[0].ResponseClass,
"The delete folder operation should be successful.");
found = true;
break;
}
Site.Assert.IsTrue(
found,
"The destination folder can not be found in the assigned parent folder.");
}
}
#endregion
#region Check whether sub folders are deleted successfully.
// Invoke the FindFolder operation again.
findFolderResponse = this.exchangeServiceBinding.FindFolder(findFolderRequest);
Site.Assert.AreEqual <ResponseCodeType>(
ResponseCodeType.NoError,
findFolderResponse.ResponseMessages.Items[0].ResponseCode,
string.Format(
"The delete folder operation should be successful. Expected response code: {0}, actual response code: {1}",
ResponseCodeType.NoError,
findFolderResponse.ResponseMessages.Items[0].ResponseCode));
// Get the found folders from the response.
FindFolderResponseMessageType findFolderResponseMessage = findFolderResponse.ResponseMessages.Items[0] as FindFolderResponseMessageType;
folders = findFolderResponseMessage.RootFolder.Folders;
// If no sub folders that created by case could be found, the folder has been cleaned up successfully.
foreach (BaseFolderType folder in folders)
{
if (string.Compare(folder.DisplayName, destFolderName, StringComparison.InvariantCultureIgnoreCase) != 0)
{
continue;
}
else
{
return(false);
}
}
return(true);
#endregion
}
public void CheckAndCreateWellKnownFolder(DistinguishedFolderIdNameType parentFolder, DistinguishedFolderIdNameType targetFolder, out FolderIdType targetFolderId)
{
targetFolderId = null;
GetFolderType getFolder = new GetFolderType
{
FolderShape = new FolderResponseShapeType
{
BaseShape = DefaultShapeNamesType.Default
},
FolderIds = new BaseFolderIdType[]
{
new DistinguishedFolderIdType
{
Id = targetFolder
}
}
};
FolderIdType localTargetFolderId = null;
bool retry = false;
do
{
this.CallEwsWithRetries((LID)47292U, () => this.binding.GetFolder(getFolder), delegate(ResponseMessageType responseMessage, int messageIndex)
{
FolderInfoResponseMessageType folderInfoResponseMessageType = responseMessage as FolderInfoResponseMessageType;
if (folderInfoResponseMessageType != null && folderInfoResponseMessageType.ResponseClass == ResponseClassType.Success && folderInfoResponseMessageType.Folders != null && folderInfoResponseMessageType.Folders.Length == 1)
{
localTargetFolderId = folderInfoResponseMessageType.Folders[0].FolderId;
if (this.IsTraceEnabled(TraceType.DebugTrace))
{
this.Tracer.TraceDebug <string, string>(0L, "Found the folder {0} with the id {1}", targetFolder.ToString(), localTargetFolderId.Id);
}
retry = false;
return(true);
}
return(false);
}, delegate(ResponseMessageType responseMessage, int messageIndex)
{
if (responseMessage != null && responseMessage.ResponseClass == ResponseClassType.Error && responseMessage.ResponseCode == ResponseCodeType.ErrorFolderNotFound && !retry)
{
DiagnosticContext.TraceLocation((LID)37196U);
if (this.IsTraceEnabled(TraceType.DebugTrace))
{
this.Tracer.TraceDebug(0L, "Folder not found, an attempt will be made to create it", new object[]
{
targetFolder.ToString(),
responseMessage.ResponseClass,
responseMessage.ResponseCode,
responseMessage.MessageText
});
}
return(true);
}
return(false);
});
if (localTargetFolderId == null && !retry)
{
DiagnosticContext.TraceLocation((LID)61628U);
if (!this.InternalCreateFolder(new CreateFolderType
{
ParentFolderId = new TargetFolderIdType
{
Item = new DistinguishedFolderIdType
{
Id = parentFolder,
Mailbox = this.Mailbox
}
},
Folders = new BaseFolderType[]
{
new FolderType
{
DistinguishedFolderId = targetFolder,
DistinguishedFolderIdSpecified = true
}
}
}, delegate(ResponseMessageType responseMessage, int messageIndex)
{
if (responseMessage != null && responseMessage.ResponseClass == ResponseClassType.Error && responseMessage.ResponseCode == ResponseCodeType.ErrorInvalidOperation)
{
DiagnosticContext.TraceLocation((LID)53580U);
retry = true;
return(true);
}
return(false);
}, out localTargetFolderId))
{
localTargetFolderId = null;
}
}
}while (retry);
ExAssert.RetailAssert(localTargetFolderId != null, "Well known folder ID must be valid at this point");
targetFolderId = localTargetFolderId;
}
/// <summary>
/// Define general CreateItem request message
/// </summary>
/// <param name="messageDisposition">A value specifies how a message item is handled after it is created or updated</param>
/// <param name="savedTargetFolderName">The folder in which new items are saved</param>
/// <returns>A request to create an item</returns>
protected CreateItemType GetCreateItemType(MessageDispositionType messageDisposition, DistinguishedFolderIdNameType savedTargetFolderName)
{
CreateItemType createItemRequest = new CreateItemType
{
MessageDisposition = messageDisposition,
MessageDispositionSpecified = true,
SavedItemFolderId = new TargetFolderIdType
{
Item = new DistinguishedFolderIdType
{
Id = savedTargetFolderName
}
},
Items = new NonEmptyArrayOfAllItemsType
{
Items = new MessageType[]
{
new MessageType
{
Sender = new SingleRecipientType
{
Item = new EmailAddressType
{
EmailAddress = this.sender
}
},
ToRecipients = new EmailAddressType[]
{
new EmailAddressType
{
EmailAddress = this.recipient1
}
},
Subject = this.subject,
}
}
},
};
return(createItemRequest);
}
public BaseFolderType GetFolder(DistinguishedFolderIdNameType folderType)
{
var binding = ChannelHelper.BuildChannel(hostname, username, password);
var getFolderType = new GetFolderType
{
FolderIds = new[] { new DistinguishedFolderIdType { Id = folderType } },
FolderShape = new FolderResponseShapeType { BaseShape = DefaultShapeNamesType.AllProperties }
};
var getFolderResponse = binding.GetFolder(getFolderType);
if (getFolderResponse.ResponseMessages.Items[0].ResponseClass == ResponseClassType.Error)
throw new Exception(getFolderResponse.ResponseMessages.Items[0].MessageText);
return ((FolderInfoResponseMessageType) getFolderResponse.ResponseMessages.Items[0]).Folders[0];
}
/// <summary>
/// Log on to a mailbox with a specified user account and create two different-level subfolders in the specified parent folder.
/// </summary>
/// <param name="userName">Name of the user.</param>
/// <param name="userPassword">Password of the user.</param>
/// <param name="userDomain">Domain of the user.</param>
/// <param name="parentFolderName">Name of the parent folder.</param>
/// <param name="firstLevelSubFolderName">Name of the first level sub folder which will be created under the parent folder.</param>
/// <param name="secondLevelSubFolderName">Name of the second level sub folder which will be created under the first level sub folder.</param>
/// <returns>If the two level sub folders are created successfully, return true; otherwise, return false.</returns>
public bool CreateSubFolders(string userName, string userPassword, string userDomain, string parentFolderName, string firstLevelSubFolderName, string secondLevelSubFolderName)
{
// Log on mailbox with specified user account(userName, userPassword, userDomain).
bool isLoged = AdapterHelper.SwitchUser(userName, userPassword, userDomain, this.exchangeServiceBinding, this.Site);
Site.Assert.IsTrue(
isLoged,
string.Format("Log on mailbox with the UserName: {0}, Password: {1}, Domain: {2} should be successful.", userName, userPassword, userDomain));
// Initialize variables
FolderIdType folderId = null;
CreateFolderType createFolderRequest = new CreateFolderType();
string folderClassName = null;
DistinguishedFolderIdNameType parentFolderIdName = (DistinguishedFolderIdNameType)Enum.Parse(typeof(DistinguishedFolderIdNameType), parentFolderName, true);
// Define different folder class name according to different parent folder.
switch (parentFolderIdName)
{
case DistinguishedFolderIdNameType.inbox:
folderClassName = "IPF.Note";
break;
case DistinguishedFolderIdNameType.contacts:
folderClassName = "IPF.Contact";
break;
case DistinguishedFolderIdNameType.calendar:
folderClassName = "IPF.Appointment";
break;
case DistinguishedFolderIdNameType.tasks:
folderClassName = "IPF.Task";
break;
default:
Site.Assume.Fail(string.Format("The parent folder name '{0}' is invalid. Valid values are: inbox, contacts, calendar or tasks.", parentFolderName));
break;
}
// Set parent folder ID.
createFolderRequest.ParentFolderId = new TargetFolderIdType();
DistinguishedFolderIdType parentFolder = new DistinguishedFolderIdType();
parentFolder.Id = parentFolderIdName;
createFolderRequest.ParentFolderId.Item = parentFolder;
// Set Display Name and Folder Class for the folder to be created.
FolderType folderProperties = new FolderType();
folderProperties.DisplayName = firstLevelSubFolderName;
folderProperties.FolderClass = folderClassName;
createFolderRequest.Folders = new BaseFolderType[1];
createFolderRequest.Folders[0] = folderProperties;
bool isSubFolderCreated = false;
// Invoke CreateFolder operation and get the response.
CreateFolderResponseType createFolderResponse = this.exchangeServiceBinding.CreateFolder(createFolderRequest);
if (createFolderResponse != null && ResponseClassType.Success == createFolderResponse.ResponseMessages.Items[0].ResponseClass)
{
// If the first level sub folder is created successfully, save the folder ID of it.
folderId = ((FolderInfoResponseMessageType)createFolderResponse.ResponseMessages.Items[0]).Folders[0].FolderId;
FolderType created = new FolderType()
{
DisplayName = folderProperties.DisplayName, FolderClass = folderClassName, FolderId = folderId
};
AdapterHelper.CreatedFolders.Add(created);
}
// Create another sub folder under the created folder above.
if (folderId != null)
{
createFolderRequest.ParentFolderId.Item = folderId;
folderProperties.DisplayName = secondLevelSubFolderName;
createFolderResponse = this.exchangeServiceBinding.CreateFolder(createFolderRequest);
if (createFolderResponse != null && ResponseClassType.Success == createFolderResponse.ResponseMessages.Items[0].ResponseClass)
{
// If the two level sub folders are created successfully, return true; otherwise, return false.
isSubFolderCreated = true;
folderId = ((FolderInfoResponseMessageType)createFolderResponse.ResponseMessages.Items[0]).Folders[0].FolderId;
FolderType created = new FolderType()
{
DisplayName = folderProperties.DisplayName, FolderClass = folderClassName, FolderId = folderId
};
AdapterHelper.CreatedFolders.Add(created);
}
}
return(isSubFolderCreated);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="id">Distinguished folder id enum value</param>
///
public TargetFolderIdType(DistinguishedFolderIdNameType id)
{
this.Item = new DistinguishedFolderIdType(id);
}
