public BeerReview GetReview(User user, Beer beer)
{
if (user == null || beer == null)
{
return(new BeerReview());
}
var review = new BeerReview();
try
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
var query = @"SELECT TOP 1 beers.id AS beer_id, beers.name AS beer_name, beers.image_url AS image_url, beerreview.id AS review_id, beerreview.rating AS review_rating, beerreview.date_of_review AS review_date, beerreview.review AS review_text, users.id AS user_id, users.username AS user_username FROM users JOIN beerreview ON users.id = beerreview.user_id JOIN beers on beers.id = beerreview.beer_id WHERE users.id = @user_id AND beerreview.beer_id = @beer_id";
SqlCommand cmd = new SqlCommand(query, conn);
cmd.Parameters.AddWithValue("@user_id", user.Id);
cmd.Parameters.AddWithValue("@beer_id", beer.BeerId);
SqlDataReader reader = cmd.ExecuteReader();
if (reader.HasRows)
{
while (reader.Read())
{
review = MapRowToBeerReview(reader);
}
}
}
return(review);
}
catch (SqlException ex)
{
throw ex;
}
}
/// <summary>
/// Add a new review
/// </summary>
/// <param name="review"></param>
/// <returns></returns>
public int AddReview(BeerReview review)
{
try
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
string sql =
@"INSERT INTO beerReviews
(review,beerID,rating)
VALUES
(@review, @beerID, @rating); Select @@Identity;";
SqlCommand cmd = new SqlCommand(sql, conn);
cmd.Parameters.AddWithValue("@review", review.Review);
cmd.Parameters.AddWithValue("@beerID", review.BeerID);
cmd.Parameters.AddWithValue("@rating", review.Rating);
return(Convert.ToInt32(cmd.ExecuteScalar()));
}
}
catch (SqlException ex)
{
throw ex;
}
}
private BeerReview MapRowToBeerReview(SqlDataReader reader)
{
//try
//{
var dt = Convert.ToString(reader["review_date"]);
var reviewDate = DateTime.ParseExact(dt, "yyyy-MM-dd HH:mm:ss.fff", CultureInfo.InvariantCulture);
var br = new BeerReview
{
BeerReviewId = Convert.ToInt32(reader["review_id"]),
UserReviewing = MapRowToUser(reader),
BeerReviewed = MapRowToBeer(reader),
ReviewText = Convert.ToString(reader["review_text"]),
DateOfReview = reviewDate
};
br.SetRaiting(Convert.ToDouble(reader["review_rating"]));
return(br);
//}
//catch
//{
//return new BeerReview();
//}
}
public async Task <ActionResult> Index(CreateReviewBindingModel m)
{
if (!this.ModelState.IsValid)
{
return(this.ReviewValidationFailure());
}
string imgUrl = null;
if (m.Image != null)
{
var stream = m.Image.InputStream;
imgUrl = await this.imageUpload.UploadImageAsync(stream, Constants.DefaultImageSizePx, Constants.DefaultImageSizePx);
if (imgUrl == null)
{
return(this.ImageUploadFailure());
}
}
var review = new BeerReview();
review = this.mapper.Map(m, review);
review.ApplicationUserId = this.User.Identity.GetUserId();
review.ImgUrl = imgUrl ?? review.ImgUrl;
var result = this.reviewService.CreateReview(review);
if (result.Successful)
{
return(this.RedirectToAction("My"));
}
return(this.ReviewValidationFailure());
}
public IActionResult SaveBeerReview(BeerViewModel response)
{
var beerReviewed = BeerDAL.GetBeer(response.CurrentBeerId);
var userReviewing = AuthProvider.GetCurrentUser();
var userReviewId = response.UserReviewId;
var reviewText = response.UserReviewText;
var reviewRating = response.UserRating;
BeerReview beerReview = new BeerReview
{
BeerReviewed = beerReviewed,
UserReviewing = userReviewing,
DateOfReview = DateTime.Now,
BeerReviewId = userReviewId,
ReviewText = reviewText,
};
beerReview.SetRaiting(response.UserRating);
if (!string.IsNullOrEmpty(reviewText) && reviewRating > 0)
{
BeerReviewDAL.CreateOrUpdateReview(beerReview);
}
return(RedirectToAction("BeerDetail", new { id = beerReviewed.BeerId }));
}
public ActionResult Edit(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BeerReview beerReview = repository.Get(id);
//BeerReview beerReview = db.Reviews.Find(id);
if (beerReview == null)
{
return(HttpNotFound());
}
if (User.Identity.GetUserId() == beerReview.UserInfo.UserInfoId || User.IsInRole("Admin"))
{
ViewBag.ProductId = beerReview.ProductId;
//ViewBag.ProductId = new SelectList(repository.GetProducts(), "ProductId", "Name", beerReview.ProductId);
//ViewBag.ProductId = new SelectList(db.Products, "ProductId", "Name", beerReview.ProductId);
return(View(beerReview));
}
else
{
return(RedirectToAction("Details", "BeerProducts", new { id = beerReview.ProductId }));
}
}
public BeerReview AddBeerReview(BeerReview review)
{
try
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
string sqlText = "INSERT INTO beer_reviews (beer_id,user_id, title,beerRating, beerReview, is_private) values (@beerId, @userId,@title,@beerRating, @beerReview, @isPrivate)";
SqlCommand cmd = new SqlCommand(sqlText, conn);
cmd.Parameters.AddWithValue("@beerId", review.BeerId);
cmd.Parameters.AddWithValue("@userId", review.UserId);
cmd.Parameters.AddWithValue("@title", review.Title);
cmd.Parameters.AddWithValue("@beerRating", review.BeerRating);
cmd.Parameters.AddWithValue("@beerReview", review.Review);
cmd.Parameters.AddWithValue("@isPrivate", review.isPrivate);
cmd.ExecuteNonQuery();
}
}
catch (Exception e)
{
throw e;
}
return(review);
}
public async Task <IHttpActionResult> AddRating(int id, ReviewDTO reviewDTO)
{
if (!ModelState.IsValid)
{
var message = string.Join(" | ", ModelState.Values
.SelectMany(v => v.Errors)
.Select(e => e.ErrorMessage));
return(Json(new { message }));
}
Boolean isIdValid = await APIHelper.ValidateID(id);
if (!isIdValid)
{
return(BadRequest("No beer exists with id '" + id + "'"));
}
BeerReview review = new BeerReview
{
id = id,
Username = reviewDTO.Username,
Rating = reviewDTO.Rating,
Comments = reviewDTO.Comments
};
DatabaseReadWrite.AddReview(review);
return(Ok("Review Added to database"));
}
public List <BeerReview> GetBeerReviews()
{
List <BeerReview> beerReviews = new List <BeerReview>();
try
{
using (SqlConnection conn = new SqlConnection(connectionString))
{
conn.Open();
string sqlText = "Select * from beer_reviews";
SqlCommand cmd = new SqlCommand(sqlText, conn);
SqlDataReader reader = cmd.ExecuteReader();
while (reader.Read())
{
BeerReview currentReview = GetBeerReviewsFromReader(reader);
beerReviews.Add(currentReview);
}
return(beerReviews);
}
}
catch (Exception e)
{
throw e;
}
}
public async Task NotCall_ImageServiceUploadImageMethodOnceWithCorrectParams_WhenImageIsNull()
{
// Arrange
var updateResult = new Mock <IDataModifiedResult>();
updateResult.Setup(r => r.Successful).Returns(true);
var sut = this.MockingKernel.Get <ReviewsController>(AjaxContextName);
var expectedReview = new BeerReview();
var bindingModel = new CreateReviewBindingModel()
{
Image = null
};
var reviewService = this.MockingKernel.GetMock <IBeerReviewService>();
reviewService.Setup(s => s.CreateReview(It.IsAny <IBeerReview>()))
.Returns(updateResult.Object);
var mapper = this.MockingKernel.GetMock <IMapper>();
mapper.Setup(m => m.Map(bindingModel, It.IsAny <BeerReview>()))
.Returns(expectedReview);
var imgUploadService = this.MockingKernel.GetMock <IImageUploadService>();
// Act
await sut.Index(bindingModel);
// Assert
imgUploadService.Verify(s => s.UploadImageAsync(It.IsAny <Stream>(), Constants.DefaultImageSizePx, Constants.DefaultImageSizePx), Times.Never);
}
public async Task Return_CorrectResult_WhenReviewCreationSucceeds()
{
// Arrange
var updateResult = new Mock <IDataModifiedResult>();
updateResult.Setup(r => r.Successful).Returns(true);
var sut = this.MockingKernel.Get <ReviewsController>(AjaxContextName);
var bindingModel = new CreateReviewBindingModel();
var expectedReview = new BeerReview();
var mapper = this.MockingKernel.GetMock <IMapper>();
mapper.Setup(m => m.Map(bindingModel, It.IsAny <BeerReview>()))
.Returns(expectedReview);
var reviewService = this.MockingKernel.GetMock <IBeerReviewService>();
reviewService.Setup(s => s.CreateReview(It.IsAny <IBeerReview>()))
.Returns(updateResult.Object);
// Act
var result = await sut.Index(bindingModel) as RedirectToRouteResult;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual("My", result.RouteValues["action"]?.ToString());
Assert.AreEqual(null, result.RouteValues["controller"]?.ToString());
}
public async Task Return_CorrectHttpStatusCodeResult_WhenReviewCreationFails()
{
// Arrange
var expectedErrors = new[] { "error1", "error2" };
var updateResult = new Mock <IDataModifiedResult>();
updateResult.Setup(r => r.Errors).Returns(expectedErrors);
// Arrange
var sut = this.MockingKernel.Get <ReviewsController>(AjaxContextName);
var bindingModel = new CreateReviewBindingModel();
var beerReview = new Mock <IBeerReview>();
var expectedReview = new BeerReview();
var mapper = this.MockingKernel.GetMock <IMapper>();
mapper.Setup(m => m.Map(bindingModel, It.IsAny <BeerReview>()))
.Returns(expectedReview);
var reviewService = this.MockingKernel.GetMock <IBeerReviewService>();
reviewService.Setup(r => r.GetById(It.IsAny <int>()))
.Returns(beerReview.Object);
reviewService.Setup(r => r.CreateReview(expectedReview))
.Returns(updateResult.Object);
// Act
var result = await sut.Index(bindingModel) as HttpStatusCodeResult;
// Assert
Assert.IsNotNull(result);
Assert.AreEqual((int)HttpStatusCode.BadRequest, result.StatusCode);
StringAssert.Contains("validation failed", result.StatusDescription);
}
public IActionResult GetBeerReview(int id)
{
BeerReview review = breweryDAO.GetReviewById(id);
if (review == null)
{
return(NotFound());
}
return(new JsonResult(review));
}
public static void AddReview(BeerReview rating)
{
var jsonData = System.IO.File.ReadAllText(FILE_PATH);
var Ratings = JsonConvert.DeserializeObject <List <BeerReview> >(jsonData)
?? new List <BeerReview>();
Ratings.Add(rating);
jsonData = JsonConvert.SerializeObject(Ratings);
System.IO.File.WriteAllText(FILE_PATH, jsonData);
}
private BeerReview RowToObjectReview(SqlDataReader reader)
{
// Create a review
BeerReview review = new BeerReview();
review.Id = Convert.ToInt32(reader["id"]);
review.Review = Convert.ToString(reader["review"]);
review.BeerID = Convert.ToInt32(reader["beerID"]);
review.Rating = Convert.ToInt32(reader["rating"]);
review.BeerName = Convert.ToString(reader["name"]);
return(review);
}
public void CreateOrUpdateReview(BeerReview beerReview)
{
var review = GetReview(beerReview.UserReviewing, beerReview.BeerReviewed);
if (review.Equals(new BeerReview()))
{
CreateReview(beerReview);
}
else
{
UpdateReview(beerReview);
}
}
public IActionResult AddBeerReview([FromBody] BeerReview review)
{
if (ModelState.IsValid)
{
int newId = breweryDAO.AddReview(review);
review = breweryDAO.GetReviewById(newId);
// Return CreatedAtRoute to return 201
return(CreatedAtRoute("GetBeerReview", new { id = newId }, review));
}
else
{
return(new BadRequestObjectResult(ModelState));
}
}
public void Call_RepositoryUpdateMethodOnceWithCorrectParams()
{
var id = this.Fixture.Create <string>();
var review = new BeerReview();
var repository = new Mock <IRepository <BeerReview> >();
repository.Setup(r => r.GetById(id))
.Returns(review);
var reviewService = new BeerReviewService(repository.Object);
reviewService.UpdateReview(review);
repository.Verify(r => r.Update(review), Times.Once);
}
public void ReturnResultFrom_RepositoryGetByIdMethod()
{
var id = this.Fixture.Create <string>();
var expected = new BeerReview();
var repository = new Mock <IRepository <BeerReview> >();
repository.Setup(r => r.GetById(It.IsAny <object>()))
.Returns(expected);
var reviewService = new BeerReviewService(repository.Object);
var actual = reviewService.GetById(id);
Assert.AreSame(expected, actual);
}
private BeerReview GetBeerReviewsFromReader(SqlDataReader reader)
{
BeerReview beerReview = new BeerReview()
{
BeerReviewId = Convert.ToInt32(reader["beerReview_id"]),
UserId = Convert.ToInt32(reader["user_id"]),
BeerId = Convert.ToInt32(reader["beer_id"]),
Title = Convert.ToString(reader["title"]),
BeerRating = Convert.ToInt32(reader["beerRating"]),
Review = Convert.ToString(reader["beerReview"]),
isPrivate = Convert.ToInt32(reader["is_private"])
};
return(beerReview);
}
public void Call_RepositorySaveChangesMethodOnceAndReturnItsValue()
{
var expected = new Mock <IDataModifiedResult>();
var review = new BeerReview();
var repository = new Mock <IRepository <BeerReview> >();
repository.Setup(r => r.SaveChanges())
.Returns(expected.Object);
var reviewService = new BeerReviewService(repository.Object);
var actual = reviewService.UpdateReview(review);
repository.Verify(r => r.SaveChanges(), Times.Once);
Assert.AreSame(expected.Object, actual);
}
public void Setters_ShouldSetUpPropertiesCorrectly()
{
// Arrange
var expectedId = this.Fixture.Create <int>();
var expectedText = this.Fixture.Create <string>();
var isPublic = true;
var expectedDate = DateTime.Now;
// Act
var review = new BeerReview()
{
Id = expectedId,
BeerId = expectedId,
ApplicationUserId = expectedText,
IsDeleted = isPublic,
Overall = expectedId,
Look = expectedId,
Smell = expectedId,
Taste = expectedId,
Description = expectedText,
IsPublic = isPublic,
Place = expectedText,
Beer = null,
CreatedAt = expectedDate,
ModifiedAt = expectedDate,
User = null,
ImgUrl = expectedText
};
// Assert
Assert.AreEqual(expectedId, review.Id);
Assert.AreEqual(expectedId, review.Overall);
Assert.AreEqual(expectedId, review.Look);
Assert.AreEqual(expectedId, review.BeerId);
Assert.AreEqual(expectedId, review.Smell);
Assert.AreEqual(expectedId, review.Taste);
Assert.AreEqual(isPublic, review.IsPublic);
Assert.AreEqual(isPublic, review.IsDeleted);
Assert.AreEqual(expectedText, review.ApplicationUserId);
Assert.AreSame(expectedText, review.Description);
Assert.AreSame(expectedText, review.Place);
Assert.AreSame(expectedText, review.ImgUrl);
Assert.AreSame(null, review.Beer);
Assert.AreSame(null, review.User);
Assert.AreEqual(expectedDate, review.CreatedAt);
Assert.AreEqual(expectedDate, review.ModifiedAt);
}
//Create beer review
public bool CreateBeerReview(BeerReviewCreate model, int beerId)
{
var beerEntity = _context.Beers.Find(beerId);
var entity = new BeerReview()
{
OwnerId = _userId,
Rev = model.Rev,
Rating = model.Rating,
CreatedUtc = DateTimeOffset.Now,
BeerId = beerEntity.BeerId,
Beer = model.Beer
};
_context.BeerReviews.Add(entity);
return(_context.SaveChanges() == 1);
}
public ActionResult Details(int?id)
{
if (id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
BeerReview beerReview = repository.Get(id);
//BeerReview beerReview = db.Reviews.Find(id);
if (beerReview == null)
{
return(HttpNotFound());
}
return(View(beerReview));
}
public ActionResult Edit([Bind(Include = "ReviewId,Aroma,Appearance,Taste,Palate,Overall,ProductId,Text,UserInfoId")] BeerReview beerReview)
{
if (ModelState.IsValid)
{
beerReview.DateTime = DateTime.Now;
repository.Update(beerReview);
repository.Save();
//db.Entry(beerReview).State = EntityState.Modified;
//db.SaveChanges();
//return RedirectToAction("Index");
return(RedirectToAction("Details", "BeerProducts", new { id = beerReview.ProductId }));
}
ViewBag.ProductId = new SelectList(repository.GetProducts(), "ProductId", "Name", beerReview.ProductId);
//ViewBag.ProductId = new SelectList(db.Products, "ProductId", "Name", beerReview.ProductId);
return(View(beerReview));
}
public void Call_RepositoryAddMethodOnceWithCorrectParams()
{
// Arrange
var id = this.Fixture.Create <string>();
var review = new BeerReview();
var repository = new Mock <IEfRepository <BeerReview> >();
repository.Setup(r => r.GetById(id))
.Returns(review);
var reviewService = new BeerReviewService(repository.Object);
// Act
reviewService.CreateReview(review);
// Assert
repository.Verify(r => r.Add(review), Times.Once);
}
private BeerReview RowToBeerReview(SqlDataReader reader)
{
try
{
var br = new BeerReview
{
BeerReviewId = Convert.ToInt32(reader["review_id"]),
ReviewText = Convert.ToString(reader["review_text"]),
DateOfReview = Convert.ToDateTime("review_date"),
UserReviewing = RowToUser(reader)
};
br.SetRaiting(Convert.ToDouble(reader["review_rating"]));
return(br);
}
catch
{
return(new BeerReview());
}
}
public void SetIsDeletedPropertyToTrue()
{
var id = this.Fixture.Create <string>();
var review = new BeerReview
{
IsDeleted = false
};
var repository = new Mock <IRepository <BeerReview> >();
repository.Setup(r => r.GetById(id))
.Returns(review);
var reviewService = new BeerReviewService(repository.Object);
reviewService.DeleteReview(id);
Assert.IsTrue(review.IsDeleted);
}
protected void InsertButton_OnClick(object sender, EventArgs e)
{
var userId = this.User.Identity.GetUserId();
var review = new BeerReview()
{
BeerId = int.Parse(this.HiddenBeerId.Value),
Place = this.TbPlace.Text,
Description = this.TbDescription.Text,
Overall = int.Parse(this.BeerRatingSelect5.SelectedValue),
Taste = int.Parse(this.BeerRatingSelect6.SelectedValue),
Look = int.Parse(this.BeerRatingSelect7.SelectedValue),
Smell = int.Parse(this.BeerRatingSelect8.SelectedValue),
ApplicationUserId = userId
};
var uploadControl = this.ImageUpload;
byte[] image = null;
if (uploadControl.HasFile)
{
var extension = Path.GetExtension(uploadControl.PostedFile.FileName).ToLower();
if (extension != ".jpg" && extension != ".jpeg" && extension != ".png" && extension != ".gif" && extension != ".psd")
{
this.ErrorMessageText = "The uploaded file is not a valid image!";
this.ErrorMessageVisible = true;
return;
}
if (uploadControl.PostedFile.ContentLength >= 4193280)
{
this.ErrorMessageText = "Your image must be less than 4MB!";
this.ErrorMessageVisible = true;
return;
}
image = uploadControl.FileBytes;
}
var args = this.EventArgsFactory.CreateBeerReviewInfoEventArgs(review, image);
this.OnCreateReview?.Invoke(this, args);
}
public ActionResult Create([Bind(Include = "ReviewId,Aroma,Appearance,Taste,Palate,Overall,ProductId,Text")] BeerReview beerReview, string returnUrl)
{
if (ModelState.IsValid)
{
beerReview.UserInfoId = User.Identity.GetUserId();
beerReview.DateTime = DateTime.Now;
repository.Add(beerReview);
repository.Save();
//db.Reviews.Add(beerReview);
//db.SaveChanges();
//return RedirectToAction("Index");
return(Redirect(returnUrl));
}
//ViewBag.ProductId = new SelectList(db.Products, "ProductId", "Name", beerReview.ProductId);
ViewBag.ProductId = beerReview.ProductId;
return(View(beerReview));
}
