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;
}
