public virtual List <SkinnyItem> GetItems(ISearchParam param, QueryOccurance innerCondition, bool showAllVersions, string sortField, bool reverse, int start, int end, out int totalResults)
{
Assert.IsNotNull(Index, "Index");
var query = param.ProcessQuery(innerCondition, Index);
return(RunQuery(query, showAllVersions, sortField, reverse, start, end, out totalResults));
}
public virtual List <SkinnyItem> GetItems(ISearchParam param, QueryOccurance innerOccurance = QueryOccurance.Must, bool showAllVersions = false, string sortField = "", bool reverse = true, int start = 0, int end = 0)
{
Assert.IsNotNull(Index, "Index");
var query = param.ProcessQuery(innerOccurance, Index);
return(RunQuery(query, showAllVersions, sortField, reverse, start, end));
}
/// <summary>
/// The process query.
/// </summary>
/// <param name="condition">
/// The condition.
/// </param>
/// <param name="index">
/// The index.
/// </param>
/// <returns>
/// The <see cref="BooleanQuery"/>.
/// </returns>
public override Query ProcessQuery(QueryOccurance condition, Index index)
{
Assert.ArgumentNotNull(index, "Index");
var baseQuery = base.ProcessQuery(condition, index);
var translator = new QueryTranslator(index);
Assert.IsNotNull(translator, "translator");
var fieldQuery = this.Partial ? QueryBuilder.BuildPartialFieldValueClause(index, this.FieldName, this.FieldValue) :
QueryBuilder.BuildExactFieldValueClause(index, this.FieldName, this.FieldValue);
if (baseQuery == null)
{
return fieldQuery;
}
if (baseQuery is BooleanQuery)
{
var booleanQuery = baseQuery as BooleanQuery;
booleanQuery.Add(fieldQuery, translator.GetOccur(condition));
}
return baseQuery;
}
/// <summary>
/// The process query.
/// </summary>
/// <param name="condition">
/// The condition.
/// </param>
/// <param name="index">
/// The index.
/// </param>
/// <returns>
/// The <see cref="BooleanQuery"/>.
/// </returns>
public override Query ProcessQuery(QueryOccurance condition, Index index)
{
Assert.ArgumentNotNull(index, "Index");
var baseQuery = base.ProcessQuery(condition, index);
var translator = new QueryTranslator(index);
Assert.IsNotNull(translator, "translator");
var fieldQuery = this.Partial ? QueryBuilder.BuildPartialFieldValueClause(index, this.FieldName, this.FieldValue) :
QueryBuilder.BuildExactFieldValueClause(index, this.FieldName, this.FieldValue);
if (baseQuery == null)
{
return(fieldQuery);
}
if (baseQuery is BooleanQuery)
{
var booleanQuery = baseQuery as BooleanQuery;
booleanQuery.Add(fieldQuery, translator.GetOccur(condition));
}
return(baseQuery);
}
public static List <SkinnyItem> GetItems(string indexName,
string language,
string templateFilter,
string locationFilter,
string fullTextQuery,
List <NumericRangeSearchParam.NumericRangeField> ranges,
QueryOccurance occuranceTypeNumRanges = QueryOccurance.Must,
bool performSort = false,
string sortFieldName = "",
bool reverse = false)
{
var searchParam = new NumericRangeSearchParam
{
Database = "web",
Ranges = ranges,
LocationIds = locationFilter,
TemplateIds = templateFilter,
FullTextQuery = fullTextQuery,
InnerCondition = occuranceTypeNumRanges,
Language = language
};
using (var runner = new QueryRunner(indexName))
{
if (performSort)
{
return(runner.GetItems(searchParam, sortField: sortFieldName, reverse: reverse));
}
else
{
return(runner.GetItems(searchParam));
}
}
}
protected void ApplyFullTextClause(CombinedQuery query, string searchText, QueryOccurance occurance)
{
if (String.IsNullOrEmpty(searchText))
{
return;
}
query.Add(new FullTextQuery(searchText), occurance);
}
internal static void AddFieldValueClause(CombinedQuery query, string fieldName, string fieldValue, QueryOccurance occurance)
{
if (fieldName.IsNullOrEmpty() || fieldValue.IsNullOrEmpty())
{
return;
}
fieldValue = IdHelper.ProcessGUIDs(fieldValue);
query.Add(new FieldQuery(fieldName, fieldValue), occurance);
}
protected void ApplyTemplateFilter(CombinedQuery query, string templateIds, QueryOccurance occurance)
{
if (String.IsNullOrEmpty(templateIds))
{
return;
}
templateIds = IdHelper.NormalizeGuid(templateIds);
var fieldQuery = new FieldQuery(BuiltinFields.Template, templateIds);
query.Add(fieldQuery, occurance);
}
protected CombinedQuery ApplyRefinements(IEnumerable<Refinement> refinements, QueryOccurance occurance)
{
if (refinements.Count() <= 0) return new CombinedQuery();
var innerQuery = new CombinedQuery();
foreach (var refinement in refinements)
{
AddFieldValueClause(innerQuery, refinement.Name, refinement.Value, occurance);
}
return innerQuery;
}
internal static void AddFieldValueClause(BooleanQuery query, string fieldName, string fieldValue, QueryOccurance occurance)
{
if (fieldName.IsNullOrEmpty() || fieldValue.IsNullOrEmpty())
{
return;
}
var globalBooleanQuery = new BooleanQuery();
var qp = new QueryParser("__workflow state", ItemBucket.Kernel.Util.IndexSearcher.Index.Analyzer);
qp.SetAllowLeadingWildcard(true);
globalBooleanQuery.Add(qp.Parse(fieldValue), BooleanClause.Occur.MUST);
query.Add(globalBooleanQuery, BooleanClause.Occur.MUST);
}
public virtual BooleanClause.Occur GetOccur(QueryOccurance occurance)
{
switch (occurance)
{
case QueryOccurance.Must:
return(BooleanClause.Occur.MUST);
case QueryOccurance.MustNot:
return(BooleanClause.Occur.MUST_NOT);
case QueryOccurance.Should:
return(BooleanClause.Occur.SHOULD);
}
throw new Exception("Unknown occurance");
}
public virtual BooleanClause.Occur GetOccur(QueryOccurance occurance)
{
switch (occurance)
{
case QueryOccurance.Must:
return BooleanClause.Occur.MUST;
case QueryOccurance.MustNot:
return BooleanClause.Occur.MUST_NOT;
case QueryOccurance.Should:
return BooleanClause.Occur.SHOULD;
}
throw new Exception("Unknown occurance");
}
protected void ApplyTemplateFilter(CombinedQuery query, string templateIds, QueryOccurance occurance)
{
if (String.IsNullOrEmpty(templateIds))
{
return;
}
string field = BuiltinFields.Template;
if (SearchBaseTemplates)
{
field = BuiltinFields.AllTemplates;
}
ApplyIdFilter(query, field, templateIds, occurance);
}
public override BooleanQuery ProcessQuery(QueryOccurance occurance, Index index)
{
var query = base.ProcessQuery(occurance, index) ?? new BooleanQuery();
if (Partial)
{
AddPartialFieldValueClause(index, query, FieldName, FieldValue);
}
else
{
AddExactFieldValueClause(index, query, FieldName, FieldValue);
}
return(query);
}
public override BooleanQuery ProcessQuery(QueryOccurance occurance, Index index)
{
var query = base.ProcessQuery(occurance, index) ?? new BooleanQuery();
if (Partial)
{
AddPartialFieldValueClause(index, query, FieldName, FieldValue);
}
else
{
AddExactFieldValueClause(index, query, FieldName, FieldValue);
}
return query;
}
public override BooleanQuery ProcessQuery(QueryOccurance outerCondition, Index index)
{
var outerQuery = new BooleanQuery();
var translator = new QueryTranslator(index);
var innerOccurance = translator.GetOccur(InnerCondition);
var outerOccurance = translator.GetOccur(outerCondition);
var baseQuery = base.ProcessQuery(outerCondition, index);
if (baseQuery != null && baseQuery.Clauses().Count > 0) outerQuery.Add(baseQuery, outerOccurance);
var dateRangeQuery = ApplyDateRangeSearchParam(innerOccurance);
if (dateRangeQuery != null) outerQuery.Add(dateRangeQuery, outerOccurance);
return outerQuery;
}
public virtual BooleanQuery ProcessQuery(QueryOccurance occurance, Index index)
{
var innerQuery = new CombinedQuery();
ApplyFullTextClause(innerQuery, FullTextQuery, occurance);
ApplyRelationFilter(innerQuery, RelatedIds, occurance);
ApplyTemplateFilter(innerQuery, TemplateIds, occurance);
ApplyLocationFilter(innerQuery, LocationIds, occurance);
AddFieldValueClause(innerQuery, BuiltinFields.Database, Database, occurance);
if (innerQuery.Clauses.Count < 1)
return null;
var translator = new QueryTranslator(index);
var booleanQuery = translator.ConvertCombinedQuery(innerQuery);
ApplyLanguageClause(booleanQuery, Language, translator.GetOccur(occurance));
return booleanQuery;
}
public override Query ProcessQuery(QueryOccurance condition, Index index)
{
Assert.ArgumentNotNull(index, "Index");
var translator = new QueryTranslator(index);
Assert.IsNotNull(translator, "Query Translator");
var baseQuery = base.ProcessQuery(condition, index) as BooleanQuery ?? new BooleanQuery();
var outerCondition = translator.GetOccur(condition);
var query = this.BuildQuery(translator.GetOccur(InnerCondition));
if (query != null)
{
baseQuery.Add(query, outerCondition);
}
return baseQuery;
}
public virtual BooleanClause.Occur GetOccur(QueryOccurance occurance)
{
if (occurance == QueryOccurance.Must)
{
return BooleanClause.Occur.MUST;
}
if (occurance == QueryOccurance.MustNot)
{
return BooleanClause.Occur.MUST_NOT;
}
if (occurance == QueryOccurance.Should)
{
return BooleanClause.Occur.SHOULD;
}
throw new Exception("Unknown occurance");
}
public override BooleanQuery ProcessQuery(QueryOccurance occurance, Index index)
{
var outerQuery = new BooleanQuery();
var refinementQuery = ApplyRefinements(Refinements, InnerCondition);
var translator = new QueryTranslator(index);
var refBooleanQuery = translator.ConvertCombinedQuery(refinementQuery);
var outerOccurance = translator.GetOccur(occurance);
if (refBooleanQuery != null && refBooleanQuery.Clauses().Count > 0)
outerQuery.Add(refBooleanQuery, outerOccurance);
var baseQuery = base.ProcessQuery(occurance, index);
if (baseQuery != null)
outerQuery.Add(baseQuery, outerOccurance);
return outerQuery;
}
public virtual BooleanClause.Occur GetOccur(QueryOccurance occurance)
{
if (occurance == QueryOccurance.Must)
{
return(BooleanClause.Occur.MUST);
}
if (occurance == QueryOccurance.MustNot)
{
return(BooleanClause.Occur.MUST_NOT);
}
if (occurance == QueryOccurance.Should)
{
return(BooleanClause.Occur.SHOULD);
}
throw new Exception("Unknown occurance");
}
public override Query ProcessQuery(QueryOccurance condition, Index index)
{
Assert.ArgumentNotNull(index, "Index");
var translator = new QueryTranslator(index);
Assert.IsNotNull(translator, "Query Translator");
var baseQuery = base.ProcessQuery(condition, index) as BooleanQuery ?? new BooleanQuery();
var outerCondition = translator.GetOccur(condition);
var query = this.BuildQuery(translator.GetOccur(InnerCondition));
if (query != null)
{
baseQuery.Add(query, outerCondition);
}
return(baseQuery);
}
public virtual BooleanQuery ProcessQuery(QueryOccurance occurance, Index index)
{
var innerQuery = new CombinedQuery();
ApplyFullTextClause(innerQuery, FullTextQuery, occurance);
ApplyRelationFilter(innerQuery, RelatedIds, occurance);
ApplyTemplateFilter(innerQuery, TemplateIds, occurance);
ApplyLocationFilter(innerQuery, LocationIds, occurance);
AddFieldValueClause(innerQuery, BuiltinFields.Database, Database, occurance);
if (innerQuery.Clauses.Count < 1)
{
return(null);
}
var translator = new QueryTranslator(index);
var booleanQuery = translator.ConvertCombinedQuery(innerQuery);
ApplyLanguageClause(booleanQuery, Language, translator.GetOccur(occurance));
return(booleanQuery);
}
public override BooleanQuery ProcessQuery(QueryOccurance occurance, Index index)
{
var outerQuery = new BooleanQuery();
var baseQuery = base.ProcessQuery(occurance, index) ?? new BooleanQuery();
var translator = new QueryTranslator(index);
var innerOccurance = translator.GetOccur(InnerCondition);
var outerOccurance = translator.GetOccur(occurance);
if (baseQuery.Clauses().Count > 0)
{
outerQuery.Add(baseQuery, outerOccurance);
}
var numericQuery = ApplyNumericRangeSearchParam(innerOccurance);
if (numericQuery != null)
{
outerQuery.Add(numericQuery, outerOccurance);
}
return(outerQuery);
}
/// <summary>
/// The process query.
/// </summary>
/// <param name="condition">
/// The condition.
/// </param>
/// <param name="index">
/// The index.
/// </param>
/// <returns>
/// The <see cref="BooleanQuery"/>.
/// </returns>
public virtual Query ProcessQuery(QueryOccurance condition, Index index)
{
Assert.ArgumentNotNull(index, "Index");
var translator = new QueryTranslator(index);
Assert.IsNotNull(translator, "Query Translator");
var templateFieldName = this.SearchBaseTemplates ? SearchFieldIDs.AllTemplates : BuiltinFields.Template;
var queries = new List <Query>
{
QueryBuilder.BuildFullTextQuery(this.FullTextQuery, index),
QueryBuilder.BuildRelationFilter(this.RelatedIds),
QueryBuilder.BuildIdFilter(templateFieldName, this.TemplateIds),
QueryBuilder.BuildLocationFilter(this.LocationIds),
QueryBuilder.BuildFieldQuery(BuiltinFields.Database, this.Database),
QueryBuilder.BuildLanguageQuery(this.Language)
}
.Where(q => q != null)
.ToList();
if (!queries.Any())
{
return(null);
}
var occur = translator.GetOccur(condition);
var booleanQuery = new BooleanQuery();
foreach (var query in queries)
{
booleanQuery.Add(query, occur);
}
return(booleanQuery);
}
public override BooleanQuery ProcessQuery(QueryOccurance occurance, Index index)
{
var outerQuery = new BooleanQuery();
var refinementQuery = ApplyRefinements(Refinements, InnerCondition);
var translator = new QueryTranslator(index);
var refBooleanQuery = translator.ConvertCombinedQuery(refinementQuery);
var outerOccurance = translator.GetOccur(occurance);
if (refBooleanQuery != null && refBooleanQuery.Clauses().Count > 0)
{
outerQuery.Add(refBooleanQuery, outerOccurance);
}
var baseQuery = base.ProcessQuery(occurance, index);
if (baseQuery != null)
{
outerQuery.Add(baseQuery, outerOccurance);
}
return(outerQuery);
}
public virtual List<SkinnyItem> GetItems(IEnumerable<SearchParam> parameters, QueryOccurance innerCondition, bool showAllVersions, string sortField, bool reverse, int start, int end, out int totalResults)
{
Sort sort = null;
if (!string.IsNullOrEmpty(sortField.ToLowerInvariant()))
sort = new Sort(new SortField(sortField, SortField.STRING, reverse));
return GetItems(parameters, innerCondition, showAllVersions, sort, start, end, out totalResults);
}
public static List <SkinnyItem> GetItems(string indexName,
string language,
string templateFilter,
string locationFilter,
string fullTextQuery,
string relationFilter,
List <MultiFieldSearchParam.Refinement> refinements,
QueryOccurance occuranceTypeRefinements,
List <DateRangeSearchParam.DateRange> dateRanges,
QueryOccurance occuranceTypeDateRanges,
List <NumericRangeSearchParam.NumericRangeField> numRanges,
QueryOccurance occuranceTypeNumRanges,
string fieldName,
string fieldValue,
bool canBePartial,
bool performSort = false,
string sortFieldName = "",
bool reverse = false)
{
var searchParam = new SearchParam
{
Database = "web",
RelatedIds = relationFilter,
Language = language,
TemplateIds = templateFilter,
LocationIds = locationFilter,
FullTextQuery = fullTextQuery
};
var searchParamMultiField = new MultiFieldSearchParam
{
Refinements = refinements,
InnerCondition = occuranceTypeRefinements
};
var searchParamDate = new DateRangeSearchParam
{
Ranges = dateRanges,
InnerCondition = occuranceTypeDateRanges
};
var searchParamNum = new NumericRangeSearchParam
{
Ranges = numRanges,
InnerCondition = occuranceTypeNumRanges
};
var searchParamField = new FieldSearchParam
{
FieldName = fieldName,
FieldValue = fieldValue,
Partial = canBePartial
};
using (var runner = new QueryRunner(indexName))
{
if (performSort)
{
return(runner.GetItems(new[] { searchParam, searchParamMultiField, searchParamDate, searchParamField, searchParamNum }, sortField: sortFieldName, reverse: reverse));
}
else
{
return(runner.GetItems(new[] { searchParam, searchParamMultiField, searchParamDate, searchParamField, searchParamNum }));
}
}
}
protected void ApplyRefinements(CombinedQuery query, SafeDictionary<string> refinements, QueryOccurance occurance)
{
if (refinements.Count <= 0) return;
var innerQuery = new CombinedQuery();
foreach (var refinement in refinements)
{
var fieldName = refinement.Key.ToLowerInvariant();
var fieldValue = refinement.Value;
AddFieldValueClause(innerQuery, fieldName, fieldValue, occurance);
}
query.Add(innerQuery, QueryOccurance.Must);
}
protected void ApplyFullTextClause(CombinedQuery query, string searchText, QueryOccurance occurance)
{
if (String.IsNullOrEmpty(searchText)) return;
query.Add(new FullTextQuery(searchText), occurance);
}
protected void ApplyLocationFilter(CombinedQuery query, string locationIds, QueryOccurance occurance)
{
ApplyIdFilter(query, BuiltinFields.Path, locationIds, occurance);
}
public virtual List<SkinnyItem> GetItems(ISearchParam param, QueryOccurance innerOccurance = QueryOccurance.Must, bool showAllVersions = false, string sortField = "", bool reverse = true, int start = 0, int end = 0)
{
Assert.IsNotNull(Index, "Index");
var query = param.ProcessQuery(innerOccurance, Index);
return RunQuery(query, showAllVersions, sortField, reverse, start, end);
}
public virtual List<SkinnyItem> GetItems(ISearchParam param, QueryOccurance innerOccurance = QueryOccurance.Must, bool showAllVersions = false, string sortField = "", bool reverse = true, int start = 0, int end = 0)
{
int temp = 0;
return GetItems(param, innerOccurance, showAllVersions, sortField, reverse, start, end, out temp);
}
protected void AddFieldValueClause(CombinedQuery query, string fieldName, string fieldValue, QueryOccurance occurance)
{
if (String.IsNullOrEmpty(fieldName) || String.IsNullOrEmpty(fieldValue))
{
return;
}
// if we are searching by _id field, do not lowercase
fieldValue = IdHelper.ProcessGUIDs(fieldValue);
query.Add(new FieldQuery(fieldName.ToLowerInvariant(), fieldValue), occurance);
}
public SearchParam()
{
Condition = QueryOccurance.Must;
}
protected void ApplyLocationFilter(CombinedQuery query, string locationIds, QueryOccurance occurance)
{
ApplyIdFilter(query, BuiltinFields.Path, locationIds, occurance);
}
protected void ApplyRelationFilter(CombinedQuery query, string ids, QueryOccurance occurance)
{
ApplyIdFilter(query, BuiltinFields.Links, ids, occurance);
}
public virtual List <SkinnyItem> GetItems(IEnumerable <SearchParam> parameters, QueryOccurance innerCondition, bool showAllVersions, Sort sorter, int start, int end, out int totalResults)
{
Assert.IsNotNull(Index, "Index");
var translator = new QueryTranslator(Index);
var query = new BooleanQuery();
foreach (var parameter in parameters.Where(p => p != null))
{
var nestedQuery = parameter.ProcessQuery(parameter.Condition, Index);
if (nestedQuery == null)
{
continue;
}
if (nestedQuery is BooleanQuery)
{
if ((nestedQuery as BooleanQuery).Clauses().Count == 0)
{
continue;
}
}
query.Add(nestedQuery, translator.GetOccur(parameter.Condition));
}
return(RunQuery(query, showAllVersions, sorter, start, end, out totalResults));
}
protected void ApplyIdFilter(CombinedQuery query, string fieldName, string filter, QueryOccurance occurance)
{
if (String.IsNullOrEmpty(fieldName) || String.IsNullOrEmpty(filter))
{
return;
}
var filterQuery = new CombinedQuery();
var values = IdHelper.ParseId(filter);
foreach (var value in values.Where(ID.IsID))
{
AddFieldValueClause(filterQuery, fieldName, value, QueryOccurance.Should);
}
query.Add(filterQuery, occurance);
}
/// <summary>
/// Searches the with parameter occurrence.
/// </summary>
/// <param name="startLocationItem">The start location item.</param>
/// <param name="refinements">The refinements.</param>
/// <param name="hitCount">The hit count.</param>
/// <param name="relatedIds">The related ids.</param>
/// <param name="indexName">Name of the index.</param>
/// <param name="text">The text.</param>
/// <param name="templates">The templates.</param>
/// <param name="location">The location.</param>
/// <param name="language">The language.</param>
/// <param name="id">The id.</param>
/// <param name="sortField">The sort field.</param>
/// <param name="sortDirection">The sort direction.</param>
/// <param name="itemName">Name of the item.</param>
/// <param name="startDate">The start date.</param>
/// <param name="endDate">The end date.</param>
/// <param name="numberOfItemsToReturn">The number of items to return.</param>
/// <param name="pageNumber">The page number.</param>
/// <param name="customParametersOccurance">The custom parameters occurrence.</param>
/// <returns></returns>
public static IEnumerable<SitecoreItem> SearchWithParameterOccurance(
Item startLocationItem,
SafeDictionary<string> refinements,
out int hitCount,
string relatedIds = "",
string indexName = "itembuckets_buckets",
string text = "",
string templates = "",
string location = "",
string language = "en",
string id = "",
string sortField = "",
string sortDirection = "",
string itemName = "",
string startDate = "",
string endDate = "",
int numberOfItemsToReturn = 20,
int pageNumber = 1,
QueryOccurance customParametersOccurance = QueryOccurance.Must)
{
Contract.Requires(startLocationItem.IsNotNull());
using (var searcher = new IndexSearcher(indexName))
{
DateRangeSearchParam dateSearchParam = GetFullParameters(
startLocationItem,
refinements,
relatedIds,
indexName = "itembuckets_buckets",
text,
templates,
location,
language,
id,
sortField,
sortDirection,
itemName,
startDate,
endDate,
numberOfItemsToReturn,
pageNumber,
customParametersOccurance);
if (dateSearchParam.IsNull())
{
hitCount = 0;
return new List<SitecoreItem>();
}
return GetItemsFromSearcher(searcher, dateSearchParam, out hitCount);
}
}
public virtual List <SkinnyItem> GetItems(ISearchParam param, QueryOccurance innerCondition = QueryOccurance.Must, bool showAllVersions = false, string sortField = "", bool reverse = true, int start = 0, int end = 0)
{
int temp;
return(GetItems(param, innerCondition, showAllVersions, sortField, reverse, start, end, out temp));
}
protected void ApplyTemplateFilter(CombinedQuery query, string templateIds, QueryOccurance occurance)
{
if (String.IsNullOrEmpty(templateIds)) return;
templateIds = IdHelper.NormalizeGuid(templateIds);
var fieldQuery = new FieldQuery(BuiltinFields.Template, templateIds);
query.Add(fieldQuery, occurance);
}
protected void ApplyRefinements(CombinedQuery query, SafeDictionary <string> refinements, QueryOccurance occurance)
{
if (refinements.Count <= 0)
{
return;
}
var innerQuery = new CombinedQuery();
foreach (var refinement in refinements)
{
var fieldName = refinement.Key.ToLowerInvariant();
var fieldValue = refinement.Value;
AddFieldValueClause(innerQuery, fieldName, fieldValue, occurance);
}
query.Add(innerQuery, QueryOccurance.Must);
}
/// <summary>
/// The process query.
/// </summary>
/// <param name="condition">
/// The condition.
/// </param>
/// <param name="index">
/// The index.
/// </param>
/// <returns>
/// The <see cref="BooleanQuery"/>.
/// </returns>
public virtual Query ProcessQuery(QueryOccurance condition, Index index)
{
Assert.ArgumentNotNull(index, "Index");
var translator = new QueryTranslator(index);
Assert.IsNotNull(translator, "Query Translator");
var templateFieldName = this.SearchBaseTemplates ? SearchFieldIDs.AllTemplates : BuiltinFields.Template;
var queries = new List<Query>
{
QueryBuilder.BuildFullTextQuery(this.FullTextQuery, index),
QueryBuilder.BuildRelationFilter(this.RelatedIds),
QueryBuilder.BuildIdFilter(templateFieldName, this.TemplateIds),
QueryBuilder.BuildLocationFilter(this.LocationIds),
QueryBuilder.BuildFieldQuery(BuiltinFields.Database, this.Database),
QueryBuilder.BuildLanguageQuery(this.Language)
}
.Where(q => q != null)
.ToList();
if (!queries.Any())
{
return null;
}
var occur = translator.GetOccur(condition);
var booleanQuery = new BooleanQuery();
foreach (var query in queries)
{
booleanQuery.Add(query, occur);
}
return booleanQuery;
}
public virtual List<SkinnyItem> GetItems(ISearchParam param, QueryOccurance innerOccurance, bool showAllVersions, string sortField, bool reverse, int start, int end, out int totalResults)
{
Assert.IsNotNull(Index, "Index");
var query = param.ProcessQuery(innerOccurance, Index);
return RunQuery(query, showAllVersions, sortField, reverse, start, end, out totalResults);
}
internal static void ApplyRefinements(CombinedQuery query, SafeDictionary <string> refinements, QueryOccurance occurance)
{
if (refinements.Count <= 0)
{
return;
}
var combinedQuery = new CombinedQuery();
refinements.ForEach(refinement => AddFieldValueClause(combinedQuery, refinement.Key.ToLowerInvariant(), refinement.Key == "_tags" ? refinement.Value.Replace("_tags ", "") : refinement.Value, occurance));
query.Add(combinedQuery, QueryOccurance.Must);
}
protected void AddFieldValueClause(CombinedQuery query, string fieldName, string fieldValue, QueryOccurance occurance)
{
if (String.IsNullOrEmpty(fieldName) || String.IsNullOrEmpty(fieldValue)) return;
// if we are searching by _id field, do not lowercase
fieldValue = IdHelper.ProcessGUIDs(fieldValue);
query.Add(new FieldQuery(fieldName.ToLowerInvariant(), fieldValue), occurance);
}
internal static void AddFieldValueClause(CombinedQuery query, string fieldName, string fieldValue, QueryOccurance occurance)
{
if (fieldName.IsNullOrEmpty() || fieldValue.IsNullOrEmpty())
{
return;
}
fieldValue = IdHelper.ProcessGUIDs(fieldValue);
query.Add(new FieldQuery(fieldName, fieldValue), occurance);
}
protected void ApplyIdFilter(CombinedQuery query, string fieldName, string filter, QueryOccurance occurance)
{
if (String.IsNullOrEmpty(fieldName) || String.IsNullOrEmpty(filter)) return;
var filterQuery = new CombinedQuery();
var values = IdHelper.ParseId(filter);
foreach (var value in values.Where(ID.IsID))
{
AddFieldValueClause(filterQuery, fieldName, value, QueryOccurance.Should);
}
query.Add(filterQuery, occurance);
}
internal static void AddFieldValueClause(BooleanQuery query, string fieldName, string fieldValue, QueryOccurance occurance)
{
if (fieldName.IsNullOrEmpty() || fieldValue.IsNullOrEmpty())
{
return;
}
var globalBooleanQuery = new BooleanQuery();
var qp = new QueryParser("__workflow state", ItemBucket.Kernel.Util.IndexSearcher.Index.Analyzer);
qp.SetAllowLeadingWildcard(true);
globalBooleanQuery.Add(qp.Parse(fieldValue), BooleanClause.Occur.MUST);
query.Add(globalBooleanQuery, BooleanClause.Occur.MUST);
}
protected void ApplyRelationFilter(CombinedQuery query, string ids, QueryOccurance occurance)
{
ApplyIdFilter(query, BuiltinFields.Links, ids, occurance);
}
public virtual List<SkinnyItem> GetItems(IEnumerable<SearchParam> parameters, QueryOccurance innerCondition, bool showAllVersions, Sort sorter, int start, int end, out int totalResults)
{
Assert.IsNotNull(Index, "Index");
var translator = new QueryTranslator(Index);
var query = new BooleanQuery();
foreach (var parameter in parameters.Where(p => p != null))
{
var nestedQuery = parameter.ProcessQuery(parameter.Condition, Index);
if (nestedQuery == null)
{
continue;
}
if (nestedQuery is BooleanQuery)
{
if ((nestedQuery as BooleanQuery).Clauses().Count == 0)
{
continue;
}
}
query.Add(nestedQuery, translator.GetOccur(parameter.Condition));
}
return RunQuery(query, showAllVersions, sorter, start, end, out totalResults);
}
public virtual List <SkinnyItem> GetItems(IEnumerable <SearchParam> parameters, QueryOccurance innerCondition, bool showAllVersions, string sortField, bool reverse, int start, int end, out int totalResults)
{
Sort sort = null;
if (!string.IsNullOrEmpty(sortField))
{
sort = new Sort(new SortField(sortField.ToLowerInvariant(), SortField.STRING, reverse));
}
return(GetItems(parameters, innerCondition, showAllVersions, sort, start, end, out totalResults));
}
internal static void ApplyRefinements(CombinedQuery query, SafeDictionary<string> refinements, QueryOccurance occurance)
{
if (refinements.Count <= 0)
{
return;
}
var combinedQuery = new CombinedQuery();
refinements.ForEach(refinement => AddFieldValueClause(combinedQuery, refinement.Key.ToLowerInvariant(), refinement.Key == "_tags" ? refinement.Value.Replace("_tags ", "") : refinement.Value, occurance));
query.Add(combinedQuery, QueryOccurance.Must);
}
protected CombinedQuery ApplyRefinements(IEnumerable <Refinement> refinements, QueryOccurance occurance)
{
if (refinements.Count() <= 0)
{
return(new CombinedQuery());
}
var innerQuery = new CombinedQuery();
foreach (var refinement in refinements)
{
AddFieldValueClause(innerQuery, refinement.Name, refinement.Value, occurance);
}
return(innerQuery);
}
/// <summary>
/// Gets the full parameters.
/// </summary>
/// <param name="startLocationItem">The start location item.</param>
/// <param name="refinements">The refinements.</param>
/// <param name="relatedIds">The related ids.</param>
/// <param name="p">The p.</param>
/// <param name="text">The text.</param>
/// <param name="templates">The templates.</param>
/// <param name="location">The location.</param>
/// <param name="language">The language.</param>
/// <param name="id">The id.</param>
/// <param name="sortField">The sort field.</param>
/// <param name="sortDirection">The sort direction.</param>
/// <param name="itemName">Name of the item.</param>
/// <param name="startDate">The start date.</param>
/// <param name="endDate">The end date.</param>
/// <param name="numberOfItemsToReturn">The number of items to return.</param>
/// <param name="pageNumber">The page number.</param>
/// <param name="customParametersOccurance">The custom parameters occurrence.</param>
/// <returns>The date range search parameters.</returns>
private static DateRangeSearchParam GetFullParameters(
Item startLocationItem,
SafeDictionary<string> refinements,
string relatedIds,
string p,
string text,
string templates,
string location,
string language,
string id,
string sortField,
string sortDirection,
string itemName,
string startDate,
string endDate,
int numberOfItemsToReturn,
int pageNumber,
QueryOccurance customParametersOccurance)
{
CultureInfo culture = CultureInfo.CreateSpecificCulture("en-US");
DateTime startDateOut;
bool startFlag = true;
if (!DateTime.TryParse(startDate, culture, DateTimeStyles.None, out startDateOut))
{
startDateOut = DateTime.Now;
startFlag = false;
}
DateTime endDateOut;
bool endFlag = true;
if (!DateTime.TryParse(endDate, culture, DateTimeStyles.None, out endDateOut))
{
endDateOut = DateTime.Now.AddDays(1);
endFlag = false;
}
if (startLocationItem.IsNull())
{
Log.Warn("You are trying to run an Search on an item that has a start location of null", null);
return null;
}
var dateSearchParam = new DateRangeSearchParam
{
ItemName = itemName,
FullTextQuery = text,
RelatedIds = relatedIds,
TemplateIds = templates,
LocationIds = startLocationItem.ID.ToString(),
Language = language,
ID = id,
SortDirection = sortDirection,
SortByField = sortField,
PageSize = numberOfItemsToReturn,
PageNumber = pageNumber,
Refinements = refinements,
Occurance = customParametersOccurance
};
if (startFlag || endFlag)
{
dateSearchParam.Ranges = new List<DateRangeSearchParam.DateRangeField>
{
new DateRangeSearchParam.DateRangeField(
SearchFieldIDs.CreatedDate,
startDateOut,
endDateOut)
{
InclusiveStart = true,
InclusiveEnd = true
}
};
}
return dateSearchParam;
}
