public async Task <int> Create(Comment comment, User user, IFormFile file)
{
comment.Id = 0;
comment.User = user;
comment.Date = DateTime.Now;
comment.Reply = await _replyService.GetAsync(comment.Reply.Id);
var rating = await _context.Rating
.SingleOrDefaultAsync(r => r.User.Equals(comment.User) && r.Topic.Equals(comment.Reply.Question.Topic));
if (rating == null)
{
await _ratingService.Create(user, comment.Reply.Question.Topic);
}
if (file != null)
{
var fileName = DateTime.Now.Ticks + ".jpg";
var dirPath = Path.Combine(_appEnvironment.WebRootPath, "Uploads");
Directory.CreateDirectory(dirPath);
var path = Path.Combine(dirPath, fileName);
using (Stream stream = File.Create(path))
{
await file.CopyToAsync(stream);
comment.Attachment = fileName;
}
}
_context.Add(comment);
await _context.SaveChangesAsync();
return(comment.Reply.Question.Id);
}
public async Task <int> CreateRatingAsync(RatingDTO rating)
{
using (var uow = UnitOfWorkProvider.Create())
{
if (rating.RatedUserRole == UserRole.Corporation)
{
var corporation = await corporationService.GetAsync(rating.RatedUserId);
if (!corporation.SumRating.HasValue)
{
corporation.SumRating = 0;
}
corporation.SumRating += rating.Score;
corporation.RatingCount += 1;
await corporationService.Update(corporation);
}
else
{
var freelancer = await freelancerService.GetAsync(rating.RatedUserId);
if (!freelancer.SumRating.HasValue)
{
freelancer.SumRating = 0;
}
freelancer.SumRating += rating.Score;
freelancer.RatingCount += 1;
await freelancerService.Update(freelancer);
}
var ratingId = ratingService.Create(rating);
await uow.Commit();
return(ratingId);
}
}
public IActionResult SetStatusAccepted(int id)
{
var inscription = _inscriptionService.GetById(id);
if (inscription == null)
{
return(BadRequest());
}
inscription.Status = Entities.Enums.EnrollmentStatus.Accepted;
_inscriptionService.Update(inscription);
var rating = new Rating()
{
CourseId = inscription.CourseId,
UserId = inscription.UserId
};
_ratingService.Create(rating);
Services.Courses.DTOs.InscriptionFilter filter = new InscriptionFilter()
{
CourseId = inscription.CourseId
};
var result = _inscriptionService.GetListUser(1, 50, null, filter).Entities.SingleOrDefault(e => e.Id == id);
return(new JsonResult(result));
}
public void CreateRating_UnderNormalConditions_ReturnsOkResponse()
{
//Arrange
var ratingToCreate = new RatingDto()
{
InstructorId = 5,
ClassId = 5,
ClassRating = 5,
Comment = "Creating a new rating comment..",
InstructorRating = 5,
RatingId = 5
};
Mock.Arrange(() => _ratingService.Create(ratingToCreate))
.Returns(ratingToCreate)
.OccursOnce();
var ratingController = new RatingController(_ratingService)
{
Request = new HttpRequestMessage()
{
RequestUri = new Uri("http://localhost/api/rating")
}
};
//Act
var actual = ratingController.Post(ratingToCreate) as CreatedNegotiatedContentResult <RatingDto>;
var actualContent = actual.Content;
//Assert
Mock.Assert(_ratingService);
Assert.IsNotNull(actual);
Assert.That(actual, Is.TypeOf <CreatedNegotiatedContentResult <RatingDto> >());
Assert.That(actualContent, Is.EqualTo(ratingToCreate));
}
public IHttpActionResult Post(RatingDto rating)
{
using (_ratingService)
{
var response = _ratingService.Create(rating);
return(Created(new Uri(Request.RequestUri, $"{response.RatingId}"), response));
}
}
private IActionResult CreateAsFreeLancer(long clientId, long jobId, RatingRequest model)
{
if (!_ratingService.FreeLancerCanWriteReview(jobId, clientId))
{
return(Forbid());
}
var jobOwnerId = _jobService.Get(jobId).ClientId;
var rating = _mapper.Map <Rating>(model);
rating.ClientIdFrom = clientId;
rating.ClientIdTo = jobOwnerId;
rating.JobId = jobId;
_ratingService.Create(rating);
return(Ok());
}
public IActionResult PostRating([FromBody] Rating entity)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
Rating rating = _service.Create(entity);
return(Ok(rating));
}
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 IActionResult ThumbsUp(int bid, int id, CreateCommentViewModel vm)
{
if (User.Identity.IsAuthenticated)
{
// if rating found by userId exist as ThumbsUp = true(1) already
var ratings = _ratingService.GetByCommentUserId(id, _userManager.GetUserId(User));
vm.Product = _productService.GetById(bid);
int checker = 1;
foreach (var rating in ratings)
{
if (rating.ThumbsUp == true)
{
checker = 0; // user can vote only if checker stays 1
}
}
if (checker == 1) // user can vote ThumbsUp for the comment
{
Rating newRating = new Rating();
newRating.ThumbsUp = true;
newRating.CommentId = id;
newRating.UserId = _userManager.GetUserId(User);
_ratingService.Create(newRating);
vm.RatingSucceed = true;
}
else if (checker == 0)
{
vm.RatingSucceed = false;
return(View(vm));
}
}
else
{
return(RedirectToAction("SignIn", "Account"));
}
return(RedirectToAction("Details", "Product", new { id = bid, vm }));
}
public ActionResult Rating(RatingViewModel ratingViewModel)
{
try
{
var ratingDTO = ConvertToRatingDTO(ratingViewModel);
_ratingService.Create(ratingDTO);
TempData["AlertSuccess"] = "Operation Done!";
}
catch (Exception e)
{
this.ModelState.AddModelError("CustomError", e.Message);
return(View(ratingViewModel));
}
return(RedirectToAction("Index"));
}
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 ActionResult CreateRating(RatingViewModel rating)
{
try
{
if (!ModelState.IsValid)
{
throw new Exception(ModelState.ToString());
}
_ratingService.Create(rating);
return(Ok());
}
catch (Exception ex)
{
return(BadRequest(ex.Message));
}
}
public ActionResult Rating(string idMovie, string feedback, double starRate)
{
var use = _applicationUserService.GetUserFromUserName(User.Identity.Name);
var ratingViewModel = new RatingViewModel()
{
UserId = use.Id,
MovieId = Guid.Parse(idMovie),
Feedback = feedback,
StarRating = starRate
};
var result = "success";
var oldRating = _ratingService.Find(ratingViewModel.MovieId, ratingViewModel.UserId);
if (oldRating != null)
{
result = "faild";
}
else
{
var rating = Mapper.Map <Rating>(ratingViewModel);
var listRating = _ratingService.GetAllRatingByIdMovie(ratingViewModel.MovieId);
double value = 0;
if (listRating != null)
{
foreach (var item in listRating)
{
value += item.StarRating;
}
}
float star = (float)((value + rating.StarRating) / (listRating.Count + 1));
var movie = _moviesService.Find(ratingViewModel.MovieId);
movie.Rating = star;
_moviesService.Update(movie, movie.Id);
_ratingService.Create(rating);
}
return(Json(result, JsonRequestBehavior.AllowGet));
}
