public ActionResult Edit(int num_no, Models.Review model)
{
ViewBag.Review = db.Reviews.Find(num_no).review_comment.ToString();
SqlConnection cnn = new SqlConnection("data source=DESKTOP-CI6H5AL;initial catalog=ECommerce;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework");
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = cnn;
cmd.CommandType = CommandType.Text;
cmd.Parameters.Add(new SqlParameter("@rating", model.review_rating));
cmd.Parameters.Add(new SqlParameter("@comment", model.review_comment));
cmd.Parameters.Add(new SqlParameter("@no", num_no));
//add any parameters the stored procedure might require
try
{
cmd.CommandText = "UPDATE Product SET review_rating = @rating" +
", review_comment = @comment" +
"WHERE review_no = @no";
cnn.Open();
object o = cmd.ExecuteScalar();
cnn.Close();
}
catch
{
ModelState.AddModelError("", "Error");
}
}
return(View());
}
public static Models.Resturant DataToModel(DataLayer.Resturant data)
{
Models.Resturant r = new Models.Resturant();
r.rs_id = data.rs_id;
r.Name = data.Name;
r.Address = data.Address;
r.City = data.City;
r.State = data.State;
r.FoodType = data.FoodType;
r.Reviews = new List <Models.Review>();
foreach (var rev in data.Reviews)
{
var tmp = new Models.Review
{
rv_id = rev.rv_id,
Author = rev.Author,
Rating = rev.Rating,
Comment = rev.Comment
};
r.Reviews.Add(tmp);
}
return(r);
}
public async Task <IActionResult> Update([Bind("ID, Name, NoodleId")] Models.Review review)
{
_context.Reviews.Update(review);
await _context.SaveChangesAsync();
return(RedirectToAction("ViewAll", "Review"));
}
public ActionResult Insert(Models.Review model)
{
SqlConnection cnn = new SqlConnection("data source=DESKTOP-CI6H5AL;initial catalog=ECommerce;integrated security=True;MultipleActiveResultSets=True;App=EntityFramework");
using (SqlCommand cmd = new SqlCommand())
{
cmd.Connection = cnn;
cmd.CommandType = CommandType.StoredProcedure;
cmd.CommandText = "dbo.add_review";
//add any parameters the stored procedure might require
try
{
cmd.Parameters.Add(new SqlParameter("@review_rating_add", model.review_rating));
cmd.Parameters.Add(new SqlParameter("@review_comment_add", model.review_comment));
cmd.Parameters.Add(new SqlParameter("@review_picture_add", model.review_picture));
cmd.Parameters.Add(new SqlParameter("@review_customer_mail_add", model.review_customer_mail));
cmd.Parameters.Add(new SqlParameter("@review_product_id_add", model.review_product_id));
cnn.Open();
object o = cmd.ExecuteScalar();
cnn.Close();
}
catch { }
}
return(View());
}
public ActionResult Edit(int id, FormCollection collection)
{
try
{
if (ModelState.IsValid)
{
Models.Review temp = new Models.Review
{
Id = id,
Comment = collection["Comment"],
Rating = double.Parse(collection["Rating"]),
RestaurantId = int.Parse(collection["RestaurantId"])
};
da.UpdateReview(temp);
return(RedirectToAction("Details", new { id = temp.RestaurantId }));
}
return(View());
}
catch
{
return(View());
}
}
public async Task <IActionResult> EditReview(int id, [Bind("Id,PlaId,Comment,Date")] Models.Review review)
{
// check the rigth review
if (id != review.Id)
{
return(RedirectToAction(nameof(Index)));
}
// check new review valid
if (ModelState.IsValid)
{
var foundReview = await _context.Reviews.FirstOrDefaultAsync(x => x.Id == review.Id);
try
{ //update review
foundReview.Comment = review.Comment;
_context.Update(foundReview);
await _context.SaveChangesAsync();
}
catch (DbUpdateConcurrencyException)
{
// check if the review exists
if (!ReviewExists(review.Id))
{
return(NotFound());
}
else
{
throw;
}
}
return(RedirectToAction(nameof(Index)));
}
return(View(review));
}
protected async void LoadDataReviewByDate()
{
try
{
IsBusy = true;
if (this.IsInternetAndCloseModal())
{
_currentReview = await _reviewModule.ReviewService.GetReview(MyItemYearPicker.Value, MyItemMonthPicker.Value);
BtnSendReviewIsVisible = !(_currentReview.IsValidated || _currentReview.IsClosed);
ImputedTotal = _currentReview.Activities.Sum(x => x.Value.Imputed);
DeviationTotal = _currentReview.Activities.Sum(x => x.Value.Deviation);
TimeLineList = await _reviewModule.TimeLineService.GetListTimesheetForDay(_currentReview);
var listTemp = new ObservableCollection <ReviewTimeLine>();
TimeLineList.ForEach(x => listTemp.Add(ReviewTimeLine.Map(x)));
listTemp.Last().IsLast = true;
LstReview = listTemp;
IsBusy = false;
}
}
catch (Exception ex)
{
IsBusy = false;
BaseModule.DialogErrorCustomService.DialogErrorCommonTryAgain();
Crashes.TrackError(ex);
}
}
public IActionResult Create(int rating, string details, int productId, int?orderId)
{
if (!ModelState.IsValid)
{
return(View());
}
Models.Review review = new Models.Review(productId, Request.Cookies["firstname"], rating, details, DateTime.Now);
string customerId = Request.Cookies["customerId"];
review.CustomerId = customerId;
Products p = db.Products.FirstOrDefault(p => p.ProductId == productId);
if (orderId == null)
{
Models.Order OrderwithProduct = db.Order
.FirstOrDefault(o => o.CustomerId == customerId && o.OrderDetails.Any(d => d.ProductId == p.ProductId && d.reviewed != true) == true);
review.OrderId = OrderwithProduct.OrderId;
}
else
{
review.OrderId = (int)orderId;
}
db.OrderDetails.FirstOrDefault(o => o.OrderId == review.OrderId && o.ProductId == productId).reviewed = true;
db.Reviews.Add(review);
db.SaveChanges();
return(RedirectToAction("ProductDetailPage", "Gallery", new { id = productId }));
}
private Domain.Review WithDetails(Models.Review model)
{
var dModel = model.ToModel();
var user = _authContext.Users.FirstOrDefault(it => it.Id == model.UserId.ToString());
dModel.User = user.ToModel();
return(dModel);
}
public static Models.Review DataToModel(DataLayer.Review model)
{
Models.Review r = new Models.Review();
r.rv_id = model.rv_id;
r.rs_id = model.rs_id;
r.Author = model.Author;
r.Rating = model.Rating;
r.Comment = model.Comment;
return(r);
}
public async Task <IActionResult> CreateProductReview(int productId, [FromBody] Models.Review request)
{
var review = _mapper.Map <Service.Models.Review>(request);
await _mediator.Send(new CreateReviewCommand()
{
Review = review, ProductId = productId
});
return(Ok());
}
// Create a review
public IActionResult CreateReview(int id)
{
// create instance of review
Models.Review review = new Models.Review()
{
PlayId = id
};
ViewData["Id"] = id;
return(View(review));
}
public static int GetReviewViewModel(ApplicationDbContext context, ReviewCreateViewModel reviewCreateViewModel)
{
Models.Review review = new Models.Review();
review.LocationID = reviewCreateViewModel.LocationID;
review.Rating = reviewCreateViewModel.Rating;
review.Comment = reviewCreateViewModel.Comment;
context.Add(review);
context.SaveChanges();
return(review.Id);
}
private void showButton(Models.Review currentReview)
{
if (currentReview == null)
{
btnUpdate.Visible = false;
btnDelete.Visible = false;
}
else
{
btnRate.Visible = false;
}
}
protected void btnDelete_Click(object sender, EventArgs e)
{
string token = Request.QueryString["Token"];
Models.Review review = ReviewController.GetReviewByToken(token);
if (review != null)
{
ReviewController.DeleteReview(review.Id);
lblError.Text = "";
Response.Redirect("ReviewPage.aspx?Token=" + token);
}
}
private void GetFullEntity(ref Models.Review entity)
{
try
{
var productId = (int)(entity.ProductId);
entity.Product = (new RestfulModels.RestfulProduct()).Read(productId);
}
catch
{
;
}
}
public static bool Pass(byte action, Models.Review Review, string accessor = null)
{
try
{
if (action == RestfulAction.Create)
{
if (!string.IsNullOrEmpty(accessor) && (new AccountMembershipService()).Exist(accessor))
{
return(true);
}
else
{
return(false);
}
}
else if (action == RestfulAction.Read)
{
return(true);
}
else if (action == RestfulAction.Update)
{
if (!string.IsNullOrEmpty(accessor) && Review.Creator == accessor)
{
return(true);
}
else
{
return(false);
}
}
else if (action == RestfulAction.Delete)
{
if (!string.IsNullOrEmpty(accessor) && Review.Creator == accessor)
{
return(true);
}
else
{
return(false);
}
}
else
{
return(false);
}
}
catch
{
return(false);
}
}
public ActionResult AddReview(Models.Review review)
{
try
{
bl.addReview(review);
Response.Redirect("~/Home/Details/" + review.rs_id);
}
catch (Exception ex)
{
logger.LogException(NLog.LogLevel.Error, "Controller: Function: AddReview: " + ex.Message, ex);
return(View());
}
return(View());
}
public static Models.Review ValidationAndProcess(Models.Review data)
{
try
{
ValidationException validationException = new ValidationException();
data.Type = Models.ReviewType.Review;
try
{
if (data.ProductId == null || (data.ProductId < 1) || (new RestfulModels.Product()).Read((int)data.ProductId) == null)
{
validationException.ValidationErrors.Add("HIT产品为空");
}
}
catch
{
validationException.ValidationErrors.Add("HIT产品为空");
}
if (data.Rate == null || data.Rate < 1 || data.Rate > 5)
{
validationException.ValidationErrors.Add("无效的评分");
}
if (string.IsNullOrEmpty(data.Details))
{
validationException.ValidationErrors.Add("评价内容为空");
}
//created
if (data.Created == null)
{
data.Created = DateTime.Now;
}
if (validationException.ValidationErrors.Count() > 0)
{
throw validationException;
}
else
{
return(data);
}
}
catch
{
throw;
}
}
public Models.Review Create(Models.Review entity)
{
try
{
entity = ReviewDataProccessor.ValidationAndProcess(entity);
DbEntities.Reviews.AddObject(entity);
DbEntities.SaveChanges();
DbEntities.Refresh(System.Data.Objects.RefreshMode.StoreWins, entity);
try
{
if (!string.IsNullOrEmpty(entity.RatedAspects))
{
string[] aspects = Utilities.StringUtility.DeGroup(entity.RatedAspects, ';');
for (int i = 0; i < aspects.Count(); i++)
{
string[] aspectData = Utilities.StringUtility.DeGroup(aspects[i], '|');
Models.Aspect theAspect = (new RestfulModels.Aspect()).Read(int.Parse(aspectData[0]), entity.Creator);
theAspect.RatedTimes++;
(new RestfulModels.Aspect()).Update(theAspect.Id, theAspect, theAspect.Creator);
(new RestfulModels.Rate()).Create(new Models.Rate()
{
ReviewId = entity.Id,
AspectId = theAspect.Id,
AspectTitle = theAspect.Title,
Stars = int.Parse(aspectData[2]),
Creator = entity.Creator,
Created = entity.Created
},
entity.Creator
);
}
}
}
catch
{
;
}
return(Read(entity.Id));
}
catch
{
throw;
}
}
public async Task <IActionResult> OnGetAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
Review = await _context.Reviews.FirstOrDefaultAsync(m => m.Id == id);
if (Review == null)
{
return(NotFound());
}
return(Page());
}
private void showRating(Models.Review currentReview)
{
if (currentReview != null)
{
string s_rating = currentReview.Rating.ToString();
string description = currentReview.Description;
lblRatingContain.Text = string.Concat(lblRatingContain.Text, s_rating);
lblDescriptionContain.Text = string.Concat(lblDescriptionContain.Text, description);
}
else
{
lblRatingContain.Visible = false;
lblDescriptionContain.Visible = false;
}
}
/// <summary>
/// Add a review, and optionally associate it with a restaurant.
/// </summary>
/// <param name="review">The review</param>
/// <param name="restaurant">The restaurant (or null if none)</param>
public void AddReview(Models.Review review, Models.Restaurant restaurant)
{
if (restaurant != null)
{
// get the db's version of that restaurant
// (can't use Find with Include)
var contextRestaurant = _db.Restaurant.Include(r => r.Review).First(r => r.Id == restaurant.Id);
restaurant.Reviews.Add(review);
contextRestaurant.Review.Add(Mapper.Map(review));
}
else
{
_db.Add(Mapper.Map(review));
}
}
public async Task AddReview(Review review)
{
Models.Review dbReview = new Models.Review
{
Name = review.Name,
Email = review.Email,
Description = review.Description,
Rating = review.Rating,
RecipeId = review.RecipeId,
CreatedDate = DateTime.Now,
Type = 1
};
await repo.AddReview(dbReview);
}
public static object Single(Models.Review data, string userName)
{
if (data.Type == Models.ReviewType.Review)
{
return(Review.Single(data, userName));
}
else if (data.Type == Models.ReviewType.News)
{
return(News.Single(data, userName));
}
else
{
return(null);
}
}
public static object MiniSingle(Models.Review data)
{
try
{
return(new
{
Id = data.Id,
Title = data.Creator + "@" + data.Product.Title + " " + data.Product.Version + "(" + data.Product.Vendor.Title + ")"
});
}
catch
{
return(null);
}
}
public ActionResult DeleteReview(Models.Review review)
{
ViewBag.id = review.rs_id;
try
{
bl.deleteReview(review);
Response.Redirect("~/Home/Details/" + review.rs_id);
}
catch (Exception ex)
{
//NLog goes here
logger.LogException(NLog.LogLevel.Error, "Controller: Function: DeleteReview: " + ex.Message, ex);
return(View());
}
return(View());
}
public static IList <RestfulJsonProccessor.RestfulOption> ControlProcess(Models.Review data, string userName)
{
try
{
if (userName == data.Creator)
{
var options = new List <RestfulJsonProccessor.RestfulOption>();
options.Add(
new RestfulJsonProccessor.RestfulOption()
{
Object = "Review",
ObjectId = data.Id,
ActionId = "Edit_Review",
ActionName = "修改",
ActionDefinition = "修改产品评价",
ActionType = Models.RestfulAction.Update,
HttpMethod = "PUT",
Uri = Models.ApplicationConfig.Domain + "Api/Review/" + data.Id
}
);
options.Add(
new RestfulJsonProccessor.RestfulOption()
{
Object = "Review",
ObjectId = data.Id,
ActionId = "Delete_Review",
ActionName = "删除",
ActionDefinition = "删除产品评价",
ActionType = Models.RestfulAction.Delete,
HttpMethod = "DELETE",
Uri = Models.ApplicationConfig.Domain + "Api/Review/" + data.Id
}
);
return(options);
}
else
{
return(null);
}
}
catch {
return(null);
}
}
public Models.Review Create(Models.Review entity)
{
try
{
entity = NewsDataProccessor.ValidationAndProcess(entity);
DbEntities.Reviews.AddObject(entity);
DbEntities.SaveChanges();
DbEntities.Refresh(System.Data.Objects.RefreshMode.StoreWins, entity);
return(Read(entity.Id));
}
catch
{
throw;
}
}
public async Task <IActionResult> OnPostAsync(int?id)
{
if (id == null)
{
return(NotFound());
}
Review = await _context.Reviews.FindAsync(id);
if (Review != null)
{
_context.Reviews.Remove(Review);
await _context.SaveChangesAsync();
}
return(RedirectToPage("./Index"));
}