public void Init(ParsingContext context, ParseTreeNode parseNode)
{
if (HasChildNodes(parseNode))
{
if (parseNode.ChildNodes[3] != null && HasChildNodes(parseNode.ChildNodes[3]) && parseNode.ChildNodes[3].ChildNodes[0].Term.Name.ToUpper() == "DESC")
{
_OrderDirection = SortDirection.Desc;
}
else
{
_OrderDirection = SortDirection.Asc;
}
_OrderByAttributeList = new List <OrderByAttributeDefinition>();
foreach (ParseTreeNode treeNode in parseNode.ChildNodes[2].ChildNodes)
{
if (treeNode.AstNode != null && treeNode.AstNode is IDNode)
{
_OrderByAttributeList.Add(new OrderByAttributeDefinition(((IDNode)treeNode.AstNode).IDChainDefinition, null));
}
else
{
_OrderByAttributeList.Add(new OrderByAttributeDefinition(null, treeNode.Token.ValueString));
}
}
OrderByDefinition = new OrderByDefinition(_OrderDirection, _OrderByAttributeList);
}
}
/// <summary>
/// Creates all readouts of all types in the <paramref name="myTypeList"/>
/// </summary>
private List <IEnumerable <IVertexView> > CreateVertices(SecurityToken mySecurityToken,
Int64 myTransactionToken,
Dictionary <String, IVertexType> myTypeList,
SelectResultManager mySelectResultManager,
BinaryExpressionDefinition myWhereExpressionDefinition,
Int64 myResolutionDepth,
OrderByDefinition myOrderByDefinition,
UInt64?myLimit,
UInt64?myOffset)
{
var _ListOfListOfVertices = new List <IEnumerable <IVertexView> >();
// Create vertices for type
foreach (var typeRef in myTypeList)
{
var _Vertices = CreateVerticesForType(mySecurityToken,
myTransactionToken,
typeRef,
mySelectResultManager,
myWhereExpressionDefinition,
myResolutionDepth,
myOrderByDefinition,
myLimit,
myOffset);
// If this type did not returned any result, we wont add it to the result
if (_Vertices != null)
{
_ListOfListOfVertices.Add(_Vertices);
}
}
return(_ListOfListOfVertices);
}
public void Init(ParsingContext context, ParseTreeNode parseNode)
{
if (HasChildNodes(parseNode))
{
if (parseNode.ChildNodes[3] != null && HasChildNodes(parseNode.ChildNodes[3]) && parseNode.ChildNodes[3].ChildNodes[0].Term.Name.ToUpper() == "DESC")
_OrderDirection = SortDirection.Desc;
else
_OrderDirection = SortDirection.Asc;
_OrderByAttributeList = new List<OrderByAttributeDefinition>();
foreach (ParseTreeNode treeNode in parseNode.ChildNodes[2].ChildNodes)
{
if (treeNode.AstNode != null && treeNode.AstNode is IDNode)
{
_OrderByAttributeList.Add(new OrderByAttributeDefinition(((IDNode)treeNode.AstNode).IDChainDefinition, null));
}
else
{
_OrderByAttributeList.Add(new OrderByAttributeDefinition(null, treeNode.Token.ValueString));
}
}
OrderByDefinition = new OrderByDefinition(_OrderDirection, _OrderByAttributeList);
}
}
public SelectDefinition(List<TypeReferenceDefinition> myTypeList, List<Tuple<AExpressionDefinition, string, SelectValueAssignment>> mySelectedElements, BinaryExpressionDefinition myWhereExpressionDefinition,
List<IDChainDefinition> myGroupByIDs, BinaryExpressionDefinition myHaving, ulong? myLimit, ulong? myOffset, OrderByDefinition myOrderByDefinition, long myResolutionDepth)
{
TypeList = myTypeList;
SelectedElements = mySelectedElements;
WhereExpressionDefinition = myWhereExpressionDefinition;
GroupByIDs = myGroupByIDs;
Having = myHaving;
Limit = myLimit;
Offset = myOffset;
OrderByDefinition = myOrderByDefinition;
ResolutionDepth = myResolutionDepth;
}
async Task ExecuteLoadItemsCommand(bool more = false)
{
if (IsBusy)
{
return;
}
IsBusy = true;
try
{
Expression <Func <Item, bool> > filter = (Item x) => true;
if (more)
{
var lastItem = Items[Items.Count - 1];
filter = (Item x) => x.DateCreated < lastItem.DateCreated;
}
else
{
Items.Clear();
}
var sort = OrderByDefinition <Item> .OrderByDescending(x => x.DateCreated);
var items = await App.Connection.Meshes.SearchAsync(filter, sort, 1, 10);
if (items.TotalRecords > 0)
{
foreach (var item in items.Results)
{
Items.Add(item);
}
}
}
catch (Exception ex)
{
Debug.WriteLine(ex);
}
finally
{
IsBusy = false;
}
}
/// <summary>
/// Creates the lazy readouts for the given <paramref name="myTypeReference"/>
/// </summary>
private IEnumerable <IVertexView> CreateVerticesForType(SecurityToken mySecurityToken,
Int64 myTransactionToken,
KeyValuePair <String, IVertexType> myTypeReference,
SelectResultManager mySelectResultManager,
BinaryExpressionDefinition myWhereExpressionDefinition,
Int64 myResolutionDepth,
OrderByDefinition myOrderByDefinition,
UInt64?myLimit,
UInt64?myOffset)
{
IEnumerable <IVertexView> _Vertices = new List <IVertexView>();
#region Check groupings & aggregates
mySelectResultManager.ValidateGroupingAndAggregate(myTypeReference.Key, myTypeReference.Value);
#endregion
#region Check, whether the type was affected by the where expressions. This will use either the Graph or the GUID index of the type
Boolean isInterestingWhere = (myWhereExpressionDefinition != null && IsInterestingWhereForReference(myTypeReference.Key, myWhereExpressionDefinition));
#endregion
#region Create an IEnumerable of Readouts for this typeNode
var result = mySelectResultManager.Examine(myResolutionDepth, myTypeReference.Key, myTypeReference.Value, isInterestingWhere, ref _Vertices, mySecurityToken, myTransactionToken);
#endregion
#region If this type did not returned any result, we wont add it to the result
if (!result)
{
return(new List <IVertexView>());
}
#endregion
#region If there was a result for this typeNode we will add a new SelectionListElementResult
// _Vertices = mySelectResultManager.GetResult(_Vertices);
#region OrderBy
if (myOrderByDefinition != null)
{
OrderVertices(mySecurityToken, myTransactionToken, myOrderByDefinition, ref _Vertices);
}
#endregion
#region Limit
if (myLimit != null || myOffset != null)
{
ApplyLimitAndOffset(myLimit, myOffset, ref _Vertices);
}
#endregion
#endregion
return(_Vertices);
}
/// <inheritdoc/>
public Task <PageResult <TModel> > SearchAsync <TModel>(IEnumerable <Expression <Func <TModel, bool> > > filters, OrderByDefinition <TModel> orderBy = null, int page = 1, int pageSize = 25)
where TModel : MeshData
{
var filter = PredicateBuilder.CombineExpressions(filters);
return(this.SearchAsync(filter, orderBy, page, pageSize));
}
/// <inheritdoc/>
public Task <PageResult <TModel> > SearchAsync <TModel>(Expression <Func <TModel, bool> > filter, OrderByDefinition <TModel> orderBy = null, int page = 1, int pageSize = 25)
where TModel : MeshData
{
var mongoFilter = Builders <TModel> .Filter.Where(filter).Render(BsonSerializer.SerializerRegistry.GetSerializer <TModel>(), BsonSerializer.SerializerRegistry);
var encodedUrl = WebUtility.UrlEncode(mongoFilter.ToString());
var encodedOrderBy = string.Empty;
if (orderBy != null)
{
encodedOrderBy = WebUtility.UrlEncode(orderBy.GenerateBsonDocument());
}
return(this.requestService.GetRequest <PageResult <TModel> >($"meshes/{this.GetMeshName<TModel>()}?filter={encodedUrl}&orderby={encodedOrderBy}&page={page}&pageSize={pageSize}"));
}
/// <inheritdoc/>
public PageResult <TModel> Search <TModel>(Expression <Func <TModel, bool> > filters, OrderByDefinition <TModel> orderBy = null, int page = 1, int pageSize = 25)
where TModel : MeshData
{
var t = this.SearchAsync <TModel>(filters, orderBy, page, pageSize);
return(t.ConfigureAwait(false).GetAwaiter().GetResult());
}
/// <inheritdoc/>
public PageResult <User> Search(string name = null, string roleId = null, OrderByDefinition <User> orderBy = null, bool activeOnly = true, int page = 1, int pageSize = 25)
{
var t = this.SearchAsync(name, roleId, orderBy, activeOnly, page, pageSize).ConfigureAwait(false).GetAwaiter();
return(t.GetResult());
}
/// <inheritdoc/>
public Task <PageResult <User> > SearchAsync(string name = null, string roleId = null, OrderByDefinition <User> orderBy = null, bool activeOnly = true, int page = 1, int pageSize = 25)
{
var parsedOrderBy = string.Empty;
if (orderBy != null)
{
parsedOrderBy = orderBy.GenerateBsonDocument();
}
return(this.SearchAsync(name, roleId, parsedOrderBy, activeOnly, page, pageSize));
}
/// <inheritdoc/>
public Task <PageResult <TData> > GetAsync <TData>(string projectionName, Expression <Func <TData, bool> > filter, OrderByDefinition <TData> orderBy, int page = 1, int pageSize = 25)
where TData : class
{
var mongoFilter = Builders <TData> .Filter.Where(filter).Render(BsonSerializer.SerializerRegistry.GetSerializer <TData>(), BsonSerializer.SerializerRegistry);
var parsedFilter = mongoFilter.ToString();
return(this.GetAsync <TData>(projectionName, parsedFilter, orderBy.GenerateBsonDocument(), page, pageSize));
}
/// <inheritdoc/>
public PageResult <TData> Get <TData>(string projectionName, OrderByDefinition <TData> orderBy = null, int page = 1, int pageSize = 25)
where TData : class
{
return(this.Get <TData>(projectionName, (TData _) => true, orderBy, page, pageSize));
}
/// <inheritdoc/>
public PageResult <TData> Get <TData>(string projectionName, IEnumerable <Expression <Func <TData, bool> > > filters, OrderByDefinition <TData> orderBy = null, int page = 1, int pageSize = 25)
where TData : class
{
var filter = PredicateBuilder.CombineExpressions(filters);
return(this.Get <TData>(projectionName, filter, orderBy, page, pageSize));
}
/// <summary>
/// Orders the readouts
/// </summary>
private void OrderVertices(SecurityToken mySecurityToken, Int64 myTransactionToken, OrderByDefinition myOrderByDefinition, ref IEnumerable <IVertexView> myVertices)
{
#region Set the as alias for all not set ones to the attribute name
foreach (var attrDef in myOrderByDefinition.OrderByAttributeList)
{
if (attrDef.IDChainDefinition != null)
{
attrDef.IDChainDefinition.Validate(_pluginManager, _graphdb, mySecurityToken, myTransactionToken, true);
if (String.IsNullOrEmpty(attrDef.AsOrderByString))
{
if (attrDef.IDChainDefinition.IsUndefinedAttribute)
{
attrDef.AsOrderByString = attrDef.IDChainDefinition.UndefinedAttribute;
}
else
{
attrDef.AsOrderByString = attrDef.IDChainDefinition.LastAttribute.Name;
}
}
}
}
#endregion
#region ORDER BY
var comparer = new Vertices_OrderByComparer(myOrderByDefinition);
if (myOrderByDefinition.OrderDirection == SortDirection.Asc)
{
myVertices = myVertices.OrderBy(dbo => dbo, comparer);
}
else
{
myVertices = myVertices.OrderByDescending(dbo => dbo, comparer);
}
#endregion
}
/// <inheritdoc/>
public PageResult <TModel> Search <TModel>(IEnumerable <Expression <Func <TModel, bool> > > filters, OrderByDefinition <TModel> orderBy = null, int page = 1, int pageSize = 25)
where TModel : MeshData
{
var filter = PredicateBuilder.CombineExpressions(filters);
var t = this.SearchAsync <TModel>(filter, orderBy, page, pageSize);
return(t.ConfigureAwait(false).GetAwaiter().GetResult());
}
public Vertices_OrderByComparer(OrderByDefinition myOrderByDefinition)
{
_OrderByDefinition = myOrderByDefinition;
}
public async Task ShouldSearchCompiledRequestHasCorrectQueryString()
{
var requestService = new Mock <IRequestService>();
var passedUrl = string.Empty;
requestService.Setup(x => x.GetRequest <PageResult <MeshNameAttributeClassTest> >(It.IsAny <string>())).Callback((string url) =>
{
passedUrl = url;
}).Returns(() =>
{
return(Task.FromResult(It.IsAny <PageResult <MeshNameAttributeClassTest> >()));
}).Verifiable();
var service = new MeshesService(requestService.Object);
var pageNumber = new Random().Next();
var pageSize = new Random().Next();
await service.SearchAsync <MeshNameAttributeClassTest>(x => x.FavoriteNumber > 5000, OrderByDefinition <MeshNameAttributeClassTest> .OrderByDescending("FavoriteNumber"), pageNumber, pageSize).ConfigureAwait(false);
var encodedFilter = WebUtility.UrlEncode("{ \"FavoriteNumber\" : { \"$gt\" : 5000 } }");
var encodedOrderBy = WebUtility.UrlEncode("{ FavoriteNumber:-1 }");
Assert.Equal($"meshes/{MeshName.ToLowerInvariant()}?filter={encodedFilter}&orderby={encodedOrderBy}&page={pageNumber}&pageSize={pageSize}", passedUrl);
requestService.VerifyAll();
}
