public IEnumerable <Sitecore.Data.Items.Item> BasicSearch(string querytext)
{
var indexName = String.Format("sitecore_{0}_index", Sitecore.Context.Database.Name);
ISearchIndex index = ContentSearchManager.GetIndex(indexName);
var tID = new ID("{766464BE-12CA-4441-8DF2-2D3865B57B23}");
using (IProviderSearchContext context = index.CreateSearchContext())
{
var query = context.GetQueryable <TestModel>().Where(x => x.description.Contains(querytext));
query = query.Filter(x => x.TemplateId == tID);
var results = query.GetResults();
return(results.Hits.Select(h => GetSiteCoreItem(h.Document.ItemId)).ToArray());
}
}
protected virtual RuleList <TrackingRuleContext> GetProfilingRules(Item item)
{
Assert.ArgumentNotNull(item, "item");
using (var context = ContentSearchManager.CreateSearchContext(new SitecoreIndexableItem(item)))
{
var results = context.GetQueryable <ConfigItem>()
.Where(i => i.Paths.Contains(DefaultRulesFolderID))
.Where(i => !i.Disabled)
.Select(i => i.GetItem())
.ToArray();
var rules = RuleFactory.GetRules <TrackingRuleContext>(results, "Rules");
return(rules);
}
}
protected void Page_Load(object sender, EventArgs e)
{
using (var context = ContentSearchManager.GetIndex("azure-sitecore-master-media-index").CreateSearchContext())
{
var queryable = context.GetQueryable <AzureSearchResultItem>();
queryable = queryable.Where(s => s.Content.Contains("android"));
queryable = queryable.Where(s => s.Language == "en");
var results = queryable.Take(10).GetResults();
gvResults.DataSource = results.Hits.Select(d => d.Document);
gvResults.DataBind();
}
}
public SearchItems GetBannerBySiteCode(string siteCode, int page = 0, int pageSize = 100)
{
var siteItems = _siteSearchRepository.GetSitebySiteCode(siteCode);
if (siteItems.TotalNumberOfResults == 1)
{
using (var searchContext = ContentSearchManager.GetIndex(this.IndexName).CreateSearchContext())
{
var path = siteItems.ScoredItems.First().Item.Paths.FullPath;
return(QueryBanner(searchContext, path, page, pageSize));
}
}
return(new SearchItems(new List <ScoredItem>(), 0));
}
public SearchItems GetPageViews(ID template)
{
using (var searchContext = ContentSearchManager.GetIndex(this.IndexName).CreateSearchContext())
{
var results = searchContext.GetQueryable <PageViewsIndex>()
.Where(x => x.AllTemplates.Contains(IdHelper.NormalizeGuid(template)))
.Filter(x => x.IsLatestVersion && x.Language == this._sitecoreContext.Language.Name)
.GetResults();
var items = this.BuildResultModel(results);
var hits = results.TotalSearchResults;
return(new SearchItems(items, hits));
}
}
public EventsList GetEventsList(int pageNo)
{
var indexname = $"events_{RenderingContext.Current.ContextItem.Database.Name.ToLower()}_index";
var index = ContentSearchManager.GetIndex(indexname);
using (var context = index.CreateSearchContext())
{
var results = context.GetQueryable <EventDetails>().Where(i => i.Paths.Contains(RenderingContext.Current.ContextItem.ID)).Where(i => i.Language == RenderingContext.Current.ContextItem.Language.Name).Page(pageNo, PageSize).GetResults();
return(new EventsList()
{
Events = results.Hits.Select(h => h.Document).ToArray(), TotalResultCount = results.TotalSearchResults, PageSize = PageSize
});
}
}
public ISearchResult Search(SearchCriteria criteria)
{
if (criteria == null || string.IsNullOrWhiteSpace(criteria.Text))
{
return(new SearchResult());
}
var timer = new Sitecore.Diagnostics.HighResTimer(true);
var index = ContentSearchManager.GetIndex("sitecore_master_index") as SpatialLuceneIndex;
using (var context = index.CreateSearchContext() as SpatialLuceneSearchContext)
{
if (criteria.PointRadius != null)
{
context.SetGeoFilter(new PointRadiusCriterion()
{
FieldName = "_geohash",
RadiusKm = criteria.PointRadius.RadiusKm,
Latitude = criteria.PointRadius.Latitude,
Longitude = criteria.PointRadius.Longitude,
Sort = PointRadiusCriterion.SortOption.Ascending
});
}
var queriable = context.GetQueryable <SearchResultItem>();
Expression <Func <SearchResultItem, bool> > predicate = PredicateBuilder.True <SearchResultItem>();
foreach (var entry in criteria.Text.Split(' '))
{
predicate = predicate.And(i => i.Content == entry);
}
var result = queriable
.Where(predicate)
.Page(criteria.CurrentPage - 1, criteria.PageSize)
.FacetPivotOn(p => p.FacetOn(d => d["categories"]).FacetOn(d => d["haspoint"]))
.GetResults();
var searchResult = new SearchResult()
{
ResultDocuments = result.Hits.Select(hit => hit.Document).ToList(),
Facets = CollectFacets(result.Facets.Categories),
TotalSearchResults = result.TotalSearchResults,
};
searchResult.TotalMilliseconds = timer.ElapsedTimeSpan.Milliseconds;
return(searchResult);
}
}
public ICognitiveSearchResult GetAnalysis(string itemId, string languageCode, string dbName)
{
var index = ContentSearchManager.GetIndex(GetIndexName(dbName));
using (var context = index.CreateSearchContext(SearchSecurityOptions.DisableSecurityCheck))
{
return(context.GetQueryable <CognitiveSearchResult>()
.Where(a =>
a.UniqueId.Contains(itemId.ToLower()) &&
a.Language == languageCode)
.Take(1)
.FirstOrDefault());
}
}
private IEnumerable <Sitecore.Data.Items.Item> GetChildCategories(ID categorySitecoreId)
{
// var searchManager = CommerceTypeLoader.CreateInstance<ICommerceSearchManager>();
var index = ContentSearchManager.GetIndex("sitecore_web_index");
//var searchIndex = searchManager.GetIndex();
//var searchIndex1 = searchManager1.GetIndex();
// TODO: I replicated this from the SXA storefront code.
// Seems a strange way to get the child categories to me.
// Why not use ParentCategoryList to query in the index, need to investigate.
//using (var context = searchIndex.CreateSearchContext())
using (var context = index.CreateSearchContext())
{
var category = context.GetQueryable <CommerceCategorySearchResultItem>()
.Where(x => x.ItemId == categorySitecoreId)
.Where(x => x.Language == Sitecore.Context.Language.Name)
.ToList();
if (category.Count() == 0)
{
return(null);
}
var childrenCategories = String.Empty;
try
{
childrenCategories = category[0]["childrencategorylist"];
}
catch (KeyNotFoundException)
{
Sitecore.Diagnostics.Log.Info($"No children categories found for {category[0].DisplayName}", this);
}
if (string.IsNullOrEmpty(childrenCategories))
{
return(null);
}
var childrenCategoryIds = childrenCategories.Split(new[] { '|' }, StringSplitOptions.RemoveEmptyEntries);
return(childrenCategoryIds
.Select(x => Sitecore.Context.Database.GetItem(new ID(x))));
}
}
protected void btnRebuild_OnClick(object sender, EventArgs e)
{
ContentSearchManager.GetIndex("sitecore_analytics_index").Reset();
var poolPath = "aggregationProcessing/processingPools/live";
var pool = Factory.CreateObject(poolPath, true) as ProcessingPool;
var driver = MongoDbDriver.FromConnectionString("analytics");
var visitorData = driver.Interactions.FindAllAs <VisitData>();
var keys = visitorData.Select(data => new InteractionKey(data.ContactId, data.InteractionId));
foreach (var key in keys)
{
var poolItem = new ProcessingPoolItem(key.ToByteArray());
pool?.Add(poolItem);
}
}
public SearchResult Search(SearchParameters searchParameters)
{
_searchParameters = searchParameters;
using (_context = ContentSearchManager.GetIndex(_searchParameters.IndexName).CreateSearchContext())
{
Expression <Func <SearchResultItem, bool> > query = _indexQueryBuilder.BuildQuery(searchParameters);
IQueryable <SearchResultItem> queryable = ConvertToQueryable(query);
queryable = _indexQueryBuilder.ApplySortingPagingFacets(queryable, searchParameters);
return(ExecuteQuery(queryable));
}
}
public static IEnumerable <ProductModel> Find(string term)
{
term = term.ToUpper();
var index = ContentSearchManager.GetIndex("sitecore_master_index");
using (var context = index.CreateSearchContext())
{
var results = context.GetQueryable <SearchResultItem>()
.Where(x => x.TemplateName.Equals("Product") && x["Description"].Contains(term))
.Take(5).ToList();
return(results.Select(x => new ProductModel(x.GetField("StockCode").Value, float.Parse(x.GetField("Price").Value), x.GetField("Description").Value)));
}
}
public IPath GetByEndpointPath(string path, IDefinition definition)
{
using (var context = ContentSearchManager.CreateSearchContext(new SitecoreIndexableItem(Context.Item)))
{
IQueryable <PathSearchItem> query = context.GetQueryable <PathSearchItem>();
query = query.Where(i => i.Paths.Contains(new ID(definition.ItemId)));
query = query.Where(i => i.TemplateId == Constants.Path.PathTemplateId);
query = query.Where(i => i.EndpointPath == path);
IEnumerable <IPath> results = query.GenerateResults <IPath, PathSearchItem>();
return(results.FirstOrDefault());
}
}
private static ISearchIndex CustomSolrIndex(string name)
{
return(_indexes.GetOrAdd(name, (x) =>
{
var searchIndex = ContentSearchManager.GetIndex(name) as SolrSearchIndex;
var customSolrIndex = new SSSolrSearchIndex(searchIndex.Name, searchIndex.Core, searchIndex.PropertyStore)
{
Configuration = searchIndex.Configuration
};
customSolrIndex.Initialize();
return customSolrIndex;
}));
}
/// <summary>
/// Get index based on the database
/// </summary>
/// <param name="database">sitecore database</param>
/// <returns>search index</returns>
public ISearchIndex GetIndex(string database)
{
foreach (var service in _sitecoreServices)
{
if (service.DatabaseName != null)
{
if (service.DatabaseName.Equals(database, StringComparison.InvariantCultureIgnoreCase))
{
return(ContentSearchManager.GetIndex(service.Index));
}
}
}
return(ContentSearchManager.GetIndex(defaultIndex));
}
public string Search([NotNull] string indexName, [NotNull] string fieldName, [NotNull] string search, [NotNull] string type, [NotNull] string pageOffset)
{
Assert.ArgumentNotNull(indexName, nameof(indexName));
Assert.ArgumentNotNull(fieldName, nameof(fieldName));
Assert.ArgumentNotNull(search, nameof(search));
Assert.ArgumentNotNull(type, nameof(type));
Assert.ArgumentNotNull(pageOffset, nameof(pageOffset));
ISearchIndex index;
try
{
index = ContentSearchManager.GetIndex(indexName);
}
catch
{
return(string.Empty);
}
if (index == null)
{
return(string.Empty);
}
int offset;
int.TryParse(pageOffset, out offset);
using (var context = index.CreateSearchContext())
{
var searchResultItems = context.GetQueryable <SearchResultItem>().Where(item => item[fieldName].Contains(search)).Skip(offset).ToList();
var writer = new StringWriter();
var output = new XmlTextWriter(writer)
{
Formatting = Formatting.Indented,
Indentation = 2
};
output.WriteStartElement("hits");
WriteDocuments(output, searchResultItems, 0);
output.WriteEndElement();
return(writer.ToString());
}
}
public ActionResult BookList()
{
BookSearchResult model = new BookSearchResult();
ISitecoreService service = new SitecoreService(Sitecore.Context.Database);
SitecoreIndexableItem contextItem = Sitecore.Context.Item;
SearchResults <CustomSearchResultItem> results;
using (var context = ContentSearchManager.GetIndex(contextItem).CreateSearchContext())
{
IQueryable <CustomSearchResultItem> query = context.GetQueryable <CustomSearchResultItem>();
query = query.Where(f => f.Paths.Contains(Sitecore.Context.Item.ID) &&
f.TemplateId == BookTemplate.Book.ID &&
f.Language == Sitecore.Context.Language.Name).Page(0, 30);
results = query.GetResults();
}
List <CustomSearchResultItem> resultItems = results?.Hits.Select(f => f.Document).ToList();
List <IBook> books = new List <IBook>();
//List<BookItem> bookItems = new List<BookItem>();
foreach (var bookItem in resultItems)
{
books.Add(service.GetItem <IBook>(bookItem.ItemId.ToGuid()));
//bookItems.Add(new BookItem
// {
// Title = bookItem.Title,
// Publisher = bookItem.Publisher,
// AuthorName = bookItem.AuthorName
// });
//model.BookItems = bookItems;
model.Books = books;
}
#region Facets
//List<Facet> facets = new List<Facet>();
//foreach(var category in results.Facets?.Categories)
//{
// foreach(var facet in category.Values)
// {
// facets.Add(new Facet { Name = facet.Name, Count = facet.AggregateCount });
// }
//}
//model.Facets = facets;
#endregion
return(View(model));
}
public void Example5()
{
using (var context = ContentSearchManager.GetIndex("sitecore_master_index").CreateSearchContext())
{
var query = context.GetQueryable <Article>().Where(item => item.Title.StartsWith("New")).FacetOn(i => i.PublishDate).GetResults();
GridView5.DataSource = query.Hits;
GridView5.DataBind();
foreach (var facet in query.Facets.Categories)
{
Facets.Text = Facets.Text + facet.Name + " : " + facet.Values.Count;
}
Count.Text = query.TotalSearchResults.ToString(CultureInfo.InvariantCulture);
}
}
protected virtual object BuildLuceneDocument(object builderObject, IIndexable indexable)
{
var documentBuilder = builderObject as LuceneDocumentBuilder;
if (documentBuilder == null)
{
return(null);
}
documentBuilder.AddSpecialFields();
documentBuilder.AddItemFields();
documentBuilder.AddComputedIndexFields();
documentBuilder.AddBoost();
return(new IndexData(ContentSearchManager.GetIndex(this.AnalyticsIndexName), indexable, documentBuilder).BuildDocument());
}
public ID GetCategory(string categoryName)
{
using (var context = ContentSearchManager.GetIndex($"sitecore_{Database.Name}_index").CreateSearchContext())
{
var searchQuery = context
.GetQueryable <SearchResultItem>()
.Where(item => item.Name == categoryName);
if (searchQuery.Any())
{
return(searchQuery.FirstOrDefault().ItemId);
}
}
return(ID.Null);
}
public override IEnumerable <Item> GetSourceItems()
{
if (ID.IsNullOrEmpty(RootPath) || IncludedContentTypes.Any() == false)
{
return(Enumerable.Empty <Item>());
}
string databaseName = Sitecore.Context.Database.Name;
using (var searcher = ContentSearchManager.GetIndex(string.Format(INDEX, databaseName)).CreateSearchContext())
{
var query = PredicateBuilder.True <CustomSearchResultItem>();
query = query.And(i => i.Paths.Contains(RootPath));
var contentTypesQuery = PredicateBuilder.False <CustomSearchResultItem>();
foreach (var ct in IncludedContentTypes)
{
var id = ct;
contentTypesQuery = contentTypesQuery.Or(i => i.TemplateId == id);
}
query = query.And(contentTypesQuery);
var from = DateTime.Today.AddMonths(-RecencyMonths);
query = query.And(x => x.CreatedDate.Between(from, DateTime.Today, Inclusion.Both));
var tagsQuery = PredicateBuilder.True <CustomSearchResultItem>();
foreach (var tag in Tags)
{
var id = tag;
tagsQuery = tagsQuery.And(i => i.PrimaryTag.Contains(id));
}
query = query.And(tagsQuery);
var results = searcher.GetQueryable <CustomSearchResultItem>()
.Where(query)
.Take(MaximumItemsInFeed)
.GetResults()
.Hits
.Select(i => i.Document.GetItem())
.ToList();
return(results);
}
}
/// <summary>
/// ContentSearch based on search text and templates (facets).
/// </summary>
/// <param name="filter">The ContentSearchFilter.</param>
/// <returns></returns>
public ContentSearchResult SearchWithFacets(ContentSearchFilter filter)
{
var contentSearchResult = new ContentSearchResult
{
Paging = new Paging(),
ContentSearchResultItems = new List <ContentSearchResultItem>()
};
string index = GetSearchIndexName();
using (var context = ContentSearchManager.GetIndex(index).CreateSearchContext())
{
// Null query, will be updated with search text and template filter.
var query = context.GetQueryable <SearchResultItem>();
// Retrieve all possible facets before a query is done with the search text.
var facetResults = query.FacetOn(item => item.TemplateId).GetFacets();
FacetResults facetResultsAfterSearch = null;
if (filter != null)
{
ApplySearchStringQuery(filter.SearchText, ref query);
facetResultsAfterSearch = query.FacetOn(item => item.TemplateId).GetFacets();
ApplyTemplateQuery(filter.Templates, ref query);
}
var searchResult = query.FacetOn(item => item.TemplateId).GetResults();
UpdateResultWithFacets(facetResults, facetResultsAfterSearch, searchResult, contentSearchResult);
var distinctHits = searchResult.Hits.Distinct().ToList();
UpdateResultWithItem(
contentSearchResult,
distinctHits,
NewsTemplate.ID);
UpdateResultWithItem(
contentSearchResult,
distinctHits,
EventTemplate.ID);
contentSearchResult.ResultCount = contentSearchResult.ContentSearchResultItems.Count;
int numberToSkip;
UpdateResultWithPaging(contentSearchResult, filter, out numberToSkip);
contentSearchResult.ContentSearchResultItems = contentSearchResult.ContentSearchResultItems.Skip(numberToSkip).Take(contentSearchResult.Paging.PageSize).ToList();
return(contentSearchResult);
}
}
/// <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]);
}
