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);
}
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;
}
private ICypherFluentQuery AddLockout(ICypherFluentQuery query, LockoutInfo lockoutInfo)
{
if (lockoutInfo == null)
return query;
query = query.With("u")
.Create($"(u)-[:{Relationship.IsLockedOut}]->(:{LockoutInfo.Label} {{lockoutParam}})")
.WithParam("lockoutParam", lockoutInfo);
return query;
}
private ICypherFluentQuery AddRoles(ICypherFluentQuery query, ICollection<Neo4jIdentity.Neo4jIdentityRole> roles)
{
if (roles == null || roles.Count == 0)
return query;
query = query.With("u")
.Unwind(roles, "role")
.Match($"(r:{RoleLabel} {{NormalizedName: role.NormalizedName}})")
.With("u,r")
.Create($"(u)-[:{Relationship.InRole}]->(r)");
return query;
}
private ICypherFluentQuery AddLogins(ICypherFluentQuery query, IList<UserLoginInfo> logins)
{
if (logins == null || logins.Count == 0)
return query;
for (var i = 0; i < logins.Count; i++)
{
var loginName = $"login{i}";
var loginParam = new InternalLoginProvider(logins[i]);
query = query.With("u")
.Create($"(u)-[:{Relationship.HasLogin}]->(l{i}:{LoginLabel} {{{loginName}}})")
.WithParam(loginName, loginParam);
}
return query;
}
private ICypherFluentQuery AddClaims(ICypherFluentQuery query, IList<SimplifiedClaim> claims)
{
if (claims == null || claims.Count == 0)
return query;
for (var i = 0; i < claims.Count; i++)
{
var claimName = $"claim{i}";
var claimParam = claims[i];
query = query.With("u")
.Create($"(u)-[:{Relationship.HasClaim}]->(c{i}:{ClaimLabel} {{{claimName}}})")
.WithParam(claimName, claimParam);
}
return query;
}
private static ICypherFluentQuery AddLogins(ICypherFluentQuery query, IList <UserLoginInfo> logins)
{
if (logins == null || logins.Count == 0)
{
return(query);
}
for (int i = 0; i < logins.Count; i++)
{
var loginName = string.Format("login{0}", i);
var loginParam = logins[i];
query = query.With("u")
.Create("(u)-[:HAS_LOGIN]->(l" + i + ":Login {" + loginName + "})")
.WithParam(loginName, loginParam);
}
return(query);
}
private static ICypherFluentQuery AddClaims(ICypherFluentQuery query, IList <IdentityUserClaim> claims)
{
if (claims == null || claims.Count == 0)
{
return(query);
}
for (int i = 0; i < claims.Count; i++)
{
var claimName = string.Format("claim{0}", i);
var claimParam = claims[i];
query = query.With("u")
.Create("(u)-[:HAS_CLAIM]->(c" + i + ":claim {" + claimName + "})")
.WithParam(claimName, claimParam);
}
return(query);
}
private static ICypherFluentQuery AddLogins(ICypherFluentQuery query, IList <UserLoginInfo> logins)
{
if ((logins == null) || (logins.Count == 0))
{
return(query);
}
for (var i = 0; i < logins.Count; i++)
{
var loginName = $"login{i}";
var loginParam = logins[i];
query = query.With("u")
.Create($"(u)-[:HAS_LOGIN]->(l{i}:Login {{{loginName}}})")
.WithParam(loginName, loginParam);
}
return(query);
}
private static ICypherFluentQuery AddClaims(ICypherFluentQuery query, IList <IdentityUserClaim> claims)
{
if ((claims == null) || (claims.Count == 0))
{
return(query);
}
for (var i = 0; i < claims.Count; i++)
{
var claimName = $"claim{i}";
var claimParam = claims[i];
query = query.With("u")
.Create($"(u)-[:HAS_CLAIM]->(c{i}:claim {{{claimName}}})")
.WithParam(claimName, claimParam);
}
return(query);
}
protected ICypherFluentQuery AddLogins(ICypherFluentQuery query, IList <IdentityExternalLogin> logins)
{
if ((logins == null) || (logins.Count == 0))
{
return(query);
}
for (var i = 0; i < logins.Count; i++)
{
var login = logins[i];
query = query
.With("u")
.Merge(p => p.Pattern <TUser, IdentityExternalLogin>("u", $"l{i}")
.Constrain(null, l => l.LoginProvider == login.LoginProvider && l.ProviderKey == login.ProviderKey))
.OnCreate().Set($"l{i}", () => login);
}
return(query);
}
protected ICypherFluentQuery AddClaims(ICypherFluentQuery query, IList <IdentityClaim> claims)
{
if (claims == null || claims.Count == 0)
{
return(query);
}
for (var i = 0; i < claims.Count; i++)
{
var claim = claims[i];
query = query
.With("u")
.Merge(p => p.Pattern <TUser, IdentityClaim>("u", $"c{i}")
.Constrain(null, c => c.Type == claim.Type && c.Value == claim.Value))
.OnCreate().Set($"c{i}", () => claim);
}
return(query);
}
public void Execute(ICypherFluentQuery cypher)
{
ProcessStacks();
foreach (var query in _queryStack)
{
if (query.QueryType == QueryTypeEnum.Match)
{
cypher = cypher.Match(query.QueryString);
continue;
}
if (query.QueryType == QueryTypeEnum.OptionalMatch)
{
cypher = cypher.OptionalMatch(query.QueryString);
continue;
}
if (query.QueryType == QueryTypeEnum.Where)
{
cypher = cypher.Where(query.QueryString);
continue;
}
if (query.QueryType == QueryTypeEnum.Create)
{
cypher = cypher.Create(query.QueryString);
continue;
}
if (query.QueryType == QueryTypeEnum.Merge)
{
cypher = cypher.Merge(query.QueryString);
continue;
}
if (query.QueryType == QueryTypeEnum.Delete)
{
cypher = cypher.Delete(query.QueryString);
continue;
}
if (query.QueryType == QueryTypeEnum.With)
{
cypher = cypher.With(query.QueryString);
continue;
}
}
cypher.ExecuteWithoutResults();
}
