public async Task Patch_should_create_events_and_update_new_version_when_draft_available() { var command = new PatchContent { Data = patch }; await ExecuteCreateAsync(); await ExecutePublishAsync(); await ExecuteCreateDraftAsync(); var result = await PublishAsync(command); result.ShouldBeEquivalent(sut.Snapshot); Assert.Equal(patched, sut.Snapshot.NewVersion?.Data); LastEvents .ShouldHaveSameEvents( CreateContentEvent(new ContentUpdated { Data = patched }) ); A.CallTo(() => scriptEngine.TransformAsync(ScriptContext(patched, data, Status.Draft), "<update-script>", ScriptOptions())) .MustHaveHappened(); }
public async Task Patch_should_create_proposal_events_and_update_state() { var command = new PatchContent { Data = patch, AsDraft = true }; await ExecuteCreateAsync(); await ExecutePublishAsync(); var result = await sut.ExecuteAsync(CreateContentCommand(command)); result.ShouldBeEquivalent(new ContentDataChangedResult(otherData, 2)); Assert.True(sut.Snapshot.IsPending); LastEvents .ShouldHaveSameEvents( CreateContentEvent(new ContentUpdateProposed { Data = patched }) ); A.CallTo(() => scriptEngine.ExecuteAndTransform(A <ScriptContext> .Ignored, "<update-script>")) .MustHaveHappened(); }
public void CanPatch_should_throw_exception_if_data_is_null() { var command = new PatchContent(); ValidationAssert.Throws(() => GuardContent.CanPatch(command), new ValidationError("Data is required.", "Data")); }
public void CanPatch_should_not_throw_exception_if_data_is_not_null() { var command = new PatchContent { Data = new NamedContentData() }; GuardContent.CanPatch(command); }
public static void CanPatch(PatchContent command) { Guard.NotNull(command, nameof(command)); Validate.It(() => "Cannot patch content.", e => { ValidateData(command, e); }); }
public async Task <IActionResult> PatchContent(Guid id, [FromBody] ContentData request) { var command = new PatchContent { ContentId = id, Data = request.ToCleaned() }; await CommandBus.PublishAsync(command); return(NoContent()); }
public async Task <IActionResult> PatchContent(string app, string name, DomainId id, [FromBody] NamedContentData request) { var command = new PatchContent { ContentId = id, Data = request.ToCleaned() }; var response = await InvokeCommandAsync(command); return(Ok(response)); }
public async Task CanPatch_should_throw_exception_if_data_is_null() { SetupCanUpdate(true); var content = CreateContent(Status.Draft); var command = new PatchContent(); await ValidationAssert.ThrowsAsync(() => GuardContent.CanPatch(content, contentWorkflow, command), new ValidationError("Data is required.", "Data")); }
public async Task CanPatch_should_throw_exception_if_workflow_blocks_it() { SetupCanUpdate(false); var content = CreateContent(Status.Draft); var command = new PatchContent { Data = new NamedContentData() }; await Assert.ThrowsAsync <DomainException>(() => GuardContent.CanPatch(content, contentWorkflow, command)); }
public async Task CanPatch_should_not_throw_exception_if_data_is_not_null() { SetupCanUpdate(true); var content = CreateContent(Status.Draft); var command = new PatchContent { Data = new NamedContentData(), User = user }; await GuardContent.CanPatch(content, contentWorkflow, command); }
public async Task <IActionResult> PatchContent(string app, string name, Guid id, [FromBody] NamedContentData request, [FromQuery] bool asDraft = false) { await contentQuery.GetSchemaOrThrowAsync(Context, name); var command = new PatchContent { ContentId = id, Data = request.ToCleaned(), AsDraft = asDraft }; var response = await InvokeCommandAsync(command); return(Ok(response)); }
public static void CanPatch(PatchContent command) { Guard.NotNull(command, nameof(command)); Validate.It(() => "Cannot patch content.", error => { if (command.Data == null) { error(new ValidationError("Data cannot be null.", nameof(command.Data))); } }); }
public void Patch(PatchContent command) { var newData = command.Data.MergeInto(Snapshot.Data); if (!newData.Equals(Snapshot.Data)) { var @event = SimpleMapper.Map(command, new ContentUpdated()); @event.Data = newData; RaiseEvent(@event); } }
public static async Task CanPatch(PatchContent command, IContentEntity content, IContentWorkflow contentWorkflow) { Guard.NotNull(command, nameof(command)); Validate.It(e => { ValidateData(command, e); }); await ValidateCanUpdate(content, contentWorkflow, command.User); }
public async Task <IActionResult> PatchContent(string app, string name, Guid id, [FromBody] NamedContentData request, [FromQuery] bool asDraft = false) { await contentQuery.ThrowIfSchemaNotExistsAsync(Context().WithSchemaName(name)); var command = new PatchContent { ContentId = id, Data = request.ToCleaned(), AsDraft = asDraft }; var context = await CommandBus.PublishAsync(command); var result = context.Result <ContentDataChangedResult>(); var response = result.Data; return(Ok(response)); }
public async Task <IActionResult> PatchContent(string app, string name, Guid id, [FromBody] NamedContentData request) { await contentQuery.FindSchemaAsync(App, name); var command = new PatchContent { ContentId = id, Data = request.ToCleaned() }; var context = await CommandBus.PublishAsync(command); var result = context.Result <ContentDataChangedResult>(); var response = result.Data; return(Ok(response)); }
public ContentDomainObject Patch(PatchContent command) { VerifyCreatedAndNotDeleted(); var newData = Data.MergeInto(command.Data); if (!newData.Equals(Data)) { RaiseEvent(SimpleMapper.Map(command, new ContentUpdated { Data = newData })); } return(this); }
protected async Task On(PatchContent command, CommandContext context) { await handler.UpdateAsync <ContentDomainObject>(context, async content => { var schemaAndApp = await ResolveSchemaAndAppAsync(command); ExecuteScriptAndTransform(command, content, schemaAndApp.SchemaEntity.ScriptUpdate, "Patch"); await ValidateAsync(schemaAndApp, command, () => "Failed to patch content", true); content.Patch(command); context.Complete(new ContentDataChangedResult(content.Data, content.Version)); }); }
protected async Task On(PatchContent command, CommandContext context) { await handler.UpdateAsync <ContentDomainObject>(context, async content => { GuardContent.CanPatch(command); var operationContext = await CreateContext(command, content, () => "Failed to patch content."); await operationContext.ValidateAsync(true); await operationContext.ExecuteScriptAndTransformAsync(x => x.ScriptUpdate, "Patch"); content.Patch(command); context.Complete(new ContentDataChangedResult(content.Snapshot.Data, content.Version)); }); }
private void AddContentPatch(string schemaType, string schemaName, ContentDataGraphInputType inputType, IComplexGraphType resultType) { AddField(new FieldType { Name = $"patch{schemaType}Content", Arguments = new QueryArguments { new QueryArgument(AllTypes.None) { Name = "id", Description = $"The id of the {schemaName} content (GUID)", DefaultValue = string.Empty, ResolvedType = AllTypes.NonNullGuid }, new QueryArgument(AllTypes.None) { Name = "data", Description = $"The data for the {schemaName} content.", DefaultValue = null, ResolvedType = new NonNullGraphType(inputType), }, new QueryArgument(AllTypes.None) { Name = "expectedVersion", Description = "The expected version", DefaultValue = EtagVersion.Any, ResolvedType = AllTypes.Int } }, ResolvedType = new NonNullGraphType(resultType), Resolver = ResolveAsync(async(c, publish) => { var contentId = c.GetArgument <Guid>("id"); var contentData = GetContentData(c); var command = new PatchContent { ContentId = contentId, Data = contentData }; var commandContext = await publish(command); var result = commandContext.Result <ContentDataChangedResult>(); return(result); }), Description = $"Patch a {schemaName} content." }); }
public ContentDomainObject Patch(PatchContent command) { Guard.Valid(command, nameof(command), () => "Cannot patch content"); VerifyCreatedAndNotDeleted(); var newData = Data.MergeInto(command.Data); if (!newData.Equals(Data)) { RaiseEvent(SimpleMapper.Map(command, new ContentUpdated { Data = newData })); } return(this); }
public async Task Patch_should_not_create_event_for_same_data() { var command = new PatchContent { Data = data }; await ExecuteCreateAsync(); var result = await sut.ExecuteAsync(CreateContentCommand(command)); result.ShouldBeEquivalent(sut.Snapshot); Assert.Single(LastEvents); A.CallTo(() => scriptEngine.ExecuteAndTransform(A <ScriptContext> .Ignored, "<update-script>")) .MustNotHaveHappened(); }
public ContentDomainObject Patch(PatchContent command) { VerifyCreatedAndNotDeleted(); var newData = command.Data.MergeInto(Snapshot.Data); if (!newData.Equals(Snapshot.Data)) { var @event = SimpleMapper.Map(command, new ContentUpdated()); @event.Data = newData; RaiseEvent(@event); } return(this); }
public async Task Patch_should_not_create_event_for_same_data() { var command = new PatchContent { Data = data }; await ExecuteCreateAsync(); var result = await PublishAsync(command); result.ShouldBeEquivalent(sut.Snapshot); Assert.Single(LastEvents); A.CallTo(() => scriptEngine.TransformAsync(A <ScriptVars> ._, "<update-script>", ScriptOptions())) .MustNotHaveHappened(); }
public async Task Patch_should_create_events_and_update_state() { var command = new PatchContent { Data = patch }; await ExecuteCreateAsync(); var result = await sut.ExecuteAsync(CreateContentCommand(command)); result.ShouldBeEquivalent(new ContentDataChangedResult(otherData, 1)); LastEvents .ShouldHaveSameEvents( CreateContentEvent(new ContentUpdated { Data = patched }) ); A.CallTo(() => scriptEngine.ExecuteAndTransform(A <ScriptContext> .Ignored, "<update-script>")) .MustHaveHappened(); }
public async Task Patch_should_create_events_and_update_state() { var command = new PatchContent { Data = patch }; await ExecuteCreateAsync(); var result = await sut.ExecuteAsync(CreateContentCommand(command)); result.ShouldBeEquivalent(sut.Snapshot); LastEvents .ShouldHaveSameEvents( CreateContentEvent(new ContentUpdated { Data = patched }) ); A.CallTo(() => scriptEngine.ExecuteAndTransform(ScriptContext(patched, data, Status.Draft, default), "<update-script>")) .MustHaveHappened(); }
public async Task Patch_should_not_create_event_for_same_data() { var command = new PatchContent { Data = data }; await ExecuteCreateAsync(); var result = await sut.ExecuteAsync(CreateContentCommand(command)); result.ShouldBeEquivalent(new ContentDataChangedResult(data, 0)); LastEvents .ShouldHaveSameEvents( CreateContentEvent(new ContentCreated { Data = data }) ); A.CallTo(() => scriptEngine.ExecuteAndTransform(A <ScriptContext> .Ignored, "<update-script>")) .MustNotHaveHappened(); }
public TerrainModelContent Build(ContentProcessorContext context) { // TODO: i think numlevels is log2, or something like that // calculate number of levels, based on patch size int nCurrent = (_patchSize - 1) * 2; int numLevels = 0; while (nCurrent != 1) { nCurrent /= 2; numLevels++; } int numPatchesX = (_heightMap.Width - 1) / (_patchSize - 1); int numPatchesY = (_heightMap.Height - 1) / (_patchSize - 1); // create patches PatchContent[,] patches = new PatchContent[numPatchesX, numPatchesY]; for (int y = 0; y < numPatchesY; y++) { for (int x = 0; x < numPatchesX; x++) { PatchContentBuilder patchContentBuilder = new PatchContentBuilder(_patchSize, x, y, _heightMap, numLevels, _detailTextureTiling, _horizontalScale); patches[x, y] = patchContentBuilder.Build(); } } return(new TerrainModelContent { NumPatchesX = numPatchesX, NumPatchesY = numPatchesY, Patches = patches, HeightMap = _heightMap, Tau = _tau, Material = _material }); }
private async Task <ContentCommand> CreateCommandAsync(BulkTask task) { var job = task.CommandJob; switch (job.Type) { case BulkUpdateContentType.Create: { var command = new CreateContent(); await EnrichAndCheckPermissionAsync(task, command, Permissions.AppContentsCreate); return(command); } case BulkUpdateContentType.Update: { var command = new UpdateContent(); await EnrichAndCheckPermissionAsync(task, command, Permissions.AppContentsUpdateOwn); return(command); } case BulkUpdateContentType.Upsert: { var command = new UpsertContent(); await EnrichAndCheckPermissionAsync(task, command, Permissions.AppContentsUpsert); return(command); } case BulkUpdateContentType.Patch: { var command = new PatchContent(); await EnrichAndCheckPermissionAsync(task, command, Permissions.AppContentsUpdateOwn); return(command); } case BulkUpdateContentType.Validate: { var command = new ValidateContent(); await EnrichAndCheckPermissionAsync(task, command, Permissions.AppContentsReadOwn); return(command); } case BulkUpdateContentType.ChangeStatus: { var command = new ChangeContentStatus { Status = job.Status ?? Status.Draft }; await EnrichAndCheckPermissionAsync(task, command, Permissions.AppContentsChangeStatusOwn); return(command); } case BulkUpdateContentType.Delete: { var command = new DeleteContent(); await EnrichAndCheckPermissionAsync(task, command, Permissions.AppContentsDeleteOwn); return(command); } default: throw new NotSupportedException(); } }
protected async Task On(PatchContent command, CommandContext context) { await ValidateAsync(command, () => "Failed to patch content"); await handler.UpdateAsync <ContentDomainObject>(context, c => c.Patch(command)); }