public ActionResult <RatingDto> RateApartment([FromBody] RatingDto ratingDto)
{
if (!ModelState.IsValid)
{
return(BadRequest("Invalid rating data"));
}
var savedRating = _repository.Butas.Rate(ratingDto);
return(Ok(_mapper.Map <Reitingas, RatingDto>(savedRating)));
}
public Rating(
RatingDto dto,
IPersistenceStrategy persistenceStrategy,
IMovieBinding movieBinding,
ICriticBinding criticBinding)
{
_dto = dto;
_persistenceStrategy = persistenceStrategy;
_movieBinding = movieBinding;
_criticBinding = criticBinding;
}
public static Rating Convert(RatingDto item)
{
return(new Rating
{
Id = item.Id,
UserId = item.UserId,
ItemId = item.ItemId,
Star = item.Star,
Date = item.Date
});
}
public async Task <Guid> CreateRatingAsync(RatingDto rating, string userEmail)
{
using (var uow = UnitOfWorkProvider.Create())
{
rating.SellerId = (await _userService.GetUserAccordingToEmailAsync(userEmail)).Id;
var ratingId = _ratingService.Create(rating);
await uow.Commit();
return(ratingId);
}
}
public RatingDto Update(RatingDto entity)
{
using (_ratingRepository)
{
var entityToUpdate = entity.ConvertToRatingDbModel();
_ratingRepository.Update(entityToUpdate);
_ratingRepository.SaveChanges();
return(entityToUpdate.ConvertToRatingDto());
}
}
//zet data in ToDto voor door te sturen naar de testcase
public RatingDto ToDto()
{
RatingDto rating = new RatingDto();
rating.MovieID = this.MovieID;
rating.RatingID = this.RatingID;
rating.RatingStars = this.RatingStars;
rating.RatingTitle = this.RatingTitle;
rating.RatingComment = this.RatingComment;
return(rating);
}
async Task Rate()
{
var request = new RatingDto()
{
PostId = Post.Id,
userId = HttpClient.UserId,
Rating = Rating
};
await ratingHttp.Insert <RatingView>(request);
await Application.Current.MainPage.DisplayAlert("asd", Rating.ToString(), "asd");
}
public RatingDto Save(RatingDto dto)
{
try
{
var retVal = this.dal.Save(dto.Id, dto.Name, dto.Amount).ToDto();
return(retVal);
}
catch (Exception ex)
{
throw ex;
}
}
public ResponseDto PageIsPublished(RatingDto actionInfo)
{
var response = new ResponseDto();
if (ContentReference.TryParse(actionInfo.ContentId, out var reviewPageReference))
{
var page = _loader.Get <PageData>(reviewPageReference);
response.PageIsPublished = page.Status == VersionStatus.Published;
}
return(response);
}
private Rating ExtractRating(RatingDto rating)
{
if (rating.Liked)
{
return(Rating.Like);
}
if (rating.Disliked)
{
return(Rating.Disliked);
}
return(Rating.None);
}
public int CreateRating(RatingDto ratingDto)
{
using (MySqlConnection conn = GetConnection())
{
conn.Open();
string command = "INSERT INTO rating (RatingID,MovieID,RatingStars,RatingTitle,RatingComment) " +
"values ({0}, '{1}', '{2}', '{3}', '{4}')";
MySqlCommand cmd = new MySqlCommand(string.Format(command, ratingDto.RatingID, ratingDto.MovieID, ratingDto.RatingStars,
ratingDto.RatingTitle, ratingDto.RatingComment), conn);
int rowcount = cmd.ExecuteNonQuery();
return(rowcount);
}
}
public IActionResult Rate(RatingDto ratingDto)
{
ratingDto.Url = Uri.UnescapeDataString(ratingDto.Url);
if (ModelState.IsValid)
{
_ratingService.Add(ratingDto);
return(RedirectToAction(nameof(Success)));
}
var errors = ModelState.Values.Select(v => v.Errors).ToList();
return(View(ratingDto));
}
private static Rating GetModel(RatingDto dto)
{
var model = new Rating
{
Grade = dto.Grade,
Number = dto.Number,
AnswerId = dto.AnswerId,
ViewerId = dto.ViewerId,
Id = dto.Id,
};
return(model);
}
public void Execute(RatingDto request)
{
request.UserId = _actor.Id;
_validator.ValidateAndThrow(request);
var rating = _context.Ratings.Find(request.Id);
if (rating.UserId != _actor.Id)
{
throw new ForbiddenUseCaseException(_actor, this.Name, request.Id);
}
rating.Value = request.Value;
_context.SaveChanges();
}
public int Save(RatingDto ratingDto)
{
try
{
context.Ratings.Add(ratingDto.ToRatingEntity());
context.SaveChanges();
return(1);
}
catch (Exception)
{
return(-1);
}
}
private static RatingDto GetDto(Rating model)
{
var dto = new RatingDto()
{
Grade = model.Grade,
Number = model.Number,
AnswerId = model.AnswerId,
ViewerId = model.ViewerId,
Id = model.Id
};
return(dto);
}
public async Task <ActionResult <Rating> > PostRating(RatingDto ratingDto)
{
var ratingId = Guid.NewGuid();
var ratingTags = new List <RatingTag>();
var validTags = await m_context.Tags.ToListAsync();
foreach (var tag in ratingDto.Tags)
{
if (validTags.Any(t => t.Id.Equals(tag.Id)))
{
ratingTags.Add(new RatingTag
{
RatingId = ratingId,
TagId = tag.Id
}
);
}
else
{
return(NotFound("Tag not found"));
}
}
var rating = new Rating
{
Id = ratingId,
DateCreated = DateTime.Now,
TeacherId = ratingDto.TeacherId,
Tags = ratingTags,
Comment = ratingDto.Comment,
CourseId = ratingDto.CourseId,
LevelOfDifficulty = ratingDto.LevelOfDifficulty,
OverallMark = ratingDto.OverallMark,
WouldTakeTeacherAgain = ratingDto.WouldTakeTeacherAgain,
RatingType = ratingDto.RatingType,
ThumbUps = 0,
ThumbDowns = 0
};
m_context.Ratings.Add(rating);
await m_context.SaveChangesAsync();
if (rating.TeacherId != Guid.Empty)
{
await m_leaderboardManager.UpdateTeacherAsync(rating.TeacherId);
}
await m_leaderboardManager.UpdateCourseAsync(rating.CourseId);
return(CreatedAtAction(nameof(GetRatingAsync), new { id = rating.Id }));
}
/*public RatingCollection()
* {
* db = new RatingContext();
* ratings = new List<Rating>();
* List<RatingDto> ratingDtos = db.GetRatings();
* foreach (RatingDto ratingDto in ratingDtos)
* {
* ratings.Add(new Rating()
* {
* RatingID = ratingDto.RatingID,
* MovieID = ratingDto.MovieID,
* RatingStars = ratingDto.RatingStars,
* RatingTitle = ratingDto.RatingTitle,
* RatingComment = ratingDto.RatingComment
* });
* }
* }*/
public int CreateRating(Rating rating)
{
RatingDto ratingDto = new RatingDto();
ratingDto.RatingID = rating.RatingID;
ratingDto.MovieID = rating.MovieID;
ratingDto.RatingStars = rating.RatingStars;
ratingDto.RatingTitle = rating.RatingTitle;
ratingDto.RatingComment = rating.RatingComment;
int rowcount = db.CreateRating(ratingDto);
return(rowcount);
}
public void Execute(RatingDto request)
{
request.UserId = _actor.Id;
_validator.ValidateAndThrow(request);
var rating = new Rating
{
UserId = _actor.Id,
PostId = request.PostId,
Value = request.Value
};
_context.Ratings.Add(rating);
_context.SaveChanges();
}
public async Task <string> Put(Guid id, [FromBody] RatingDto rating)
{
if (!ModelState.IsValid)
{
throw new HttpResponseException(HttpStatusCode.BadRequest);
}
var success = await InteractionFacade.EditRatingAsync(rating);
if (!success)
{
throw new HttpResponseException(HttpStatusCode.NotFound);
}
return($"Updated rating with id: {id}");
}
public async Task <RatingDto> GetRatingForEdit(RatingDto input)
{
var users = await _context.Rating.Where(x => x.Id == input.Id).FirstOrDefaultAsync();
if (users != null)
{
Rating ratingDto = MappingProfile.MappingConfigurationSetups().Map <Rating>(input);
_context.Rating.Update(ratingDto);
await _context.SaveChangesAsync();
return(MappingProfile.MappingConfigurationSetups().Map <RatingDto>(ratingDto));
}
return(new RatingDto());
}
public IActionResult AddRating(RatingViewModel ratingViewModel)
{
if (String.IsNullOrEmpty(HttpContext.Session.GetString("UserId")))
{
return(RedirectToAction("Login", "UserEntry"));
}
var ratingDto = new RatingDto
{
Stars = ratingViewModel.Stars,
ToGame = ratingViewModel.ToGame,
UserId = new Guid(HttpContext.Session.GetString("UserId"))
};
ratingService.Create(ratingDto);
return(RedirectToAction("ShowGames", "Home"));
}
public static RatingDto ToDto(this DataAccess.Models.Rating item)
{
RatingDto dto = null;
if (item != null)
{
dto = new RatingDto
{
Id = item.Id,
Name = item.Name,
Amount = item.Amount
};
}
return(dto);
}
[HttpGet("AddRating/{username}/{movietitle}/{rating}", Name = nameof(AddRating))] //actually it's better to use HttpPost here, since when testing we call this api from url, I keep HttpGet for now.
public async Task <IActionResult> AddRating(string userName, string movieTitle, string rating)
{
try
{
if (String.IsNullOrEmpty(userName) || String.IsNullOrEmpty(movieTitle) || String.IsNullOrEmpty(rating))
{
return(NotFound()); //Returns 404 - Not Found.
}
else
{
var user = await _userRepository.GetSingle(userName);
var movie = await _movieRepository.GetSingleByTitle(movieTitle);
if (user == null || movie == null)
{
return(NotFound()); //Returns 404 - Not Found.
}
if (int.TryParse(rating, out var parsedRating) && parsedRating >= 1 && parsedRating <= 5)
{
var ratingNew = await _ratingRepository.AddUpdateRating(user, movie, parsedRating);
var ratingDto = new RatingDto()
{
Id = ratingNew.Id,
UserId = user.Id,
UserName = userName,
MovieId = movie.Id,
MovieTitle = movieTitle,
RatingScore = parsedRating
};
return(Ok(ratingDto));
}
else
{
return(BadRequest());
}
}
}
catch (Exception ex)
{
return(BadRequest()); //Returns 400 - Bad Request.
}
}
public async Task Rate(int id, RatingDto rating)
{
var film = await _uow.Repository <Film>().FindOneAsync(new FilmWithRatingsSpecification(id));
var ratingToInsert = new Domain.Entities.Rating
{
UserId = (int)_currentUserService.UserId,
RatingValue = rating.Rating,
CreatedAt = DateTime.UtcNow
};
film.Ratings.Add(ratingToInsert);
film.Rating = (float)Math.Round(film.Ratings.Select(x => x.RatingValue).Average(), 2);
await _uow.SaveAsync();
}
public void EnableRating(RatingDto actionInfo)
{
ContentReference reviewPageReference;
if (ContentReference.TryParse(actionInfo.ContentId, out reviewPageReference))
{
var page = _loader.Get <PageData>(reviewPageReference);
var writablePage = page.CreateWritableClone();
if (writablePage is IRatingPage ratingPage)
{
ratingPage.RatingEnabled = actionInfo.RatingEnabled;
}
_repository.Save(writablePage, SaveAction.Publish);
}
}
public void Create(RatingDto rating)
{
if (rating == null)
{
throw new ArgumentNullException(nameof(rating));
}
var thisRating = new Rating
{
RatingId = Guid.NewGuid(),
Stars = rating.Stars,
ToGame = rating.ToGame,
UserId = rating.UserId
};
ratingRepository.Add(thisRating);
unitOfWork.Commit();
}
public async Task <bool> EditRatingAsync(RatingDto ratingDto)
{
using (var uow = UnitOfWorkProvider.Create())
{
var updatedRating = await _ratingService.GetAsync(ratingDto.Id, false);
if (updatedRating == null)
{
return(false);
}
await _ratingService.Update(ratingDto);
await uow.Commit();
return(true);
}
}
public RatingDbModel ToDbModel(RatingDto item)
{
if (item.Id == 0)
{
return(new RatingDbModel
{
UserRatings = _userRatingMapper.ToDbModelList(item.RatingList), TestId = item.TestId
});
}
else
{
return(new RatingDbModel
{
UserRatings = _userRatingMapper.ToDbModelList(item.RatingList), Id = item.Id, TestId = item.TestId
});
}
}
public RatingDto UpdateRating(RatingDto rating)
{
var entity = _context.Ratings.Find(rating.Id);
entity.MovieId = rating.MovieId;
entity.MovieName = rating.MovieName;
entity.Comment = rating.Comment;
entity.RatingPoint = rating.RatingPoint;
entity.UserMail = rating.UserMail;
_context.Ratings.Update(entity);
_context.SaveChangesAsync(new CancellationToken());
// success, return updated obj
return(rating);
}
