Esempio n. 1
0
        protected virtual Expression <Func <TEntity, bool> > GetEntitySearchQueryExpression <TEntity>(string searchQuery)
            where TEntity : class, IEntityBase
        {
            var searchQueryArray = searchQuery.ToLower().Split(' ', ',', ';');

            Type entityType       = typeof(TEntity);
            var  entityProperties = entityType.GetProperties();
            var  expressionsList  = new List <Expression <Func <TEntity, bool> > >();

            foreach (var property in entityProperties)
            {
                if (property.GetCustomAttributes(typeof(SearchCriteriaAttribute), false).Length > 0)
                {
                    Expression <Func <TEntity, bool> > currentExpression = x =>
                                                                           x.GetType().GetProperty(property.Name).GetValue(x) != null &&
                                                                           (x.GetType().GetProperty(property.Name).GetValue(x).ToString().ToLower().Contains(searchQuery.ToLower()) ||
                                                                            searchQueryArray.Contains(x.GetType().GetProperty(property.Name).GetValue(x).ToString().ToLower()));

                    expressionsList.Add(currentExpression);
                }
            }

            var propertyExpression = expressionsList.FirstOrDefault();

            for (int i = 1; i < expressionsList.Count; i++)
            {
                propertyExpression = ExpressionFunctions.OrElse <TEntity>(propertyExpression, expressionsList[i]);
            }

            return(propertyExpression);
        }
Esempio n. 2
0
        /// <summary>
        /// Extract filter expression for entity by search string.
        /// </summary>
        /// <typeparam name="TEntity">Target entity.</typeparam>
        /// <param name="searchQuery"></param>
        /// <returns></returns>
        public static Expression <Func <TEntity, bool> > BuildQueryExpressionBySearchQuery <TEntity>(string searchQuery)
        {
            if (!string.IsNullOrWhiteSpace(searchQuery))
            {
                searchQuery = searchQuery.Trim();
            }

            var  allowedTypes        = DefaultValues.OrderTypes;
            Type entityType          = typeof(TEntity);
            var  searchingProperties = entityType
                                       .GetProperties()
                                       .Where(x => allowedTypes.Contains(x.PropertyType) && x.GetSetMethod() != null)
                                       .Select(x => x.Name)
                                       .ToList();

            searchQuery = searchQuery?.ToLower() ?? string.Empty;
            if (string.IsNullOrEmpty(searchQuery))
            {
                return(x => true);
            }

            var expressionsList = new List <Expression <Func <TEntity, bool> > >();

            foreach (var searchingPropertyName in searchingProperties)
            {
                var currentExpression = Search <TEntity>(searchingPropertyName, searchQuery);
                expressionsList.Add(currentExpression);
            }

            var resultExpression = expressionsList.FirstOrDefault();

            for (int i = 1; i < expressionsList.Count; i++)
            {
                resultExpression = ExpressionFunctions.OrElse <TEntity>(resultExpression, expressionsList[i]);
            }

            return(resultExpression);
        }