public async Task Update(PlaneTypeDto item)
{
var updItem = _mapper.Map <PlaneTypeDto, PlaneType>(item);
await _unitOfWork.Repository <PlaneType>().Update(updItem);
await _unitOfWork.SaveAsync();
}
public void Update_Valid()
{
//arange
PlaneTypesService service = new PlaneTypesService(unitOfWork, mapper, validator);
var expected = new PlaneType
{
Id = 1, Model = "AN140", Capacity = 5000, Seats = 23, Range = 2345, ServiceLife = new TimeSpan(200, 0, 0, 0)
};
var DtoToMake = new PlaneTypeDto
{
Id = 1, Model = "AN140", Capacity = 5000, Seats = 23, Range = 2345, ServiceLife = new TimeSpan(200, 0, 0, 0)
};
//act
service.Update(DtoToMake);
var actual = (unitOfWork.Set <PlaneType>() as FakeRpository <PlaneType>).updatedItem;
//assert
Assert.AreEqual(expected.Id, actual.Id);
Assert.AreEqual(expected.Capacity, actual.Capacity);
Assert.AreEqual(expected.Model, actual.Model);
Assert.AreEqual(expected.Range, actual.Range);
Assert.AreEqual(expected.Seats, actual.Seats);
Assert.AreEqual(expected.ServiceLife, actual.ServiceLife);
}
public async Task Create(PlaneTypeDto item)
{
var newItem = _mapper.Map <PlaneTypeDto, PlaneType>(item);
await _unitOfWork.Repository <PlaneType>().Create(newItem);
await _unitOfWork.SaveAsync();
}
public async Task <IActionResult> Put(int id, [FromBody] PlaneTypeDto entity)
{
var result = await _planeTypesService.UpdateAsync(entity, id);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
public async Task <IActionResult> Post([FromBody] PlaneTypeDto entity)
{
var result = await _planeTypesService.AddAsync(entity);
if (result == null)
{
return(NotFound());
}
return(Ok(result));
}
public IActionResult Put(int id, [FromBody] PlaneTypeDto value)
{
if (ModelState.IsValid)
{
var item = service.Update(value);
if (item != null)
{
return(Ok(item));
}
}
return(BadRequest());
}
public IActionResult Put(int id, [FromBody] PlaneTypeDto value)
{
if (ModelState.IsValid)
{
try
{
service.Update(value);
}
catch (Exception) { return(BadRequest()); }
return(Ok());
}
return(BadRequest());
}
public async Task <IActionResult> Update([FromBody] PlaneTypeDto planeType)
{
if (ModelState.IsValid)
{
await _service.Update(planeType);
return(Ok(planeType));
}
else
{
return(new BadRequestObjectResult(ModelState));
}
}
public async Task <IActionResult> Put([FromBody] PlaneTypeDto value)
{
if (ModelState.IsValid)
{
try
{
await Task.Run(() => service.Update(mapper.Map <PlaneTypeDto, PlaneType>(value)));
await service.SaveChangesAsync();
}
catch (Exception) { return(BadRequest()); }
return(Ok());
}
return(BadRequest());
}
public void Update_UnValid()
{
//arange
PlaneTypesService service = new PlaneTypesService(unitOfWork, mapper, validator);
var DtoToMake = new PlaneTypeDto
{
Id = 1, Model = "", Capacity = 5000, Seats = 23, Range = 2345, ServiceLife = new TimeSpan(200, 0, 0, 0)
};
//act
service.Update(DtoToMake);
var actual = (unitOfWork.Set <PlaneType>() as FakeRpository <PlaneType>).updatedItem;
//assert
Assert.IsNull(actual);
}
public async Task <IActionResult> Delete([FromBody] PlaneTypeDto entity)
{
var result = await _planeTypesService.DeleteAsync(entity);
return(Ok());
}
public PlaneTypeDto Put(int id, [FromBody] PlaneTypeDto entity)
{
return(_planeTypesService.Update(entity));
}
public ActionResult <PlaneTypeDto> Post([FromBody] PlaneTypeDto entity)
{
return(_planeTypesService.Make(entity));
}
public PlaneTypeDto Update(PlaneTypeDto entity)
{
var updatedEntity = _mapper.Map <PlaneTypeDto, PlaneType>(entity);
return(_mapper.Map <PlaneType, PlaneTypeDto>(_repository.Update(updatedEntity)));
}
public PlaneTypeDto Make(PlaneTypeDto entity)
{
var makedEntity = _mapper.Map <PlaneTypeDto, PlaneType>(entity);
return(_mapper.Map <PlaneType, PlaneTypeDto>(_repository.Create(makedEntity)));
}
