/// <summary>
/// Performs a search using the specified <paramref name="options"/>.
/// </summary>
/// <param name="operation">The boolean operation the search should be based on.</param>
/// <param name="options">The options specyfing how the results should be sorted.</param>
/// <param name="results">The results of the search.</param>
/// <param name="total">The total amount of results returned by the search.</param>
protected virtual void Execute(IBooleanOperation operation, ISearchOptions options, out IEnumerable <ISearchResult> results, out long total)
{
// Cast the boolean operation to IQueryExecutor
IQueryExecutor executor = operation;
// Start the search in Examine
ISearchResults allResults = executor.Execute(int.MaxValue);
// Update the total amount of results
total = allResults.TotalItemCount;
results = allResults;
// If "options" implements the interface, results are sorted using the "Sort" method
if (options is IPostSortOptions postSort)
{
results = postSort.Sort(results);
}
// If "options" implements implement the interface, the results are paginated
if (options is IOffsetOptions offset)
{
results = results.Skip(offset.Offset).Take(offset.Limit);
}
}
public ISearchResult SearchQuery(string indexName, SearchQuery query, ISearchOptions options = default)
{
return(SearchQueryAsync(indexName, query, options)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult());
}
public CurrentP4kFileSystemViewModel(ICurrentP4k currentP4k,
ICurrentItem currentFile,
IPinnedItems selectedItems,
IExtractP4kContent extractP4KContent,
ISearch search,
ISearchOptions searchOptions,
IUiDispatch uiDispatch,
SearchOptionsViewModel searchOptionsViewModel,
IEnumerable <IFileSubStructureProvider> subFileFactories = null)
{
_currentP4K = currentP4k;
_currentFile = currentFile;
_selectedItems = selectedItems;
_extractP4KContent = extractP4KContent;
_search = search;
_searchOptions = searchOptions;
_uiDispatch = uiDispatch;
_subFileFactories = subFileFactories != null?subFileFactories.ToArray() : new IFileSubStructureProvider[0];
SearchOptionsViewModel = searchOptionsViewModel;
Initialize();
_currentP4K.Changed += Initialize;
}
public static ISearchResult SearchQuery(this ICluster cluster, string indexName, SearchQuery query,
ISearchOptions options = default)
{
return(cluster.SearchQueryAsync(indexName, query, options)
.ConfigureAwait(false)
.GetAwaiter()
.GetResult());
}
public SearchResultList(ISearchOptions options, IQuery query, long total, IEnumerable <ISearchResult> items)
{
Options = options;
IsDebug = options is IDebugSearchOptions debug && debug.IsDebug;
Query = query;
Total = total;
Items = items;
}
protected static void Init()
{
_testParam = new TestSearchOptionsParam();
_jsonSerializer = new DefaultJsonSerializer();
_searchBiulder = new SearchOptionsBuilder<object>();
_queryMapper = new FacatedSearchMapper<object>();
_builder = new TestSearchOptionsParamBuilder(_testParam, _searchBiulder, _queryMapper);
_searchOptions = new SearchOptions();
}
protected static void Init()
{
_testParam = new TestSearchOptionsParam();
_jsonSerializer = new DefaultJsonSerializer();
_searchBiulder = new SearchOptionsBuilder <object>();
_queryMapper = new FacatedSearchMapper <object>();
_builder = new TestSearchOptionsParamBuilder(_testParam, _searchBiulder, _queryMapper);
_searchOptions = new SearchOptions();
}
public QueryOptions(
ISearchOptions searchOptions,
IEnumerable <ISortOptions> sortOptions,
IPaginationOptions paginationOptions)
{
SearchOptions = searchOptions;
SortOptions = sortOptions;
PaginationOptions = paginationOptions;
}
public SearchOptionsViewModel(ISearchOptions searchOptions,
IKnownFileExtensions knownFileTypes)
{
_searchOptions = searchOptions;
_knownFileTypes = knownFileTypes;
IncludedExtensions = new ObservableCollection <IncludedExtensionViewModel>();
UpdateKnownFileTypes();
_knownFileTypes.Changed += UpdateKnownFileTypes;
SearchAllSearchableFileTypes = true;
}
/// <summary>
/// Performs a search using the specified <paramref name="options"/> and returns the result of that search.
///
/// Each item in the result is parsed to the type of <typeparamref name="TItem"/> using <paramref name="callback"/>.
/// </summary>
/// <typeparam name="TItem">The common output type of each item.</typeparam>
/// <param name="options">The options for the search.</param>
/// <param name="callback">A callback used for converting an <see cref="ISearchResult"/> to <typeparamref name="TItem"/>.</param>
/// <returns>An instance of <see cref="SearchResultList{TItem}"/> representing the result of the search.</returns>
public virtual SearchResultList <TItem> Search <TItem>(ISearchOptions options, Func <ISearchResult, TItem> callback)
{
// Make the search in Examine
SearchResultList results = Search(options);
// Iterate through and call "callback" for each item
IEnumerable <TItem> items = results.Items
.Select(callback)
.Where(x => x != null);
// Wrap the result
return(new SearchResultList <TItem>(options, results.Query, results.Total, items));
}
/// <summary>
/// Performs a search using the specified <paramref name="options"/> and returns the result of that search.
///
/// Each item in the result first found in either the content cache or media cache, and then parsed to the type of <typeparamref name="TItem"/> using <paramref name="callback"/>.
/// </summary>
/// <typeparam name="TItem">The common output type of each item.</typeparam>
/// <param name="options">The options for the search.</param>
/// <param name="callback">A callback used for converting an <see cref="IPublishedContent"/> to <typeparamref name="TItem"/>.</param>
/// <returns>An instance of <see cref="SearchResultList{TItem}"/> representing the result of the search.</returns>
public virtual SearchResultList <TItem> Search <TItem>(ISearchOptions options, Func <IPublishedContent, TItem> callback)
{
// Make the search in Examine
SearchResultList results = Search(options);
// Iterate through the result and look up the content
IEnumerable <TItem> items = results.Items
.Select(GetPublishedContentFromResult)
.WhereNotNull()
.Select(callback)
.Where(x => x != null);
// Wrap the result
return(new SearchResultList <TItem>(options, results.Query, results.Total, items));
}
public virtual IEnumerable <SearchResultEntry> GetAncestors(string identity, ISearchOptions searchOptions)
{
var ancestors = new List <SearchResultEntry>();
var parent = this.GetParent(identity, searchOptions);
while (parent != null)
{
ancestors.Add(parent);
parent = this.GetParent(parent.DistinguishedName, searchOptions);
}
return(ancestors.ToArray());
}
/// <summary>
/// Performs a search using the specified <paramref name="options"/> and returns the result of that search.
///
/// Each item in the result first found in either the content cache or media cache, and then parsed to the type of <typeparamref name="TItem"/> using <paramref name="callback"/>.
/// </summary>
/// <typeparam name="TItem">The common output type of each item.</typeparam>
/// <param name="options">The options for the search.</param>
/// <param name="callback">A callback used for converting an <see cref="IPublishedContent"/> to <typeparamref name="TItem"/>.</param>
/// <returns>An instance of <see cref="SearchResultList{TItem}"/> representing the result of the search.</returns>
public virtual SearchResultList <TItem> Search <TItem>(ISearchOptions options, Func <IPublishedContent, ISearchResult, TItem> callback)
{
// Make the search in Examine
SearchResultList results = Search(options);
// Map the search results
IEnumerable <TItem> items = (
from x in results.Items
let content = GetPublishedContentFromResult(x)
let result = callback(content, x)
where result != null
select result
);
// Wrap the result
return(new SearchResultList <TItem>(options, results.Query, results.Total, items));
}
/// <summary>
/// Performs a search using the specified <paramref name="options"/> and returns the result of that search.
/// </summary>
/// <param name="options">The options for the search.</param>
/// <returns>An instance of <see cref="SearchResultList"/> representing the result of the search.</returns>
public virtual SearchResultList Search(ISearchOptions options)
{
// Start measuring the elapsed time
Stopwatch sw = Stopwatch.StartNew();
// Get the searcher from the options
ISearcher searcher = GetSearcher(options);
// Create a new Examine query
IQuery query = CreateQuery(searcher, options);
// Get the boolean operation via the options class
IBooleanOperation operation = options.GetBooleanOperation(this, searcher, query);
// Declare some variables
long total;
IEnumerable <ISearchResult> results;
switch (options)
{
case IExecuteOptions execute:
execute.Execute(operation, out results, out total);
break;
case ISortOptions sortOptions:
Execute(operation, sortOptions, out results, out total);
break;
default:
Execute(operation, options, out results, out total);
break;
}
sw.Stop();
if (options is IDebugSearchOptions debug && debug.IsDebug)
{
_logger.Debug <SearchHelper>("Search of type {Type} completed in {Milliseconds} with {Query}", options.GetType().FullName, sw.ElapsedMilliseconds, query);
}
// Wrap the results
return(new SearchResultList(options, query, total, results));
}
public virtual SearchResultEntry GetParent(string identity, ISearchOptions searchOptions)
{
var item = this.Get(identity, searchOptions);
if (item == null)
{
return(null);
}
var distinguishedName = this.DistinguishedNameParser.Parse(item.DistinguishedName);
var parentDistinguishedName = distinguishedName.Parent;
if (parentDistinguishedName == null)
{
return(null);
}
return(this.Get(parentDistinguishedName.ToString(), searchOptions));
}
public SearchResults <T> GetSearchResults <T>(ISearchOptions <T> options) where T : SearchResultItem
{
using (var context = _index.GetSearchContext())
{
var results = context.GetQueryable <T>(new CultureExecutionContext(options.CultureInfo));
// filter
if (options.Filter != null)
{
results = results.Filter(options.Filter);
}
// query
if (options.Predicate != null)
{
results = results.Where(options.Predicate);
}
// sort
if (options.OrderByDirection == OrderByDirection.Ascending && options.OrderByExpression != null)
{
results = results.OrderBy(options.OrderByExpression);
}
if (options.OrderByDirection == OrderByDirection.Descending && options.OrderByExpression != null)
{
results = results.OrderByDescending(options.OrderByExpression);
}
// pagination
if (options.PageNumber.HasValue && options.ResultsPerPage.HasValue)
{
results = results.Skip((options.PageNumber.Value - 1) * options.ResultsPerPage.Value);
}
if (options.ResultsPerPage.HasValue)
{
results = results.Take(options.ResultsPerPage.Value);
}
return(results.GetResults());
}
}
public static IQueryable <TModel> ApplyOptions <TModel>(
this IQueryable <TModel> query,
ISearchOptions options,
out ISearchOptions appliedOptions)
where TModel : IQueryModel
{
if (options == null)
{
appliedOptions = null;
return(query);
}
var propertiesToSearch = ReflectionHelper
.GetPropertyNamesThatAllowSearch <TModel>();
appliedOptions =
new SearchOptions
{
PropertyNames =
(options.PropertyNames ?? Enumerable.Empty <string>())
.Where(
name => propertiesToSearch.Contains(name))
.ToList(),
Term = options.Term
};
if (!appliedOptions.PropertyNames.Any() ||
string.IsNullOrEmpty(appliedOptions.Term))
{
return(query);
}
var searchExpression = ReflectionHelper
.CreateSearchExpressionFor <TModel>(
appliedOptions.PropertyNames, appliedOptions.Term);
return(query.Where(searchExpression));
}
protected internal virtual IEnumerable <string> GetAttributes(ISearchOptions searchOptions)
{
if (searchOptions == null)
{
throw new ArgumentNullException("searchOptions");
}
switch (searchOptions.AttributesSetting)
{
case AttributesSetting.Identity:
return(this.DirectorySettings.IdentityAttributes);
case AttributesSetting.Minimum:
return(this.DirectorySettings.MinimumNumberOfAttributes);
case AttributesSetting.None:
return(this.DirectorySettings.NoExistingAttributes);
default:
return(searchOptions.Attributes);
}
}
public P4kFileSystemViewModel(IFileSystem fileSystem,
ICurrentItem currentItem,
IPinnedItems selectedItems,
IExtractP4kContent extractP4KContent,
ISearch search,
ISearchOptions searchOptions,
IUiDispatch uiDispatch,
IEnumerable <IFileSubStructureProvider> subFileFactories)
{
_fileSystem = fileSystem;
_currentItem = currentItem;
_selectedItems = selectedItems;
_extractP4KContent = extractP4KContent;
_search = search;
_searchOptions = searchOptions;
_uiDispatch = uiDispatch;
_subFileFactories = subFileFactories.ToArray();
RootItems = new ObservableCollection <TreeNodeViewModel>();
SetCurrentItemCommand = new RelayCommand <object>(SetCurrentItem);
SetCurrentFileToNothingCommand = new RelayCommand(_currentItem.Clear);
ToggleSelectionOfCurrentItemCommand = new RelayCommand(ToggleSelectionOfCurrentItem);
ExtractCommand = new RelayCommand <object>(ExtractItem);
ExpandCommand = new RelayCommand <object>(async p =>
{
if (!(p is DirectoryTreeNodeViewModel directory))
{
return;
}
await directory.LoadChildrenAsync();
});
CreateRootItems();
_search.Finished += FilterRootItems;
_search.ResultsCleared += CreateRootItems;
}
public DirectoryTreeNodeViewModel(IDirectory directory,
ISearch search,
ISearchOptions searchOptions,
IUiDispatch uiDispatch,
IEnumerable <IFileSubStructureProvider> subFileFactories)
: base(directory.Name, directory.Path)
{
Model = directory;
_search = search;
_searchOptions = searchOptions;
_uiDispatch = uiDispatch;
_subFileFactories = subFileFactories;
_search.Finished += FilterContent;
_search.Finished += HighlightSearchTerm;
_search.ResultsCleared += ResetName;
_search.Began += ResetChildren;
//if (!Model.IsEmpty)
//{
// ResetChildren();
//}
HighlightSearchTerm();
}
/// <summary>
/// Returns the <see cref="ISearcher"/> as specified by the specified <paramref name="options"/>.
///
/// If <paramref name="options"/> doesn't specify a searcher, the searcher of <c>ExternalIndex</c> will be used as fallback.
/// </summary>
/// <param name="options">The search options.</param>
/// <returns>The <see cref="ISearcher"/> to be used for the search.</returns>
protected virtual ISearcher GetSearcher(ISearchOptions options)
{
ISearcher searcher;
switch (options)
{
case ISearcherOptions searcherOptions:
searcher = searcherOptions.Searcher;
if (searcher != null)
{
return(searcher);
}
break;
case IGetSearcherOptions getSearcherOptions:
searcher = getSearcherOptions.GetSearcher(_examine, this);
if (searcher != null)
{
return(searcher);
}
break;
default:
if (_examine.TryGetIndex(ExamineConstants.ExternalIndexName, out IIndex index))
{
searcher = index.GetSearcher();
if (searcher != null)
{
return(searcher);
}
}
break;
}
throw new Exception($"Failed determining searcher from {options.GetType()}");
}
public async Task <ISearchResult> SearchQueryAsync(string indexName, SearchQuery query, ISearchOptions options = default)
{
await EnsureBootstrapped();
query.Index = indexName;
if (options == default)
{
options = new SearchOptions();
}
//TODO: convert options to params
return(await _lazySearchClient.Value.QueryAsync(query));
}
public virtual IEnumerable <SearchResultEntry> GetTree(ISearchOptions searchOptions)
{
return(this.GetTree(this.LdapConnectionSettings.DistinguishedName, searchOptions));
}
public static string GenerateSearchString(this ISearchOptions searchOptions, IList <object> parameters)
{
var sb = new StringBuilder();
var type = searchOptions.GetType();
/***************************************************************************************
* Create the Select statement. Determine the table name and schema. *
**************************************************************************************/
var tableAttribute = type.GetCustomAttribute(typeof(TableAttribute)) as TableAttribute;
var schema = tableAttribute?.Schema ?? "dbo";
var tableName = tableAttribute?.Name ?? searchOptions.GetType().Name.Replace("SearchOptions", "");
sb.Append($"SELECT * FROM {schema}.{tableName} WHERE ");
/***************************************************************************************
* Add the WHERE statements. *
**************************************************************************************/
foreach (var property in type.GetProperties())
{
if (!property.CanRead)
{
continue;
}
//Ignore the current property if necessary.
var ignoreAttribute = (IgnoreAttribute)property.GetCustomAttribute(typeof(IgnoreAttribute));
if (ignoreAttribute?.IsIgnored(SqlAction.Select) == true)
{
continue;
}
//Determine the column name.
var columnAttribute = (Attributes.ColumnAttribute)property.GetCustomAttribute(typeof(Attributes.ColumnAttribute));
var columnName = columnAttribute != null
? columnAttribute.Name
: property.Name;
var equalityMethod = columnAttribute != null
? columnAttribute.EqualityMethod
: "=";
if (property.GetValue(searchOptions) != null)
{
var val = property.GetValue(searchOptions);
if (val is IEnumerable list)
{
switch (list.Count())
{
case 0:
sb.Append("1=0");
break;
case 1:
sb.Append($"{columnName} = {{{parameters.Count}}}");
parameters.Add(list.FirstOrDefault());
break;
default:
sb.Append($"{columnName} IN ({{{parameters.Count}}})");
parameters.Add(list);
break;
}
}
else if (property.GetValue(searchOptions) is string str)
{
if (!string.IsNullOrEmpty(str))
{
switch (equalityMethod)
{
case "LIKE":
sb.Append($"{columnName} LIKE {{{parameters.Count}}}");
parameters.Add($"%{str}%");
break;
case "=":
sb.Append($"{columnName} = {{{parameters.Count}}}");
parameters.Add(str);
break;
}
}
}
else
{
sb.Append($"{columnName} {equalityMethod} {{{parameters.Count}}}");
parameters.Add(property.GetValue(searchOptions));
}
sb.Append(" AND ");
}
}
sb.Length -= sb.ToString().EndsWith(" WHERE ")
? 7
: 5;
return(sb.ToString());
}
public Task <ISearchResult> SearchQueryAsync(string indexName, SearchQuery query, ISearchOptions options = default)
{
if (_searchClient == null)
{
_searchClient = new SearchClient(_configuration);
}
query.Index = indexName;
if (options == default)
{
options = new SearchOptions();
}
//TODO: convert options to params
return(_searchClient.QueryAsync(query));
}
public virtual IEnumerable <SearchResultEntry> GetTree(string identity, ISearchOptions searchOptions)
{
return(this.GetSearchResult(identity, searchOptions, SearchScope.Subtree, this.DirectorySettings.PageSize));
}
public UrlParameterBuilder(ISearchOptions options)
{
Options = options;
}
/// <summary>
/// Creates a new query from the specified <paramref name="searcher"/> and <paramref name="options"/>.
/// </summary>
/// <param name="searcher">The searcher.</param>
/// <param name="options">The options for the search.</param>
/// <returns>An instance of <see cref="IQuery"/>.</returns>
protected virtual IQuery CreateQuery(ISearcher searcher, ISearchOptions options)
{
return(searcher.CreateQuery());
}
public Search(ICurrentP4k currentP4K,
ISearchOptions searchOptions)
{
_currentP4K = currentP4K;
_searchOptions = searchOptions;
}
public static IQueryable <T> ApplySearch <T>(this IQueryable <T> query, ISearchOptions options)
{
if (options?.Search?.Length > 0)
{
var _searchQuery = options.Search;
var searchQueryLength = _searchQuery.Length;
// get given type's all properties
var properties = typeof(T).GetProperties();
var propertiesLength = properties.Length;
// iterate over all terms
for (int i = 0; i < searchQueryLength; i++)
{
if (string.IsNullOrEmpty(_searchQuery[i]))
{
continue;
}
// expression -> name eq shahid
var tokens = _searchQuery[i].Split(' ');
if (tokens.Length == 3)
{
string @operator = tokens[1];
string value = tokens[2];
for (int j = 0; j < propertiesLength; j++)
{
// if property has sortable attribute and sort term equals to property name
var searchableAttribute = properties[j].GetCustomAttributes <SearchableAttribute>().FirstOrDefault();
bool isSearchable = searchableAttribute != null && properties[j].Name.Equals(tokens[0], StringComparison.OrdinalIgnoreCase);
if (isSearchable)
{
// build up the LINQ expression backwards:
// query = query.Where(x => x.Property == "Value");
var parameter = ExpressionHelper.Parameter <T>();
// x.Property
var left = ExpressionHelper.GetPropertyExpression(parameter, properties[j]);
// "Value"
var right = GetConstantExpression(tokens[2], searchableAttribute.Type);
// x.Property == "Value"
var comparisonExpression = GetComparisonExpression(left, tokens[1], right);
// x => x.Property == "Value"
var lambda = ExpressionHelper
.GetLambda <T, bool>(parameter, comparisonExpression);
// query = query.Where...
query = ExpressionHelper.CallWhere(query, lambda);
}
}
}
}
}
return(query);
}
public static IQueryable <T> ApplySearch <T>(this IQueryable <T> query, ISearchOptions options)
{
if (options?.Search?.Length > 0)
{
if (_utilitiesOptions == null)
{
_utilitiesOptions = SearchUtilitiesOptions.DefaultOptions;
_comparisonExpressionProviderFactory = _utilitiesOptions.ComparisonExpressionProviderFactory;
}
var _searchQuery = options.Search;
var searchQueryLength = _searchQuery.Length;
// get given type's all properties
var properties = typeof(T).GetProperties();
var propertiesLength = properties.Length;
// iterate over all terms
for (int i = 0; i < searchQueryLength; i++)
{
if (string.IsNullOrEmpty(_searchQuery[i]))
{
continue;
}
// expression -> name eq shahid
var tokens = _searchQuery[i].Split(' ');
if (tokens.Length > 3)
{
// remove null or empty items
tokens = tokens.Where(x => !string.IsNullOrEmpty(x)).ToArray();
}
if (tokens.Length == 3)
{
string @operator = tokens[1];
string value = tokens[2];
for (int j = 0; j < propertiesLength; j++)
{
// if property has sortable attribute and sort term equals to property name
var searchableAttribute = properties[j].GetCustomAttributes <SearchableAttribute>().FirstOrDefault();
bool isSearchable = searchableAttribute != null && properties[j].Name.Equals(tokens[0], StringComparison.OrdinalIgnoreCase);
if (isSearchable)
{
// build up the LINQ expression backwards:
// query = query.Where(x => x.Property == "Value");
var parameter = ExpressionUtilities.Parameter <T>();
// x.Property
var left = parameter.GetPropertyExpression(properties[j]);
// "Value"
var constantValue = Convert.ChangeType(tokens[2], properties[j].PropertyType);
var right = Expression.Constant(constantValue);
// x.Property == "Value"
var comparisonExpressionProvider = _comparisonExpressionProviderFactory.CreateProvider(tokens[1].ToLower());
var comparisonExpression = comparisonExpressionProvider.GetExpression(left, right);
// x => x.Property == "Value"
var lambda = ExpressionUtilities
.GetLambda <T, bool>(parameter, comparisonExpression);
// query = query.Where...
query = query.DynamicWhere(lambda);
}
}
}
}
}
return(query);
}
