/// <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>
/// Generate the request message for operation "UpdateFolder".
/// </summary>
/// <param name="folderType">An array of folder types.</param>
/// <param name="updateType">An array of update folder types.</param>
/// <param name="folderIds">An array of folder Ids.</param>
/// <returns>Update folder request instance that will send to server.</returns>
protected UpdateFolderType GetUpdateFolderRequest(string[] folderType, string[] updateType, FolderIdType[] folderIds)
{
Site.Assert.AreEqual<int>(folderType.Length, folderIds.Length, "Folder type count should equal to folder id count!");
Site.Assert.AreEqual<int>(folderType.Length, updateType.Length, "Folder type count should equal to update type count!");
// UpdateFolder request.
UpdateFolderType updateFolderRequest = new UpdateFolderType();
int folderCount = folderIds.Length;
// Set the request's folder id field to Custom Folder's folder id.
updateFolderRequest.FolderChanges = new FolderChangeType[folderCount];
for (int folderIndex = 0; folderIndex < folderCount; folderIndex++)
{
updateFolderRequest.FolderChanges[folderIndex] = new FolderChangeType();
updateFolderRequest.FolderChanges[folderIndex].Item = folderIds[folderIndex];
// Add the array of changes; in this case, a single element array.
updateFolderRequest.FolderChanges[folderIndex].Updates = new FolderChangeDescriptionType[1];
switch (updateType[folderIndex])
{
case "SetFolderField":
{
// Set the new folder name of the specific folder.
SetFolderFieldType setFolderField = new SetFolderFieldType();
PathToUnindexedFieldType displayNameProp = new PathToUnindexedFieldType();
displayNameProp.FieldURI = UnindexedFieldURIType.folderDisplayName;
switch (folderType[folderIndex])
{
case "Folder":
FolderType updatedFolder = new FolderType();
updatedFolder.DisplayName = Common.GenerateResourceName(this.Site, "UpdatedFolder" + folderIndex);
setFolderField.Item1 = updatedFolder;
break;
case "CalendarFolder":
CalendarFolderType updatedCalendarFolder = new CalendarFolderType();
updatedCalendarFolder.DisplayName = Common.GenerateResourceName(this.Site, "UpdatedFolder" + folderIndex);
setFolderField.Item1 = updatedCalendarFolder;
break;
case "ContactsFolder":
CalendarFolderType updatedContactFolder = new CalendarFolderType();
updatedContactFolder.DisplayName = Common.GenerateResourceName(this.Site, "UpdatedFolder" + folderIndex);
setFolderField.Item1 = updatedContactFolder;
break;
case "SearchFolder":
CalendarFolderType updatedSearchFolder = new CalendarFolderType();
updatedSearchFolder.DisplayName = Common.GenerateResourceName(this.Site, "UpdatedFolder" + folderIndex);
setFolderField.Item1 = updatedSearchFolder;
break;
case "TasksFolder":
CalendarFolderType updatedTaskFolder = new CalendarFolderType();
updatedTaskFolder.DisplayName = Common.GenerateResourceName(this.Site, "UpdatedFolder" + folderIndex);
setFolderField.Item1 = updatedTaskFolder;
break;
default:
FolderType generalFolder = new FolderType();
generalFolder.DisplayName = Common.GenerateResourceName(this.Site, "UpdatedFolder" + folderIndex);
setFolderField.Item1 = generalFolder;
break;
}
setFolderField.Item = displayNameProp;
updateFolderRequest.FolderChanges[folderIndex].Updates[0] = setFolderField;
}
break;
case "DeleteFolderField":
{
// Use DeleteFolderFieldType.
DeleteFolderFieldType delFolder = new DeleteFolderFieldType();
PathToUnindexedFieldType delProp = new PathToUnindexedFieldType();
delProp.FieldURI = UnindexedFieldURIType.folderPermissionSet;
delFolder.Item = delProp;
updateFolderRequest.FolderChanges[folderIndex].Updates[0] = delFolder;
}
break;
case "AppendToFolderField":
{
// Use AppendToFolderFieldType.
AppendToFolderFieldType appendToFolderField = new AppendToFolderFieldType();
PathToUnindexedFieldType displayNameAppendTo = new PathToUnindexedFieldType();
displayNameAppendTo.FieldURI = UnindexedFieldURIType.calendarAdjacentMeetings;
appendToFolderField.Item = displayNameAppendTo;
FolderType folderAppendTo = new FolderType();
folderAppendTo.FolderId = folderIds[folderIndex];
appendToFolderField.Item1 = folderAppendTo;
updateFolderRequest.FolderChanges[folderIndex].Updates[0] = appendToFolderField;
}
break;
}
}
return updateFolderRequest;
}
/// <summary>
/// Open a folder in the specified folder.
/// If the folder exists, return the folder ID,
/// If not, create the folder first, and then return the folder ID.
/// </summary>
/// <param name="folderName">Folder name value</param>
/// <param name="folderType">The folder type: generic or search folder</param>
/// <param name="parentFolderId">The parent folder ID</param>
/// <param name="openedFolderHandle">folder handle</param>
/// <returns>Return folder ID</returns>
protected ulong OpenFolder(string folderName, FolderType folderType, ulong parentFolderId, out uint openedFolderHandle)
{
ulong folderId;
#region Open a folder
RopOpenFolderRequest openFolderRequest;
RopOpenFolderResponse openFolderResponse;
openFolderRequest.RopId = 0x02;
openFolderRequest.LogonId = 0x0;
openFolderRequest.InputHandleIndex = 0x0;
openFolderRequest.OutputHandleIndex = 0x01;
openFolderRequest.FolderId = parentFolderId;
openFolderRequest.OpenModeFlags = 0x0; // Opening an existing folder
this.oxcstorAdapter.DoRopCall(openFolderRequest, this.outObjHandle, ROPCommandType.Others, out this.outputBuffer);
openFolderResponse = (RopOpenFolderResponse)this.outputBuffer.RopsList[0];
Site.Assert.AreEqual<uint>(
0x00000000,
openFolderResponse.ReturnValue,
"0 indicates the ROP succeeds, other value indicates error occurs.");
openedFolderHandle = this.outputBuffer.ServerObjectHandleTable[openFolderRequest.OutputHandleIndex];
RopHardDeleteMessagesAndSubfoldersRequest deleteSearchFolders = new RopHardDeleteMessagesAndSubfoldersRequest
{
RopId = (byte)RopId.RopHardDeleteMessagesAndSubfolders,
InputHandleIndex = 0,
LogonId = 0,
WantDeleteAssociated = 1
};
this.oxcstorAdapter.DoRopCall(deleteSearchFolders, openedFolderHandle, ROPCommandType.Others, out this.outputBuffer);
#endregion
#region Create a folder
string folderNameWithNull = folderName + "\0";
RopCreateFolderRequest createFolderRequest;
RopCreateFolderResponse createFolderResponse;
createFolderRequest.RopId = 0x1C;
createFolderRequest.LogonId = 0x0;
createFolderRequest.InputHandleIndex = 0x0;
createFolderRequest.OutputHandleIndex = 0x01;
createFolderRequest.FolderType = (byte)folderType;
createFolderRequest.UseUnicodeStrings = 0x0; // FALSE
createFolderRequest.OpenExisting = 0xFF; // non-zero(TRUE)
createFolderRequest.Reserved = 0x0; // FALSE
createFolderRequest.DisplayName = Encoding.ASCII.GetBytes(folderNameWithNull);
createFolderRequest.Comment = createFolderRequest.DisplayName;
this.oxcstorAdapter.DoRopCall(createFolderRequest, openedFolderHandle, ROPCommandType.Others, out this.outputBuffer);
createFolderResponse = (RopCreateFolderResponse)this.outputBuffer.RopsList[0];
Site.Assert.AreEqual<uint>(
0x00000000,
createFolderResponse.ReturnValue,
"if ROP succeeds, the this.returnValue of its response is 0(success)");
folderId = createFolderResponse.FolderId;
#endregion
return folderId;
}
/// <summary>
/// Set related folder properties of create folder request
/// </summary>
/// <param name="displayNames">Display names of folders that will be set into create folder request.</param>
/// <param name="folderClasses">Folder class values of folders that will be set into create folder request.</param>
/// <param name="folderPermissions">Folder permission values of folders that will be set into create folder request. </param>
/// <param name="createFolderRequest">Create folder request instance that needs to set property values.</param>
/// <returns>Create folder request instance that have folder property value configured.</returns>
protected CreateFolderType ConfigureFolderProperty(string[] displayNames, string[] folderClasses, PermissionSetType[] folderPermissions, CreateFolderType createFolderRequest)
{
Site.Assert.IsNotNull(displayNames, "Display names should not be null!");
Site.Assert.IsNotNull(folderClasses, "Folder classes should not be null!");
Site.Assert.AreEqual<int>(displayNames.Length, folderClasses.Length, "Folder names count should equals to folder class value count!");
if (folderPermissions != null)
{
Site.Assert.AreEqual<int>(displayNames.Length, folderPermissions.Length, "Folder names count should equals to folder permission value count!");
}
int folderCount = displayNames.Length;
createFolderRequest.Folders = new BaseFolderType[folderCount];
for (int folderPropertyIndex = 0; folderPropertyIndex < folderCount; folderPropertyIndex++)
{
string folderResourceName = Common.GenerateResourceName(this.Site, displayNames[folderPropertyIndex]);
if (folderClasses[folderPropertyIndex] == "IPF.Appointment")
{
CalendarFolderType calendarFolder = new CalendarFolderType();
calendarFolder.DisplayName = folderResourceName;
createFolderRequest.Folders[folderPropertyIndex] = calendarFolder;
}
else if (folderClasses[folderPropertyIndex] == "IPF.Contact")
{
ContactsFolderType contactFolder = new ContactsFolderType();
contactFolder.DisplayName = folderResourceName;
if (folderPermissions != null)
{
contactFolder.PermissionSet = folderPermissions[folderPropertyIndex];
}
createFolderRequest.Folders[folderPropertyIndex] = contactFolder;
}
else if (folderClasses[folderPropertyIndex] == "IPF.Task")
{
TasksFolderType taskFolder = new TasksFolderType();
taskFolder.DisplayName = folderResourceName;
if (folderPermissions != null)
{
taskFolder.PermissionSet = folderPermissions[folderPropertyIndex];
}
createFolderRequest.Folders[folderPropertyIndex] = taskFolder;
}
else if (folderClasses[folderPropertyIndex] == "IPF.Search")
{
SearchFolderType searchFolder = new SearchFolderType();
searchFolder.DisplayName = folderResourceName;
// Set search parameters.
searchFolder.SearchParameters = new SearchParametersType();
searchFolder.SearchParameters.Traversal = SearchFolderTraversalType.Deep;
searchFolder.SearchParameters.TraversalSpecified = true;
searchFolder.SearchParameters.BaseFolderIds = new DistinguishedFolderIdType[1];
DistinguishedFolderIdType inboxType = new DistinguishedFolderIdType();
inboxType.Id = new DistinguishedFolderIdNameType();
inboxType.Id = DistinguishedFolderIdNameType.inbox;
searchFolder.SearchParameters.BaseFolderIds[0] = inboxType;
// Use the following search filter
searchFolder.SearchParameters.Restriction = new RestrictionType();
PathToUnindexedFieldType path = new PathToUnindexedFieldType();
path.FieldURI = UnindexedFieldURIType.itemSubject;
RestrictionType restriction = new RestrictionType();
ExistsType isEqual = new ExistsType();
isEqual.Item = path;
restriction.Item = isEqual;
searchFolder.SearchParameters.Restriction = restriction;
if (folderPermissions != null)
{
searchFolder.PermissionSet = folderPermissions[folderPropertyIndex];
}
createFolderRequest.Folders[folderPropertyIndex] = searchFolder;
}
else
{
// Set Display Name and Folder Class for the folder to be created.
FolderType folder = new FolderType();
folder.DisplayName = folderResourceName;
folder.FolderClass = folderClasses[folderPropertyIndex];
if (folderPermissions != null)
{
folder.PermissionSet = folderPermissions[folderPropertyIndex];
}
createFolderRequest.Folders[folderPropertyIndex] = folder;
}
}
return createFolderRequest;
}
/// <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>
/// Get the server ID for the given default folder type in the actual FolderSyncResponse.
/// </summary>
/// <param name="folderSyncResponse">A FolderSyncResponse returned by previous ActiveSync FolderSync operation.</param>
/// <param name="folderType">Specify the default folder type.</param>
/// <param name="site">An instance of interface ITestSite which provides logging, assertions, and adapters for test code onto its execution context.</param>
/// <returns>Returns the server ID associated with the specified default folder type.</returns>
public static string GetDefaultFolderServerId(FolderSyncResponse folderSyncResponse, FolderType folderType, ITestSite site)
{
site.Assert.IsNotNull(folderSyncResponse, "The FolderSyncResponse should not be null.");
site.Assert.IsNotNull(folderSyncResponse.ResponseData, "The FolderSyncResponse.ResponseData should not be null.");
site.Assert.IsNotNull(folderSyncResponse.ResponseData.Changes, "The FolderSyncResponse.ResponseData.Changes should not be null.");
site.Assert.IsNotNull(folderSyncResponse.ResponseData.Changes.Add, "The FolderSyncResponse.ResponseData.Changes.Add should not be null.");
string serverId = null;
foreach (FolderSyncChangesAdd addResponse in folderSyncResponse.ResponseData.Changes.Add)
{
int type = (int)folderType;
if (string.Equals(addResponse.Type, type.ToString(), StringComparison.CurrentCultureIgnoreCase))
{
serverId = addResponse.ServerId;
break;
}
}
return serverId;
}
/// <summary>
/// Create a new folder on the server
/// </summary>
/// <param name="parentFolderHandle">The parent folder handle</param>
/// <param name="name">The new folder name</param>
/// <param name="newFolderHandle">Return the new folder handle</param>
/// <param name="folderType">Specifies the folder type</param>
/// <returns>The server response</returns>
private RopCreateFolderResponse CreateFolder(uint parentFolderHandle, string name, out uint newFolderHandle, FolderType folderType)
{
RopCreateFolderRequest createFolderRequest;
RopCreateFolderResponse createFolderResponse;
createFolderRequest.RopId = (byte)RopId.RopCreateFolder;
createFolderRequest.LogonId = TestSuiteBase.LogonId;
// Set InputHandleIndex to 0x0,which specifies the location in the Server object handle table
// where the handle for the input Server object is stored.
createFolderRequest.InputHandleIndex = 0;
// Set OutputHandleIndex to 0x01,which specifies the location in the Server object handle table
// where the handle for the output Server object will be stored.
createFolderRequest.OutputHandleIndex = 1;
createFolderRequest.FolderType = (byte)folderType;
// Set UseUnicodeStrings to 0x0(FALSE),which specifies the DisplayName and Comment are not specified in Unicode.
createFolderRequest.UseUnicodeStrings = 0;
// Set OpenExisting to 0xFF,which means the folder being created will be opened when it is already existed.
createFolderRequest.OpenExisting = 1;
// Set Reserved to 0x0,this field is reserved and MUST be set to 0.
createFolderRequest.Reserved = 0;
// Set DisplayName,which specifies the name of the created folder.
createFolderRequest.DisplayName = Encoding.ASCII.GetBytes(name + "\0");
// Set Comment,which specifies the folder comment that is associated with the created folder.
createFolderRequest.Comment = Encoding.ASCII.GetBytes(name + "\0");
IList<IDeserializable> response = this.cnotifAdapter.Process(
createFolderRequest,
parentFolderHandle,
out this.responseSOHs);
createFolderResponse = (RopCreateFolderResponse)response[0];
this.Site.Assert.AreEqual<uint>(
0,
createFolderResponse.ReturnValue,
"If ROP succeeds, the ReturnValue of its response is 0(success)");
newFolderHandle = this.responseSOHs[0][createFolderResponse.OutputHandleIndex];
return createFolderResponse;
}
/// <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;
}
