示例#1
0
        public async Task <IEnumerable <ContentPickerResult> > Search(ContentPickerSearchContext searchContext)
        {
            var query = _session.Query <ContentItem, ContentItemIndex>()
                        .With <ContentItemIndex>(x => x.ContentType.IsIn(searchContext.ContentTypes) && x.Latest);

            if (!string.IsNullOrEmpty(searchContext.Query))
            {
                query.With <ContentItemIndex>(x => x.DisplayText.Contains(searchContext.Query) || x.ContentType.Contains(searchContext.Query));
            }

            var contentItems = await query.Take(20).ListAsync();

            var results = new List <ContentPickerResult>();

            foreach (var contentItem in contentItems)
            {
                results.Add(new ContentPickerResult
                {
                    ContentItemId = contentItem.ContentItemId,
                    DisplayText   = contentItem.ToString()
                });
            }

            return(results);
        }
示例#2
0
        public async Task <IEnumerable <ContentPickerResult> > Search(ContentPickerSearchContext searchContext)
        {
            var indexName = "Search";

            var fieldSettings = searchContext.PartFieldDefinition?.GetSettings <ContentPickerFieldElasticEditorSettings>();

            if (!string.IsNullOrWhiteSpace(fieldSettings?.Index))
            {
                indexName = fieldSettings.Index;
            }

            if (!await _elasticIndexProvider.ExistsAsync(indexName))
            {
                return(new List <ContentPickerResult>());
            }

            var results = new List <ContentPickerResult>();

            await _elasticIndexProvider.SearchAsync(indexName, () =>
            {
                //todo
//                Query query = null;
//
//                if (string.IsNullOrWhiteSpace(searchContext.Query))
//                {
//                    query = new MatchAllDocsQuery();
//                }
//                else
//                {
//                    query = new WildcardQuery(new Term("Content.ContentItem.DisplayText.Analyzed", searchContext.Query.ToLowerInvariant() + "*"));
//                }
//
//                var filter = new FieldCacheTermsFilter("Content.ContentItem.ContentType", searchContext.ContentTypes.ToArray());
//
//                var docs = searcher.Search(query, filter, 50, Sort.RELEVANCE);
//
//                foreach (var hit in docs.ScoreDocs)
//                {
//                    var doc = searcher.Doc(hit.Doc);
//
//                    results.Add(new ContentPickerResult
//                    {
//                        ContentItemId = doc.GetField("ContentItemId").GetStringValue(),
//                        DisplayText = doc.GetField("Content.ContentItem.DisplayText").GetStringValue()
//                    });
//                }

                return(Task.CompletedTask);
            });

            return(results);
        }
        public async Task <IEnumerable <ContentPickerResult> > Search(ContentPickerSearchContext searchContext)
        {
            var indexName = "Search";

            var fieldSettings = searchContext.PartFieldDefinition?.GetSettings <ContentPickerFieldLuceneEditorSettings>();

            if (!string.IsNullOrWhiteSpace(fieldSettings?.Index))
            {
                indexName = fieldSettings.Index;
            }

            if (!_luceneIndexProvider.Exists(indexName))
            {
                return(new List <ContentPickerResult>());
            }

            var results = new List <ContentPickerResult>();

            await _luceneIndexProvider.SearchAsync(indexName, searcher =>
            {
                Query query = null;

                if (string.IsNullOrWhiteSpace(searchContext.Query))
                {
                    query = new MatchAllDocsQuery();
                }
                else
                {
                    query = new WildcardQuery(new Term("Content.ContentItem.DisplayText.Analyzed", searchContext.Query.ToLowerInvariant() + "*"));
                }

                var filter = new FieldCacheTermsFilter("Content.ContentItem.ContentType", searchContext.ContentTypes.ToArray());

                var docs = searcher.Search(query, filter, 50, Sort.RELEVANCE);

                foreach (var hit in docs.ScoreDocs)
                {
                    var doc = searcher.Doc(hit.Doc);

                    results.Add(new ContentPickerResult
                    {
                        ContentItemId = doc.GetField("ContentItemId").GetStringValue(),
                        DisplayText   = doc.GetField("Content.ContentItem.DisplayText").GetStringValue(),
                        HasPublished  = doc.GetField("Content.ContentItem.Published").GetStringValue() == "true" ? true : false
                    });
                }

                return(Task.CompletedTask);
            });

            return(results.OrderBy(x => x.DisplayText));
        }
        public async Task <IEnumerable <ContentPickerResult> > Search(ContentPickerSearchContext searchContext)
        {
            var contentTypes = searchContext.ContentTypes;

            if (searchContext.DisplayAllContentTypes)
            {
                contentTypes = _contentDefinitionManager
                               .ListTypeDefinitions()
                               .Where(x => string.IsNullOrEmpty(x.GetSettings <ContentTypeSettings>().Stereotype))
                               .Select(x => x.Name)
                               .AsEnumerable();
            }

            var query = _session.Query <ContentItem, ContentItemIndex>()
                        .With <ContentItemIndex>(x => x.ContentType.IsIn(contentTypes) && x.Latest);

            if (!string.IsNullOrEmpty(searchContext.Query))
            {
                query.With <ContentItemIndex>(x => x.DisplayText.Contains(searchContext.Query) || x.ContentType.Contains(searchContext.Query));
            }

            var contentItems = await query.Take(50).ListAsync();

            var results = new List <ContentPickerResult>();

            foreach (var contentItem in contentItems)
            {
                results.Add(new ContentPickerResult
                {
                    ContentItemId = contentItem.ContentItemId,
                    DisplayText   = contentItem.ToString(),
                    HasPublished  = await _contentManager.HasPublishedVersionAsync(contentItem)
                });
            }

            return(results.OrderBy(x => x.DisplayText));
        }