public async Task Should_Create_New_Actor_From_Entity_Parameter()
{
var person = new Person
{
born = 1962,
name = "Tom Cruise"
};
var parameters = new Neo4jParameters().WithEntity("actor", person);
try
{
await Session.RunAsync(@"CREATE (:Actor $actor)", parameters);
var cursor = await Session.RunAsync(@"
MATCH (actor:Actor)
RETURN actor");
var tomCruise = await cursor.MapSingleAsync <Person>();
Assert.AreEqual(1962, tomCruise.born);
Assert.AreEqual("Tom Cruise", tomCruise.name);
}
catch (Exception exception)
{
Assert.Fail(exception.Message);
}
finally
{
await Session.RunAsync(@"
MATCH (a:Actor)
DELETE a");
}
}
public async Task InserirNoAsync(string nome, string anilha, string sexo, string nomePopular, string nascimento)
{
session = _driver.AsyncSession(o => o.WithDatabase("neo4j"));//Nome da database está nas propriedades como padrão
string query = String.Empty;
if (sexo != string.Empty)
{
query += ",Sexo:" + "$sexo";
}
if (nomePopular != string.Empty)
{
query += ",NomePopular:" + "$nomePopular";
}
if (nascimento != string.Empty)
{
query += ",Nascimento:" + "$nascimento";
}
try {
if (anilha == string.Empty)
{
cursor = await session.RunAsync("CREATE (p:Passaro{nome:$nome" + query + "})", new { nome, sexo, nomePopular, nascimento });//MERGE Impede cadastro de mesmo nome
}
else
{
cursor = await session.RunAsync("CREATE (p:Passaro{nome:$nome, anilha:$anilha" + query + "})", new { nome, anilha, sexo, nomePopular, nascimento });
}
await cursor.ConsumeAsync();
}
finally {
await session.CloseAsync();
}
}
public async void Dispose()
{
await _session.RunAsync("MATCH (u:TestUser) DETACH DELETE u");
await _session.RunAsync("MATCH (r:TestRole) DETACH DELETE r");
await _session.CloseAsync();
_driver.Dispose();
}
public async Task ShouldShowMessage(string message)
{
var query = await session.RunAsync(
"CREATE (a:Greeting {message: $message}) " +
"RETURN a.message + ', from node ' + id(a)",
new { message });
var result = await query.SingleAsync();
result[0].As <string>().ShouldStartWith(message);
}
public async Task Setup()
{
driver = GraphDatabase.Driver("bolt://localhost:7687");
session = driver.AsyncSession();
await session.RunAsync("MATCH (m:Movie) DETACH DELETE m ");
await session.RunAsync("MATCH (p:Person) DETACH DELETE p ");
await session.RunAsync("MATCH (a:Greeting) DELETE a ");
}
// ############
// RETURN TWO LIST<STRING>
// ############
async void MultipleReturnsTest()
{
// Each IDriver instance maintains a pool of connections inside, as a result, it is recommended to only use one driver per application.
// The driver is thread-safe, while the session or the transaction is not thread-safe.
IDriver driver = GraphDatabase.Driver("neo4j://localhost:7687", AuthTokens.Basic("neo4j", "123456"));
IAsyncSession session = driver.AsyncSession(o => o.WithDatabase("neo4j"));
try
{
IResultCursor cursor = await session.RunAsync("MATCH (a:Person) RETURN a.name, a.born");
// A record is accessible once it is received by the client. It is not needed for the whole result set to be received before it can be visited.
// Each record can only be visited (a.k.a.consumed) once!
// The recommended way to access these result records is to make use of methods provided by ResultCursorExtensions such as SingleAsync,
// ToListAsync, and ForEachAsync.
List <DataHolder> people = await cursor.ToListAsync(record => new DataHolder(record["a.name"].As <string>(), record["a.born"].As <string>()));
await cursor.ConsumeAsync();
foreach (var item in people)
{
Debug.Log(item.ToString());
}
}
finally
{
await session.CloseAsync();
}
await driver.CloseAsync();
}
// ############
// RETURN SINGLE NODE
// ############
async void SingleNodeLabelsTest()
{
// Each IDriver instance maintains a pool of connections inside, as a result, it is recommended to only use one driver per application.
// The driver is thread-safe, while the session or the transaction is not thread-safe.
IDriver driver = GraphDatabase.Driver("neo4j://localhost:7687", AuthTokens.Basic("neo4j", "123456"));
IAsyncSession session = driver.AsyncSession(o => o.WithDatabase("neo4j"));
try
{
IResultCursor cursor = await session.RunAsync("MATCH (a {name: 'Joel Silver'}) RETURN a");
// The recommended way to access these result records is to make use of methods provided by ResultCursorExtensions such as SingleAsync,
// ToListAsync, and ForEachAsync.
INode person = await cursor.SingleAsync(record => record["a"].As <INode>());
await cursor.ConsumeAsync();
foreach (var item in person.Labels)
{
Debug.Log(item);
}
}
finally
{
await session.CloseAsync();
}
await driver.CloseAsync();
}
// ############
// RETURN SINGLE LIST<STRING>
// ############
async void SingleReturnTest()
{
// Each IDriver instance maintains a pool of connections inside, as a result, it is recommended to only use one driver per application.
// The driver is thread-safe, while the session or the transaction is not thread-safe.
IDriver driver = GraphDatabase.Driver("neo4j://localhost:7687", AuthTokens.Basic("neo4j", "123456"));
IAsyncSession session = driver.AsyncSession(o => o.WithDatabase("neo4j"));
try
{
IResultCursor cursor = await session.RunAsync("MATCH (a:Person) RETURN a.name as name");
// The recommended way to access these result records is to make use of methods provided by ResultCursorExtensions such as SingleAsync,
// ToListAsync, and ForEachAsync.
List <string> people = await cursor.ToListAsync(record => record["name"].As <string>());
await cursor.ConsumeAsync();
Debug.Log(people.Count + " single returns");
}
finally
{
await session.CloseAsync();
}
await driver.CloseAsync();
}
private async Task mnu_ClickAsync(object sender, RoutedEventArgs e)
{
IDriver driver = GraphDatabase.Driver("neo4j://localhost:7687", AuthTokens.Basic("neo4j", "neo4j"));
IAsyncSession session = driver.AsyncSession(o => o.WithDatabase("neo4j"));
try
{
IResultCursor cursor = await session.RunAsync("CREATE (n) RETURN n");
await cursor.ConsumeAsync();
}
finally
{
await session.CloseAsync();
}
await driver.CloseAsync();
///https://stackoverflow.com/questions/59581789/why-does-idriver-not-contain-a-definition-for-session-when-using-neo4j-in-c
///test
/*[TestClass]
* {
* [TestMethod]
* {
* System.Console.WriteLine();
* }
* }*/
}
public async void CreateActor()
{
// arrange
IAsyncSession session = _neo4JResource.GetAsyncSession();
try
{
// act
var actor = new Actor("Keanu Reaves", 56);
IDictionary <string, object> parameters =
new Neo4jParameters().WithEntity("newActor", actor);
IResultCursor cursor = await session.RunAsync(
@"CREATE (actor:Actor $newActor) RETURN actor",
parameters);
Actor createdActor = await cursor.MapSingleAsync <Actor>();
await cursor.ConsumeAsync();
// assert
createdActor.MatchSnapshot();
}
finally
{
await session.CloseAsync();
}
}
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 async Task <List <Room> > GetRooms()
{
_logger.LogInformation("starting query");
var rooms = new List <Room>();
var cursor = await _graphClient.RunAsync("MATCH (a:Room) RETURN a");
var records = await cursor.ToListAsync();
foreach (var record in records)
{
var nodeProps = JsonSerializer.Serialize(record[0].As <INode>().Properties);
rooms.Add(JsonSerializer.Deserialize <Room>(nodeProps));
}
return(rooms);
}
// Get all records as a List
public async Task <List <T> > FetchRecords <T>(
Func <IRecord, T> recordProcessor,
string cypherQuery,
object queryParams = null)
{
List <T> result = null;
IAsyncSession session = _driver.AsyncSession(o => o.WithDatabase(this._database));
_logger.LogDebug($"Executing query: {cypherQuery}");
if (queryParams == null)
{
queryParams = new {};
}
try
{
IResultCursor resultCursor = await session.RunAsync(cypherQuery, queryParams);
result = await resultCursor.ToListAsync(record => recordProcessor(record));
_logger.LogDebug("Query executed successfully");
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error executing query. {ex.Message}");
throw;
}
finally
{
await session.CloseAsync();
}
return(result);
}
public async Task UpsertNodes <T>(IEnumerable <T> nodes, IEnumerable <string> indices = null)
{
IAsyncSession session = AsyncSession();
string objectName = typeof(T).Name.ToLowerInvariant();
string key = null;
try
{
if (!indices.IsNullOrEmpty())
{
key = indices.Select(_ => $"{{{_}:{objectName}.{_}}}").FirstOrDefault();
foreach (var query in indices.Select(_ => $"INDEX ON :{objectName}({_})"))
{
ICypherBuilder cypherBuilder = _cypherBuilderFactory.NewCypherBuilder().AddCreate(query);
await session.RunAsync(cypherBuilder.ToString());
}
}
string cypher = UpsertNodesCypher <T>(key);
await session.WriteTransactionAsync(tx => RunCypher(tx, cypher, new Dictionary <string, object>()
{
{ "nodes", nodes.ToDictionaries() }
}));
}
finally
{
await session.CloseAsync();
}
}
private static async Task <Response> RunQueryAsync(IAsyncSession session, PlanType planType, Dictionary <string, object> parameters)
{
var query = GetQuery(planType);
var result = await(await session.RunAsync(query, parameters)).ToListAsync();
var plan = result
.Select(r =>
r["nodes"]
.As <List <INode> >()
.Select(n => FormatNode(n))
.ToList())
.FirstOrDefault();
var markers = result
.Select(r =>
r["nodes"]
.As <List <INode> >()
.Where(n => n.Labels.Contains("Stop"))
.Select(n => n["location"].As <Point>())
.Select(p => new LatLng(p.Y, p.X))
.ToArray())
.FirstOrDefault();
if (plan == null)
{
return(null);
}
FormatPlan(plan, planType);
return(new Response(plan.ToArray(), markers));
}
public async Task <T> ExecuteScalar <T>(string cypherQuery, object queryParams = null)
{
T result = default(T);
IAsyncSession session = _driver.AsyncSession(o => o.WithDatabase(this._database));
_logger.LogDebug($"Executing query: {cypherQuery}");
if (queryParams == null)
{
queryParams = new {};
}
try
{
IResultCursor resultCursor = await session.RunAsync(cypherQuery, queryParams);
IRecord record = await resultCursor.SingleAsync();
result = record[0].As <T>();
_logger.LogDebug("Query executed successfully");
}
catch (Exception ex)
{
_logger.LogError(ex, $"Error executing query. {ex.Message}");
throw;
}
finally
{
await session.CloseAsync();
}
return(result);
}
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();
}
}
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();
}
}
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();
}
}
public static async Task <TEntity> GetNodeAsync <TEntity>(
this IAsyncSession asyncSession,
long nodeId) where TEntity : class
{
var parameters = new Neo4jParameters()
.WithValue("p1", nodeId);
var resultCursor = await asyncSession.RunAsync(Constants.Statement.GetNode, parameters)
.ConfigureAwait(false);
return(await resultCursor.MapSingleAsync <TEntity>().ConfigureAwait(false));
}
private static Task <IResultCursor> ExecuteQuery(IAsyncSession session, string cypher)
{
try
{
return(session.RunAsync(cypher));
}
catch (Neo4jException ex)
{
Console.WriteLine("\tError!");
Console.WriteLine($"\t{ex}");
throw;
}
}
public async Task CriarUniqueAsync()
{
session = _driver.AsyncSession(o => o.WithDatabase("neo4j"));//Nome da database está nas propriedades como padrão
try {
cursor = await session.RunAsync("CREATE CONSTRAINT anilhaC ON (p:Passaro) ASSERT p.anilha IS UNIQUE");
await cursor.ConsumeAsync();
}
finally {
await session.CloseAsync();
}
}
public async Task <IRequestExecutor> CreateSchema()
{
IAsyncSession session = GetAsyncSession();
IResultCursor cursor = await session.RunAsync(seedCypher);
await cursor.ConsumeAsync();
return(await new ServiceCollection()
.AddSingleton(Driver)
.AddGraphQL()
.AddQueryType()
.AddMovieTypes()
.Services
.BuildServiceProvider()
.GetRequiredService <IRequestExecutorResolver>()
.GetRequestExecutorAsync());
}
// Get records as a stream of buffered List
public async IAsyncEnumerable <List <T> > FetchRecordsAsStream <T>(
Func <IRecord, T> recordProcessor,
string cypherQuery, object queryParams = null,
long bufferSize = 100)
{
long recordsProcessed = 0;
List <T> resultBuffer = new List <T>();
IAsyncSession session = _driver.AsyncSession(o => o.WithDatabase(this._database));
_logger.LogDebug($"Executing query: {cypherQuery}");
if (queryParams == null)
{
queryParams = new {};
}
try
{
IResultCursor resultCursor = await session.RunAsync(cypherQuery, queryParams);
_logger.LogDebug("Reading cursor");
while (await resultCursor.FetchAsync())
{
recordsProcessed += 1;
resultBuffer.Add(recordProcessor(resultCursor.Current));
if (resultBuffer.Count >= bufferSize)
{
_logger.LogDebug($"Records processed: {recordsProcessed} ...");
yield return(resultBuffer);
resultBuffer.Clear();
}
}
_logger.LogDebug($"* Total records processed: {recordsProcessed} *");
yield return(resultBuffer);
}
finally
{
await session.CloseAsync();
}
}
public static async Task <IResultCursor> SetNodeAsync <TEntity>(
this IAsyncSession asyncSession,
TEntity entity) where TEntity : class
{
var nodeId = EntityAccessor.GetNodeId(entity);
if (nodeId == null)
{
throw new InvalidOperationException(Constants.NodeIdUnspecifiedMessage);
}
var parameters = new Neo4jParameters()
.WithValue("p1", nodeId)
.WithEntity("p2", entity);
return(await asyncSession.RunAsync(Constants.Statement.SetNode, parameters)
.ConfigureAwait(false));
}
public async Task <ActionResult> Get()
{
IResultCursor cursor;
var types = new List <string>();
IAsyncSession session = _driver.AsyncSession();
try
{
cursor = await session.RunAsync(@"MATCH (t:Type) RETURN t.name AS name");
types = await cursor.ToListAsync(record => record["name"].As <string>());
}
finally
{
await session.CloseAsync();
}
return(Ok(types));
}
//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();
}
}
public async Task <IRequestExecutor> CreateSchema()
{
IAsyncSession session = GetAsyncSession();
IResultCursor cursor = await session.RunAsync(seedCypher);
await cursor.ConsumeAsync();
return(await new ServiceCollection()
.AddSingleton(Driver)
.AddGraphQL()
.AddQueryType(d => d.Name("Query"))
.AddType <Queries>()
.AddNeo4JProjections()
.AddNeo4JFiltering()
.AddNeo4JSorting()
.UseDefaultPipeline()
.Services
.BuildServiceProvider()
.GetRequiredService <IRequestExecutorResolver>()
.GetRequestExecutorAsync());
}
public static Task<IResultCursor> Run(this IAsyncSession session, CypherQuery query, IGraphClient gc)
{
return session.RunAsync(query.QueryText, query.ToNeo4jDriverParameters(gc));
}
/// <inheritdoc />
public async ValueTask <IList> ToListAsync(CancellationToken cancellationToken)
{
IResultCursor cursor = await _session.RunAsync(Pipeline().Build());
return(await cursor.MapAsync <T>().ConfigureAwait(false));
}