public async Task AddRating(RatingCreateRequest request)
{
var categoryRatings = request.CategoryRatings;
var categories = await _categoryRepository.GetByFilterAsync(c =>
categoryRatings.Select(cr => cr.CategoryId).Contains(c.Id));
var scoreWeights = categoryRatings.Join(categories, cr => cr.CategoryId, c => c.Id, (cr, c) => new ScoreWeight {
Score = cr.Score, Weight = c.Weight
}).ToList();
float totalScore = GetTotalScore(scoreWeights);
var rating = await _ratingRepository
.GetFirstByFilterAsync(r =>
r.PlayerProfileId == request.PlayerProfileId &&
r.ItemId == request.ItemId);
if (rating == null)
{
rating = new Rating
{
ItemId = request.ItemId,
PlayerProfileId = request.PlayerProfileId,
TotalScore = totalScore
};
await _ratingRepository.AddAsync(rating);
}
else
{
rating.TotalScore = totalScore;
await _ratingRepository.UpdateAsync(rating);
}
await AddCategoryRatings(categoryRatings, rating.Id);
}
public async Task <RatingVm> PostRating(RatingCreateRequest request)
{
var claimsIdentity = User.Identity as ClaimsIdentity;
string userId = claimsIdentity.FindFirst("sub").Value;
var rating = new RatingProduct
{
TotalStar = request.TotalStar,
Comment = request.Comment,
Date = DateTime.Now,
ApplicationUserId = userId,
IDProduct = request.IDProduct
};
_context.RatingProducts.Add(rating);
await _context.SaveChangesAsync();
var ratingVm = new RatingVm()
{
IDRating = rating.IDRating,
TotalStar = rating.TotalStar,
Comment = rating.Comment,
Date = rating.Date,
UserId = rating.ApplicationUserId,
IDProduct = rating.IDProduct
};
return(ratingVm);
}
public async Task <ActionResult> PostRating(RatingCreateRequest ratingCreateRequest)
{
var transaction = await _context.Database.BeginTransactionAsync();
var rating = new Rating
{
UserId = ratingCreateRequest.UserId,
ProductId = ratingCreateRequest.ProductId,
Star = ratingCreateRequest.Star,
CreatedDate = DateTime.Now,
};
try
{
await _context.Ratings.AddAsync(rating);
await _context.SaveChangesAsync();
var product = await _context.Products.FirstOrDefaultAsync(x => x.ProductId == ratingCreateRequest.ProductId);
var listrating = await _context.Ratings.Where(x => x.ProductId == ratingCreateRequest.ProductId).ToListAsync();
product.StarRating = listrating.Sum(x => x.Star) / listrating.Count;
await _context.SaveChangesAsync();
await transaction.CommitAsync();
}
catch (Exception)
{ }
return(Accepted());
}
public async Task <RatingVm> PostRating(RatingCreateRequest request)
{
var rating = new EcommerceShop.Application.Models.Rating()
{
RateValue = request.RateValue,
FeedBack = request.FeedBack,
UserId = request.UserId,
ProductId = request.ProductId
};
var result = await _context.Ratings.Where(r => r.UserId == request.UserId && r.ProductId == request.ProductId).FirstOrDefaultAsync();
if (result != null)
{
return(new RatingVm());
}
else
{
_context.Ratings.Add(rating);
await _context.SaveChangesAsync();
}
var ratingVm = new RatingVm()
{
RatingId = rating.RatingId,
RateValue = rating.RateValue,
FeedBack = rating.FeedBack,
UserId = rating.UserId,
ProductId = rating.ProductId
};
return(ratingVm);
}
public async Task <bool> Rating(RatingCreateRequest rateRequest)
{
var client = _httpClientFactory.CreateClient();
var json = JsonConvert.SerializeObject(rateRequest);
var data = new StringContent(json, Encoding.UTF8, "application/json");
var res = await client.PostAsync(_configuration.GetValue <string>("Backend") + "Rating", data);
res.EnsureSuccessStatusCode();
if (res.ReasonPhrase.Equals("Created"))
{
return(true);
}
else
{
return(false);
}
/* var result = await res.Content.ReadAsAsync<bool>();
*
* return result;*/
}
public async Task <IActionResult> Create(RatingCreateRequest rating)
{
string userToken = await HttpContext.GetTokenAsync("access_token");
await _ratingClient.PostRating(userToken, rating);
return(RedirectToAction("Details", "Product", new { id = rating.IDProduct }));
}
public async Task <RatingCreateRequest> CreateRating(RatingCreateRequest ratingCreateRequest)
{
HttpContent httpContent = new StringContent(JsonConvert.SerializeObject(ratingCreateRequest), Encoding.UTF8, "application/json");
var response = await _httpClient.PostAsync("api/Ratings", httpContent);
response.EnsureSuccessStatusCode();
return(await response.Content.ReadAsAsync <RatingCreateRequest>());
}
public async Task <RatingVm> PostRating(string userToken, RatingCreateRequest request)
{
// 2 dòng dưới dùng khi muốn chèn access token vào httpclient đề lấy api đã dc bảo mật
_client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", userToken);
var response = await _client.PostAsync("api/rating/", JsonContent.Create(request));
response.EnsureSuccessStatusCode();
return(await response.Content.ReadAsAsync <RatingVm>());
}
public async Task <IActionResult> CreateRating(int id, int star)
{
var claimIdentity = User.Identity as ClaimsIdentity;
string userid = claimIdentity.FindFirst(ClaimTypes.NameIdentifier).Value;
var ratingCreateRequest = new RatingCreateRequest
{
UserId = userid,
ProductId = id,
Star = star,
};
await _ratingApiClient.CreateRating(ratingCreateRequest);
return(RedirectToAction("Detail", "Product", new { id }));
}
public async Task <ActionResult <RatingVm> > PostRating(RatingCreateRequest request)
{
var claimsIdentity = User.Identity as ClaimsIdentity;
string userId = claimsIdentity.FindFirst(ClaimTypes.NameIdentifier).Value;
request.UserId = userId;
var rating = await _ratingService.PostRating(request);
if (rating.RatingId == 0)
{
return(NoContent());
}
return(Ok(rating));
}
public async Task <ActionResult> Rating(RatingCreateRequest ratingCreateRequest)
{
var product = await _context.Products.FindAsync(ratingCreateRequest.ProductId);
if (product == null)
{
return(NotFound());
}
var Rating = await _context.UserRatings
.Where(r => r.ProductId == ratingCreateRequest.ProductId && r.UserId == _userUtility.GetUserId())
.ToListAsync();
if (Rating.Count() == 0)
{
_context.UserRatings.Add(new UserRating
{
UserId = _userUtility.GetUserId(),
ProductId = ratingCreateRequest.ProductId,
Rating = ratingCreateRequest.Rating
});
await _context.SaveChangesAsync();
}
else
{
Rating[0].Rating = ratingCreateRequest.Rating;
await _context.SaveChangesAsync();
}
var ListRating = await _context.UserRatings
.Where(r => r.ProductId == ratingCreateRequest.ProductId)
.Select(x => new UserRating
{
Rating = x.Rating
})
.ToListAsync();
var totalRating = 0;
ListRating.ForEach(x =>
{
totalRating += x.Rating;
});
product.Rating = totalRating / ListRating.Count();
product.RatingCount = ListRating.Count();
await _context.SaveChangesAsync();
return(Ok());
}
public async Task <IActionResult> PutRating(int id, RatingCreateRequest ratingCreateRequest)
{
var rating = await _context.Ratings.FindAsync(id);
if (rating == null)
{
return(NotFound());
}
rating.RatingValue = ratingCreateRequest.RatingValue;
rating.RatingBody = ratingCreateRequest.RatingBody;
await _context.SaveChangesAsync();
return(NoContent());
}
public async Task AddRating([GameCode] string gameCode, RatingCreateRequest request)
{
int.TryParse(Context.Items[KeyConstants.GameCode] as string, out int gameId);
if (int.TryParse(Context.UserIdentifier, out int userId) && userId != 0)
{
request.PlayerProfileId = await _profileService.GetProfileIdByUserGame(userId, gameId);
}
await _ratingService.AddRating(request);
var(ratingsCount, expectedRatingsCount) =
await _gameService.GetVotingStatus(gameId, request.ItemId);
await Clients.Group(gameCode).RefreshVotingProgress(ratingsCount, expectedRatingsCount);
}
public async Task Rating(int productId, int rating)
{
var accessToken = await _httpContextAccessor.HttpContext.GetTokenAsync("access_token");
_client.DefaultRequestHeaders.Authorization = new AuthenticationHeaderValue("Bearer", accessToken);
var ratingCrequest = new RatingCreateRequest {
ProductId = productId,
Rating = rating
};
var response = await _client.PostAsJsonAsync($"{_config["Host"]}/api/Rating", ratingCrequest);
response.EnsureSuccessStatusCode();
await response.Content.ReadAsAsync <IList <CartVM> >();
}
public async Task <RatingVm> PostRating(RatingCreateRequest ratingCreateRequest)
{
//Send access token
var client = _httpClientFactory.CreateClient();
var accessToken = await _httpContextAccessor.HttpContext.GetTokenAsync(OpenIdConnectParameterNames.AccessToken);
client.SetBearerToken(accessToken);
//Send json with body
HttpContent httpContent = new StringContent(JsonConvert.SerializeObject(ratingCreateRequest),
Encoding.UTF8, "application/json");
var response = await client.PostAsync(_configuration["BackendUrl:Default"] + "/api/Ratings", httpContent);
response.EnsureSuccessStatusCode();
return(await response.Content.ReadFromJsonAsync <RatingVm>());
}
public IActionResult AddRating(int ProductId, float rvalue)
{
if (!User.Identity.IsAuthenticated)
{
return(RedirectToAction(actionName: "SignIn", controllerName: "Account"));
}
RatingCreateRequest x = new RatingCreateRequest();
x.RatingValue = rvalue;
x.RatingTime = DateTime.Now;
x.ProductId = ProductId;
//var claimsIdentity = User.Identity as ClaimsIdentity;
//string userId = claimsIdentity.FindFirst("sub").Value;
x.UserId = User.FindFirstValue(ClaimTypes.NameIdentifier);
_ratingApiClient.PostRating(x);
string referer = Request.Headers["Referer"].ToString();
return(Redirect(referer));
}
public async Task <ActionResult <RatingVm> > PostRating(RatingCreateRequest ratingCreateRequest)
{
if (CheckIfExist(ratingCreateRequest.ProductId, ratingCreateRequest.UserId) == true)
{
var ratin = await _context.Ratings.Where(x => x.ProductId == ratingCreateRequest.ProductId && x.UserId == ratingCreateRequest.UserId).FirstOrDefaultAsync();
if (ratin == null)
{
return(NotFound());
}
ratin.RatingValue = ratingCreateRequest.RatingValue;
await _context.SaveChangesAsync();
return(NoContent());
}
var rating = new Rating
{
RatingValue = ratingCreateRequest.RatingValue,
RatingBody = ratingCreateRequest.RatingBody,
RatingTime = ratingCreateRequest.RatingTime,
UserId = ratingCreateRequest.UserId,
ProductId = ratingCreateRequest.ProductId
};
_context.Ratings.Add(rating);
await _context.SaveChangesAsync();
return(CreatedAtAction("GetRating", new { id = rating.RatingId }, new RatingVm {
RatingId = rating.RatingId,
RatingValue = rating.RatingValue,
RatingBody = rating.RatingBody,
RatingTime = rating.RatingTime
}));
}
public async Task <IActionResult> PostRating(RatingCreateRequest rateRequest)
{
var postRating = new ProductRating
{
ProductId = rateRequest.ProductID,
CustomerName = rateRequest.CustomerName,
CustomerEmail = rateRequest.CustomerEmail,
Title = rateRequest.Title,
Content = rateRequest.Content,
Rating = rateRequest.Rating
};
var isPostSuccessRating = await _ratingService.CreateRating(postRating);
if (isPostSuccessRating)
{
return(NoContent());
}
else
{
return(NotFound());
}
}
