Exemple #1
0
        public async Task <IEnumerable <Order> > Handle(GetOrdersQuery request, CancellationToken cancellationToken)
        {
            var queryable = _db.Orders.AsQueryable();

            if (request.UserId.HasValue)
            {
                queryable = queryable.Where(w => w.UserId == request.UserId.Value);
            }

            if (request.Status.HasValue)
            {
                queryable = queryable.Where(w => w.Status == request.Status.Value);
            }

            if (request.ItemId.HasValue)
            {
                queryable = queryable.Where(w => w.ItemId == request.ItemId.Value);
            }

            if (request.NotExpired.HasValue && request.NotExpired.Value)
            {
                request.IncludeItem = true;
            }

            if (!string.IsNullOrEmpty(request.Sku))
            {
                request.IncludeItem = true;
                queryable           = queryable.Where(w => w.Item.Sku == request.Sku);
            }

            if (request.IncludeItem)
            {
                queryable = queryable.Include(w => w.Item);
            }

            var results = await queryable
                          .OrderByDescending(w => w.Id)
                          .ToListAsync(cancellationToken);

            if (request.NotExpired.HasValue && request.NotExpired.Value)
            {
                results = results.Where(w =>
                {
                    if (!w.Item.ExpirationInMinutes.HasValue)
                    {
                        return(true);
                    }
                    var minutes = w.Item.ExpirationInMinutes.Value;
                    return(DateTimeOffset.UtcNow < w.Timestamp.AddMinutes(minutes));
                }).ToList();
            }

            return(results);
        }
        public async Task <DateTimeOffset> Handle(GetOrdersExpirationQuery request, CancellationToken cancellationToken)
        {
            var query = new GetOrdersQuery
            {
                NotExpired = true, Sku = request.Sku, IncludeItem = true, Status = OrderStatus.Completed,
                UserId     = request.UserId
            };

            var orders = request.Orders ?? await _mediator.Send(query, cancellationToken);

            var preReleaseExpirationRaw = await _mediator.Send(new GetSiteConfigOrThrowCommand
                                                               { Key = "inuvation:pre:expiration:minutes" }, cancellationToken);

            var preReleaseExpirationMinutes = long.Parse(preReleaseExpirationRaw);

            var preRelease = new HashSet <int>();

            foreach (var order in orders)
            {
                if (order.Item.Sku != "rs3-inuvation-access")
                {
                    continue;
                }
                var key = $"inuvation:prerelease:{order.Id}";
                if (await _db.Data.AnyAsync(w => w.Key == key, cancellationToken))
                {
                    preRelease.Add(order.Id);
                }
            }

            var minutes = orders.Sum(w => preRelease.Contains(w.Id)
                ? preReleaseExpirationMinutes * w.Quantity
                : w.Item.ExpirationInMinutes.GetValueOrDefault(int.MaxValue) * w.Quantity);

            return(minutes == 0 ? DateTimeOffset.MinValue : DateTimeOffset.UtcNow.AddMinutes(minutes));
        }