public IEnumerable <TOut> Find <TOut>(FilterBundle <TOut> bundle, bool noTracking = false, bool includeSoftDelete = false)
        {
            if (bundle.Page <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(bundle.Page), $"{nameof(bundle.Page)} should be larger than zero");
            }

            if (bundle.PageSize <= 0)
            {
                throw new ArgumentOutOfRangeException(nameof(bundle.PageSize), $"{nameof(bundle.PageSize)} should be larger than zero");
            }



            // Where  Expression

            FilterExpressionHelper <T, TOut> filterExpressionHelper = new FilterExpressionHelper <T, TOut>();

            var whereFilter = filterExpressionHelper.GetFilterPredicateForWhere(bundle.FilterExpression);



            //select


            var select = filterExpressionHelper.BuildSelector();


            var data = PrivateFind(whereFilter, noTracking, includeSoftDelete);

            //order data

            return(filterExpressionHelper.GetFilterPredicateForSort(bundle.Orders, data.Select(select)).Skip((bundle.Page - 1) * bundle.PageSize).Take(bundle.PageSize));
        }
        public void GetPositionTest()
        {
            var repo = new PositionRepository();

            var bundle = new FilterBundle <ReturnType>
            {
                FilterExpression = new List <FilterExpression>
                {
                    new FilterExpression
                    {
                        FilterOperation = FilterOperations.NotEqual,
                        Value           = null,
                        ColumnName      = "Email"
                    },
                    new FilterExpression
                    {
                        FilterOperation = FilterOperations.Contains,
                        Value           = "Tam",
                        ColumnName      = "Name"
                    }
                }
            };

            bundle.Orders.Add(new Order {
                ColumnName = "Name", Dir = OrderDirection.Desc
            });
            bundle.Orders.Add(new Order {
                ColumnName = "Salary", Dir = OrderDirection.Asc
            });
            var data = repo.GetPostions(bundle);

            Assert.IsNotNull(data);
        }
        /// <summary>
        ///
        /// </summary>
        /// <param name="args"></param>
        /// <returns></returns>
        public (FilterChain, string[], string[]) RegisterCliOptions(string[] args)
        {
            // Register Filters
            FilterBundle.RegisterCliOptions();
            _filterCount = CliArgs.GetItems().Count();

            // Register Experimental Filters
            ExperimentalBundle.RegisterCliOptions();
            _experimentalFilterCount = CliArgs.GetItems().Count() - _filterCount;

            // Parse CLI args and generate FilterSet of them
            (var filterChain, string[] nonOptionArgs) = CliArgs.ParseFilterArgs(args);

            // Extract non-option and remaining option arguments
            string[] nonFilterOptionArgs;
            (nonOptionArgs, nonFilterOptionArgs) = CliArgs.ExtractOptionArguments(nonOptionArgs);

            return(filterChain, nonOptionArgs, nonFilterOptionArgs);
        }
 public List <ReturnType> GetPostions(FilterBundle <ReturnType> filterBundle)
 {
     return(_newGenericRepository.Find(filterBundle).ToList());
 }