public int AddRating(RatingRequest request)
{
if (request == null)
{
return(-1);
}
var rating = new Rating
{
Description = request.RatingDescription,
Tag = _friendlyContext.Tags.Find(request.TagId)
};
_friendlyContext.Ratings.Add(rating);
_friendlyContext.SaveChanges();
return(rating.Id);
}
public IActionResult Create(long jobId, [FromBody] RatingRequest model)
{
var clientId = long.Parse(User.FindFirstValue(ClaimTypes.NameIdentifier));
UserRole userRole;
if (Enum.TryParse(typeof(UserRole), User.FindFirstValue(ClaimTypes.Role), true, out var role))
{
userRole = (UserRole)role;
}
else
{
return(BadRequest());
}
return(userRole == UserRole.FreeLancer
? CreateAsFreeLancer(clientId, jobId, model)
: CreateAsEmployeer(clientId, jobId, model));
}
public IActionResult GetRatingForBook([FromBody] RatingRequest request)
{
var bookIds = request?.BookIds ?? Array.Empty <int>();
var avgRating = _context.BookRatings
.Where(rating => bookIds.Contains(rating.BookId))
.GroupBy(b => b.BookId)
.Select(grp =>
new AvgRatingDto
{
BookId = grp.Key,
AvgRating = Math.Round(grp.Select(r => r.Rating).Average(), 1)
}).ToArray();
var result = new RatingResponse {
Ratings = avgRating
};
return(Ok(result));
}
public bool EditRating(RatingRequest request)
{
if (request == null)
{
return(false);
}
var rating = _friendlyContext.Ratings.Find(request.RatingId);
if (rating == null)
{
return(false);
}
rating.Description = request.RatingDescription;
rating.Tag = _friendlyContext.Tags.Find(request.TagId);
_friendlyContext.SaveChanges();
return(true);
}
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 async Task <object> AddEditRating(RatingRequest request)
{
if (!ModelState.IsValid)
{
return(JsonResults.Error(400, ModelState.Values.FirstOrDefault().Errors.FirstOrDefault().ErrorMessage.ToString()));
}
try
{
var checkRating = await _ratingService.CheckRating(request);
if (!checkRating)
{
var model = new Rating
{
UserId = request.UserId,
ServiceId = request.ServiceId,
Rating1 = request.Rating1
};
await _ratingService.AddRating(model);
return(JsonResults.Success(model));
}
var rating = await _ratingService.GetRating(request.Id);
rating.Rating1 = request.Rating1;
await _ratingService.UpdateRating(rating);
return(JsonResults.Success(rating));
}
catch (Exception ex)
{
return(JsonResults.Error(400, ex.Message));
}
}
public override void BuildPacket()
{
base.BuildPacket();
var request = new RatingRequest()
{
user_id = GlobalVariables.CurrentUser.UserID,
motion_id = MotionID,
rating = Rating,
version_id = VersionID,
comment_title = CommentTitle,
comment_content = CommentContent
};
byte[] packetData;
using (var stream = new MemoryStream())
{
Serializer.Serialize(stream, request);
packetData = stream.ToArray();
}
GlobalVariables.CountRequest++;
Packet = StoreConnection.BuildServerPacket(packetData.Length + 16, (int)MessageType.Type.RATING, 2,
packetData, GlobalVariables.CountRequest);
}
public void Update(RatingRequest ratingResponse)
{
try
{
Product product = findProduct(ratingResponse.productId);
if (product == null)
{
throw new Exception("El producto no existe");
}
Rating model = listRating(ratingResponse.productId, ratingResponse.userId);
if (model == null)
{
model = new Rating();
model.userId = toGuid(ratingResponse.userId);
model.productId = toGuid(ratingResponse.productId);
model.createdOn = DateTime.Now;
db.Ratings.Add(model);
}
else
{
db.Entry(model).State = EntityState.Modified;
}
model.changedOn = DateTime.Now;
model.stars = ratingResponse.stars;
db.SaveChanges();
product.avgStars = totalRating(ratingResponse.productId);
Update(product);
}
catch (Exception ex)
{
throw ex;
//throw new CrudException("Rating", CrudAction.Update, , ex.Message);
}
}
private IActionResult CreateAsEmployeer(long clientId, long jobId, RatingRequest model)
{
if (!_ratingService.EmployeerCanWriteReview(jobId, clientId))
{
return(Forbid());
}
var freeLancerId = _jobService.GetJobFreeLancerId(jobId);
if (freeLancerId == null)
{
return(BadRequest(new BaseResponse("Job is not started")));
}
var rating = _mapper.Map <Rating>(model);
rating.ClientIdFrom = clientId;
rating.ClientIdTo = freeLancerId.Value;
rating.JobId = jobId;
_ratingService.Create(rating);
return(Ok());
}
public async Task <ActionResult <RatingResponse> > CreateRating([FromBody] RatingRequest ratingDto)
{
string userId = HttpContext.User.FindFirst("id").Value;
return(await _ratingService.CreateRatingAsync(ratingDto, userId));
}
public async Task <bool> CheckRating(RatingRequest request)
{
var rating = await db.Ratings.Where(x => x.Id == request.Id && x.ServiceId == request.ServiceId && x.UserId == request.UserId).FirstOrDefaultAsync();
return(rating != null);
}
public ActionResult Patch([FromBody] RatingRequest request)
{
ProductService.AddRating(request.ProductId, request.Rating);
return(Ok());
}
public static RatingRequest CreateRatingRequest(int quantity, long entityKindId, string currency)
{
RatingRequest ratingRequest = new RatingRequest();
ratingRequest.Quantity = quantity;
ratingRequest.EntityKindId = entityKindId;
ratingRequest.Currency = currency;
return ratingRequest;
}
public async Task <ActionResult <NewRating> > Rate([FromRoute(Name = "id")] Guid restaurantId, RatingRequest rating)
{
var result = await ratingsService.RateAsync(restaurantId, rating.Score, rating.Comment);
return(result);
}
//Update movie ratings
public ActionResult Patch([FromBody] RatingRequest request)
{
MovieService.AddRating(request.MovieId, request.Rating);
return(Ok());
}
private static string BuildRatingRequestJson(RatingRequest request)
{
return($"{{\"attributes\":{{\"value\":{request?.Attributes?.Value}}},\"type\":\"{request?.Type}\"}}");
}
public async Task <ActionResult> Patch(RatingRequest request)
{
await _productService.AddRating(request.ProductId, request.Rating);
return(Ok());
}
public ActionResult Patch([FromBody] RatingRequest request)
{
return(Ok());
}
