public async Task <IActionResult> CreateItemCategory([FromRoute(Name = "name")] string name)
{
var command = new CreateItemCategoryCommand(name);
await commandDispatcher.DispatchAsync(command, default);
return(Ok());
}
public async Task <ShoppingCart.Model.ShoppingCart> Get()
{
return(await _dispatcher.DispatchAsync(new GetCartQuery
{
UserId = this.GetUserId()
}));
}
public async Task <ActionResult> AddItem([FromQuery] string name)
{
var newItemId = Guid.NewGuid();
await _commandDispatcher.DispatchAsync(new CreateInventoryItemCommand(newItemId, name));
return(StatusCode(201, newItemId.ToString()));
}
public override async Task <PersistResponse> Persist(PersistRequest request, ServerCallContext context)
{
try
{
await _commandDispatcher.DispatchAsync(new PersistNavigationCommand
{
Id = request.Id,
Navigation = request.Navigation,
});
return(new PersistResponse
{
StatusCode = PersistResponse.Types.StatusCode.Ok,
});
}
catch (ArgumentException e)
{
_logger.LogError($"Failed persisting entity {request.Id}", e);
return(new PersistResponse
{
StatusCode = PersistResponse.Types.StatusCode.Invalid,
Errors = { e.Message },
});
}
catch (Exception e)
{
_logger.LogError($"Failed persisting entity {request.Id}", e);
}
return(new PersistResponse
{
StatusCode = PersistResponse.Types.StatusCode.Unavailable,
});
}
public async Task <Guid> AddTelegramAccount(string externalAccountId)
{
return(await _commandDispatcher.DispatchAsync <AddAccount.Request, AddAccount.Command>(new AddAccount.Request()
{
ExternalAccountId = externalAccountId
}));
}
public async Task <IHttpActionResult> Post([FromBody] CreatePlaylist command)
{
await _commandDispatcher.DispatchAsync(command);
var playlist = await _playlistService.GetLatesAddedAsync();
return(Created($"api/playlists/{command.Id}", playlist));
}
public async Task InvokeAsync()
{
var instanceWorkerId = _workerRecordStoreService.GenerateUniqueId();
await _workerRecordStoreService.RecordPing("ingester", instanceWorkerId);
var rawDataQueueMessages = await _queueClient.Dequeue(_config.RawDataQueueName, _config.MaxQueueItemsBatchSizeToProcessPerWorker);
if (rawDataQueueMessages.Count == 0)
{
await _workerRecordStoreService.RecordHasTerminated("ingester", instanceWorkerId);
return;
}
foreach (var rawDataQueueMessage in rawDataQueueMessages)
{
var rawDataObjectKey = rawDataQueueMessage.Message;
Stream rawDataObjectStream = await _commandDispatcher.DispatchAsync(new RetrieveObjectCommand { Key = rawDataQueueMessage.Message });
var objectName = _keyRegex.Match(rawDataObjectKey).Groups["objectName"].Value;
using (var objectReader = new StreamReader(rawDataObjectStream))
{
while (!objectReader.EndOfStream)
{
using (var memoryStream = new MemoryStream())
{
var ingestedObjectKey = $"{_config.IngestedFolder}/{objectName}-{Guid.NewGuid()}";
using (var sw = new StreamWriter(memoryStream))
{
for (int i = 0; i < _config.IngesterMaxLinesPerFile && !objectReader.EndOfStream; i++)
{
var line = await objectReader.ReadLineAsync();
await sw.WriteLineAsync(line);
}
await sw.FlushAsync();
await _commandDispatcher.DispatchAsync(new StoreObjectCommand
{
Key = ingestedObjectKey,
DataStream = memoryStream
});
}
await _queueClient.Enqueue(_config.IngestedQueueName, ingestedObjectKey);
}
}
}
await _queueClient.MessageProcessed(_config.RawDataQueueName, rawDataQueueMessage.MessageId);
}
await _workerRecordStoreService.RecordHasTerminated("ingester", instanceWorkerId);
}
public async Task <IActionResult> Worker(Guid id)
{
await _commandDispatcher.DispatchAsync(new DeleteWorker()
{
WorkerID = id
});
return(Ok());
}
public async Task <IActionResult> CreateStore([FromBody] CreateStoreContract createStoreContract)
{
var model = storeCreationInfoConverter.ToDomain(createStoreContract);
var command = new CreateStoreCommand(model);
await commandDispatcher.DispatchAsync(command, default);
return(Ok());
}
public async Task <IActionResult> Worker([FromBody] WorkerDTO workerDTO)
{
await _commandDispatcher.DispatchAsync(new AddWorker()
{
Worker = workerDTO
});
return(Ok());
}
public void DispatchAsync_InvoiceModelIsInvalid_CommandDispatcherDispatchMustNotHaveHappened()
{
A.CallTo(() => _validationProcessor.Validate(_command)).Returns(new ValidationStatus(new List <ValidationError> {
new ValidationError("error")
}));
Assert.Throws <ValidationException>(() => _validatedCommandDispatcher.DispatchAsync(_command));
A.CallTo(() => _commandDispatcher.DispatchAsync(A <ICommand> ._)).MustNotHaveHappened();
}
public async Task <IActionResult> Post()
{
var cmd = new CreateUserCommand(Guid.NewGuid(), "Nelson", "Junior", new DateTime(1989, 6, 9));
await _dispatcher.DispatchAsync(cmd);
await _unitOfWork.CommitAsync();
return(Ok(cmd));
}
public async Task <IActionResult> Post()
{
var cmd = new CreateFooCommand(Guid.NewGuid());
await _dispatcher.DispatchAsync(cmd);
await _unitOfWork.CommitAsync();
return(Ok(cmd));
}
public async Task <IActionResult> Post()
{
var cmd = new CreateFooCommand(Guid.NewGuid());
var response = await _dispatcher.DispatchAsync <CreateFooCommand, CreateFooResponse>(cmd);
await _session.CommitAsync();
return(Ok(cmd));
}
public async Task <HttpResponseMessage> UpdateQuestion([FromBody] QuestionDto question)
{
var command = new UpdateQuestion(question);
var result = await _commandDispatcher.DispatchAsync(command) as IdentityResult;
return(new HttpResponseMessage(HttpStatusCode.OK)
{
Content = new StringContent(result.Identity)
});
}
private async Task <IActionResult> RefreshToken(TokenRequestViewModel viewModel)
{
try
{
var refreshTokenResult = await _queryDispatcher.DispatchAsync <GetTokenQuery, GetTokenQueryResult>(new GetTokenQuery
{
ClientId = viewModel.ClientId,
RefreshToken = viewModel.RefreshToken
});
if (refreshTokenResult.Token == null)
{
return(new UnauthorizedResult());
}
var userResult = await _queryDispatcher.DispatchAsync <GetUserByIdQuery, GetUserQueryResult>(new GetUserByIdQuery
{
UserId = refreshTokenResult.Token.UserId
});
if (userResult.User == null)
{
return(new UnauthorizedResult());
}
var newRefreshToken = _tokenService.GenerateRefreshToken(refreshTokenResult.Token.ClientId,
refreshTokenResult.Token.UserId);
await _commandDispatcher.DispatchAsync <RemoveTokenCommand>(new RemoveTokenCommand
{
Id = refreshTokenResult.Token.Id
});
await _commandDispatcher.DispatchAsync <AddTokenCommand>(new AddTokenCommand
{
Token = refreshTokenResult.Token
});
var tokenData = _tokenService.CreateAccessToken(newRefreshToken.UserId);
var response = new TokenResponseViewModel
{
Expiration = tokenData.ExporationTimeInMinutes,
RefreshToken = newRefreshToken.Value,
Token = tokenData.EncodedToken
};
return(Json(response));
}
catch (Exception)
{
return(new UnauthorizedResult());
}
}
public async Task ProcessMessageAsync(GatewayPayload payload)
{
var message = JsonConvert.DeserializeObject <GatewayMessage>(payload.EventData.ToString());
if (_commandValidator.IsCommand(message))
{
var command = new Command(message);
await _commandDispatcher.DispatchAsync(command);
}
}
public async Task <IActionResult> Login([FromBody] UserLoginDTO userParam)
{
var command = new Login()
{
LoginCredentials = userParam
};
await _commandDispatcher.DispatchAsync(command);
return(new JsonResult(command.Token));
}
protected async Task <IActionResult> DispatchCommandAsync <T>(T command) where T : ICommand
{
var result = await _commandDispatcher.DispatchAsync(command, User);
if (!result.IsSuccess)
{
return(BadRequest(result));
}
return(Accepted(result));
}
public async Task <Guid> CriarAsync(CriarProdutoDto dto)
{
var produtoId = Guid.NewGuid();
var command = new CriarProdutoCommand(produtoId, dto.Codigo, dto.Nome, dto.Preco, dto.Quantidade);
await _dispatcher.DispatchAsync(command);
await _unitOfWork.CommitAsync();
return(produtoId);
}
private bool ProcessCommand(string command)
{
try
{
AppHealth.Current.Verbose.TrackAsync(string.Format(StringRes.ReceivedCommand, command)).FireAndForget();
var args = Regex.Split(command, splitPattern)
.Select(s => s.Trim('"'));
var parserResult = _parser.ParseArguments <
SyncCommand,
GetProjectTypesCommand,
GetFrameworksCommand,
GetLayoutsCommand,
GetPagesCommand,
GetFeaturesCommand,
GetServicesCommand,
GetTestingsCommand,
GetAllLicencesCommand,
GenerateCommand,
CloseCommand>(args);
var exitCode = parserResult.MapResult(
(SyncCommand opts) => _dispatcher.DispatchAsync(opts),
(GetProjectTypesCommand opts) => _dispatcher.DispatchAsync(opts),
(GetFrameworksCommand opts) => _dispatcher.DispatchAsync(opts),
(GetLayoutsCommand opts) => _dispatcher.DispatchAsync(opts),
(GetPagesCommand opts) => _dispatcher.DispatchAsync(opts),
(GetFeaturesCommand opts) => _dispatcher.DispatchAsync(opts),
(GetServicesCommand opts) => _dispatcher.DispatchAsync(opts),
(GetTestingsCommand opts) => _dispatcher.DispatchAsync(opts),
(GetAllLicencesCommand opts) => _dispatcher.DispatchAsync(opts),
(GenerateCommand opts) => _dispatcher.DispatchAsync(opts),
(CloseCommand opts) => Task.FromResult(1),
errors =>
{
var helpText = HelpText.AutoBuild(parserResult);
var errorText = string.Format(StringRes.ErrorParsingCommand, command, helpText);
_messageService.SendError(errorText);
AppHealth.Current.Error.TrackAsync(errorText).FireAndForget();
return(Task.FromResult(0));
});
// todo: use async task
return(exitCode.Result == 0);
}
catch (Exception ex)
{
var errorMessage = string.Format(StringRes.ErrorExecutingCommand, command, ex.Message);
AppHealth.Current.Exception.TrackAsync(ex, errorMessage).FireAndForget();
_messageService.SendError(errorMessage);
return(true);
}
}
public async Task <IActionResult> Create(string username, string password, string email)
{
await _commandDispatcher.DispatchAsync(new CreateUserCommand
{
CreateProfile = true,
Email = email,
Password = password,
UserName = username,
}, HttpContext.RequestAborted);
return(Ok());
}
public async Task <IActionResult> Create([FromBody] CreateBoardRequestDTO dto)
{
var command = new CreateBoardCommandHandler.Command
{
UserId = GetUser().ID,
Name = dto.Name,
ParticipantIds = dto.ParticipantIds
};
await _commandDispatcher.DispatchAsync(command);
return(Json(new ApiJsonResponse(command.BoardId, ApiMessage.Info($"'{dto.Name}' board has been created"))));
}
public async Task <IActionResult> AddByClient([FromBody] ClientOrderDTO clOrder)
{
var command = new AddClientOrder()
{
Order = clOrder,
User = User
};
await _commandDispatcher.DispatchAsync(command);
return(Ok());
}
public static async Task Run()
{
ICommandDispatcher dispatcher = Configure();
CommandWithoutResult command = new CommandWithoutResult
{
DoSomething = "Hello"
};
await dispatcher.DispatchAsync(command);
await dispatcher.DispatchAsync(command);
Console.WriteLine("\nPress a key to continue...");
}
public async Task <IActionResult> Add(AddCommentRequestDTO dto)
{
await _commandDispatcher.DispatchAsync(
new AddCommandHandler.Command
{
BoardId = dto.BoardId,
Content = dto.Content,
UserId = GetUser().ID,
ItemId = dto.ItemId
});
return(await GetComments(dto.ItemId));
}
public async Task <IActionResult> Post()
{
CommandResponse <Order> response = await _dispatcher.DispatchAsync(new CreateOrderCommand
{
UserId = this.GetUserId()
});
if (response.IsSuccess)
{
return(Ok(response.Result));
}
return(BadRequest(response.ErrorMessage));
}
private async Task <string> UpdateRefreshTokenAsync(string userName, HttpContext httpContext)
{
string?newRefreshToken = null;
await _commandDispatcher.DispatchAsync(new UpdateJwtRefreshTokenCommand
{
UserName = userName,
TokenExpirationTimeSpan = _jwtRefreshTokenExpirationTime,
Verify = false,
OnKeyGenerated = (_, key) => newRefreshToken = (string)key
}, httpContext.RequestAborted);
return(newRefreshToken ?? throw new InvalidOperationException());
}
public static async Task Run()
{
ICommandDispatcher dispatcher = Configure();
OutputToConsoleCommand command = new OutputToConsoleCommand
{
Message = "Hello"
};
CountResult result = await dispatcher.DispatchAsync(command);
Console.WriteLine($"{result.Count} actors called");
await dispatcher.DispatchAsync(command);
Console.WriteLine("\nPress a key to continue...");
}
public async Task ShouldNotRecheduleCommandThatReturnsFalse()
{
// Arrange
_registrationCatalogue.GetRegisteredCommands().Returns(new Type[] { typeof(SimpleSchedulableCommand) });
SimpleSchedulableCommand command = new SimpleSchedulableCommand();
_commandDispatcher.DispatchAsync(command).ReturnsForAnyArgs(new CommandResult <bool>(false, false));
// Act
await _testSubject.ExecuteAsync(new SimpleSchedulableCommand().CreateScheduledMessage());
// Assert
await _commandRescheduler.DidNotReceiveWithAnyArgs().Reschedule(null);
}