public void ToKey_NullSafe()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>();
var key = mapper.ToKey(new ReflectedDocument());
Assert.NotNull(key);
}
public void ToKey_DifferentInstance()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>(LuceneVersion.LUCENE_30);
var key1 = mapper.ToKey(new ReflectedDocument { Id = "x", Version = new Version("1.0") });
var key2 = mapper.ToKey(new ReflectedDocument { Id = "x", Version = new Version("1.0") });
Assert.That(key1, Is.Not.SameAs(key2));
}
public void ToKey_NotEqual()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>();
var key1 = mapper.ToKey(new ReflectedDocument { Version = new Version("1.0") });
var key2 = mapper.ToKey(new ReflectedDocument { Version = new Version("2.0") });
Assert.That(key1, Is.Not.EqualTo(key2));
}
public void ToKey_Equal()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>();
var key1 = mapper.ToKey(new ReflectedDocument());
var key2 = mapper.ToKey(new ReflectedDocument());
Assert.That(key1, Is.EqualTo(key2));
}
public void ToKey_DifferentInstance()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>();
var key1 = mapper.ToKey(new ReflectedDocument());
var key2 = mapper.ToKey(new ReflectedDocument());
Assert.That(key1, Is.Not.SameAs(key2));
}
public void ToKey_NotEqual()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>(LuceneVersion.LUCENE_30);
var key1 = mapper.ToKey(new ReflectedDocument { Id = "x", Version = new Version("1.0") });
var key2 = mapper.ToKey(new ReflectedDocument { Id = "y", Version = new Version("2.0") });
Assert.That(key1, Is.Not.EqualTo(key2));
}
public void Documents_Equal_IgnoredField()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>(LuceneVersion.LUCENE_30);
item1.IgnoreMe = "different";
Assert.That(mapper.Equals(item1, item2), Is.True);
}
public void Documents_Equal_Not()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>(LuceneVersion.LUCENE_30);
item1.Version = new Version("5.6.7.8");
Assert.That(mapper.Equals(item1, item2), Is.False);
}
public void ToKey_Equal()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>();
var key1 = mapper.ToKey(new ReflectedDocument());
var key2 = mapper.ToKey(new ReflectedDocument());
Assert.That(key1, Is.EqualTo(key2));
}
public void ToKey_DifferentInstance()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>();
var key1 = mapper.ToKey(new ReflectedDocument());
var key2 = mapper.ToKey(new ReflectedDocument());
Assert.That(key1, Is.Not.SameAs(key2));
}
public void ToKey_ThrowsOnNullValues()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>(LuceneVersion.LUCENE_30);
TestDelegate call = () => mapper.ToKey(new ReflectedDocument());
Assert.That(call, Throws.InvalidOperationException);
}
public void Documents_Equal_Not()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>();
item1.Version = new Version("5.6.7.8");
Assert.That(mapper.Equals(item1, item2), Is.False);
}
public void Documents_Equal_IgnoredField()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>();
item1.IgnoreMe = "different";
Assert.That(mapper.Equals(item1, item2), Is.True);
}
public void ToKey_DocumentKeys()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocumentWithKey>(LuceneVersion.LUCENE_30);
mapper.ToKey(new ReflectedDocumentWithKey {
Id = "x", Version = new Version("1.0")
});
}
public void ToKey_ThrowsOnNullValues()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>(LuceneVersion.LUCENE_30);
TestDelegate call = () => mapper.ToKey(new ReflectedDocument());
Assert.That(call, Throws.InvalidOperationException);
}
public List <PraticienToIndexModel> Search(string q)
{
q = Uri.UnescapeDataString(q);
var path = ConfigurationManager.AppSettings["LuceneDirectory"];
//get path
var chemin = HttpContext.Current.Server.MapPath("~");
path = Path.Combine(chemin, path);
var result = new List <PraticienToIndexModel>();
var analyzer = new KeywordAnalyzer();
var indexDirInfo = new DirectoryInfo(path);
if (!System.IO.Directory.Exists(path))
{
System.IO.Directory.CreateDirectory(path);
}
Directory directory = FSDirectory.Open(indexDirInfo,
new SimpleFSLockFactory(indexDirInfo));
Index(directory);
var searcher = new IndexSearcher(directory);
var parser = new QueryParser(Lucene.Net.Util.Version.LUCENE_30, "All", analyzer)
{
AllowLeadingWildcard = true,
LowercaseExpandedTerms = false
};
var queryString = string.Format("{0} OR *{0}* OR *{0} OR {0}*", q);
var query = parser.Parse(queryString);
var maxResult = 100;
var hits = searcher.Search(query, maxResult);
var mapper = new ReflectionDocumentMapper <PraticienToIndexModel>(Lucene.Net.Util.Version.LUCENE_30);
maxResult = (hits.TotalHits < maxResult) ? hits.TotalHits : maxResult;
for (var i = 0; i < maxResult; i++)
{
var praticien = new PraticienToIndexModel();
var doc = searcher.Doc(hits.ScoreDocs[i].Doc);
mapper.ToObject(doc, null, praticien);
if (!result.Any(r => r.Cin.Equals(praticien.Cin)))
{
result.Add(praticien);
}
}
searcher.Dispose();
return(result);
}
public void IsModified_Equal()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>(LuceneVersion.LUCENE_30);
var doc = new Document();
mapper.ToDocument(item1, doc);
Assert.That(mapper.IsModified(item1, doc), Is.False);
}
/// <summary>
/// Create a <see cref="QueryParsers.QueryParser"/> suitable for parsing advanced queries
/// that cannot not expressed as LINQ (e.g. queries submitted by a user).
///
/// After the instance is returned, options such as <see cref="QueryParsers.QueryParser.AllowLeadingWildcard"/>
/// and <see cref="QueryParsers.QueryParser.Field"/> can be customized to the clients needs.
/// </summary>
/// <typeparam name="T">The type of document that queries will be built against.</typeparam>
public FieldMappingQueryParser <T> CreateQueryParser <T>()
{
var mapper = new ReflectionDocumentMapper <T>(version, externalAnalyzer);
return(new FieldMappingQueryParser <T>(version, mapper)
{
DefaultSearchProperty = mapper.KeyProperties.FirstOrDefault() ?? mapper.IndexedProperties.FirstOrDefault()
});
}
public void ValuesEqual_Enumerable()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>(LuceneVersion.LUCENE_30);
var result = mapper.ValuesEqual(new[] { "a", "b" }, new List <string> {
"a", "b"
});
Assert.That(result, Is.True, "Should be equal when sequences are equal");
}
public void IsModified_IgnoredField()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>(LuceneVersion.LUCENE_30);
var doc = new Document();
mapper.ToDocument(item1, doc);
item1.IgnoreMe = "different";
Assert.That(mapper.IsModified(item1, doc), Is.False);
}
public void IsModified_Equal_Not()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>(LuceneVersion.LUCENE_30);
var doc = new Document();
mapper.ToDocument(item1, doc);
item1.Version = new Version("5.6.7.8");
Assert.That(mapper.IsModified(item1, doc), Is.True);
}
/// <summary>
/// Opens a session for staging changes and then committing them atomically.
/// </summary>
/// <param name="factory">Factory delegate that creates new instances of <typeparamref name="T"/></param>
/// <typeparam name="T">The type of object that will be mapped to <c cref="Document"/>.</typeparam>
public ISession <T> OpenSession <T>(Func <T> factory)
{
if (context.IsReadOnly)
{
throw new InvalidOperationException("This data provider is read-only. To enable writes, construct " + typeof(LuceneDataProvider) + " with an IndexWriter.");
}
var mapper = new ReflectionDocumentMapper <T>();
return(new LuceneSession <T>(mapper, context, CreateQueryable(factory, context, mapper)));
}
public void ToKey_NotEqual()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>(LuceneVersion.LUCENE_30);
var key1 = mapper.ToKey(new ReflectedDocument {
Id = "x", Version = new Version("1.0")
});
var key2 = mapper.ToKey(new ReflectedDocument {
Id = "y", Version = new Version("2.0")
});
Assert.That(key1, Is.Not.EqualTo(key2));
}
public void ToKey_DifferentInstance()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>(LuceneVersion.LUCENE_30);
var key1 = mapper.ToKey(new ReflectedDocument {
Id = "x", Version = new Version("1.0")
});
var key2 = mapper.ToKey(new ReflectedDocument {
Id = "x", Version = new Version("1.0")
});
Assert.That(key1, Is.Not.SameAs(key2));
}
public void ToKey_NotEqual()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>();
var key1 = mapper.ToKey(new ReflectedDocument {
Version = new Version("1.0")
});
var key2 = mapper.ToKey(new ReflectedDocument {
Version = new Version("2.0")
});
Assert.That(key1, Is.Not.EqualTo(key2));
}
public void ReadOnlyKey()
{
var document = new Document();
var mapper = new ReflectionDocumentMapper <ReflectedDocumentWithReadOnlyKey>(LuceneVersion.LUCENE_30);
mapper.ToDocument(new ReflectedDocumentWithReadOnlyKey {
Id = "a"
}, document);
Assert.That(document.GetField("Type").StringValue, Is.EqualTo("ReflectedDocumentWithReadOnlyKey"));
}
public void Documents_Equal()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>();
Assert.That(mapper.Equals(item1, item2), Is.True);
}
public void Documents_Equal()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>(LuceneVersion.LUCENE_30);
Assert.That(mapper.Equals(item1, item2), Is.True);
}
public void IsModified_Equal()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>(LuceneVersion.LUCENE_30);
var doc = new Document();
mapper.ToDocument(item1, doc);
Assert.That(mapper.IsModified(item1, doc), Is.False);
}
public void ContainsMetaPropertyForDocumentKey()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocumentWithKey>(LuceneVersion.LUCENE_30);
Assert.That(mapper.KeyProperties.Select(mapper.GetMappingInfo).Count(), Is.EqualTo(5));
}
public void CtrFindsKeyFields()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>(LuceneVersion.LUCENE_30);
Assert.That(mapper.KeyProperties, Is.EquivalentTo(new[] { "Id", "Version", "Number" }));
}
public void CtrFindsDocumentKeys()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocumentWithKey>(LuceneVersion.LUCENE_30);
Assert.That(mapper.KeyProperties, Is.EquivalentTo(new[] { "Id", "Version", "Number", "**DocumentKey**Type", "**DocumentKey**Revision" }));
}
public void ContainsMetaPropertyForDocumentKey()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocumentWithKey>(LuceneVersion.LUCENE_30);
Assert.That(mapper.KeyProperties.Select(mapper.GetMappingInfo).Count(), Is.EqualTo(5));
}
public IDocumentMapper <TModel> ToDocumentMapper(Version version)
{
ReflectionDocumentMapper <TModel> reflectionDocumentMapper = new ReflectionDocumentMapper <TModel>(version);
return(reflectionDocumentMapper);
}
public void Documents_Equal()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>(LuceneVersion.LUCENE_30);
Assert.That(mapper.Equals(item1, item2), Is.True);
}
public void ToKey_DocumentKeys()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocumentWithKey>(LuceneVersion.LUCENE_30);
mapper.ToKey(new ReflectedDocumentWithKey { Id = "x", Version = new Version("1.0") });
}
public void ToKey_NullSafe()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>();
var key = mapper.ToKey(new ReflectedDocument());
Assert.NotNull(key);
}
public void CtrFindsKeyFields()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>(LuceneVersion.LUCENE_30);
Assert.That(mapper.KeyProperties, Is.EquivalentTo(new[] {"Id", "Version", "Number"}));
}
public void ReadOnlyKey()
{
var document = new Document();
var mapper = new ReflectionDocumentMapper<ReflectedDocumentWithReadOnlyKey>(LuceneVersion.LUCENE_30);
mapper.ToDocument(new ReflectedDocumentWithReadOnlyKey { Id = "a" }, document);
Assert.That(document.GetField("Type").StringValue, Is.EqualTo("ReflectedDocumentWithReadOnlyKey"));
}
public void Documents_Equal()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>();
Assert.That(mapper.Equals(item1, item2), Is.True);
}
public void ScoreProperty()
{
var mapper = new ReflectionDocumentMapper <ScoreDoc>(LuceneVersion.LUCENE_30);
Assert.That(mapper.AllProperties.ToArray(), Is.EqualTo(new [] { "Score" }));
}
public void ValuesEqual_Enumerable()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>(LuceneVersion.LUCENE_30);
var result = mapper.ValuesEqual(new[] {"a", "b"}, new List<string> {"a", "b"});
Assert.That(result, Is.True, "Should be equal when sequences are equal");
}
public void CtrFindsDocumentKeys()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocumentWithKey>(LuceneVersion.LUCENE_30);
Assert.That(mapper.KeyProperties, Is.EquivalentTo(new[] { "Id", "Version", "Number", "**DocumentKey**Type", "**DocumentKey**Revision" }));
}
/// <summary>
/// <see cref="OpenSession{T}(ObjectLookup{T}, IDocumentMapper{T}, IDocumentModificationDetector{T})"/>
/// </summary>
public ISession <T> OpenSession <T>(ObjectLookup <T> lookup)
{
var reflectionDocumentMapper = new ReflectionDocumentMapper <T>(version, externalAnalyzer);
return(OpenSession(lookup, reflectionDocumentMapper, reflectionDocumentMapper));
}
public void CtrFindsKeyFields()
{
var mapper = new ReflectionDocumentMapper <ReflectedDocument>();
Assert.That(mapper.KeyFields.Select(k => k.FieldName), Is.EquivalentTo(new[] { "Id", "Version", "Number" }));
}
public void ScoreProperty()
{
var mapper = new ReflectionDocumentMapper<ScoreDoc>(LuceneVersion.LUCENE_30);
Assert.That(mapper.AllProperties.ToArray(), Is.EqualTo(new [] {"Score"}));
}
/// <summary>
/// Create a <see cref="QueryParsers.QueryParser"/> suitable for parsing advanced queries
/// that cannot not expressed as LINQ (e.g. queries submitted by a user).
///
/// After the instance is returned, options such as <see cref="QueryParsers.QueryParser.AllowLeadingWildcard"/>
/// and <see cref="QueryParsers.QueryParser.Field"/> can be customized to the clients needs.
/// </summary>
/// <typeparam name="T">The type of document that queries will be built against.</typeparam>
/// <param name="defaultSearchField">The default field for queries that don't specify which field to search.
/// For an example query like <c>Lucene OR NuGet</c>, if this argument is set to <c>SearchText</c>,
/// it will produce a query like <c>SearchText:Lucene OR SearchText:NuGet</c>.</param>
/// <returns></returns>
public FieldMappingQueryParser <T> CreateQueryParser <T>(string defaultSearchField)
{
var mapper = new ReflectionDocumentMapper <T>(version, externalAnalyzer);
return(new FieldMappingQueryParser <T>(version, defaultSearchField, mapper));
}
public void IsModified_IgnoredField()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>(LuceneVersion.LUCENE_30);
var doc = new Document();
mapper.ToDocument(item1, doc);
item1.IgnoreMe = "different";
Assert.That(mapper.IsModified(item1, doc), Is.False);
}
public void CtrFindsKeyFields()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>();
Assert.That(mapper.KeyFields.Select(k => k.FieldName), Is.EquivalentTo(new[] {"Id", "Version", "Number"}));
}
public void IsModified_Equal_Not()
{
var mapper = new ReflectionDocumentMapper<ReflectedDocument>(LuceneVersion.LUCENE_30);
var doc = new Document();
mapper.ToDocument(item1, doc);
item1.Version = new Version("5.6.7.8");
Assert.That(mapper.IsModified(item1, doc), Is.True);
}
