Example #1
0
        public ActionResult GetList(string filter, DateTime loadTime, DateTime?updateTime, int page = 1,
                                    string types     = null, string platforms       = null, bool isUpdate = false,
                                    bool orderByTime = false, Enums.CouponSort sort = Enums.CouponSort.Default,
                                    decimal minPrice = 0, decimal maxPrice          = 0)
        {
            var model = new CouponSearchModel()
            {
                Platform    = platforms.SplitToArray <Enums.CouponPlatform>(),
                UserId      = User.Identity.GetUserId(),
                Type        = types.SplitToArray <int>(),
                Filter      = filter,
                LoadTime    = loadTime,
                UpdateTime  = updateTime,
                OrderByTime = orderByTime,
                IsUpdate    = isUpdate,
                MaxPrice    = maxPrice,
                MinPrice    = minPrice,
                Sort        = sort
            };

            ViewBag.IsUpdate = isUpdate;
            if (isUpdate)
            {
                var list = QueryCoupon(model);
                return(View(list));
            }
            else
            {
                var stwatch = new System.Diagnostics.Stopwatch();
                stwatch.Start();
                var paged  = QueryCoupon(model).ToPagedList(page, 50);
                var models = paged.Distinct(new CouponUserViewModelComparer());
                ViewBag.Paged = paged;
                stwatch.Stop();
                Comm.WriteLog("QueryCoupon", $"查券时间{stwatch.Elapsed.TotalSeconds}秒", Enums.DebugLogLevel.Normal);
                return(View(models));
            }
        }
Example #2
0
        public ActionResult GetAll(string filter,
                                   DateTime?loadTime, DateTime?updateTime, bool isUpdate = false,
                                   int page         = 1, string types = null,
                                   string platforms = null,
                                   bool orderByTime = false, Enums.CouponSort sort = Enums.CouponSort.Default,
                                   decimal minPrice = 0, decimal maxPrice          = 0, string userId = null, int pageSize = 50)
        {
            loadTime = loadTime.HasValue ? loadTime : DateTime.Now;
            var model = new CouponSearchModel()
            {
                Platform    = platforms.SplitToArray <Enums.CouponPlatform>(),
                UserId      = userId,
                Type        = types.SplitToArray <int>(),
                Filter      = filter,
                LoadTime    = loadTime.Value,
                UpdateTime  = updateTime,
                OrderByTime = orderByTime,
                IsUpdate    = isUpdate,
                MaxPrice    = maxPrice,
                MinPrice    = minPrice,
                Sort        = sort,
            };

            if (isUpdate)
            {
                var models = QueryCoupon(model).Select(s => new Models.ActionCell.CouponCell(s)).ToList();
                return(Json(Comm.ToJsonResult("Success", "成功", models), JsonRequestBehavior.AllowGet));
            }
            else
            {
                var paged  = QueryCoupon(model).ToPagedList(page, pageSize);
                var models = paged.Distinct(new CouponUserViewModelComparer())
                             .Select(s => new Models.ActionCell.CouponCell(s)).ToList();
                return(Json(Comm.ToJsonResultForPagedList(paged, models), JsonRequestBehavior.AllowGet));
            }
        }
Example #3
0
        private IQueryable <CouponUserViewModel> QueryCoupon(CouponSearchModel model)
        {
            string couponUserID = Bll.Accounts.GetCouponUserID(model.UserId);
            IQueryable <CouponQuery> query;

            if (!string.IsNullOrWhiteSpace(couponUserID))
            {
                query = from u in db.CouponUsers
                        from s in db.Coupons
                        join f in db.Favorites
                        .Where(s => s.Type == Enums.FavoriteType.Coupon && s.UserID == model.UserId)
                        on s.ID equals f.CouponID
                        into sf
                        where u.CouponID == s.ID && u.UserID == couponUserID
                        select new CouponQuery
                {
                    CreateDateTime = s.CreateDateTime,
                    DataJson       = s.DataJson,
                    Discount       = s.OriginalPrice - s.Price,
                    DiscountRate   = (s.OriginalPrice - s.Price) / s.OriginalPrice,
                    EndDateTime    = s.EndDateTime,
                    Commission     = s.Commission,
                    CommissionRate = s.CommissionRate,
                    ID             = s.ID,
                    Image          = s.Image,
                    Link           = u.Link,
                    Name           = s.Name,
                    OriginalPrice  = s.OriginalPrice,
                    Platform       = s.Platform,
                    Price          = s.Price,
                    ProductID      = s.ProductID,
                    ProductType    = s.ProductType,
                    Sales          = s.Sales,
                    ShopName       = s.ShopName,
                    StartDateTime  = s.StartDateTime,
                    Subtitle       = s.Subtitle,
                    Type           = s.Type,
                    TypeID         = s.TypeID,
                    Value          = s.Value,
                    UserID         = u.UserID,
                    IsFavorite     = false,
                    FavoriteID     = 0,
                    HotSort        = s.Price > 19.99m && s.Price < 150.01m ? 0 : 1
                };
            }
            else
            {
                query = from s in db.Coupons
                        join f in db.Favorites
                        .Where(s => s.Type == Enums.FavoriteType.Coupon && s.UserID == model.UserId)
                        on s.ID equals f.CouponID
                        into sf
                        select new CouponQuery
                {
                    CreateDateTime = s.CreateDateTime,
                    DataJson       = s.DataJson,
                    Discount       = s.OriginalPrice - s.Price,
                    DiscountRate   = (s.OriginalPrice - s.Price) / s.OriginalPrice,
                    EndDateTime    = s.EndDateTime,
                    Commission     = s.Commission,
                    CommissionRate = s.CommissionRate,
                    ID             = s.ID,
                    Image          = s.Image,
                    Link           = null,
                    Name           = s.Name,
                    OriginalPrice  = s.OriginalPrice,
                    Platform       = s.Platform,
                    Price          = s.Price,
                    ProductID      = s.ProductID,
                    ProductType    = s.ProductType,
                    Sales          = s.Sales,
                    ShopName       = s.ShopName,
                    StartDateTime  = s.StartDateTime,
                    Subtitle       = s.Subtitle,
                    Type           = s.Type,
                    TypeID         = s.TypeID,
                    Value          = s.Value,
                    UserID         = null,
                    IsFavorite     = sf.Any(),
                    FavoriteID     = sf.Any() ? sf.FirstOrDefault().ID : 0,
                    HotSort        = s.Price > 19.99m && s.Price < 150.01m ? 0 : 1
                };
            }
            query = query.Where(s => s.EndDateTime > DateTime.Now);
            //不显示创建时间是未来的和过期的
            if (model.OrderByTime)
            {
                if (!model.IsUpdate)
                {
                    query = query.Where(s => s.CreateDateTime < model.LoadTime);
                }
                else
                {
                    query = query.Where(s => s.CreateDateTime < model.UpdateTime && s.CreateDateTime >= model.LoadTime);
                }
            }

            if (model.Type != null && model.Type.Count > 0 && model.Type.Contains(0))
            {
                model.Type.Remove(0);
            }
            if (model.Type != null && model.Type.Count > 0)
            {
                query = query.Where(s => s.TypeID.HasValue && (model.Type.Contains(s.Type.ID) ||
                                                               model.Type.Contains(s.Type.ParentID)));
            }
            if (model.Platform != null && model.Platform.Count > 0)
            {
                if (model.Platform.Contains(Enums.CouponPlatform.TaoBao) ||
                    model.Platform.Contains(Enums.CouponPlatform.TMall))
                {
                    model.Platform.Add(Enums.CouponPlatform.TaoBao);
                    model.Platform.Add(Enums.CouponPlatform.TMall);
                }
                query = query.Where(s => model.Platform.Contains(s.Platform));
            }
            if (!string.IsNullOrWhiteSpace(model.Filter))
            {
                var filterList = Bll.Keywords.Split(model.Filter);
                foreach (var item in filterList)
                {
                    query = query.Where(s => s.Name.Contains(item) || s.ProductType.Contains(item));
                }
            }
            if (model.MinPrice > 0)
            {
                query = query.Where(s => s.Price >= model.MinPrice);
            }
            if (model.MaxPrice > 0)
            {
                query = query.Where(s => s.Price <= model.MaxPrice);
            }
            switch (model.Sort)
            {
            case Enums.CouponSort.Sales:
            {
                query = query.OrderByDescending(s => s.Sales);
            }
            break;

            case Enums.CouponSort.CreateTime:
            {
                query = query.OrderByDescending(s => s.CreateDateTime);
            }
            break;

            case Enums.CouponSort.CouponValue:
            {
                query = query.OrderByDescending(s => s.Discount).ThenByDescending(s => s.Sales);
            }
            break;

            case Enums.CouponSort.CouponPrice:
            {
                query = query.OrderBy(s => s.Price).ThenByDescending(s => s.Sales);
            }
            break;

            case Enums.CouponSort.CouponPriceDesc:
            {
                query = query.OrderByDescending(s => s.Price).ThenByDescending(s => s.Sales);
            }
            break;

            case Enums.CouponSort.Commission:
            {
                query = query.OrderByDescending(s => s.CommissionRate)
                        .ThenByDescending(s => s.Commission)
                        .ThenByDescending(s => s.Sales);
            }
            break;

            case Enums.CouponSort.TodayTop:
            {
                query = query.Where(s => s.Price > 19.99m &&
                                    s.Price <150.01m &&
                                             s.CommissionRate> 0.3m)
                        .OrderByDescending(s => s.CommissionRate);
            }
            break;

            case Enums.CouponSort.Default:
            default:
            {
                query = query.OrderByDescending(s => s.HotSort)
                        .ThenByDescending(s => s.CommissionRate)
                        .ThenByDescending(s => s.Sales);
                //query = query.Select(s => new
                //{
                //    result = s.Price > 19.99m && s.Price < 150.01m ? 0 : 1,
                //    CouponQuery = s
                //}).OrderBy(s => s.result)
                //.ThenByDescending(s => s.CouponQuery.CommissionRate)
                //.ThenByDescending(s => s.CouponQuery.Sales)
                //.Select(s => s.CouponQuery);
            }
            break;
            }
            //DateTime limit = DateTime.Now.Date.AddDays(-3);
            //query = query.Where(s => s.CreateDateTime >= limit);
            return(query);
        }