public async Task UserReviewVoteAsyncChangesVoteCorrectly()
{
var reviews = new List <Review>();
var review = new Review()
{
Id = "test",
ReviewAuthorId = "gosho",
ReviewNumber = "123"
};
reviews.Add(review);
var mockReviewsRepo = new Mock <IReviewsRepository>();
mockReviewsRepo.Setup(x => x.GetReviewByReviewNumber("123")).Returns(review);
var mockReviewsVotesRepo = new Mock <IReviewsVotesRepository>();
var reviewVote = new ReviewVote()
{
ReviewId = "test",
ApplicationUserId = "gosho",
};
mockReviewsVotesRepo.Setup(x => x.GetReviewVoteByIds("test", "gosho")).Returns(reviewVote);
var service = new ReviewsVotesService(mockReviewsVotesRepo.Object, mockReviewsRepo.Object);
await service.UserReviewVoteAsync("123", true, "gosho");
Assert.Equal("UpVote", reviewVote.Vote.ToString());
await service.UserReviewVoteAsync("123", false, "gosho");
Assert.Equal("DownVote", reviewVote.Vote.ToString());
}
public async Task <IHttpActionResult> LikeReview(int id, bool isup)
{
var userId = User.Identity.GetUserId();
if (userId != null)
{
Review comment = await db.Reviews.FindAsync(id);
var commentVoteByUser = await db.ReviewVotes.FirstOrDefaultAsync(x => x.reviewId == id && x.votedBy == userId);
if (comment == null)
{
return(NotFound());
}
var vote = commentVoteByUser;
if (vote != null)
{
if (vote.isup && isup)
{
return(BadRequest("You have already voteup"));
}
else if (vote.isup && !isup)
{
vote.isup = false;
}
else if (!vote.isup && !isup)
{
return(BadRequest("You have already votedown"));
}
else if (!vote.isup && isup)
{
vote.isup = true;
}
}
else
{
ReviewVote repvote = new ReviewVote();
repvote.isup = isup;
repvote.votedBy = userId;
repvote.reviewId = id;
db.ReviewVotes.Add(repvote);
}
await db.SaveChangesAsync();
var q = (from x in comment.ReviewVotes.Where(x => x.reviewId == comment.Id)
let voteUp = comment.ReviewVotes.Count(m => m.isup)
let voteDown = comment.ReviewVotes.Count(m => m.isup == false)
select new { voteUpCount = voteUp, voteDownCount = voteDown }).FirstOrDefault();
return(Ok(q));
}
else
{
return(BadRequest("You are not login"));
}
}
public ActionResult DownvoteReview(int reviewID, int movieID)
{
if (User.Identity.IsAuthenticated == false)
{
TempData["msg"] = "<script>alert('You must be logged in to vote on a review.');</script>";
return(Redirect(Request.UrlReferrer.ToString()));
}
String currentuserID = User.Identity.GetUserId();
AppUser currentuser = db.Users.First(x => x.Id == currentuserID);
IEnumerable <ReviewVote> reviewvotes = db.ReviewVotes.Where(x => x.Review.ReviewID == reviewID);
IEnumerable <ReviewVote> UserReviews = reviewvotes.Where(x => x.AppUser == currentuser);
if (UserReviews != null && UserReviews.GetEnumerator().MoveNext())
{
foreach (ReviewVote vote in UserReviews)
{
if (vote.UpOrDown == UpOrDown.Up)
{
vote.UpOrDown = UpOrDown.Down;
db.Entry(vote).State = EntityState.Modified;
TempData["msg"] = "<script>alert('Your vote was changed.');</script>";
return(Redirect(Request.UrlReferrer.ToString()));
}
else
{
TempData["msg"] = "<script>alert('You have already downvoted this review.');</script>";
return(Redirect(Request.UrlReferrer.ToString()));
}
}
db.SaveChanges();
}
else
{
Review MovieReview = db.Reviews.First(x => x.ReviewID == reviewID);
IEnumerable <Review> MovieReviews = db.Reviews.Where(x => x.Movie.MovieID == movieID);
Movie movie = db.Movies.First(x => x.MovieID == movieID);
ReviewVote reviewvote = new ReviewVote();
reviewvote.UpOrDown = UpOrDown.Down;
reviewvote.AppUser = currentuser;
reviewvote.Review = MovieReview;
reviewvote.Review.Movie = movie;
MovieReview.TotalVotes += 1;
db.ReviewVotes.Add(reviewvote);
db.SaveChanges();
return(Redirect(Request.UrlReferrer.ToString()));
}
return(Redirect(Request.UrlReferrer.ToString()));
}
public void GetUserReviewsWorksCorrectly()
{
var reviews = new List <Review>();
var dateTime = new DateTime(1994, 01, 01);
var review = new Review()
{
Id = "012",
ReviewAuthorId = "gosho",
ReviewNumber = "123",
ReviewInfo = "work",
CreatedOn = dateTime,
WebtoonId = "456",
Webtoon = new Webtoon()
{
Title = "test",
TitleNumber = "789"
},
ReviewVotes = new List <ReviewVote>()
};
var reviewVote = new ReviewVote()
{
ApplicationUserId = "ivan",
ReviewId = "012",
Vote = MyWebtoonWebProject.Data.Models.Enums.VoteType.UpVote
};
review.ReviewVotes.Add(reviewVote);
reviews.Add(review);
var mockReviewRepo = new Mock <IReviewsRepository>();
mockReviewRepo.Setup(x => x.All()).Returns(reviews.AsQueryable());
var service = new ApplicationUsersService(null, mockReviewRepo.Object, null, null, null, null);
var result = service.GetUserReviews("gosho");
Assert.Equal(new DateTime(1994, 01, 01), result.First().CreatedOn);
Assert.Equal(0, result.First().Dislikes);
Assert.Equal(1, result.First().Likes);
Assert.Equal("gosho", result.First().ReviewAuthorId);
Assert.Equal("123", result.First().ReviewNumber);
Assert.Equal("789", result.First().WebtoonTitleNumber);
Assert.Equal("test", result.First().WebtoonTitle);
Assert.Equal("work", result.First().ReviewInfo);
}
protected async override Task <HandleResult> HandleCoreAsync(VoteReviewRequest reqObj)
{
var reviewVote = new ReviewVote
{
MID = reqObj.MID,
ReviewID = reqObj.RID,
Oppose = 0,
Support = reqObj.Support,
UID = reqObj.UserId,
VoteTime = DateTime.Now
};
var rowAffected = await _mottoRepo.AddReviewVoteAsync(reviewVote);
return(new VoteReviewResult
{
State = HandleStates.Success,
Msg = "操作成功"
});
}
public void ReviewLikesAndDislikesWorksCorrectly()
{
var reviews = new List <Review>();
var review = new Review()
{
ReviewNumber = "pesho",
Id = "test123"
};
reviews.Add(review);
var reviewVote = new ReviewVote()
{
ApplicationUserId = "gosho",
ReviewId = "test123",
Vote = MyWebtoonWebProject.Data.Models.Enums.VoteType.UpVote
};
var secondReviewVote = new ReviewVote()
{
ApplicationUserId = "pesho",
ReviewId = "test123",
Vote = MyWebtoonWebProject.Data.Models.Enums.VoteType.DownVote
};
review.ReviewVotes.Add(reviewVote);
review.ReviewVotes.Add(secondReviewVote);
var mockReviewsRepo = new Mock <IReviewsRepository>();;
mockReviewsRepo.Setup(x => x.GetReviewByReviewNumber("pesho")).Returns(review);
var service = new ReviewsService(mockReviewsRepo.Object, null);
var result = service.ReviewLikesAndDislikes("pesho");
Assert.Equal(1, result.Dislikes);
Assert.Equal(1, result.Likes);
}
public async Task UserReviewVoteAsync(string reviewNumber, bool isUpVote, string userId)
{
var reviewId = this.reviewsRepository.GetReviewByReviewNumber(reviewNumber).Id;
var userReviewVote = this.reviewsVotesRepository.GetReviewVoteByIds(reviewId, userId);
if (userReviewVote != null)
{
userReviewVote.Vote = isUpVote ? VoteType.UpVote : VoteType.DownVote;
}
else
{
userReviewVote = new ReviewVote
{
ReviewId = reviewId,
ApplicationUserId = userId,
Vote = isUpVote ? VoteType.UpVote : VoteType.DownVote,
};
await this.reviewsVotesRepository.AddAsync(userReviewVote);
}
await this.reviewsVotesRepository.SaveChangesAsync();
}
public async Task <int> AddReviewVoteAsync(ReviewVote rv)
{
var rowAffected = 0;
using (var conn = _connProvider.GetConnection())
{
var tran = conn.BeginTransaction();
try
{
var cmd = conn.CreateCommand();
cmd.Transaction = tran;
if (rv.Support == 1)
{
rowAffected = await conn.ExecuteAsync("Insert into ReviewVotes (MID,ReviewID,UID,Support,Oppose,VoteTime) " +
"values(@MID,@ReviewID,@UID,@Support,@Oppose,@VoteTime)",
rv, tran);
}
else
{
rowAffected = await conn.ExecuteAsync("delete from ReviewVotes where MID=@MID and ReviewID=@ReviewID and UID=@UID", rv, tran);
}
if (rowAffected > 0)
{
if (rv.Support == 1)
{
await conn.ExecuteAsync("update Reviews set Up=Up+1 where MID=@mid and ID=@reviewId",
new
{
MID = rv.MID,
ReviewId = rv.ReviewID
}, tran);
}
else
{
await conn.ExecuteAsync("update Reviews set Up=Up-1 where MID=@mid and ID=@reviewId",
new
{
MID = rv.MID,
ReviewId = rv.ReviewID
}, tran);
}
tran.Commit();
}
else
{
tran.Rollback();
}
}
catch
{
try
{
tran.Rollback();
}
catch
{
}
throw;
}
}
return(rowAffected);
}
