private static Node<PO.Workers> AddWorkersRootNode(GraphClient client, Node<PO.Root> rootNode)
{
var nodeRef = client.Create(PO.Workers.Create("Workers"), null,
new[]{
new IndexEntry{
Name=NameIndexName,
KeyValues=new[]{
new KeyValuePair<string,object>("Name", "Workers")
}
}
});
client.CreateRelationship<PO.Root, Relationships.RelatedToRelationship>(rootNode.Reference, new Relationships.RelatedToRelationship(nodeRef));
var ret = client.Get<PO.Workers>(nodeRef.Id);
client.Update<PO.Workers>(ret.Reference, node => { node.SetID(ret.Reference.Id); });
ret = client.Get<PO.Workers>(nodeRef.Id);
Debug.Assert(ret.Reference.Id == ret.Data.ID);
Debug.Assert(ret.Reference.Id == nodeRef.Id);
Debug.Assert(ret.Reference.Id == GetWorkersRootNode(client, rootNode).Reference.Id);
return ret;
}
private static Node<PO.Root> AddRootNode( GraphClient client)
{
var nodeRef = client.Create(PO.Root.Create(), null,
new[]{
new IndexEntry{
Name=NameIndexName,
KeyValues=new[]{
new KeyValuePair<string,object>("Name", "Root")
}
}
});
var ret = client.Get<PO.Root>(nodeRef.Id);
client.Update<PO.Root>(ret.Reference, node => { node.SetID(ret.Reference.Id); });
ret = client.Get<PO.Root>(nodeRef.Id);
return ret;
}
private Node<Actor> EnsureActorIsInDb(GraphClient db)
{
if (!db.CheckIndexExists("Actors", IndexFor.Node))
{
db.CreateIndex("Actors",
new IndexConfiguration { Provider = IndexProvider.lucene, Type = IndexType.exact },
IndexFor.Node);
}
var actor = db.RootNode
.Out<Actor>(ObjectBelongsTo.TypeKey, i => i.ActorName == this.ActorName)
.FirstOrDefault();
if (actor == null)
{
var actorRef = db.Create<Actor>(this, new ObjectBelongsTo(db.RootNode));
actor = db.Get<Actor>(actorRef);
}
return actor;
}
internal static Node<PO.Chunk> Update(DTO.Chunk chunk, GraphClient client)
{
Debug.Assert(chunk.ID >= 1);
var chunkNode = client.Get<PO.Chunk>(chunk.ID);
client.Update<PO.Chunk>( chunkNode.Reference, node =>
node.Set(chunk.Start, chunk.Stop, chunk.Duration)
);
return Get( chunk.ID, client );
}
internal static Node<PO.Chunk> Get(int id, GraphClient client)
{
return client.Get<PO.Chunk>(id);
}
static void Main(string[] args)
{
// Ready the node manager!
var nodeManager = new NodeManager();
// Neo4J client, connect to localhost
GraphClient client = new GraphClient(new Uri("http://*****:*****@"
SELECT DISTINCT Person.FirstName as lhFName, Person.LastName as lhLName, Person.Id as lhId, Person.FacebookId as lhFB, Friend.PersonId rhId, Friend.FacebookId as rhFB, pFriend.FirstName as rhFName,pFriend.LastName as rhLName
FROM Person
JOIN Friend ON (Friend.PersonId = Person.Id)
JOIN Person pFriend ON (pFriend.FacebookId=Friend.FacebookId)
";
sqlConnection1.Open();
reader = cmd.ExecuteReader();
// Create graph structure
Graph<Person> peopleGraph = new Graph<Person>(new NodeList<Person>());
while (reader.Read())
{
// Get left and right nodes in friendships, they certainly exist
var left = nodeManager.CreateIfExists((string)reader["lhFB"], client, (string)reader["lhFName"], (string)reader["lhLName"], peopleGraph);
var right = nodeManager.CreateIfExists((string)reader["rhFB"], client, (string)reader["rhFName"], (string)reader["rhLName"], peopleGraph);
//// Parse the user's first name and last name from Facebook display name.
//string parsedFirstName = (string)reader["Display"];
//int index = 0;
//foreach (char character in parsedFirstName) {
// index++;
// if (character == ' ') {
// break;
// }
//}
//string parsedLastName = parsedFirstName.Substring(index, parsedFirstName.Length - index);
//parsedFirstName = parsedFirstName.Substring(0, index-1);
//Dictionary<string, Object> dictRight = nodeManager.CreateIfExists((string)reader["rhFB"], client, parsedFirstName, parsedLastName, peopleGraph);
//Object tempRight;
//dictRight.TryGetValue("NodeReference", out tempRight);
//NodeReference<Person> right = (NodeReference<Person>)tempRight;
// Create relationship between left and right
client.CreateRelationship(left.NodeReference, new FriendsWith(right.NodeReference));
Person leftPerson = client.Get<Person>(left.NodeReference).Data;
Person rightPerson = client.Get<Person>(right.NodeReference).Data;
//Object tempLeftNode;
//dictLeft.TryGetValue("GraphNode", out tempLeftNode);
//GraphNode<Person> leftNode = (GraphNode<Person>)tempLeftNode;
//Object tempRightNode;
//dictRight.TryGetValue("GraphNode", out tempRightNode);
//GraphNode<Person> rightNode = (GraphNode<Person>)tempRightNode;
peopleGraph.AddUndirectedEdge(left.GraphNode, right.GraphNode);
// Log relationship creation
string leftName = leftPerson.FirstName;
string rightName = rightPerson.FirstName;
Console.WriteLine("Relationship between " + leftName + " and " + rightName + " created.");
}
sqlConnection1.Close();
// New sql command
SqlCommand cmd2 = new SqlCommand();
cmd2.CommandType = System.Data.CommandType.Text;
cmd2.Connection = sqlConnection1;
// Query for all people with no friends :(
cmd2.CommandText = @"SELECT DISTINCT Person.FacebookId, Person.FirstName, Person.LastName FROM Person";
sqlConnection1.Open();
reader = cmd2.ExecuteReader();
// Create nodes without relationships for all people to fill holes left by original query
while (reader.Read())
{
nodeManager.CreateIfExists((string)reader["FacebookId"], client, (string)reader["FirstName"], (string)reader["LastName"], peopleGraph);
}
sqlConnection1.Close();
Console.WriteLine("\n");
Console.WriteLine(BronKerbosch1(new Graph<Person>(new NodeList<Person>()), peopleGraph, new Graph<Person>(new NodeList<Person>())));
}
internal static Node<PO.Worker> Get(int id, GraphClient client)
{
var worker = client.Get<PO.Worker>(id);
return worker;
}
private static Node<PO.Worker> UpdateWorker(DTO.Worker worker, GraphClient client)
{
var workerNode = client.Get<PO.Worker>(worker.ID);
//workerNode.Data.Set(worker.Name);
client.Update<PO.Worker>(workerNode.Reference, node =>
{
node.ID = worker.ID;
node.Name = worker.Name;
});
return Get(worker.ID, client);
}
