public async Task <IActionResult> CreateCar([FromBody] CreateCarCommand car)
{
_logger.LogInformation($"Send Create Car Command. Car id: {car.Id}");
await _mediator.Send(car);
return(Ok(true));
}
public async Task <ICommandResult <CarModel> > Handle(CreateCarCommand request, CancellationToken cancellationToken)
{
var validator = _validatorFactory.Create <CreateCarCommand, CreateCarCommandValidator>();
await ValidateAsync(request, validator);
var domainObj = _mapper.Map <Car>(request.Payload);
var newDomainObj = Car.CreateNewCar(domainObj.Brand, domainObj.Model, domainObj.Year);
var success = await _commandCarCatalogRepository.CreateCarAsync(request.Name, newDomainObj);
if (success)
{
Log.Information("CreateCarCommand successfully created");
var createCarEvent = new CreateCarEvent(newDomainObj);
_ = Task.Run(() => _eventBusPublisher.PublishAsync(createCarEvent));
}
else
{
Log.Error("CreateCarCommand unsuccessful");
}
var newDtoObject = _mapper.Map <CarModel>(newDomainObj);
return(await Task.FromResult(new CommandResult <CarModel>(newDtoObject, success)));
}
public void BDDScenario_1_1_TestCarCreation(string make,
string model,
string engine,
int doors,
int wheels,
CarBodyType bodyType)
{
IVehicleFactory <Car, CreateCarCommand> factory = new CarFactory();
CreateCarCommand createCarCommand = new CreateCarCommand(make,
model,
engine,
doors,
wheels,
bodyType);
Car car = factory.Create(createCarCommand);
Assert.NotNull(car);
Assert.Equal(make, car.Make);
Assert.Equal(model, car.Model);
Assert.Equal(engine, car.Engine);
Assert.Equal(doors, car.Doors);
Assert.Equal(wheels, car.Wheels);
Assert.Equal(bodyType, car.BodyType);
}
public void ExecutarComandos()
{
var bus = new FakeBus();
// Registro com sucesso
var cmd = new CreateCarCommand("Fox Rock in Rio", 19000, EStatus.Ativo, Guid.NewGuid());
Init(cmd);
bus.SendCommand(cmd);
End(cmd);
//Registro com erro
cmd = new CreateCarCommand("Fox Rock in Rio", 19000, EStatus.Ativo, Guid.NewGuid());
Init(cmd);
bus.SendCommand(cmd);
End(cmd);
//Atualizar Car
var cmd2 = new UpdateCarCommand(Guid.NewGuid(), "Fox Rock in Rio", 19000, EStatus.Ativo);
Init(cmd2);
bus.SendCommand(cmd2);
End(cmd2);
//Deletar Car
var cmd3 = new DeleteCarCommand(Guid.NewGuid());
Init(cmd3);
bus.SendCommand(cmd3);
End(cmd3);
}
private async Task SeedCar()
{
var fakeName = "BMW";
var command = new CreateCarCommand(FakeCarId, fakeName);
await Mediatr.Send(command);
}
public void AddCar(CreateCarCommand createCarCommand)
{
if (createCarCommand is null)
{
throw new ArgumentNullException(nameof(createCarCommand), "Input was null!");
}
Cars.Add(new Car(createCarCommand.ClientId, createCarCommand.BrandName, createCarCommand.ModelName,
createCarCommand.PlateNumber, createCarCommand.RegistrationId));
}
public When_car_created()
{
When(async() =>
{
var command = new CreateCarCommand(_fakeId, _fakeName);
_result = await The <IMediator>().Send(command);
});
}
public async Task <ICommandResult <Car> > Handle(CreateCarCommand command, CancellationToken cancellationToken)
{
CarSm carSm = command.CarSm;
Car car = _carSmToCarMapper.Map(carSm);
car = await _carRepository.AddAsync(car, cancellationToken);
return(new CommandResult <Car>(CommandStatus.Ok, car));
}
public async Task <ActionResult <Unit> > CreateCarAsync(CreateCarCommand commandDto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var command = _mapper.Map <CreateCarCommand>(commandDto);
return(await _mediator.Send(command));
}
public Task <Response <Car> > Handle(CreateCarCommand request, CancellationToken cancellationToken)
{
if (false)
{
return(Task.FromResult(Response.Fail <Car>("Car Already Exists")));
}
return(Task.FromResult(Response.Ok(new Car {
name = "ford"
}, "Car Created")));
}
public CreateCarCommandTests()
{
_factory = new Mock <ICarFactory>();
_factory.Setup(c => c.Create(It.IsAny <string>(), It.IsAny <string>(), It.IsAny <double>()))
.Returns(new Car());
_uow = new Mock <IUnitOfWork>();
_uow.Setup(c => c.Cars.Add(It.IsAny <Car>()));
_uow.Setup(c => c.SaveChanges());
_subject = new CreateCarCommand(_factory.Object, _uow.Object);
}
public IActionResult AddCar([FromBody] CreateCarCommand carCreateCommand)
{
try
{
var client = _clientAggregateFactory.Create(carCreateCommand.ClientId);
client.AddCar(carCreateCommand);
_clientsWriteRepository.Save(client);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> PostCar()
{
var aggregateId = CarId.New;
var command = new CreateCarCommand(aggregateId);
var executionResult = await _aggregateManager.Ask <ExecutionResult>(command);
if (executionResult.IsSuccess)
{
return(Accepted(new { Id = aggregateId.GetGuid() }));
}
return(BadRequest(executionResult.ToString()));
}
public async Task CreateAsync(CreateCarDto createCarDto)
{
var createCarCommand = new CreateCarCommand(createCarDto.Make,
createCarDto.Model,
createCarDto.Engine,
createCarDto.Doors,
createCarDto.Wheels,
createCarDto.BodyType);
Car car = _factory.Create(createCarCommand);
await _carRepository.AddAsync(car);
await _context.SaveChangesAsync();
}
private bool Handle(CreateCarCommand command)
{
if (IsNew)
{
Emit(new CarCreatedEvent());
Sender.Tell(new SuccessExecutionResult(), Self);
}
else
{
Sender.Tell(new FailedExecutionResult(new List <string> {
"aggregate is already created"
}), Self);
}
return(true);
}
public IActionResult Post([FromBody] CreateCarCommand createCarCommand)
{
if (createCarCommand == null)
{
return(BadRequest());
}
Guid carId = Guid.Empty;
_commandDispatcher.Send(createCarCommand, out carId);
var carToReturn = _mapper.Map <CarResult>(createCarCommand);
carToReturn.CarId = carId;
return(CreatedAtRoute("GetCar", new { carId }, carToReturn));
}
public void Handler_ShouldWork(string make, string model, string registration, int year, int odometer)
{
var carRepositoryMock = new Mock <ICarRepository>();
var uowMock = new Mock <IUnitOfWork>();
var handler = new CreateCarCommand.Handler(carRepositoryMock.Object, uowMock.Object, APITestsHelper.GetMapper());
var createCarCommand = new CreateCarCommand(model, make, registration, odometer, year);
var result = handler.Handle(createCarCommand, new CancellationToken()).Result;
carRepositoryMock.Verify(t => t.Add(It.IsAny <Car>()), Times.Once);
uowMock.Verify(t => t.CommitAsync(It.IsAny <CancellationToken>()), Times.Once);
Assert.Equal(make, result.Make);
Assert.Equal(model, result.Model);
Assert.Equal(registration, result.Registration);
Assert.Equal(year, result.Year);
Assert.Equal(odometer, result.Odometer);
}
[InlineData("Honda", "Civic", "4 cylinder Petrol Aspirated 1.8L", 5, 20)] //Twenty num of wheels is incorrect for a car
public void BDDScenario_1_1_2_HondaCivicHavingInvalidNumOfWheelsShouldFail(string make,
string model,
string engine,
int doors,
int wheels)
{
IVehicleFactory <Car, CreateCarCommand> factory = new CarFactory();
CreateCarCommand createCarCommand = new CreateCarCommand(make,
model,
engine,
doors,
wheels,
CarBodyType.Hatchback);
var exception = Assert.Throws <ArgumentOutOfRangeException>(() => factory.Create(createCarCommand));
Assert.Equal(nameof(Car.Wheels).ToLowerInvariant(), exception.ParamName.ToLowerInvariant());
}
public async Task AddDistinctCar_Works()
{
var repo = new CarsRepository(_db);
var createCommand = new CreateCarCommand {
BrandId = 1,
ChassisTypeId = 1,
ModelName = "new model",
SeatsCount = 4,
Url = "http://test.ru",
UrlImage = "base64:"
};
var _logger = new Mock <ILogger <CarsController> >();
var handler = new CreateCarCommandHandler(repo);
var cltToken = new System.Threading.CancellationToken();
var result = await handler.Handle(createCommand, cltToken);
Assert.True(result != default(Guid));
Assert.Equal(2, _db.Cars.Count());
// Assert.Equal(1, _db.CarImages.Count());
}
public async Task <IActionResult> PostCar(CreateCarCommand command)
{
var car = new Car
(
command.BrandId,
command.ModelName,
command.ChassisTypeId,
command.SeatsCount,
command.Url,
command.UrlImage
);
await _carsRepo.Add(car);
// await _context.SaveChangesAsync();
await _carsRepo.UnitOfWork.SaveChangesAsync();
var addedCar = await _carsRepo.Get(car.Id);
_logger.LogWarning("Добавлен автомобиль {brand}, {model}", addedCar?.Brand?.Name, addedCar?.ModelName);
return(CreatedAtAction("GetCar", new { id = car.Id }, car));
}
public async Task <IActionResult> PostCar(CreateCarCommand command)
{
var car = new Car
(
command.BrandId,
command.ModelName,
command.ChassisTypeId,
command.SeatsCount,
command.Url,
command.UrlImage
);
var id = await _mediatr.Send(command);
// await _carsRepo.Add(car);
// // await _context.SaveChangesAsync();
//await _carsRepo.UnitOfWork.SaveChangesAsync();
// var addedCar = await _carsRepo.Get(car.Id);
return(CreatedAtAction("GetCar", new { id = id }, null));
}
public async Task <IActionResult> PostAsync([FromForm] CreateCarCommand command)
{
return(Ok(await Mediator.Send(command)));
}
public async Task Create()
{
var command = new CreateCarCommand();
await _bus.Send(command);
}
public Task <Response <Car> > Index([FromBody] CreateCarCommand command)
{
return(mediator.Send(command));
}
public Task <string> Create([FromBody] CreateCarCommand command)
{
return(_mediator.Send(command));
}
public async Task <ActionResult <CarDto> > CreateCar(CreateCarCommand command)
{
var car = await Mediator.Send(command);
return(CreatedAtAction(nameof(GetCar), new { id = car.Id }, car));
}
public async Task <Unit> Handle(CreateCarCommand request, CancellationToken cancellationToken) => await AddAsync(async() => Car.RegisterCar(request.Id, request.Name).State, request.Id) .MapAsync(_ => Unit.Value);
public async Task <ActionResult <CarDto> > CreateCar(CreateCarCommand command, CancellationToken cancellationToken)
{
var car = await Sender.Send(command, cancellationToken);
return(CreatedAtAction(nameof(GetCar), new { car.Id }, car));
}
public void CreateCar(string name, string surname, string licensePlate)
{
var command = new CreateCarCommand(carRepository, parkingFactory, name, surname, licensePlate);
commandHandler.Execute(command);
}
// TODO: MAKE GENERIC
protected override void Handle(CreateCarCommand request, ValidationException exception, RequestExceptionHandlerState <ICommandResult <CarModel> > state)
{
var result = new CommandResult <CarModel>(false, exception.Errors);
state.SetHandled(result);
}
