public void user_project_command_failed()
{
//given
var fixture = new Fixture().Customize(new AutoNSubstituteCustomization {
ConfigureMembers = true
});
fixture.Customizations.Add(new RandomNumericSequenceGenerator(long.MinValue, -1));
fixture.Register <Money>(() => Money.From(fixture.Create <Decimal>()));
fixture.Register <EntityId>(() => EntityId.Empty());
fixture.Register <ProjectName>(() => ProjectName.Empty());
fixture.Register <ProjectCode>(() => ProjectCode.Empty());
fixture.Register <DateAndTime>(() => DateAndTime.Empty());
fixture.Register <Money>(() => fixture.Create <Money>());
var command = new AddProjectCommand();
var mediator = fixture.Create <IMediator>();
var logger = fixture.Create <ILogger <AddProjectCommandHandler> >();
var projectDb = fixture.Create <IDbSession <IProjectRepository> >();
var userDb = fixture.Create <IDbSession <IUserRepository> >();
// when
var handler = new AddProjectCommandHandler(logger, mediator, projectDb, userDb);
var result = handler.Execute(command);
// then
Assert.True(!result.IsSucceed && result.Violations.Count == 4);
}
public async Task <AddProjectPayload> AddProject(
AddProjectInput input,
[Service] IServiceProvider serviceProvider,
CancellationToken cancellationToken)
{
var addProjectCommand = new AddProjectCommand()
{
Description = input.Description,
LongDescription = input.LongDescription
};
using (var scope = serviceProvider.CreateScope())
{
var mediator = scope.ServiceProvider.GetRequiredService <IMediator>();
try
{
var response = await mediator.Send(addProjectCommand, cancellationToken);
return(new AddProjectPayload(response));
}
catch (ValidationException e)
{
var userErrors = new List <UserError>();
e.Message.Split(";").ForAll(item =>
{
userErrors.Add(new UserError(item, item));
});
return(new AddProjectPayload(userErrors));
}
}
}
public void AddAProjectToRepository()
{
var projectRepository = new ProjectRepository();
var project = new Project("secrets");
var addProjectCommand = new AddProjectCommand(projectRepository, "secrets");
addProjectCommand.Execute();
Assert.That(projectRepository.AllProjects()[0], Is.EqualTo(project));
}
public async Task <IActionResult> AddProject([FromBody] AddProjectCommand command)
{
if (command is null)
{
return(BadRequest());
}
var projectId = await _mediator.Send(command);
return(CreatedAtAction("AddProject", new { id = projectId }));
}
public void ProjectCommandHandler_Handle_AddProjectCommand_AddNewProject(string description, string longDescription)
{
IRequestHandler <AddProjectCommand, bool> handler = GetCommandHandlerInstance();
var commmand = new AddProjectCommand()
{
Description = description, LongDescription = longDescription
};
Action handle = () => handler.Handle(commmand, default).Wait();
handle.Should().Throw <ValidationException>();
}
public void ProjectCommandHandler_Handle_AddProjectCommand_AddValidProjects(string description, string longDescription)
{
IRequestHandler <AddProjectCommand, bool> handler = GetCommandHandlerInstance();
var commmand = new AddProjectCommand()
{
Description = description, LongDescription = longDescription
};
var handle = handler.Handle(commmand, default).Result;
handle.Should().BeTrue();
}
public ProjectController(
GetProjectOverviewQuery getProjectOverviewQuery,
AddProjectCommand addProjectCommand,
ChangeProjectOrderCommand changeProjectOrderCommand,
GetProjectByIdQuery getProjectByIdQuery,
EditProjectCommandHandler editProjectHandler)
{
_getProjectOverviewQuery = getProjectOverviewQuery;
_addProjectCommand = addProjectCommand;
_changeProjectOrderCommand = changeProjectOrderCommand;
_getProjectByIdQuery = getProjectByIdQuery;
_editProjectHandler = editProjectHandler;
}
public async Task <IActionResult> AddProject([FromBody] AddProjectCommand command)
{
try
{
if (ModelState.IsValid)
{
var response = await _mediator.Send(command);
return(StatusCode(response.ResponseStatusCode, response.Value));
}
return(StatusCode(StatusCodes.Status400BadRequest));
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex));
}
}
public async Task <AddProjectPayload> AddProject(
AddProjectInput input,
[Service] IServiceProvider serviceProvider,
CancellationToken cancellationToken)
{
var addProjectCommand = new AddProjectCommand
{
Name = input.Name,
Description = input.Description,
CategoryId = input.CategoryId,
TypeId = input.TypeId,
ResponsibleDepartmentId = input.ResponsibleDepartmentId,
InitiatorId = input.InitiatorId,
CuratorId = input.CuratorId,
ManagerId = input.ManagerId,
DepartmentIds = input.DepartmentIds,
ContragentIds = input.ContragentIds,
ProductIds = input.ProductIds
};
using (var scope = serviceProvider.CreateScope())
{
var mediator = scope.ServiceProvider.GetRequiredService <IMediator>();
try
{
var response = await mediator.Send(addProjectCommand, cancellationToken);
return(new AddProjectPayload(response));
}
catch (ValidationException e)
{
var userErrors = new List <UserError>();
e.Message.Split(";").ForAll(item =>
{
userErrors.Add(new UserError(item, item));
});
return(new AddProjectPayload(userErrors));
}
}
}
protected override CommandResult <Guid> ExecuteCommand(AddProjectCommand command)
{
var isSucceed = false;
var aggregationId = Guid.Empty;
_logger.LogDebug("Criada agregação a partir do comando {CommandName} com valores {Valores}",
nameof(command), command);
var client = _dbUserSession.Repository.Get(EntityId.From(command.ClientId));
var agg = ProjectAggregationRoot.CreateFrom(
ProjectName.From(command.Name),
ProjectCode.From(command.Code),
Money.From(command.Budget),
DateAndTime.From(command.StartDate),
client.Id);
if (agg.ValidationResults.IsValid)
{
// _logger.LogInformation($"Agregação Project valida id gerado", agg.GetChange().Id);
using (_logger.BeginScope("Persistencia"))
{
_dbSession.Repository.Add(agg.GetChange());
_dbSession.SaveChanges();
}
// _logger.LogInformation($"Project persistido ID: {agg.GetChange().Id}");
using (_logger.BeginScope("Publicacão de Eventos"))
{
agg.GetEvents().ToImmutableList().ForEach(ev => Publisher.Publish(ev));
}
isSucceed = true;
aggregationId = agg.GetChange().Id.Value;
}
return(new CommandResult <Guid>(isSucceed, aggregationId, agg.ValidationResults.Errors.ToImmutableList()));
}
public async Task <BaseDto> AddHandle([FromBody] AddProjectCommand cmd)
{
var cmdResponse = await _mediator.Send(cmd);
return(cmdResponse);
}
public async Task <ActionResult> AddProjectDmr([FromBody] AddProjectCommand command)
{
var dto = await _mediator.SendAsync(command);
return(Created("", dto));
}
public IActionResult Save([FromBody] AddProjectCommand entity)
{
var result = _mediator.Send <ExecutionResult>(entity);
return(Ok(result));
}
public Task <Project> AddProjectAsync(AddProjectCommand command)
{
return(api.PostAsync <AddProjectCommand, Project>(GetProjectsPath(), command));
}
