private void ReindexContent(Index config, IndexService indexService, string index)
{
var contentTypes = Services.ContentTypeService.GetAllContentTypes().ToArray();
foreach (var contentType in config.ContentTypes)
{
var contentTypeId = contentTypes?.FirstOrDefault(c => c.Alias == contentType.Alias)?.Id ?? 0;
if (!string.IsNullOrWhiteSpace(contentType.Alias) && contentTypeId == 0)
{
continue;
}
var contents = Services.ContentService.GetContentOfContentType(contentTypeId).Where(c => c.Published);
if (string.IsNullOrWhiteSpace(contentType.Alias))
{
contents = GetNodesByContentTypes(
contentTypes.Except(
contentTypes.Where(ct => config.ContentTypes.Select(c => c.Alias).Contains(ct.Alias))
).Select(x => x.Id));
}
foreach (var content in contents)
{
indexService.Index(content, Models.Indexable.Source.Content, index);
}
}
}
public void IndexBTreeTest()
{
var Persons = workunit.PersonRepository.GetAsList();
var indexService = new IndexService<Person>(workunit.PersonRepository.GetAsList());
//http://stackoverflow.com/questions/16676854/lambda-property-value-selector-as-parameter
Func<Person, IComparable> propertyFunc = x => x.Name;
Func<Person, string> propertyFunc1 = x => x.Name;
indexService.CreateIndex("Name", item => item.Name);
var result = indexService.RetrieveData("Name", "ben").ToList();
Assert.IsTrue(result.Count > 0);
//
result.Clear();
indexService.CreateIndex("PersonID", item => item.PersonID);
result = indexService.RetrieveData("PersonID", 6, 9).ToList();
Assert.IsTrue(result.Count > 0);
//
result.Clear();
indexService.DropIndex("PersonID");
result = indexService.RetrieveData("PersonID", 6, 9).ToList();
Assert.IsTrue(result.Count == 0);
//
//result.Clear();
//indexService.CreateIndex("PhoneNr", item => item.PhoneNr);
//var row = indexService.RetrieveData("PhoneNr", 123451, 123457);
//Assert.IsTrue(result.Count > 0);
}
public void Can_resolve_index_services_when_processing_index_queue()
{
var t1 = new EntityUpdateTask<Product>(new Product(), new ProductIndexDefinition(), new TestIndexLocation("products"));
var t2 = new EntityUpdateTask<Product>(new Product(), new ProductIndexDefinition(), new TestIndexLocation("products"));
var t3 = new EntityUpdateTask<Product>(new Product(), new ProductIndexDefinition(), new TestIndexLocation("products2"));
Action<IIndexTask> queue = t => IndexQueue.Instance.Queue(t);
queue(t1);
queue(t2);
queue(t3);
var services = new HashSet<IIndexService>();
IIndexTask task;
while (IndexQueue.Instance.TryDequeue(out task))
{
var service = services.FindWithOptions(task.IndexOptions);
if (service == null) {
service = new IndexService(new DirectoryIndexWriter(task.IndexOptions.IndexLocation.GetDirectory(), task.IndexOptions.RecreateIndex));
services.Add(service);
}
// process the task
}
Assert.IsTrue(services.Count == 2);
}
public IEnumerable <Models.Backoffice.Index> GetIndexes(string indexName = "")
{
var config = ConfigProvider.GetRootConfig();
var indexService = new IndexService(ConfigProvider);
var indexer = indexService.LoadIndexer(config);
var indexes = new List <Models.Backoffice.Index>();
foreach (var name in config.Indexes)
{
if (indexName != "" && name != indexName)
{
continue;
}
var indexConfig = ConfigProvider.GetIndexConfig(name);
var index = new Models.Backoffice.Index();
index.Name = name;
index.DocumentsIndexed = indexer.GetNumberOfDocumentsStored(indexConfig.Alias);
indexes.Add(index);
}
return(indexes);
}
internal override IEnumerable<IndexNode> ExecuteIndex(IndexService indexer, CollectionIndex index)
{
// find first indexNode
var value = _value.Normalize(index.Options);
var node = indexer.Find(index, value, true, Query.Ascending);
var str = value.AsString;
// navigate using next[0] do next node - if less or equals returns
while (node != null)
{
var valueString = node.Key.AsString;
// value will not be null because null occurs before string (bsontype sort order)
if (valueString.StartsWith(str))
{
if (!node.DataBlock.IsEmpty)
{
yield return node;
}
}
else
{
break; // if not more startswith, stop scanning
}
node = indexer.GetNode(node.Next[0]);
}
}
public void Can_use_the_same_index_writer_for_multiple_index_operations()
{
var repo = new Repository();
var writer = new MemoryIndexWriter(true);
var indexService = new IndexService(writer);
var p1p5 = repo.Products.Skip(0).Take(5);
var result = indexService.IndexEntities(p1p5, new ProductIndexDefinition());
Assert.AreEqual(5, result.Count);
var p6p10 = repo.Products.Skip(5).Take(5);
var result2 = indexService.IndexEntities(p6p10, new ProductIndexDefinition());
Assert.AreEqual(5,result2.Count);
var searcher = new MemoryIndexSearcher(writer.Directory, true);
var searchResult = new SearchService(searcher).SearchIndex(new TermQuery(new Term("type", "product")));
Assert.AreEqual(0, searchResult.Documents.Count(), "Index writer has not yet been committed so should return 0");
// commits writer
indexService.Dispose();
searchResult = new SearchService(searcher).SearchIndex(new TermQuery(new Term("type", "product")));
Assert.AreEqual(10, searchResult.Documents.Count());
}
public CollectionService(CacheService cache, PageService pager, IndexService indexer, DataService data)
{
_cache = cache;
_pager = pager;
_indexer = indexer;
_data = data;
}
public ActionResult Login(string returnUrl)
{
ViewBag.ReturnUrl = returnUrl;
var indexService = new IndexService();
indexService.CreateIndex();
return(View());
}
public int Execute(Options o)
{
var exists = IndexService.IndexExists(o);
var existsMessage = exists ? "exists" : "does not exist";
Logger.LogInformation($"{o.IndexName} {existsMessage}");
return(0);
}
public Startup(IConfiguration configuration)
{
Configuration = configuration;
var option = new DBOptions();
Configuration.GetSection("ConnectionOptions").Bind(option);
IndexService.InitDbUtils(option);
}
public override Folder Add(Folder folderToAdd)
{
folderToAdd.FolderId = folderIndex++;
using (var indexService = new IndexService(directoryIndexWriter)) {
IndexResult indexResult = indexService.IndexEntity(folderToAdd, new FolderIndexDefinition());
}
return folderToAdd;
}
public override File Add(File fileToAdd)
{
fileToAdd.FileId = fileIndex++;
using (var indexService = new IndexService(directoryIndexWriter)) {
IndexResult indexResult = indexService.IndexEntity(fileToAdd, new FileIndexDefinition());
}
return fileToAdd;
}
public IHttpActionResult Get(Query query)
{
query.Count = true;
var result = IndexService.Search(query);
var model = new ScrollableList <IndexDocument>(result, Request.RequestUri);
return(Ok(model));
}
public void InitIndicesServices()
{
try {
service = new IndexService();
} catch (Exception ex) {
caughtException = ex;
}
}
public int Execute(Options o)
{
var success = IndexService.DeleteIndex(o);
var successMessage = success ? "deleted" : "delete failed";
Logger.LogInformation($"{o.IndexName} {successMessage}");
return(success ? 0 : 1);
}
public async Task when_getting_and_waiting()
{
var repo = new Mock<IModifiedUrlRepository>();
repo.Setup(r => r.GetLastIndex(It.IsAny<CancellationToken>()))
.ReturnsAsync(7);
var service = new IndexService(new Mock<ILogger<IndexService>>().Object, repo.Object);
var index = await service.GetNextIndex(default).ConfigureAwait(false);
public void with_a_valid_repo_and_logger()
{
var repo = new Mock <IModifiedUrlRepository>().Object;
var logger = new Mock <ILogger <IndexService> >().Object;
var service = new IndexService(logger, repo);
Assert.NotNull(service);
}
public void Can_Restart()
{
var indexMock = new Mock <IInvertedIndex>();
var indexService = new IndexService(indexMock.Object, this.observerMock.Object);
indexService.StartBuildIndex();
indexService.StopBuildIndex();
indexService.StartBuildIndex();
}
public static void AddOrUpdate(Page page)
{
EntityUpdateTask<Page> entityUpdateTask = CreateEntityUpdateTask(page);
using (IndexService indexService = new IndexService(
new DirectoryIndexWriter(IndexDirectoryInfo)))
{
entityUpdateTask.Execute(indexService);
}
}
public static void Delete(int pageId)
{
EntityDeleteTask<Page> entityDeleteTask = CreateEntityDeleteTask(pageId);
using (IndexService indexService = new IndexService(
new DirectoryIndexWriter(IndexDirectoryInfo)))
{
entityDeleteTask.Execute(indexService);
}
}
public async Task Test_IndexServiceNeverDuplicatesPathMasterRecords()
{
var _connection = new SqliteConnection("DataSource=:memory:");
_connection.Open();
var options = new DbContextOptionsBuilder <DbCtxt>()
.UseSqlite(_connection)
.EnableSensitiveDataLogging(true)
.Options;
var dbc = new DbCtxt(options);
await dbc.Database.EnsureCreatedAsync();
var r = new IndexDbRepo(dbc, _logger);
var indexService = new IndexService(r);
var container = new ContainerDto
{
ContainerNumber = new ContainerNumberDto()
{
Number = "bcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxz :123456789012345678901234567890 12345678901234567890 12345678901234567890123456789012bcdefghijklmnopqrst uvwxyabcdefghijklmnopqrstuvwxz:12345678901234 567890123456789012345678 901234567890123456 78901234567890123456789012"
},
AssignedTo = new ContainerDto.CarrierDto {
Code = "aby", Name = "name", phones = new string[] { "bcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxz:1234567890123456789012345678901234567890123456789012345678901234567890123456789012bcdefghijklmnopqrstuvwxyabcdefghijklmnopqrstuvwxz:1234567890123456789012345678901234567890123456789012345678901234567890123456789012" }
}
};
var cmd = indexService.CreateUpdateCommand("0001", container);
await indexService.Handle(cmd);
var attchs = new List <AttachmentDto>();
attchs.Add(new AttachmentDto
{
Type = "invoice",
DownloadUrl = "hdhjdhjhsa"
});
container.Attachments = attchs.ToArray();
var cmd2 = indexService.CreateUpdateCommand("0001", container);
await indexService.Handle(cmd2);
attchs.Add(new AttachmentDto
{
Type = "invoice3",
DownloadUrl = "hdhjdhjhsa3"
});
container.Attachments = attchs.ToArray();
var cmd3 = indexService.CreateUpdateCommand("0001", container);
await indexService.Handle(cmd3);
var paths = dbc.Set <DbDocSourcePath>().Select(p => p).Where(p => p.PathString == "$.Attachments.[].DownloadUrl").ToArray();
var tokens = dbc.Set <DbDocToken>().Select(t => t).ToArray();
// load paths from database
//var paths = await dbc.Set<DbDocSourcePath>().Where(p=>p.PathString == "$.Attachments.[].DownloadUrl").ToArrayAsync();
Assert.AreEqual(1, paths.Length);
}
public void Process(Item item)
{
lock (this.lockingObject)
{
using (var indexService = new IndexService(this.indexWriter))
{
indexService.IndexEntity(item, new ItemIndexDefinition());
}
}
}
public void GivenValidData_AndAnUnavailableDatabase_WhenIUpdateAnIndex_ThenAnUnityExceptionIsThhrown()
{
_indexRepository.Setup(p => p.Update(It.IsAny <int>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>())).Throws
<Exception>();
var _indexService = new IndexService(_indexRepository.Object);
Action act = () => _indexService.Update(It.IsAny <int>(), It.IsAny <string>(), It.IsAny <string>(), It.IsAny <string>());
act.ShouldThrow <UnityException>();
}
public static void BuildIndex()
{
var indexPath = Path.Combine(AppDomain.CurrentDomain.BaseDirectory, "Index");
var indexWriter = new DirectoryIndexWriter(new DirectoryInfo(indexPath), true);
using (var indexService = new IndexService(indexWriter))
{
var result = indexService.IndexEntities(OnTimeItemRepository.GetItems(), new OnTimeItemIndexDefinition());
}
}
public int Execute(Options o)
{
var documents = DocumentProvider.GetDocuments(o);
var success = IndexService.AddOrUpdateDocuments(o, documents);
var successMessage = success ? "updated" : "failed";
Logger.LogInformation($"{documents.Count()} document(s) {successMessage} to {o.IndexName}");
return(success ? 0 : 1);
}
public void Could_Not_Start_Two_Times()
{
var indexMock = new Mock <IInvertedIndex>();
var indexService = new IndexService(indexMock.Object, this.observerMock.Object);
Action startAction = () => indexService.StartBuildIndex();
startAction.Should().NotThrow();
startAction.Should().Throw <ArgumentException>().And.Message.Should().Be("Already started");
}
public void Process(Item item)
{
lock (this.lockingObject)
{
using (var indexService = new IndexService(this.indexWriter))
{
indexService.IndexEntity(item, new ItemIndexDefinition());
}
}
}
internal override IEnumerable<IndexNode> ExecuteIndex(IndexService indexer, CollectionIndex index)
{
foreach (var value in _values.Distinct())
{
foreach (var node in Query.EQ(this.Field, value).ExecuteIndex(indexer, index))
{
yield return node;
}
}
}
public async Task <string> Execute()
{
try
{
QueryResults = null;
HitItems.Clear();
Fid = -1;
Path = " ";
NotifyOfChange("Path");
Contents.Clear();
var svc = new IndexService(cts.Token);
QueryResults = await svc.FindTextAsync(Group, QueryText);
ProcessQueryResults();
return(null);
}
catch (TaskCanceledException)
{
return(string.Empty);
}
catch (AggregateException e) when(e.InnerExceptions[0] is TaskCanceledException)
{
return(string.Empty);
}
catch (AggregateException e)
{
var sb = new StringBuilder();
foreach (var x in e.InnerExceptions)
{
if (sb.Length > 0)
{
sb.AppendLine();
}
sb.Append(x.Message);
Exception y = x;
while ((y = y.InnerException) != null)
{
sb.AppendLine();
sb.Append(y.Message);
#if DEBUG
sb.AppendFormat(" {0}", y.GetType().FullName);
if (y is System.Net.Sockets.SocketException s)
{
sb.AppendFormat(" SocketErrorCode={0}", s.SocketErrorCode.ToString());
}
#endif
}
}
return(sb.ToString());
}
catch (Exception e)
{
return(e.Message);
}
}
private void ContentService_UnPublished(Umbraco.Core.Publishing.IPublishingStrategy sender, Umbraco.Core.Events.PublishEventArgs <Umbraco.Core.Models.IContent> e)
{
var fileSystemService = new FileSystemService(new DirectoryInfo(HttpRuntime.AppDomainAppPath));
var configProvider = new DexterConfigProvider(fileSystemService);
var indexService = new IndexService(configProvider);
foreach (var entity in e.PublishedEntities)
{
indexService.Remove(entity);
}
}
private void MediaService_Deleted(Umbraco.Core.Services.IMediaService sender, Umbraco.Core.Events.DeleteEventArgs <Umbraco.Core.Models.IMedia> e)
{
var fileSystemService = new FileSystemService(new DirectoryInfo(HttpRuntime.AppDomainAppPath));
var configProvider = new DexterConfigProvider(fileSystemService);
var indexService = new IndexService(configProvider);
foreach (var entity in e.DeletedEntities)
{
indexService.Remove(entity);
}
}
public void CreatingIndexExample()
{
DeleteIndex();
Console.WriteLine(
IndexService.Create <Product>(IndexName)
.DebugInformation
);
DeleteIndex();
}
private void IndexService_UpdateStatusEvent(IndexService iService, EventStatusBool e)
{
if (e.eventStatusBool)
{
toolStripStatusLabelIndexStatusValue.Text = "Index ready";
}
else
{
toolStripStatusLabelIndexStatusValue.Text = "Indexing files";
}
}
public void SetUp()
{
var repo = new Repository();
var writer = new MemoryIndexWriter(true);
using (var indexService = new IndexService(writer))
{
indexService.IndexEntities(repo.Products, new ProductIndexDefinition());
}
directory = writer.Directory;
}
private void MediaService_Saved(IMediaService sender, SaveEventArgs <IMedia> e)
{
var fileSystemService = new FileSystemService(new DirectoryInfo(HttpRuntime.AppDomainAppPath));
var configProvider = new DexterConfigProvider(fileSystemService);
var indexService = new IndexService(configProvider);
foreach (var entity in e.SavedEntities)
{
indexService.Index(entity, Models.Indexable.Source.Media);
}
}
// REMOVE!
private void ContentService_Trashed(Umbraco.Core.Services.IContentService sender, Umbraco.Core.Events.MoveEventArgs <Umbraco.Core.Models.IContent> e)
{
var fileSystemService = new FileSystemService(new DirectoryInfo(HttpRuntime.AppDomainAppPath));
var configProvider = new DexterConfigProvider(fileSystemService);
var indexService = new IndexService(configProvider);
foreach (var moveInfo in e.MoveInfoCollection)
{
indexService.Remove(moveInfo.Entity);
}
}
public ArtistCommands(Logger.Logger logger, IndexService indexService, ILastfmApi lastfmApi, IPrefixService prefixService)
{
this._logger = logger;
this._indexService = indexService;
this._lastfmApi = lastfmApi;
this._prefixService = prefixService;
this._embed = new EmbedBuilder()
.WithColor(Constants.LastFMColorRed);
this._embedAuthor = new EmbedAuthorBuilder();
this._embedFooter = new EmbedFooterBuilder();
}
public ScrollableList <IndexDocument> Search(Query query)
{
if (query != null)
{
var result = IndexService.Search(query, true);
return(new ScrollableList <IndexDocument>(result, Request.RequestUri));
}
else
{
return(null);
}
}
public override IEnumerable<File> Add(IEnumerable<File> filesToAdd)
{
var filesToAddToLucene = new List<File>();
foreach (File file in filesToAdd) {
file.FileId = fileIndex++;
filesToAddToLucene.Add(file);
}
using (var indexService = new IndexService(directoryIndexWriter)) {
indexService.IndexEntities(filesToAddToLucene, new FileIndexDefinition());
}
return filesToAddToLucene;
}
public void SetUp()
{
var repo = new Repository();
var writer = new MemoryIndexWriter(true);
using (var indexService = new IndexService(writer))
{
indexService.IndexEntities(repo.Products, new ProductIndexDefinition());
}
directory = writer.Directory;
}
public void ProcessQueue()
{
IIndexTask task;
while (IndexQueue.Instance.TryDequeue(out task))
{
using (var service = new IndexService(new DirectoryIndexWriter(task.IndexOptions.IndexLocation.GetDirectory(), task.IndexOptions.RecreateIndex)))
{
task.Execute(service);
}
}
}
public void Can_index_a_collection_of_entities()
{
var repo = new Repository();
var writer = new MemoryIndexWriter(true);
using (var indexService = new IndexService(writer))
{
var result = indexService.IndexEntities(repo.Products, new ProductIndexDefinition());
Assert.AreEqual(10, result.Count);
Assert.AreEqual(0, result.Errors.Count);
}
}
public CalculateForm(string[] colNames, IndexSystem indexSystem, DataTable dataTable)
{
InitializeComponent();
this.indexService = new IndexServiceImpl();
this.colNames = colNames;
this.indexSystem = indexSystem;
this.stdTable = dataTable;
hashTable = FillHashTable();
FillIndexInstanceList();
CreateColumns(tlMatch);
}
public IndexServiceTests()
{
var indexStoreMock = new Mock <IIndexStore>();
_examplePatientJson = TextFileHelper.ReadTextFileFromDisk(
$".{Path.DirectorySeparatorChar}Examples{Path.DirectorySeparatorChar}patient-example.json");
_exampleAppointmentJson = TextFileHelper.ReadTextFileFromDisk(
$".{Path.DirectorySeparatorChar}Examples{Path.DirectorySeparatorChar}appointment-example2doctors.json");
_carePlanWithContainedGoal = TextFileHelper.ReadTextFileFromDisk(
$".{Path.DirectorySeparatorChar}Examples{Path.DirectorySeparatorChar}careplan-example-f201-renal.json");
_exampleObservationJson = TextFileHelper.ReadTextFileFromDisk(
$".{Path.DirectorySeparatorChar}Examples{Path.DirectorySeparatorChar}observation-example-bloodpressure.json");
var spPatientName = new SearchParamDefinition
{
Resource = "Patient",
Name = "name",
Description = new Markdown(@"A portion of either family or given name of the patient"),
Type = SearchParamType.String,
Path = new[] { "Patient.name" },
Expression = "Patient.name"
};
var spMiddleName = new SearchParamDefinition
{
Resource = "Patient",
Name = "middlename",
Type = SearchParamType.String,
Path = new[]
{
"Patient.name.extension.where(url='http://hl7.no/fhir/StructureDefinition/no-basis-middlename')"
},
Expression =
"Patient.name.extension.where(url='http://hl7.no/fhir/StructureDefinition/no-basis-middlename')"
};
var searchParameters = new List <SearchParamDefinition> {
spPatientName, spMiddleName
};
var resources =
new Dictionary <Type, string> {
{ typeof(Patient), "Patient" }, { typeof(HumanName), "HumanName" }
};
// For this test setup we want a limited available types and search parameters.
IFhirModel limitedFhirModel = new FhirModel(resources, searchParameters);
var limitedElementIndexer = new ElementIndexer(limitedFhirModel, new Mock <ILogger <ElementIndexer> >().Object);
_limitedIndexService = new IndexService(limitedFhirModel, indexStoreMock.Object, limitedElementIndexer);
// For this test setup we want all available types and search parameters.
IFhirModel fullFhirModel = new FhirModel();
var fullElementIndexer = new ElementIndexer(fullFhirModel, new Mock <ILogger <ElementIndexer> >().Object);
_fullIndexService = new IndexService(fullFhirModel, indexStoreMock.Object, fullElementIndexer);
}
/// <summary>
/// Initialize database reader with database stream file and password
/// </summary>
public bool Initialize(Stream stream, string password)
{
// test if current stream is V6
if (stream.ReadByte(25 + 27) != 6) return false;
_disk = new FileDiskService(stream, password);
_pager = new PageService(_disk);
_indexer = new IndexService(_pager);
_data = new DataService(_pager);
_collections = new CollectionService(_pager, _indexer, _data);
return true;
}
public void Can_index_a_collection_of_entities()
{
var repo = new Repository();
var writer = new MemoryIndexWriter(true);
using (var indexService = new IndexService(writer))
{
var result = indexService.IndexEntities(repo.Products, new ProductIndexDefinition());
Assert.AreEqual(10, result.Count);
Assert.AreEqual(0, result.Errors.Count);
}
}
public void Can_index_a_single_entity()
{
var repo = new Repository();
var product = repo.Products.First();
var writer = new MemoryIndexWriter(true);
using (var indexService = new IndexService(writer))
{
var result = indexService.IndexEntity(product, new ProductIndexDefinition());
Assert.AreEqual(1, result.Count);
Assert.AreEqual(0, result.Errors.Count);
}
}
public void Can_index_a_collection_of_entities()
{
var repo = new Repository();
var writer = new MemoryIndexWriter(true);
using (var indexService = new IndexService(writer))
{
var result = indexService.IndexEntities(repo.Products, new ProductIndexDefinition());
Assert.AreEqual(10, result.Count);
Assert.AreEqual(0, result.Errors.Count);
Console.WriteLine("Indexed {0} records in {1} milliseconds",
result.Count, result.ExecutionTime);
}
}
internal override IEnumerable<IndexNode> ExecuteIndex(IndexService indexer, CollectionIndex index)
{
var value = _value.Normalize(index.Options);
foreach (var node in indexer.FindAll(index, Query.Ascending))
{
var diff = node.Key.CompareTo(value);
if (diff == 1 || (!_equals && diff == 0)) break;
if (node.IsHeadTail(index)) yield break;
yield return node;
}
}
internal override IEnumerable<IndexNode> ExecuteIndex(IndexService indexer, CollectionIndex index)
{
var value = _value.Normalize(index.Options);
var node = indexer.Find(index, value, false, Query.Ascending);
if (node == null) yield break;
yield return node;
if (index.Options.Unique == false)
{
// navigate using next[0] do next node - if equals, returns
while (!node.Next[0].IsEmpty && ((node = indexer.GetNode(node.Next[0])).Key.CompareTo(value) == 0))
{
if (node.IsHeadTail(index)) yield break;
yield return node;
}
}
}
public static void BuildIndex(HttpContext ctx) {
var indexPath = ctx.Server.MapPath("~/App_Data/Index");
var indexWriter = new DirectoryIndexWriter(new DirectoryInfo(indexPath), true);
var documentPath = ctx.Server.MapPath("~/Documentation");
using (var indexService = new IndexService(indexWriter)) {
indexService.IndexEntities(
Directory.EnumerateFiles(documentPath, "*.markdown", SearchOption.AllDirectories),
f => {
var doc = new Document();
var name = Path.GetFileNameWithoutExtension(f);
var text = File.ReadAllText(f);
doc.Add(new Field("Id", name, Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.Add(new Field("Url", "~/Documentation/" + name, Field.Store.YES, Field.Index.NOT_ANALYZED));
doc.Add(new Field("Title", name.Replace('-', ' '), Field.Store.YES, Field.Index.ANALYZED));
doc.Add(new Field("Text", text, Field.Store.YES, Field.Index.ANALYZED));
doc.Add(new Field("Summary", MarkdownExtensions.ExtractSummary(text), Field.Store.YES, Field.Index.NOT_ANALYZED));
return doc;
});
}
}
internal override IEnumerable<IndexNode> ExecuteIndex(IndexService indexer, CollectionIndex index)
{
// find first indexNode
var value = _value.Normalize(index.Options);
var node = indexer.Find(index, value, true, Query.Ascending);
if (node == null) yield break;
// move until next is last
while (node != null)
{
var diff = node.Key.CompareTo(value);
if (diff == 1 || (_equals && diff == 0))
{
if (node.IsHeadTail(index)) yield break;
yield return node;
}
node = indexer.GetNode(node.Next[0]);
}
}
internal override IEnumerable<IndexNode> ExecuteIndex(IndexService indexer, CollectionIndex index)
{
this.ExecuteMode = QueryExecuteMode.FullScan;
return indexer.FindAll(index, Query.Ascending);
}
public void CreateIndex(Offers newOffer)
{
// index location
var indexLocation = new FileSystemIndexLocation(new DirectoryInfo(Server.MapPath("~/Index")));
var definition = new OfferIndexDefinition();
var task = new EntityUpdateTask<Offers>(newOffer, definition, indexLocation);
task.IndexOptions.RecreateIndex = false;
task.IndexOptions.OptimizeIndex = true;
//IndexQueue.Instance.Queue(task);
var indexWriter = new DirectoryIndexWriter(new DirectoryInfo(Server.MapPath("~/Index")), false);
using (var indexService = new IndexService(indexWriter))
{
task.Execute(indexService);
}
}
internal override IEnumerable<IndexNode> ExecuteIndex(IndexService indexer, CollectionIndex index)
{
var value = _value.Normalize(index.Options);
return indexer.FindAll(index, Query.Ascending).Where(x => x.Key.CompareTo(value) != 0);
}
