public IHttpActionResult GetRandomWines(int numOfWines)
{
try
{
List <WineDTO> RWines = new List <WineDTO>();
List <RV_Wine> list = db.RV_Wine.ToList();
for (int i = 0; i < numOfWines; i++)
{
var rand = new Random().Next(list.Count);
RV_Wine temp = list[rand];
list.Remove(list[rand]);
WineDTO sWineDTO = new WineDTO()
{
wineId = temp.wineId,
wineImgPath = temp.wineImgPath,
wineName = temp.wineName,
content = temp.content,
price = temp.price,
wineryName = db.RV_Winery.FirstOrDefault(j => j.wineryId == temp.wineryId).wineryName,
wineryImage = db.RV_Winery.FirstOrDefault(j => j.wineryId == temp.wineryId).IconImgPath,
wineryId = db.RV_Winery.FirstOrDefault(j => j.wineryId == temp.wineryId).wineryId
};
RWines.Add(sWineDTO);
}
return(Ok(RWines));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
/// <summary>
/// https://localhost:44370/api/Wine/id
/// </summary>
/// <param name="id"></param>
/// <param name="value"></param>
/// <returns></returns>
public IHttpActionResult Put(int id, [FromBody] WineDTO value)
{
try
{
RV_Wine w = db.RV_Wine.SingleOrDefault(x => x.wineId == id);
if (w != null)
{
w.wineName = value.wineName;
w.content = value.content;
w.price = value.price;
w.wineImgPath = value.wineImgPath;
w.wineLabelPath = value.wineLabelPath;
w.categoryId = value.categoryId;
w.wineryId = value.wineryId;
db.SaveChanges();
return(Ok(w));
}
return(Content(HttpStatusCode.NotFound,
$"wine with id {id} was not found to update!"));
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public async Task <IActionResult> Put(WineDTO request)
{
try
{
var existingWine = await wineRepository.WineExistsAsync(
new Request <Guid>
{
Data = request.Id
});
if (!existingWine.Result)
{
return(NotFound($"Wine with Id {request.Id} does not exists."));
}
var response = await wineRepository.UpdateWineAsync(request.MapToWineContract());
if (response.Result > 0)
{
return(Ok(request));
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Failed to Update Wine!"));
}
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
public async Task UpdateAsync_given_wine_updates_it()
{
using (var connection = await CreateConnectionAsync())
using (var context = await CreateContextAsync(connection))
{
var entity = new Wine
{
Name = "name",
Year = 2019,
};
context.Wines.Add(entity);
await context.SaveChangesAsync();
var id = entity.Id;
var repository = new WineRepository(context);
var wine = new WineDTO
{
Id = id,
Name = "new name",
Year = 2018,
};
var updated = await repository.UpdateAsync(wine);
Assert.True(updated);
var updatedEntity = await context.Wines.FindAsync(id);
Assert.Equal("new name", updatedEntity.Name);
Assert.Equal(2018, updatedEntity.Year);
}
}
public async Task Post_given_valid_dto_returns_CreatedAtAction()
{
var dto = new WineDTO();
var repo = new Mock <IWineRepository>();
repo.Setup(s => s.CreateAsync(It.IsAny <WineDTO>())).ReturnsAsync(1);
var controller = new WinesController(repo.Object);
var post = await controller.Post(dto);
Assert.IsType <CreatedAtActionResult>(post.Result);
}
public async Task Put_given_repository_returns_false_returns_NotFound()
{
var repository = new Mock <IWineRepository>();
var controller = new WinesController(repository.Object);
var dto = new WineDTO();
var put = await controller.Put(42, dto);
Assert.IsType <NotFoundResult>(put);
}
public async Task Get_existing_id_returns_dto()
{
var dto = new WineDTO();
var repo = new Mock <IWineRepository>();
repo.Setup(s => s.FindAsync(42)).ReturnsAsync(dto);
var controller = new WinesController(repo.Object);
var get = await controller.Get(42);
Assert.Equal(dto, get.Value);
}
public async Task Put_given_dto_updates_wine()
{
var repository = new Mock <IWineRepository>();
var controller = new WinesController(repository.Object);
var dto = new WineDTO();
await controller.Put(42, dto);
repository.Verify(s => s.UpdateAsync(dto));
}
public async Task Put_returns_NoContent()
{
var dto = new WineDTO();
var repository = new Mock <IWineRepository>();
repository.Setup(s => s.UpdateAsync(dto)).ReturnsAsync(true);
var controller = new WinesController(repository.Object);
var put = await controller.Put(42, dto);
Assert.IsType <NoContentResult>(put);
}
private Wine GetWine(WineDTO resultWine)
{
Wine wine = new Wine();
wine.Color = resultWine.Color;
wine.AlcoholQuantity = resultWine.AlcoholQuantity;
wine.Flavor = resultWine.Flavor;
wine.Quantity = resultWine.Quantity;
wine.CostPerLiter = resultWine.CostPerLiter;
wine.TotalCost = resultWine.TotalCost;
return(wine);
}
public async Task <int> CreateAsync(WineDTO wine)
{
var wineEntity = new Wine
{
Name = wine.Name,
Year = wine.Year
};
await _context.Wines.AddAsync(wineEntity);
await _context.SaveChangesAsync();
return(wineEntity.Id);
}
public async Task <ActionResult> Put(int id, [FromBody] WineDTO dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var updated = await _repo.UpdateAsync(dto);
if (updated)
{
return(NoContent());
}
return(NotFound());
}
public static Contract.Wine MapToWineContract(this WineDTO wine)
{
return(new Contract.Wine
{
Id = wine.Id,
WineryId = wine.WineryId,
Name = wine.Name,
Price = wine.Price,
Color = (Contract.WineColor)wine.Color,
Vintage = wine.Vintage,
IssueDate = DateTime.Parse(wine.IssueDate),
Note = wine.Note
});
}
public async Task <ActionResult <WineDTO> > Post([FromBody] WineDTO dto)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
if (dto == null)
{
return(BadRequest());
}
var create = await _repo.CreateAsync(dto);
return(CreatedAtAction(nameof(Get), create));
}
public async Task UpdateAsync_given_non_existing_wine_returns_false()
{
using (var connection = await CreateConnectionAsync())
using (var context = await CreateContextAsync(connection))
{
var repository = new WineRepository(context);
var wine = new WineDTO {
Id = 42
};
var updated = await repository.UpdateAsync(wine);
Assert.False(updated);
}
}
public async Task <bool> UpdateAsync(WineDTO wine)
{
var wineEntity = await _context.Wines.FindAsync(wine.Id);
if (wineEntity == null)
{
return(false);
}
wineEntity.Name = wine.Name;
wineEntity.Year = wine.Year;
await _context.SaveChangesAsync();
return(true);
}
public async Task <IActionResult> Post(WineDTO request)
{
try
{
var response = await wineRepository.AddWineAsync(request.MapToWineContract());
if (response.Result != Guid.Empty)
{
request.Id = response.Result;
return(Created($"api/wines/{request.Id}", request));
}
else
{
return(StatusCode(StatusCodes.Status500InternalServerError, "Failed to Add Wine!"));
}
}
catch (Exception ex)
{
return(StatusCode(StatusCodes.Status500InternalServerError, ex.Message));
}
}
public async Task CreateAsync_given_wine_creates()
{
using (var connection = await CreateConnectionAsync())
using (var context = await CreateContextAsync(connection))
{
var repository = new WineRepository(context);
var wine = new WineDTO
{
Name = "wineTest",
Year = 2019
};
var created = await repository.CreateAsync(wine);
var entity = await context.Wines.FindAsync(created);
Assert.Equal("wineTest", entity.Name);
Assert.Equal(2019, entity.Year);
}
}
/// <summary>
/// https://localhost:44370/api/Wine
/// </summary>
/// <param name="value"></param>
/// <returns></returns>
public IHttpActionResult Post([FromBody] WineDTO value)
{
try
{
RV_Wine wine = new RV_Wine()
{
wineName = value.wineName,
content = value.content,
price = value.price,
wineImgPath = value.wineImgPath,
wineLabelPath = value.wineLabelPath,
categoryId = value.categoryId,
wineryId = value.wineryId
};
db.RV_Wine.Add(wine);
db.SaveChanges();
return(Ok());
}
catch (Exception ex)
{
return(Content(HttpStatusCode.BadRequest, ex));
}
}
