/// <summary>
/// Create a result block query action for a Query Rule
/// </summary>
/// <param name="rule">The query rule object</param>
/// <param name="blockTitle">The result block Title</param>
/// <param name="queryTemplate">The search query template in KQL format</param>
/// <param name="resultSourceId">The search result source Id</param>
/// <param name="routingLabel">A routing label for a content search WebPart</param>
/// <param name="numberOfItems">The number of result to retrieve</param>
public void CreateResultBlockAction(QueryRule rule, string blockTitle, string queryTemplate, Guid resultSourceId, string routingLabel, string numberOfItems)
{
var queryAction = (CreateResultBlockAction)rule.CreateQueryAction(QueryActionType.CreateResultBlock);
queryAction.ResultTitle.DefaultLanguageString = blockTitle;
if (!string.IsNullOrEmpty(queryTemplate))
{
queryAction.QueryTransform.QueryTemplate = queryTemplate;
}
queryAction.QueryTransform.SourceId = resultSourceId;
if (!string.IsNullOrEmpty(routingLabel))
{
queryAction.ResultTableType = routingLabel;
}
if (!string.IsNullOrEmpty(numberOfItems))
{
queryAction.QueryTransform.OverrideProperties = new QueryTransformProperties();
queryAction.QueryTransform.OverrideProperties["RowLimit"] = int.Parse(numberOfItems, CultureInfo.InvariantCulture);
queryAction.QueryTransform.OverrideProperties["TotalRowsExactMinimum"] = int.Parse(numberOfItems, CultureInfo.InvariantCulture);
}
rule.Update();
}
public Trade[] GetAllTrades(QueryRule query, IList<string> filterOutTrades)
{
var allTrades = TradeRepository.GetAllTrades(query);
if (allTrades != null && allTrades.Length > 0 &&
filterOutTrades != null && filterOutTrades.Count > 0)
{
var tempMapper = new Dictionary<string, Trade>();
foreach(var item in allTrades)
{
tempMapper[item.Id] = item;
}
foreach(var item in filterOutTrades)
{
tempMapper.Remove(item);
}
var values = tempMapper.Values;
allTrades = new Trade[values.Count];
values.CopyTo(allTrades, 0);
}
return allTrades;
}
/// <summary>
/// Creates a query rule object for the search level.
/// If the rule already exists, if may be overwritten, depending on
/// the QueryRuleInfo upgrade behavior definition (the OverwriteIfAlreadyExists
/// flag is false by default).
/// </summary>
/// <param name="site">The current site collection.</param>
/// <param name="queryRuleMetadata">The query rule definition.</param>
/// <param name="level">The search level object.</param>
/// <returns>The new query rule object.</returns>
public QueryRule EnsureQueryRule(SPSite site, QueryRuleInfo queryRuleMetadata, SearchObjectLevel level)
{
var searchApp = this.searchHelper.GetDefaultSearchServiceApplication(site);
var queryRuleManager = new QueryRuleManager(searchApp);
var searchOwner = new SearchObjectOwner(level, site.RootWeb);
// Build the SearchObjectFilter
var searchObjectFilter = new SearchObjectFilter(searchOwner);
QueryRuleCollection rules = queryRuleManager.GetQueryRules(searchObjectFilter);
QueryRule returnedRule = null;
var existingRule = rules.FirstOrDefault(r => r.DisplayName == queryRuleMetadata.DisplayName);
if (existingRule != null)
{
// Deal with upgrade behavior (delete and re-create or return existing)
if (queryRuleMetadata.OverwriteIfAlreadyExists)
{
rules.RemoveQueryRule(existingRule);
returnedRule = rules.CreateQueryRule(queryRuleMetadata.DisplayName, queryRuleMetadata.StartDate, queryRuleMetadata.EndDate, queryRuleMetadata.IsActive);
}
else
{
returnedRule = existingRule;
}
}
else
{
// None exist already with that display name, create it
returnedRule = rules.CreateQueryRule(queryRuleMetadata.DisplayName, queryRuleMetadata.StartDate, queryRuleMetadata.EndDate, queryRuleMetadata.IsActive);
}
return(returnedRule);
}
/// <summary>
/// Create a promoted link action for a a query rule
/// </summary>
/// <param name="rule">The query rule object</param>
/// <param name="bestBetId">The bestBetIds</param>
public void CreatePromotedResultAction(QueryRule rule, Guid bestBetId)
{
var queryAction = (AssignBestBetsAction)rule.CreateQueryAction(QueryActionType.AssignBestBet);
queryAction.BestBetIds.Add(bestBetId);
rule.Update();
}
private static MethodInfo GetQueriedMethod(QueryRule queryRule, Type propertyType)
{
var method = propertyType.GetMethod(
Operations.Get(queryRule.FieldOperation),
new[] { propertyType }
);
return(method);
}
Predicate <T> IQueryCompiler <T> .CompileRule(QueryRule queryRule)
{
ConditionChecker.Requires(queryRule != null, "Query Rule cannot be null.");
// When migrating the database, some fields of the old DTO might be missing.
if (!typeof(T).HasProperty(queryRule.Field))
{
return(null);
}
var targetedType = Expression.Parameter(typeof(T));
var leftMember = Expression.Property(targetedType, queryRule.Field);
var propertyType = typeof(T).GetProperty(queryRule.Field)?.PropertyType;
if (propertyType == null)
{
return(null);
}
Expression expression;
// The given rule is binary(aka : equal, less than , gte, etc.)
if (Enum.TryParse(Operations.Get(queryRule.FieldOperation), out ExpressionType binaryOperator))
{
var queriedValue = GetQueriedValue(queryRule, propertyType);
expression = Expression.MakeBinary(binaryOperator, leftMember, queriedValue);
}
else
{
// The given rule is a method(aka: Contains, Equals, etc.
var queriedMethod = GetQueriedMethod(queryRule, propertyType);
if (queriedMethod == null)
{
return(null);
}
var rightMember = GetRightMember(queryRule, queriedMethod);
if (propertyType == typeof(string))
{
var toLowerMethodInfo = typeof(string).GetMethod("ToLower", new Type[] { });
Expression leftMemberLowerCase = Expression.Call(leftMember, toLowerMethodInfo ?? throw new MissingMethodException());
Expression rightMemberLowerCase = Expression.Call(rightMember, toLowerMethodInfo ?? throw new MissingMethodException());
expression = Expression.Call(leftMemberLowerCase, queriedMethod, rightMemberLowerCase);
}
else
{
expression = Expression.Call(leftMember, queriedMethod, rightMember);
}
}
return(Expression.Lambda <Predicate <T> >(expression, targetedType).Compile());
}
/// <summary>
/// Create a change query action for a Query Rule
/// </summary>
/// <param name="rule">The query rule object</param>
/// <param name="queryTemplate">The search query template in KQL format</param>
/// <param name="resultSourceId">The search result source Id</param>
public void CreateChangeQueryAction(QueryRule rule, string queryTemplate, Guid resultSourceId)
{
var queryAction = (ChangeQueryAction)rule.CreateQueryAction(QueryActionType.ChangeQuery);
if (!string.IsNullOrEmpty(queryTemplate))
{
queryAction.QueryTransform.QueryTemplate = queryTemplate;
}
queryAction.QueryTransform.SourceId = resultSourceId;
rule.Update();
}
private static ConstantExpression GetQueriedValue(QueryRule queryRule, Type propertyType)
{
ConstantExpression queriedValue;
if (propertyType.IsEnum)
{
queriedValue = Expression.Constant(Enum.Parse(propertyType, queryRule.Value.ToString()));
}
else if (propertyType == typeof(TimeSpan))
{
queriedValue = Expression.Constant(TimeSpan.Parse(queryRule.Value.ToString()));
}
else if (propertyType == typeof(string))
{
queriedValue = Expression.Constant(Convert.ChangeType(queryRule.Value.ToString().Trim().ToLower(), propertyType));
}
else
{
queriedValue = Expression.Constant(Convert.ChangeType(queryRule.Value, propertyType));
}
return(queriedValue);
}
private void QueryAndPrint()
{
try
{
FlyingMessageContext.Current = context;
var configRepository = IocContainer.Container.Resolve<IConfigRepository>();
var tradeService = IocContainer.Container.Resolve<ITradeService>();
using (var printerService = IocContainer.Container.Resolve<IPrinterService>())
{
printerService.InitializePrinter(new PrinterParameter()
{
Type = PrinterType.USB,
EncodingName = configRepository.PrinterEncodingName
});
var queryRule = new QueryRule()
{
PayType = PayTypeLite.All,
Status = TradeStatusLite.ToSend,
EndTime = DateTime.MinValue
};
while (true)
{
queryRule.StartTime = configRepository.QueryTime;
var trades = tradeService.GetAllTrades(queryRule, printerService.LastPrintedTrades);
if (trades != null && trades.Length > 0)
{
Message = new MessageItem(MessageLevel.Info, null, "trades.count:" + trades.Length);
foreach (var item in trades)
{
printerService.Print(item);
if (item.Created > queryRule.StartTime)
{
queryRule.StartTime = item.Created;
}
}
printerService.Update();
configRepository.QueryTime = queryRule.StartTime;
configRepository.Update();
}
else
{
Thread.Sleep(configRepository.QueryInterval * 1000);
}
}
}
}
catch(Exception ex)
{
LoggerUtility.WriteMessage(Severity.Error,
I18NUtility.GetString("I18N_QueryAndPrintFailed"), ex);
Message = new MessageItem(MessageLevel.Error, null,
I18NUtility.GetString("I18N_QueryAndPrintFailed", ex.Message));
}
}
private static ConstantExpression GetRightMember(QueryRule queryRule, MethodInfo queriedMethod)
{
var methodParameterType = queriedMethod.GetParameters()[0].ParameterType;
return(Expression.Constant(Convert.ChangeType(queryRule.Value, methodParameterType)));
}
private static void Main(string[] args)
{
var someList = new DummyDataGenerator().GenerateDummyData();
var engine = QueryFactory <SimpleModel> .BuildQueryFilterEngine();
#region Filtering
// boolean field
var onlyEnabledOnesRule = new QueryRule("Enabled", FieldOperation.Equal, false);
var onlyEnabledOnes = new QueryGroup(onlyEnabledOnesRule);
var result = engine.FilterCollection(someList, onlyEnabledOnes);
Console.WriteLine("----Testing against boolean fields----");
Assert.Equal(1, result.Count());
// number field
var onlySomeIdsRule = new QueryRule("Id", FieldOperation.GreaterThan, 2);
var onlySomeIds = new QueryGroup(onlySomeIdsRule);
result = engine.FilterCollection(someList, onlySomeIds);
Console.WriteLine("----Testing against integer fields----");
Assert.Equal(1, result.Count());
// string fields
var startsWithRule = new QueryRule("Name", FieldOperation.StartsWith, "A");
var endsWithRule = new QueryRule("Name", FieldOperation.EndsWith, "f");
var startsEnds = new QueryGroup().And(startsWithRule).Or(endsWithRule);
result = engine.FilterCollection(someList, startsEnds);
Console.WriteLine("----Testing against string fields----");
Assert.Equal(2, result.Count());
// datetime fields
var datesGreaterThanRule = new QueryRule("Date", FieldOperation.GreaterThan, new DateTime(2017, 1, 1));
var datesGreaterThan = new QueryGroup().And(datesGreaterThanRule);
result = engine.FilterCollection(someList, datesGreaterThan);
Console.WriteLine("----Testing against datetime fields----");
Assert.Equal(1, result.Count());
// timespan
var timeSpanGreaterThanRule = new QueryRule("TimeSpan", FieldOperation.GreaterThan, new DateTime(2017, 1, 1, 8, 0, 0).TimeOfDay);
var timeSpanLessThanRule = new QueryRule("TimeSpan", FieldOperation.LessThan, new DateTime(2018, 12, 1, 23, 0, 0).TimeOfDay);
var timeSpanGreaterLess = new QueryGroup().And(timeSpanGreaterThanRule).And(timeSpanLessThanRule);
result = engine.FilterCollection(someList, timeSpanGreaterLess);
Console.WriteLine("----Testing against timespan fields----");
Assert.Equal(1, result.Count());
// enums
var enumEqualRule = new QueryRule("SimpleEnum", FieldOperation.Equal, SimpleEnum.Option0);
var enumEqual = new QueryGroup().And(enumEqualRule);
result = engine.FilterCollection(someList, enumEqual);
Console.WriteLine("----Testing against enum fields----");
Assert.Equal(2, result.Count());
#endregion Filtering
#region Sorting
// ascending
var ascendingByDateRule = new QuerySorter("Date", SortingOperation.Ascending);
var ascendingByDate = new QueryGroup().AscendingBy(ascendingByDateRule);
result = engine.SortCollection(someList, ascendingByDate);
Console.WriteLine("----Testing against ascending sorting----");
Assert.StrictEqual(JsonConvert.SerializeObject(someList.OrderBy(x => x.Date)), JsonConvert.SerializeObject(result));
// desceding
var descendingByDateRule = new QuerySorter("Date", SortingOperation.Descending);
var descendingById = new QuerySorter("Id", SortingOperation.Descending);
var descendingByName = new QuerySorter("Name", SortingOperation.Descending);
var multipleDescending = new QueryGroup().DescendingBy(descendingByDateRule).DescendingBy(descendingById).DescendingBy(descendingByName);
result = engine.SortCollection(someList, multipleDescending);
Console.WriteLine("----Testing against descending sorting----");
Assert.StrictEqual(JsonConvert.SerializeObject(someList.OrderByDescending(x => x.Date).ThenByDescending(x => x.Id).ThenByDescending(x => x.Name)), JsonConvert.SerializeObject(result));
#endregion Sorting
#region Filtering Fields
var fieldsToShow = new string[] { "Id", "Name", "SimpleEnum" };
var filteredResult = engine.FilterFields(someList, fieldsToShow);
Console.WriteLine("----Testing against filtering fields----");
Assert.Equal(3, filteredResult.Count());
Assert.Equal(2, filteredResult.Count(x => x.SimpleEnum == SimpleEnum.Option0.ToString()));
#endregion Filtering Fields
Console.WriteLine("---------------------------------All tests passed------------------------------------");
Console.ReadKey();
}
/// <summary>
/// Create a promoted link action for a a query rule
/// </summary>
/// <param name="rule">The query rule object</param>
/// <param name="bestBetId">The bestBetIds</param>
public void CreatePromotedResultAction(QueryRule rule, Guid bestBetId)
{
var queryAction = (AssignBestBetsAction)rule.CreateQueryAction(QueryActionType.AssignBestBet);
queryAction.BestBetIds.Add(bestBetId);
rule.Update();
}
/// <summary>
/// Create a result block query action for a Query Rule
/// </summary>
/// <param name="rule">The query rule object</param>
/// <param name="blockTitle">The result block Title</param>
/// <param name="queryTemplate">The search query template in KQL format</param>
/// <param name="resultSourceId">The search result source Id</param>
/// <param name="routingLabel">A routing label for a content search WebPart</param>
/// <param name="numberOfItems">The number of result to retrieve</param>
public void CreateResultBlockAction(QueryRule rule, string blockTitle, string queryTemplate, Guid resultSourceId, string routingLabel, string numberOfItems)
{
var queryAction = (CreateResultBlockAction)rule.CreateQueryAction(QueryActionType.CreateResultBlock);
queryAction.ResultTitle.DefaultLanguageString = blockTitle;
if (!string.IsNullOrEmpty(queryTemplate))
{
queryAction.QueryTransform.QueryTemplate = queryTemplate;
}
queryAction.QueryTransform.SourceId = resultSourceId;
if (!string.IsNullOrEmpty(routingLabel))
{
queryAction.ResultTableType = routingLabel;
}
if (!string.IsNullOrEmpty(numberOfItems))
{
queryAction.QueryTransform.OverrideProperties = new QueryTransformProperties();
queryAction.QueryTransform.OverrideProperties["RowLimit"] = int.Parse(numberOfItems, CultureInfo.InvariantCulture);
queryAction.QueryTransform.OverrideProperties["TotalRowsExactMinimum"] = int.Parse(numberOfItems, CultureInfo.InvariantCulture);
}
rule.Update();
}
/// <summary>
/// Create a change query action for a Query Rule
/// </summary>
/// <param name="rule">The query rule object</param>
/// <param name="queryTemplate">The search query template in KQL format</param>
/// <param name="resultSourceId">The search result source Id</param>
public void CreateChangeQueryAction(QueryRule rule, string queryTemplate, Guid resultSourceId)
{
var queryAction = (ChangeQueryAction)rule.CreateQueryAction(QueryActionType.ChangeQuery);
if (!string.IsNullOrEmpty(queryTemplate))
{
queryAction.QueryTransform.QueryTemplate = queryTemplate;
}
queryAction.QueryTransform.SourceId = resultSourceId;
rule.Update();
}
