public void DeleteIfExists(DeleteMode deleteMode = DeleteMode.Normal) { ThrowIfRelative(); if (FileExists() || DirectoryExists()) { Delete(deleteMode); } }
public override void Deserialize(BinaryReader reader) { base.Deserialize(reader); ObjectID = reader.ReadInt16(); ObjectPID = reader.ReadUInt32(); CleanupAll = reader.ReadBoolean(); Success = reader.ReadBoolean(); Mode = (DeleteMode)reader.ReadByte(); }
/// <summary> /// Empties the folder. Calling this method results in a call to EWS. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="deleteSubFolders">Indicates whether sub-folders should also be deleted.</param> public Task <ServiceResponseCollection <ServiceResponse> > Empty( DeleteMode deleteMode, bool deleteSubFolders) { this.ThrowIfThisIsNew(); return(this.Service.EmptyFolder( this.Id, deleteMode, deleteSubFolders)); }
/// <summary> /// Deletes the object. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="sendCancellationsMode">Indicates whether meeting cancellation messages should be sent.</param> /// <param name="affectedTaskOccurrences">Indicate which occurrence of a recurring task should be deleted.</param> internal override Task <ServiceResponseCollection <ServiceResponse> > InternalDelete( DeleteMode deleteMode, SendCancellationsMode?sendCancellationsMode, AffectedTaskOccurrence?affectedTaskOccurrences, CancellationToken token) { this.ThrowIfThisIsNew(); return(this.Service.DeleteFolder(this.Id, deleteMode, token)); }
/// <summary> /// Empties the folder. Calling this method results in a call to EWS. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="deleteSubFolders">Indicates whether sub-folders should also be deleted.</param> public void Empty( DeleteMode deleteMode, bool deleteSubFolders) { this.ThrowIfThisIsNew(); this.Service.EmptyFolder( this.Id, deleteMode, deleteSubFolders); }
internal void DeleteIfExists(DeleteMode deleteMode = DeleteMode.Normal) { ThrowIfNotInitialized(); ThrowIfRelative(); if (FileExists() || DirectoryExists()) { Delete(deleteMode); } }
public override bool Verify(VM vm, VMAvatar caller) { if (Verified) { return(true); } ObjectPID = 0; VMEntity obj = vm.GetObjectById(ObjectID); if (!vm.TS1) { Mode = vm.PlatformState.Validator.GetDeleteMode(Mode, caller, obj); if (Mode == DeleteMode.Disallowed) { return(false); } if (caller.AvatarState.Permissions == VMTSOAvatarPermissions.Admin) { VMNetLockCmd.LockObj(vm, obj); return(true); //admins can always deete } } else if (vm.Context.Cheats.MoveObjects) //for ts1 moveobjects cheat { return(true); } if (obj == null || (obj is VMAvatar) || obj.IsUserMovable(vm.Context, true) != VMPlacementError.Success) { return(false); } if ((((VMGameObject)obj).Disabled & VMGameObjectDisableFlags.TransactionIncomplete) > 0) { return(false); //can't delete objects mid trasaction... } VMNetLockCmd.LockObj(vm, obj); if (Mode == DeleteMode.Delete) { //straight up delete this object. another check will be done at the execution stage. return(true); } else { //send to the owner's inventory ObjectPID = obj.PersistID; //we don't want to accidentally delete the wrong object - so use its real persist id. vm.GlobalLink.MoveToInventory(vm, obj.MultitileGroup, (bool success, uint pid) => { Success = success; Verified = true; vm.ForwardCommand(this); }); return(false); } }
public RelationAttribute(Type relatedType, string relatedColumn, string mamyToManyRelationTable, string MtmRelationTableParentColumn, string MtmRelationTableChildColumn, DeleteMode deleteMode) { _relationType = RelationType.ManyToMany; _relatedType = relatedType; _relatedColumn = relatedColumn; _mamyToManyRelationTable = mamyToManyRelationTable; _MtmRelationTableParentColumn = MtmRelationTableParentColumn; _MtmRelationTableChildColumn = MtmRelationTableChildColumn; _deleteMode = deleteMode; }
public void ExcluirEmail(EmailMessage mail) { try { DeleteMode delete = DeleteMode.MoveToDeletedItems; mail.Delete(delete); } catch (Exception ex) { Console.WriteLine(ex); } }
/// <summary> /// Empties the folder. Calling this method results in a call to EWS. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="deleteSubFolders">Indicates whether sub-folders should also be deleted.</param> public Task <ServiceResponseCollection <ServiceResponse> > Empty( DeleteMode deleteMode, bool deleteSubFolders, CancellationToken token = default(CancellationToken)) { this.ThrowIfThisIsNew(); return(this.Service.EmptyFolder( this.Id, deleteMode, deleteSubFolders, token)); }
/// <summary> /// Deletes items in the specified conversation. /// Calling this method results in a call to EWS. /// </summary> /// <param name="contextFolderId">The Id of the folder items must belong to in order to be deleted. If contextFolderId is /// null, items across the entire mailbox are deleted.</param> /// <param name="deleteMode">The deletion mode.</param> public async System.Threading.Tasks.Task DeleteItems( FolderId contextFolderId, DeleteMode deleteMode) { (await this.Service.DeleteItemsInConversations( new KeyValuePair <ConversationId, DateTime?>[] { new KeyValuePair <ConversationId, DateTime?>( this.Id, this.GlobalLastDeliveryTime) }, contextFolderId, deleteMode).ConfigureAwait(false))[0].ThrowIfNecessary(); }
/// <summary> /// Deletes items in the specified conversation. /// Calling this method results in a call to EWS. /// </summary> /// <param name="contextFolderId">The Id of the folder items must belong to in order to be deleted. If contextFolderId is /// null, items across the entire mailbox are deleted.</param> /// <param name="deleteMode">The deletion mode.</param> public void DeleteItems( FolderId contextFolderId, DeleteMode deleteMode) { this.Service.DeleteItemsInConversations( new KeyValuePair <ConversationId, DateTime?>[] { new KeyValuePair <ConversationId, DateTime?>( this.Id, this.GlobalLastDeliveryTime) }, contextFolderId, deleteMode)[0].ThrowIfNecessary(); }
public override DeleteMode GetDeleteMode(DeleteMode desired, VMAvatar ava, VMEntity obj) { if (desired > DeleteMode.Delete) { return(DeleteMode.Disallowed); } if (obj == null || ava == null) { return(DeleteMode.Disallowed); } if (desired == DeleteMode.Sendback && (obj.PersistID == 0 || obj is VMAvatar || !CanSendbackObject(ava, (VMGameObject)obj))) { return(DeleteMode.Disallowed); } if (obj is VMAvatar && ava.AvatarState.Permissions < VMTSOAvatarPermissions.Admin) { return(DeleteMode.Disallowed); } if (ava.AvatarState.Permissions >= VMTSOAvatarPermissions.Owner) { return(desired); } if (ava.AvatarState.Permissions < VMTSOAvatarPermissions.BuildBuyRoommate) { return(DeleteMode.Disallowed); } //build buy donator can delete build mode objects that are donated if (!(obj.TSOState as VMTSOObjectState).ObjectFlags.HasFlag(VMTSOObjectFlags.FSODonated)) { return(DeleteMode.Disallowed); } var catalog = Content.Content.Get().WorldCatalog; var item = catalog.GetItemByGUID(obj.Object.OBJ.GUID); if (item != null) { if (BuilderWhiteList.Contains(item.Value.Category) && !RoomieWhiteList.Contains(item.Value.Category)) { return(desired); } } return(DeleteMode.Disallowed); }
public static void RemoveWorkspace(Workspace workspace, DeleteMode deleteMode) { Workspaces.Remove(workspace); if (deleteMode == DeleteMode.DeleteWorkspace) { try { Directory.Delete(workspace.WorkspacePath, true); } catch (Exception ex) { Logger.Error(ex, "Error deleting workspace folder {0}", workspace.WorkspacePath); } } }
private static void DeleteTask(ExchangeService service, string Subject, DeleteMode deleteMode) { // Try to retrieve the task specified by the subject. Task task = Ex15_FindTaskBySubject_CS.FindTaskBySubject(service, Subject); // If the task if found, delete it with the specified deleteMode. if (task != null) { task.Delete(deleteMode); Console.WriteLine("Task deleted."); } else { Console.WriteLine("Task not found."); } }
private static void HandleDelete(DeleteMode d, string file) { switch (d) { case DeleteMode.truncate: File.WriteAllBytes(file, new byte[0]); break; case DeleteMode.delete: File.Delete(file); break; default: break; } }
/// <summary> /// Deletes the specified page version id. /// </summary> /// <param name="pageVersionId">The page version id.</param> /// <param name="userUID">The user UID.</param> /// <param name="deleteMode">The delete mode.</param> public void Delete(int pageVersionId, Guid userUID, DeleteMode deleteMode) { switch (deleteMode) { case DeleteMode.TemporaryStorage: if (userUID != Guid.Empty) { _temporaryDocumentStorage.Delete(pageVersionId, userUID); } break; case DeleteMode.PersistantStorage: //pDocument = _persistentDocumentStorage.Load(PageVersionId); break; default: throw new ArgumentNullException("DeleteMode"); } }
static void DeleteFolder(ExchangeService service, string DisplayName, DeleteMode deleteMode, WellKnownFolderName ParentFolder) { // Attempt to retrieve the unique identifier of the folder with the specified display name (DisplayName) within the specified folder (ParentFolder). FolderId folderId = Ex15_FindFolderIdByDisplayName_CS.FindFolderIdByDisplayName(service, DisplayName, ParentFolder); if (folderId != null) { // Bind to the folder by using its unique identifier. Folder folder = Folder.Bind(service, folderId); // Delete the folder. folder.Delete(deleteMode); Console.WriteLine("Folder '" + DisplayName + "' has been deleted."); } else { Console.WriteLine("Folder '" + DisplayName + "' could not be found in the '" + ParentFolder + "' folder."); } }
private void Delete(DeleteMode mode) { if (CheckDeleteGroup()) { foreach (DataGridViewRow row in dgvResult.Rows) { if (row.Cells["colMatchType"].Value.ToString() == "SEPARATOR") { continue; } if (true == Convert.ToBoolean(row.Cells["colCheck"].Value)) { string filename = row.Cells["colFilename"].Value.ToString(); try { Font fnt = new System.Drawing.Font(row.InheritedStyle.Font, FontStyle.Strikeout); row.DefaultCellStyle.Font = fnt; row.DefaultCellStyle.BackColor = Color.Red; row.Cells["colCheck"].Value = false; if (mode == DeleteMode.RECYCLED) { Logger.Info("Delete to Recyle Bin: " + filename); Microsoft.VisualBasic.FileIO.FileSystem.DeleteFile(filename, Microsoft.VisualBasic.FileIO.UIOption.OnlyErrorDialogs, Microsoft.VisualBasic.FileIO.RecycleOption.SendToRecycleBin); } else if (mode == DeleteMode.PERMANENT) { Logger.Info("Delete Permanently: " + filename); System.IO.File.Delete(filename); } row.Cells["colStatus"].Value = mode.ToString(); } catch (Exception ex) { Logger.Error(ex.Message + "(" + filename + ")."); row.Cells["colStatus"].Value = ex.Message; } } } MessageBox.Show("Done."); } }
public void Delete(DeleteMode deleteMode = DeleteMode.Normal) { ThrowIfNotInitialized(); ThrowIfRelative(); if (IsRoot) { throw new NotSupportedException("Delete is not supported on a root level directory because it would be dangerous:" + ToString()); } var isFile = FileExists(); var isDir = DirectoryExists(); if (!isFile && !isDir) { throw new InvalidOperationException("Trying to delete a path that does not exist: " + ToString()); } try { if (isFile) { FSWrapper.FileDelete(this); } else { FSWrapper.DirectoryDelete(this, true); } } catch (IOException) { if (deleteMode == DeleteMode.Normal) { throw; } } }
/// <summary> /// Deserialize <see cref="RequestDelete"/>. /// </summary> /// <param name="uid"><c>uid</c> associated with the request</param> /// <param name="path">Path associated with the request</param> /// <returns>The deserialized request</returns> private RequestDelete DeserializeRequestDelete(ulong uid, string path) { int version = this.binaryReader.ReadInt32(); DeleteMode mode = DeleteMode.None; if (this.serializationVersionUsed >= SerializationFormatVersions.Version18) { ushort moderaw = this.binaryReader.ReadUInt16(); mode = (DeleteMode)moderaw; } else { bool iscascade = this.binaryReader.ReadBoolean(); if (iscascade) { mode |= DeleteMode.CascadeDelete; } } return(new RequestDelete(path, version, mode, uid)); }
/// <summary> /// Deletes the folder. Calling this method results in a call to EWS. /// </summary> /// <param name="deleteMode">Deletion mode.</param> public Task <ServiceResponseCollection <ServiceResponse> > Delete(DeleteMode deleteMode) { return(this.InternalDelete(deleteMode, null, null)); }
/// <summary> /// Deletes the object. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="sendCancellationsMode">Indicates whether meeting cancellation messages should be sent.</param> /// <param name="affectedTaskOccurrences">Indicate which occurrence of a recurring task should be deleted.</param> internal override void InternalDelete( DeleteMode deleteMode, SendCancellationsMode? sendCancellationsMode, AffectedTaskOccurrence? affectedTaskOccurrences) { throw new NotSupportedException(); }
public void DeleteFolder(FolderId findFolderId, DeleteMode deleteMode) { Folder folder = Folder.Bind(CurrentExchangeService, findFolderId); folder.Delete(deleteMode); }
/// <summary> /// Deletes the current occurrence of a recurring task. After the current occurrence isdeleted, /// the task represents the next occurrence. Developers should call Load to retrieve the new property /// values of the task. Calling this method results in a call to EWS. /// </summary> /// <param name="deleteMode">The deletion mode.</param> public void DeleteCurrentOccurrence(DeleteMode deleteMode) { this.InternalDelete( deleteMode, null, AffectedTaskOccurrence.SpecifiedOccurrenceOnly); }
public void DeleteFolder(string findFolderId, DeleteMode deleteMode) { Folder folder = _ewsOperator. FolderBind(findFolderId); _ewsOperator.FolderDelete(folder, deleteMode); }
/// <summary> /// Deletes a file and it's associated revisions. Iteratively deletes revisions for a file one by one. /// </summary> /// <param name="mode">Soft deletes are atomic. Hard are atomic on the file but not a file's chunks.</param> /// <param name="deleteOpts">Delete durability options. See ReQL API.</param> /// <param name="bucket"><see cref="Bucket"/></param> /// <param name="filename">The filename</param> public static void DeleteAllRevisions(this Bucket bucket, string filename, DeleteMode mode = DeleteMode.Soft, object deleteOpts = null) { DeleteAllRevisionsAsync(bucket, filename, mode, deleteOpts).WaitSync(); }
private void AddColOnClick(object sender, RoutedEventArgs e) { Mode = DeleteMode.Undelete; Step.AddPoint(); AddCol(Step.GetPointCount() - 1); }
private void DelRowOnClick(object sender, RoutedEventArgs e) { mainGrid.SelectedIndex = -1; Mode = DeleteMode.DeleteRow; }
/// <summary> /// Deletes async the item. Calling this method results in a call to EWS. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="suppressReadReceipts">Whether to suppress read receipts</param> public async System.Threading.Tasks.Task DeleteAsync(DeleteMode deleteMode, bool suppressReadReceipts) { await this.InternalDeleteAsync(deleteMode, null, null, suppressReadReceipts); }
/// <summary> /// Deletes async the object. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="sendCancellationsMode">Indicates whether meeting cancellation messages should be sent.</param> /// <param name="affectedTaskOccurrences">Indicate which occurrence of a recurring task should be deleted.</param> /// <returns></returns> /// <exception cref="System.InvalidOperationException"></exception> internal override System.Threading.Tasks.Task InternalDeleteAsync(DeleteMode deleteMode, SendCancellationsMode? sendCancellationsMode, AffectedTaskOccurrence? affectedTaskOccurrences) { throw new InvalidOperationException(Strings.DeletingThisObjectTypeNotAuthorized); }
/// <summary> /// Helper method for deleting folder. /// </summary> /// <param name="folder">Folder to delete.</param> /// <param name="deleteMode">Delete mode operation.</param> private void RemoveFolder(Folder folder, DeleteMode deleteMode) { folder.Delete(deleteMode); }
/// <summary> /// Deletes async the item. Calling this method results in a call to EWS. /// </summary> /// <param name="deleteMode">The deletion mode.</param> public async System.Threading.Tasks.Task DeleteAsync(DeleteMode deleteMode) { await this.DeleteAsync(deleteMode, false); }
/// <summary> /// Deletes a file in the bucket. /// </summary> /// <param name="mode">Soft deletes are atomic. Hard are atomic on the file but not a file's chunks.</param> /// <param name="deleteOpts">Delete durability options. See ReQL API.</param> /// <param name="bucket"><see cref="Bucket"/></param> /// <param name="fileId"><see cref="FileInfo.Id"/></param> public static void DeleteRevision(this Bucket bucket, Guid fileId, DeleteMode mode = DeleteMode.Soft, object deleteOpts = null) { DeleteRevisionAsync(bucket, fileId, mode, deleteOpts).WaitSync(); }
/// <summary> /// Deletes a file and it's associated revisions. Iteratively deletes revisions for a file one by one. /// </summary> /// <param name="mode">Soft deletes are atomic. Hard are atomic on the file but not a file's chunks.</param> /// <param name="deleteOpts">Delete durability options. See ReQL API.</param> /// <param name="bucket"><see cref="Bucket"/></param> /// <param name="filename">The filename</param> public static async Task DeleteAllRevisionsAsync(this Bucket bucket, string filename, DeleteMode mode = DeleteMode.Soft, object deleteOpts = null) { filename = filename.SafePath(); var result = await GetAllRevisionsAsync(bucket, filename) .ConfigureAwait(false); foreach( var file in result ) { await DeleteRevisionAsync(bucket, file.Id, mode, deleteOpts) .ConfigureAwait(false); } }
private void UndeleteOnClick(object sender, RoutedEventArgs e) { Mode = DeleteMode.Undelete; }
public void update_mode(DeleteMode mode) => SelectedDeleteMode = mode;
/// <summary> /// This is not supported in this object. /// Deletes the object. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="sendCancellationsMode">Indicates whether meeting cancellation messages should be sent.</param> /// <param name="affectedTaskOccurrences">Indicate which occurrence of a recurring task should be deleted.</param> internal override void InternalDelete(DeleteMode deleteMode, SendCancellationsMode?sendCancellationsMode, AffectedTaskOccurrence?affectedTaskOccurrences) { throw new NotSupportedException(); }
/// <summary> /// Deletes a file in the bucket. /// </summary> /// <param name="mode">Soft deletes are atomic. Hard are atomic on the file but not a file's chunks.</param> /// <param name="deleteOpts">Delete durability options. See ReQL API.</param> /// <param name="bucket"><see cref="Bucket"/></param> /// <param name="cancelToken"><see cref="CancellationToken"/></param> /// <param name="fileId"><see cref="FileInfo.Id"/></param> public static async Task DeleteRevisionAsync(this Bucket bucket, Guid fileId, DeleteMode mode = DeleteMode.Soft, object deleteOpts = null, CancellationToken cancelToken = default(CancellationToken)) { var result = await bucket.fileTable.Get(fileId) .Update( R.HashMap(FileInfo.StatusJsonName, Status.Deleted) .With(FileInfo.DeletedDateJsonName, DateTimeOffset.UtcNow) )[deleteOpts] .RunResultAsync(bucket.conn, cancelToken) .ConfigureAwait(false); result.AssertReplaced(1); if( mode == DeleteMode.Hard ) { //delete the chunks.... await bucket.chunkTable.Between( R.Array(fileId, R.Minval()), R.Array(fileId, R.Maxval()))[new {index = bucket.chunkIndexName}] .Delete()[deleteOpts] .RunResultAsync(bucket.conn, cancelToken) .ConfigureAwait(false); //then delete the file. await bucket.fileTable.Get(fileId).Delete()[deleteOpts] .RunResultAsync(bucket.conn, cancelToken) .ConfigureAwait(false); } }
/// <summary> /// Method used to delete folder. If folder contains item or subfolder, force switch should be used. /// </summary> /// <param name="folder">Folder to delete.</param> /// <param name="deleteMode">Delete mode operation.</param> /// <param name="force">Overrides child folder and item check. </param> internal void RemoveFolder(Folder folder, DeleteMode deleteMode, bool force) { if (force) { this.RemoveFolder(folder, deleteMode); } else { int childFolderCount = folder.ChildFolderCount; int folderItemCount = folder.TotalCount; if (childFolderCount == 0 && folderItemCount == 0) this.RemoveFolder(folder, deleteMode); else { throw new InvalidOperationException(String.Format("Folder not empty or contains subfolders. ChildFolders: {0}, ItemsInFolder: {1}", childFolderCount, folderItemCount)); } } }
/// <summary> /// Deletes the item. Calling this method results in a call to EWS. /// </summary> /// <param name="deleteMode">The deletion mode.</param> public void Delete(DeleteMode deleteMode) { this.Delete(deleteMode, false); }
/// <summary> /// Deletes the folder. Calling this method results in a call to EWS. /// </summary> /// <param name="deleteMode">Deletion mode.</param> public void Delete(DeleteMode deleteMode) { this.InternalDelete(deleteMode, null, null); }
/// <summary> /// Deletes the object. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="sendCancellationsMode">Indicates whether meeting cancellation messages should be sent.</param> /// <param name="affectedTaskOccurrences">Indicate which occurrence of a recurring task should be deleted.</param> internal override async System.Threading.Tasks.Task InternalDeleteAsync( DeleteMode deleteMode, SendCancellationsMode? sendCancellationsMode, AffectedTaskOccurrence? affectedTaskOccurrences) { await this.InternalDeleteAsync(deleteMode, sendCancellationsMode, affectedTaskOccurrences, false); }
private void AddRowOnClick(object sender, RoutedEventArgs e) { Mode = DeleteMode.Undelete; Step.AddStation(); }
/// <summary> /// Deletes the item. Calling this method results in a call to EWS. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="suppressReadReceipts">Whether to suppress read receipts</param> public void Delete(DeleteMode deleteMode, bool suppressReadReceipts) { this.InternalDelete(deleteMode, null, null, suppressReadReceipts); }
public void Delete(DeleteMode deleteMode = DeleteMode.Normal) { ThrowIfRelative(); if (FileExists()) File.Delete(ToString()); else if (DirectoryExists()) try { Directory.Delete(ToString(), true); } catch (IOException) { if (deleteMode == DeleteMode.Normal) throw; } else throw new InvalidOperationException("Trying to delete a path that does not exist: " + ToString()); }
/// <summary> /// Deletes the object. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="sendCancellationsMode">Indicates whether meeting cancellation messages should be sent.</param> /// <param name="affectedTaskOccurrences">Indicate which occurrence of a recurring task should be deleted.</param> internal override void InternalDelete( DeleteMode deleteMode, SendCancellationsMode? sendCancellationsMode, AffectedTaskOccurrence? affectedTaskOccurrences) { throw new InvalidOperationException(Strings.DeletingThisObjectTypeNotAuthorized); }
/// <summary> /// Create a new instance of the <see cref="Op"/> class that represents a Delete operation. /// </summary> /// <param name="path">Path of the node to be deleted</param> /// <param name="version">Version of the node's data</param> /// <param name="deletemode">the delete mode for the operation</param> /// <returns>A Delete operation</returns> public static Op Delete(string path, int version, DeleteMode deletemode = DeleteMode.None) { return(new Op(OpCode.Delete, new RequestDelete(path, version, deletemode))); }
/// <summary> /// Deletes this appointment. Calling this method results in a call to EWS. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="sendCancellationsMode">Specifies if and how cancellations should be sent if this appointment is a meeting.</param> public void Delete(DeleteMode deleteMode, SendCancellationsMode sendCancellationsMode) { this.InternalDelete( deleteMode, sendCancellationsMode, null); }
/// <summary> /// This is not supported in this object. /// Deletes the object. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="sendCancellationsMode">Indicates whether meeting cancellation messages should be sent.</param> /// <param name="affectedTaskOccurrences">Indicate which occurrence of a recurring task should be deleted.</param> internal override Task <ServiceResponseCollection <ServiceResponse> > InternalDelete(DeleteMode deleteMode, SendCancellationsMode?sendCancellationsMode, AffectedTaskOccurrence?affectedTaskOccurrences, CancellationToken token) { throw new NotSupportedException(); }
/// <summary> /// Deletes items in the specified conversation. /// Calling this method results in a call to EWS. /// </summary> /// <param name="contextFolderId">The Id of the folder items must belong to in order to be deleted. If contextFolderId is /// null, items across the entire mailbox are deleted.</param> /// <param name="deleteMode">The deletion mode.</param> public void DeleteItems( FolderId contextFolderId, DeleteMode deleteMode) { this.Service.DeleteItemsInConversations( new KeyValuePair<ConversationId, DateTime?>[] { new KeyValuePair<ConversationId, DateTime?>( this.Id, this.GlobalLastDeliveryTime) }, contextFolderId, deleteMode)[0].ThrowIfNecessary(); }
/// <summary> /// Deletes the object. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="sendCancellationsMode">Indicates whether meeting cancellation messages should be sent.</param> /// <param name="affectedTaskOccurrences">Indicate which occurrence of a recurring task should be deleted.</param> internal override void InternalDelete( DeleteMode deleteMode, SendCancellationsMode? sendCancellationsMode, AffectedTaskOccurrence? affectedTaskOccurrences) { this.InternalDelete(deleteMode, sendCancellationsMode, affectedTaskOccurrences, false); }
/// <summary> /// Deletes async the object. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="sendCancellationsMode">Indicates whether meeting cancellation messages should be sent.</param> /// <param name="affectedTaskOccurrences">Indicate which occurrence of a recurring task should be deleted.</param> /// <returns></returns> /// <exception cref="System.NotSupportedException"></exception> internal override System.Threading.Tasks.Task InternalDeleteAsync(DeleteMode deleteMode, SendCancellationsMode? sendCancellationsMode, AffectedTaskOccurrence? affectedTaskOccurrences) { throw new NotSupportedException(); }
/// <summary> /// Deletes the object. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="sendCancellationsMode">Indicates whether meeting cancellation messages should be sent.</param> /// <param name="affectedTaskOccurrences">Indicate which occurrence of a recurring task should be deleted.</param> internal abstract void InternalDelete( DeleteMode deleteMode, SendCancellationsMode?sendCancellationsMode, AffectedTaskOccurrence?affectedTaskOccurrences);
/// <summary> /// Deletes the object. /// </summary> /// <param name="deleteMode">The deletion mode.</param> /// <param name="sendCancellationsMode">Indicates whether meeting cancellation messages should be sent.</param> /// <param name="affectedTaskOccurrences">Indicate which occurrence of a recurring task should be deleted.</param> /// <param name="suppressReadReceipts">Whether to suppress read receipts</param> internal void InternalDelete( DeleteMode deleteMode, SendCancellationsMode? sendCancellationsMode, AffectedTaskOccurrence? affectedTaskOccurrences, bool suppressReadReceipts) { this.ThrowIfThisIsNew(); this.ThrowIfThisIsAttachment(); // If sendCancellationsMode is null, use the default value that's appropriate for item type. if (!sendCancellationsMode.HasValue) { sendCancellationsMode = this.DefaultSendCancellationsMode; } // If affectedTaskOccurrences is null, use the default value that's appropriate for item type. if (!affectedTaskOccurrences.HasValue) { affectedTaskOccurrences = this.DefaultAffectedTaskOccurrences; } this.Service.DeleteItem( this.Id, deleteMode, sendCancellationsMode, affectedTaskOccurrences, suppressReadReceipts); }