/// <summary>
/// Multi condition filter with main filter on company name like
/// </summary>
/// <param name="pNameCondition">Company name like text</param>
/// <param name="pName">Text to filter on company name</param>
/// <param name="pContactType">contact type from contact type reference table</param>
/// <returns></returns>
public List <CustomerEntity> GetCustomersLikeCustomerEntities(LikeOptions pNameCondition, string pName, int pContactType)
{
var nameFilter = "";
if (pNameCondition == LikeOptions.StartsWith)
{
nameFilter = $"{pName}%";
}
else if (pNameCondition == LikeOptions.Contains)
{
nameFilter = $"%{pName}%";
}
else if (pNameCondition == LikeOptions.EndsWith)
{
nameFilter = $"{pName}%";
}
using (var context = new NorthWindContext())
{
var customerData = (
from customer in context.Customers
join contactType in context.ContactType on customer.ContactTypeIdentifier equals contactType.ContactTypeIdentifier
join contact in context.Contact on customer.ContactIdentifier equals contact.ContactIdentifier
where Functions.Like(customer.CompanyName, nameFilter)
select new CustomerEntity
{
CustomerIdentifier = customer.CustomerIdentifier,
CompanyName = customer.CompanyName,
ContactIdentifier = customer.ContactIdentifier,
FirstName = contact.FirstName,
LastName = contact.LastName,
ContactTypeIdentifier = contactType.ContactTypeIdentifier,
ContactTitle = contactType.ContactTitle,
City = customer.City,
PostalCode = customer.PostalCode,
CountryIdentifier = customer.CountryIdentfier,
CountyName = customer.CountryIdentfierNavigation.CountryName
}).ToList();
if (pContactType > 0)
{
customerData = customerData.Where(x => x.ContactTypeIdentifier == pContactType).ToList();
}
return(customerData);
}
}
/// <summary>
/// Set like option Contains, StartWith or EndWith
/// </summary>
/// <param name="strValue"></param>
/// <param name="option"></param>
/// <returns></returns>
internal static string SetOption(string strValue, LikeOptions option)
{
switch (option)
{
case LikeOptions.Contains:
{
strValue = string.Join("", '%', strValue, '%');
break;
}
case LikeOptions.StartWith:
{
strValue = string.Join("", strValue, '%');
break;
}
case LikeOptions.EndWith:
{
strValue = string.Join("", '%', strValue);
break;
}
}
return(strValue);
}
/// <summary>
/// Property value like start, end or contains strValue expression
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <param name="parameter"></param>
/// <param name="property"></param>
/// <param name="strValue"></param>
/// <returns></returns>
internal static MethodCallExpression LikeExpression <TSource>(ParameterExpression parameter, string property, string strValue, LikeOptions option)
{
MethodCallExpression body = Expression.Call(typeof(DbFunctionsExtensions).GetMethod(nameof(DbFunctionsExtensions.Like),
new[] {
typeof(DbFunctions), typeof(string), typeof(string)
}),
Expression.Constant(EF.Functions),
Expression.Property(parameter, typeof(TSource).GetProperty(property)),
Expression.Constant(SetOption(strValue, option)));
return(body);
}
/// <summary>
/// Property value like start, end or contains words expression
/// </summary>
/// <param name="props"></param>
/// <param name="words"></param>
/// <param name="option"></param>
/// <param name="operators"></param>
/// <returns></returns>
internal static Expression <Func <TSource, bool> > LikesExpression <TSource>(string[] props, string[] words, LikeOptions option, Operators operators)
{
Expression result = null;
ParameterExpression parameter = Expression.Parameter(typeof(TSource));
foreach (var prop in props)
{
Expression expr = words
.Select(word =>
LikeExpression <TSource>(parameter, prop, word, option)
)
.Aggregate <MethodCallExpression, Expression>(null, (current, call) => current != null ? ConcatExpression(current, call, operators) : (Expression)call);
result = result.ConcatExpression(expr, operators);
}
return(Expression.Lambda <Func <TSource, bool> >(result, parameter));
}
} /// <summary>
/// Where property value like %strValue% extension
/// </summary>
/// <typeparam name="TSource"></typeparam>
/// <param name="source"></param>
/// <param name="property"></param>
/// <param name="strValue"></param>
/// <returns></returns>
public static IQueryable <TSource> WhereLike <TSource>(this IQueryable <TSource> source,
string property, string strValue, LikeOptions option) =>
source.WhereFiltered(new List <Filter> {
new Filter
{
Key = property,
Value = strValue,
Comparison = option.ParseEnum()
}
});
private static ComparisonOperators ParseEnum(this LikeOptions value)
{
return((ComparisonOperators)Enum.Parse(typeof(ComparisonOperators), value.ToString("G"), true));
}
