public static async Task <TReturn> MapSingleAsync <TReturn>(
this IResultCursor resultCursor)
{
return((await resultCursor.SingleAsync().ConfigureAwait(false)).Map <TReturn>());
}
public static async Task <TReturn> MapSingleAsync <TValue1, TValue2, TValue3, TValue4, TValue5, TValue6, TValue7, TValue8, TValue9, TValue10, TValue11, TValue12, TValue13, TReturn>(
this IResultCursor resultCursor,
Func <TValue1, TValue2, TValue3, TValue4, TValue5, TValue6, TValue7, TValue8, TValue9, TValue10, TValue11, TValue12, TValue13, TReturn> mapFunc)
{
return((await resultCursor.SingleAsync().ConfigureAwait(false)).Map(mapFunc));
}
/// <summary>
/// Return the only record in the result stream.
/// </summary>
/// <param name="result">The result stream</param>
/// <returns>The only record in the result stream.</returns>
/// <remarks>Throws <exception cref="InvalidOperationException"></exception>
/// if the result contains more than one record or the result is empty.</remarks>
public static Task <IRecord> SingleAsync(this IResultCursor result)
{
return(SingleAsync(result, record => record));
}
public async Task PopulateRecords(IResultCursor cursor)
{
await cursor.ForEachAsync(record => Records.Add(record)).ConfigureAwait(false);
}
private async void CreateNodes(object sender, SelectionArgs e)
{
var control = _customTaskPane.Control as ExecuteQuery;
if (_connected == false)
{
ConnectDatabase(this, new ConnectDatabaseArgs {
ConnectionString = control.ConnectionString()
});
}
var session = _driver.AsyncSession();
try
{
var worksheet = ((Worksheet)Application.ActiveSheet);
var inputrange = e.SelectionRange;
control.progress.Report(0);
if (inputrange.Columns.Count <= 1)
{
CurrentControl.SetMessage("Select more than 1 column");
}
string[] properties = new string[inputrange.Columns.Count];
for (int i = 2; i <= inputrange.Columns.Count; i++)
{
try
{
properties[i - 2] = Convert.ToString(inputrange.Cells[1, i].Value2);
}
catch
{
properties[i - 2] = "property" + (i - 1).ToString();
}
}
for (int r = 2; r <= inputrange.Rows.Count; r++)
{
control.progress.Report(r / inputrange.Rows.Count * 100);
var row = inputrange.Rows[r];
var label = "";
try
{
label = row.Cells[1, 1].Value2.ToString();
}
catch
{
label = "NewExcelNode";
}
string cypher = "MERGE (a: " + label + " { ";
int i = 2;
{
string propval = Convert.ToString(row.Cells[1, i].Value2);
if (properties[i - 2].Length > 0 && propval.Length > 0)
{
cypher += "`" + properties[i - 2] + "`" + ": \"" + propval + "\",";
}
}
cypher = cypher.TrimEnd(',');
cypher += "})";
if (row.columns.count > 2)
{
cypher += " SET a += { ";
for (i = 3; i <= row.Columns.Count; i++)
{
string propval = Convert.ToString(row.Cells[1, i].Value2);
if (properties[i - 2] != null && propval != null)
{
if (properties[i - 2].Length > 0 && propval.Length > 0)
{
cypher += "`" + properties[i - 2] + "`" + ": \"" + propval + "\",";
}
}
}
cypher = cypher.TrimEnd(',');
cypher += "}";
}
try
{
IResultCursor cursor = await session.RunAsync(cypher);
var records = await cursor.ToListAsync();
var summary = await cursor.ConsumeAsync();
string message = summary.ToString();
if (r == inputrange.Rows.Count)
{
CurrentControl.SetMessage(message);
}
}
catch (Neo4jException ee)
{
CurrentControl.SetMessage(ee.Message);
}
}
await session.CloseAsync();
}
catch (Neo4jException ex)
{
CurrentControl.SetMessage(ex.Message);
}
}
private static async Task CreateCommandAsync(string command)
{
IResultCursor cursor = await _session.RunAsync(command);
await cursor.ConsumeAsync();
}
public RecordSet(IResultCursor cursor, BlockingExecutor executor)
{
_cursor = cursor;
_executor = executor;
}
private async void CreateRelationships(object sender, SelectionArgs e)
{
if (_connected == false)
{
var control = _customTaskPane.Control as ExecuteQuery;
ConnectDatabase(this, new ConnectDatabaseArgs {
ConnectionString = control.ConnectionString()
});
}
var session = _driver.AsyncSession();
try
{
var worksheet = ((Worksheet)Application.ActiveSheet);
var inputrange = e.SelectionRange;
if (inputrange.Columns.Count <= 1)
{
CurrentControl.SetMessage("Select 3 columns with nodes and relationship to create");
await session.CloseAsync();
return;
}
if (inputrange.Rows.Count <= 2)
{
CurrentControl.SetMessage("Select 2 header rows and 1 data row");
await session.CloseAsync();
return;
}
string label1 = Convert.ToString(inputrange.Cells[1, 1].Value2);
string label2 = Convert.ToString(inputrange.Cells[1, 2].Value2);
string relationshiptype = Convert.ToString(inputrange.Cells[1, 3].Value2);
if (label1.Length == 0 || label2.Length == 0 || relationshiptype.Length == 0)
{
CurrentControl.SetMessage("Labels and relationship type must not be empty");
await session.CloseAsync();
return;
}
string[] properties = new string[inputrange.Columns.Count];
for (int i = 1; i <= inputrange.Columns.Count; i++)
{
try
{
properties[i - 1] = Convert.ToString(inputrange.Cells[2, i].Value2);
}
catch
{
}
}
for (int r = 3; r <= inputrange.Rows.Count; r++)
{
var row = inputrange.Rows[r];
var input = inputrange;
string cypher = "MATCH (a: {0}),(b: {1} ) WHERE a.`{2}` = '{3}' and b.`{4}` = '{5}' MERGE (a)-[r:`{6}`]->(b) {7}";
string relprop = "";
if (properties.Length > 2)
{
relprop = "SET r += { ";
bool addcoma = false;
for (int p = 2; p < properties.Length; p++)
{
string propvalue = Convert.ToString(inputrange.Cells[r, p].Value2);
if (properties[p].Length > 0 && propvalue.Length > 0)
{
string prop = "`{0}`:\"{1}\"";
prop = String.Format(prop, properties[p], propvalue);
if (addcoma)
{
relprop += " , ";
}
addcoma = true;
relprop += prop;
}
}
relprop += " }";
if (relprop.Length == "SET r += { ".Length)
{
relprop = "";
}
}
string formatedcypher = String.Format(
cypher,
label1,
label2,
properties[0],
inputrange.Cells[r, 1].Value2.ToString(),
properties[1],
inputrange.Cells[r, 2].Value2.ToString(),
relationshiptype, relprop);
try
{
IResultCursor cursor = await session.RunAsync(formatedcypher);
var records = await cursor.ToListAsync();
var summary = await cursor.ConsumeAsync();
if (r == inputrange.Rows.Count)
{
string message = summary.ToString();
CurrentControl.SetMessage(message);
}
}
catch (Exception ex)
{
CurrentControl.SetMessage(ex.Message);
}
}
await session.CloseAsync();
}
catch (Neo4jException ex)
{
CurrentControl.SetMessage(ex.Message);
}
}
public static async Task <List <TReturn> > MapAsync <TReturn>(
this IResultCursor resultCursor)
{
return(await resultCursor.MapAsync(
record => record.Map <TReturn>()).ConfigureAwait(false));
}
/// <summary>
/// Gets a value from the <see cref="IResultCursor.Current" /> element. Throwing an exception if the
/// <paramref name="identifier" /> isn't there.
/// </summary>
/// <typeparam name="T">The <see cref="Type" /> to attempt to get the property as.</typeparam>
/// <param name="cursor">The <see cref="IResultCursor" /> instance to pull the property from.</param>
/// <param name="identifier">The name of the identifier to get.</param>
/// <returns>The converted <typeparamref name="T" /> or <c>default</c></returns>
/// <exception cref="NullReferenceException">
/// Thrown if the <paramref name="cursor" /> hasn't had
/// <see cref="IResultCursor.FetchAsync" /> called on it.
/// </exception>
public static T GetValueStrict <T>(this IResultCursor cursor, string identifier)
{
return(cursor.GetValueInternal <T>(identifier, true));
}
public async Task <IEnumerable <LiveDbObject <T> > > ReturnAsync()
{
internalQ.Append("WITH ");
for (int i = 0; i < PathCount; i++)
{
if (i > 0)
{
internalQ.Append(" + ");
}
internalQ.Append($"collect(p{i})");
}
internalQ.Append($" AS paths{Environment.NewLine}");
internalQ.Append($"UNWIND paths AS ret{Environment.NewLine}");
internalQ = internalQ.AppendLine("RETURN ret as json");
using (IDriver driver = clientFactory())
{
Query q = new Query(internalQ.ToString());
IResultCursor resultCursor = await driver.AsyncSession().RunAsync(q);
List <IRecord> results = await resultCursor.ToListAsync();
Dictionary <string, INeo4jNode> nodeHeap = new Dictionary <string, INeo4jNode>();
var raw = results.SelectMany(x =>
{
var h = x["json"].As <IPath>();
List <INeo4jNode> nodes = h.Nodes.Select(a =>
{
INeo4jNode parentInstance;
if (!nodeHeap.TryGetValue(a["Id"].ToString(), out parentInstance))
{
Type parentType = ReflectionCache.BuildType(a["__type__"].As <string>());
parentInstance = Activator.CreateInstance(parentType) as INeo4jNode;
ReflectionCache.Type typeData = ReflectionCache.GetTypeData(parentType);
foreach (KeyValuePair <string, object> k in a.Properties)
{
if (typeData.props.TryGetValue(k.Key, out ReflectionCache.Property prop))
{
prop.PushValue(parentInstance, DBOps.Neo4jDecode(k.Value, prop.info.PropertyType));
}
}
nodeHeap.Add(a["Id"].ToString(), parentInstance);
}
return(parentInstance);
}).ToList();
return(h.Relationships
.Select((x, i) => (nodes[i].Id, nodes[i + 1].Id, x.Type))
.Cast <(string parentID, string childID, string relationship)>());
}).ToList();
var withProps = raw.Select(x => (x.Item1, x.Item2,
ReflectionCache.GetTypeData(nodeHeap[x.Item1]).props
.Where(y =>
y.Key == x.Item3
||
(
y.Value.neo4JAttributes.Where(x => x is DbNameAttribute).Any()
&&
y.Value.neo4JAttributes.Select(x => x as DbNameAttribute).Where(x => x != null).FirstOrDefault()?.Name
==
x.Item3
)
)
.SingleOrDefault()
.Value
)).ToList();
var groupDedupe = withProps.GroupBy(x => x.Item1 + x.Item2).Select(x => x.First()).GroupBy(x => (x.Value, x.Item1));
foreach (var g in groupDedupe)
{
if (!g.Key.Value.isCollection)
{
var v = g.Single();
v.Item3.PushValue(nodeHeap[v.Item1], nodeHeap[v.Item2]);
}
else
{
System.Type t = g.Key.Value.info.PropertyType.GetGenericArguments()[0];
System.Type lstT = typeof(List <>).MakeGenericType(t);
ConstructorInfo cotr = lstT.GetConstructors().Where(x => x.GetParameters().Length == 0).Single();
Type enu = typeof(Enumerable);
MethodInfo selct = enu.GetMethods()
.Where(x => x.Name == "Select")
.OrderBy(x => x.GetParameters().Length)
.First()
.MakeGenericMethod(typeof(string), t);
MethodInfo toLst = enu.GetMethods()
.Where(x => x.Name == "ToList")
.OrderBy(x => x.GetParameters().Length)
.First()
.MakeGenericMethod(t);
Type ndhpTyp = nodeHeap.GetType();
ParameterExpression ndhp = Expression.Parameter(ndhpTyp, "ndhp");
ParameterExpression ky = Expression.Parameter(typeof(string), "ky");
var selExpr = Expression.Lambda(
Expression.Convert(Expression.Property(ndhp, "Item", ky), t),
ky
);
var expr = Expression.Lambda(
Expression.Call(
null,
toLst,
Expression.Call(
null,
selct,
Expression.Constant(g.Select(x => x.Item2)),
selExpr
)
),
ndhp
);
object psh = expr.Compile().DynamicInvoke(nodeHeap);
g.Key.Item1.PushValue(nodeHeap[g.Key.Item2],
psh);
}
}
var ret = nodeHeap
.Select(x => x.Value)
.Where(x => x is T)
.Cast <T>()
.Distinct()
.Select(x => LiveDbObject <T> .Build(x, clientFactory, LiveObjectMode.LiveWrite | LiveObjectMode.DeferedRead))
.ToArray();
return(ret);
}
}
public void SetupCypherRequestResponse(string request, IDictionary <string, object> cypherQueryQueryParameters, IResultCursor response)
{
MockSession.Setup(s => s.RunAsync(request, It.IsAny <IDictionary <string, object> >())).Returns(Task.FromResult(response));
var mockTransaction = new Mock <IAsyncTransaction>();
mockTransaction.Setup(s => s.RunAsync(request, It.IsAny <IDictionary <string, object> >())).Returns(Task.FromResult(response));
MockSession.Setup(s => s.WriteTransactionAsync(It.IsAny <Func <IAsyncTransaction, Task <List <IRecord> > > >()))
.Returns <Func <IAsyncTransaction, Task <List <IRecord> > > >(async param => await param(mockTransaction.Object));
MockSession.Setup(s => s.ReadTransactionAsync(It.IsAny <Func <IAsyncTransaction, Task <List <IRecord> > > >()))
.Returns <Func <IAsyncTransaction, Task <List <IRecord> > > >(async param => await param(mockTransaction.Object));
MockSession
.Setup(s => s.BeginTransactionAsync(It.IsAny <Action <TransactionConfigBuilder> >()))
.Returns(Task.FromResult(mockTransaction.Object));
MockSession
.Setup(s => s.BeginTransactionAsync())
.Returns(Task.FromResult(mockTransaction.Object));
}
public async Task <string> ProcessResults(IResultCursor cursor)
{
return(await ResultHandler(cursor));
}
