public RatingVM Insert(int articleId, int grade)
{
RatingVM viewModel = new RatingVM();
if (articleId == 0 || grade == 0)
{
return(viewModel);
}
Rating rating = new Rating();
rating.ArticleId = articleId;
rating.Grade = grade;
try
{
_context.Rating.Add(rating);
_context.SaveChanges();
}
catch (Exception ex)
{
throw ex;
}
return(_mapper.Map <RatingVM>(rating));
}
public RatingVM Get(string dictaatName, int ratingId)
{
string userId = _userManager.GetUserId(HttpContext.User);
RatingVM result = _ratingRepo.GetRating(ratingId, userId);
return(result);
}
public IActionResult Edit(int id)
{
Rating rating = _ratingrepo.FindById(id);
RatingVM model = _mapper.Map <RatingVM>(rating);
return(View(model));
}
// GET: Auction/Rating
public ActionResult Rating(RatingVM vm)
{
using (var ctx = new AuctionSiteDBEntities())
{
int idcurrent = CurrentContext.GetCurUser().ID;
bool check = ctx.Ratings.Any(r => r.IDUser == vm.ID && r.IDUserRating == idcurrent);
if (check == true)
{
TempData["mess"] = "You Have already rated for this seller!!!";
return(RedirectToAction("ShowWin", "Auction"));
}
int id = vm.ID;
User user = ctx.Users.Where(u => u.ID == id).FirstOrDefault <User>();
if (vm.negativePoint == -1)
{
user.negativePoint++;
}
else
{
user.positivePoint++;
}
//save rating
var rating = new Rating()
{
IDUser = vm.ID,
IDUserRating = CurrentContext.GetCurUser().ID,
};
ctx.Ratings.Add(rating);
ctx.SaveChanges();
}
TempData["mess"] = "Thanks for your rating!!!";
return(RedirectToAction("ShowWin", "Auction"));
}
public RatingVM Post(string dictaatName, [FromBody] RatingVM rating)
{
if (!AuthorizeResrouce(dictaatName))
{
return(null);
}
RatingVM result = _ratingRepo.CreateRating(dictaatName, rating);
return(result);
}
public IActionResult Edit(RatingVM model)
{
Rating rating = _ratingrepo.FindById(model.RatingId);
rating.Value = model.Value;
rating.DateRated = DateTime.Now;
_ratingrepo.Update(rating);
return(RedirectToAction(nameof(Index)));
}
public async Task <IActionResult> AddRating(RatingVM rating)
{
if (rating == null)
{
return(BadRequest("The rating model is null"));
}
bool result = await _ratingService.AddAsync(_mapper.Map <RatingDTO>(rating));
return((result == true)
? Ok()
: (IActionResult)NotFound());
}
public async Task <IActionResult> Create(RatingVM ratingVm)
{
if (ModelState.IsValid)
{
var user = await _userManager.GetUserAsync(User);
_context.Add(new Rating(ratingVm, user.CompanyUser));
await _context.SaveChangesAsync();
return(RedirectToAction(nameof(Index)));
}
return(View(ratingVm));
}
public ActionResult <RatingVM> Create(int productId, RatingVM ratingVM)
{
if (!ModelState.IsValid || productId <= 0)
{
return(BadRequest());
}
var result = _ratingSer.Add(productId, ratingVM);
if (result == null)
{
return(Problem("Can't add rating"));
}
return(CreatedAtAction(nameof(Create), result));
}
public async Task <IActionResult> SubmitAsync(int productId, RatingVM ratingVM)
{
if (!ModelState.IsValid)
{
return(Redirect("/product/" + productId));
}
var userId = User.FindFirstValue(ClaimTypes.NameIdentifier);
ratingVM.UserId = userId;
await _request.CreateAsync(productId, ratingVM);
ViewBag.ProductId = productId;
return(View("Index"));
}
/// <summary>
/// Create a new rating based on a VM
/// </summary>
/// <param name="rating"></param>
/// <returns></returns>
public RatingVM CreateRating(string dictaatName, RatingVM rating)
{
var r = new Rating()
{
DictaatDetailsName = dictaatName,
Timestamp = DateTime.Now,
Title = rating.Title,
Description = rating.Description,
};
_context.Ratings.Add(r);
_context.SaveChanges();
rating.Id = r.Id;
return(rating);
}
public bool UpdateRating(RatingVM model)
{
var data = (from x in _context.Rating
where x.RatingId == model.RatingId
select x).FirstOrDefault();
if (data == null)
{
throw new Exception("Record not found");
}
data.RatingId = model.RatingId;
data.Rating1 = model.Ratings;
return(_context.SaveChanges() > 0);
}
public HttpResponseMessage UpdateRating(RatingVM model)
{
try
{
var response = _repo.UpdateRating(model);
if (response == false)
{
return(Request.CreateResponse(HttpStatusCode.OK, new { success = false, message = "No record found" }));
}
return(Request.CreateResponse(HttpStatusCode.OK, new { success = true, result = response }));
}
catch (Exception ex)
{
return(Request.CreateResponse(HttpStatusCode.OK, new { success = false, message = ex.Message }));
}
}
public bool AddRating(RatingVM model)
{
if (model == null)
{
throw new Exception("There is no Entry!");
}
var data = new Rating
{
RatingId = model.RatingId,
Rating1 = model.Ratings,
};
_context.Rating.Add(data);
return(_context.SaveChanges() > 0);
}
/// <summary>
/// returns null if no question with that Id
/// </summary>
/// <param name="ratingId"></param>
/// <returns></returns>
public RatingVM GetRating(int ratingId, string userId)
{
Rating rating = _context.Ratings.Include("Rates").FirstOrDefault(q => q.Id == ratingId);
if (rating == null)
{
return(null);
}
var result = new RatingVM(rating);
if (userId != null)
{
Rate rate = _context.Rates.FirstOrDefault(r => r.RatingId == rating.Id && r.UserId == userId);
if (rate != null)
{
result.MyRate = new RateVM(rate);
}
}
return(result);
}
public async Task <RatingVM> CreateAsync(int productId, RatingVM ratingVM)
{
var router = routeName + "?productId=" + productId;
return(await _request.PostAsync <RatingVM>(router, ratingVM));
}
