public List <Rating> GetRatings(string pageName, string pageAccessToken, int count, List <long> blockedUserIds, int?seedPull = null, int?minimumStars = null)
{
// get fields returned
string fields = "created_time%2Creviewer%2Creview_text%2Chas_rating%2Chas_review%2Crating" + (seedPull.HasValue ? "&limit=" + seedPull.Value.ToString() : "");
string endpoint = Endpoints.ACCOUNT_MEDIAS.Replace("{pageName}", pageName).Replace("{fields}", fields).Replace("{pageAccessToken}", pageAccessToken);
List <Rating> ratings = new List <Rating>();
HttpResponse <string> response = Unirest.get(endpoint).asString();
// if http response is success, we will continue, if not, we cannot do much more so we will just say no more available
// and return whatever we currently have
if (response.Code == 200)
{
RatingResponse ratingResponse = JsonConvert.DeserializeObject <RatingResponse>(response.Body);
if (ratingResponse.data != null)
{
// get data from unblocked FB users only
var relevantData = ratingResponse.data.Where(i => i.HasRating && i.HasReview).Where(i => i.Reviewer != null && !blockedUserIds.Contains(i.Reviewer.Id));
if (minimumStars.HasValue)
{
return(relevantData.Where(i => i.RatingValue >= minimumStars.Value).OrderByDescending(i => i.CreateDate).Take(count).ToList());
}
else
{
return(relevantData.OrderByDescending(i => i.CreateDate).Take(count).ToList());
}
}
}
return(ratings);
}
public void getMicroRating(double cat, double lat, double lon, string country)
{
string url = String.Format("{0}/{1}?cat={2}&countryCode={3}&lat={4}&lon={5}", ConfigurationManager.AppSettings["Server"], ConfigurationManager.AppSettings["MicroRating"], cat, country, lat, lon);
string result = iaziClientsync.getApiResponse(url, token);
ratingResponse = JsonConvert.DeserializeObject <RatingResponse>(result);
}
private static Response RateCourseResponse(RatingRequest ratingRequest)
{
DatabaseManager database = new DatabaseManager();
(MySqlDataReader reader, var Connection) = database.RunQuery($"UPDATE course_details SET rating=(rating * ratingCount +{ratingRequest.Rating})/(ratingCount+1) , ratingCount=ratingCount+1 WHERE courseid='{ratingRequest.CourseID}'");
RatingResponse ack = new RatingResponse()
{
Status = "FAIL", Reason = "Failed to rate course."
};
Response resp = new Response()
{
Type = ResponseType.RateCourse, Status = "OK", Content = ack
};
if (reader != null)
{
ack.Reason = "Course Rated Successfully.";
ack.Status = "OK";
Connection.Close();
(reader, Connection) = database.RunQuery($"SELECT rating FROM course_details WHERE courseid='{ratingRequest.CourseID}'");
if (reader != null)
{
reader.Read();
ack.NewRating = float.Parse(reader.GetString(0));
}
}
Connection.Close();
return(resp);
}
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 async Task <IActionResult> ProcessReviewApiAction(string requestedAction, string id)
{
Response.Headers.Add("Cache-Control", "no-cache");
string responseString = string.Empty;
string vtexCookie = HttpContext.Request.Headers[HEADER_VTEX_COOKIE];
ValidatedUser validatedUser = null;
bool userValidated = false;
bool keyAndTokenValid = false;
string vtexAppKey = HttpContext.Request.Headers[HEADER_VTEX_APP_KEY];
string vtexAppToken = HttpContext.Request.Headers[HEADER_VTEX_APP_TOKEN];
if (!string.IsNullOrEmpty(vtexCookie))
{
validatedUser = await this._productReviewsService.ValidateUserToken(vtexCookie);
if (validatedUser != null)
{
if (validatedUser.AuthStatus.Equals(AUTH_SUCCESS))
{
userValidated = true;
}
}
}
if (!string.IsNullOrEmpty(vtexAppKey) && !string.IsNullOrEmpty(vtexAppToken))
{
string baseUrl = HttpContext.Request.Headers[FORWARDED_HOST];
keyAndTokenValid = await this._productReviewsService.ValidateKeyAndToken(vtexAppKey, vtexAppToken, baseUrl);
}
if (string.IsNullOrEmpty(requestedAction))
{
return(BadRequest("Missing parameter"));
}
if ("post".Equals(HttpContext.Request.Method, StringComparison.OrdinalIgnoreCase))
{
string bodyAsText = await new System.IO.StreamReader(HttpContext.Request.Body).ReadToEndAsync();
switch (requestedAction)
{
case REVIEW:
if (!userValidated && !keyAndTokenValid)
{
return(Unauthorized("Invalid User"));
}
Review newReview = JsonConvert.DeserializeObject <Review>(bodyAsText);
bool hasShopperReviewed = await _productReviewsService.HasShopperReviewed(validatedUser.User, newReview.ProductId);
if (hasShopperReviewed)
{
return(Json("Duplicate Review"));
}
bool hasShopperPurchased = await _productReviewsService.ShopperHasPurchasedProduct(validatedUser.User, newReview.ProductId);
Review reviewToSave = new Review
{
ProductId = newReview.ProductId,
Rating = newReview.Rating,
ShopperId = validatedUser.User,
Title = newReview.Title,
Text = newReview.Text,
VerifiedPurchaser = hasShopperPurchased
};
var reviewResponse = await this._productReviewsService.NewReview(reviewToSave);
return(Json(reviewResponse.Id));
break;
case REVIEWS:
if (!keyAndTokenValid)
{
return(Unauthorized());
}
IList <Review> reviews = JsonConvert.DeserializeObject <IList <Review> >(bodyAsText);
List <int> ids = new List <int>();
foreach (Review review in reviews)
{
var reviewsResponse = await this._productReviewsService.NewReview(review);
ids.Add(reviewsResponse.Id);
}
return(Json(ids));
break;
}
}
else if ("delete".Equals(HttpContext.Request.Method, StringComparison.OrdinalIgnoreCase))
{
int[] ids;
switch (requestedAction)
{
case REVIEW:
if (!userValidated && !keyAndTokenValid)
{
return(Json("Invalid User"));
}
if (string.IsNullOrEmpty(id))
{
return(BadRequest("Missing parameter."));
}
ids = new int[1];
ids[0] = int.Parse(id);
return(Json(await this._productReviewsService.DeleteReview(ids)));
break;
case REVIEWS:
if (!keyAndTokenValid)
{
return(Unauthorized());
}
string bodyAsText = await new System.IO.StreamReader(HttpContext.Request.Body).ReadToEndAsync();
ids = JsonConvert.DeserializeObject <int[]>(bodyAsText);
return(Json(await this._productReviewsService.DeleteReview(ids)));
break;
}
}
else if ("patch".Equals(HttpContext.Request.Method, StringComparison.OrdinalIgnoreCase))
{
switch (requestedAction)
{
case REVIEW:
if (!userValidated && !keyAndTokenValid)
{
return(Json("Invalid User"));
}
string bodyAsText = await new System.IO.StreamReader(HttpContext.Request.Body).ReadToEndAsync();
Review review = JsonConvert.DeserializeObject <Review>(bodyAsText);
return(Json(await this._productReviewsService.EditReview(review)));
break;
}
}
else if ("get".Equals(HttpContext.Request.Method, StringComparison.OrdinalIgnoreCase))
{
var queryString = HttpContext.Request.Query;
var searchTerm = queryString["search_term"];
var fromParam = queryString["from"];
var toParam = queryString["to"];
var orderBy = queryString["order_by"];
var status = queryString["status"];
var productId = queryString["product_id"];
switch (requestedAction)
{
case REVIEW:
if (string.IsNullOrEmpty(id))
{
return(BadRequest("Missing parameter."));
}
Review review = await this._productReviewsService.GetReview(int.Parse(id));
return(Json(review));
break;
case REVIEWS:
IList <Review> reviews;
if (string.IsNullOrEmpty(fromParam))
{
fromParam = "0";
}
if (string.IsNullOrEmpty(toParam))
{
toParam = "3";
}
int from = int.Parse(fromParam);
int to = int.Parse(toParam);
IList <Review> searchResult = null;
int totalCount = 0;
if (!string.IsNullOrEmpty(productId))
{
searchResult = await _productReviewsService.GetReviewsByProductId(productId);
}
else
{
searchResult = await _productReviewsService.GetReviews();
}
IList <Review> searchData = await _productReviewsService.FilterReviews(searchResult, searchTerm, orderBy, status);
totalCount = searchData.Count;
searchData = await _productReviewsService.LimitReviews(searchData, from, to);
SearchResponse searchResponse = new SearchResponse
{
Data = new DataElement {
data = searchData
},
Range = new SearchRange {
From = from, To = to, Total = totalCount
}
};
return(Json(searchResponse));
break;
case RATING:
decimal average = await _productReviewsService.GetAverageRatingByProductId(id);
searchResult = await _productReviewsService.GetReviewsByProductId(id);
totalCount = searchResult.Count;
RatingResponse ratingResponse = new RatingResponse
{
Average = average,
TotalCount = totalCount
};
return(Json(ratingResponse));
}
}
return(Json(responseString));
}
private BookCatalog BuildBookCatalogVm(IEnumerable <Book> books, PriceResponse prices, RatingResponse ratings)
{
var priceMap = prices.Prices.ToDictionary(p => p.BookId);
var ratingMap = ratings.Ratings.ToDictionary(p => p.BookId);
var catalogItems = books.Select(b =>
new BookCatalogItem
{
Id = b.Id,
Isbn = b.Isbn,
Title = b.Title,
ReleaseDate = b.ReleaseDate,
Price = priceMap.TryGetValue(b.Id, out Price price) ? price.Amount : 0m,
Rating = ratingMap.TryGetValue(b.Id, out BookRating rating) ? rating.AvgRating : 0
}).ToArray();
