void PublishToGraph()
{
var client = new Neo4jClient(new Uri(string.Format("bolt://{0}:{1}", Host, Port)), Username, Password);
_publisher.Publish(_settings, client);
Autodesk.Revit.UI.TaskDialog.Show("Publish complete", "The current revit model has been successfully published to the graph database.");
Close();
}
protected override void SolveInstance(IGH_DataAccess dataAccess)
{
bool commitChanges = false;
dataAccess.GetData <bool>("_Commit", ref commitChanges);
if (_neo4jDB != null && !_wasCommitted && commitChanges)
{
_neo4jDB.Value.CommitAsync().RunSynchronously();
_wasCommitted = !commitChanges;
AddRuntimeMessage(GH_RuntimeMessageLevel.Remark, "Changes committed");
return;
}
string host = string.Empty;
string userName = string.Empty;
string password = string.Empty;
if (!dataAccess.GetData <string>("_neo4jHost", ref host))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Host required");
}
if (!dataAccess.GetData <string>("_neo4jUserName", ref userName))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Username required");
}
dataAccess.GetData <string>("_neo4jPassword", ref password);
if (string.IsNullOrEmpty(host) || string.IsNullOrEmpty(userName))
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Missing input data");
return;
}
var driver = new Neo4jClient(new Uri(host), userName, password);
var vstask = driver.VerifyConnectionAsync();
vstask.RunSynchronously();
if (vstask.Exception != null)
{
AddRuntimeMessage(GH_RuntimeMessageLevel.Error, "Connection failed: " + vstask.Exception.Message);
}
if (_neo4jDB == null)
{
_neo4jDB = new Neo4jDatabase(driver);
}
else
{
var oldDb = _neo4jDB.Value;
oldDb.CloseAsync().ContinueWith((d) => { oldDb.Dispose(); });
_neo4jDB.Value = driver;
}
dataAccess.SetData("_neo4jDriver", _neo4jDB);
}
public static string RunCypherQuery(Neo4jClient client, string cypher, Dictionary <string, object> vars)
{
var task = Task.Run(() => AsyncContext.Run(() => client.RunCypherQueryAsync(cypher, vars)));
if (task.Exception != null)
{
throw new Exception("Query failed: " + task.Exception.Message, task.Exception);
}
return(task.Result.AsJson);
}
public void Publish(RevitToGraphPublisherSettings settings, Neo4jClient client)
{
var meGraph = new MEPRevitGraph();
MEPRevitGraphWriter mps = new MEPRevitGraphWriter(meGraph);
if (settings.IncludeElectrical)
{
mps.Parsers.Add(new Parsers.MEPGraphParserElectrical());
}
if (settings.IncludeMechanical)
{
mps.Parsers.Add(new Parsers.MEPGraphParserConnectors());
}
if (settings.IncludeBoundaries)
{
mps.Parsers.Add(new Parsers.MEPGraphParserSpaces());
}
//if (settings.IncludeBoundaries) mps.Parsers.Add(new Parsers.ClashDetection());
mps.Parsers.Add(new Parsers.MEPGraphParserIoT());
if (mps.Parsers.Count == 0)
{
return;
}
var mecFEc = new FilteredElementCollector(_rdoc);
var mecFilter = mps.GetFilterForAllParsers;
var mecElements = mecFEc.WherePasses(mecFilter).WhereElementIsNotElementType().ToElements();
var wfic = new FilteredElementCollector(_rdoc);
var geoElementsFilter = new ElementMulticategoryFilter(new BuiltInCategory[] { BuiltInCategory.OST_Floors, BuiltInCategory.OST_Roofs, BuiltInCategory.OST_Windows, BuiltInCategory.OST_Doors, BuiltInCategory.OST_MEPSpaces, BuiltInCategory.OST_Rooms });
var geoElements = wfic.WherePasses(geoElementsFilter).WhereElementIsNotElementType().ToElements();
using (Transaction tx = new Transaction(_rdoc, "Build graph"))
{
tx.Start("Build graph");
mps.Write(mecElements, geoElements, -1, true, _rdoc);
tx.Commit();
}
MEPGraphWriter wre = new MEPGraphWriter(client);
wre.Write(meGraph, _rdoc);
//var bc = new HLApps.Cloud.BuildingGraph.BuildingGraphClient(@"http://*****:*****@"C:\src\HLApps\GraphData-MEP\HLApps.Revit.Graph\RevitToGraphQLMappings.json");
//var bgmap = new HLApps.Cloud.BuildingGraph.Introspection.BuildingGraphMapping(json);
//gqlWrtier.Write(meGraph, bgmap, _rdoc);
}
public void Save(Lokation lokation)
{
Contract.Requires(lokation != null);
IEnumerable<IndexEntry> indexEntries = new[]
{
new IndexEntry("LokationIdx")
{
{ "Name", lokation.Name }
}
};
NodeReference<Lokation> nodeRef = gc.Create(
lokation,
new IRelationshipAllowingParticipantNode<Lokation>[0],
indexEntries);
lokation.LokNr = nodeRef.Id;
}
public void Publish(RevitToGraphPublisherSettings settings, Neo4jClient client)
{
var meGraph = new MEPRevitGraph();
MEPRevitGraphWriter mps = new MEPRevitGraphWriter(meGraph);
if (settings.IncludeElectrical)
{
mps.Parsers.Add(new Parsers.MEPGraphParserElectrical());
}
if (settings.IncludeMechanical)
{
mps.Parsers.Add(new Parsers.MEPGraphParserConnectors());
}
if (settings.IncludeBoundaries)
{
mps.Parsers.Add(new Parsers.MEPGraphParserSpaces());
}
//if (settings.IncludeBoundaries) mps.Parsers.Add(new Parsers.ClashDetection());
mps.Parsers.Add(new Parsers.MEPGraphParserIoT());
if (mps.Parsers.Count == 0)
{
return;
}
var mecFEc = new FilteredElementCollector(_rdoc);
var mecFilter = mps.GetFilterForAllParsers;
var mecElements = mecFEc.WherePasses(mecFilter).WhereElementIsNotElementType().ToElements();
var wfic = new FilteredElementCollector(_rdoc);
var geoElementsFilter = new ElementMulticategoryFilter(new BuiltInCategory[] { BuiltInCategory.OST_Floors, BuiltInCategory.OST_Roofs, BuiltInCategory.OST_Windows, BuiltInCategory.OST_Doors, BuiltInCategory.OST_MEPSpaces, BuiltInCategory.OST_Rooms });
var geoElements = wfic.WherePasses(geoElementsFilter).WhereElementIsNotElementType().ToElements();
using (Transaction tx = new Transaction(_rdoc, "Build graph"))
{
tx.Start("Build graph");
mps.Write(mecElements, geoElements, -1, true, _rdoc);
tx.Commit();
}
MEPGraphWriter wre = new MEPGraphWriter(client);
wre.Write(meGraph, _rdoc);
}
public static async Task AddClientAsync(this IdentityServerDriverProvider ext, Client client)
{
ext = ext ?? throw new ArgumentNullException(nameof(ext));
client = client ?? throw new ArgumentNullException(nameof(client));
using (ISession session = ext.GetDriver().Session())
{
Node n = new Node(type: typeof(Neo4jClient));
Neo4jClient newClient = await session.AsAsync(s =>
s.ExecuteQuery <Neo4jClient>($"CREATE (p{n.Labels}) SET p+=${nameof(client)}, p.{nameof(IGraphEntity.EntityId)}=id(p), p :{typeof(Neo4jClient).Name} RETURN p",
new { client = client.ExludeProperties(p => new { p.Properties, p.Claims, p.ClientSecrets }) }).FirstOrDefault());
if (client is Neo4jClient)
{
(client as Neo4jClient).EntityId = newClient.EntityId;
}
}
}
public async Task CreateNodesLoadTest()
{
Neo4jClient n4 = new Neo4jClient(new Uri("bolt://localhost:8687"), "neo4j", "neo4j");
Node b = new Node("Building");
b.ExtendedProperties.Add("Name", "Building 1");
var pbn = n4.Push(b, b.ExtendedProperties);
var pnl = new List <PendingNode>();
for (int i = 1; i < 100; i++)
{
Node n = new Node("Space");
n.ExtendedProperties.Add("Name", "Space " + i);
for (int p = 1; p < 100; p++)
{
n.ExtendedProperties.Add("Param " + p, p);
}
var spn = n4.Push(n, n.ExtendedProperties);
pnl.Add(spn);
n4.Relate(spn, pbn, "IS_IN", null);
for (int e = 1; e < 100; e++)
{
Node en = new Node("Element");
en.ExtendedProperties.Add("Name", "Element " + i);
for (int p = 1; p < 100; p++)
{
en.ExtendedProperties.Add("Param " + p, p);
}
var epn = n4.Push(en, en.ExtendedProperties);
pnl.Add(epn);
n4.Relate(epn, spn, "IS_IN", null);
}
}
await n4.CommitAsync();
}
public async Task spquery()
{
Neo4jClient n4 = new Neo4jClient(new Uri("bolt://*****:*****@"match (frmSpace:Space {Number:$fromSpaceNumber}) MATCH (toSpace:Space {Number:$toSpaceNumber})
CALL apoc.algo.dijkstra(frmSpace, toSpace, 'TRAVEL_TO', 'Distance') YIELD path, weight
with nodes(path) as sfs, path, weight, frmSpace, toSpace
unwind sfs as sf
match p=(n)-[b:BOUNDED_BY]-(sf:Surface)-[o:IS_ON]-(t)
RETURN path, sum(weight) as totalDistance, collect(p) as context";
var q2 = @"match (sp:Space {Number:$fromSpaceNumber}) MATCH (sc:Space {Number:$toSpaceNumber})
CALL apoc.algo.dijkstra(sp, sc, 'TRAVEL_TO', 'Distance') YIELD path, weight
RETURN path, sum(weight)";
var vars = new Dictionary <string, object>();
vars.Add("fromSpaceNumber", "01-01");
vars.Add("toSpaceNumber", "02-01");
var res = await n4.RunCypherQueryAsync(q1, vars);
_ = res.Messages;
}
static void Main(string[] args)
{
using (Neo4jClient client = new Neo4jClient("bolt://localhost:7687", "neo4j", "1234"))
{
var command = client.NewCommand();
command.Match().Pattern().Node("a", typeof(Person)).All()
//.Relation("b").All()
//.Node("c").All()
//.Relation("d").All()
//.Node("e").All()
.Close()
//.Pattern().Node("f").All()
// .Relation("g").All()
// .Node("h").All()
// .Close()
.Close()
.Return("a");
//var cmd = command.AsPainCypher();
//Console.WriteLine(cmd);
var test = client.ExecuteQuery(command);
Console.Read();
}
}
public MEPGraphWriter(Neo4jClient gdbClient)
{
_gdbClient = gdbClient;
}
public static Neo4jClient CreateClient(string host, string username, string password)
{
var n4c = new Neo4jClient(new Uri(host), username, password);
return(n4c);
}
internal Node<PO.Chunk> Add(DateTimeOffset start, DateTimeOffset stop, TimeSpan duration, Node<PO.Worker> owningWorkerNode, Neo4jClient.GraphClient Client, Neo4jClient.Node<PO.Root> RootNode)
{
var chunkNodeRef = Client.Create(
PO.Chunk.Create(start, stop, duration),
null,
new[]
{
new IndexEntry
{
Name = "NameIndex",
KeyValues = new[]
{
new KeyValuePair<string,object>("Name", "Chunk")
}
}
}
);
// I update all fields again because I have a problem with serialising/deserialising DateTimeOffset - I lose the fractions of a second. Not that it matters in my project but rätt skall vara rätt.
Client.Update<PO.Chunk>(chunkNodeRef, node => { node.Set(chunkNodeRef.Id, start, stop, duration); });
var rel = Client.CreateRelationship<PO.Worker, Relationships.HasWorkedRelationship>(
owningWorkerNode.Reference,
new Relationships.HasWorkedRelationship( chunkNodeRef)
);
var ret = Get( chunkNodeRef.Id, Client );
return ret;
}
