private static string BuildOutput(DeleteContext context) { MarkdownBuilder builder = new MarkdownBuilder(); bool empty = true; if (context.DeletedFiles.Count > 0) { builder.Header("Deleted files"); builder.WriteRawPathList(context.DeletedFiles); empty = false; } if (context.DeletedFolders.Count > 0) { builder.Header("Deleted directories"); builder.WriteRawPathList(context.DeletedFolders); empty = false; } if (empty) { builder.Italic("Nothing deleted."); } return(builder.ToString()); }
public async Task DeleteContextValidator_ThrowsWhenInputIdsIsEmpty() { var context = new DeleteContext <TestEntity>(EndpointName.Tests, new List <int>()); await this.pipelineElement.ProcessAsync(context, MockLogger.Object, default) .ConfigureAwait(false); }
public async Task RestClientDeleteHandler_RestClientIsInvokedWithExpectedInputsAsync() { var idsToDelete = new List <long> { 1, 2, 3 }; // rest client Delete() method is called with 3 parameters: // the request id, the endpoint, and the list of id's to delete this.mockRestClient .Setup(p => p.DeleteAsync( It.Is <EndpointName>(t => t.Equals(EndpointName.Tests)), It.Is <IEnumerable <long> >(s => s.IsEqualTo(idsToDelete)), It.IsAny <LogContext>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(Response)); var context = new DeleteContext <BasicTestEntity>(EndpointName.Tests, idsToDelete) { RestClient = this.mockRestClient.Object }; await this.pipelineElement.ProcessAsync(context, NullLogger.Instance, default).ConfigureAwait(false); this.mockRestClient.VerifyAll(); }
/// <summary> /// Asynchronously Delete Jobcode Assignments, with support for cancellation. /// </summary> /// <remarks> /// Delete one or more <see cref="JobcodeAssignment"/> assignments, by id. /// </remarks> /// <param name="ids"> /// The set of ids for the <see cref="JobcodeAssignment"/> assignment objects to be deleted. /// </param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The asynchronous task.</returns> public async Task DeleteJobcodeAssignmentsAsync( IEnumerable <long> ids, CancellationToken cancellationToken) { var context = new DeleteContext <JobcodeAssignment>(EndpointName.JobcodeAssignments, ids); await ExecuteOperationAsync(context, cancellationToken).ConfigureAwait(false); }
/// <summary> /// Asynchronously Delete Timesheets, with support for cancellation. /// </summary> /// <remarks> /// Delete one or more <see cref="Timesheet"/> objects, by id. /// </remarks> /// <param name="ids"> /// The set of ids for the <see cref="Timesheet"/> objects to be deleted. /// </param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The asynchronous task.</returns> public async Task DeleteTimesheetsAsync( IEnumerable <int> ids, CancellationToken cancellationToken) { var context = new DeleteContext <Timesheet>(EndpointName.Timesheets, ids); await ExecuteOperationAsync(context, cancellationToken).ConfigureAwait(false); }
protected override bool OnDeleting(DeleteContext deleteContext) { if (OnDeletingFun != null) { var flag = OnDeletingFun(deleteContext); } return(base.OnDeleting(deleteContext)); }
/// <summary> /// Asynchronously Delete Notifications, with support for cancellation. /// </summary> /// <remarks> /// Delete one or more <see cref="Notification"/> objects, by id. /// </remarks> /// <param name="ids"> /// The set of ids for the <see cref="Notification"/> objects to be deleted. /// </param> /// <param name="cancellationToken"> /// A cancellation token that can be used by other objects or threads to receive notice of cancellation. /// </param> /// <returns>The asynchronous task.</returns> public async Task DeleteNotificationsAsync( IEnumerable <long> ids, CancellationToken cancellationToken) { var context = new DeleteContext <Notification>(EndpointName.Notifications, ids); await ExecuteOperationAsync(context, cancellationToken).ConfigureAwait(false); }
public async Task DeleteResultsSerializer_CorrectlyDeserializesResponseWithErrorResultsAsync() { DeleteContext <TestEntity> context = GetDeleteContextWithErrorItems <TestEntity>(); await this.pipelineElement.ProcessAsync(context, NullLogger.Instance, default).ConfigureAwait(false); const int expectedCount = 2; Assert.AreEqual(expectedCount, context.Results.ErrorItems.Count, $"Expected {expectedCount} error results."); }
private void DeleteFile(string filePath, DeleteContext context) { if (!File.Exists(filePath)) { return; } context.DeletedFiles.Add(filePath.GetFriendlyPath(context.SourceLobby)); ProcessFileDelete(filePath, context); }
public async Task ExecuteAsync(DeleteContext context, DeleteResult result, CancellationToken cancellationToken) { try { await _repository.DeleteByIdAsync(context.Id, context.ETag, cancellationToken); result.ResourceWasDeleted = true; } catch (Exception ex) { result.Exception = ex; } }
private void ProcessFileDelete(string filePath, DeleteContext context) { if (context.Preview) { return; } try { File.Delete(filePath); } catch (Exception exception) { logger.Error("File delete: " + filePath, exception); } }
private void DeleteDirectory(string directoryPath, DeleteContext context) { foreach (string filePath in TexoDirectory.GetFiles(directoryPath)) { DeleteFile(filePath, context); } if (context.Preview || !TexoDirectory.IsEmpty(directoryPath)) { return; } context.DeletedFolders.Add(directoryPath.GetFriendlyPath(context.SourceLobby)); ProcessDirectoryDelete(directoryPath); }
private ICommandResult Delete(DeleteContext context) { foreach (string path in context.Items) { switch (path.GetPathType()) { case PathTypeEnum.File: DeleteFile(path, context); break; case PathTypeEnum.Directory: DeleteDirectory(path, context); break; } } return(new ItemsResult(Item.AsMarkdown(BuildOutput(context)))); }
/// <summary> /// 数据库操作类 /// </summary> /// <param name="ConnectionString">链接串 不传入默认为 ConnectionString </param> public DBContext(string ConnectionString = null) { if (string.IsNullOrEmpty(ConnectionString)) { _ConnectionString = System.Configuration.ConfigurationManager.ConnectionStrings["ConnectionString"].ToString(); } else { _ConnectionString = ConnectionString; } add = new AddContext(_ConnectionString); edit = new EditContext(_ConnectionString); delete = new DeleteContext(_ConnectionString); find = new FindContext(_ConnectionString); dbhelper = new DbHelper(_ConnectionString); check = new CheckContext <BaseEntity>(_ConnectionString); jss = new JavaScriptSerializer(); }
public void PipelineFactory_GivenDeleteContext_BuildsExpectedPipeline() { var context = new DeleteContext <TestEntity>( EndpointName.Tests, new[] { 1, 2, 3 }); var pipeline = (RequestPipeline)this.pipelineFactory.GetPipeline(context); Type[] expectedElementTypes = { typeof(DeleteContextValidator), typeof(RestClientDeleteHandler), typeof(DeleteResultsDeserializer), typeof(MultiStatusHandler) }; IPipelineElement[] actualElements = pipeline.PipelineElements.ToArray(); AssertElements(expectedElementTypes, actualElements); }
public async Task RestClientDeleteHandler_RestClientSetsResponseContentPropertyOfContextObjectAsync() { this.mockRestClient .Setup(p => p.DeleteAsync( It.IsAny <EndpointName>(), It.IsAny <IEnumerable <long> >(), It.IsAny <LogContext>(), It.IsAny <CancellationToken>())) .Returns(Task.FromResult(Response)); var context = new DeleteContext <BasicTestEntity>(EndpointName.Tests, new long[] { 1 }) { RestClient = this.mockRestClient.Object }; await this.pipelineElement.ProcessAsync(context, NullLogger.Instance, default); Assert.AreEqual(Response, context.ResponseContent, "Expected response content to be set."); this.mockRestClient.VerifyAll(); }
private async Task DeleteAsync(MusicDb db, PathData pd) { db.ChangeTracker.AutoDetectChangesEnabled = false; taskItem = await db.TaskItems.FindAsync(taskId); IEnumerable <MusicFile> musicFileList = null; string path = ""; if (pd.GetFullOpusPath() != null) { path = pd.IsCollections ? pd.OpusPath : $"{pd.ArtistPath}\\{pd.OpusPath}"; musicFileList = db.MusicFiles .Where(f => (f.DiskRoot.ToLower() == pd.DiskRoot.ToLower()) && (f.StylePath.ToLower() == pd.StylePath.ToLower()) && (f.OpusPath.ToLower() == path.ToLower())) .OrderBy(f => f.File) ; } else { if (pd.IsCollections) { musicFileList = db.MusicFiles .Where(f => (f.DiskRoot.ToLower() == pd.DiskRoot.ToLower()) && (f.StylePath.ToLower() == pd.StylePath.ToLower()) && f.Musician.ToLower() == "collections") .OrderBy(f => f.File) ; } else { musicFileList = db.MusicFiles .Where(f => (f.DiskRoot.ToLower() == pd.DiskRoot.ToLower()) && (f.StylePath.ToLower() == pd.StylePath.ToLower()) && f.OpusPath.StartsWith(pd.ArtistPath)) .OrderBy(f => f.File) ; } } log.Information($"Deleting {musicFileList.Count()} music files"); var dc = new DeleteContext(taskItem); foreach (var mf in musicFileList) { db.Delete(mf, dc); } taskItem.Status = Music.Core.TaskStatus.Finished; taskItem.FinishedAt = DateTimeOffset.Now; await db.SaveChangesAsync(); if (dc.DeletedArtistId.HasValue) { await this.playManager.SendArtistDeleted(dc.DeletedArtistId.Value); } else if (dc.ModifiedArtistId.HasValue) { var shouldSend = true; var artist = await db.Artists.FindAsync(dc.ModifiedArtistId.Value); if (artist != null) { shouldSend = artist.Type != ArtistType.Various; } if (shouldSend) { await this.playManager.SendArtistNewOrModified(dc.ModifiedArtistId.Value); } } //if (dc.DeletedArtistId.HasValue || dc.ModifiedArtistId.HasValue) //{ // var shouldSend = true; // var id = dc.ModifiedArtistId ?? 0; // if (id > 0) // { // var artist = await db.Artists.FindAsync(id); // shouldSend = artist.Type != ArtistType.Various; // } // if (shouldSend) // { // if (dc.DeletedArtistId.HasValue) // { // await this.playManager.SendArtistDeleted(dc.DeletedArtistId.Value); // } // else if (dc.ModifiedArtistId.HasValue) // { // await this.playManager.SendArtistNewOrModified(dc.ModifiedArtistId.Value); // } // } //} // send artist modified/deleted - info is in dc }
public bool OnDeleting(IDatabase database, DeleteContext deleteContext) { var context = deleteContext; return(true); }