public PagingList <T> GetWithCriteria <T>(Criteria criteria, string includeProperties = null) where T : class
        {
            var toReturn     = new PagingList <T>();
            var query        = base.Set <T>().IncludePropertyListCsv(includeProperties);
            var queryBuilder = query as IQueryable <T>;

            if (criteria.FilterFieldName != null && criteria.FilterFieldValue != null)
            {
                queryBuilder = queryBuilder.Where(
                    DynamicExpressionBuilder.BuildFilterExpression <T>(
                        criteria.FilterFieldName,
                        criteria.FilterFieldValue,
                        StringFilterOperator.Contains));
            }

            toReturn.TotalCount = queryBuilder.Count();

            if (criteria.SortFieldName != null)
            {
                queryBuilder = queryBuilder.OrderBy(
                    property: criteria.SortFieldName,
                    direction: (criteria.SortDirection == SortDirection.Ascending) ? "ASC" : "DESC");
            }

            if (criteria.PageSize != -1)
            {
                queryBuilder = queryBuilder
                               .Skip(criteria.PageSize * (criteria.PageNumber - 1))
                               .Take(criteria.PageSize);
            }

            toReturn.AddRange(queryBuilder);

            return(toReturn);
        }
示例#2
0
        internal PagingList <T> GetWithCriteria(Expression <Func <T, bool> > selector, ISearchCriteria criteria, string includeProperties = null)
        {
            var            toReturn     = new PagingList <T>();
            IQueryable <T> queryBuilder = GetWithCriteriaQueryable(selector, includeProperties);

            if (!string.IsNullOrEmpty(criteria.SortFieldName))
            {
                queryBuilder = queryBuilder.OrderBy(
                    property: criteria.SortFieldName,
                    direction: (criteria.SortDirection == SortDirection.Ascending) ? "ASC" : "DESC");
            }

            toReturn.TotalCount = queryBuilder.Count();

            //Skip can only be used with sorting
            if (criteria.PageSize != -1 && !string.IsNullOrEmpty(criteria.SortFieldName))
            {
                queryBuilder = queryBuilder
                               .Skip(criteria.PageSize * (criteria.PageNumber - 1))
                               .Take(criteria.PageSize);
            }

            toReturn.AddRange(queryBuilder);

            return(toReturn);
        }
        public PagingList <T> GetWithCriteria <T>(Criteria criteria, string includeProperties = null) where T : class
        {
            var toReturn     = new PagingList <T>();
            var table        = _session.GetTable <T>();
            var queryBuilder = table as CqlQuery <T>;

            if (criteria.FilterFieldName != null && criteria.FilterFieldValue != null)
            {
                queryBuilder = queryBuilder.Where(
                    DynamicExpressionBuilder.BuildFilterExpression <T>(
                        criteria.FilterFieldName,
                        criteria.FilterFieldValue,
                        StringFilterOperator.Equals));
            }

            var select     = queryBuilder.Select(m => m);
            var expression = select.Expression;

            Type d1 = typeof(CqlQuery <>);

            Type[] typeArgs          = { typeof(T) };
            Type   typeToInstantiate = d1.MakeGenericType(typeArgs);


            var cqlQuery = Activator.CreateInstance(typeToInstantiate,
                                                    System.Reflection.BindingFlags.NonPublic |
                                                    System.Reflection.BindingFlags.Instance,
                                                    null, new object[] { expression, table }, null) as CqlQuery <T>;

            var records = cqlQuery.Execute().ToList();

            toReturn.TotalCount = records.Count;

            if (criteria.SortFieldName != null)
            {
                records = records.AsQueryable <T>().OrderBy(
                    property: criteria.SortFieldName,
                    direction: (criteria.SortDirection == SortDirection.Ascending) ? "ASC" : "DESC").ToList();
            }

            if (criteria.PageSize != -1)
            {
                records = records
                          .Skip(criteria.PageSize * (criteria.PageNumber - 1))
                          .Take(criteria.PageSize)
                          .ToList();
            }


            toReturn.AddRange(records);

            return(toReturn);
        }
        public PagingList <T> GetWithCriteria <T>(
            IList <Expression <Func <T, bool> > > selectors,
            string sortFieldName        = null,
            SortDirection sortDirection = SortDirection.Ascending,
            int pageSize             = 10,
            int pageNumber           = 1,
            string includeProperties = null) where T : class
        {
            var toReturn = new PagingList <T>();
            var query    = _session.GetTable <T>() as CqlQuery <T>;

            foreach (var selector in selectors)
            {
                query = query.Where(selector);
            }

            var records = query
                          .Select(m => m)
                          .Execute()
                          .ToList();

            toReturn.TotalCount = records.Count;

            if (sortFieldName != null)
            {
                records = records.AsQueryable <T>().OrderBy(
                    property: sortFieldName,
                    direction: (sortDirection == SortDirection.Ascending) ? "ASC" : "DESC").ToList();
            }

            if (pageSize != -1)
            {
                records = records
                          .Skip(pageSize * (pageNumber - 1))
                          .Take(pageSize)
                          .ToList();
            }


            toReturn.AddRange(records);

            return(toReturn);
        }