Exemple #1
0
        public async Task <ActionResult <IEnumerable <Product_CategoryDto> > > GetTreeAsync(int id)
        {
            byte[] bytes = await distributedCache.GetAsync($"Product_Category_{id}");

            IEnumerable <Product_CategoryDto> data = Enumerable.Empty <Product_CategoryDto>();

            if (bytes == null)
            {
                data = await repositoryWrapper.Product_CategoryRepository.GetTreeProduct_CategoryDtoesAsync(id);

                await cacheHelper.SetRedisCacheAsync($"Product_Category_{id}", data);

                //DistributedCacheEntryOptions options = new DistributedCacheEntryOptions()
                //{
                //    SlidingExpiration = TimeSpan.FromHours(3)
                //};
                //using (MemoryStream stream = new MemoryStream())
                //{
                //      Serializer.Serialize(stream, data);
                //      await distributedCache.SetAsync($"Product_Category_{id}", stream.ToArray(), options);
                //}
                return(data.ToList());
            }
            //using (MemoryStream stream = new MemoryStream(bytes))
            //{

            //     data= Serializer.Deserialize<IEnumerable<Product_CategoryDto>>(stream);

            //}
            data = await cacheHelper.GetRedisCacheAsync <IEnumerable <Product_CategoryDto> >(bytes);

            return(data.ToList());
        }
        public async Task <ActionResult <List <ChartDto> > > GetChartDataAsync()
        {
            IEnumerable <ChartDto> list = Enumerable.Empty <ChartDto>();

            byte[] bytes = await _distributedCache.GetAsync("chartData");

            if (bytes == null)
            {
                var orders = await _repositoryWrapper.OrderRepository.GetAllAsync();

                List <ChartDto> chartDtos = new List <ChartDto>();

                foreach (var item in orders.Where(m => m.Status != 4).ToList())
                {
                    ChartDto chartDto = new ChartDto();
                    var      product  = await _repositoryWrapper.ProductRepository.GetByIdAsync(item.ProductId);

                    var cate = await _repositoryWrapper.Product_CategoryRepository.GetByIdAsync(product.Product_CategoryId);

                    if (cate.Id == 30 || cate.Id == 31 || cate.Id == 32)
                    {
                        chartDto.Id    = cate.Id;
                        chartDto.Name  = cate.Title;
                        chartDto.Count = item.Count;
                        chartDtos.Add(chartDto);
                        continue;
                    }
                    var parentCate = await _repositoryWrapper.Product_CategoryRepository.GetByIdAsync(cate.PId);

                    chartDto.Id    = parentCate.Id;
                    chartDto.Name  = parentCate.Title;
                    chartDto.Count = item.Count;
                    chartDtos.Add(chartDto);
                }

                list = chartDtos.GroupBy(m => m.Name).Select(g => new ChartDto {
                    Name = g.Key.ToString(), Count = g.Sum(m => m.Count), Id = g.FirstOrDefault().Id
                }).OrderBy(m => m.Id).ToList();
                await _cacheHelper.SetRedisCacheAsync("chartData", list);

                return(list.ToList());
            }
            list = await _cacheHelper.GetRedisCacheAsync <List <ChartDto> >(bytes);

            return(list.ToList());;
        }
        public async Task <ActionResult <PageList <Product> > > GetProductsAsync(int typeId, [FromQuery] PageParameters pageParameters)
        {
            PageList <Product> data = new PageList <Product>();

            //名称查询缓冲
            if (!string.IsNullOrEmpty(pageParameters.Name))
            {
                //价格排序缓冲
                if (pageParameters.IsPriceSort != null)
                {
                    byte[] pricebytes = await distributedCache.GetAsync($"Product_Price_{typeId}_{pageParameters.PageIndex}_{pageParameters.Name}_{pageParameters.IsPriceSort}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}");

                    if (pricebytes == null)
                    {
                        data = await repositoryWrapper.ProductRepository.GetPageListsAsync(pageParameters, typeId);

                        await cacheHelper.SetRedisCacheAsync <PageList <Product> >($"Product_Price_{typeId}_{pageParameters.PageIndex}_{pageParameters.Name}_{pageParameters.IsPriceSort}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}", data);

                        return(data);
                    }
                    else
                    {
                        data = await cacheHelper.GetRedisCacheAsync <PageList <Product> >(pricebytes);

                        return(data);
                    }
                }

                //购买量查询
                if (pageParameters.IsPurchaseSort != null)
                {
                    byte[] purchasebytes = await distributedCache.GetAsync($"Product_Purchase_{typeId}_{pageParameters.PageIndex}_{pageParameters.Name}_{pageParameters.IsPurchaseSort}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}");

                    if (purchasebytes == null)
                    {
                        data = await repositoryWrapper.ProductRepository.GetPageListsAsync(pageParameters, typeId);

                        await cacheHelper.SetRedisCacheAsync <PageList <Product> >($"Product_Purchase_{typeId}_{pageParameters.PageIndex}_{pageParameters.Name}_{pageParameters.IsPurchaseSort}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}", data);

                        return(data);
                    }
                    else
                    {
                        data = await cacheHelper.GetRedisCacheAsync <PageList <Product> >(purchasebytes);

                        return(data);
                    }
                }

                //时间查询
                if (pageParameters.IsTimeSort != null)
                {
                    byte[] timebytes = await distributedCache.GetAsync($"Product_Time_{typeId}_{pageParameters.PageIndex}_{pageParameters.Name}_{pageParameters.IsTimeSort}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}");

                    if (timebytes == null)
                    {
                        data = await repositoryWrapper.ProductRepository.GetPageListsAsync(pageParameters, typeId);

                        await cacheHelper.SetRedisCacheAsync <PageList <Product> >($"Product_Time_{typeId}_{pageParameters.PageIndex}_{pageParameters.Name}_{pageParameters.IsTimeSort}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}", data);

                        return(data);
                    }
                    else
                    {
                        data = await cacheHelper.GetRedisCacheAsync <PageList <Product> >(timebytes);

                        return(data);
                    }
                }

                //名称查询
                byte[] bytes = await distributedCache.GetAsync($"Product_Name_{typeId}_{pageParameters.PageIndex}_{pageParameters.Name}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}");

                if (bytes == null)
                {
                    data = await repositoryWrapper.ProductRepository.GetPageListsAsync(pageParameters, typeId);

                    await cacheHelper.SetRedisCacheAsync <PageList <Product> >($"Product_Name_{typeId}_{pageParameters.PageIndex}_{pageParameters.Name}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}", data);

                    return(data);
                }
                else
                {
                    data = await cacheHelper.GetRedisCacheAsync <PageList <Product> >(bytes);

                    return(data);
                }
            }

            //价格排序缓冲
            if (pageParameters.IsPriceSort != null)
            {
                byte[] pricebytes = await distributedCache.GetAsync($"Product_Price_{typeId}_{pageParameters.PageIndex}_{pageParameters.IsPriceSort}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}");

                if (pricebytes == null)
                {
                    data = await repositoryWrapper.ProductRepository.GetPageListsAsync(pageParameters, typeId);

                    await cacheHelper.SetRedisCacheAsync <PageList <Product> >($"Product_Price_{typeId}_{pageParameters.PageIndex}_{pageParameters.IsPriceSort}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}", data);

                    return(data);
                }
                else
                {
                    data = await cacheHelper.GetRedisCacheAsync <PageList <Product> >(pricebytes);

                    return(data);
                }
            }

            //购买量查询
            if (pageParameters.IsPurchaseSort != null)
            {
                byte[] purchasebytes = await distributedCache.GetAsync($"Product_Purchase_{typeId}_{pageParameters.PageIndex}_{pageParameters.IsPurchaseSort}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}");

                if (purchasebytes == null)
                {
                    data = await repositoryWrapper.ProductRepository.GetPageListsAsync(pageParameters, typeId);

                    await cacheHelper.SetRedisCacheAsync <PageList <Product> >($"Product_Purchase_{typeId}_{pageParameters.PageIndex}_{pageParameters.IsPurchaseSort}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}", data);

                    return(data);
                }
                else
                {
                    data = await cacheHelper.GetRedisCacheAsync <PageList <Product> >(purchasebytes);

                    return(data);
                }
            }

            //时间查询
            if (pageParameters.IsTimeSort != null)
            {
                byte[] timebytes = await distributedCache.GetAsync($"Product_Time_{typeId}_{pageParameters.PageIndex}_{pageParameters.IsTimeSort}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}");

                if (timebytes == null)
                {
                    data = await repositoryWrapper.ProductRepository.GetPageListsAsync(pageParameters, typeId);

                    await cacheHelper.SetRedisCacheAsync <PageList <Product> >($"Product_Time_{typeId}_{pageParameters.PageIndex}_{pageParameters.IsTimeSort}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}", data);

                    return(data);
                }
                else
                {
                    data = await cacheHelper.GetRedisCacheAsync <PageList <Product> >(timebytes);

                    return(data);
                }
            }

            //正常查询
            byte[] noParameterbytes = await distributedCache.GetAsync($"Product_{typeId}_{pageParameters.PageIndex}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}");

            if (noParameterbytes == null)
            {
                data = await repositoryWrapper.ProductRepository.GetPageListsAsync(pageParameters, typeId);

                await cacheHelper.SetRedisCacheAsync <PageList <Product> >($"Product_{typeId}_{pageParameters.PageIndex}_Price_{pageParameters.BottomPrice}_{pageParameters.TopPrice}", data);

                return(data);
            }
            else
            {
                data = await cacheHelper.GetRedisCacheAsync <PageList <Product> >(noParameterbytes);

                return(data);
            }
        }