public bool PostMyRating(UserRatingDto rating)
{
if (_context.Users.Any(u => u.Id == rating.UserId) && _context.Movies.Any(m => m.Id == rating.MovieId))
{
try
{
var ratingDetails = new MovieRating()
{
Rating = rating.Rating,
UserId = rating.UserId,
MovieId = rating.MovieId
};
var userRating =
_context.MovieRatings.SingleOrDefault(r => r.MovieId == rating.MovieId && r.UserId == rating.UserId);
if (userRating == null)
{
_context.MovieRatings.Add(ratingDetails);
}
else
{
userRating.Rating = rating.Rating;
}
_context.SaveChanges();
return(true);
}
catch
{
return(false);
}
}
return(false);
}
public void AddObjectiveRating(UserRatingDto rating)
{
try
{
var userRating = rating.ToDbEntity();
_unitOfWork.UserRatingRepository.Create(userRating);
_unitOfWork.UserRatingRepository.Save();
_unitOfWork.Commit();
int status;
if (userRating.Grade == 0)
{
status = (int)Common.Enums.ObjectiveStatus.Rejected;
}
else
{
status = (int)Common.Enums.ObjectiveStatus.Reviewed;
}
var objective = _unitOfWork.ObjectiveRepository.GetById(rating.ObjectiveId);
objective.Status_ID = status;
UpdateChallengeBasedGrade(objective.Objective_ID);
_unitOfWork.ObjectiveRepository.Save();
_unitOfWork.Commit();
}
catch (Exception ex)
{
_unitOfWork.RollBack();
throw;
}
}
public async Task <CommonResult> Add(UserRatingDto ratingDto)
{
if (string.IsNullOrEmpty(ratingDto.Feedback))
{
return(CommonResult.Failure("Cannot create user without field provided."));
}
if (string.IsNullOrEmpty(ratingDto.UserAssessorId))
{
return(CommonResult.Failure("Cannot create user without userAssessorId provided."));
}
if (string.IsNullOrEmpty(ratingDto.UserEvaluatedId))
{
return(CommonResult.Failure("Cannot create user without userEvaluatedId provided."));
}
if (Enum.IsDefined(typeof(StarNumberType), ratingDto.StarType))
{
return(CommonResult.Failure("Wrong enum value."));
}
await _ratingsRepository.Add(ratingDto);
return(CommonResult.Success());
}
public async Task <IActionResult> RateMovie(int movieId, [FromBody] UserRatingDto ratingDto)
{
var userId = GetUserId();
var userRating = await _service.RateMovieAsync(userId, movieId, ratingDto.rating);
return(new OkObjectResult(_mapper.Map <UserRatingDto>(userRating)));
}
public async Task <IActionResult> UpdateRating(UserRatingDto ratingDto)
{
var user = await _ratingsService.Update(ratingDto);
if (user.IsSuccess)
{
return(Ok(user));
}
return(BadRequest(user.ErrorMessage));
}
public static UserRating ToDbEntity(this UserRatingDto rating)
{
return(new UserRating()
{
Objective_ID = rating.ObjectiveId,
Rating_ID = rating.Id,
User_ID = rating.UserID,
Grade = rating.Grade
});
}
public async Task <CommonResult> Update(UserRatingDto ratingDto)
{
var updateQualificationDto = await _ratingsRepository.Update(ratingDto);
if (updateQualificationDto == null)
{
return(CommonResult <UserRatingDto> .Failure <UserRatingDto>("Problem occured updating entity."));
}
return(CommonResult <QualificationDto> .Success(ratingDto));
}
public UserRating(UserRatingDto userRatingDto)
{
Average = userRatingDto.Average;
Count = userRatingDto.Count;
NumOneStarRatings = userRatingDto.RatingTable.TryGetValue(1, out var n1) ? n1 : 0;
NumTwoStarRatings = userRatingDto.RatingTable.TryGetValue(2, out var n2) ? n2 : 0;
NumThreeStarRatings = userRatingDto.RatingTable.TryGetValue(3, out var n3) ? n3 : 0;
NumFourStarRatings = userRatingDto.RatingTable.TryGetValue(4, out var n4) ? n4 : 0;
NumFiveStarRatings = userRatingDto.RatingTable.TryGetValue(5, out var n5) ? n5 : 0;
}
public async Task <IActionResult> AddRating(UserRatingDto ratingDto)
{
ratingDto.UserAssessorId = _httpContextAccessor.HttpContext.User.FindFirst(ClaimTypes.NameIdentifier).Value;
var user = await _ratingsService.Add(ratingDto);
if (user.IsSuccess)
{
return(Ok(user));
}
return(BadRequest(user.ErrorMessage));
}
public HttpResponseMessage AddObjectiveRating([FromBody] UserRatingDto rating)
{
try
{
_objectiveService.AddObjectiveRating(rating);
return(Request.CreateResponse(HttpStatusCode.Created, "Successfully added the rating!"));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.InternalServerError, ex.Message));
}
}
public void AddRating(UserRatingDto rating)
{
try
{
_unitOfWork.UserRatingRepository.Create(rating.ToDbEntity());
_unitOfWork.UserRatingRepository.Save();
_unitOfWork.Commit();
}
catch (Exception)
{
_unitOfWork.RollBack();
throw;
}
}
public HttpResponseMessage PostRating([FromBody] UserRatingDto data)
{
if (!ModelState.IsValid)
{
return(Request.CreateErrorResponse(HttpStatusCode.BadRequest, "Invalid rating value."));
}
bool status = _service.PostMyRating(data);
if (status)
{
return(Request.CreateResponse(HttpStatusCode.OK, data));
}
return(Request.CreateErrorResponse(HttpStatusCode.NotFound, "movie/user is not found."));
}
public async Task <ServiceResponse <int> > AddUserRating(UserRatingDto rating)
{
ServiceResponse <int> response = new ServiceResponse <int>();
try
{
int userId = GetUserId();
UserRating rating1 = new UserRating {
UserId = userId,
CharacterId = rating.CharacterId,
Rating = rating.Rating
};
bool isRated = await _context.UserRatings.AnyAsync(ur =>
ur.CharacterId == rating.CharacterId &&
ur.UserId == userId);
System.Console.WriteLine(isRated);
if (isRated)
{
UserRating ur = await _context.UserRatings.FirstOrDefaultAsync(ur =>
ur.CharacterId == rating.CharacterId &&
ur.UserId == userId);
_context.UserRatings.Remove(ur);
await _context.SaveChangesAsync();
response.Message = "Rating removed";
}
else
{
await _context.UserRatings.AddAsync(rating1);
await _context.SaveChangesAsync();
response.Message = "Rating added";
}
List <UserRating> ratings = await(_context.UserRatings.Where(ur => ur.CharacterId == rating.CharacterId)
.ToListAsync());
response.Data = ratings.Count;
}
catch (System.Exception ex)
{
response.Success = false;
response.Message = ex.Message;
}
return(response);
}
public UserRatingDbModel ToDbModel(UserRatingDto item)
{
if (item.Id == 0)
{
return(new UserRatingDbModel
{
RatingId = item.RatingId, TestId = item.TestId, UserName = item.UserName, Mark = item.Mark
});
}
else
{
return(new UserRatingDbModel
{
Id = item.Id, RatingId = item.RatingId, TestId = item.TestId, UserName = item.UserName,
Mark = item.Mark
});
}
}
public async Task <UserRatingDto> Update(UserRatingDto userRatingDto)
{
var result = await DbSet.SingleOrDefaultAsync(x => x.Id == userRatingDto.Id);
await UpdateAsync(result);
if (await _dbContext.SaveChangesAsync() == 0)
{
return(null);
}
return(new UserRatingDto
{
Id = result.Id,
UserAssessorId = userRatingDto.UserAssessorId,
UserEvaluatedId = userRatingDto.UserEvaluatedId,
Feedback = userRatingDto.Feedback,
StarType = userRatingDto.StarType
});
}
public async Task <UserRatingDto> Add(UserRatingDto userRatingDto)
{
var userRating = new UserRating
{
UserAssessorId = userRatingDto.UserAssessorId,
UserEvaluatedId = userRatingDto.UserEvaluatedId,
Feedback = userRatingDto.Feedback,
StarType = userRatingDto.StarType
};
await DbSet.AddAsync(userRating);
if (await _dbContext.SaveChangesAsync() == 0)
{
return(null);
}
userRatingDto.Id = userRating.Id;
return(userRatingDto);
}
public void PostRating()
{
var client = new HttpClient();
var postAddress = string.Format("api/movies/rating");
client.BaseAddress = new Uri(Url);
//string myJson = "{'userId': 4,'movieId':2, 'Rating':4}";
var data = new UserRatingDto()
{
UserId = 4, MovieId = 2, Rating = Rating.FourStar
}; // <---- Note that this is an explicit object, not an interface
var postData = new StringContent(JsonConvert.SerializeObject(data), Encoding.UTF8, "application/json");
using (var response = client.PostAsync(postAddress, postData).Result)
{
var result = response.Content.ReadAsAsync <UserRatingDto>().Result;
Assert.AreEqual(4, result.UserId);
Assert.AreEqual(2, result.MovieId);
Assert.AreEqual(response.StatusCode, HttpStatusCode.OK);
}
}
public async Task <IActionResult> Addrating(UserRatingDto rating)
{
return(Ok(await _characterService.AddUserRating(rating)));
}
