private static LuceneParams GetLuceneSearchParams(SearchArguments arguments)
{
var result = new LuceneParams();
//Set Defaults
if (arguments.Query == null)
{
arguments.Query = new MatchAllDocsQuery();
}
//Special Behavior for OData Queries since OData queries potentially specify the query/filter/skip/take all in one.
var query = arguments.Query as ODataQuery;
if (query != null)
{
var oDataQuery = query;
var parser = new ODataQueryParser();
var modelFilter = parser.ParseQuery(oDataQuery.DefaultField, oDataQuery.Query);
result.Query = modelFilter.Query.IsNullOrWhiteSpace()
? new Lucene.Net.Search.MatchAllDocsQuery()
: LuceneModelFilter.ParseQuery(oDataQuery.DefaultField, modelFilter.Query);
result.Filter = modelFilter.Filter.IsNullOrWhiteSpace()
? null
: LuceneModelFilter.ParseFilter(oDataQuery.DefaultField, modelFilter.Filter);
result.Sort = modelFilter.Sort ?? new Lucene.Net.Search.Sort();
if (modelFilter.Take > 0)
{
result.MaxResults = modelFilter.Take;
}
if (modelFilter.Skip > 0)
{
result.Skip = modelFilter.Skip;
}
}
else
{
result.Query = Barista.Search.Query.ConvertQueryToLuceneQuery(arguments.Query);
result.Filter = null;
result.Sort = Barista.Search.Sort.ConvertSortToLuceneSort(arguments.Sort);
if (arguments.Filter != null)
{
result.Filter = Barista.Search.Filter.ConvertFilterToLuceneFilter(arguments.Filter);
}
if (arguments.Skip.HasValue)
{
result.Skip = arguments.Skip.Value;
}
result.MaxResults = arguments.Take ?? 1000;
}
return(result);
}
private void VerifyQuery <TClient, TClientResult, TResult>(Func <IQueryable <TClient>, IQueryable <TClientResult> > clientQueryTransform, Func <IQueryable <A>, IQueryable <TResult> > expectedTransform, bool requireNonEmpty = true)
{
var comparer = GetComparer <TResult>();
var translated = new LinqToODataTranslator().Translate(clientQueryTransform(Empty <TClient> .Array.AsQueryable()).Expression, out var rootQuery, out var resultTranslator);
Assert.That(translated, Is.InstanceOf <ODataQueryExpression>());
Assert.That(rootQuery, Is.InstanceOf <IQueryable <TClient> >());
var random = new Random(123456);
var wasNonEmpty = false;
for (var i = 0; i < 10; ++i)
{
var randomQuery = this.RandomQueryable(random);
var transformed = expectedTransform(randomQuery);
var expected = transformed.ToArray();
wasNonEmpty |= expected.Any();
Console.WriteLine("original = " + transformed);
Console.WriteLine("odata = " + HttpUtility.UrlDecode(translated.ToString()));
var rawApplied = ODataQueryFilter.Apply(randomQuery, ODataQueryParser.Parse(randomQuery.ElementType, translated.ToString()), out var inlineCountQuery);
var applied = (IEnumerable <TResult>)resultTranslator(rawApplied, null);
Console.WriteLine("applied = " + rawApplied);
applied.ToArray().CollectionShouldEqual(expected, comparer: comparer, orderMatters: true);
Console.WriteLine(new string('-', 80));
}
if (requireNonEmpty)
{
wasNonEmpty.ShouldEqual(true, "At least 1 run should produce non-empty results!");
}
}
IODataParseResult IODataServiceQueryPipeline.Parse <TElement>(NameValueCollection urlQuery)
{
Throw.IfNull(urlQuery, "urlQuery");
var oDataQuery = ODataQueryParser.Parse(typeof(TElement), urlQuery);
return(new Result <TElement>(oDataQuery));
}
public void FilterTest()
{
var expression = "$filter=Age eq 10";
var docQuery = new ODataQueryParser <Employee>();
var query = docQuery.TryParse(expression);
Assert.NotNull(query.Filter.FilterExpression);
}
private void TestParseQuery(string query)
{
var parsed = ODataQueryParser.Parse(typeof(A), query);
parsed.ToString().ShouldEqual(query);
var dynamicParsed = ODataQueryParser.Parse(typeof(ODataEntity), query);
dynamicParsed.ToString().ShouldEqual(query);
}
private void TestFilterQuery(string filter, string orderBy, string skip, string top, int[] expectedIds)
{
var query = ODataQueryParser.Parse(typeof(A), new NameValueCollection {
{ "$filter", filter }, { "$orderby", orderBy }, { "$skip", skip }, { "$top", top }
});
var results = ODataQueryFilter.Apply(this._records, query, out var inlineCountQuery);
results.Select(a => a.Id).CollectionShouldEqual(expectedIds, orderMatters: true);
var equivalentToInlineCountResults = ODataQueryFilter.Apply(this._records, query.Update(top: null, skip: 0), out _);
inlineCountQuery.Select(a => a.Id).CollectionShouldEqual(equivalentToInlineCountResults.Select(a => a.Id));
}
public async Task EnumConditionTest()
{
var expression = "$filter=MessagingAccountType ne 1";
var runner = new MongoDBQueryRunner <MessagingAccount>();
var docQuery = new ODataQueryParser <MessagingAccount>();
var query = docQuery.TryParse(expression);
runner.Create(query);
var collection = GetCollection <MessagingAccount>("messagingaccount");
var list = await runner.QueryAsync(collection);
Assert.True(list.Count > 0);
}
public async Task ComplexFilterTest()
{
var expression = "$filter=(CompanyGroup eq 'Synechron' and IsDeleted eq false) or NumberOfEmployees ge 1";
//var expression = "startswith(Name,'Syne') eq true";
var runner = new MongoDBQueryRunner <Company>();
var docQuery = new ODataQueryParser <Company>();
var query = docQuery.TryParse(expression);
runner.Create(query);
var collection = GetCollection <Company>("company");
var list = await runner.QueryAsync(collection);
Assert.True(list.Count > 0);
}
public async Task ContainsFilterTest()
{
var expression = "$filter=contains(Name,'Test')&$orderby=name desc";
//var expression = "$filter=substringof('Test', Name)";
//var expression = "startswith(Name,'Syne') eq true";
var runner = new MongoDBQueryRunner <MessagingAccount>();
var docQuery = new ODataQueryParser <MessagingAccount>();
var query = docQuery.TryParse(expression);
runner.Create(query);
var collection = GetCollection <MessagingAccount>("messagingaccount");
var list = await runner.QueryAsync(collection);
Assert.True(list.Count > 0);
}
public void TestParseQueryWithEmpty()
{
var parameters = new[] { "top", "skip", "filter", "select", "orderby", "format", "inlinecount" };
// empty is allowed (see http://services.odata.org/v3/odata/odata.svc/Categories?$filter=&$format=json)
foreach (var parameter in parameters)
{
UnitTestHelpers.AssertDoesNotThrow(() => ODataQueryParser.Parse(typeof(A), string.Format("?${0}=", parameter)));
}
// whitespace is not allowed (see http://services.odata.org/v3/odata/odata.svc/Categories?$orderby=%20&$format=json)
foreach (var parameter in parameters)
{
UnitTestHelpers.AssertThrows <ODataParseException>(() => ODataQueryParser.Parse(typeof(A), string.Format("?${0}= ", parameter)));
}
}
/// <summary>
/// Get list of entity of type TEntity.
/// </summary>
/// <param name="oDataFilterQuery">Filter query in odata format</param>
/// <returns>The task object representing the asynchronous operation.
/// It returns the list of Entity of type TEntity.</returns>
public async Task <IList <TEntity> > FindAsync(string oDataFilterQuery = null)
{
if (string.IsNullOrEmpty(oDataFilterQuery) || queryRunner == default(IMongoDBQueryRunner <TEntity>))
{
return((await documentStorageContext.GetCollection(Collection).FindAsync(Builders <TEntity> .Filter.Empty))
.ToList());
}
else
{
try
{
var queryParser = new ODataQueryParser <TEntity>();
var query = queryParser.TryParse(oDataFilterQuery);
queryRunner.Create(query);
return(await queryRunner.QueryAsync(documentStorageContext.GetCollection(Collection)));
}
catch (Exception ex)
{
throw new DocumentQueryException(ex.Message, ex);
}
}
}
public async Task <long> GetCountAsync(string oDataFilterQuery = null)
{
if (string.IsNullOrEmpty(oDataFilterQuery) || queryRunner == default(IMongoDBQueryRunner <TEntity>))
{
return(await documentStorageContext.GetCollection(Collection).CountAsync(Builders <TEntity> .Filter.Empty));
}
else
{
try
{
var queryRunner = new MongoDBQueryRunner <TEntity>();
var docQuery = new ODataQueryParser <TEntity>();
var query = docQuery.TryParse(oDataFilterQuery);
queryRunner.Create(query);
return(await documentStorageContext.GetCollection(Collection).CountAsync(queryRunner.FilterDefinition));
}
catch (Exception ex)
{
throw new DocumentQueryException(ex.Message, ex);
}
}
}
public void TestSetUp()
{
_parser = new ODataQueryParser(new ODataQueryPartParserStrategy());
}
public ODataUriParser(ODataQueryParser parser, IODataQueryTranslator translator)
{
_parser = parser;
_translator = translator;
}
