public HttpResponseMessage GettById(HttpRequestMessage request, int id)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = request.CreateErrorResponse(HttpStatusCode.NotFound, "No item found");
var productReview = _productService.GetProductReviewById(id);
if (productReview != null)
{
if (_baseService.WorkContext.CurrentVendor != null && productReview.Product.VendorId != _baseService.WorkContext.CurrentVendor.Id)
{
response = request.CreateErrorResponse(HttpStatusCode.NotFound, "A vendor should only edit his products reviews");
}
else
{
var model = new ProductReviewVM();
PrepareProductReviewVM(model, productReview, false, false);
response = request.CreateResponse <ProductReviewVM>(HttpStatusCode.OK, model);
//string uri = Url.Link("GetAll", null);
//response.Headers.Location = new Uri(uri);
}
}
return response;
}));
}
public void CreateProductReview(ProductReviewVM vm, EventHandler <RestClientEventArgs <ProductReview> > callback)
{
string relativeUrl = "/MKTService/CommentInfo/CreateProductReview";
var model = vm.ConvertVM <ProductReviewVM, ProductReview>();
restClient.Create <ProductReview>(relativeUrl, model, callback);
}
/// <summary>
/// Adds a review document to the Collection.
/// </summary>
public async Task WriteReviewToDatabase(ProductReviewVM review)
{
ProductReview model = new ProductReview();
model.DocType = Constants.DOCTYPE_REVIEW;
model.PartitionKey = "review-" + review.ProductId;
model.Rating = review.Rating;
model.Review = review.Review;
model.ReviewerName = review.ReviewerName;
model.ProductId = review.ProductId;
//we'll have the document that was just inserted returned so that we can
//get the new id.
model = (ProductReview)(dynamic)await _repository.CreateDocumentAsync(model);
//next, check to see if there is already a first review for the
//product. If not, update the product document to include
//this new review.
Product p = await _repository.GetProductById(review.ProductId);
if (p.FirstReview == null)
{
p.FirstReview = model;
await _repository.UpdateItemAsync(p.Id, Constants.PARTITIONKEY_PRODUCT, p);
}
}
public HttpResponseMessage GetBySearchCriteria(HttpRequestMessage request, bool?approved, string reviewText, int storeId, int productId, int vendorId = 0, DateTime?createdOnFromValue = null, DateTime?createdToFromValue = null, int pageIndex = 0, int pageSize = int.MaxValue)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = request.CreateErrorResponse(HttpStatusCode.NotFound, "No items found");
var productReviews = _productService.GetAllProductReviews(0, approved, createdOnFromValue, createdToFromValue, reviewText, storeId, productId, vendorId, pageIndex, pageSize);
if (productReviews != null)
{
var gridModel = new DataSourceResult
{
Data = productReviews.Select(x =>
{
var m = new ProductReviewVM();
PrepareProductReviewVM(m, x, false, true);
return m;
}),
Total = productReviews.TotalCount
};
response = request.CreateResponse <DataSourceResult>(HttpStatusCode.OK, gridModel);
}
return response;
}));
}
public ActionResult Save(ProductReviewVM productReviewVM)
{
try
{
Review review = new Review();
review.CustomerReview = productReviewVM.Review.CustomerReview;
review.ProductId = productReviewVM.Product.Id;
var product = db.Products.Find(productReviewVM.Product.Id);
review.Product = product;
int id = productReviewVM.Product.Id;
var user = db.Users.Where(m => m.Email == User.Identity.Name).FirstOrDefault();
review.UserId = user.Id;
review.User = user;
review.ReviewDateTime = DateTime.Now;
db.Reviews.Add(review);
db.SaveChanges();
return(RedirectToAction("Details", "Products", new { id = id }));
}
catch
{
return(View(productReviewVM));
}
}
private ProductVM CopyProductToViewModel(Product p)
{
ProductVM productVm = new ProductVM()
{
Id = p.Id,
ProductName = p.ProductName,
Description = p.Description,
Price = p.Price,
AverageRating = p.AverageRating
};
foreach (ProductAttribute attribute in p.Attributes)
{
productVm.Attributes.Add(new AttributeVM()
{
Attribute = attribute.Attribute,
Value = attribute.Value
});
}
//see if there's a first review. If so, add it.
if (p.FirstReview != null)
{
ProductReviewVM reviewVM = CopyProductReviewToViewModel(p.FirstReview);
productVm.Reviews.Add(reviewVM);
}
return(productVm);
}
public ActionResult Details(int?Id)
{
ProductReviewVM productReviewVM = new ProductReviewVM();
if (Id == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.BadRequest));
}
//Product product = db.Products.Where(x => x.Id == Id).Include(x => x.Reviews).SingleOrDefault();
Product product = db.Products.Where(x => x.Id == Id).SingleOrDefault();
List <Review> reviews = db.Reviews.Where(x => x.ProductId == Id).Include(x => x.User).ToList();
List <Rating> ratings = db.Rating.Where(x => x.ProductId == Id).ToList();
if (User.Identity.IsAuthenticated)
{
var user = db.Users.Where(m => m.Email == User.Identity.Name).FirstOrDefault();
var userRating = db.Rating.Where(x => x.ProductId == Id && x.UserId == user.Id).SingleOrDefault();
if (userRating != null)
{
productReviewVM.userRating = userRating.ProductRating;
}
}
if (ratings.Count != 0)
{
int totalrating = 0;
foreach (var item in ratings)
{
totalrating += item.ProductRating;
}
var averageRating = totalrating / ratings.Count;
string quality;
if (averageRating <= 1.6)
{
quality = "Worst";
}
else if (averageRating > 1.6 && averageRating <= 3.2)
{
quality = "Bad";
}
else if (averageRating > 3.2)
{
quality = "Good";
}
else
{
quality = "Not Yet Rated";
}
ViewBag.quality = quality;
ViewBag.averageRating = averageRating;
}
product.Reviews = reviews;
productReviewVM.Product = product;
return(View(productReviewVM));
}
public async Task <ActionResult <ProductReviewVM> > Post(ProductReviewVM reviewVM)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var data = repository.Add(reviewVM);
return(CreatedAtAction(nameof(data), new { id = data.ID }, data));
}
public async Task <ActionResult> WriteReview(string id)
{
ProductReviewVM reviewVm = new ProductReviewVM();
ProductVM product = await _productService.GetProductById(id);
WriteReviewVM vm = new WriteReviewVM();
vm.Review = reviewVm;
vm.ProductId = id;
vm.ProductName = product.ProductName;
return(View(vm));
}
/// <summary>
/// Retrieves all reviews for a given product.
/// </summary>
public async Task <List <ProductReviewVM> > GetAllReviewsForProduct(string productId)
{
List <ProductReview> allReviews = await _repository.GetReviewsForProduct(productId);
List <ProductReviewVM> allReviewsVM = new List <ProductReviewVM>();
foreach (ProductReview pr in allReviews)
{
ProductReviewVM vm = CopyProductReviewToViewModel(pr);
allReviewsVM.Add(vm);
}
return(allReviewsVM);
}
private ProductReviewVM CopyProductReviewToViewModel(ProductReview pr)
{
ProductReviewVM reviewVm = new ProductReviewVM()
{
Id = pr.Id,
ProductId = pr.ProductId,
ReviewerName = pr.ReviewerName,
Rating = pr.Rating,
Review = pr.Review,
CreatedAt = pr.CreatedAt
};
return(reviewVm);
}
public async Task <ActionResult <ProductReviewVM> > Put(ProductReviewVM reviewVM)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
else
{
var mainData = repository.Get(reviewVM.ID);
if (mainData == null)
{
return(NotFound());
}
var data = repository.Update(reviewVM);
return(data);
}
}
protected virtual void PrepareProductReviewVM(ProductReviewVM model, ProductReview productReview, bool excludeProperties, bool formatReviewAndReplyText)
{
if (model == null)
{
throw new ArgumentNullException("model");
}
if (productReview == null)
{
throw new ArgumentNullException("productReview");
}
model.Id = productReview.Id;
model.StoreName = productReview.Store.Name;
model.ProductId = productReview.ProductId;
model.ProductName = productReview.Product.Name;
model.CustomerId = productReview.CustomerId;
var customer = productReview.Customer;
model.CustomerInfo = customer.IsRegistered() ? customer.Email : _localizationService.GetResource("Admin.Customers.Guest");
model.Rating = productReview.Rating;
model.CreatedOn = _dateTimeHelper.ConvertToUserTime(productReview.CreatedOnUtc, DateTimeKind.Utc);
if (!excludeProperties)
{
model.Title = productReview.Title;
if (formatReviewAndReplyText)
{
model.ReviewText = HtmlHelper.FormatText(productReview.ReviewText, false, true, false, false, false, false);
model.ReplyText = HtmlHelper.FormatText(productReview.ReplyText, false, true, false, false, false, false);
}
else
{
model.ReviewText = productReview.ReviewText;
model.ReplyText = productReview.ReplyText;
}
model.IsApproved = productReview.IsApproved;
}
//a vendor should have access only to his products
model.IsLoggedInAsVendor = _baseService.WorkContext.CurrentVendor != null;
}
public HttpResponseMessage GetAllProductReviews(HttpRequestMessage request)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = request.CreateErrorResponse(HttpStatusCode.NotFound, "No items found");
var productReviews = _productService.GetAllProductReviews(0, (bool?)null);
if (productReviews != null)
{
var gridModel = new DataSourceResult
{
Data = productReviews.Select(x =>
{
var m = new ProductReviewVM();
PrepareProductReviewVM(m, x, false, true);
return m;
}),
Total = productReviews.TotalCount
};
response = request.CreateResponse <DataSourceResult>(HttpStatusCode.OK, gridModel);
}
return response;
}));
}
public HttpResponseMessage Update(HttpRequestMessage request, ProductReviewVM prodReviewVM, bool continueEditing = false)
{
return(CreateHttpResponse(request, () =>
{
HttpResponseMessage response = request.CreateResponse(HttpStatusCode.NotFound);
var productReview = _productService.GetProductReviewById(prodReviewVM.Id);
if (!ModelState.IsValid)
{
var model = new ProductReviewVM();
PrepareProductReviewVM(model, productReview, true, false);
response = request.CreateResponse <ProductReviewVM>(HttpStatusCode.BadRequest, model);
}
else if (productReview != null)
{
if (_baseService.WorkContext.CurrentVendor != null && productReview.Product.VendorId != _baseService.WorkContext.CurrentVendor.Id)
{
response = request.CreateErrorResponse(HttpStatusCode.NotFound, "A vendor should have access only to his products");
}
else
{
var isLoggedInAsVendor = _baseService.WorkContext.CurrentVendor != null;
var previousIsApproved = productReview.IsApproved;
//vendor can edit "Reply text" only
if (!isLoggedInAsVendor)
{
productReview.Title = prodReviewVM.Title;
productReview.ReviewText = prodReviewVM.ReviewText;
productReview.IsApproved = prodReviewVM.IsApproved;
}
productReview.ReplyText = prodReviewVM.ReplyText;
_productService.UpdateProduct(productReview.Product);
//activity log
_customerActivityService.InsertActivity("EditProductReview", _localizationService.GetResource("ActivityLog.EditProductReview"), productReview.Id);
//vendor can edit "Reply text" only
if (!isLoggedInAsVendor)
{
//update product totals
_productService.UpdateProductReviewTotals(productReview.Product);
}
_baseService.Commit();
response = request.CreateResponse <ProductReview>(HttpStatusCode.OK, productReview);
if (continueEditing)
{
// Generate a link to the update item and set the Location header in the response.
string uri = Url.Link("GetProductReviewById", new { id = productReview.Id });
response.Headers.Location = new Uri(uri);
}
//else
//{
// string uri = Url.Link("GetAll",null);
// response.Headers.Location = new Uri(uri);
//}
}
}
return response;
}));
}
