public async Task <IActionResult> CreateAsync([FromBody] CreateCarRequest request)
{
if (request.Brand == Brand.Undefined)
{
return(BadRequest(new BadRequestObjectResult($"Undefined brand. Select a valid brand.")));
}
if (request.Type == CarType.Undefined)
{
return(BadRequest(new BadRequestObjectResult($"Undefined type. Select a valid type.")));
}
if (string.IsNullOrEmpty(request.Registration) || request.Registration.Length != 10)
{
return(BadRequest(new BadRequestObjectResult($"Registration must have 10 characters.")));
}
Car createdCar = await _fleetService.CreateAsync(_mapper.Map <Car>(request));
if (createdCar == null)
{
return(NotFound(new NotFoundObjectResult($"Car was not created.")));
}
var locationUri = _uriService.GetCarUri(Request.Path.Value.Substring(1) + "/" + createdCar.Id.ToString());
return(Created(locationUri, new Response <CarResponse>(_mapper.Map <CarResponse>(createdCar))));
}
public async void Post_CreateCar_ShouldWork()
{
var expected = new CarDTO();
var createCarRequest = new CreateCarRequest()
{
Make = "Make",
Model = "Model",
Registration = "Reg",
Year = 2000
};
var mediatorMock = new Mock <IMediator>();
mediatorMock.Setup(t => t.Send(It.IsAny <CreateCarCommand>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(expected));
var logger = new Mock <ILogger <CarController> >();
var controller = new CarController(mediatorMock.Object, logger.Object);
ValidateModelState(createCarRequest, controller);
var response = await controller.Post(createCarRequest);
var okResult = Assert.IsType <CreatedResult>(response);
var car = Assert.IsAssignableFrom <CarDTO>(okResult.Value);
Assert.Equal(expected, car);
}
public CreateCarRequestValidatorSpec()
{
this.validator = new CreateCarRequestValidator();
this.dto = new CreateCarRequest
{
Year = Manufacturer.MinYear,
Make = Manufacturer.Makes[0],
Model = Manufacturer.Models[0]
};
}
public CreateCarResponse Post(CreateCarRequest request)
{
var car = this.carsApplication.Create(Request.ToCaller(), request.Year, request.Make, request.Model);
Response.SetLocation(car);
return(new CreateCarResponse
{
Car = car
});
}
public static Task <CreateCarResponse> CreateCarResponseAsync(Car car, IEndpointInstance endpointInstance)
{
var message = new CreateCarRequest(car);
var sendOptions = new SendOptions();
sendOptions.SetDestination("NServiceBusCore.Server");
var responseTask = endpointInstance
.Request <CreateCarResponse>(message, sendOptions);
return(responseTask);
}
public async Task <IActionResult> Post([FromBody] CreateCarRequest request)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
CarDTO car = await _mediator.Send(new CreateCarCommand(request.Model, request.Make, request.Registration, request.Odmometer, request.Year));
return(Created(string.Empty, car));
}
catch (OException ex)
{
return(BadRequest(ex.Message));
}
}
public async void Post_CreateCar_ShouldReturnBadRequest()
{
var createCarRequest = new CreateCarRequest();
var mediatorMock = new Mock <IMediator>();
var logger = new Mock <ILogger <CarController> >();
var controller = new CarController(mediatorMock.Object, logger.Object);
ValidateModelState(createCarRequest, controller);
var response = await controller.Post(createCarRequest);
var badRequestResult = Assert.IsType <BadRequestObjectResult>(response);
var errors = Assert.IsAssignableFrom <SerializableError>(badRequestResult.Value);
Assert.True(errors.ContainsKey(nameof(createCarRequest.Make)));
Assert.True(errors.ContainsKey(nameof(createCarRequest.Model)));
Assert.True(errors.ContainsKey(nameof(createCarRequest.Registration)));
Assert.True(errors.ContainsKey(nameof(createCarRequest.Year)));
}
public GenericResponse Create([FromBody] CreateCarRequest createCarRequest)
{
if (!ModelState.IsValid)
{
return new GenericResponse {
IsSuccessful = false
}
}
;
Car car = createCarRequest.Car;
carDAO.AddCar(car);
foreach (var picture in createCarRequest.Pictures)
{
carDAO.AddCarPicture(new CarPicture
{
CarId = car.CarId,
Picture = Convert.FromBase64String(picture)
});
}
return(new GenericResponse());
}
public async Task <ActionResult> Create(CreateCarRequest request)
{
var result = await _carService.CreateCarAsync(HttpContext.GetUserId(), _mapper.Map <Car>(request));
return(GenerateResponse(result));
}
protected async Task <CarResponse> CreateCarAsync(CreateCarRequest request)
{
var response = await _client.PostAsJsonAsync("/api/v1/Cars" + ApiRoutes.Cars.Create, request);
return((await response.Content.ReadAsAsync <Response <CarResponse> >()).Data);
}
public async Task <ServiceResult <CreateCarResponse> > CreateCarAsync(CreateCarRequest request)
{
return(await _requestSenderService.SendAuthPostRequestAsync <CreateCarResponse>(Url, request));
}
public Car Post(CreateCarRequest request)
{
return(new Car());
}
public Engine Post(CreateCarRequest request)
{
return(new Engine());
}