internal static void ApplyTemplateFilter(CombinedQuery query, string templateIds)
{
if (templateIds.IsNullOrEmpty())
{
return;
}
var templateList = templateIds.Split('|');
if (templateList.Length > 1)
{
var filterQuery = new CombinedQuery();
foreach (var templateId in templateList)
{
templateIds = IdHelper.NormalizeGuid(templateId);
filterQuery.Add(new FieldQuery(BuiltinFields.Template, templateIds), QueryOccurance.Should);
}
query.Add(filterQuery, QueryOccurance.Must);
}
else
{
templateIds = IdHelper.NormalizeGuid(templateIds);
query.Add(new FieldQuery(BuiltinFields.Template, templateIds), QueryOccurance.Must);
}
}
/// <summary>
/// Gets the comments for the given blog entry
/// </summary>
/// <param name="item">The item to get the comments under</param>
/// <param name="maximumCount">The maximum number of comments to retrieve</param>
/// <param name="language">The language to get the comments in</param>
/// <returns>The comments which are decendants of the given item</returns>
public CommentItem[] GetCommentsFor(Item item, int maximumCount, bool sort = false, bool reverse = false)
{
if (item != null && maximumCount > 0)
{
var blog = ManagerFactory.BlogManagerInstance.GetCurrentBlog(item);
if (blog != null)
{
var query = new CombinedQuery();
// TODO: What about items using templates derived from commenttemplateid? need to accommodate those
query.Add(new FieldQuery(Constants.Index.Fields.Template, blog.BlogSettings.CommentTemplateID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Path, item.ID.ToShortID().ToString()), QueryOccurance.Must);
string sortField = null;
if (sort)
{
sortField = Constants.Index.Fields.Created;
}
var searcher = new Searcher();
return(searcher.Execute <CommentItem>(query, maximumCount, (list, listItem) => list.Add((CommentItem)listItem), sortField, reverse));
}
}
return(new CommentItem[0]);
}
/// <summary>
/// Gets blog entries for the given blog up to the maximum number given
/// </summary>
/// <param name="blog">The blog item to get the entries for</param>
/// <param name="maxNumber">The maximum number of entries to retrieve</param>
/// <param name="tag">A tag the entry must contain</param>
/// <param name="category">A category the entry must contain</param>
/// <returns></returns>
public EntryItem[] GetBlogEntries(Item blog, int maxNumber, string tag, string category, string datePrefix = null)
{
if (blog == null || maxNumber <= 0)
{
return(new EntryItem[0]);
}
BlogHomeItem customBlogItem = null;
if (blog.TemplateIsOrBasedOn(Settings.BlogTemplateID))
{
customBlogItem = blog;
}
else
{
customBlogItem = blog.GetCurrentItem(Settings.BlogTemplateIDString);
}
if (customBlogItem == null)
{
return(new EntryItem[0]);
}
var query = new CombinedQuery();
//query.Add(new FieldQuery(Constants.Index.Fields.BlogID, blog.ID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Path, customBlogItem.ID.ToShortID().ToString()), QueryOccurance.Must);
query.Add(new FieldQuery(Constants.Index.Fields.Template, customBlogItem.BlogSettings.EntryTemplateID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
if (!string.IsNullOrEmpty(tag))
{
query.Add(new FieldQuery(Constants.Index.Fields.Tags, DatabaseCrawler.TransformCSV(tag)), QueryOccurance.Must);
}
if (!string.IsNullOrEmpty(category))
{
var categoryItem = ManagerFactory.CategoryManagerInstance.GetCategory(blog, category);
ID id = ID.Null;
if (categoryItem != null)
{
id = categoryItem.ID;
}
query.Add(new FieldQuery(Constants.Index.Fields.Category, id.ToShortID().ToString().ToLower()), QueryOccurance.Must);
}
if (!string.IsNullOrEmpty(datePrefix))
{
query.Add(new FieldQuery(Constants.Index.Fields.Created, datePrefix + "*"), QueryOccurance.Must);
}
var searcher = new Searcher();
var result = searcher.Execute <EntryItem>(query, maxNumber, (list, item) => list.Add((EntryItem)item), Constants.Index.Fields.EntryDate, true);
return(result);
}
private static void AppendIndexSpecificTerms(CombinedQuery combinedQuery, string indexName, string searchText)
{
switch (indexName)
{
case "itembuckets_medialibrary":
combinedQuery.Add(new FieldQuery("artist", searchText), QueryOccurance.Should);
combinedQuery.Add(new FieldQuery("copyright", searchText), QueryOccurance.Should);
combinedQuery.Add(new FieldQuery("imagedescription", searchText), QueryOccurance.Should);
combinedQuery.Add(new FieldQuery("title", searchText), QueryOccurance.Should);
break;
case "itembuckets_sitecore":
combinedQuery.Add(new FieldQuery("artist", searchText), QueryOccurance.Should);
combinedQuery.Add(new FieldQuery("copyright", searchText), QueryOccurance.Should);
combinedQuery.Add(new FieldQuery("imagedescription", searchText), QueryOccurance.Should);
combinedQuery.Add(new FieldQuery("title", searchText), QueryOccurance.Should);
break;
case "itembuckets_systemfolder":
break;
case "itembuckets_templates":
break;
}
}
public SitecoreSearchResultCollection FieldSearch(QueryInfo[] qis, int maxResults)
{
HighResTimer timer = new HighResTimer(true);
var combinedQuery = new CombinedQuery();
foreach (var qi in qis)
{
var q = GetQuery(qi);
if (q != null)
{
combinedQuery.Add(q, qi.SitecoreSearchQueryOccurance);
}
}
SearchResultCollection results = null;
if (combinedQuery.Clauses.Count > 0)
{
results = GetSearchHits(combinedQuery, maxResults);
}
return(results != null
? new SitecoreSearchResultCollection(results, timer.Elapsed())
: null);
}
public static IEnumerable <Item> GetItemsInCategories([NotNull] IEnumerable <ID> categories)
{
Assert.ArgumentNotNull(categories, "categories");
var index = SearchManager.SystemIndex;
if (index == null)
{
return(new Item[0]);
}
var query = new CombinedQuery();
foreach (var id in categories)
{
query.Add(new FieldQuery("_categories", ShortID.Encode(id)), QueryOccurance.Must);
}
SearchResultCollection collection;
using (var context = index.CreateSearchContext())
{
collection = context.Search(query).FetchResults(0, int.MaxValue);
}
return(collection.Select(result => SearchManager.GetObject(result)).OfType <Item>());
}
/// <summary>
/// Gets the comments for the given blog entry
/// </summary>
/// <param name="item">The item to get the comments under</param>
/// <param name="maximumCount">The maximum number of comments to retrieve</param>
/// <param name="language">The language to get the comments in</param>
/// <returns>The comments which are decendants of the given item</returns>
public CommentItem[] GetCommentsFor(Item item, int maximumCount, bool sort = false, bool reverse = false)
{
if (item != null && maximumCount > 0)
{
var blog = ManagerFactory.BlogManagerInstance.GetCurrentBlog(item);
if (blog != null)
{
#if FEATURE_CONTENT_SEARCH
var indexName = Settings.SearchIndexName;
List <CommentItem> result = new List <CommentItem>();
if (!string.IsNullOrEmpty(indexName))
{
using (var context = ContentSearchManager.GetIndex(indexName).CreateSearchContext())
{
var builder = PredicateBuilder.True <CommentResultItem>();
builder = builder.And(i => i.Path.Contains(item.Paths.FullPath));
builder = builder.And(i => i.TemplateId == Settings.CommentTemplateID);
var indexresults = context.GetQueryable <CommentResultItem>().Where(builder);
if (indexresults.Any())
{
result = indexresults.Select(i => new CommentItem(i.GetItem())).ToList();
result = result.Distinct().OrderBy(comment => comment.InnerItem.Statistics.Created).Take(maximumCount).ToList();
}
}
}
return(result.ToArray());
#else
var query = new CombinedQuery();
// TODO: What about items using templates derived from commenttemplateid? need to accommodate those
query.Add(new FieldQuery(Constants.Index.Fields.Template, blog.BlogSettings.CommentTemplateID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Path, item.ID.ToShortID().ToString()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Language, item.Language.Name), QueryOccurance.Must);
string sortField = null;
if (sort)
{
sortField = Constants.Index.Fields.Created;
}
var searcher = new Searcher();
return(searcher.Execute <CommentItem>(query, maximumCount, (list, listItem) => list.Add((CommentItem)listItem), sortField, reverse));
#endif
}
}
return(new CommentItem[0]);
}
protected void ApplyFullTextClause(CombinedQuery query, string searchText, QueryOccurance occurance)
{
if (String.IsNullOrEmpty(searchText))
{
return;
}
query.Add(new FullTextQuery(searchText), occurance);
}
internal static void ApplyLanguageClause(CombinedQuery query, string language)
{
if (language.IsNullOrEmpty())
{
return;
}
query.Add(new FieldQuery(BuiltinFields.Language, language.ToLowerInvariant()), QueryOccurance.Must);
}
internal static void ApplyNameFilter(CombinedQuery query, string Name)
{
if (Name.IsNullOrEmpty())
{
return;
}
query.Add(new FieldQuery(BuiltinFields.Name, Name), QueryOccurance.Must);
}
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);
}
internal static void ApplyContextItemRemoval(CombinedQuery query, string Id)
{
if (Id.IsNullOrEmpty())
{
return;
}
Id = IdHelper.NormalizeGuid(Id);
query.Add(new FieldQuery(BuiltinFields.ID, Id), QueryOccurance.MustNot);
}
internal static void ApplyFullTextClause(CombinedQuery query, string searchText, string indexName)
{
if (searchText.IsNullOrEmpty())
{
return;
}
var combinedQuery = new CombinedQuery();
combinedQuery.Add(new FullTextQuery(searchText), QueryOccurance.Should);
combinedQuery.Add(new FieldQuery(BuiltinFields.Name, searchText), QueryOccurance.Should);
if (!indexName.IsNullOrEmpty())
{
AppendIndexSpecificTerms(combinedQuery, indexName, searchText);
}
query.Add(combinedQuery, QueryOccurance.Must);
}
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 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 ApplyIdFilter(CombinedQuery query, string fieldName, string filter)
{
if (fieldName.IsNullOrEmpty() || filter.IsNullOrEmpty())
{
return;
}
var filterQuery = new CombinedQuery();
IdHelper.ParseId(filter).Where(IdHelper.IsGuid).ForEach(value => AddFieldValueClause(filterQuery, fieldName, value, QueryOccurance.Should));
query.Add(filterQuery, QueryOccurance.Must);
}
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);
}
private QueryBase CreateQuery(Database database)
{
var query = new CombinedQuery();
var databaseQuery = new FieldQuery(BuiltinFields.Database, database.Name);
var languageQuery = new FieldQuery(BuiltinFields.Language, Context.Language.Name);
var templateQuery = new FieldQuery(BuiltinFields.Template, ShortID.Encode(RewriteReportItem.TemplateId));
query.Add(databaseQuery, QueryOccurance.Must);
query.Add(languageQuery, QueryOccurance.Must);
query.Add(templateQuery, QueryOccurance.Must);
return query;
}
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 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);
}
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);
}
public SitecoreSearchResultCollection FieldSearch(QueryInfo[] qis, int maxResults)
{
HighResTimer timer = new HighResTimer(true);
var combinedQuery = new CombinedQuery();
foreach (var qi in qis)
{
var q = GetQuery(qi);
if (q != null)
combinedQuery.Add(q, qi.SitecoreSearchQueryOccurance);
}
SearchResultCollection results = null;
if (combinedQuery.Clauses.Count > 0)
results = GetSearchHits(combinedQuery, maxResults);
return results != null
? new SitecoreSearchResultCollection(results, timer.Elapsed())
: null;
}
/// <summary>
/// Gets the comments for the given blog entry
/// </summary>
/// <param name="item">The item to get the comments under</param>
/// <param name="maximumCount">The maximum number of comments to retrieve</param>
/// <param name="language">The language to get the comments in</param>
/// <returns>The comments which are decendants of the given item</returns>
public CommentItem[] GetCommentsFor(Item item, int maximumCount, bool sort = false, bool reverse = false)
{
if (item != null && maximumCount > 0)
{
var blog = ManagerFactory.BlogManagerInstance.GetCurrentBlog(item);
if (blog != null)
{
#if FEATURE_CONTENT_SEARCH
var indexName = Settings.SearchIndexName;
List<CommentItem> result = new List<CommentItem>();
if (!string.IsNullOrEmpty(indexName))
{
using (var context = ContentSearchManager.GetIndex(indexName).CreateSearchContext())
{
var indexresults = context.GetQueryable<CommentResultItem>().Where(x =>
x.Paths.Contains(item.ID) &&
x.TemplateId == blog.BlogSettings.CommentTemplateID &&
x.DatabaseName.Equals(Context.Database.Name, StringComparison.InvariantCulture) &&
x.Language == item.Language.Name
);
if (indexresults.Any())
{
if(sort)
indexresults = indexresults.OrderByDescending(x => x.CreatedDate);
else if (reverse)
indexresults = indexresults.OrderBy(x => x.CreatedDate);
indexresults = indexresults.Take(maximumCount);
// Had some odd issues with the linq layer. Array to avoid them.
var indexresultsList = indexresults.ToArray();
var items = from resultItem in indexresultsList
let i = resultItem.GetItem()
where i != null
select i;
result = items.Select(x => new CommentItem(x)).ToList();
}
}
}
return result.ToArray();
#else
var query = new CombinedQuery();
// TODO: What about items using templates derived from commenttemplateid? need to accommodate those
query.Add(new FieldQuery(Constants.Index.Fields.Template, blog.BlogSettings.CommentTemplateID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Path, item.ID.ToShortID().ToString()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Language, item.Language.Name), QueryOccurance.Must);
string sortField = null;
if (sort)
{
sortField = Constants.Index.Fields.Created;
}
var searcher = new Searcher();
return searcher.Execute<CommentItem>(query, item.Language, maximumCount, (list, listItem) => list.Add((CommentItem)listItem), sortField, reverse);
#endif
}
}
return new CommentItem[0];
}
internal static void ApplyLanguageClause(CombinedQuery query, string language)
{
if (language.IsNullOrEmpty())
{
return;
}
query.Add(new FieldQuery(BuiltinFields.Language, language.ToLowerInvariant()), QueryOccurance.Must);
}
internal static void ApplyTemplateFilter(CombinedQuery query, string templateIds)
{
if (templateIds.IsNullOrEmpty())
{
return;
}
var templateList = templateIds.Split('|');
if (templateList.Length > 1)
{
var filterQuery = new CombinedQuery();
foreach (var templateId in templateList)
{
templateIds = IdHelper.NormalizeGuid(templateId);
filterQuery.Add(new FieldQuery(BuiltinFields.Template, templateIds), QueryOccurance.Should);
}
query.Add(filterQuery, QueryOccurance.Must);
}
else
{
templateIds = IdHelper.NormalizeGuid(templateIds);
query.Add(new FieldQuery(BuiltinFields.Template, templateIds), QueryOccurance.Must);
}
}
/// <summary>
/// Gets the comments for the given blog entry
/// </summary>
/// <param name="item">The item to get the comments under</param>
/// <param name="maximumCount">The maximum number of comments to retrieve</param>
/// <param name="language">The language to get the comments in</param>
/// <returns>The comments which are decendants of the given item</returns>
public CommentItem[] GetCommentsFor(Item item, int maximumCount, bool sort = false, bool reverse = false)
{
if (item != null && maximumCount > 0)
{
var blog = ManagerFactory.BlogManagerInstance.GetCurrentBlog(item);
if (blog != null)
{
#if FEATURE_CONTENT_SEARCH
var indexName = Settings.SearchIndexName;
List <CommentItem> result = new List <CommentItem>();
if (!string.IsNullOrEmpty(indexName))
{
using (var context = ContentSearchManager.GetIndex(indexName).CreateSearchContext())
{
var indexresults = context.GetQueryable <CommentResultItem>().Where(x =>
x.Paths.Contains(item.ID) &&
x.TemplateId == blog.BlogSettings.CommentTemplateID &&
x.DatabaseName.Equals(Context.Database.Name, StringComparison.InvariantCulture) &&
x.Language == item.Language.Name
);
if (indexresults.Any())
{
if (sort)
{
indexresults = indexresults.OrderByDescending(x => x.CreatedDate);
}
else if (reverse)
{
indexresults = indexresults.OrderBy(x => x.CreatedDate);
}
indexresults = indexresults.Take(maximumCount);
// Had some odd issues with the linq layer. Array to avoid them.
var indexresultsList = indexresults.ToArray();
var items = from resultItem in indexresultsList
let i = resultItem.GetItem()
where i != null
select i;
result = items.Select(x => new CommentItem(x)).ToList();
}
}
}
return(result.ToArray());
#else
var query = new CombinedQuery();
// TODO: What about items using templates derived from commenttemplateid? need to accommodate those
query.Add(new FieldQuery(Constants.Index.Fields.Template, blog.BlogSettings.CommentTemplateID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Path, item.ID.ToShortID().ToString()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Language, item.Language.Name), QueryOccurance.Must);
string sortField = null;
if (sort)
{
sortField = Constants.Index.Fields.Created;
}
var searcher = new Searcher();
return(searcher.Execute <CommentItem>(query, item.Language, maximumCount, (list, listItem) => list.Add((CommentItem)listItem), sortField, reverse));
#endif
}
}
return(new CommentItem[0]);
}
internal static void ApplyContextItemRemoval(CombinedQuery query, IEnumerable<Guid> ids)
{
if (ids == null || !ids.Any())
{
return;
}
ids.ForEach(id => query.Add(new FieldQuery(BuiltinFields.ID, IdHelper.NormalizeGuid(id)), QueryOccurance.MustNot));
}
internal static void ApplyTemplateNotFilter(CombinedQuery query)
{
query.Add(new FieldQuery(BuiltinFields.Template, IdHelper.NormalizeGuid(Config.ContainerTemplateId)), QueryOccurance.MustNot);
}
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>
/// Gets blog entries for the given blog up to the maximum number given
/// </summary>
/// <param name="blog">The blog item to get the entries for</param>
/// <param name="maxNumber">The maximum number of entries to retrieve</param>
/// <param name="tag">A tag the entry must contain</param>
/// <param name="category">A category the entry must contain</param>
/// <param name="minimumDate">The minimum date for entries</param>
/// <param name="maximumDate">The maximum date for the entries</param>
/// <returns></returns>
public EntryItem[] GetBlogEntries(Item blog, int maxNumber, string tag, string category, DateTime? minimumDate = null, DateTime? maximumDate = null)
{
if (blog == null || maxNumber <= 0)
{
return new EntryItem[0];
}
BlogHomeItem customBlogItem = null;
if (blog.TemplateIsOrBasedOn(Settings.BlogTemplateID))
{
customBlogItem = blog;
}
else
{
customBlogItem = blog.GetCurrentItem(Settings.BlogTemplateIDString);
}
if (customBlogItem == null)
{
return new EntryItem[0];
}
List<EntryItem> result = new List<EntryItem>();
#if FEATURE_CONTENT_SEARCH
var indexName = Settings.SearchIndexName;
if (!string.IsNullOrEmpty(indexName))
{
using (var context = ContentSearchManager.GetIndex(indexName).CreateSearchContext(SearchSecurityOptions.DisableSecurityCheck))
{
var builder = PredicateBuilder.True<EntryResultItem>();
var id = customBlogItem.BlogSettings.EntryTemplateID;
builder = builder.And(i => i.TemplateId == id);
builder = builder.And(i => i.Paths.Contains(customBlogItem.ID));
builder = builder.And(i => i.Language.Equals(customBlogItem.InnerItem.Language.Name, StringComparison.InvariantCulture));
builder = builder.And(item => item.DatabaseName.Equals(Context.Database.Name, StringComparison.InvariantCulture));
// Tag
if (!string.IsNullOrEmpty(tag))
{
builder = builder.And(i => i.Tags.Contains(tag));
}
// Categories
if (!string.IsNullOrEmpty(category))
{
var categoryItem = ManagerFactory.CategoryManagerInstance.GetCategory(customBlogItem, category);
// If the category is unknown, don't return any results.
if (categoryItem == null)
return new EntryItem[0];
#if SC70
var normalizedID = Sitecore.ContentSearch.Utilities.IdHelper.NormalizeGuid(categoryItem.ID);
builder = builder.And(i => i.Category.Contains(normalizedID));
#else
builder = builder.And(i => i.Category.Contains(categoryItem.ID));
#endif
}
if (minimumDate != null)
builder = builder.And(i => i.CreatedDate >= minimumDate);
if(maximumDate != null)
builder = builder.And(i => i.CreatedDate < maximumDate);
var indexresults = context.GetQueryable<EntryResultItem>().Where(builder);
if (indexresults.Any())
{
result = indexresults.Select(i => new EntryItem(i.GetItem())).ToList();
result = result.OrderByDescending(post => post.EntryDate.DateTime).Take(maxNumber).ToList();
}
}
}
#else
var query = new CombinedQuery();
//query.Add(new FieldQuery(Constants.Index.Fields.BlogID, blog.ID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Path, customBlogItem.ID.ToShortID().ToString()), QueryOccurance.Must);
query.Add(new FieldQuery(Constants.Index.Fields.Template, customBlogItem.BlogSettings.EntryTemplateID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
if (!string.IsNullOrEmpty(tag))
{
query.Add(new FieldQuery(Constants.Index.Fields.Tags, DatabaseCrawler.TransformCSV(tag)), QueryOccurance.Must);
}
if (!string.IsNullOrEmpty(category))
{
var categoryItem = ManagerFactory.CategoryManagerInstance.GetCategory(blog, category);
ID id = ID.Null;
// If the category is unknown, don't return any results.
if (categoryItem == null)
return new EntryItem[0];
id = categoryItem.ID;
query.Add(new FieldQuery(Constants.Index.Fields.Category, id.ToShortID().ToString().ToLower()), QueryOccurance.Must);
}
if (minimumDate != null)
query.Add(new FieldQuery(Constants.Index.Fields.Created, minimumDate.Value.Year.ToString() + minimumDate.Value.Month.ToString() + "*"), QueryOccurance.Must);
var searcher = new Searcher();
result = searcher.Execute<EntryItem>(query, blog.Language, maxNumber, (list, item) => list.Add((EntryItem)item), Constants.Index.Fields.EntryDate, false).ToList();
#endif
return result.ToArray();
}
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 ApplyFullTextClause(CombinedQuery query, string searchText, QueryOccurance occurance)
{
if (String.IsNullOrEmpty(searchText)) return;
query.Add(new FullTextQuery(searchText), occurance);
}
private static void AppendIndexSpecificTerms(CombinedQuery combinedQuery, string indexName, string searchText)
{
switch (indexName)
{
case "itembuckets_medialibrary":
combinedQuery.Add(new FieldQuery("artist", searchText), QueryOccurance.Should);
combinedQuery.Add(new FieldQuery("copyright", searchText), QueryOccurance.Should);
combinedQuery.Add(new FieldQuery("imagedescription", searchText), QueryOccurance.Should);
combinedQuery.Add(new FieldQuery("title", searchText), QueryOccurance.Should);
break;
case "itembuckets_sitecore":
combinedQuery.Add(new FieldQuery("artist", searchText), QueryOccurance.Should);
combinedQuery.Add(new FieldQuery("copyright", searchText), QueryOccurance.Should);
combinedQuery.Add(new FieldQuery("imagedescription", searchText), QueryOccurance.Should);
combinedQuery.Add(new FieldQuery("title", searchText), QueryOccurance.Should);
break;
case "itembuckets_systemfolder":
break;
case "itembuckets_templates":
break;
}
}
internal static void ApplyTemplateNotFilter(CombinedQuery query)
{
query.Add(new FieldQuery(BuiltinFields.Template, IdHelper.NormalizeGuid(Config.ContainerTemplateId)), QueryOccurance.MustNot);
}
internal static void ApplyIdFilter(CombinedQuery query, string fieldName, string filter)
{
if (fieldName.IsNullOrEmpty() || filter.IsNullOrEmpty())
{
return;
}
var filterQuery = new CombinedQuery();
IdHelper.ParseId(filter).Where(IdHelper.IsGuid).ForEach(value => AddFieldValueClause(filterQuery, fieldName, value, QueryOccurance.Should));
query.Add(filterQuery, QueryOccurance.Must);
}
/// <summary>
/// Gets blog entries for the given blog up to the maximum number given
/// </summary>
/// <param name="blog">The blog item to get the entries for</param>
/// <param name="maxNumber">The maximum number of entries to retrieve</param>
/// <param name="tag">A tag the entry must contain</param>
/// <param name="category">A category the entry must contain</param>
/// <returns></returns>
public EntryItem[] GetBlogEntries(Item blog, int maxNumber, string tag, string category, string datePrefix = null)
{
if (blog == null || maxNumber <= 0)
{
return new EntryItem[0];
}
BlogHomeItem customBlogItem = null;
if (blog.TemplateIsOrBasedOn(Settings.BlogTemplateID))
{
customBlogItem = blog;
}
else
{
customBlogItem = blog.GetCurrentItem(Settings.BlogTemplateIDString);
}
if (customBlogItem == null)
{
return new EntryItem[0];
}
var query = new CombinedQuery();
//query.Add(new FieldQuery(Constants.Index.Fields.BlogID, blog.ID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Path, customBlogItem.ID.ToShortID().ToString()), QueryOccurance.Must);
query.Add(new FieldQuery(Constants.Index.Fields.Template, customBlogItem.BlogSettings.EntryTemplateID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
if (!string.IsNullOrEmpty(tag))
{
query.Add(new FieldQuery(Constants.Index.Fields.Tags, DatabaseCrawler.TransformCSV(tag)), QueryOccurance.Must);
}
if (!string.IsNullOrEmpty(category))
{
var categoryItem = ManagerFactory.CategoryManagerInstance.GetCategory(blog, category);
ID id = ID.Null;
if (categoryItem != null)
id = categoryItem.ID;
query.Add(new FieldQuery(Constants.Index.Fields.Category, id.ToShortID().ToString().ToLower()), QueryOccurance.Must);
}
if (!string.IsNullOrEmpty(datePrefix))
{
query.Add(new FieldQuery(Constants.Index.Fields.Created, datePrefix + "*"), QueryOccurance.Must);
}
var searcher = new Searcher();
var result = searcher.Execute<EntryItem>(query, maxNumber, (list, item) => list.Add((EntryItem)item), Constants.Index.Fields.EntryDate, true);
return result;
}
internal static void ApplyFullTextClause(CombinedQuery query, string searchText, string indexName)
{
if (searchText.IsNullOrEmpty())
{
return;
}
var combinedQuery = new CombinedQuery();
combinedQuery.Add(new FullTextQuery(searchText), QueryOccurance.Should);
combinedQuery.Add(new FieldQuery(BuiltinFields.Name, searchText), QueryOccurance.Should);
if (!indexName.IsNullOrEmpty())
{
AppendIndexSpecificTerms(combinedQuery, indexName, searchText);
}
query.Add(combinedQuery, QueryOccurance.Must);
}
internal static void ApplyNameFilter(CombinedQuery query, string Name)
{
if (Name.IsNullOrEmpty())
{
return;
}
query.Add(new FieldQuery(BuiltinFields.Name, Name), QueryOccurance.Must);
}
/// <summary>
/// Gets the comments for the given blog entry
/// </summary>
/// <param name="item">The item to get the comments under</param>
/// <param name="maximumCount">The maximum number of comments to retrieve</param>
/// <param name="language">The language to get the comments in</param>
/// <returns>The comments which are decendants of the given item</returns>
public CommentItem[] GetCommentsFor(Item item, int maximumCount, bool sort = false, bool reverse = false)
{
if (item != null && maximumCount > 0)
{
var blog = ManagerFactory.BlogManagerInstance.GetCurrentBlog(item);
if (blog != null)
{
#if FEATURE_CONTENT_SEARCH
var indexName = Settings.SearchIndexName;
List<CommentItem> result = new List<CommentItem>();
if (!string.IsNullOrEmpty(indexName))
{
using (var context = ContentSearchManager.GetIndex(indexName).CreateSearchContext())
{
var builder = PredicateBuilder.True<CommentResultItem>();
builder = builder.And(i => i.DatabaseName == Context.Database.Name);
builder = builder.And(i => i.Language == Context.Language.Name);
builder = builder.And(i => i.Paths.Contains(item.ID));
builder = builder.And(i => i.TemplateId == Settings.CommentTemplateID);
var indexresults = context.GetQueryable<CommentResultItem>().Where(builder);
if (indexresults.Any())
{
result = indexresults.Select(i => new CommentItem(i.GetItem())).ToList();
if (sort && reverse)
{
result = result.OrderByDescending(x => x.Created).ToList();
}
else if (sort)
{
result = result.OrderBy(x => x.Created).ToList();
}
result = result.Take(maximumCount).ToList();
}
}
}
return result.ToArray();
#else
var query = new CombinedQuery();
// TODO: What about items using templates derived from commenttemplateid? need to accommodate those
query.Add(new FieldQuery(Constants.Index.Fields.Template, blog.BlogSettings.CommentTemplateID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Path, item.ID.ToShortID().ToString()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Language, item.Language.Name), QueryOccurance.Must);
string sortField = null;
if (sort)
{
sortField = Constants.Index.Fields.Created;
}
var searcher = new Searcher();
return searcher.Execute<CommentItem>(query, maximumCount, (list, listItem) => list.Add((CommentItem)listItem), sortField, reverse);
#endif
}
}
return new CommentItem[0];
}
internal static void ApplyLatestVersion(CombinedQuery globalQuery)
{
var fieldQuery = new FieldQuery(BuiltinFields.LatestVersion, "1");
globalQuery.Add(fieldQuery, QueryOccurance.Must);
}
internal static void ApplyLatestVersion(CombinedQuery globalQuery)
{
var fieldQuery = new FieldQuery(BuiltinFields.LatestVersion, "1");
globalQuery.Add(fieldQuery, QueryOccurance.Must);
}
/// <summary>
/// Gets blog entries for the given blog up to the maximum number given
/// </summary>
/// <param name="blog">The blog item to get the entries for</param>
/// <param name="maxNumber">The maximum number of entries to retrieve</param>
/// <param name="tag">A tag the entry must contain</param>
/// <param name="category">A category the entry must contain</param>
/// <param name="minimumDate">The minimum date for entries</param>
/// <param name="maximumDate">The maximum date for the entries</param>
/// <returns></returns>
public EntryItem[] GetBlogEntries(Item blog, int maxNumber, string tag, string category, DateTime?minimumDate = null, DateTime?maximumDate = null)
{
if (blog == null || maxNumber <= 0)
{
return(new EntryItem[0]);
}
BlogHomeItem customBlogItem = null;
if (blog.TemplateIsOrBasedOn(Settings.BlogTemplateID))
{
customBlogItem = blog;
}
else
{
customBlogItem = blog.GetCurrentItem(Settings.BlogTemplateIDString);
}
if (customBlogItem == null)
{
return(new EntryItem[0]);
}
List <EntryItem> result = new List <EntryItem>();
#if FEATURE_CONTENT_SEARCH
var indexName = Settings.SearchIndexName;
if (!string.IsNullOrEmpty(indexName))
{
using (var context = ContentSearchManager.GetIndex(indexName).CreateSearchContext(SearchSecurityOptions.DisableSecurityCheck))
{
var builder = PredicateBuilder.True <EntryResultItem>();
var id = customBlogItem.BlogSettings.EntryTemplateID;
builder = builder.And(i => i.TemplateId == id);
builder = builder.And(i => i.Paths.Contains(customBlogItem.ID));
builder = builder.And(i => i.Language.Equals(customBlogItem.InnerItem.Language.Name, StringComparison.InvariantCulture));
builder = builder.And(item => item.DatabaseName.Equals(Context.Database.Name, StringComparison.InvariantCulture));
// Tag
if (!string.IsNullOrEmpty(tag))
{
builder = builder.And(i => i.Tags.Contains(tag));
}
// Categories
if (!string.IsNullOrEmpty(category))
{
var categoryItem = ManagerFactory.CategoryManagerInstance.GetCategory(customBlogItem, category);
// If the category is unknown, don't return any results.
if (categoryItem == null)
{
return(new EntryItem[0]);
}
#if SC70
var normalizedID = Sitecore.ContentSearch.Utilities.IdHelper.NormalizeGuid(categoryItem.ID);
builder = builder.And(i => i.Category.Contains(normalizedID));
#else
builder = builder.And(i => i.Category.Contains(categoryItem.ID));
#endif
}
if (minimumDate != null)
{
builder = builder.And(i => i.CreatedDate >= minimumDate);
}
if (maximumDate != null)
{
builder = builder.And(i => i.CreatedDate < maximumDate);
}
var indexresults = context.GetQueryable <EntryResultItem>().Where(builder);
if (indexresults.Any())
{
result = indexresults.Select(i => new EntryItem(i.GetItem())).ToList();
result = result.OrderByDescending(post => post.EntryDate.DateTime).Take(maxNumber).ToList();
}
}
}
#else
var query = new CombinedQuery();
//query.Add(new FieldQuery(Constants.Index.Fields.BlogID, blog.ID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Path, customBlogItem.ID.ToShortID().ToString()), QueryOccurance.Must);
query.Add(new FieldQuery(Constants.Index.Fields.Template, customBlogItem.BlogSettings.EntryTemplateID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
if (!string.IsNullOrEmpty(tag))
{
query.Add(new FieldQuery(Constants.Index.Fields.Tags, DatabaseCrawler.TransformCSV(tag)), QueryOccurance.Must);
}
if (!string.IsNullOrEmpty(category))
{
var categoryItem = ManagerFactory.CategoryManagerInstance.GetCategory(blog, category);
ID id = ID.Null;
// If the category is unknown, don't return any results.
if (categoryItem == null)
{
return(new EntryItem[0]);
}
id = categoryItem.ID;
query.Add(new FieldQuery(Constants.Index.Fields.Category, id.ToShortID().ToString().ToLower()), QueryOccurance.Must);
}
if (minimumDate != null)
{
query.Add(new FieldQuery(Constants.Index.Fields.Created, minimumDate.Value.Year.ToString() + minimumDate.Value.Month.ToString() + "*"), QueryOccurance.Must);
}
var searcher = new Searcher();
result = searcher.Execute <EntryItem>(query, blog.Language, maxNumber, (list, item) => list.Add((EntryItem)item), Constants.Index.Fields.EntryDate, false).ToList();
#endif
return(result.ToArray());
}
internal static void ApplyTemplateFilter(CombinedQuery query, IEnumerable<Guid> templateIds)
{
if (templateIds == null || !templateIds.Any())
{
return;
}
var ids = templateIds as Guid[] ?? templateIds.ToArray();
if (ids.Count() > 1)
{
var filterQuery = new CombinedQuery();
foreach (var templateId in ids.Select(IdHelper.NormalizeGuid))
{
filterQuery.Add(new FieldQuery(BuiltinFields.Template, templateId), QueryOccurance.Should);
}
query.Add(filterQuery, QueryOccurance.Must);
}
else
{
query.Add(new FieldQuery(BuiltinFields.Template, IdHelper.NormalizeGuid(ids.First())), QueryOccurance.Must);
}
}
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 ApplyLanguageClause(CombinedQuery query, string language)
{
if (String.IsNullOrEmpty(language)) return;
query.Add(new FieldQuery(BuiltinFields.Language, language.ToLowerInvariant()), QueryOccurance.Must);
}
private QueryBase GetQuery()
{
QueryBase base2 = null;
NameValueCollection fieldValues = GetFieldValues();
string str = StringUtil.GetString(new string[] { Context.ClientPage.ClientRequest.Form["TreeSearch"] });
if (str == "Search")
{
str = string.Empty;
}
str = str.Trim();
if (!string.IsNullOrEmpty(str))
{
base2 = new FullTextQuery(str);
}
if (fieldValues.Count <= 0)
{
return base2;
}
CombinedQuery query = new CombinedQuery();
foreach (string str2 in fieldValues.AllKeys)
{
string fieldValue = fieldValues[str2];
if (fieldValue.Length > 0)
{
query.Add(new FieldQuery(str2.ToLowerInvariant(), fieldValue), QueryOccurance.Should);
}
}
return query;
}
public static IEnumerable<Item> GetItemsInCategories([NotNull] IEnumerable<ID> categories)
{
Assert.ArgumentNotNull(categories, "categories");
var index = SearchManager.SystemIndex;
if (index == null)
{
return new Item[0];
}
var query = new CombinedQuery();
foreach (var id in categories)
{
query.Add(new FieldQuery("_categories", ShortID.Encode(id)), QueryOccurance.Must);
}
SearchResultCollection collection;
using (var context = index.CreateSearchContext())
{
collection = context.Search(query).FetchResults(0, int.MaxValue);
}
return collection.Select(result => SearchManager.GetObject(result)).OfType<Item>();
}
/// <summary>
/// Gets blog entries for the given blog up to the maximum number given
/// </summary>
/// <param name="blog">The blog item to get the entries for</param>
/// <param name="maxNumber">The maximum number of entries to retrieve</param>
/// <param name="tag">A tag the entry must contain</param>
/// <param name="category">A category the entry must contain</param>
/// <returns></returns>
public EntryItem[] GetBlogEntries(Item blog, int maxNumber, string tag, string category, string datePrefix = null)
{
if (blog == null || maxNumber <= 0)
{
return(new EntryItem[0]);
}
BlogHomeItem customBlogItem = null;
if (blog.TemplateIsOrBasedOn(Settings.BlogTemplateID))
{
customBlogItem = blog;
}
else
{
customBlogItem = blog.GetCurrentItem(Settings.BlogTemplateIDString);
}
if (customBlogItem == null)
{
return(new EntryItem[0]);
}
List <EntryItem> result = new List <EntryItem>();
#if FEATURE_CONTENT_SEARCH
var indexName = Settings.SearchIndexName;
if (!string.IsNullOrEmpty(indexName))
{
using (var context = ContentSearchManager.GetIndex(indexName).CreateSearchContext())
{
var builder = PredicateBuilder.True <EntryResultItem>();
var id = Settings.EntryTemplateID;
builder = builder.And(i => i.TemplateId == id);
// Tag
if (!String.IsNullOrEmpty(tag))
{
builder = builder.And(PredicateController.BlogTags(tag));
}
// Categories
if (!string.IsNullOrEmpty(category))
{
builder = builder.And(PredicateController.BlogCategory(category));
}
var indexresults = context.GetQueryable <EntryResultItem>().Where(builder);
if (indexresults.Any())
{
result = indexresults.Select(i => new EntryItem(i.GetItem())).ToList();
result = result.OrderByDescending(post => post.Created).Take(maxNumber).ToList();
}
}
}
#else
var query = new CombinedQuery();
//query.Add(new FieldQuery(Constants.Index.Fields.BlogID, blog.ID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Path, customBlogItem.ID.ToShortID().ToString()), QueryOccurance.Must);
query.Add(new FieldQuery(Constants.Index.Fields.Template, customBlogItem.BlogSettings.EntryTemplateID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
if (!string.IsNullOrEmpty(tag))
{
query.Add(new FieldQuery(Constants.Index.Fields.Tags, DatabaseCrawler.TransformCSV(tag)), QueryOccurance.Must);
}
if (!string.IsNullOrEmpty(category))
{
var categoryItem = ManagerFactory.CategoryManagerInstance.GetCategory(blog, category);
ID id = ID.Null;
if (categoryItem != null)
{
id = categoryItem.ID;
}
query.Add(new FieldQuery(Constants.Index.Fields.Category, id.ToShortID().ToString().ToLower()), QueryOccurance.Must);
}
if (!string.IsNullOrEmpty(datePrefix))
{
query.Add(new FieldQuery(Constants.Index.Fields.Created, datePrefix + "*"), QueryOccurance.Must);
}
var searcher = new Searcher();
result = searcher.Execute <EntryItem>(query, maxNumber, (list, item) => list.Add((EntryItem)item), Constants.Index.Fields.EntryDate, true).ToList();
#endif
return(result.ToArray());
}
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 ApplyContextItemRemoval(CombinedQuery query, string Id)
{
if (Id.IsNullOrEmpty())
{
return;
}
Id = IdHelper.NormalizeGuid(Id);
query.Add(new FieldQuery(BuiltinFields.ID, Id), QueryOccurance.MustNot);
}
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>
/// Gets the comments for the given blog entry
/// </summary>
/// <param name="item">The item to get the comments under</param>
/// <param name="maximumCount">The maximum number of comments to retrieve</param>
/// <param name="language">The language to get the comments in</param>
/// <returns>The comments which are decendants of the given item</returns>
public CommentItem[] GetCommentsFor(Item item, int maximumCount, bool sort = false, bool reverse = false)
{
if (item != null && maximumCount > 0)
{
var blog = ManagerFactory.BlogManagerInstance.GetCurrentBlog(item);
if (blog != null)
{
var query = new CombinedQuery();
// TODO: What about items using templates derived from commenttemplateid? need to accommodate those
query.Add(new FieldQuery(Constants.Index.Fields.Template, blog.BlogSettings.CommentTemplateID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Path, item.ID.ToShortID().ToString()), QueryOccurance.Must);
string sortField = null;
if (sort)
{
sortField = Constants.Index.Fields.Created;
}
var searcher = new Searcher();
return searcher.Execute<CommentItem>(query, maximumCount, (list, listItem) => list.Add((CommentItem)listItem), sortField, reverse);
}
}
return new CommentItem[0];
}
/// <summary>
/// Gets blog entries for the given blog up to the maximum number given
/// </summary>
/// <param name="blog">The blog item to get the entries for</param>
/// <param name="maxNumber">The maximum number of entries to retrieve</param>
/// <param name="tag">A tag the entry must contain</param>
/// <param name="category">A category the entry must contain</param>
/// <returns></returns>
public EntryItem[] GetBlogEntries(Item blog, int maxNumber, string tag, string category, string datePrefix = null)
{
if (blog == null || maxNumber <= 0)
{
return new EntryItem[0];
}
BlogHomeItem customBlogItem = null;
if (blog.TemplateIsOrBasedOn(Settings.BlogTemplateID))
{
customBlogItem = blog;
}
else
{
customBlogItem = blog.GetCurrentItem(Settings.BlogTemplateIDString);
}
if (customBlogItem == null)
{
return new EntryItem[0];
}
List<EntryItem> result = new List<EntryItem>();
#if FEATURE_CONTENT_SEARCH
var indexName = Settings.SearchIndexName;
if (!string.IsNullOrEmpty(indexName))
{
using (var context = ContentSearchManager.GetIndex(indexName).CreateSearchContext())
{
var builder = PredicateBuilder.True<EntryResultItem>();
var id = Settings.EntryTemplateID;
builder = builder.And(i => i.TemplateId==id);
// Tag
if (!String.IsNullOrEmpty(tag))
{
builder = builder.And(PredicateController.BlogTags(tag));
}
// Categories
if (!string.IsNullOrEmpty(category))
{
builder = builder.And(PredicateController.BlogCategory(category));
}
var indexresults = context.GetQueryable<EntryResultItem>().Where(builder);
if (indexresults.Any())
{
result = indexresults.Select(i => new EntryItem(i.GetItem())).ToList();
result = result.OrderByDescending(post => post.Created).Take(maxNumber).ToList();
}
}
}
#else
var query = new CombinedQuery();
//query.Add(new FieldQuery(Constants.Index.Fields.BlogID, blog.ID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
query.Add(new FieldQuery(Sitecore.Search.BuiltinFields.Path, customBlogItem.ID.ToShortID().ToString()), QueryOccurance.Must);
query.Add(new FieldQuery(Constants.Index.Fields.Template, customBlogItem.BlogSettings.EntryTemplateID.ToShortID().ToString().ToLower()), QueryOccurance.Must);
if (!string.IsNullOrEmpty(tag))
{
query.Add(new FieldQuery(Constants.Index.Fields.Tags, DatabaseCrawler.TransformCSV(tag)), QueryOccurance.Must);
}
if (!string.IsNullOrEmpty(category))
{
var categoryItem = ManagerFactory.CategoryManagerInstance.GetCategory(blog, category);
ID id = ID.Null;
if (categoryItem != null)
id = categoryItem.ID;
query.Add(new FieldQuery(Constants.Index.Fields.Category, id.ToShortID().ToString().ToLower()), QueryOccurance.Must);
}
if (!string.IsNullOrEmpty(datePrefix))
{
query.Add(new FieldQuery(Constants.Index.Fields.Created, datePrefix + "*"), QueryOccurance.Must);
}
var searcher = new Searcher();
result = searcher.Execute<EntryItem>(query, maxNumber, (list, item) => list.Add((EntryItem)item), Constants.Index.Fields.EntryDate, true).ToList();
#endif
return result.ToArray();
}
internal static void ApplyIdFilter(CombinedQuery query, string fieldName, params Guid[] guids)
{
if (guids == null || !guids.Any())
{
return;
}
if (guids.Length > 1)
{
var filterQuery = new CombinedQuery();
guids.Select(IdHelper.NormalizeGuid).ForEach(value => AddFieldValueClause(filterQuery, fieldName, value, QueryOccurance.Should));
query.Add(filterQuery, QueryOccurance.Must);
}
else
{
AddFieldValueClause(query, fieldName, IdHelper.NormalizeGuid(guids.First()), QueryOccurance.Must);
}
}