public IEnumerable <ExamineIndex> GetAllExamineIndexes()
        {
            var indexes = new List <ExamineIndex>();
            var examineIndexesCollection = ExamineManager.Instance.IndexProviderCollection;

            foreach (LuceneIndexer examineItem in examineIndexesCollection)
            {
                var i = new ExamineIndex {
                    Name = examineItem.Name, IndexPath = examineItem.LuceneIndexFolder.FullName
                };
                indexes.Add(i);
            }

            return(indexes);
        }
Ejemplo n.º 2
0
        public IExamineIndex Get <T>(
            IEnumerable <T> source,
            Analyzer analyzer,
            IEnumerable <string> includeDocumentTypes = null,
            IEnumerable <string> excludeDocumentTypes = null,
            EventHandler <DocumentWritingEventArgs> documentWritingHandler    = null,
            EventHandler <IndexingNodeDataEventArgs> gatheringNodeDataHandler = null,
            string indexDirectoryPath = null) where T : class, IExamineDocument
        {
            Directory dir;

            if (!string.IsNullOrEmpty(indexDirectoryPath))
            {
                dir = FSDirectory.Open(System.IO.Directory.CreateDirectory(indexDirectoryPath));
            }
            else
            {
                dir = new RAMDirectory();
            }

            var userFieldSets = ExamineUserFieldSetFactory.Get(typeof(T));

            var examineIndex = new ExamineIndex
            {
                UserFields        = userFieldSets,
                IncludeNodeTypes  = (includeDocumentTypes ?? new string[] { }).ToArray(),
                ExcludeNodeTypes  = (excludeDocumentTypes ?? new string[] { }).ToArray(),
                SimpleDataService = MockRepository.GenerateMock <ISimpleDataService>(),
                LuceneDir         = dir
            };

            examineIndex.IndexCriteria = new IndexCriteria(
                Enumerable.Empty <IIndexField>(),
                userFieldSets,
                examineIndex.IncludeNodeTypes,
                examineIndex.ExcludeNodeTypes,
                -1);

            examineIndex.Analyzer = analyzer;

            examineIndex.Indexer = new SimpleDataIndexer(
                examineIndex.IndexCriteria,
                examineIndex.LuceneDir,
                examineIndex.Analyzer,
                examineIndex.SimpleDataService,
                new[] { Constants.IndexType },
                false);

            if (documentWritingHandler != null)
            {
                ((LuceneIndexer)examineIndex.Indexer).DocumentWriting += documentWritingHandler;
            }

            if (gatheringNodeDataHandler != null)
            {
                ((LuceneIndexer)examineIndex.Indexer).GatheringNodeData += gatheringNodeDataHandler;
            }

            examineIndex.LuceneSearcherProvider = new LuceneSearcher(dir, analyzer);

            var dataSet =
                source.Select(
                    (itemToIndex, index) =>
                    ExamineSimpleDataSetFactory.Get(itemToIndex))
                .Where(p => p != null);

            var examineSimpleDataSet = new ExamineSimpleDataSet(Constants.IndexType, dataSet);

            examineIndex.SimpleDataService.Stub(p => p.GetAllData(Constants.IndexType)).Return(examineSimpleDataSet);

            examineIndex.Indexer.RebuildIndex();

            return(examineIndex);
        }