public static async Task <List <TResult> > ToListAsync <TResult>(this ICypherFluentQuery query, Expression <Func <ICypherResultItem, TResult> > expression, string orderBy = null, int?skip = null, int?limit = null) { if (orderBy.HasValue()) { var returnExp = query.Return(expression).OrderBy(orderBy); if (skip.HasValue && limit.HasValue) { var test = returnExp.Skip(skip.Value).Limit(limit.Value); return((await test.ResultsAsync).ToList()); } return((await returnExp.ResultsAsync).ToList()); } return((await query.Return(expression).ResultsAsync).ToList()); }
private RelationshipCheckResponse Check(ICypherFluentQuery q, IRelationshipCheckRequest request) { q = q.With("ID(e) as nodeId, count(rel) as relationshipCount"); switch (request.ThresholdType) { case RelationshipThresholdType.ReturnIfGreaterThan: q = q.Where($"relationshipCount > {request.Threshold}"); break; case RelationshipThresholdType.ReturnIfNotExact: q = q.Where($"relationshipCount <> {request.Threshold}"); break; case RelationshipThresholdType.ReturnIfEqual: q = q.Where($"relationshipCount = {request.Threshold}"); break; default: throw new Exception("<INSERT PR HERE>"); } var responses = q.Return((nodeId, relationshipCount) => new Violation { NodeId = nodeId.As<long>() }); var response = new RelationshipCheckResponse(); response.Request = request; response.Violations.AddRange(responses.Results.ToList()); return response; }
/// <summary> /// Erstellt einen neuen Logeintrag einer Variation /// </summary> public LogEntry Create(Variation variation, LogEntry logEntry) { ICypherFluentQuery query = GraphClient.Cypher .Match("".Variation("v")) .Where((Variation v) => v.Id == variation.Id) .Create("".Node("v").Has().LogEntryWithParam()) .WithParam("logEntry", logEntry); return(query.Return(le => le.As <LogEntry>()).Results.First()); }
/// <summary> /// Erstellt einen neuen Schwierigkeitsgrad in einer Skala /// </summary> public DifficultyLevel Create(DifficultyLevelScale difficultyLevelScale, DifficultyLevel difficultyLevel) { ICypherFluentQuery query = GraphClient.Cypher .Match("".DifficultyLevelScale("dls")) .Where((DifficultyLevelScale dls) => dls.Id == difficultyLevelScale.Id) .Create("dls".Has().DifficultyLevelWithParam()) .WithParam("difficultyLevel", difficultyLevel); return(query.Return(dl => dl.As <DifficultyLevel>()).Results.First()); }
/// <summary> /// Erstellt eine neue Gipfelgruppe in einer Gegend /// </summary> /// <param name="area"></param> /// <param name="summitGroup"></param> public SummitGroup Create(Area area, SummitGroup summitGroup) { ICypherFluentQuery query = GraphClient.Cypher .Match("".Area("a")) .Where((Area a) => a.Id == area.Id) .Create("a".Has().SummitGroupWithParam()) .WithParam("summitGroup", summitGroup); return(query.Return(sg => sg.As <SummitGroup>()).Results.First()); }
private ICypherFluentQuery <RouteResponse> ReturnRouteResponse(ICypherFluentQuery query) { return(query.Return(() => new RouteResponse { Origin = Return.As <Warehouse>("from"), Destiny = Return.As <Warehouse>("to"), RoutePoints = Return.As <IEnumerable <Warehouse> >("[x IN nodes(path) WHERE (x:Warehouse) | x]"), ShipDetails = Return.As <IEnumerable <SHIPS_TO> >("[y IN relationships(path) | y]"), Hops = Return.As <int>("length(path)"), TotalCost = Return.As <int>("reduce(accumCost = 0, r IN relationships(path)| accumCost + r.cost)"), TotalTime = Return.As <int>("reduce(accumTime = 0, r IN relationships(path)| accumTime + r.time)") })); }
public ICollection <T> Find <T>(Expression <Func <T, bool> > filter) where T : IEntity { ICypherFluentQuery queryWithoutReturn = _graphClient.Cypher .Match(String.Format("(n:{0})", typeof(T).Name)); if (filter != null) { queryWithoutReturn = queryWithoutReturn.Where(filter); } var query = queryWithoutReturn.Return(n => n.As <T>()); QueryDebugText(MethodBase.GetCurrentMethod().Name, query); return(query.ResultsAsync.Result.ToList()); }
public static TResult FirstOrDefault <TResult>(this ICypherFluentQuery query, Expression <Func <TResult> > expression) { return(query.Return(expression).FirstOrDefault()); }
public static async Task <TResult> FirstOrDefaultAsync <TResult>(this ICypherFluentQuery query, Expression <Func <TResult> > expression) { return(await query.Return(expression).FirstOrDefaultAsync()); }
public static async Task <TResult> FirstOrDefaultAsync <TResult>(this ICypherFluentQuery query, Expression <Func <ICypherResultItem, TResult> > expression) { var returnExp = query.Return(expression); return(await returnExp.FirstOrDefaultAsync()); }