public string GetPageLink(IJsonApiContext context, int pageOffset, int pageSize)
{
var filterQueryComposer = new QueryComposer();
var filters = filterQueryComposer.Compose(context);
return($"{context.BasePath}/{context.RequestEntity.EntityName}?page[size]={pageSize}&page[number]={pageOffset}{filters}");
}
public SimpleDeleter(ObjectInfo info, QueryComposer composer, DataProvider provider, IDbObjectHandler handler)
{
this.Info = info;
this.Composer = composer;
this.Provider = provider;
this.Handler = handler;
}
public Query ComposeQuery(string keywords, string[] fields)
{
var queryString = QueryComposer.Provide(keywords);
var parser = new MultiFieldQueryParser(fields, Factory.GetAnalyser());
return(parser.Parse(queryString));
}
internal ModelOperator(ObjectInfo info, QueryComposer composer, DataProvider provider, IDbObjectHandler handler)
{
this.Info = info;
this.Composer = composer;
this.Provider = provider;
this._saver = SaverFactory.CreateSaver(info, composer, provider, handler);
this._deleter = DeleterFactory.CreateDeleter(info, composer, provider, handler);
this.Fixer = AutoSchemeFixer.CreateInstance(this.Provider, this.Info);
}
public override void OnActionExecuted(HttpActionExecutedContext actionExecutedContext)
{
if (actionExecutedContext == null)
{
throw Error.ArgumentNull("actionExecutedContext");
}
Contract.Assert(actionExecutedContext.Request != null);
HttpRequestMessage request = actionExecutedContext.Request;
HttpResponseMessage response = actionExecutedContext.Response;
IQueryable query;
if (response != null && response.TryGetContentValue(out query))
{
IQueryable deserializedQuery = null;
if (request != null && request.RequestUri != null && !String.IsNullOrWhiteSpace(request.RequestUri.Query))
{
Uri requestUri = request.RequestUri;
try
{
ServiceQuery serviceQuery = ODataQueryDeserializer.GetServiceQuery(requestUri);
if (serviceQuery.QueryParts.Count > 0)
{
IQueryable baseQuery = Array.CreateInstance(query.ElementType, 0).AsQueryable(); // T[]
deserializedQuery = ODataQueryDeserializer.Deserialize(baseQuery, serviceQuery.QueryParts);
if (_queryValidator != null)
{
_queryValidator.Validate(deserializedQuery);
}
}
}
catch (ParseException e)
{
actionExecutedContext.Response = request.CreateResponse(
HttpStatusCode.BadRequest,
Error.Format(SRResources.UriQueryStringInvalid, e.Message));
return;
}
}
if (deserializedQuery != null)
{
query = QueryComposer.Compose(query, deserializedQuery);
}
query = ApplyResultLimit(actionExecutedContext, query);
((ObjectContent)response.Content).Value = query;
}
}
public void SplitPartiallySupportedQuery()
{
IQueryable <string> queryRoot = new[] { "query", "root" }.AsQueryable();
IQueryable <string> query = queryRoot.Where(s => true).Take(5).OrderBy(s => s).ThenBy(s => s);
IQueryable supportedQuery;
IQueryable unsupportedQuery;
supportedQuery = QueryComposer.Split(query, out unsupportedQuery);
MethodCallExpression mce = supportedQuery.Expression as MethodCallExpression;
Assert.IsNotNull(mce,
"The first supported expression should be a method call.");
Assert.AreEqual("Take", mce.Method.Name,
"The first supported expression should be a Take call.");
Assert.AreEqual(2, mce.Arguments.Count,
"The first supported expression should have 2 arguments.");
MethodCallExpression mce2 = mce.Arguments[0] as MethodCallExpression;
Assert.IsNotNull(mce2,
"The second supported expression should be a method call.");
Assert.AreEqual("Where", mce2.Method.Name,
"The second supported expression should be a Where call.");
Assert.AreEqual(2, mce2.Arguments.Count,
"The second supported expression should have 2 arguments.");
ConstantExpression ce = mce2.Arguments[0] as ConstantExpression;
Assert.IsNotNull(ce,
"The first argument in the second supported expression should be constant.");
mce = unsupportedQuery.Expression as MethodCallExpression;
Assert.IsNotNull(mce,
"The first unsupported expression should be a method call.");
Assert.AreEqual("ThenBy", mce.Method.Name,
"The first unsupported expression should be a ThenBy call.");
Assert.AreEqual(2, mce.Arguments.Count,
"The first unsupported expression should have 2 arguments.");
mce2 = mce.Arguments[0] as MethodCallExpression;
Assert.IsNotNull(mce2,
"The second unsupported expression should be a method call.");
Assert.AreEqual("OrderBy", mce2.Method.Name,
"The second unsupported expression should be an OrderBy call.");
Assert.AreEqual(2, mce2.Arguments.Count,
"The second unsupported expression should have 2 arguments.");
ce = mce2.Arguments[0] as ConstantExpression;
Assert.IsNotNull(ce,
"The first argument in the second unsupported expression should be constant.");
}
public void TestQueryBuilder()
{
ISelectQuery selectQuery = new SelectQuery
{
SelectFrom = new TableDefinition("dbo.TableA", "tA", new[] { new ColumnDefinition("*") })
};
List <IWhereQuery> whereQueries = new List <IWhereQuery>
{
new WhereQuery()
{
ColumnsDefinition = new[]
{
new ColumnDefinition(0, "tA.ColumnA", "Sahil", CompareOperatorEnum.Equals)
}
},
new WhereQuery()
{
ColumnsDefinition = new[]
{
new ColumnDefinition(0, "ColumnA", "Sahil", CompareOperatorEnum.Equals),
new ColumnDefinition(1, "ColumnB", "9901", CompareOperatorEnum.NotEquals)
},
ConditionOperator = ConditionOperatorEnum.And
}
};
List <IJoinQuery> joinQueries = new List <IJoinQuery>()
{
new JoinQuery()
{
JoinOperator = JoinOperatorEnum.InnerJoin,
TableFrom = new TableDefinition("dbo.TableB", "tB", new[] { new ColumnDefinition("ColumnB") }),
TableTo = new TableDefinition("dbo.TableA", "tA", new[] { new ColumnDefinition("ColumnA") })
},
new JoinQuery()
{
JoinOperator = JoinOperatorEnum.InnerJoin,
TableFrom = new TableDefinition("dbo.TableB", "tB", new[] { new ColumnDefinition(0, "ColumnB2"), new ColumnDefinition(1, "ColumnB3") }),
TableTo = new TableDefinition("dbo.TableA", "tA", new[] { new ColumnDefinition(0, "ColumnA2"), new ColumnDefinition(1, "ColumnA3") })
},
//TODO: Test Case is Failing - columns already added in join condition, shouldn't get added again
new JoinQuery()
{
JoinOperator = JoinOperatorEnum.InnerJoin,
TableFrom = new TableDefinition("dbo.TableB", "tB", new[] { new ColumnDefinition(0, "ColumnB") }),
TableTo = new TableDefinition("dbo.TableA", "tA", new[] { new ColumnDefinition(0, "ColumnA") })
}
};
ISqlQuery sqlQuery = new SqlQuery(selectQuery, joinQueries.ToArray(), whereQueries.ToArray());
var queryString = QueryComposer.GenerateQuerySql(sqlQuery);
}
public static SimpleDeleter CreateDeleter(ObjectInfo info, QueryComposer composer, DataProvider provider, IDbObjectHandler handler)
{
if (info.HasRelation)
{
return(new RelationModelDeleter(info, composer, provider, handler));
}
if (info.HasOnePrimaryKey && info.KeyMembers[0].UnsavedValue != null)
{
return(new KeyModelDeleter(info, composer, provider, handler));
}
return(new SimpleDeleter(info, composer, provider, handler));
}
public void NoFilter_Compose_EmptyStringReturned()
{
// arrange
var querySet = new QuerySet();
_jsonApiContext
.Setup(m => m.QuerySet)
.Returns(querySet);
var queryComposer = new QueryComposer();
// act
var filterString = queryComposer.Compose(_jsonApiContext.Object);
// assert
Assert.Equal("", filterString);
}
public List <object> SearchTwitter(QueryInfo queryInfo, bool filterAll)
{
string searchText = QueryComposer.ComposeQuery(queryInfo);
Dictionary <string, string> parameters = new Dictionary <string, string>()
{
{ "q", searchText },
{ "result_type", queryInfo.ResultType },
{ "lang", queryInfo.LanguageCode },
{ "count", queryInfo.SearchCount.ToString() }
};
string jsonResult = SearchTweet(parameters);
List <Status> lstSearches = Deserializer.DeserializeJSON <List <Status> >("statuses", jsonResult);
if (filterAll)
{
if (lstSearches != null && lstSearches.Count > 0)
{
int takeCount = 0;
int totalFound = lstSearches.Count;
int half = queryInfo.SearchCount / 2;
if (totalFound > half)
{
takeCount = half + 1; // TAKE 1 MORE THAN HALF
}
else if (totalFound <= half)
{
takeCount = half; // TAKE ALL
}
else
{
takeCount = 0; // TAKE NONE
}
lstSearches = lstSearches.OrderBy(x => x.retweet_count)
.Take(takeCount).ToList();
}
}
return(new List <object>(lstSearches.Cast <object>()));
}
private ModelContext(Type t)
{
Info = ObjectInfoFactory.Instance.GetInstance(t);
Provider = DataProviderFactory.Instance.GetInstance(Info.ContextName);
Composer = GetQueryComposer();
if (LoadHandler)
{
Handler = CreateDbObjectHandler();
}
if (ConfigReader.Config.Database.Cache.Enabled && Info.HasOnePrimaryKey && Info.Cacheable)
{
Operator = new CachedModelOperator(Info, Composer, Provider, Handler);
}
else
{
Operator = new ModelOperator(Info, Composer, Provider, Handler);
}
}
public void Can_ComposeEqual_FilterStringForUrl()
{
// arrange
var filter = new FilterQuery("attribute", "value", "eq");
var querySet = new QuerySet();
List <FilterQuery> filters = new List <FilterQuery>();
filters.Add(filter);
querySet.Filters = filters;
_jsonApiContext
.Setup(m => m.QuerySet)
.Returns(querySet);
var queryComposer = new QueryComposer();
// act
var filterString = queryComposer.Compose(_jsonApiContext.Object);
// assert
Assert.Equal("&filter[attribute]=eq:value", filterString);
}
public static SimpleObjectSaver CreateSaver(ObjectInfo info, QueryComposer composer, DataProvider provider, IDbObjectHandler handler)
{
if (info.HasSystemKey && info.KeyMembers[0].UnsavedValue == null)
{
throw new DataException("System key must have UnsavedValue.");
}
if (info.HandleType.IsSubclassOf(typeof(DbObjectSmartUpdate)))
{
if (info.HasRelation)
{
return(new RelationModelSaver(info, composer, provider, handler));
}
return(new DbModelSaver(info, composer, provider, handler));
}
if (info.HasSystemKey)
{
return(new DbObjectSaver(info, composer, provider, handler));
}
return(new SimpleObjectSaver(info, composer, provider, handler));
}
public void Rebase()
{
IQueryable <string> queryRoot = new[] { "query", "root" }.AsQueryable();
IQueryable <string> query = queryRoot.Where(s => true);
MethodCallExpression mce = query.Expression as MethodCallExpression;
Assert.IsNotNull(mce,
"Expression should be a method call.");
Assert.AreEqual("Where", mce.Method.Name,
"Expression should be a Where call.");
Assert.AreEqual(2, mce.Arguments.Count,
"Expression should have 2 arguments.");
ConstantExpression ce = mce.Arguments[0] as ConstantExpression;
Assert.IsNotNull(ce,
"The first expression argument should be constant.");
Assert.AreEqual(queryRoot, ce.Value,
"The first expression argument should be the query root.");
IQueryable <string> newQueryRoot = new[] { "new", "query", "root" }.AsQueryable();
IQueryable rebasedQuery = QueryComposer.Compose(newQueryRoot, query);
mce = rebasedQuery.Expression as MethodCallExpression;
Assert.IsNotNull(mce,
"Rebased expression should be a method call.");
Assert.AreEqual("Where", mce.Method.Name,
"Rebased expression should be a Where call.");
Assert.AreEqual(2, mce.Arguments.Count,
"Rebased expression should have 2 arguments.");
ce = mce.Arguments[0] as ConstantExpression;
Assert.IsNotNull(ce,
"The first rebased expression argument should be constant.");
Assert.AreEqual(newQueryRoot, ce.Value,
"The first rebased expression argument should be the new query root.");
}
internal Reclaimer(QueryComposer composer)
{
this.composer = composer;
this.passer = new Passer(this);
}
public DbModelSaver(ObjectInfo info, QueryComposer composer, DataProvider provider, IDbObjectHandler handler)
: base(info, composer, provider, handler)
{
}
public RelationModelDeleter(ObjectInfo info, QueryComposer composer, DataProvider provider, IDbObjectHandler handler)
: base(info, composer, provider, handler)
{
}
internal Reclaimer( QueryComposer composer ) {
this.composer = composer;
this.passer = new Passer(this);
}
internal CachedModelOperator(ObjectInfo info, QueryComposer composer, DataProvider provider, IDbObjectHandler handler)
: base(info, composer, provider, handler)
{
}
