public ActionResult Create(CreateReviewViewModel reviewVM) { if (ModelState.IsValid) { var review = new Review { BodyText = reviewVM.BodyText, ReactionLink = reviewVM.ReactionLink, userID = reviewVM.userID, videoID = reviewVM.videoID }; var emojiList = new List <ReactionEmoji>(); foreach (var emojiID in reviewVM.ReactionEmojiIDs) { var emoji = db.ReactionEmojis.Find(emojiID); emojiList.Add(emoji); } review.ReactionEmojis = emojiList; db.Reviews.Add(review); db.SaveChanges(); return(RedirectToAction("Details", "Videos", new { id = review.videoID })); } ViewBag.allEmojis = db.ReactionEmojis.ToList(); //ViewBag.userID = new SelectList(db.UserDatas, "ID", "DisplayName", review.userID); //ViewBag.videoID = new SelectList(db.Videos, "ID", "youtubeLinkAPI", review.videoID); return(View(reviewVM)); }
public async Task <IActionResult> Create(CreateReviewViewModel model) { if (!this.User.IsAdmin() && !this.User.IsReviewer()) { this.TempData.AddErrorMessage(WebConstants.NoPrivillegesMessage); return(this.RedirectBack()); } var product = this.productsData.GetById(model.Review.ProductId); if (product == null) { this.TempData.AddErrorMessage("The product does not exist!"); return(this.RedirectBack()); } if (!this.ModelState.IsValid) { return(this.View(model)); } await this.reviewsData.CreateAsync( model.Review.ProductId, model.Review.Title, model.Review.Content, model.Review.Score, this.User.GetId()); this.TempData.AddSuccessMessage($"Successfully added review for the product {model.Product.Name}"); return(this.RedirectToAction("Details", "Products", new { id = model.Review.ProductId, area = "Products" })); }
public ActionResult AddReview(int id) { var thesis = this.Data.Theses.GetById(id); var userId = this.User.Identity.GetUserId(); if (this.IsThesisTeacher(userId, thesis) && thesis.Evaluation == null) { var newReview = new CreateReviewViewModel { Id = id }; var reviewers = this.Data.Teachers.All() .OrderBy(t => t.User.FirstName) .ThenBy(t => t.User.LastName) .AsQueryable() .Project() .To <SupervisorDropDownListITemViewModel>() .ToList(); ViewBag.ReviewerId = new SelectList(reviewers, "Id", "FullName"); return(View(newReview)); } return(RedirectToAction("Index", "Storage")); }
public async Task <IActionResult> Edit(int id, int albumID, CreateReviewViewModel viewModel) { if (id != viewModel.Review.ReviewID) { return(NotFound()); } if (ModelState.IsValid) { try { _context.Update(viewModel.Review); await _context.SaveChangesAsync(); } catch (DbUpdateConcurrencyException) { if (!ReviewExists(viewModel.Review.ReviewID)) { return(NotFound()); } else { throw; } } return(RedirectToAction(nameof(Details), "Album", new { id = albumID })); } return(View(viewModel.Review)); }
public async Task Create(CreateReviewViewModel model) { var reviewLink = await _dbContext.ReviewLinks.FirstOrDefaultAsync(rl => rl.Link == model.Link); if (reviewLink != null) { _dbContext.ReviewLinks.Remove(reviewLink); await _dbContext.SaveChangesAsync(); var review = new Review { Author = reviewLink.Author, Content = model.Content, CourierId = Convert.ToInt32(model.Link.Substring(model.Link.Length - 1)), Mark = model.Mark }; await _dbContext.Reviews.AddAsync(review); await _dbContext.SaveChangesAsync(); } else { //error } }
public ActionResult Create(CreateReviewViewModel viewModel) { if (!ModelState.IsValid) { return(View(viewModel)); } switch (viewModel.ReviewType) { case ReviewType.Film: ReviewService.CreateReviewForFilm(viewModel, this.User.Identity.GetUserId()); return(RedirectToAction("Details", "Films", new { mediaId = viewModel.MediaId })); case ReviewType.Show: ReviewService.CreateReviewForShow(viewModel, this.User.Identity.GetUserId()); return(RedirectToAction("Details", "Shows", new { mediaId = viewModel.MediaId })); case ReviewType.Season: //ReviewService.CreateReviewForSeason(viewModel, this.User.Identity.GetUserId()); break; case ReviewType.Episode: //ReviewService.CreateReviewForEpisode(viewModel, this.User.Identity.GetUserId()); break; default: return(RedirectToAction("MyReviews", "Reviews")); } return(RedirectToAction("MyReviews", "Reviews")); }
public async Task <IActionResult> Create(int productId) { if (!this.User.IsReviewer() && !this.User.IsAdmin()) { this.TempData.AddErrorMessage(WebConstants.NoPrivillegesMessage); return(this.RedirectBack()); } var productExists = await this.productsData.ExistsById(productId); if (!productExists) { this.TempData.AddErrorMessage("The product for which you want to make review does not exist"); return(this.RedirectBack()); } var product = await this.productsData .GetByIdQuery(productId) .ProjectTo <SimpleProductViewModel>() .FirstOrDefaultAsync(); var review = new ReviewViewModel { ProductId = product.Id }; var model = new CreateReviewViewModel { Product = product, Review = review }; return(this.View(model)); }
public async Task <IActionResult> Create(CreateReviewViewModel model) { if (ModelState.IsValid) { try { var createDTO = new NewReviewDTO() { Comment = model.Comment, Score = model.Score, PhotoId = model.PhotoId, WrongCategory = model.WrongCategory }; await this.reviewService.CreateAsync(createDTO); return(RedirectToAction("Index", "Contests")); } catch (Exception e) { toastNotification.AddErrorToastMessage(e.Message, new NotyOptions()); var path = Request.Path.Value.ToString() + "?photoId=" + model.PhotoId; return(Redirect(path)); } } return(View(model)); }
public async Task <ActionResult <Review> > PostReview(CreateReviewViewModel model) { User user = await _context.Users.FindAsync(User.Claims.ToList()[0].Value); if (user == null) { return(Unauthorized()); } Movie movie = _movieRepository.GetMovie(User, model.MovieID); if (movie == null) { return(NotFound("Movie " + model.MovieID + " not found.")); } Review review = new Review { Stars = model.Stars, Comment = model.Comment, MovieID = movie.Id }; _context.Reviews.Add(review); await _context.SaveChangesAsync(); return(CreatedAtAction("GetReview", new { id = review.Id }, review)); }
public async Task VerifyCreatingReviewCallsApiWhenDataIsFilled() { var book = new DetailedBookDto(); var authService = new Mock <IAuthenticationService>(); AccountModel loggedOnUser = new AccountModel(new AuthTokenDto { Person = new PersonDto() }); authService.SetupGet(s => s.LoggedOnAccount).Returns(() => loggedOnUser); var feedbackService = new Mock <IFeedbackService>(); var viewModel = new CreateReviewViewModel(book, authService.Object, feedbackService.Object); await Should.ThrowAsync <InvalidOperationException>(async() => await viewModel.CreateReview()); feedbackService.Verify(s => s.CreateFeedback(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <string>()), Times.Never); viewModel.Rating = 3; await Should.ThrowAsync <InvalidOperationException>(async() => await viewModel.CreateReview()); feedbackService.Verify(s => s.CreateFeedback(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <string>()), Times.Never); viewModel.Message = "Message"; var dto = await viewModel.CreateReview(); feedbackService.Verify(s => s.CreateFeedback(It.IsAny <int>(), It.IsAny <int>(), It.IsAny <string>()), Times.Once); }
private int SaveNewReview(CreateReviewViewModel model) { byte[] byteArray = null; using (var memory = new MemoryStream()) { model.Archive.InputStream.CopyTo(memory); byteArray = memory.GetBuffer(); } var fileName = string.Format(GlobalPatternConstants.VERSION_NAME, DateTime.Now.ToUniversalTime(), model.Archive.FileName); var fullPath = storage.UploadFile(byteArray, fileName, GlobalConstants.STORAGE_FOLDER); var extensionStartIndex = model.Archive.FileName.LastIndexOf('.'); var fileExtension = model.Archive.FileName.Substring(extensionStartIndex + 1, model.Archive.FileName.Length - extensionStartIndex - 1).ToLower(); var review = new Evaluation() { Id = model.Id, FilePath = fullPath, FileName = model.Archive.FileName, FileExtension = fileExtension, ReviewerId = model.ReviewerId, Mark = model.Mark }; this.Data.Evaluations.Add(review); this.Data.SaveChanges(); return(review.Id); }
public async Task VerifyValidCreateCallsApi() { var book = new DetailedBookDto { Id = 5 }; var authService = new Mock <IAuthenticationService>(); AccountModel loggedOnUser = new AccountModel(new AuthTokenDto { Person = new PersonDto() }); authService.SetupGet(s => s.LoggedOnAccount).Returns(() => loggedOnUser); var feedbackService = new Mock <IFeedbackService>(); var viewModel = new CreateReviewViewModel(book, authService.Object, feedbackService.Object) { Message = "test", Rating = 2 }; var feedback = new BookFeedbackDto(); feedbackService.Setup(s => s.CreateFeedback(5, 2, "test")).ReturnsAsync(feedback); var dto = await viewModel.CreateReview(); dto.ShouldBe(feedback); feedbackService.Verify(s => s.CreateFeedback(5, 2, "test"), Times.Once); }
public IActionResult Create(string link) { var model = new CreateReviewViewModel { Link = link }; return(View(model)); }
public async Task <IActionResult> GetCreateReview() { var model = new CreateReviewViewModel(); model.Ratings = (await Services.Reviews.GetRatings()).Value.ToList(); model.Services = (await Services.Reviews.GetServices()).Value.ToList(); return(View("Create", model)); }
public void CreateReviewForShow(CreateReviewViewModel review, string userId) { var newReview = CreateReview(review, userId); FilmHausDbContext.Reviews.Add(newReview); FilmHausDbContext.SaveChanges(); ReviewShowService.CreateReviewShow(newReview.ReviewId, review.MediaId); }
public IActionResult Create(int id) { CreateReviewViewModel viewModel = new CreateReviewViewModel { Review = new Review(), Album = _context.Albums.FirstOrDefault(x => x.AlbumID == id) }; return(View(viewModel)); }
public ActionResult Create(CreateReviewViewModel model) { if (!this.ModelState.IsValid) { return(this.View(model)); } this.reviewService.AddReview(model); return(RedirectToAction("Details", "Item", new { itemId = model.ItemId })); }
public async Task <ActionResult> Create(CreateReviewViewModel content, HttpPostedFileBase uploadImage) { if (ModelState.IsValid) { Review review = new Review { SubjectId = Db.Subjects.Where(s => s.Name.ToLower() == content.Objectname.ToLower()).Select(s => s.SubjectId).FirstOrDefault(), Rating = content.Rating, Recommend = Convert.ToByte(content.Recomendations ? 1 : 0), Exp = Convert.ToByte(content.Experience), Like = content.Like, Dislike = content.Dislike, Content = content.Comment }; Subject subject = Db.Subjects.Where(su => su.SubjectId == review.SubjectId).FirstOrDefault(); if (subject.AverageRating == 0) { subject.AverageRating = (double)content.Rating; } else { double[] rating = Db.Reviews.Where(r => r.SubjectId == review.SubjectId).Select(r => r.Rating).ToArray(); subject.AverageRating = (rating.Sum() + content.Rating) / rating.Count() + 1; } ApplicationUser user = null; if (HttpContext.User.Identity.IsAuthenticated) { user = await UserManager.FindByNameAsync(HttpContext.User.Identity.Name); review.AuthorId = user.Id; } if (uploadImage != null) { byte[] imageData = null; using (var binaryReader = new BinaryReader(uploadImage.InputStream)) { imageData = binaryReader.ReadBytes(uploadImage.ContentLength); } review.Image = imageData; } review.DateCreate = DateTime.Now; Db.Reviews.Add(review); await Db.SaveChangesAsync(); return(RedirectToAction("Index", "Home")); } return(RedirectToAction("Index", "Home")); }
public async Task <IActionResult> CreateReview(int?orderID, int?productID) { if (productID == null) { return(RedirectToAction("Error", "Home", new { ErrorTitle = "Product information not found", ErrorMessage = "Something happened while trying to get the product information, please try again." })); } if (orderID == null) { return(RedirectToAction("Error", "Home", new { ErrorTitle = "Order information not found", ErrorMessage = "Something happened while trying to get the order information, please try again." })); } if (!signInManager.IsSignedIn(User)) { return(RedirectToAction("Error", "Home", new { ErrorTitle = "Not signed in", ErrorMessage = "You are not signed in to perform this action." })); } else { var customerID = userManager.GetUserId(User); var customer = await _context.Customers .Include(c => c.Orders) .ThenInclude(o => o.OrderedProducts) .ThenInclude(op => op.Product) .FirstOrDefaultAsync(c => c.Id == customerID); var order = customer.Orders.FirstOrDefault(o => o.ID == orderID); var product = order.OrderedProducts.FirstOrDefault(p => p.ProductID == productID).Product; var review = await _context.ProductReviews.FirstOrDefaultAsync(r => r.OrderID == order.ID && r.ProductID == product.ID); CreateReviewViewModel model = new CreateReviewViewModel { Product = product, Order = order, }; if (review != null) { model.Rating = review.Rating; model.Description = review.Description; } return(View(model)); } }
/// <summary> /// Create Review Via Factory /// </summary> /// <param name="reviewModel"></param> /// <param name="userId"></param> /// <param name="reviewType">Type of review to be created</param> public async Task CreateReview(CreateReviewViewModel reviewModel, string userId, ReviewTypes reviewType) { if (!await IsUserExisting(userId)) { throw new ContentNotFoundException("Потребителят който се въвели не съществува!"); } Reviews reviewToAdd = await ReviewsCreateFactory(reviewModel, userId, reviewType); await unitOfWork.SaveAsync(); }
public void AddReview(CreateReviewViewModel model) { using (var context = new HardwareShopContext()) { var review = Mapper.Map <Review>(model); review.ReviewDate = DateTime.Now; review.AuthorId = HttpContext.Current.User.Identity.GetUserId(); context.Reviews.Add(review); context.SaveChanges(); } }
public async Task <IActionResult> Create(CreateReviewViewModel reviewViewModel) { if (!ModelState.IsValid) { return(View()); } var userId = _userManager.GetUserId(HttpContext.User); await _reviewService.CreateReviewAsync(Guid.Parse(userId), reviewViewModel.ReviewText, reviewViewModel.GameName, reviewViewModel.GamePublisher, reviewViewModel.ReleaseYear, reviewViewModel.VideoReview); return(Redirect("~/Reviews")); }
public void ToString_OnCall_ReturnsCorrectInformation() { var viewModel = new CreateReviewViewModel { Comment = "Some Comment", Rating = 1.0, ReviewerName = "Some Reviewer", RestaurantPublicId = Guid.Empty }; Approvals.Verify(viewModel); }
public static CocktailReviewDTO ToCocktailDTO(this CreateReviewViewModel createReviewViewModel) { var cocktailCommentDTO = new CocktailReviewDTO { CocktailId = createReviewViewModel.Id, UserId = createReviewViewModel.UserId, Comment = createReviewViewModel.Comment, Grade = createReviewViewModel.Rate, CreatedOn = createReviewViewModel.DateCreated }; return(cocktailCommentDTO); }
public ActionResult CreateReview(CreateReviewViewModel postViewModel) { if (!ModelState.IsValid) { return(View("CreateReview", postViewModel)); } var review = _mapper.Map <Review>(postViewModel); _reviewService.CreateReview(review, postViewModel.RestaurantPublicId); return(RedirectToAction("ListRestaurants", "Restaurant")); }
public ActionResult CreateReview(int pMediaId) { var media = ServiceFactory.Instance.CatalogueService.GetMediaById(pMediaId); var user = ServiceFactory.Instance.UserService.GetUserByUserName(User.Identity.GetUserName()); var vm = new CreateReviewViewModel { ReviewDate = DateTime.Now, Media = media, User = user }; return(View(vm)); }
public static BarReviewDTO ToBarDTO(this CreateReviewViewModel createReviewViewModel) { var barCommentDTO = new BarReviewDTO { BarId = createReviewViewModel.Id, UserId = createReviewViewModel.UserId, Comment = createReviewViewModel.Comment, Grade = createReviewViewModel.Rate, DateCreated = createReviewViewModel.DateCreated }; return(barCommentDTO); }
public ActionResult Create(int id) { // Get name of venue to display on View and return model Venue venue = _venueService.GetVenueById(id); var model = new CreateReviewViewModel { VenueId = venue.VenueId, VenueName = venue.Name }; return(View(model)); }
public async Task <IActionResult> CreateReviewPost(CreateReviewViewModel model) { var order = await _context.Orders.Include(o => o.OrderedProducts).ThenInclude(op => op.Product) .FirstOrDefaultAsync(o => o.ID == model.OrderID); var product = order.OrderedProducts.FirstOrDefault(op => op.ProductID == model.ProductID).Product; try { if (ModelState.IsValid) { ProductReview review = await _context.ProductReviews.FirstOrDefaultAsync(r => r.OrderID == order.ID && r.ProductID == product.ID); if (review == null) { review = new ProductReview() { Order = order, Product = product, Rating = model.Rating, DateAdded = DateTime.Now.Date, Description = model.Description }; _context.Add(review); } else { review.Rating = model.Rating; review.DateAdded = DateTime.Now.Date; review.Description = model.Description; _context.Update(review); } await _context.SaveChangesAsync(); return(RedirectToAction(nameof(Details))); } } catch (DbUpdateException /* ex */) { //Log the error (uncomment ex variable name and write a log. ModelState.AddModelError("", "Unable to save changes. " + "Try again, and if the problem persists " + "see your system administrator."); } model.Order = order; model.Product = product; return(View(model)); }
public Review CreateReview(CreateReviewViewModel review, string userId) { return(new Review() { ReviewId = Guid.NewGuid(), Id = userId, Body = review.Body, Shared = review.Shared, CreatedOn = DateTime.Now, Flagged = false, IsActive = true, ReviewType = review.ReviewType }); }
public ActionResult CreateFor(int id) { var movie = _movieRepository.Find(id); if (!CanReviewerReviewGenre(movie.Genres)) { return View("InvalidGenre", PrepareInvalidGenreViewModel(movie.Genres)); } var vm = new CreateReviewViewModel() { MovieID = movie.ID, Movie = movie }; return View("CreateFor", vm); }
public ActionResult AddReview(int id, CreateReviewViewModel model) { var thesis = this.Data.Theses.GetById(id); var userId = this.User.Identity.GetUserId(); if (this.IsThesisTeacher(userId, thesis) && thesis.Evaluation == null) { if (ModelState.IsValid) { var reviewId = 0; try { reviewId = SaveNewReview(model); } catch (Exception) { return RedirectToAction("ThesisProfile", "Thesis", new { id = id }); } var logger = this.loggerCreator.Create(this.Data); var log = new ThesisLog { ThesisId = id, UserId = userId, LogType = LogType.AddedReview, ForwardUrl = string.Format(GlobalPatternConstants.FORWARD_URL_WITH_ID, "Thesis", "ThesisProfile", id) }; logger.Log(log); CreateNotification(id, userId, log.ForwardUrl, GlobalPatternConstants.NOTIFICATION_ADDED_REVIEW); return RedirectToAction("ThesisProfile", "Thesis", new { id = id }); } var reviewers = this.Data.Teachers.All() .OrderBy(t => t.User.FirstName) .ThenBy(t => t.User.LastName) .AsQueryable() .Project() .To<SupervisorDropDownListITemViewModel>() .ToList(); ViewBag.ReviewerId = new SelectList(reviewers, "Id", "FullName"); return View(model); } return RedirectToAction("Index", "Storage"); }
public ActionResult AddReview(int id) { var thesis = this.Data.Theses.GetById(id); var userId = this.User.Identity.GetUserId(); if (this.IsThesisTeacher(userId, thesis) && thesis.Evaluation == null) { var newReview = new CreateReviewViewModel { Id = id }; var reviewers = this.Data.Teachers.All() .OrderBy(t => t.User.FirstName) .ThenBy(t => t.User.LastName) .AsQueryable() .Project() .To<SupervisorDropDownListITemViewModel>() .ToList(); ViewBag.ReviewerId = new SelectList(reviewers, "Id", "FullName"); return View(newReview); } return RedirectToAction("Index", "Storage"); }
private int SaveNewReview(CreateReviewViewModel model) { byte[] byteArray = null; using (var memory = new MemoryStream()) { model.Archive.InputStream.CopyTo(memory); byteArray = memory.GetBuffer(); } var fileName = string.Format(GlobalPatternConstants.VERSION_NAME, DateTime.Now.ToUniversalTime(), model.Archive.FileName); var fullPath = storage.UploadFile(byteArray, fileName, GlobalConstants.STORAGE_FOLDER); var extensionStartIndex = model.Archive.FileName.LastIndexOf('.'); var fileExtension = model.Archive.FileName.Substring(extensionStartIndex + 1, model.Archive.FileName.Length - extensionStartIndex - 1).ToLower(); var review = new Evaluation() { Id = model.Id, FilePath = fullPath, FileName = model.Archive.FileName, FileExtension = fileExtension, ReviewerId = model.ReviewerId, Mark = model.Mark }; this.Data.Evaluations.Add(review); this.Data.SaveChanges(); return review.Id; }