public async Task <IResultSummary> Update <T>(string matchQuery, IDictionary <string, object> parameters, string matchQueryResultVariable, T obj)
where T : class, new()
{
IResultSummary resultSummary = await RunQuery(engine.CreateSetNodeQuery <T>(matchQuery, parameters, matchQueryResultVariable, obj));
return(resultSummary);
}
public void ClearTokens()
{
try
{
_logger.LogTrace("Querying for tokens to clear");
var found = Int32.MaxValue;
using (var serviceScope = _serviceProvider.GetRequiredService <IServiceScopeFactory>().CreateScope())
{
using (ISession session = serviceScope.ServiceProvider.GetService <IdentityServerDriverProvider>().GetDriver().Session())
{
while (found >= _options.TokenCleanupBatchSize)
{
Node n = new Node(type: typeof(PersistedGrant));
IResultSummary summary = session.Run(
$"MATCH (p{n.Labels}) " +
$"WHERE p.{nameof(PersistedGrant.Expiration)}<$date " +
$"WITH p ORDER BY p.{nameof(PersistedGrant.Key)} " +
$"LIMIT $count " +
$"DETACH DELETE p",
new { date = DateTime.UtcNow, count = _options.TokenCleanupBatchSize }).Summary;
found = summary.Counters.NodesDeleted;
_logger.LogInformation("Cleared {tokenCount} tokens", found);
}
}
}
}
catch (Exception ex)
{
_logger.LogError("Exception clearing tokens: {exception}", ex.Message);
}
}
public ProcessingResult Process(Resource resource)
{
var eventRecorder = new EventRecorder();
this.Target = new StubTarget();
var concordionBuilder = new ConcordionBuilder()
.WithEvaluatorFactory(this.EvaluatorFactory)
.WithSource(this.Source)
.WithTarget(this.Target)
.WithAssertEqualsListener(eventRecorder)
.WithExceptionListener(eventRecorder);
if (this.Fixture != null)
{
new ExtensionLoader(this.Configuration).AddExtensions(this.Fixture, concordionBuilder);
}
if (this.Extension != null)
{
this.Extension.AddTo(concordionBuilder);
}
var concordion = concordionBuilder.Build();
try
{
IResultSummary resultSummary = concordion.Process(resource, this.Fixture);
string xml = this.Target.GetWrittenString(resource);
return new ProcessingResult(resultSummary, eventRecorder, xml);
}
catch (Exception e)
{
throw new Exception("Test rig failed to process specification", e);
}
}
public async void TestUpdateNode()
{
var personGuid = Guid.NewGuid();
var person = new Person()
{
Age = 50,
DateOfBirth = DateTime.Now.AddYears(-50),
Id = personGuid,
Name = "neo",
Salary = 5400.77,
};
IDictionary <string, object> parameters = new Dictionary <string, object>()
{
{ "Id", personGuid }
};
var context = new NeoContext(Driver);
IResultSummary resultExecuting = await context.InsertNode <Person>(person);
person.Age = 55;
await context.Update <Person>("MATCH (p:Person { Id : $Id} )", parameters, "p", person);
var resultPerson = await context.QueryDefault <Person>("MATCH (p:Person { Id : $Id} ) return p", parameters);
Assert.Equal <Person>(person, resultPerson);
await context.ExecuteQuery("MATCH (p:Person) DETACH DELETE p");
}
public async Task <IResultSummary> Insert(string cypherQuery, IDictionary <string, object> parameters)
{
parameters = engine.ParameterConverter(parameters);
IResultSummary resultSummary = await RunQuery(new Query(cypherQuery, parameters));
return(resultSummary);
}
public async Task <int> DropIndexAsync(string label, string propertyname)
{
string query = $"DROP INDEX ON :{label}({propertyname})";
int count = 0;
using (ISession session = this._driver.Session())
{
try
{
await session.ReadTransactionAsync(async (tx) =>
{
IStatementResultCursor reader = await tx.RunAsync(query);
await reader.ConsumeAsync();
IResultSummary summary = await reader.SummaryAsync();
count = summary.Counters.IndexesRemoved;
});
}
catch (Exception e)
{
this._logger.LogError(e, $"Error dropping index for label {label} on property {propertyname}");
}
finally
{
await session.CloseAsync();
}
}
return(count);
}
public async Task ExecuteNonQuery(string cypherQuery, object queryParams = null)
{
IAsyncSession session = _driver.AsyncSession(o => o.WithDatabase(this._database));
if (queryParams == null)
{
queryParams = new {};
}
try
{
_logger.LogDebug($"Executing query: {cypherQuery}");
IResultCursor cursor = await session.RunAsync(cypherQuery, queryParams);
IResultSummary result = await cursor.ConsumeAsync();
_logger.LogTrace($"Query executed successfully.");
}
catch (Exception ex)
{
Console.WriteLine($"Error executing query. {ex.Message}");
throw;
}
finally
{
await session.CloseAsync();
}
}
public ExecuteHttpTriggerTests()
{
_request = new DefaultHttpRequest(new DefaultHttpContext());
_request.Headers.Add("X-Forwarded-Host", "test.com");
_executionContext = new ExecutionContext();
_config = A.Fake <IOptionsMonitor <ServiceTaxonomyApiSettings> >();
A.CallTo(() => _config.CurrentValue).Returns(new ServiceTaxonomyApiSettings
{
Function = DefaultFunctionName,
Neo4jUrl = "bolt://localhost:11002",
Neo4jUser = "******",
Neo4jPassword = "******",
Scheme = "https://",
ApplicationName = "ServiceTaxonomy"
});
_log = A.Fake <ILogger>();
_httpRequestHelper = A.Fake <IHttpRequestHelper>();
_neo4JHelper = A.Fake <INeo4JHelper>();
_fileHelper = A.Fake <IFileHelper>();
_resultSummary = A.Fake <IResultSummary>();
A.CallTo(() => _neo4JHelper.GetResultSummaryAsync()).Returns(_resultSummary);
const string query = "{\"query\": \"QUERY HERE\"}";
A.CallTo(() => _fileHelper.ReadAllTextFromFileAsync($"\\CypherQueries\\{DefaultApiVersion}\\{DefaultFunctionName}.json")).Returns(query);
_executeFunction = new Execute(_config, _httpRequestHelper, _neo4JHelper, _fileHelper);
}
public async void TestQueryMultiple()
{
var persons = new List <Person>()
{
new Person()
{
Age = 50,
DateOfBirth = DateTime.Now.AddYears(-50),
Id = Guid.NewGuid(),
Name = "neo",
Salary = 5400.77,
},
new Person()
{
Age = 50,
DateOfBirth = DateTime.Now.AddYears(-50),
Id = Guid.NewGuid(),
Name = "neo",
Salary = 5400.77,
}
};
var context = new NeoContext(Driver);
IResultSummary resultExecuting = await context.InsertNodes <Person>(persons);
IEnumerable <Person> personsResult = await context.QueryMultiple <Person>("MATCH (p:Person) return p");
await context.ExecuteQuery("MATCH (p:Person) DETACH DELETE p");
}
public async Task <int> CreateIndexAsync(NewIndex newIndex)
{
string query = $"CREATE INDEX ON :{newIndex.Label}({newIndex.Property})";
int count = 0;
using (ISession session = this._driver.Session())
{
try
{
await session.ReadTransactionAsync(async (tx) =>
{
IStatementResultCursor reader = await tx.RunAsync(query);
await reader.ConsumeAsync();
IResultSummary summary = await reader.SummaryAsync();
count = summary.Counters.IndexesAdded;
});
}
catch (Exception e)
{
this._logger.LogError(e, $"Error creating index for label {newIndex.Label} on property {newIndex.Property}");
}
finally
{
await session.CloseAsync();
}
}
return(count);
}
public void ValidateResults(List <IRecord> records, IResultSummary resultSummary)
{
if (resultSummary.Counters.NodesDeleted != 1)
{
throw new CommandValidationException($"Expecting 1 node to be deleted, but {resultSummary.Counters.NodesDeleted} were actually deleted.");
}
//todo: check number of relationships deleted?
}
private Task <IResultSummary> GetSummaryAsync()
{
if (_summary == null && _summaryFunc != null)
{
_summary = _summaryFunc();
}
return(Task.FromResult(_summary));
}
public void CRUD_Node()
{
DriverProvider provider = Fixture.GetService <TestDriverProvider>();
using (ISession session = provider.GetDriver().Session())
{
Symbol s = new Symbol();
TestNode tnode = new TestNode()
{
Id = 1
};
PrepareEntity(tnode);
TestNode val = session.ExecuteQuery <TestNode>($"MATCH {new Node(s, tnode.GetType(), new { Id = 1 }.ToPropDictionary())} RETURN {s}").FirstOrDefault();
Assert.Null(val);
val = session.ExecuteQuery <TestNode>($"CREATE " +
$"{new Node(s, tnode.GetType(), (IDictionary<string, object>)tnode.Scope(new N4pper.ObjectExtensionsConfiguration(), q=>q.ToPropDictionary()))}" +
$" SET {s} :testlabel RETURN {s}").FirstOrDefault();
Assert.NotNull(val);
Assert.Equal(tnode.Id, val.Id);
CheckEntityEquals(tnode, val);
Assert.Null(val.ValuesObject);
val = session.ExecuteQuery <TestNode>($"MATCH {new Node(s, tnode.GetType(), new { Id = 1 }.ToPropDictionary())} SET {new Set(s, new { Double = 1.2 }.ToPropDictionary())} RETURN {s}")
.FirstOrDefault();
Assert.NotNull(val);
Assert.Equal(1.2, val.Double);
val = session.ExecuteQuery <TestNode>($"MATCH {new Node(s, tnode.GetType(), new { Id = 1 }.ToPropDictionary())} SET {s}+=$val RETURN {s}", new { val = new { EnumValue = TestEnum.C, Values = new List <string>()
{
"aaa", "bbb", "ccc"
} } })
.FirstOrDefault();
Assert.NotNull(val);
Assert.Equal(TestEnum.C, val.EnumValue);
val = session.ExecuteQuery <TestNode>($"MATCH {new Node(s, tnode.GetType(), new { Id = 1 }.ToPropDictionary())} SET {s}+=$val RETURN {s}", new { val = new { EnumValue = TestEnum.C, Values = new List <string>()
{
"aaa", "ccc"
} } })
.FirstOrDefault();
Assert.NotNull(val);
Assert.Equal(new List <string>()
{
"aaa", "ccc"
}, val.Values);
IResultSummary result = session.Execute($"MATCH {new Node(s, tnode.GetType(), new { Id = 1 }.ToPropDictionary())} DELETE {s}");
Assert.Equal(1, result.Counters.NodesDeleted);
val = session.ExecuteQuery <TestNode>($"MATCH {new Node(s, tnode.GetType(), new { Id = 1 }.ToPropDictionary())} RETURN {s}").FirstOrDefault();
Assert.Null(val);
}
}
protected override void ProcessSummary(IResultSummary summary)
{
if (summary == null)
{
return;
}
_readQueriesByServer.AddOrUpdate(summary.Server.Address, new AtomicLong(1),
(key, value) => value.Increment());
}
protected override void ProcessSummary(IResultSummary summary)
{
if (summary == null)
{
return;
}
summary.Server.Address.Should().Be(_expectedAddress);
Interlocked.Increment(ref _readQueries);
}
public async Task ProcurarFamilia(string filho, string aniFilho, bool comAnilha) //Testar essa função
{
session = _driver.AsyncSession(o => o.WithDatabase("neo4j")); //Nome da database está nas propriedades como padrão
try {
string optMatch;
string matchf;
if (comAnilha)
{
matchf = "MATCH (f:Passaro{nome:$filho, anilha:$aniFilho})" +
"OPTIONAL MATCH (f)<-[:PAI]-(p1:Passaro)" +
"OPTIONAL MATCH (m1:Passaro)-[:MAE]->(f)";
}
else
{
matchf = "MATCH (f:Passaro{nome:$filho})" +
"WHERE ID(f) = toInteger($aniFilho)" +
"OPTIONAL MATCH (f)<-[:PAI]-(p1:Passaro)" +
"OPTIONAL MATCH (m1:Passaro)-[:MAE]->(f)";
}
optMatch =
"optional match(m2:Passaro)-[:MAE]->(p1) < -[:PAI] - (p2: Passaro)" +
"optional match(m3:Passaro)-[:MAE]->(m1) < -[:PAI] - (p3: Passaro)" +
"optional match(m4:Passaro)-[:MAE]->(p2) < -[:PAI] - (p4: Passaro)" +
"optional match(m5:Passaro)-[:MAE]->(m2) < -[:PAI] - (p5: Passaro)" +
"optional match(m6:Passaro)-[:MAE]->(p3) < -[:PAI] - (p6: Passaro)" +
"optional match(m7:Passaro)-[:MAE]->(m3) < -[:PAI] - (p7: Passaro)" +
"OPTIONAL MATCH(m8:Passaro)-[:MAE]->(p4) < -[:PAI] - (p8: Passaro)" +
"OPTIONAL MATCH(m9:Passaro)-[:MAE]->(m4) < -[:PAI] - (p9: Passaro)" +
"OPTIONAL MATCH(m10:Passaro)-[:MAE]->(p5) < -[:PAI] - (p10: Passaro)" +
"OPTIONAL MATCH(m11:Passaro)-[:MAE]->(m5) < -[:PAI] - (p11: Passaro)" +
"OPTIONAL MATCH(m12:Passaro)-[:MAE]->(p6) < -[:PAI] - (p12: Passaro)" +
"OPTIONAL MATCH(m13:Passaro)-[:MAE]->(m6) < -[:PAI] - (p13: Passaro)" +
"OPTIONAL MATCH(m14:Passaro)-[:MAE]->(p7) < -[:PAI] - (p14: Passaro)" +
"OPTIONAL MATCH(m15:Passaro)-[:MAE]->(m7) < -[:PAI] - (p15: Passaro)" +
"return [f.nome, p1.nome, m1.nome, p2.nome, m2.nome, p3.nome, m3.nome, " +
"p4.nome, m4.nome, p5.nome, m5.nome, p6.nome, m6.nome, p7.nome, m7.nome," +
"p8.nome, m8.nome, p9.nome, m9.nome, p10.nome, m10.nome, p11.nome, m11.nome," +
"p12.nome, m12.nome, p13.nome, m13.nome, p14.nome, m14.nome, p15.nome, m15.nome] AS familia";
cursor = await session.RunAsync(matchf + optMatch, new { filho, aniFilho });
records = await cursor.ToListAsync();
familia = new List <string>();
//familia.Add(aniFilho);
//familia.Add(filho);
familia = Records();
resultado = await cursor.ConsumeAsync();
}
finally {
await session.CloseAsync();
}
}
/// <summary>
/// Removes all grants of a give type for a given subject id and client id combination.
/// </summary>
/// <param name="subjectId">The subject identifier.</param>
/// <param name="clientId">The client identifier.</param>
/// <param name="type">The type.</param>
/// <returns></returns>
public async Task RemoveAllAsync(string subjectId, string clientId, string type)
{
using (ISession session = _context.GetDriver().Session())
{
Node c = new Node(type: typeof(Client));
Node n = new Node(type: typeof(PersistedGrant));
Rel rel = new Rel(type: typeof(Relationships.Has));
IResultSummary summary = await(await session.RunAsync(
$"MATCH (c{c.Labels} {{{nameof(Client.ClientId)}:${nameof(clientId)}}})" +
$"-{rel}->" +
$"(n{n.Labels} {{{nameof(PersistedGrant.ClientId)}:${nameof(clientId)},{nameof(PersistedGrant.SubjectId)}:${nameof(subjectId)},{nameof(PersistedGrant.Type)}:${nameof(type)}}}) " +
$"DETACH DELETE n"
, new { clientId, subjectId, type })).SummaryAsync();
}
}
public async void TestInsertNodesWithRelation()
{
var person = new Person()
{
Age = 50,
DateOfBirth = DateTime.Now.AddYears(-50),
Id = Guid.NewGuid(),
Name = "neo",
Salary = 5400.77,
Owns = new List <Owns>()
{
new Owns()
{
OwnedFrom = DateTime.Now.AddYears(-2),
OwnedTill = DateTime.Now.AddYears(-1),
House = new House()
{
Address = "test address",
Age = 150
}
}
}
};
INeoContext context = new NeoContext(Driver);
IResultSummary resultExecuting = await context.InsertNodeWithRelation <Person, Owns, House>(person, person.Owns.First(), person.Owns.First().House);
Dictionary <Guid, Person> personContainer = new Dictionary <Guid, Person>();
var resultPerson = await context.QueryDefaultIncludeable <Person, Owns, House>("MATCH (p:Person { Name: 'neo' })-[o:Owns]->(h:House) return p,o,h",
(p, o, h) =>
{
if (!personContainer.ContainsKey(p.Id))
{
personContainer.Add(p.Id, p);
p.Owns = new List <Owns>();
}
personContainer[p.Id].Owns.Add(o);
o.House = h;
return(personContainer[p.Id]);
}
);
await context.ExecuteQuery("MATCH (n:Person { Name: 'neo' }) DETACH DELETE n");
await context.ExecuteQuery("MATCH (p:House {Address: 'test address'}) DETACH DELETE p");
Assert.Equal <Person>(person, resultPerson);
}
/// <summary>
/// Removes the grant by key.
/// </summary>
/// <param name="key">The key.</param>
/// <returns></returns>
public async Task RemoveAsync(string key)
{
using (ISession session = _context.GetDriver().Session())
{
Node n = new Node(type: typeof(PersistedGrant));
IResultSummary summary = await(await session.RunAsync(
$"MATCH (n{n.Labels} {{{nameof(PersistedGrant.Key)}:${nameof(key)}}}) " +
$"DETACH DELETE n"
, new { key })).SummaryAsync();
if (summary.Counters.NodesDeleted == 0)
{
_logger.LogDebug("no {persistedGrantKey} persisted grant found in database", key);
}
}
}
private void AddToTestResults(IResultSummary singleResult, IResultRecorder resultSummary)
{
if (resultSummary == null) return;
if (singleResult.HasExceptions)
{
resultSummary.Record(Result.Exception);
}
else if (singleResult.HasFailures)
{
resultSummary.Record(Result.Failure);
}
else
{
resultSummary.Record(Result.Success);
}
}
/// <summary>
/// 创建node
/// </summary>
/// <param name="nodeType">node类型</param>
/// <param name="id">id</param>
/// <param name="vip">vip等级</param>
/// <param name="ids">身份证</param>
/// <param name="caree">名片</param>
/// /// <param name="careerType">名片</param>
/// <returns>bool 是否创建成功</returns>
public bool CreateSingleNode(string nodeType, string id, string nickName, int vip, int identityAuth, int careerAuth, int careerType, DateTime registerAt, int status)
{
string query = string.Format("CREATE (n:{0} ", nodeType) + @"{id:$id,nickName:$nickName,vip:$vip,identityAuth:$identityAuth,careerAuth:$careerAuth,careerType:$careerType,registerAt:$registerAt,status:$status})";
using (var session = _graphDatabase.Session(AccessMode.Write))
{
try
{
var result = session.WriteTransaction(tx => tx.Run(query, new { id = id.ToLower(), nickName, vip, identityAuth, careerAuth, careerType, registerAt, status }));
IResultSummary rs = result.Summary;
return(rs.Counters.NodesCreated == 1);
}
catch (Exception ex)
{
throw ex;
}
}
}
public async Task DefinirPaisAsync(string filho, string aniFilho, string pai, string aniPai, string mae, string aniMae, bool[] comAnilha)
{
session = _driver.AsyncSession(o => o.WithDatabase("neo4j"));//Nome da database está nas propriedades como padrão
try {
if (!comAnilha.All(anilhas => anilhas == true)) //Expressão Lambda (entrada) => (corpo/condição)
{
string matchf = " MATCH(f: Passaro { nome: $filho, anilha:$aniFilho})";
string matchp = " MATCH(p: Passaro { nome: $pai, anilha:$aniPai})";
string matchm = " MATCH(m:Passaro { nome: $mae, anilha:$aniMae})";
string where = " WHERE NOT (:Passaro)-[:PAI]->(f)<-[:MAE]-(:Passaro)";
string merge = " MERGE (p)-[:PAI]->(f)<-[:MAE]-(m)";
if (!comAnilha[0])
{
matchf = "MATCH (f:Passaro {nome: $filho})";
where += " and ID(f) = toInteger($aniFilho)";
}
if (!comAnilha[1])
{
matchp = "MATCH (p:Passaro {nome: $pai})";
where += " and ID(p) = toInteger($aniPai)";
}
if (!comAnilha[2])
{
matchm = "MATCH (m:Passaro {nome: $mae})";
where += " and ID(m) = toInteger($aniMae)";
}
cursor = await session.RunAsync(matchf + matchp + matchm + where + merge, new { filho, aniFilho, pai, aniPai, mae, aniMae });
}
else
{
cursor = await session.RunAsync("MATCH (f:Passaro {nome: $filho, anilha:$aniFilho})" +
"MATCH (p:Passaro {nome: $pai, anilha:$aniPai})" +
"MATCH (m:Passaro {nome: $mae, anilha:$aniMae})" +
"WHERE NOT (:Passaro)-[:PAI]->(f)<-[:MAE]-(:Passaro)" +
"MERGE (p)-[:PAI]->(f)<-[:MAE]-(m)", new { filho, aniFilho, pai, aniPai, mae, aniMae });
}
resultado = await cursor.ConsumeAsync();
}
finally {
await session.CloseAsync();
}
}
private TestResult NUnitTestResult(IResultSummary concordionResult)
{
var testResult = new TestResult(this);
if (concordionResult.HasExceptions)
{
testResult.Error(new NUnitException("Exception in Concordion test: please see Concordion test reports"));
}
else if (concordionResult.HasFailures)
{
testResult.Failure("Concordion Test Failures: " + concordionResult.FailureCount,
"for stack trace, please see Concordion test reports");
} else
{
testResult.Success();
}
return testResult;
}
public void ResultSummaryQueryProfile()
{
var driver = GraphDatabase.Driver(_serverEndPoint, _authToken);
var session = driver.Session();
//tag::result-summary-query-profile[]
var result = session.Run("PROFILE MATCH (p:Person {name: {name}}) RETURN id(p)",
new Dictionary <string, object> {
{ "name", "Arthur" }
});
IResultSummary summary = result.Consume();
Output.WriteLine(summary.StatementType.ToString());
Output.WriteLine(summary.Profile.ToString());
//end::result-summary-query-profile[]
driver.Dispose();
}
public bool CreateSingleNode(string nodeType, UserInfo userInfo)
{
string query = string.Format("CREATE (n:{0} ", nodeType) + @"{id: $userID,nickName:$NickName,vip:$Vip,identityAuth:$IdentityAuth,careerAuth:$CareerAuth,careerType:$CareerType,registerAt:$RegisterAt})";
using (var session = _graphDatabase.Session(AccessMode.Write))
{
try
{
var userID = userInfo.UserId.ToString();
var result = session.WriteTransaction(tx => tx.Run(query, new { userID, userInfo.NickName, userInfo.Vip, userInfo.IdentityAuth, userInfo.CareerAuth, userInfo.CareerType, userInfo.RegisterAt }));
IResultSummary rs = result.Summary;
return(rs.Counters.NodesCreated == 1);
}
catch (Exception ex)
{
throw ex;
}
}
}
public void ResultSummaryQueryProfile()
{
var driver = GraphDatabase.Driver("bolt://localhost:7687");
var session = driver.Session();
//tag::result-summary-query-profile[]
var result = session.Run("PROFILE MATCH (p:Person { name: {name} }) RETURN id(p)",
new Dictionary <string, object> {
{ "name", "The One" }
});
IResultSummary summary = result.Summary;
output.WriteLine(summary.StatementType.ToString());
output.WriteLine(summary.Profile.ToString());
//end::result-summary-query-profile[]
driver.Dispose();
}
public async void TestInsertQuery()
{
var person = new Person()
{
Age = 50,
DateOfBirth = DateTime.Now.AddYears(-50),
Id = Guid.NewGuid(),
Name = "neo",
Salary = 5400.77,
};
var context = new NeoContext(Driver);
IResultSummary resultExecuting = await context.InsertNode <Person>(person);
var resultPerson = await context.QueryDefault <Person>("MATCH (p:Person) RETURN p");
Assert.True(resultExecuting.QueryType == Neo4j.Driver.QueryType.WriteOnly);
Assert.Equal <Person>(person, resultPerson);
await context.ExecuteQuery("MATCH (p:Person { Name : 'neo' }) DETACH DELETE p");
}
private TestResult NUnitTestResult(IResultSummary concordionResult)
{
var testResult = new TestResult(this);
testResult.AssertCount = (int)concordionResult.SuccessCount + (int)concordionResult.FailureCount;
if (!(concordionResult.HasFailures || concordionResult.HasExceptions))
{
testResult.Success();
}
else if (concordionResult.HasFailures)
{
testResult.Failure("Concordion Test Failures: " + concordionResult.FailureCount,
"for stack trace, please see Concordion test reports");
}
else if (concordionResult.HasExceptions)
{
testResult.Error(new NUnitException("Exception in Concordion test: please see Concordion test reports"));
}
return(testResult);
}
private void AddToTestResults(IResultSummary singleResult, IResultRecorder resultSummary)
{
if (resultSummary == null)
{
return;
}
if (singleResult.HasExceptions)
{
resultSummary.AddResultDetails(singleResult.ErrorDetails);
}
else if (singleResult.HasFailures)
{
resultSummary.AddResultDetails(singleResult.FailureDetails);
}
else
{
resultSummary.Success();
}
}
/// <summary>
/// Stores the asynchronous.
/// </summary>
/// <param name="token">The token.</param>
/// <returns></returns>
public async Task StoreAsync(PersistedGrant token)
{
using (ISession session = _context.GetDriver().Session())
{
Node cli = new Node(type: typeof(Client));
Node n = new Node(type: typeof(PersistedGrant));
Rel rel = new Rel(type: typeof(Relationships.Has));
IResultSummary summary = await(await session.RunAsync(
$"MATCH (c{cli.Labels} {{{nameof(Client.ClientId)}:$value.{nameof(token.ClientId)}}}) " +
$"MERGE (c)-{rel}->(n{n.Labels} {{{nameof(PersistedGrant.Key)}:$value.{nameof(token.Key)}}}) " +
$"ON CREATE SET n+=$value, n.{nameof(IGraphEntity.EntityId)}=id(n), n :{typeof(Neo4jPersistedGrant).Name} " +
$"ON MATCH SET n+=$value, n.{nameof(IGraphEntity.EntityId)}=id(n) ", new { value = token })).SummaryAsync();
if (!summary.Counters.ContainsUpdates && summary.Counters.NodesCreated == 0)
{
_logger.LogWarning("No node have been created or updated.");
}
}
}
public async Task <List <IRecord> > ProcurarPais(string nome, string anilha, bool comAnilha)
{
session = _driver.AsyncSession(o => o.WithDatabase("neo4j"));//Nome da database está nas propriedades como padrão
try {
if (!comAnilha)
{
if (anilha != String.Empty)
{
cursor = await session.RunAsync("MATCH (f:Passaro{nome:$nome})" +
"WHERE ID(f) = toInteger($anilha) " +
"OPTIONAL MATCH (m1:Passaro)-[:MAE]->(f)" +
"OPTIONAL MATCH (f)<-[:PAI]-(p1:Passaro)" +
"RETURN f,[f.nome] AS Nomes,[m1.nome] AS Maes,[p1.nome] AS Pais, [ID(f)] AS Ids", new { nome, anilha });
}
else
{
cursor = await session.RunAsync("MATCH (f:Passaro{nome:$nome})" +
"OPTIONAL MATCH (m1:Passaro)-[:MAE]->(f)" +
"OPTIONAL MATCH (f)<-[:PAI]-(p1:Passaro)" +
"RETURN f,[f.nome] AS Nomes,[m1.nome] AS Maes,[p1.nome] AS Pais, [ID(f)] AS Ids", new { nome });
}
}
else
{
cursor = await session.RunAsync("MATCH (f:Passaro {nome: $nome, anilha:$anilha})" +
"OPTIONAL MATCH (m1:Passaro)-[:MAE]->(f)" +
"OPTIONAL MATCH (f)<-[:PAI]-(p1:Passaro)" +
"RETURN f,[f.nome] AS Nomes,[m1.nome] AS Maes,[p1.nome] AS Pais, [ID(f)] AS Ids", new { nome, anilha });
}
var lista = await cursor.ToListAsync();
resultado = await cursor.ConsumeAsync();
return(lista);
}
finally {
await session.CloseAsync();
}
}
//TODO: Mudar cor das labels na frente do cartão pelo usuário
//TODO: Menu para atualizar campos de passarinho
//TODO: Pontos que precisam estão marcados com indicadores de bandeira branca
//TODO: Clicar em pesquisar sem sair nomeFilhoF faz com que listnomesF == null
//TODO: Criar menu para cadastrar em árvore
//TODO: Atualizar buttonPesquisa para buttonImpressão
public async Task <List <IRecord> > ProcurarFilhos(string nome)
{
session = _driver.AsyncSession(o => o.WithDatabase("neo4j"));//Nome da database está nas propriedades como padrão
try {
cursor = await session.RunAsync("MATCH (p:Passaro {nome: $nome})" +
"OPTIONAL MATCH (p)-[:PAI|MAE]->(f:Passaro)" +
"RETURN [p.nome] AS Nomes, [ID(p)] AS Ids,[f.nome] AS Filhos, " +
"[p.anilha] AS Anilhas, [p.Sexo] AS Sexos, [p.NomePopular] AS NomesPopulares, " +
"[p.Nascimento] AS Nascimentos ", new { nome });
var lista = await cursor.ToListAsync();
resultado = await cursor.ConsumeAsync();
return(lista);
}
finally {
await session.CloseAsync();
}
}
private TestResult NUnitTestResult(IResultSummary concordionResult, string resultPath)
{
var testResult = new TestResult(this);
if (concordionResult.HasExceptions)
{
var errorDetails = concordionResult.ErrorDetails.First();
testResult.Error(errorDetails.Exception);
testResult.SetResult(testResult.ResultState,
resultPath + Environment.NewLine + testResult.Message,
testResult.StackTrace);
}
else if (concordionResult.HasFailures)
{
var failureDetails = concordionResult.FailureDetails.First();
testResult.Failure(resultPath + Environment.NewLine + failureDetails.Message, failureDetails.StackTrace);
} else
{
testResult.Success(resultPath);
}
return testResult;
}
private void AddToTestResults(IResultSummary singleResult, IResultRecorder resultSummary)
{
if (resultSummary == null) return;
if (singleResult.HasExceptions)
{
resultSummary.AddResultDetails(singleResult.ErrorDetails);
}
else if (singleResult.HasFailures)
{
resultSummary.AddResultDetails(singleResult.FailureDetails);
}
else
{
resultSummary.Success();
}
}
public ProcessingResult(IResultSummary resultSummary, EventRecorder eventRecorder, string documentXML)
{
this.resultSummary = resultSummary;
this.eventRecorder = eventRecorder;
this.documentXML = documentXML;
}
