/// <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; }