protected ICypherFluentQuery AddRoles(ICypherFluentQuery query, IList <IdentityRole> roles, string userId) { if (roles == null || roles.Count == 0) { return(query); } for (var i = 0; i < roles.Count; i++) { var roleVar = $"r{i}"; var userRoleVar = $"ur{i}"; query = query .With("u") .Match(p => p.Pattern <IdentityRole>(roleVar) .Constrain(r => r.NormalizedName == roles[i].NormalizedName)) .Merge(p => p.Pattern <TUser, IdentityUser_Role, IdentityRole>("u", userRoleVar, roleVar) .Constrain(null, ur => ur.RoleId == CypherVariables.Get <IdentityRole>(roleVar).Id&& ur.UserId == userId, null)) .OnCreate() .Set <IdentityUser_Role>(ur => ur.CreatedOn == new Occurrence(), userRoleVar); } return(query); }
public void Constraints_FinalProperties(string testContextName, TestContext testContext) { var client = testContext.AnnotationsContext.GraphClient; var query = testContext.Query; var builder = new PathBuilder(query); var pattern = builder .Pattern <ActorNode>("Ambode") .Constrain(actor => actor.Name == "Ellen Pompeo" && actor.Born == CypherVariables.Get <ActorNode>("shondaRhimes").Born && actor.Roles == new[] { "Meredith Grey" }) .Pattern as Pattern; var aConstraints = pattern.AConstraints; Assert.NotNull(aConstraints); var aFinalProperties = pattern.AFinalProperties; Assert.NotNull(aFinalProperties); var expected = new Dictionary <string, dynamic> { { "Name", "\"Ellen Pompeo\"" }, { "Born", "shondaRhimes.Born" }, { "Roles", $"[{Environment.NewLine} \"Meredith Grey\"{Environment.NewLine}]" } }; TestUtilities.TestFinalPropertiesForEquality(instance => client.Serializer.Serialize(instance), expected, aFinalProperties); var str = pattern.Build(ref query); }
public static IPath BuildTestPath(IPathBuilder P) { return(P .Pattern <MovieNode, MovieActorRelationship, ActorNode>("greysAnatomy", "ellenPompeo") .Label(new[] { "Series" }, new[] { "STARRED_IN" }, new[] { "Female" }, true, false, false) .Constrain(movie => movie.Title == "Grey's Anatomy" && movie.Year == 2017, null, actor => actor.Name == "Ellen Pompeo" && actor.Born == CypherVariables.Get <ActorNode>("shondaRhimes").Born && actor.Roles == new[] { "Meredith Grey" }) .Hop(1) //not necessary, but for tests ); }
public void PredicateComplexTypeSet(string testContextName, TestContext testContext) { Expression <Func <ActorNode, bool> > expression = a => a.Address == new AddressWithComplexType { //Use this style only if you're sure all the properties here are assigned, //because this address object would replace the instance address property entirely. //Also note that there's a good chance the parameters set inline here wouldn't make it to the generated pattern. //This was done mainly for testing. //Use a => a.Address.Location.Longitude == (double)CypherVariables.Get("ellenPompeo")["NewAddressName_Location_Longitude"] instead. AddressLine = CypherVariables.Get <ActorNode>("shondaRhimes").Address.AddressLine, Location = new Location { Latitude = 4.0, Longitude = (double)CypherVariables.Get("ellenPompeo")["NewAddressName_Location_Longitude"] } } && a.Name == "Shonda Rhimes"; var entityVisitor = new EntityExpressionVisitor(testContext.QueryContext, expression.Parameters.FirstOrDefault()); var newExpression = entityVisitor.Visit(expression.Body); Assert.NotNull(newExpression); Assert.NotEqual(newExpression, expression.Body); Assert.Equal(2, entityVisitor.PredicateAssignments.Count); Assert.Equal(6, entityVisitor.PendingAssignments.Count); dynamic result = newExpression.ExecuteExpression <Dictionary <string, object> >(); Assert.NotNull(result); var tokensExpected = new Dictionary <string, object> { { "Name", "Shonda Rhimes" }, { "NewAddressName_AddressLine", null }, { "NewAddressName_City", null }, { "NewAddressName_State", null }, { "NewAddressName_Country", null }, { "NewAddressName_Location_Latitude", 0.0 }, { "NewAddressName_Location_Longitude", 0.0 } }; Assert.Equal(tokensExpected.Count, result.Count); foreach (var pair in result) { Assert.Equal(tokensExpected[pair.Key], pair.Value); } }
public void SetPredicate(string testContextName, TestContext testContext) { var query = testContext.Query; var actual = query.Set((ActorNode actor) => actor.Name == "Ellen Pompeo" && actor.Born == CypherVariables.Get <ActorNode>("shondaRhimes").Born && actor.Roles == new[] { "Meredith Grey" }, out var setParam).Query.QueryText; var expected = $"SET actor.Name = ${setParam}.Name, actor.Born = shondaRhimes.Born, actor.Roles = ${setParam}.Roles"; Assert.Equal(expected, actual); }
public void ComplexAnonymousType(string testContextName, TestContext testContext) { //the following is purely a test, and not necessarily a good example for neo4j cypher. Expression <Func <object> > expression = () => new { new AddressWithComplexType { AddressLine = CypherVariables.Get("A")["AddressLine"] as string, Location = new Location { Latitude = (double)CypherVariables.Get("A")["Location_Latitude"], Longitude = 56.90 } }.Location }; var entityVisitor = new EntityExpressionVisitor(testContext.QueryContext); var newExpression = entityVisitor.Visit(expression.Body); Assert.NotNull(newExpression); Assert.NotEqual(newExpression, expression.Body); Assert.Equal(2, entityVisitor.PendingAssignments.Count); Assert.Equal("Location_Latitude", entityVisitor.PendingAssignments.First().Key.ComplexJsonName); Assert.Contains("Get(\"A\").get_Item(\"Location_Latitude\")", entityVisitor.PendingAssignments.First().Value.ToString()); Assert.Equal("Location_Longitude", entityVisitor.PendingAssignments.Last().Key.ComplexJsonName); Assert.Contains("Get(\"A\").get_Item(\"AddressLine\")", entityVisitor.PendingAssignments.Last().Value.ToString()); var result = newExpression.ExecuteExpression <Dictionary <string, object> >(); Assert.NotNull(result); var tokensExpected = new Dictionary <string, object> { { "Location_Latitude", 0.0 }, //because the assignment is pending due to the CypherVariables Get method. { "Location_Longitude", 0.0 } //because the assignment is pending due to the CypherVariables Get method. }; Assert.Equal(tokensExpected.Count, result.Count); foreach (var pair in result) { Assert.Equal(tokensExpected[pair.Key], pair.Value); } }
public void PredicateComplexTypeMemberAccessSet(string testContextName, TestContext testContext) { Expression <Func <ActorNode, bool> > expression = a => (a.Address as AddressWithComplexType).Location.Longitude == new AddressWithComplexType { //Using this style, parameters set inline of a member access may or may not make it to the generated pattern, or even throw an exception. //This is because this MemberInit may be taken as an object value, since it was accessed, and then used directly. //This was done mainly for testing. //Use a => a.Address.Location.Longitude == (double)CypherVariables.Get("ellenPompeo")["NewAddressName_Location_Longitude"] instead. AddressLine = CypherVariables.Get <ActorNode>("shondaRhimes").Address.AddressLine, Location = new Location { Latitude = 4.0, Longitude = (double)CypherVariables.Get("ellenPompeo")["NewAddressName_Location_Longitude"] } }.Location.Longitude&& a.Name == "Shonda Rhimes"; var entityVisitor = new EntityExpressionVisitor(testContext.QueryContext, expression.Parameters.FirstOrDefault()); var newExpression = entityVisitor.Visit(expression.Body); Assert.NotNull(newExpression); Assert.NotEqual(newExpression, expression.Body); Assert.Equal(2, entityVisitor.PredicateAssignments.Count); Assert.Single(entityVisitor.PendingAssignments); Assert.Equal("NewAddressName_Location_Longitude", entityVisitor.PendingAssignments.First().Key.ComplexJsonName); dynamic result = newExpression.ExecuteExpression <Dictionary <string, object> >(); Assert.NotNull(result); var tokensExpected = new Dictionary <string, object> { { "Name", "Shonda Rhimes" }, { "NewAddressName_Location_Longitude", 0.0 } }; Assert.Equal(tokensExpected.Count, result.Count); foreach (var pair in result) { Assert.Equal(tokensExpected[pair.Key], pair.Value); } }
public void EscapedComplexAnonymousType(string testContextName, TestContext testContext) { //the following is purely a test, and not necessarily a good example for neo4j cypher. Expression <Func <object> > expression = () => new { Address = CypherFunctions._(TestUtilities.Actor.Address as AddressWithComplexType), Coordinates = new[] { (TestUtilities.Actor.Address as AddressWithComplexType).Location.Latitude, (double)CypherVariables.Get("shondaRhimes")["NewAddressName_Location_Longitude"] } }; var entityVisitor = new EntityExpressionVisitor(testContext.QueryContext); var newExpression = entityVisitor.Visit(expression.Body); Assert.NotNull(newExpression); Assert.NotEqual(newExpression, expression.Body); Assert.Single(entityVisitor.PendingAssignments); Assert.Equal("Coordinates", entityVisitor.PendingAssignments.First().Key.ComplexJsonName); Assert.Contains("Get(\"shondaRhimes\").get_Item(\"NewAddressName_Location_Longitude\")", entityVisitor.PendingAssignments.First().Value.ToString()); var result = newExpression.ExecuteExpression <Dictionary <string, object> >(); Assert.NotNull(result); var tokensExpected = new Dictionary <string, object> { //same name (Address) returned because it was escaped (instead of: NewAddressName) { "Address_AddressLine", null }, { "Address_City", "Los Angeles" }, { "Address_State", "California" }, { "Address_Country", "US" }, { "Address_Location_Latitude", 34.0522 }, { "Address_Location_Longitude", -118.2437 }, { "Coordinates", null } //assignment pending due to CypherVariables Get call }; Assert.Equal(tokensExpected.Count, result.Count); foreach (var pair in result) { Assert.Equal(tokensExpected[pair.Key], pair.Value); } }
public static IPath BuildTestPathMixed(IPathBuilder P) { return(P .Pattern <MovieNode, MovieActorRelationship, ActorNode>("greysAnatomy", "ellenPompeo") .Label(new[] { "Series" }, new[] { "STARRED_IN" }, new[] { "Female" }, true, false, false) .Prop(() => new MovieNode //could have used constrain, but would be good to test both methods { Title = "Grey's Anatomy", Year = 2017 }) .Hop(1) //not necessary, but for tests .Constrain(null, null, actor => actor.Name == "Ellen Pompeo" && actor.Born == CypherVariables.Get <ActorNode>("shondaRhimes").Born && actor.Roles == new[] { "Meredith Grey" })); }
public void SetPredicateWithParamsWithComplexVarsGetAssigment(string testContextName, TestContext testContext) { var query = testContext.Query; var actual = query.UsingBuildStrategy(PropertiesBuildStrategy.WithParams) .Set((ActorNode actor) => actor.Name == "Ellen Pompeo" && actor.Born == CypherVariables.Get <ActorNode>("actor").Born + 1 && //((int?)null ?? 1969) + 1 actor.Roles == new[] { "Meredith Grey" }, out var setParam).Query.QueryText; //When using Set predicate, WithParams strategy is the same as WithParamsForValues var expected = $"SET actor.Name = ${setParam}.Name, actor.Born = actor.Born + $p1, actor.Roles = ${setParam}.Roles"; Assert.Equal(expected, actual); }
public void AnonymousType(string testContextName, TestContext testContext) { Expression <Func <object> > expression = () => new { Name = "Ellen Pompeo", CypherVariables.Get <ActorNode>("shondaRhimes").Born, Roles = new[] { "Meredith Grey" }, Age = 47.ToString() }; var entityVisitor = new EntityExpressionVisitor(testContext.QueryContext); var newExpression = entityVisitor.Visit(expression.Body); Assert.NotNull(newExpression); Assert.NotEqual(newExpression, expression.Body); Assert.Single(entityVisitor .PendingAssignments); //because we are accounting for an implicit convert to object type. Assert.Equal("Born", entityVisitor.PendingAssignments.First().Key.ComplexJsonName); Assert.Equal("Get(\"shondaRhimes\").Born", entityVisitor.PendingAssignments.First().Value.ToString()); var result = newExpression.ExecuteExpression <Dictionary <string, object> >(); Assert.NotNull(result); var tokensExpected = new Dictionary <string, object> { { "Name", "Ellen Pompeo" }, { "Born", 0 }, //to be later replaced at serialization with params { "Roles", new[] { "Meredith Grey" } }, { "Age", "47" } }; Assert.Equal(tokensExpected.Count, result.Count); foreach (var pair in result) { Assert.Equal(tokensExpected[pair.Key], pair.Value); } }
public void Predicate(string testContextName, TestContext testContext) { Expression <Func <ActorNode, bool> > expression = a => a.Born == CypherVariables.Get <ActorNode>("ellenPompeo").Born && a.Name == "Shonda Rhimes" && a.Address.AddressLine == CypherVariables.Get <ActorNode>("shondaRhimes").Address.AddressLine; var entityVisitor = new EntityExpressionVisitor(testContext.QueryContext, expression.Parameters.FirstOrDefault()); var newExpression = entityVisitor.Visit(expression.Body); Assert.NotNull(newExpression); Assert.NotEqual(newExpression, expression.Body); Assert.Equal(3, entityVisitor.PredicateAssignments.Count); Assert.Equal(2, entityVisitor.PendingAssignments.Count); Assert.Equal("Born", entityVisitor.PendingAssignments.First().Key.ComplexJsonName); Assert.Equal("Get(\"ellenPompeo\").Born._()", entityVisitor.PendingAssignments.First().Value .ToString()); //the npf escape will be added for concrete classes var result = newExpression.ExecuteExpression <Dictionary <string, object> >(); Assert.NotNull(result); var tokensExpected = new Dictionary <string, object> { { "Name", "Shonda Rhimes" }, { "Born", 0 }, //assignment pending due to CypherVariables Get call { "NewAddressName_AddressLine", null } }; Assert.Equal(tokensExpected.Count, result.Count); foreach (var pair in result) { Assert.Equal(tokensExpected[pair.Key], pair.Value); } }
public void Properties_FinalProperties(string testContextName, TestContext testContext) { var client = testContext.AnnotationsContext.GraphClient; var query = testContext.Query; var builder = new PathBuilder(query); var pattern = builder .Pattern <ActorNode>("Ambode") .Prop(() => new { Name = "Ellen Pompeo", CypherVariables.Get <ActorNode>("shondaRhimes").Born, Roles = new[] { "Meredith Grey" }, Age = 47.ToString() }) .Pattern as Pattern; var aProperties = pattern.AProperties; Assert.NotNull(aProperties); var aFinalProperties = pattern.AFinalProperties; Assert.NotNull(aFinalProperties); var expected = new Dictionary <string, dynamic> { { "Name", "\"Ellen Pompeo\"" }, { "Born", "shondaRhimes.Born" }, { "Roles", "[" + Environment.NewLine + " \"Meredith Grey\"" + Environment.NewLine + "]" }, { "Age", "\"47\"" } //because we assigned a 47 string and not a 47 int. }; TestUtilities.TestFinalPropertiesForEquality(instance => client.Serializer.Serialize(instance), expected, aFinalProperties); }
public void PredicateDictionarySet(string testContextName, TestContext testContext) { Expression <Func <Dictionary <string, object>, bool> > expression = a => a["Address"] == CypherVariables.Get <ActorNode>("ellenPompeo").Address && (int)a["Born"] == 1671 && a["Name"] == "Shonda Rhimes"; var entityVisitor = new EntityExpressionVisitor(testContext.QueryContext, expression.Parameters.FirstOrDefault()); var newExpression = entityVisitor.Visit(expression.Body); Assert.NotNull(newExpression); Assert.NotEqual(newExpression, expression.Body); Assert.Equal(3, entityVisitor.PredicateAssignments.Count); Assert.Equal(4, entityVisitor.PendingAssignments.Count); //the address complex type should have exploded to make 4 Assert.Equal("NewAddressName_AddressLine", entityVisitor.PendingAssignments.First().Key.ComplexJsonName); Assert.Contains("Get(\"ellenPompeo\").Address.AddressLine", entityVisitor.PendingAssignments.First().Value.ToString()); dynamic result = newExpression.ExecuteExpression <Dictionary <string, object> >(); Assert.NotNull(result); var tokensExpected = new Dictionary <string, object> { { "Name", "Shonda Rhimes" }, { "Born", 1671 }, { "NewAddressName_AddressLine", null }, { "NewAddressName_City", null }, { "NewAddressName_State", null }, { "NewAddressName_Country", null } }; Assert.Equal(tokensExpected.Count, result.Count); foreach (var pair in result) { Assert.Equal(tokensExpected[pair.Key], pair.Value); } }