/// <summary> /// Delete a folder from mailbox. /// </summary> /// <param name="request">Request DeleteFolder operation.</param> /// <returns>Response of DeleteFolder operation.</returns> public DeleteFolderResponseType DeleteFolder(DeleteFolderType request) { // Send the request and get the response. DeleteFolderResponseType response = this.exchangeServiceBinding.DeleteFolder(request); Site.Assert.IsNotNull(response, "If the operation is successful, the response should not be null."); return response; }
/// <remarks/> public void DeleteFolderAsync(DeleteFolderType DeleteFolder1, object userState) { if ((this.DeleteFolderOperationCompleted == null)) { this.DeleteFolderOperationCompleted = new System.Threading.SendOrPostCallback(this.OnDeleteFolderOperationCompleted); } this.InvokeAsync("DeleteFolder", new object[] { DeleteFolder1}, this.DeleteFolderOperationCompleted, userState); }
/// <remarks/> public void DeleteFolderAsync(DeleteFolderType DeleteFolder1) { this.DeleteFolderAsync(DeleteFolder1, null); }
/// <remarks/> public System.IAsyncResult BeginDeleteFolder(DeleteFolderType DeleteFolder1, System.AsyncCallback callback, object asyncState) { return this.BeginInvoke("DeleteFolder", new object[] { DeleteFolder1}, callback, asyncState); }
/// <summary> /// Delete a folder from mailbox. /// </summary> /// <param name="request">Request DeleteFolder operation.</param> /// <returns>Response of DeleteFolder operation.</returns> public DeleteFolderResponseType DeleteFolder(DeleteFolderType request) { // Send the request and get the response. DeleteFolderResponseType response = this.exchangeServiceBinding.DeleteFolder(request); Site.Assert.IsNotNull(response, "If the operation is successful, the response should not be null."); if (ResponseClassType.Success == response.ResponseMessages.Items[0].ResponseClass) { this.VerifyDeleteFolderResponse(this.exchangeServiceBinding.IsSchemaValidated); this.VerifyAllRelatedRequirements(this.exchangeServiceBinding.IsSchemaValidated, response); } // Verify transport type related requirement. this.VerifyTransportType(); // Verify soap version. this.VerifySoapVersion(); return response; }
/// <summary> /// Generate the request message for operation "DeleteFolder". /// </summary> /// <param name="deleteType">How folders are to be deleted.</param> /// <param name="folderIds">An array of folder identifier of the folders need to be deleted</param> /// <returns>Delete folder request instance that will send to server.</returns> protected DeleteFolderType GetDeleteFolderRequest(DisposalType deleteType, 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!"); DeleteFolderType deleteFolderRequest = new DeleteFolderType(); // Specify the delete type. deleteFolderRequest.DeleteType = deleteType; int folderCount = folderIds.Length; // Set the request's folderId field. deleteFolderRequest.FolderIds = new BaseFolderIdType[folderCount]; for (int folderIdIndex = 0; folderIdIndex < folderCount; folderIdIndex++) { deleteFolderRequest.FolderIds[folderIdIndex] = folderIds[folderIdIndex]; } return deleteFolderRequest; }
/// <summary> /// Clean up the environment. /// </summary> protected override void TestCleanup() { // Ensure use the right user to clean up. #region Switch user this.SwitchUser(Common.GetConfigurationPropertyValue("User1Name", this.Site), Common.GetConfigurationPropertyValue("User1Password", this.Site), Common.GetConfigurationPropertyValue("Domain", this.Site)); #endregion // Following codes shall be run after every test case execution. #region Delete the new created folder to make sure each case run at the same environment. // Clean up all created folders. if (this.newCreatedFolderIds.Count > 0) { for (int temp = 0; temp < this.newCreatedFolderIds.Count; temp++) { // Delete folder request. DeleteFolderType deleteFolderRequest = new DeleteFolderType(); // Specify the delete type. deleteFolderRequest.DeleteType = DisposalType.HardDelete; // Set the deleteFolderRequest's folderId type. deleteFolderRequest.FolderIds = new BaseFolderIdType[1]; deleteFolderRequest.FolderIds[0] = this.newCreatedFolderIds[temp]; // Delete the specified folder. this.FOLDAdapter.DeleteFolder(deleteFolderRequest); } } // Clean up all created items. if (this.newCreatedItemIds.Count > 0) { for (int temp = 0; temp < this.newCreatedItemIds.Count; temp++) { this.DeleteItem(this.newCreatedItemIds[temp]); } } #endregion }
/// <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> /// 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 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 }