public async Task <Result <PagedList <ProductListItemModel> > > GetProducts([FromBody] VProductSkuFilter filter)
        {
            var result = await productService.GetProductsAsync2(filter);

            var agents =
                await
                _agentService.GetAgents(
                    result.Items.Where(p => p.IdEditedBy.HasValue).Select(p => p.IdEditedBy.Value).Distinct().ToList());

            var toReturn = new PagedList <ProductListItemModel>
            {
                Items = await result.Items.Select(async p =>
                {
                    var productItem = await _mapper.ToModelAsync <ProductListItemModel>(p);
                    if (p.IdEditedBy != null)
                    {
                        productItem.EditedByAgentId = agents.GetValueOrDefault(p.IdEditedBy.Value);
                    }
                    return(productItem);
                }).ToListAsync(),
                Count = result.Count,
            };

            return(toReturn);
        }
        public async Task <Result <SkuListItemModel> > GetSku([FromBody] VProductSkuFilter filter)
        {
            var result = await productService.GetSkusAsync(filter);

            return
                (await
                     (result.Select(async p => await _skuMapper.ToModelAsync <SkuListItemModel>(p)).FirstOrDefault() ??
                     TaskCache <SkuListItemModel> .DefaultCompletedTask));
        }
        public async Task <Result <ICollection <SkuWithStatisticListItemModel> > > GetTopPurchasedSkus(int id)
        {
            ICollection <SkuWithStatisticListItemModel> toReturn = new List <SkuWithStatisticListItemModel>();

            FilterBase idsFilter = new FilterBase {
                Paging = null
            };
            Dictionary <int, int> items = await productService.GetTopPurchasedSkuIdsAsync(idsFilter, id);

            VProductSkuFilter filter = new VProductSkuFilter
            {
                Ids    = items.Select(p => p.Key).ToList(),
                Paging = null
            };

            var result = await productService.GetSkusAsync(filter);

            //only in stock
            var inStockItems = result.Where(dynamic => (ProductType)dynamic.Product.IdObjectType == ProductType.EGс ||
                                            (ProductType)dynamic.Product.IdObjectType == ProductType.Gc ||
                                            ((bool?)dynamic.SafeData.DisregardStock ?? false) ||
                                            ((int?)dynamic.SafeData.Stock ?? 0) > 0)
                               .Select(p => _skuMapper.ToModelAsync <SkuWithStatisticListItemModel>(p));

            foreach (var skuTask in inStockItems)
            {
                var sku = await skuTask;
                int ordered;
                // ReSharper disable once PossibleInvalidOperationException
                // ReSharper disable once AssignNullToNotNullAttribute
                if (items.TryGetValue(sku.Id.Value, out ordered))
                {
                    sku.Ordered = ordered;
                    toReturn.Add(sku);
                }
            }
            return(toReturn.OrderByDescending(p => p.Ordered).Take(20).ToList());
        }
        public async Task <Result <ICollection <SkuListItemModel> > > GetSkus([FromBody] VProductSkuFilter filter)
        {
            var result = await productService.GetSkusAsync(filter);

            return(await result.Select(p => _skuMapper.ToModelAsync <SkuListItemModel>(p)).ToListAsync());
        }