public async Task <IActionResult> UpdateBeerStyle(int id, BeerStyle beerStyle)
{
if (id != beerStyle.Id)
{
return(BadRequest());
}
db.Entry(beerStyle).State = EntityState.Modified;
try
{
await db.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BeerStyleExists(id))
{
return(NotFound());
}
else
{
throw;
}
}
return(Ok());
}
public static BeerStyle ToBeerStyle(this Style style)
{
var beerStyle = new BeerStyle
{
Id = Guid.NewGuid().ToString("N"),
AbvMax = style.AbvMax,
AbvMin = style.AbvMin,
Description = style.Description,
FgMax = style.FgMax,
FgMin = style.FgMin,
IbuMax = style.IbuMax,
IbuMin = style.IbuMin,
Name = style.Name,
OgMin = style.OgMin,
ShortName = style.ShortName,
SrmMax = style.SrmMax,
SrmMin = style.SrmMin
};
if (style.Category != null)
{
beerStyle.Category = style.Category.Name;
}
return(beerStyle);
}
private void Init(string brand, string subBrand, BeerStyle style, BeerType type)
{
Type = type;
Style = style;
Brand = brand;
SubBrand = subBrand;
}
public async Task UpdateAsync_ShouldChangeNameOfStyleAndDescriptionAsync()
{
//Arrange
var options = InMemory.GetOptions("UpdateAsync_ShouldChangeNameOfStyleAndDescriptionAsync");
using (var context = new BOContext(options))
{
var style = new BeerStyle()
{
Name = "Ale",
Description = "This description"
};
context.BeerStyles.Add(style);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
var styleDTO = new BeerStyleDTO()
{
Name = "Ale2",
Description = "This description2"
};
//Act
var sut = new BeerStylesService(context);
await sut.UpdateAsync(1, styleDTO);
var dbresult = await context.BeerStyles.FindAsync(1);
//Assert
Assert.AreEqual(dbresult.Name, "Ale2");
Assert.AreEqual(dbresult.Description, "This description2");
}
}
public async Task DeleteAsync_ShouldReturnTrueStyleIfSucceded()
{
//Arrange
var options = InMemory.GetOptions("DeleteAsync_ShouldReturnTrueStyleIfSucceded");
using (var context = new BOContext(options))
{
var style = new BeerStyle()
{
Name = "Ale",
Description = "This description"
};
context.BeerStyles.Add(style);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new BeerStylesService(context);
var result = await sut.DeleteAsync(1);
//Assert
Assert.AreEqual(result, true);
}
}
public async Task DeleteAsync_ShouldDeleteStyleIfExist()
{
//Arrange
var options = InMemory.GetOptions("DeleteAsync_ShouldDeleteStyleIfExist");
using (var context = new BOContext(options))
{
var style = new BeerStyle()
{
Name = "Ale",
Description = "This description"
};
context.BeerStyles.Add(style);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new BeerStylesService(context);
await sut.DeleteAsync(1);
var dbresult = await context.BeerStyles.FirstOrDefaultAsync(c => c.Name == "Ale");
//Assert
Assert.AreEqual(dbresult.Name, "Ale");
Assert.AreEqual(dbresult.DeletedOn, dbresult.ModifiedOn);
Assert.AreEqual(dbresult.IsDeleted, true);
}
}
public virtual async Task AddAsync(BeerStyle beerStyle)
{
using (var context = new MicrobrewitContext())
{
context.Entry(beerStyle).State = EntityState.Added;
try
{
await context.SaveChangesAsync();
}
catch (DbEntityValidationException dbEx)
{
//foreach (var validationErrors in dbEx.EntityValidationErrors)
//{
// foreach (var validationError in validationErrors.ValidationErrors)
// {
// Trace.TraceInformation("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage);
// Log.DebugFormat("Property: {0} Error: {1}", validationError.PropertyName, validationError.ErrorMessage);
// throw dbEx;
// }
//}
throw;
}
catch (Exception ex)
{
throw;
}
}
}
public async Task <IActionResult> Edit(int id, [Bind("Id,Name")] BeerStyle beerStyle)
{
if (id != beerStyle.Id)
{
return(NotFound());
}
if (ModelState.IsValid)
{
try
{
_context.Update(beerStyle);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
if (!BeerStyleExists(beerStyle.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(beerStyle));
}
public async Task <ActionResult <BeerStyle> > CreateStyle(BeerStyle beerStyle)
{
db.BeerStyle.Add(beerStyle);
await db.SaveChangesAsync();
return(CreatedAtAction("GetOneStyle", new{ id = beerStyle.Id }, beerStyle));
}
public async Task GetAllAsync_ShouldReturnIEnumerableBeerStyleDTOAsync()
{
//Arrange
var options = InMemory.GetOptions("GetAllAsync_ShouldReturnIEnumerableBeerStyleDTOAsync");
using (var context = new BOContext(options))
{
var style = new BeerStyle()
{
Name = "Ale",
Description = "This description"
};
context.BeerStyles.Add(style);
await context.SaveChangesAsync();
}
using (var context = new BOContext(options))
{
//Act
var sut = new BeerStylesService(context);
var result = await sut.GetAllAsync();
//Assert
Assert.IsInstanceOfType(result, typeof(IEnumerable <BeerStyleDTO>));
}
}
public async Task <int> UpdateAsync(BeerStyle beerStyle)
{
using (DbConnection connection = new NpgsqlConnection(_databaseSettings.DbConnection))
{
connection.Open();
using (var transaction = connection.BeginTransaction())
{
try
{
var result = await connection.ExecuteAsync("UPDATE BeerStyles set Name = @Name,superstyle_id = @SuperStyleId,og_low = @OGLow,og_high = @OGHigh," +
"fg_low = @FGLow,fg_high = @FGHigh,ibu_low = @IBULow,ibu_high = @IBUHigh, srm_low = @SRMLow, srm_high = @SRMHigh," +
"abv_low = @ABVLow, abv_high = @ABVHigh, comments = @Comments " +
"WHERE beerstyle_id = @BeerStyleId",
beerStyle, transaction);
transaction.Commit();
return(result);
}
catch (Exception)
{
transaction.Rollback();
throw;
}
}
}
}
public async Task AddAsync(BeerStyle beerStyle)
{
using (DbConnection connection = new NpgsqlConnection(_databaseSettings.DbConnection))
{
connection.Open();
using (var transaction = connection.BeginTransaction())
{
try
{
var result =
await
connection.ExecuteAsync(
"INSERT INTO beerstyles(name,superstyle_id,og_low,og_high,fg_low,fg_high,ibu_low,ibu_high,srm_low,srm_high,abv_low,abv_high,comments) " +
"VALUES(@Name,@SuperStyleId,@OGLow,@OGHigh,@FGLow,@FGHigh,@IBULow,@IBUHigh,@SRMLow,@SRMHigh,@ABVLow,@ABVHigh,@Comments);",
beerStyle, transaction);
var beerStyleId = await connection.QueryAsync <int>("SELECT last_value FROM beerstyles_seq;");
beerStyle.BeerStyleId = beerStyleId.SingleOrDefault();
transaction.Commit();
}
catch (Exception)
{
transaction.Rollback();
throw;
}
}
}
}
public virtual void Remove(BeerStyle beerStyle)
{
using (var context = new MicrobrewitContext())
{
context.Entry(beerStyle).State = EntityState.Deleted;
context.SaveChanges();
}
}
public Barrel(Customer customer, BeerStyle beerStyle, DateTime orderDate)
{
Customer = customer;
BeerStyle = beerStyle;
OrderDate = orderDate;
}
public void MapStyleToDTO_ShouldReturnBeerStyleDTO()
{
//Arrange
var cut = new BeerStyle();
//Act
var sut = cut.MapStyleToDTO();
//Assert
Assert.IsInstanceOfType(sut, typeof(BeerStyleDTO));
}
public async Task <IActionResult> Create([Bind("Id,Name")] BeerStyle beerStyle)
{
if (ModelState.IsValid)
{
_context.Add(beerStyle);
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(beerStyle));
}
private DynamicParameters GetParameters(BeerStyle styles)
{
var queryParameters = new DynamicParameters();
queryParameters.Add("@Id", styles.Id);
queryParameters.Add("@CategoryId", styles.CategoryId);
queryParameters.Add("@Name", styles.Name);
queryParameters.Add("@ShortName", styles.ShortName);
queryParameters.Add("@Description", styles.Description);
return(queryParameters);
}
public void MapStyleToDTO_ShouldReturnCorrectID()
{
//Arrange
var cut = new BeerStyle()
{
ID = 1
};
//Act
var sut = cut.MapStyleToDTO();
//Assert
Assert.AreEqual(sut.ID, 1);
}
protected override IList <string> ResolveCore(BeerStyle BeerStyle)
{
var subStyles = new List <string>();
if (BeerStyle.SubStyles != null)
{
foreach (var subStyle in BeerStyle.SubStyles)
{
subStyles.Add(subStyle.Name);
}
}
return(subStyles);
}
// Ordered barrels should be produced and delivered.
// If the customer has ordered several barrels of this beer style and those are not delivered yet, the brewery must deliver the earliest order (FIFO principle - First In First Out)
public void CreateDeliveryBarrel(Guid id, BeerStyle beerStyle, DateTime deliveryDate)
{
var tempCustomer = customers.Where(o => o.Id == id).FirstOrDefault();
// We select ordered barrels of this beer style and sort these by ascending
LinkedList <Barrel> orderBarrels = new LinkedList <Barrel>(tempCustomer.OrderedBarrels.Where(o => o.BeerStyle.Equals(beerStyle)).OrderBy(o => o.OrderDate));
// Get the barrel with the earliest order date and deliver it
Barrel tempBarrel = orderBarrels.First.Value;
tempBarrel.DeliveryDate = deliveryDate;
tempCustomer.DeliveredBarrels.AddLast(tempBarrel);
tempCustomer.OrderedBarrels.Remove(tempBarrel);
}
private async Task IndexHopAsync(BeerStyle beerStyle)
{
if (beerStyle.HopBeerStyles == null)
{
return;
}
foreach (var hopBeerStyle in beerStyle.HopBeerStyles)
{
var hop = await _hopRepository.GetSingleAsync(hopBeerStyle.HopId);
var hopDto = AutoMapper.Mapper.Map <Hop, HopDto>(hop);
await _hopElasticsearch.UpdateAsync(hopDto);
}
}
public void MapStyleToDTO_ShouldReturnCorrectNameAndDescription()
{
//Arrange
var cut = new BeerStyle()
{
Name = "Ale",
Description = "This Description"
};
//Act
var sut = cut.MapStyleToDTO();
//Assert
Assert.AreEqual(sut.Name, "Ale");
Assert.AreEqual(sut.Description, "This Description");
}
public virtual async Task <int> UpdateAsync(BeerStyle beerStyle)
{
using (var context = new MicrobrewitContext())
{
context.Entry(beerStyle).State = EntityState.Modified;
try
{
return(await context.SaveChangesAsync());
}
catch (Exception e)
{
throw;
}
}
}
public virtual async Task RemoveAsync(BeerStyle beerStyle)
{
using (var context = new MicrobrewitContext())
{
context.Entry(beerStyle).State = EntityState.Deleted;
try
{
await context.SaveChangesAsync();
}
catch (Exception e)
{
Log.Debug(e);
throw;
}
}
}
public void CreateDeliveryBarrelCheck()
{
// Arrange
Customer tempCustomer = testController.customers.ElementAt(0);
int deliveredBarrelsBefore = tempCustomer.DeliveredBarrels.Count;
int orderedBarrelsBefore = tempCustomer.OrderedBarrels.Count;
BeerStyle style = BeerStyle.IPA;
DateTime deliveryDate = new DateTime(2014, 9, 1);
// Act
testController.CreateDeliveryBarrel(tempCustomer.Id, style, deliveryDate);
// Assert
Assert.IsTrue((tempCustomer.DeliveredBarrels.Count - deliveredBarrelsBefore) == 1);
Assert.IsTrue((tempCustomer.OrderedBarrels.Count - orderedBarrelsBefore) == -1);
}
public static BeerStyle MapDTOToStyle(this BeerStyleDTO dto)
{
try
{
var style = new BeerStyle()
{
ID = dto.ID,
Name = dto.Name,
Description = dto.Description
};
return(style);
}
catch (Exception)
{
return(new BeerStyle());
}
}
public static BeerStyleDTO MapStyleToDTO(this BeerStyle style)
{
try
{
//TODO: Test with actual list of brewery
var styleDTO = new BeerStyleDTO()
{
ID = style.ID,
Name = style.Name,
Description = style.Description
};
return(styleDTO);
}
catch (Exception)
{
return(new BeerStyleDTO());
}
}
protected override IList <DTO> ResolveCore(BeerStyle beerStyle)
{
var beerStylesDto = new List <DTO>();
foreach (var hopBeerStyle in beerStyle.HopBeerStyles)
{
if (hopBeerStyle.Hop != null)
{
beerStylesDto.Add(new DTO
{
Id = hopBeerStyle.Hop.HopId,
Name = hopBeerStyle.Hop.Name,
});
}
}
return(beerStylesDto);
}
public void CreateOrderBarrelCheck()
{
// Arrange
var rand = new Random();
int i = rand.Next(testController.customers.Count);
Customer tempCustomer = testController.customers.ElementAt(i);
int orderedBarrelsBefore = tempCustomer.OrderedBarrels.Count;
int deliveredBarrelsBefore = tempCustomer.DeliveredBarrels.Count;
BeerStyle style = BeerStyle.Pilsner;
DateTime orderDate = DateTime.Today;
// Act
testController.CreateOrderBarrel(tempCustomer.Id, style, orderDate);
// Assert
Assert.IsTrue((tempCustomer.OrderedBarrels.Count - orderedBarrelsBefore) == 1);
Assert.IsTrue((tempCustomer.DeliveredBarrels.Count - deliveredBarrelsBefore) == 0);
}
public async Task <int> UpdateAsync(BeerStyle beerStyle)
{
using (var context = DapperHelper.GetConnection())
{
context.Open();
using (var transaction = context.BeginTransaction())
{
try
{
var result = await context.ExecuteAsync("UPDATE BeerStyles set Name = @Name,SuperStyleId = @SuperStyleId,OGLow = @OGLow,OGHigh = @OGHigh," +
"FGLow = @FGLow,FGHigh = @FGHigh,IBULow = @IBULow,IBUHigh = @IBUHigh, SRMLow = @SRMLow, SRMHigh = @SRMHigh," +
"ABVLow = @ABVLow, ABVHigh = @ABVHigh, Comments = @Comments " +
"WHERE BeerStyleId = @BeerStyleId",
new
{
beerStyle.BeerStyleId,
beerStyle.Name,
beerStyle.SuperStyleId,
beerStyle.OGLow,
beerStyle.OGHigh,
beerStyle.FGLow,
beerStyle.FGHigh,
beerStyle.IBULow,
beerStyle.IBUHigh,
beerStyle.SRMLow,
beerStyle.SRMHigh,
beerStyle.ABVLow,
beerStyle.ABVHigh,
beerStyle.Comments,
}, transaction);
transaction.Commit();
return(result);
}
catch (Exception e)
{
Log.Error(e.ToString());
transaction.Rollback();
throw;
}
}
}
}
public List<BeerViewModel> Top(BeerStyle? style)
{
using (var context = new BeerBoutiqueEntities()) {
var t = context.Ratings.GroupBy(x => x.Beer).Select(y => new
{
BeerID = y.Key.ID,
AverageOverall = y.Average(z => z.Overall)
}).OrderBy(x => x.AverageOverall).Take(10);
var b = new List<BeerViewModel>();
foreach (var a in t) {
b.Add(new BeerViewModel(context.Beers.SingleOrDefault(x => x.ID == a.BeerID)));
}
//var beers = context.Beers.Join(t, Beers => Beers.ID, Ratings => Ratings.BeerID, (beer, rating) => new BeerViewModel(beer)).ToList();
return b.OrderByDescending(x => x.AverageOverall).ToList();
}
}
public IEnumerable<BeerViewModel> Top(BeerStyle? style = null)
{
var beers = _beerFacade.Top(style);
return beers;
}
public IEnumerable<BeerViewModel> ByStyle(BeerStyle style)
{
var beers = _beerFacade.GetByStyle((int)style);
return beers;
}
public JsonResult GetTop(BeerStyle? style = null)
{
int echo = 0;
if (Request["sEcho"] != null)
{
if (!Int32.TryParse(Request["sEcho"], out echo))
{
throw new HttpRequestException("XSS Attack possibly attempted");
}
}
var beerFacade = new BeerFacade();
var res = beerFacade.Top(style);
return Json(new
{
iTotalRecords = res.Count(),
iTotalDisplayRecords = res.Count(),
sEcho = echo,
aaData = res.Select(x => new[]
{
x.Name,
x.Style,
x.ABV.ToString(),
x.AverageOverall.ToString(),
x.ID.ToString()
})
}, JsonRequestBehavior.AllowGet);
}
