public async Task <IActionResult> Get()
{
var request = new GetDictionariesRequest();
await _commandProcessor.SendAsync(request);
return(Ok(request.Result));
}
public async Task <IActionResult> Delete(string id, CancellationToken ct)
{
var deleteExistingAccountCommand = new DeleteExistingAccountCommand(Guid.Parse(id));
await _commandProcessor.SendAsync(deleteExistingAccountCommand, false, ct);
return(Ok());
}
public async Task When_Handling_A_Command_With_A_Inbox_Enabled_Async()
{
await _commandProcessor.SendAsync(_command);
// should_store_the_command_to_the_inbox
_inbox.GetAsync <MyCommand>(_command.Id, _contextKey).Result.Value.Should().Be(_command.Value);
}
public async Task When_Handling_A_Command_Once_Only_With_Throw_Enabled()
{
await _commandProcessor.SendAsync(_command);
Exception ex = await Assert.ThrowsAsync <OnceOnlyException>(() => _commandProcessor.SendAsync(_command));
Assert.Equal($"A command with id {_command.Id} has already been handled", ex.Message);
}
public async Task When_Handling_A_Command_Once_Only_With_Warn_Enabled()
{
await _commandProcessor.SendAsync(_command);
await _commandProcessor.SendAsync(_command);
MyStoredCommandToWarnHandlerAsync.ReceivedCount.Should().Be(1);
}
public async Task <IActionResult> GetRelationshipByWord(int id, int wordId)
{
var request = new GetRelationshipsByWordRequest
{
DictionaryId = id,
WordId = wordId
};
await _commandProcessor.SendAsync(request);
return(Ok(request.Result));
}
public async Task <IActionResult> Post([FromBody] AddGreetingRequest request)
{
var newGreetingId = Guid.NewGuid();
var addGreetingCommand = new AddGreetingCommand(newGreetingId, request.Message);
await _commandProcessor.SendAsync(addGreetingCommand);
var addedGreeting = await _queryProcessor.ExecuteAsync(new GreetingsByIdQuery(newGreetingId));
return(Ok(addedGreeting));
}
public async Task <IActionResult> CreateAsync(CreateExamCommand command)
{
if (!User.IsInRole(Roles.Admin))
{
command.Shared = false;
}
await _commandProcessor.SendAsync(command);
return(Ok());
}
public async Task <IActionResult> Post([FromBody] AddToDoRequest request)
{
var addToDoCommand = new AddToDoCommand(request.Title, request.Completed, request.Order);
await _commandProcessor.SendAsync(addToDoCommand);
var addedToDo = await _queryProcessor.ExecuteAsync(new ToDoByIdQuery(addToDoCommand.ToDoItemId));
addedToDo.Url = Url.RouteUrl("GetTodo", new { id = addedToDo.Id }, protocol: Request.Scheme);
return(CreatedAtRoute("GetTodo", new { id = addedToDo.Id }, addedToDo));
}
public async Task <IActionResult> Post([FromBody] AddShippingLineRequest request)
{
var addShippingLineCommand = new AddShippingLineCommand(
lineName: new LineName(request.LineName)
);
await _commandProcessor.SendAsync(addShippingLineCommand);
var addedShip = await _queryProcessor.ExecuteAsync(new ShippingLineByIdQuery(new Id(addShippingLineCommand.Id)));
return(Ok(addedShip));
}
public async Task <IActionResult> GetWords(int id, int pageNumber = 1, int pageSize = 10)
{
var request = new GetWordsByDictionaryRequest
{
DictionaryId = id,
PageNumber = pageNumber,
PageSize = pageSize
};
await _commandProcessor.SendAsync(request);
return(Ok(request.Result));
}
public async Task <IActionResult> Post([FromBody] TodoView view, CancellationToken cancellationToken = default(CancellationToken))
{
var id = Math.Abs(Guid.NewGuid().GetHashCode());
await _commandProcessor.SendAsync(new CreateTodo(id, view.Title, view.Completed, view.Order), false, cancellationToken).ConfigureAwait(false);
// todo: yeah, this is a hack
view.Id = id;
view.Url = GetTodoUri(id);
HttpContext.Response.Headers.Add("Location", view.Url);
return(Created(view.Url, view));
}
public async Task <IActionResult> CreatePeriodical(int libraryId, [FromBody] PeriodicalView periodical, CancellationToken token = default(CancellationToken))
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState));
}
var request = new AddPeriodicalRequest(libraryId, periodical.Map());
await _commandProcessor.SendAsync(request, cancellationToken : token);
var renderResult = _periodicalRenderer.Render(request.Result, libraryId);
return(new CreatedResult(renderResult.Links.Self(), renderResult));
}
public async Task <IActionResult> CreateLibrary([FromBody] LibraryView library, CancellationToken token)
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState));
}
var request = new AddLibraryRequest(library.Map());
await _commandProcessor.SendAsync(request, cancellationToken : token);
var renderResult = _libraryRenderer.Render(request.Result);
return(new CreatedResult(renderResult.Links.Self(), renderResult));
}
public async Task <IActionResult> GetAsync()
{
var list = await _queryProcessor.ExecuteAsync(new GetUserScoreFormulasQuery());
if (list.Any())
{
return(Ok(list));
}
await _commandProcessor.SendAsync(new CloneScoreFormulaCommand());
list = await _queryProcessor.ExecuteAsync(new GetUserScoreFormulasQuery());
return(Ok(list));
}
public async Task <IActionResult> Post([FromBody] AddShipRequest request)
{
var addShipCommand = new AddShipCommand(
type: (ShipType)Enum.Parse <ShipType>(request.Type),
name: new ShipName(request.Name),
capacity: new Capacity(request.Capacity),
shippingLine: new Id(request.ShippingLine)
);
await _commandProcessor.SendAsync(addShipCommand);
var addedShip = await _queryProcessor.ExecuteAsync(new ShipByIdQuery(new Id(addShipCommand.Id)));
return(Ok(addedShip));
}
public void When_Monitoring_Is_on_For_A_Handler_Async()
{
AsyncContext.Run(async() => await _commandProcessor.SendAsync(_command));
_beforeEvent = _controlBusSender.Observe <MonitorEvent>();
_afterEvent = _controlBusSender.Observe <MonitorEvent>();
//_should_have_an_instance_name_before
Assert.AreEqual("UnitTests", _beforeEvent.InstanceName);
//_should_post_the_event_type_to_the_control_bus_before
Assert.AreEqual(MonitorEventType.EnterHandler, _beforeEvent.EventType);
//_should_post_the_handler_fullname_to_the_control_bus_before
Assert.AreEqual(typeof(MyMonitoredHandlerAsync).AssemblyQualifiedName, _beforeEvent.HandlerFullAssemblyName);
//_should_post_the_handler_name_to_the_control_bus_before
Assert.AreEqual(typeof(MyMonitoredHandlerAsync).FullName, _beforeEvent.HandlerName);
//_should_include_the_underlying_request_details_before
Assert.AreEqual(_originalRequestAsJson, _beforeEvent.RequestBody);
//should_post_the_time_of_the_request_before
Assert.AreEqual(_at, _beforeEvent.EventTime);
//_should_have_an_instance_name_after
Assert.AreEqual("UnitTests", _afterEvent.InstanceName);
//_should_post_the_event_type_to_the_control_bus_after
Assert.AreEqual(MonitorEventType.ExitHandler, _afterEvent.EventType);
//_should_post_the_handler_fullname_to_the_control_bus_after
Assert.AreEqual(typeof(MyMonitoredHandlerAsync).AssemblyQualifiedName, _afterEvent.HandlerFullAssemblyName);
//_should_post_the_handler_name_to_the_control_bus_after
Assert.AreEqual(typeof(MyMonitoredHandlerAsync).FullName, _afterEvent.HandlerName);
//_should_include_the_underlying_request_details_after
Assert.AreEqual(_originalRequestAsJson, _afterEvent.RequestBody);
//should_post_the_time_of_the_request_after
Assert.Greater(_afterEvent.EventTime, _at);
//should_post_the_elapsedtime_of_the_request_after
Assert.AreEqual((_afterEvent.EventTime - _beforeEvent.EventTime).Milliseconds, _afterEvent.TimeElapsedMs);
}
public async Task Post()
{
await _processor.SendAsync(new BlogCommand()
{
Name = "bob"
});
}
public void When_Handling_A_Command_With_A_Command_Store_Enabled_Async()
{
AsyncContext.Run(async() => await _commandProcessor.SendAsync(_command));
// should_store_the_command_to_the_command_store
Assert.AreEqual(_command.Value, _commandStore.GetAsync <MyCommand>(_command.Id).Result.Value);
}
public async Task <IActionResult> Index()
{
var request = new GetEntryRequest();
await _commandProcessor.SendAsync(request);
return(Ok(request.Result));
}
public async Task When_Monitoring_Is_on_For_A_Handler_Async()
{
await _commandProcessor.SendAsync(_command);
_beforeEvent = _controlBusSender.Observe <MonitorEvent>();
_afterEvent = _controlBusSender.Observe <MonitorEvent>();
//_should_have_an_instance_name_before
_beforeEvent.InstanceName.Should().Be("UnitTests");
//_should_post_the_event_type_to_the_control_bus_before
_beforeEvent.EventType.Should().Be(MonitorEventType.EnterHandler);
//_should_post_the_handler_fullname_to_the_control_bus_before
_beforeEvent.HandlerFullAssemblyName.Should().Be(typeof(MyMonitoredHandlerAsync).AssemblyQualifiedName);
//_should_post_the_handler_name_to_the_control_bus_before
_beforeEvent.HandlerName.Should().Be(typeof(MyMonitoredHandlerAsync).FullName);
//_should_include_the_underlying_request_details_before
_beforeEvent.RequestBody.Should().Be(_originalRequestAsJson);
//should_post_the_time_of_the_request_before
_beforeEvent.EventTime.AsUtc().Should().BeCloseTo(_at.AsUtc(), 1000);
//_should_have_an_instance_name_after
_afterEvent.InstanceName.Should().Be("UnitTests");
//_should_post_the_event_type_to_the_control_bus_after
_afterEvent.EventType.Should().Be(MonitorEventType.ExitHandler);
//_should_post_the_handler_fullname_to_the_control_bus_after
_afterEvent.HandlerFullAssemblyName.Should().Be(typeof(MyMonitoredHandlerAsync).AssemblyQualifiedName);
//_should_post_the_handler_name_to_the_control_bus_after
_afterEvent.HandlerName.Should().Be(typeof(MyMonitoredHandlerAsync).FullName);
//_should_include_the_underlying_request_details_after
_afterEvent.RequestBody.Should().Be(_originalRequestAsJson);
//should_post_the_time_of_the_request_after
_afterEvent.EventTime.AsUtc().Should().BeAfter(_at.AsUtc());
}
public async Task <ActionResult <AuthDataViewModel> > PostAsync([FromBody] RegisterViewModel model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var emailUnique = await _queryProcessor.ExecuteAsync(new IsEmailUniqueQuery(model.Email));
if (!emailUnique)
{
return(BadRequest(new { email = "User with this email already exists" }));
}
var usernameUnique = await _queryProcessor.ExecuteAsync(new IsEmailUniqueQuery(model.Username));
if (!usernameUnique)
{
return(BadRequest(new { username = "******" }));
}
var command = new CreateUserCommand(model.Username, model.Email, model.Password);
await _commandProcessor.SendAsync <CreateUserCommand>(command);
return(new AuthDataViewModel(_jwtSecretKey, _jwtLifespan, command.UserId));
}
public async Task <IActionResult> DeleteFile(int fileId, CancellationToken token = default(CancellationToken))
{
var request = new DeleteFileRequest(fileId);
await _commandProcessor.SendAsync(request, cancellationToken : token);
return(new NoContentResult());
}
public async Task <IActionResult> AddCorrection(string language, string profile, [FromBody] CorrectionView correction, CancellationToken cancellationToken = default(CancellationToken))
{
if (!ModelState.IsValid)
{
return(new BadRequestObjectResult(ModelState));
}
correction.Language = language;
correction.Profile = profile;
var request = new AddCorrectionRequest(correction.Map());
await _commandProcessor.SendAsync(request, cancellationToken : cancellationToken);
var renderResult = _correctionRenderer.Render(request.Result);
return(new CreatedResult(renderResult.Links.Self(), renderResult));
}
public async Task When_A_Request_Logger_Is_In_The_Pipeline_Async()
{
await _commandProcessor.SendAsync(_myCommand);
//_should_log_the_request_handler_call
_logger.Logs.Should().Contain(log => log.Message.Contains("Logging handler pipeline call"));
//_should_log_the_type_of_handler_in_the_call
_logger.Logs.Should().Contain(log => log.Message.Contains(typeof(MyCommand).ToString()));
}
public void When_A_Request_Logger_Is_In_The_Pipeline_Async()
{
AsyncContext.Run(async() => await _commandProcessor.SendAsync(_myCommand));
//_should_log_the_request_handler_call
Assert.True(((Func <IList <SpyLog.LogRecord>, bool>)(logs => logs.Any(log => log.Message.Contains("Logging handler pipeline call")))).Invoke(_logger.Logs));
//_should_log_the_type_of_handler_in_the_call
Assert.True(((Func <IList <SpyLog.LogRecord>, bool>)(logs => logs.Any(log => log.Message.Contains(typeof(MyCommand).ToString())))).Invoke(_logger.Logs));
}
public async Task <IHttpActionResult> Post(CreateWorksheetRequest request)
{
var userIdOnPrincipal = 210;
var worksheetId = new Guid();
var command = new CreateWorksheetCommand(worksheetId, request.WorksheetName, userIdOnPrincipal);
await _commandProcessor.SendAsync(command);
return(CreatedAtRoute("GetWorksheetBrighter", new { worksheetId = worksheetId }, worksheetId));
}
public async Task SendAsync <T>(T command, bool continueOnCapturedContext = false, CancellationToken cancellationToken = default)
where T : class, IRequest
{
if (!(command is CommandBase commandBase))
{
await _commandProcessor.SendAsync(command, continueOnCapturedContext, cancellationToken);
return;
}
if (!(commandBase is ISkipLogging))
{
await _commandQueryLogger.LogCommandAsync(command);
}
commandBase.UserId = await _userIdProvider.GetAsync();
await _commandProcessor.SendAsync(command, continueOnCapturedContext, cancellationToken);
}
public void Execute(int dictionaryId)
{
_logger.LogDebug("Started downloading dictionary {0}", dictionaryId);
var downloadDictionaryCommand = new DownloadDictionaryCommand
{
DictionaryId = dictionaryId
};
_commandProcessor.SendAsync(downloadDictionaryCommand).Wait();
_logger.LogDebug("Dictionary {0} downloaded to {1}", dictionaryId, downloadDictionaryCommand.FilePath);
_commandProcessor.SendAsync(new AddLocalDictionaryCommand
{
Dictionary = downloadDictionaryCommand.Result,
FilePath = downloadDictionaryCommand.FilePath
}).Wait();
_logger.LogDebug("Finished downloading dictionary {0}", dictionaryId);
}
public async Task <IActionResult> Create()
{
var command = new CreateGameCommand(UserId);
await _commandProcessor.SendAsync(command);
return(CreatedAtAction(
"GetGame",
new { command.Id },
new { command.Id, command.CreatedOn }));
}