Example #1
0
        public PaginatedQueryable <object> GetOptions(string keywords, int page, int limitPerPage, string handlerParam)
        {
            var param  = ParseParam(handlerParam);
            var ct     = FindDatumType(param.DatumTypeId);
            var finder = string.IsNullOrWhiteSpace(keywords) ? ct.FinderBase() : ct.FinderBase().SearchBase(keywords);

            foreach (var wc in param.WhereConditions)
            {
                finder = finder.WhereBase(wc.Item1, wc.Item2);
            }
            var hasSort = false;

            foreach (var si in param.SortInfos)
            {
                finder  = finder.SortBase(si.Item1, si.Item2);
                hasSort = true;
            }
            if (!hasSort)
            {
                finder = finder.SortBase(ct.DefaultSortFieldName, ct.DefaultSortDescending);
            }
            var q   = finder.AsQueryableBase().DirectCastTo <IQueryable <object> >();
            var pag = new PaginatedQueryable <object>(q, page, limitPerPage);

            return(pag);
        }
        public PaginatedQueryable <object> GetOptions(string keywords, int page, int limitPerPage, string handlerParam)
        {
            var param = ParseParam(handlerParam);
            var ctIds = param.ContentTypeIds;

            if (ctIds.Length == 1)
            {
                var ct     = FindContentType(ctIds[0]);
                var finder = string.IsNullOrWhiteSpace(keywords) ? ct.Finder() : ct.Finder().Search(keywords);
                foreach (var wc in param.WhereConditions)
                {
                    finder = finder.Where(wc.Item1, wc.Item2);
                }
                var hasSort = false;
                foreach (var si in param.SortInfos)
                {
                    finder  = finder.Sort(si.Item1, si.Item2);
                    hasSort = true;
                }
                if (!hasSort)
                {
                    finder = finder.Sort(ct.DefaultSortFieldName, ct.DefaultSortDescending);
                }
                var q   = finder.AsQueryable().DirectCastTo <IQueryable <object> >();
                var pag = new PaginatedQueryable <object>(q, page, limitPerPage);
                return(pag);
            }
            if (!string.IsNullOrWhiteSpace(keywords))
            {
                var kws   = keywords.SplitAsKeywords();
                var preds = PredicateBuilder.False <ProtoContent>();
                preds = preds.And(x => x.ContentFields.Any(cf => kws.Any(k => cf.StringValue.Contains(k))));
                var hasDtExpr = ChronoUtils.Self.TryBuildSearchConditionExpression <ProtoField>(out var searchDtCond,
                                                                                                keywords,
                                                                                                cf => cf.DateTimeValue, true);
                if (hasDtExpr)
                {
                    preds = preds.And(x => x.ContentFields.AsQueryable().Any(searchDtCond));
                }
                var q = _dbContext.ProtoContents.AsQueryable().Where(preds)
                        .Where(x => ctIds.Any(ctId => x.ContentTypeId == ctId))
                        .OrderBy(x => x.ContentFields.FirstOrDefault(cf => cf.StringValue != null).StringValue)
                        .ThenBy(x => x.ContentTypeId).DirectCastTo <IQueryable <object> >();

                var pag = new PaginatedQueryable <object>(q, page, limitPerPage);
                return(pag);
            }
            else
            {
                var q = _dbContext.ProtoContents.Where(x => ctIds.Any(ctId => x.ContentTypeId == ctId))
                        .OrderBy(x => x.ContentFields.FirstOrDefault(cf => cf.StringValue != null).StringValue)
                        .ThenBy(x => x.ContentTypeId).DirectCastTo <IQueryable <object> >();

                var pag = new PaginatedQueryable <object>(q, page, limitPerPage);
                return(pag);
            }
        }
        public ContentListApiResult(ProtoCmsRuntimeContext cmsContext, ContentType contentType, string search,
                                    string sortColumn, bool?isDescending, int offset, int limit, ContentListShape?shape,
                                    IContentFinder finder = null)
        {
            finder = finder ?? contentType.Finder();
            var contentShape = shape ?? ContentListShape.Normal;

            if (!string.IsNullOrWhiteSpace(search))
            {
                finder = finder.Search(search.Trim());
            }
            if (!string.IsNullOrWhiteSpace(sortColumn))
            {
                SortColumn = sortColumn;
                if (isDescending.HasValue)
                {
                    SortIsDescending = isDescending.Value;
                    finder           = finder.Sort(sortColumn, isDescending.Value);
                }
                else
                {
                    SortIsDescending = contentType.DefaultSortDescending;
                    finder           = finder.Sort(sortColumn, contentType.DefaultSortDescending);
                }
            }
            else
            {
                SortColumn = contentType.DefaultSortFieldName;
                if (isDescending.HasValue)
                {
                    SortIsDescending = isDescending.Value;
                    finder           = finder.Sort(contentType.DefaultSortFieldName, isDescending.Value);
                }
                else
                {
                    SortIsDescending = contentType.DefaultSortDescending;
                    finder           = finder.Sort(contentType.DefaultSortFieldName, contentType.DefaultSortDescending);
                }
            }

            if (offset < 0)
            {
                offset = 0;
            }
            if (limit < 1)
            {
                limit = 100;
            }
            var currentPage = offset / limit + 1;

            var paginated = new PaginatedQueryable <ProtoContent>(finder.AsQueryable(), currentPage, limit);
            var rawData   = paginated.CurrentPageQueryable.ToArray();

            CurrentPage    = paginated.CurrentPage;
            TotalPage      = paginated.TotalPage;
            StartNumbering = paginated.StartNumbering;
            GlobalCount    = paginated.Count;
            CurrentCount   = rawData.Length;
            Offset         = paginated.Offset;
            Limit          = paginated.Limit;
            SearchKeywords = search;
            ResultShape    = $"{contentShape.ToString()} ({(int) contentShape})";
            var data   = new List <dynamic>();
            var getter = new ContentShapedApiModelBuilder();

            foreach (var rd in rawData)
            {
                data.Add(getter.GetContentShaped(rd, contentType, cmsContext, contentShape));
            }
            Data = data.ToArray();
        }