public NodeReference Visit(Type type)
{
const BindingFlags bindingFlags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;
var classNode = _graphClient.Create(new Nodes.Interface
{
Id = type.Name,
Name = type.Name
});
var propertyVisitor = new PropertyVisitor(_graphClient);
foreach (var propertyNode in type.GetProperties(bindingFlags).Select(propertyVisitor.Visit))
{
_graphClient.CreateRelationship(classNode, new InterfaceContainsProperty(propertyNode));
}
var methodVisitor = new MethodVisitor(_graphClient);
foreach (var methodNode in type.GetMethods(bindingFlags).Select(methodVisitor.Visit))
{
_graphClient.CreateRelationship(classNode, new InterfaceContainsMethod(methodNode));
}
return(classNode);
}
public NodeReference Visit(Type type)
{
const BindingFlags bindingFlags = BindingFlags.DeclaredOnly | BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance | BindingFlags.Static;
Console.WriteLine("Discovered class {0}", type.FullName);
var classNode = _graphClient.Create(new Nodes.Class
{
Id = type.FullName,
Name = type.FullName
});
var propertyVisitor = new PropertyVisitor(_graphClient);
foreach (var propertyNode in type.GetProperties(bindingFlags).Select(propertyVisitor.Visit))
{
_graphClient.CreateRelationship(classNode, new ClassContainsProperty(propertyNode));
}
var fieldVisitor = new FieldVisitor(_graphClient);
foreach (var fieldNode in type.GetFields(bindingFlags).Select(fieldVisitor.Visit))
{
_graphClient.CreateRelationship(classNode, new ClassContainsField(fieldNode));
}
var methodVisitor = new MethodVisitor(_graphClient);
foreach (var methodNode in type.GetMethods(bindingFlags).Select(methodVisitor.Visit))
{
_graphClient.CreateRelationship(classNode, new ClassContainsMethod(methodNode));
}
return(classNode);
}
public Comment AddCommentToSession(Session session, int id, Comment comment)
{
var client = new GraphClient(new Uri("http://localhost:7474/db/data"));
client.Connect();
var result = client.Cypher.Create("(c:Comment {comm})")
.WithParams(new { comm = comment })
.Return(c => c.Node <Comment>())
.Results
.Single();
client.Connect();
var userNode =
client.Cypher.Match("(u:User)").Where((User u) => u.ProviderUserKey == id).Return(u => u.Node <User>())
.Results.Single();
client.CreateRelationship(result.Reference, new CreatedByRelationship(userNode.Reference));
client.Connect();
var sessionNode = client.Cypher.Start(new { s = string.Format("node({0})", session.Id) })
.Match("(s)")
.Return(s => s.Node <Session>()).Results.Single();
client.CreateRelationship(result.Reference, new OnSession(sessionNode.Reference));
result.Data.Id = (int)result.Reference.Id;
result.Data.MadeBy = userNode.Data.AsType <UserInfo>();
result.Data.MadeBy.NodeId = (int)result.Data.MadeBy.ProviderUserKey;
return(result.Data);
}
public void Visit(Node <Nodes.Database> databaseNode, TSqlObject view)
{
var viewNode = GetViewNode(databaseNode, view);
foreach (var table in view.GetReferenced().Where(x => x.ObjectType == ModelSchema.Table))
{
try
{
var tableNode = GetTableNode(databaseNode, table);
if ((viewNode == null) || (tableNode == null))
{
continue;
}
if (RelationshipExists(viewNode.Reference, tableNode.Reference))
{
continue;
}
Console.WriteLine("Creating dependency between view {0} and table {1}", viewNode.Data.Id, tableNode.Data.Id);
_graphClient.CreateRelationship(viewNode.Reference, new ViewReferencesTable(tableNode.Reference));
}
catch (Exception ex)
{
Console.WriteLine("Error analyzing {0}: {1}", view.Name.ToString(), ex);
}
}
foreach (var column in view.GetReferenced().Where(x => x.ObjectType == ModelSchema.Column))
{
try
{
var columnNode = GetColumnNode(databaseNode, column);
if ((viewNode == null) || (columnNode == null))
{
continue;
}
if (RelationshipExists(viewNode.Reference, columnNode.Reference))
{
continue;
}
Console.WriteLine("Creating dependency between stored procedure {0} and column {1}", viewNode.Data.Id, columnNode.Data.Id);
_graphClient.CreateRelationship(viewNode.Reference, new ViewReferencesColumn(columnNode.Reference));
}
catch (Exception ex)
{
Console.WriteLine("Error analyzing {0}: {1}", view.Name.ToString(), ex);
}
}
}
static void Main(string[] args)
{
try
{
GraphClient client = new GraphClient(new Uri("http://localhost:7474/db/data"));
client.Connect();
// Create nodes and relationship
MyNode node1 = new MyNode()
{
Name = "Test 1"
};
MyNode node2 = new MyNode()
{
Name = "Test 2"
};
NodeReference <MyNode> node1ref = client.Create <MyNode>(node1);
NodeReference <MyNode> node2ref = client.Create <MyNode>(node2);
MyRelationShip rel12 = new MyRelationShip(node2ref);
var Rel1 = client.CreateRelationship <MyNode, MyRelationShip>(node1ref, rel12);
MyNode node3 = new MyNode()
{
Name = "Test 3"
};
NodeReference <MyNode> node3ref = client.Create <MyNode>(node3);
MyRelationShip rel13 = new MyRelationShip(node3ref);
var Rel13 = client.CreateRelationship <MyNode, MyRelationShip>(node1ref, rel13);
var query = client.Cypher.Start(new { n1 = node1ref })
.Match("n1-[:MYRELATIONSHIP]->targetnode")
.Return <MyNode>(targetnode => targetnode.As <MyNode>());
var res = query.Results;
int i = 0;
foreach (MyNode n in res)
{
i++;
Console.WriteLine(i + ". Name: '" + n.Name + "'");
}
}
catch (NeoException ex)
{
Console.WriteLine(ex.ToString());
}
Console.ReadKey();
}
static void Main(string[] args)
{
var arguments = new Dictionary <string, string>();
for (var index = 0; index < args.Length; index = index + 2)
{
arguments.Add(args[index].Substring(1), args[index + 1]);
}
GraphClient.Connect();
if (arguments.ContainsKey("dacpac"))
{
var databaseVisitor = new DatabaseVisitor(GraphClient);
var databaseServerNode = GetDatabaseServerNode(arguments["server"]);
GraphClient.CreateRelationship(databaseServerNode, new DatabaseServerContainsDatabase(databaseVisitor.Visit(arguments["dacpac"])));
}
else if (arguments.ContainsKey("dacpac-references"))
{
var storedProcedureDependencyVisitor = new StoredProcedureDependencyVisitor(GraphClient);
storedProcedureDependencyVisitor.Visit(arguments["dacpac-references"]);
var viewDependencyVisitor = new ViewDependencyVisitor(GraphClient);
viewDependencyVisitor.Visit(arguments["dacpac-references"]);
}
else if (arguments.ContainsKey("assembly"))
{
var assemblyVisitor = new AssemblyVisitor(GraphClient);
GraphClient.CreateRelationship(GraphClient.RootNode, new RootContainsAssembly(assemblyVisitor.Visit(arguments["assembly"])));
}
else if (arguments.ContainsKey("reports"))
{
var reportVisitor = new ReportVisitor(GraphClient);
var reportServerNode = GetReportServerNode(arguments["server"]);
var directory = new DirectoryInfo(arguments["reports"]);
foreach (var report in directory.EnumerateFiles("*.rdl"))
{
GraphClient.CreateRelationship(reportServerNode, new ReportServerContainsReport(reportVisitor.Visit(report.FullName)));
}
}
else if (arguments.ContainsKey("dotnet"))
{
var projectVisitor = new DotNetProjectVisitor(GraphClient);
projectVisitor.Visit(arguments["dotnet"]);
}
}
static void Main(string[] args)
{
try{
GraphClient client = new GraphClient(new Uri("http://localhost:7474/db/data"));
client.Connect();
Us us = new Us { Name = "We are Us" };
NodeReference<Us> usRef = client.Create(us);
Console.WriteLine("us node.id: {0}", usRef.Id);
var queryUs = client.Cypher.Start("n", "node(" + usRef.Id + ")").Return<Node<Us>>("n");
Console.WriteLine("Us node name: {0}\n", queryUs.Results.AsEnumerable<Node<Us>>().First().Data);
AllYourBase allYourBase = new AllYourBase { Name = "We are all your base" };
NodeReference<AllYourBase> allYourBaseRef = client.Create(allYourBase);
Console.WriteLine("AllYourBase node.id: {0}",allYourBaseRef.Id);
var queryAllYourBase = client.Cypher.Start("n", "node(" + allYourBaseRef.Id + ")").Return<Node<AllYourBase>>("n");
Console.WriteLine("AllYourBase node name: {0}\n", queryAllYourBase.Results.AsEnumerable<Node<AllYourBase>>().First().Data);
RelationshipReference areBelongToRef = client.CreateRelationship(allYourBaseRef, new AreBelongTo(usRef));
var query = client.Cypher.Start("allyourbase", "node(" + allYourBaseRef.Id + ")").Match("allyourbase-[:ARE_BELONG_TO]->us").Return<Node<AllYourBase>>("allyourbase");
query.ExecuteWithoutResults();
Console.WriteLine("Result of querying for all your base that belongs to us: {0}", query.Results.AsEnumerable<Node<AllYourBase>>().First().Data.Name);
}
catch(Exception ex)
{
Console.WriteLine("{0}", ex.Message);
Console.WriteLine("{0}", ex.InnerException);
}
Console.ReadKey();
}
private void CreateAssemblyReferencesAssemblyRelationship(Assembly source, AssemblyName target)
{
var sourceNode = GetAssemblyNode(source);
var targetNode = GetAssemblyNode(target);
if ((sourceNode != null) && (targetNode != null))
{
_graphClient.CreateRelationship(sourceNode.Reference, new AssemblyReferencesAssembly(targetNode.Reference));
}
}
private void CreateMethodInvokesMethodRelationship(ISymbol source, ISymbol target)
{
var sourceNode = GetMethodNode(source);
var targetNode = GetMethodNode(target);
if ((sourceNode != null) && (targetNode != null))
{
Console.WriteLine("Discovered dependendency between {0} and {1}", sourceNode.Data.Id, targetNode.Data.Id);
_graphClient.CreateRelationship(sourceNode.Reference, new MethodInvokesMethod(targetNode.Reference));
}
}
private void EnsureRelationshipInDb(Node <Actor> actor, Node <Character> character, GraphClient db)
{
var rel = actor
.Out <Character>(ActorPlayed.TypeKey, i => i.CharacterName == character.Data.CharacterName)
.InE()
.FirstOrDefault();
if (rel == null)
{
db.CreateRelationship <Actor, ActorPlayed>(actor.Reference, new ActorPlayed(character.Reference));
}
}
public NodeReference Visit(string databasePackagePath)
{
var databaseNode = _graphClient.Create(new Nodes.Database
{
Id = Path.GetFileNameWithoutExtension(databasePackagePath),
Name = Path.GetFileNameWithoutExtension(databasePackagePath)
});
var model = new TSqlModel(databasePackagePath);
var tableVisitor = new TableVisitor(_graphClient);
foreach (var tableNode in model.GetObjects(DacQueryScopes.All, ModelSchema.Table).Select(tableVisitor.Visit))
{
_graphClient.CreateRelationship(databaseNode, new DatabaseContainsTable(tableNode));
}
var storedProcedureVisitor = new StoredProcedureVisitor(_graphClient);
foreach (var storedProcedureNode in model.GetObjects(DacQueryScopes.All, ModelSchema.Procedure).Select(storedProcedureVisitor.Visit))
{
_graphClient.CreateRelationship(databaseNode, new DatabaseContainsStoredProcedure(storedProcedureNode));
}
var viewVisitor = new ViewVisitor(_graphClient);
foreach (var viewNode in model.GetObjects(DacQueryScopes.All, ModelSchema.View).Select(viewVisitor.Visit))
{
_graphClient.CreateRelationship(databaseNode, new DatabaseContainsView(viewNode));
}
var userDefinedFunctionVisitor = new UserDefinedFunctionVisitor(_graphClient);
foreach (var userDefinedFunctionNode in model.GetObjects(DacQueryScopes.All, ModelSchema.TableValuedFunction, ModelSchema.ScalarFunction).Select(userDefinedFunctionVisitor.Visit))
{
_graphClient.CreateRelationship(databaseNode, new DatabaseContainsUserDefinedFunction(userDefinedFunctionNode));
}
return(databaseNode);
}
private void CreateMethodInvokesStoredProcedureRelationship(ISymbol source, string target)
{
var sourceNode = GetMethodNode(source);
var targetNode = GetStoredProcedureNode(target);
if ((sourceNode == null) || (targetNode == null))
{
return;
}
Console.WriteLine("Discovered dependendency between {0} and {1}", sourceNode.Data.Id, targetNode.Data.Id);
_graphClient.CreateRelationship(sourceNode.Reference, new MethodInvokesStoredProcedure(targetNode.Reference));
}
public NodeReference Visit(Assembly assembly)
{
Console.WriteLine("Discovered assembly {0}", assembly.FullName);
var assemblyNode = _graphClient.Create(new Nodes.Assembly
{
Id = assembly.FullName,
Name = assembly.GetName().Name
});
Type[] types;
try
{
types = assembly.GetTypes();
}
catch (ReflectionTypeLoadException ex)
{
types = ex.Types;
}
var classVisitor = new ClassVisitor(_graphClient);
foreach (var classNode in types.Where(x => x != null && x.IsClass).Select(classVisitor.Visit))
{
_graphClient.CreateRelationship(assemblyNode, new AssemblyContainsClass(classNode));
}
var interfaceVisitor = new InterfaceVisitor(_graphClient);
foreach (var interfaceNode in types.Where(x => x != null && x.IsInterface).Select(interfaceVisitor.Visit))
{
_graphClient.CreateRelationship(assemblyNode, new AssemblyContainsInterface(interfaceNode));
}
return(assemblyNode);
}
public void LikeSession(Session session, int id)
{
var client = new GraphClient(new Uri("http://localhost:7474/db/data"));
client.Connect();
var createdSession = client.Cypher.Match("(s:Session)")
.Where((Session s) => s.Id == session.Id).Return(s => s.Node <Session>())
.Results.Single();
client.Connect();
var userNode =
client.Cypher.Match("(u:User)").Where((User u) => u.ProviderUserKey == id).Return(u => u.Node <User>())
.Results.Single();
client.CreateRelationship(createdSession.Reference, new LikedBy(userNode.Reference));
}
public NodeReference Visit(TSqlObject table)
{
Console.WriteLine("Discovered table {0}", table.Name);
var tableNode = _graphClient.Create(new Nodes.Table
{
Id = table.Name.ToString(),
Name = table.Name.ToString()
});
var columnVisitor = new ColumnVisitor(_graphClient);
foreach (var columnNode in table.GetChildren().Where(x => x.ObjectType == ModelSchema.Column).Select(columnVisitor.Visit))
{
_graphClient.CreateRelationship(tableNode, new TableContainsColumn(columnNode));
}
return(tableNode);
}
public void AddSession(Session s, long userKey)
{
var client = new GraphClient(new Uri("http://localhost:7474/db/data"));
var sess = s;
client.Connect();
var createdSession = client.Cypher.Create("(session:Session {session})")
.WithParams(new { session = sess })
.Return(session => session.Node <Session>())
.Results
.Single();
client.Connect();
var userNode =
client.Cypher.Match("(u:User)").Where((User u) => u.ProviderUserKey == userKey).Return(u => u.Node <User>())
.Results.Single();
client.CreateRelationship(createdSession.Reference, new CreatedByRelationship(userNode.Reference));
}
public NodeReference Visit(string path)
{
var reportNode = _graphClient.Create(new Report
{
Id = Path.GetFileNameWithoutExtension(path),
Name = Path.GetFileNameWithoutExtension(path)
});
var root = XDocument.Load(path);
var storedProcedureNames = root
.Descendants("{http://schemas.microsoft.com/sqlserver/reporting/2008/01/reportdefinition}Query")
.Where(x => (string)x.Element("{http://schemas.microsoft.com/sqlserver/reporting/2008/01/reportdefinition}CommandType") == "StoredProcedure")
.Select(x => (string)x.Element("{http://schemas.microsoft.com/sqlserver/reporting/2008/01/reportdefinition}CommandText"));
foreach (var storedProcedureName in storedProcedureNames)
{
var fullyQualifiedStoredProcedureName = string.Format("[dbo].[{0}]", storedProcedureName);
var storedProcedureQuery = _graphClient.Cypher
.Start(new { root = _graphClient.RootNode })
.Match("root-[:ROOT_CONTAINS_DATABASESERVER]->databaseServer-[:DATABASESERVER_CONTAINS_DATABASE]->database-[:DATABASE_CONTAINS_STOREDPROCEDURE]->storedprocedure")
.Where((StoredProcedure storedprocedure) => storedprocedure.Id == fullyQualifiedStoredProcedureName)
.Return <Node <StoredProcedure> >("storedprocedure");
var results = storedProcedureQuery.Results.ToList();
if (results.Count == 1)
{
_graphClient.CreateRelationship(reportNode, new ReportInvokesStoredProcedure(results.First().Reference));
}
}
return(reportNode);
}
public void ShouldThrowInvalidOperationExceptionIfNotConnected()
{
var client = new GraphClient(new Uri("http://foo"));
client.CreateRelationship(new NodeReference <TestNode>(5), new TestRelationship(10));
}
public void ShouldThrowArgumentNullExceptionForNullNodeReference()
{
var client = new GraphClient(new Uri("http://foo"));
client.CreateRelationship((NodeReference <TestNode>)null, new TestRelationship(10));
}
private static void CreateSampleDataShunLan()
{
// Create entities
var ShunLan = client.Create(new Person()
{
Name = "ShunLan"
});
var BillyHub = client.Create(new Person()
{
Name = "BillyHub"
});
var BobbySon = client.Create(new Person()
{
Name = "BobbySon"
});
var autoPolicyA = client.Create(new Policy()
{
PolicyNumber = "AutoPolicy A"
});
// var cyclePolicyA = client.Create(new Policy() { PolicyNumber = "Cycle Policy B" });
var homePolicyA = client.Create(new Policy()
{
PolicyNumber = "Home Policy A"
});
var veh1 = client.Create(new Vehicle()
{
MakeModel = "Honda 1", Id = "111"
});
var veh2 = client.Create(new Vehicle()
{
MakeModel = "Subaru 2", Id = "222"
});
var veh3 = client.Create(new Vehicle()
{
MakeModel = "MG 3", Id = "333"
});
var home = client.Create(new Home()
{
HomeAddress = "1 GEICO Plaza", Id = "12345"
});
// ShunLan is Spouse of BillyHub
client.CreateRelationship(ShunLan, new IsSpouseRelationship(BillyHub));
// BobbySon child of ShunLan
client.CreateRelationship(BobbySon, new IsChildRelationship(ShunLan));
// BobbySon child of BillyHub
client.CreateRelationship(BobbySon, new IsChildRelationship(BillyHub));
// ShunLan is NIN on Auto Policy A
client.CreateRelationship(ShunLan, new NamedInsuredRelationship(autoPolicyA, new NamedInsuredData("Named Insured Data")));
// BillyHub is SIN on Auto Policy A
client.CreateRelationship(BillyHub, new SecondaryInsuredRelationship(autoPolicyA));
//PolicyA has 3 Operators. THis doesn't mean they actually drive all the cars.
client.CreateRelationship(ShunLan, new OperatorRelationship(autoPolicyA));
client.CreateRelationship(BillyHub, new OperatorRelationship(autoPolicyA));
client.CreateRelationship(BobbySon, new OperatorRelationship(autoPolicyA));
//BillyHub Owns Veh 1 and Veh 3
client.CreateRelationship(BillyHub, new OwnerRelationship(veh1));
client.CreateRelationship(BillyHub, new OwnerRelationship(veh3));
//ShunLan Owns Veh 2
client.CreateRelationship(ShunLan, new OwnerRelationship(veh2));
//BillyHub Drives Vehicle 1
client.CreateRelationship(BillyHub, new PolicyDriverRelationship(veh1));
//ShunLan Drives Veh 2
client.CreateRelationship(ShunLan, new PolicyDriverRelationship(veh2));
//BobbySon Drives Veh 3
client.CreateRelationship(BobbySon, new PolicyDriverRelationship(veh3));
//ShunLan Owns Home
client.CreateRelationship(ShunLan, new OwnerRelationship(home));
//BillyHub Owns Home as well
client.CreateRelationship(BillyHub, new OwnerRelationship(home));
// ShunLan Has a home Policy
client.CreateRelationship(ShunLan, new NamedInsuredRelationship(homePolicyA, new NamedInsuredData("sdajklf")));
// PolicyA insures Veh1, Veh2, and Veh3
client.CreateRelationship(autoPolicyA, new InsuresRelationship(veh1));
client.CreateRelationship(autoPolicyA, new InsuresRelationship(veh2));
client.CreateRelationship(autoPolicyA, new InsuresRelationship(veh3));
// HomePolicy insures Home
client.CreateRelationship(homePolicyA, new InsuresRelationship(home));
}
public void Visit(Node <Nodes.Database> databaseNode, TSqlObject storedProcedure)
{
var storedProcedureNode = GetStoredProcedureNode(databaseNode, storedProcedure);
foreach (var table in storedProcedure.GetReferenced().Where(x => x.ObjectType == ModelSchema.Table))
{
try
{
var tableNode = GetTableNode(databaseNode, table);
if ((storedProcedureNode == null) || (tableNode == null))
{
continue;
}
if (RelationshipExists(storedProcedureNode.Reference, tableNode.Reference))
{
continue;
}
Console.WriteLine("Creating dependency between stored procedure {0} and table {1}", storedProcedureNode.Data.Id, tableNode.Data.Id);
_graphClient.CreateRelationship(storedProcedureNode.Reference, new StoredProcedureReferencesTable(tableNode.Reference));
}
catch (Exception ex)
{
Console.WriteLine("Error analyzing {0}: {1}", storedProcedure.Name.ToString(), ex);
}
}
foreach (var column in storedProcedure.GetReferenced().Where(x => x.ObjectType == ModelSchema.Column))
{
try
{
var columnNode = GetColumnNode(databaseNode, column);
if ((storedProcedureNode == null) || (columnNode == null))
{
continue;
}
if (RelationshipExists(storedProcedureNode.Reference, columnNode.Reference))
{
continue;
}
Console.WriteLine("Creating dependency between stored procedure {0} and column {1}", storedProcedureNode.Data.Id, columnNode.Data.Id);
_graphClient.CreateRelationship(storedProcedureNode.Reference, new StoredProcedureReferencesColumn(columnNode.Reference));
}
catch (Exception ex)
{
Console.WriteLine("Error analyzing {0}: {1}", storedProcedure.Name.ToString(), ex);
}
}
// Check for dynamic SQL
var script = storedProcedure.GetScript();
if (!script.Contains("EXEC"))
{
return;
}
foreach (Match match in FromRegex.Matches(script))
{
try
{
var tableNode = GetTableNode(databaseNode, string.Format("[dbo].[{0}]", match.Groups["table"].Value));
if ((storedProcedureNode == null) || (tableNode == null))
{
continue;
}
if (RelationshipExists(storedProcedureNode.Reference, tableNode.Reference))
{
continue;
}
Console.WriteLine("Creating dependency between stored procedure {0} and table {1} (dynamic SQL)", storedProcedureNode.Data.Id, tableNode.Data.Id);
_graphClient.CreateRelationship(storedProcedureNode.Reference, new StoredProcedureReferencesTable(tableNode.Reference));
}
catch (Exception ex)
{
Console.WriteLine("Error analyzing {0}: {1}", storedProcedure.Name.ToString(), ex);
}
}
foreach (Match match in JoinRegex.Matches(script))
{
try
{
var tableNode = GetTableNode(databaseNode, string.Format("[dbo].[{0}]", match.Groups["table"].Value));
if ((storedProcedureNode == null) || (tableNode == null))
{
continue;
}
if (RelationshipExists(storedProcedureNode.Reference, tableNode.Reference))
{
continue;
}
Console.WriteLine("Creating dependency between stored procedure {0} and table {1} (dynamic SQL)", storedProcedureNode.Data.Id, tableNode.Data.Id);
_graphClient.CreateRelationship(storedProcedureNode.Reference, new StoredProcedureReferencesTable(tableNode.Reference));
}
catch (Exception ex)
{
Console.WriteLine("Error analyzing {0}: {1}", storedProcedure.Name.ToString(), ex);
}
}
}
void createGraph(GraphOfNodes graphNodes, Dictionary <int, int> SubjectIdLevelMapping, GraphClient client)
{
List <GraphNode> lst_graphNodes = graphNodes.GraphNodes;
Dictionary <GraphNode, List <GraphNode> > lst_relationships = graphNodes.ParentToChildrenMap;
if (lst_graphNodes == null || lst_relationships == null)
{
return;
}
Dictionary <TermNode, NodeReference <Neo4jTermNode> > m_term_nodes = new Dictionary <TermNode, NodeReference <Neo4jTermNode> >();
Dictionary <CoverNode, NodeReference <Neo4jCoverNode> > m_cover_nodes = new Dictionary <CoverNode, NodeReference <Neo4jCoverNode> >();
//Add Nodes
foreach (GraphNode node in lst_graphNodes)
{
if (node is TermNode)
{
TermNode term_node = (TermNode)node;
//term_node.ded;
int id = node.Subject.ID;
Neo4jTermNode tn = new Neo4jTermNode();
tn.NodeID = id;
tn.NumberOfBuildings = term_node.PrimarySubject.Schedule.ActNumOfBldgs;
tn.IsPerRisk = term_node.IsPerRisk;
tn.Level = SubjectIdLevelMapping[id];
if (term_node.Deductibles.GetDedList() != null && term_node.Deductibles.GetDedList().Count != 0)
{
tn.Deductible = term_node.Deductibles.GetDedList().First().Amount;
}
if (term_node.Limits.GetLimList() != null && term_node.Limits.GetLimList().Count != 0)
{
tn.Limit = term_node.Limits.GetLimList().First().Amount;
}
var ref1 = client.Create(tn);
m_term_nodes.Add(term_node, (NodeReference <Neo4jTermNode>)ref1);
}
else if (node is CoverNode)
{
CoverNode cover_node = (CoverNode)node;
//term_node.ded;
string coverName = cover_node.CoverName;
Neo4jCoverNode cn = new Neo4jCoverNode();
cn.Name = coverName;
cn.IsPerRisk = cover_node.IsPerRisk;
cn.Level = SubjectIdLevelMapping[cover_node.Subject.ID];
var ref1 = client.Create(cn);
m_cover_nodes.Add(cover_node, (NodeReference <Neo4jCoverNode>)ref1);
}
}
//Add relationships
foreach (KeyValuePair <GraphNode, List <GraphNode> > rel in lst_relationships)
{
//Parent is term Node
if (rel.Key is TermNode)
{
NodeReference <Neo4jTermNode> parentTermNode;
m_term_nodes.TryGetValue(rel.Key as TermNode, out parentTermNode);
List <GraphNode> lst_childnodes = rel.Value;
foreach (GraphNode child in lst_childnodes)
{
NodeReference <Neo4jTermNode> childGraphTermNode;
m_term_nodes.TryGetValue(child as TermNode, out childGraphTermNode);
if (child != null)
{
client.CreateRelationship <Neo4jTermNode, TermChildRelationship>(parentTermNode, new TermChildRelationship(childGraphTermNode));
}
}
}
//Parent is Cover Node
else if (rel.Key is CoverNode)
{
NodeReference <Neo4jCoverNode> parentTermNode;
m_cover_nodes.TryGetValue(rel.Key as CoverNode, out parentTermNode);
List <GraphNode> lst_childnodes = rel.Value;
foreach (GraphNode child in lst_childnodes)
{
if (child is TermNode)
{
NodeReference <Neo4jTermNode> childGraphTermNode;
m_term_nodes.TryGetValue(child as TermNode, out childGraphTermNode);
if (child != null)
{
client.CreateRelationship <Neo4jCoverNode, CoverChildRelationship>(parentTermNode, new CoverChildRelationship(childGraphTermNode));
}
}
else if (child is CoverNode)
{
NodeReference <Neo4jCoverNode> childGraphCoverNode;
m_cover_nodes.TryGetValue(child as CoverNode, out childGraphCoverNode);
if (child != null)
{
client.CreateRelationship <Neo4jCoverNode, DerivedCoverChildRelationship>(parentTermNode, new DerivedCoverChildRelationship(childGraphCoverNode));
}
}
else
{
throw new NotSupportedException("Can only handle nodes of type term and cover");
}
}
}
}
// Create entities
//var refA = client.Create(new Person() { Name = "Person A" });
//var refB = client.Create(new Person() { Name = "Person B" });
//var refC = client.Create(new Person() { Name = "Person C" });
//var refD = client.Create(new Person() { Name = "Person D" });
//// Create relationships
//client.CreateRelationship(refA, new KnowsRelationship(refB));
//client.CreateRelationship(refB, new KnowsRelationship(refC));
//client.CreateRelationship(refB, new HatesRelationship(refD), new HatesData("Crazy guy")));
//client.CreateRelationship(refC, new HatesRelationship(refD), new HatesData("Don't know why...")));
//client.CreateRelationship(refD, new KnowsRelationship(refA));
}
