Beispiel #1
0
        public async Task <IActionResult> GetRatingList([FromQuery] RatingQuery query)
        {
            var ratings = await _ratingService.GetRatingList(query);

            Response.AddPaginationHeader(ratings, nameof(GetRatingList), query, Url);
            return(Ok(new RatingList(ratings)));
        }
        internal static async Task RouteAsync(string message)
        {
            JObject receivedObj   = JsonConvert.DeserializeObject <JObject>(message);
            string  command       = receivedObj["Command"].Value <string>();
            int     eventId       = receivedObj["EventId"].Value <int>();
            string  correlationId = receivedObj["CorrelationId"].Value <string>();
            string  replyTo       = receivedObj["ReplyTo"].Value <string>();

            switch (command)
            {
            case "add":
                int    feedback = receivedObj["Feedback"].Value <int>();
                Rating rating   = new Rating(AppDb.Instance)
                {
                    EventId  = eventId,
                    Feedback = feedback
                };

                if (AppDb.Instance.Connection.State != System.Data.ConnectionState.Open)
                {
                    await AppDb.Instance.Connection.OpenAsync();
                }
                await rating.InsertAsync();

                break;

            case "get":
                if (AppDb.Instance.Connection.State != System.Data.ConnectionState.Open)
                {
                    await AppDb.Instance.Connection.OpenAsync();
                }
                RatingQuery query       = new RatingQuery(AppDb.Instance);
                Rating      foundRating = await query.FindOneAsync(eventId);

                if (!(foundRating is null))
                {
                    // Convert to JSON without a command
                    MessageGateway.PublishRPC(replyTo, correlationId, foundRating.ConvertToJson(""));
                }
                break;

            default:
                Console.WriteLine("No such command");
                break;
            }
        }
Beispiel #3
0
        public Task <IPagedCollection <RatingDetail> > GetRatingList(RatingQuery query)
        {
            if (query is null)
            {
                throw new ArgumentNullException(nameof(query));
            }

            return(GetRatingList());

            async Task <IPagedCollection <RatingDetail> > GetRatingList()
            {
                var filter = _filter
                             .WhereMovieId(query.MovieId)
                             .WhereRating(query.MinimumScore, query.MaximumScore)
                             .WhereTimestamp(query.MinimumTimestamp, query.MaximumTimestamp)
                             .WhereUserId(query.UserId)
                             .Filter;

                var ratingsFromDb = await _context
                                    .Ratings
                                    .TagWithQueryName(nameof(GetRatingList))
                                    .AsNoTracking()
                                    .Where(filter)
                                    .Include(rating => rating.User)
                                    .Include(rating => rating.Movie)
                                    .OrderBy(query.Order, _order)
                                    .ToPagedCollectionAsync(query.Page, query.Limit)
                                    .ConfigureAwait(false);

                var ratings = _mapper.Map <IReadOnlyList <RatingDetail> >(ratingsFromDb);

                return(new PagedCollection <RatingDetail>(
                           ratings,
                           ratingsFromDb.ItemCount,
                           ratingsFromDb.CurrentPageNumber,
                           ratingsFromDb.PageSize));
            }
        }