public async Task <ServiceResult> Create(User user, Movie movie, ReviewBindingModel model)
{
var result = new ServiceResult();
var review = new Review
{
Movie = movie,
MovieId = movie.Id,
User = user,
UserId = user.Id,
DateCreated = DateTime.Now
};
Mapper.Map(model, review);
try
{
await this.db.Reviews.AddAsync(review);
await this.db.SaveChangesAsync();
result.Succeeded = true;
}
catch (DbUpdateException ex)
{
result.Succeeded = false;
result.Error = ex.Message;
}
return(result);
}
public async Task <IActionResult> Update(string id, [FromBody] ReviewBindingModel model)
{
if (ModelState.IsValid)
{
var movie = this._movieService.GetMovieById(model.movieId);
var review = this._reviewService.GetReviewById(id);
if (movie == null || review == null)
{
return(NotFound());
}
var user = await this._userManager.FindByNameAsync(User.Identity.Name);
if (review.UserId != user.Id)
{
return(BadRequest());
}
var result = await this._reviewService.Update(review, model);
if (result.Succeeded)
{
return(Ok());
}
}
return(BadRequest());
}
private ReviewBindingModel DummyDataReviewModel()
{
var reviewModel = new ReviewBindingModel
{
Content = "Review ContentReview ContentReview ContentReview ContentReview Content",
Stars = 5,
};
return(reviewModel);
}
public async Task <bool> AddReview(ReviewBindingModel productModel)
{
var review = AutoMapper.Mapper.Map <Review>(productModel);
await this.context.Reviews.AddAsync(review);
var result = await this.context.SaveChangesAsync();
return(result > 0);
}
public async Task <ActionResult> PostReview(ReviewBindingModel reviewBindingModel)
{
var review = _mapper.Map <Review>(reviewBindingModel);
review.Date = DateTime.Now;
_repositoryWrapper.ReviewRepository.Create(review);
_repositoryWrapper.Save();
return(Ok());
}
public async Task <IActionResult> AddReview(ReviewBindingModel reviewBindingModel, int id)
{
if (!this.ModelState.IsValid)
{
return(this.RedirectToAction(nameof(this.Details), new { id }));
}
var userId = this.userManager.GetUserId(this.User);
await this.reviewService.AddAsync <ReviewBindingModel>(reviewBindingModel, id, userId);
return(this.RedirectToAction(nameof(this.Details), new { id }));
}
public async Task <ActionResult <Review> > PostReview([FromForm] ReviewBindingModel reviewBindingModel)
{
try
{
var review = _mapper.Map <Review>(reviewBindingModel);
_context.Reviews.Add(review);
await _context.SaveChangesAsync();
return(CreatedAtAction(nameof(GetReviews), new { id = review.ReviewId }, review));
}
catch (Exception ex)
{
}
return(BadRequest());
}
public ReviewBindingModel GetReviewBindingModelWithCourseId(int courseId, string userId)
{
var isValid = this.db.Courses.Any(x => x.Id == courseId && x.InstructorId == userId);
var existReview = this.db.Reviews.Any(x => x.CourseId == courseId);
if (!isValid || existReview)
{
return(null);
}
var model = new ReviewBindingModel
{
CourseId = courseId
};
return(model);
}
public IHttpActionResult SubmitStoreReview(ReviewBindingModel model)
{
try
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
using (DunkeyContext ctx = new DunkeyContext())
{
if (ctx.StoreRatings.Any(x => x.User_Id == model.User_Id && x.Store_Id == model.Store_Id))
{
return(Content(HttpStatusCode.OK, new CustomResponse <Error>
{
Message = "Forbidden",
StatusCode = (int)HttpStatusCode.Forbidden,
Result = new Error {
ErrorMessage = "User already reviews this store."
}
}));
}
else
{
var storeRating = new StoreRatings {
User_Id = model.User_Id, Rating = model.Rating, Store_Id = model.Store_Id, Feedback = model.Feedback
};
ctx.StoreRatings.Add(storeRating);
ctx.SaveChanges();
var latestStoreRating = ctx.StoreRatings.Include(z => z.User).FirstOrDefault(x => x.Id == storeRating.Id);
CustomResponse <StoreRatings> response = new CustomResponse <StoreRatings>
{
Message = Global.SuccessMessage,
StatusCode = (int)HttpStatusCode.OK,
Result = storeRating
};
return(Ok(response));
}
}
}
catch (Exception ex)
{
return(StatusCode(DunkeyDelivery.Utility.LogError(ex)));
}
}
public async Task <ServiceResult> Update(Review review, ReviewBindingModel model)
{
var result = new ServiceResult();
Mapper.Map(model, review);
try
{
await this.db.SaveChangesAsync();
result.Succeeded = true;
}
catch (DbUpdateException ex)
{
result.Succeeded = false;
result.Error = ex.Message;
}
return(result);
}
public async Task <ReviewViewModel> Update(long id, ReviewBindingModel review)
{
using (var ctx = new CMMIContext())
{
var entity = await ctx.Reviews.FindAsync(id);
if (entity == null)
{
throw new NotFoundException("Review not found.");
}
entity.Rating = review.Rating;
entity.Comment = review.Comment;
await ctx.SaveChangesAsync();
await UpdateRestaurantReviewDetails(ctx, entity.Restaurant);
return(new ReviewViewModel(entity));
}
}
public async Task <ReviewViewModel> Create(long restaurantId, ReviewBindingModel review)
{
using (var ctx = new CMMIContext())
{
var entity = ctx.Reviews.Create();
entity.UserGuid = CurrentUserGuid;
entity.RestaurantId = restaurantId;
entity.Rating = review.Rating;
entity.Comment = review.Comment;
entity.CreateDate = DateTime.Now;
ctx.Reviews.Add(entity);
await ctx.SaveChangesAsync();
await UpdateRestaurantReviewDetails(ctx, entity.Restaurant);
return(new ReviewViewModel(entity));
}
}
public ActionResult Add(int id, ReviewBindingModel reviewModel)
{
var game = this.Data.Games.Find(id);
if (game == null)
{
return(this.HttpNotFound("The requested game was not found in the system."));
}
var currentUser = this.Data.Users.Find(this.User.Identity.GetUserId());
var review = new Review()
{
Content = reviewModel.Content, Game = game, Author = currentUser, CreationTime = DateTime.Now
};
game.Reviews.Add(review);
this.Data.SaveChanges();
var model = Mapper.Map <ConciseReviewViewModel>(review);
return(this.PartialView("_Review", model));
}
public ActionResult Add(int id, ReviewBindingModel reviewModel)
{
var motorcycle = this.Data.Motorcycles.Find(id);
var currentUser = this.Data.Users.Find(this.User.Identity.GetUserId());
var review = new Review()
{
Content = reviewModel.Content, Motorcycle = motorcycle, Author = currentUser, CreationTime = DateTime.Now
};
motorcycle.Reviews.Add(review);
this.Data.SaveChanges();
var vm = this.service.GetConciseReviewViewModel(review);
if (vm == null)
{
return(new HttpStatusCodeResult(HttpStatusCode.NotFound));
}
Response.StatusCode = 200;
return(this.PartialView("_Review", vm));
}
public async Task <IActionResult> Create([FromBody] ReviewBindingModel model)
{
if (ModelState.IsValid)
{
var movie = this._movieService.GetMovieById(model.movieId);
if (movie == null)
{
return(NotFound());
}
var user = await this._userManager.FindByNameAsync(User.Identity.Name);
var result = await this._reviewService.Create(user, movie, model);
if (result.Succeeded)
{
return(CreatedAtRoute("GetUser", model));
}
}
return(BadRequest());
}
public async Task AddReview_WithCorrectData_ShouldCreateSuccessfully()
{
string onFalseErrorMessage = "The method returned false on valid creation model.";
string onNullErrorMessage = "The review was not added to the database.";
var context = ApplicationDbContextInMemoryFactory.InitializeContext();
var reviewService = new ReviewService(context);
ReviewBindingModel model = new ReviewBindingModel
{
ClientFullName = "TestClient",
Comment = "TestComment",
Rating = 5,
};
var methodResult = await reviewService.AddReview(model);
Assert.True(methodResult, onFalseErrorMessage);
var reviewExists = context.Reviews.FirstOrDefaultAsync(x => x.ClientFullName == model.ClientFullName);
AssertExtensions.NotNullWithMessage(reviewExists, onNullErrorMessage);
}
public ActionResult Create(ReviewBindingModel review)
{
var game = this.Data.Games.Find(review.GamePublicationId);
if (game == null)
{
return(this.HttpNotFound("Game does not exist"));
}
var newReview = new Review()
{
Content = review.Content,
AuthorId = this.UserProfile.Id,
CreationTime = DateTime.Now,
GameId = game.Id
};
this.Data.Reviews.Add(newReview);
this.Data.SaveChanges();
var modelReview = Mapper.Map <ReviewModel>(newReview);
return(this.PartialView("DisplayTemplates/ReviewModel", modelReview));
}
public IHttpActionResult AddReview(ReviewBindingModel reviewModel)
{
if (reviewModel == null)
{
return(this.BadRequest("Missing review data"));
}
if (!this.ModelState.IsValid)
{
return(this.BadRequest(this.ModelState));
}
var currentUserId = this.User.Identity.GetUserId();
if (!this.EscortServiceData.Customers.Any(c => c.Id == currentUserId))
{
return(this.Content(HttpStatusCode.Unauthorized, new
{
Message = "User " + this.User.Identity.GetUserName() + " is not customer"
}));
}
var escortId =
this.EscortServiceData.Escorts.Where(c => c.UserName == reviewModel.EscortName).Select(c => c.Id).FirstOrDefault();
if (escortId == null)
{
return(this.Content(HttpStatusCode.NotFound, new
{
Message = "Escort " + reviewModel.EscortName + " does not exist."
}));
}
var lastReview = this.EscortServiceData.Reviews
.Where(r => r.AuthorId == currentUserId && r.EscortId == escortId)
.OrderByDescending(r => r.Date)
.FirstOrDefault();
if (lastReview != null)
{
var dateTiemDiff = (DateTime.Now - lastReview.Date).TotalHours;
if (dateTiemDiff < 2.0)
{
return(this.BadRequest(String.Format("You have given revie for escort: {0} just before {1:F0} minutes.",
reviewModel.EscortName, dateTiemDiff * 60 < 1 ? 1 : dateTiemDiff * 60)));
}
}
Review newReview = new Review()
{
Content = reviewModel.Content,
Date = DateTime.Now,
Rating = reviewModel.Rating,
AuthorId = currentUserId,
EscortId = escortId,
};
this.EscortServiceData.Reviews.Add(newReview);
this.EscortServiceData.SaveChanges();
return
(this.Ok(String.Format(
"Review for escort: {0} created from customer: {1}", reviewModel.EscortName, this.User.Identity.GetUserName())));
}
public async Task <IActionResult> AddReview(ReviewBindingModel productModel)
{
await this.reviewService.AddReview(productModel);
return(this.RedirectToAction("Details", new { id = productModel.ProductId }));
}
public IHttpActionResult AddReview(ReviewBindingModel reviewModel)
{
if (reviewModel == null)
{
return this.BadRequest("Missing review data");
}
if (!this.ModelState.IsValid)
{
return this.BadRequest(this.ModelState);
}
var currentUserId = this.User.Identity.GetUserId();
if (!this.EscortServiceData.Customers.Any(c => c.Id == currentUserId))
{
return this.Content(HttpStatusCode.Unauthorized, new
{
Message = "User " + this.User.Identity.GetUserName() + " is not customer"
});
}
var escortId =
this.EscortServiceData.Escorts.Where(c => c.UserName == reviewModel.EscortName).Select(c => c.Id).FirstOrDefault();
if (escortId == null)
{
return this.Content(HttpStatusCode.NotFound, new
{
Message = "Escort " + reviewModel.EscortName + " does not exist."
});
}
var lastReview = this.EscortServiceData.Reviews
.Where(r => r.AuthorId == currentUserId && r.EscortId == escortId)
.OrderByDescending(r => r.Date)
.FirstOrDefault();
if (lastReview != null)
{
var dateTiemDiff = (DateTime.Now - lastReview.Date).TotalHours;
if (dateTiemDiff < 2.0)
{
return this.BadRequest(String.Format("You have given revie for escort: {0} just before {1:F0} minutes.",
reviewModel.EscortName, dateTiemDiff * 60 < 1 ? 1 : dateTiemDiff * 60));
}
}
Review newReview = new Review()
{
Content = reviewModel.Content,
Date = DateTime.Now,
Rating = reviewModel.Rating,
AuthorId = currentUserId,
EscortId = escortId,
};
this.EscortServiceData.Reviews.Add(newReview);
this.EscortServiceData.SaveChanges();
return
this.Ok(String.Format(
"Review for escort: {0} created from customer: {1}", reviewModel.EscortName, this.User.Identity.GetUserName()));
}
public ActionResult AddReview(ReviewBindingModel model)
{
if (model == null || !this.ModelState.IsValid)
{
return this.View("Error");
}
var loggedUserId = this.User.Identity.GetUserId();
var loggedUser = this.Data.Users.Find(loggedUserId);
var game = this.Data.Games.Find(model.GameId);
if (game == null)
{
return this.View("Error");
}
var newReview = new Review
{
Author = loggedUser,
AuthorId = loggedUserId,
Content = model.Content,
CreationTime = DateTime.Now,
GameId= model.GameId,
Game = game
};
this.Data.Reviews.Add(newReview);
this.Data.SaveChanges();
return RedirectToAction("Details", "Games", routeValues: new { gameTitle = game.Title });
}
// PUT: api/Reviews/5
public async Task <IHttpActionResult> Put(ApiId reviewId, [FromBody] ReviewBindingModel review)
{
var result = await _reviews.Update(reviewId, review);
return(Ok(result));
}
// POST: api/Reviews
public async Task <IHttpActionResult> Post(ApiId restaurantId, [FromBody] ReviewBindingModel review)
{
var created = await _reviews.Create(restaurantId, review);
return(Created("api/reviews/" + created.Id, created));
}
