Example #1
0
        /// <summary>
        /// 获取section列表
        /// </summary>
        /// <param name="page"></param>
        /// <param name="pagesize"></param>
        /// <param name="loadCount"></param>
        /// <returns></returns>
        public PagerData <SectionModel> GetSectionList(
            string q = null, string sectionType = null,
            int page = 1, int pagesize          = 10)
        {
            string key = GetCacheKey($"{nameof(PageService)}.{nameof(GetSectionList)}", q, sectionType, page.ToString(), pagesize.ToString());

            return(Cache(key, () =>
            {
                var data = new PagerData <SectionModel>();
                //列表
                _SectionDal.PrepareIQueryable((query) =>
                {
                    if (ValidateHelper.IsPlumpString(q))
                    {
                        query = query.Where(x => x.SectionTitle.Contains(q) || x.SectionDescription.Contains(q));
                    }
                    if (ValidateHelper.IsPlumpString(sectionType))
                    {
                        query = query.Where(x => x.SectionType == sectionType);
                    }
                    data.ItemCount = query.Count();
                    var range = PagerHelper.GetQueryRange(page, pagesize);
                    data.DataList = query.OrderByDescending(x => x.UpdateTime).Skip(range[0]).Take(range[1]).ToList();
                    return true;
                });
                return data;
            }));
        }
Example #2
0
        /// <summary>
        /// 分页
        /// </summary>
        /// <typeparam name="T"></typeparam>
        /// <param name="sd"></param>
        /// <param name="page"></param>
        /// <param name="pagesize"></param>
        /// <returns></returns>
        public static SearchDescriptor <T> QueryPage_ <T>(this SearchDescriptor <T> sd, int page, int pagesize)
            where T : class, IESIndex
        {
            var pager = PagerHelper.GetQueryRange(page, pagesize);

            return(sd.Skip(pager.skip).Take(pager.take));
        }
Example #3
0
        public static IFindFluent <T, T> QueryPage <T>(this IFindFluent <T, T> finder, int page, int pagesize)
        {
            var range = PagerHelper.GetQueryRange(page, pagesize);
            var res   = finder.Skip(range.skip).Take(range.take);

            return(res);
        }
Example #4
0
        /// <summary>
        /// 获取评论分页
        /// </summary>
        /// <param name="threadID"></param>
        /// <param name="page"></param>
        /// <param name="pagesize"></param>
        /// <returns></returns>
        public PagerData <CommentModel> GetComments(string threadID, int page, int pagesize)
        {
            if (!ValidateHelper.IsPlumpString(threadID))
            {
                return(null);
            }

            string key = Com.GetCacheKey("commentbll.getcomments", threadID, page.ToString(), pagesize.ToString());

            return(Cache(key, () =>
            {
                var data = new PagerData <CommentModel>();
                int[] range = PagerHelper.GetQueryRange(page, pagesize);
                var _commentDal = new CommentDal();
                _commentDal.PrepareIQueryable((query) =>
                {
                    query = query.Where(x => x.ThreadID == threadID);
                    data.ItemCount = query.Count();
                    data.DataList = query.OrderByDescending(x => x.CommentID)
                                    .Skip(range[0]).Take(range[1]).ToList();
                    return true;
                });
                if (ValidateHelper.IsPlumpList(data.DataList))
                {
                    var useridlist = data.DataList.Select(x => x.UserID).Distinct().Where(x => x > 0).ToArray();
                    if (ValidateHelper.IsPlumpList(useridlist))
                    {
                        var userbll = AppContext.GetObject <IUserService>();
                        var userlist = userbll.GetUserByIDS(useridlist);
                        if (ValidateHelper.IsPlumpList(userlist))
                        {
                            data.DataList.ForEach(x =>
                            {
                                x.UserModel = userlist.Where(m => m.UserID == x.UserID).FirstOrDefault();
                            });
                        }
                    }

                    var parentidlist = data.DataList.Select(x => x.ParentCommentID).Distinct().Where(x => x > 0).ToArray();
                    if (ValidateHelper.IsPlumpList(parentidlist))
                    {
                        var commentslist = GetCommentsByIDS(parentidlist);
                        if (ValidateHelper.IsPlumpList(commentslist))
                        {
                            data.DataList.ForEach(x =>
                            {
                                x.ParentComment = commentslist.Where(m => m.CommentID == x.ParentCommentID).FirstOrDefault();
                            });
                        }
                    }
                }
                return data;
            }));
        }
Example #5
0
        /// <summary>
        /// 分页
        /// </summary>
        public static IQueryable <T> QueryPage <T>(this IOrderedQueryable <T> query, int page, int pagesize)
        {
            var pager = PagerHelper.GetQueryRange(page, pagesize);

            IQueryable <T> q = query;

            if (pager.skip > 0)
            {
                q = q.Skip(pager.skip);
            }
            return(q.Take(pager.take));
        }
Example #6
0
        public List <T> QueryNearBy(Expression <Func <T, bool> > where, int page, int pagesize,
                                    Expression <Func <T, object> > field, GeoInfo point,
                                    double?max_distance = null, double?min_distance = null)
        {
            var condition = Builders <T> .Filter.Empty;

            condition &= Builders <T> .Filter.Near(field, point.Lat, point.Lon, max_distance, min_distance);

            if (where != null)
            {
                condition &= Builders <T> .Filter.Where(where);
            }
            var range = PagerHelper.GetQueryRange(page, pagesize);

            return(this.Set().Find(condition).QueryPage(page, pagesize).ToList());
        }
Example #7
0
        private static List <ProductListV2> LoadData(int page)
        {
            var client = new ElasticClient(new Uri("http://172.16.42.28:9200/"));
            var sd     = new SearchDescriptor <ProductListV2>();

            sd = sd.Index("productlist");
            int pagesize = 100;
            var range    = PagerHelper.GetQueryRange(page, pagesize);

            sd = sd.Skip(range[0]).Take(range[1]);
            var response = client.Search <ProductListV2>(x => sd);

            if (response.IsValid)
            {
                return(response?.Hits.Select(x => x.Source).Where(x => x != null).ToList());
            }
            return(null);
        }
Example #8
0
        public ISearchResponse <ProductListV2> SearchEsProducts(SearchParamModel model)
        {
            ISearchResponse <ProductListV2> response = null;
            var temp = new ProductListV2();

            PrepareES(client =>
            {
                var sd = new SearchDescriptor <ProductListV2>();

                sd = sd.Index(ES_PRODUCTLIST_INDEX);

                sd = sd.Query(q => BuildQuery(model));

                var NAMEOF_ShowCatalogIdList = nameof(temp.ShowCatalogIdList);
                var NAMEOF_BrandId           = nameof(temp.BrandId);
                var NAMEOF_ProductAttributes = nameof(temp.ProductAttributes);

                sd = sd.Aggregations(agg => agg
                                     .Terms(NAMEOF_ShowCatalogIdList, av => av.Field(NAMEOF_ShowCatalogIdList).Size(1000))
                                     .Terms(NAMEOF_BrandId, av => av.Field(NAMEOF_BrandId).Size(1000))
                                     .Terms(NAMEOF_ProductAttributes, av => av.Field(NAMEOF_ProductAttributes).Size(1000)));

                sd = sd.Sort(x => BuildSort(model));

                var range = PagerHelper.GetQueryRange(model.page, model.pagesize);
                sd        = sd.Skip(range[0]).Take(range[1]);

                response = client.Search <ProductListV2>(x => sd);

                return(true);
            });
            if (response == null || !response.IsValid || response.OriginalException != null)
            {
                throw new Exception("ES 挂了");
            }
            return(response);
        }
Example #9
0
        /// <summary>
        /// 搜索
        /// </summary>
        /// <param name="keywords"></param>
        /// <param name="page"></param>
        /// <param name="pageSize"></param>
        /// <returns></returns>
        public PagerData <UserModel> GetPagerList(
            string name = null, string sex = null, string email = null, string keywords = null,
            bool LoadRoleAndPrivilege = false,
            int page = 1, int pageSize = 20)
        {
            string key = string.Format("SearchUserList:name:{0},sex:{1},email:{2},keywords:{3},page:{4},pagesize:{5},"
                                       + "LoadRoleAndPrivilege:{6}",
                                       name, sex, email, keywords, page, pageSize, LoadRoleAndPrivilege);

            return(Cache(key, () =>
            {
                int[] range = PagerHelper.GetQueryRange(page, pageSize);
                var data = new PagerData <UserModel>();

                #region 查询
                _UserDal.PrepareIQueryable((query) =>
                {
                    if (ValidateHelper.IsPlumpString(name))
                    {
                        query = query.Where(x => x.NickName == name);
                        data.UrlParams["name"] = name;
                    }

                    if (ValidateHelper.IsPlumpString(sex))
                    {
                        query = query.Where(x => x.Sex == sex);
                        data.UrlParams["sex"] = name;
                    }

                    if (ValidateHelper.IsPlumpString(email))
                    {
                        query = query.Where(x => x.Email == email);
                        data.UrlParams["email"] = name;
                    }

                    if (ValidateHelper.IsPlumpString(keywords))
                    {
                        query = query.Where(x =>
                                            x.NickName.Contains(keywords) ||
                                            x.Phone.Contains(keywords) ||
                                            x.Email.Contains(keywords) ||
                                            x.Introduction.Contains(keywords) ||
                                            x.QQ.Contains(keywords));
                        data.UrlParams["q"] = keywords;
                    }

                    query = query.OrderByDescending(x => x.UserID);

                    data.ItemCount = query.Count();
                    data.DataList = query.Skip(range[0]).Take(range[1]).ToList();
                    return true;
                });
                #endregion

                if (ValidateHelper.IsPlumpList(data?.DataList) && LoadRoleAndPrivilege)
                {
                    data.DataList = GetRolesForUserList(data.DataList);
                }

                return data;
            }));
        }