public IHttpActionResult Get()
{
// set windings
((TransformerNodeViewModel)testNodes[2]).FirstWinding = new NodeViewModel {
Id = "3", DMSType = "TRANSFORMERWINDING"
};
((TransformerNodeViewModel)testNodes[2]).SecondWinding = new NodeViewModel {
Id = "5", DMSType = "TRANSFORMERWINDING"
};
((TransformerNodeViewModel)testNodes[5]).FirstWinding = new NodeViewModel {
Id = "8", DMSType = "TRANSFORMERWINDING"
};
((TransformerNodeViewModel)testNodes[5]).SecondWinding = new NodeViewModel {
Id = "10", DMSType = "TRANSFORMERWINDING"
};
OmsGraphViewModel graph = new OmsGraphViewModel
{
Nodes = testNodes,
Relations = testRelations
};
return(Ok(graph));
}
public static OmsGraphViewModel RemoveNodes(this OmsGraphViewModel graph, IEnumerable <NodeViewModel> nodes)
{
foreach (var node in nodes)
{
graph.Nodes.Remove(node);
}
return(graph);
}
public static OmsGraphViewModel RemoveRelations(this OmsGraphViewModel graph, IEnumerable <RelationViewModel> relations)
{
foreach (var relation in relations)
{
graph.Relations.Remove(relation);
}
return(graph);
}
public OmsGraphViewModel Map(UIModel topologyModel)
{
OmsGraphViewModel graph = new OmsGraphViewModel();
// map nodes
foreach (KeyValuePair <long, UINode> keyValue in topologyModel.Nodes)
{
NodeViewModel graphNode = new NodeViewModel
{
Id = keyValue.Value.Id.ToString(),
Name = keyValue.Value.Name,
Description = keyValue.Value.Description,
Mrid = keyValue.Value.Mrid,
IsActive = keyValue.Value.IsActive,
DMSType = keyValue.Value.DMSType,
IsRemote = keyValue.Value.IsRemote,
NoReclosing = keyValue.Value.NoReclosing,
NominalVoltage = keyValue.Value.NominalVoltage.ToString(),
Measurements = new List <MeasurementViewModel>()
};
foreach (var measurement in keyValue.Value.Measurements)
{
graphNode.Measurements.Add(new MeasurementViewModel()
{
Id = measurement.Gid.ToString(),
Type = measurement.Type,
Value = measurement.Value,
AlarmType = AlarmType.NO_ALARM
});
}
graph.Nodes.Add(
graphNode.DMSType == PowerTransformerDmsTypeName
? graphNode.ToTransformerNode()
: graphNode
);
}
// map relations
foreach (KeyValuePair <long, HashSet <long> > keyValue in topologyModel.Relations)
{
foreach (long targetNodeId in keyValue.Value)
{
RelationViewModel graphRelation = new RelationViewModel
{
SourceNodeId = keyValue.Key.ToString(),
TargetNodeId = targetNodeId.ToString(),
IsActive = topologyModel.Nodes[keyValue.Key].IsActive || topologyModel.Nodes[targetNodeId].IsActive
};
graph.Relations.Add(graphRelation);
}
}
return(graph.SquashTransformerWindings());
}
/// <summary>
/// Maps the input topology object to a graph object and dispatches it
/// to a Graph Hub endpoint
/// </summary>
/// <param name="message"></param>
public void Notify(IPublishableMessage message)
{
if (message is TopologyForUIMessage topologyMessage)
{
OmsGraphViewModel graph = _mapper.Map(topologyMessage.UIModel);
_dispatcher.Connect();
try
{
_dispatcher.NotifyGraphUpdate(graph.Nodes, graph.Relations);
}
catch (Exception)
{
// retry ?
}
}
}
public async Task NotifyGraphUpdate(List <NodeViewModel> nodes, List <RelationViewModel> relations)
{
try
{
Logger.LogDebug($"{baseLogString} NotifyGraphUpdate => nodes count: {nodes.Count}, relations count: {relations.Count}");
var omsGraphData = new OmsGraphViewModel {
Nodes = nodes, Relations = relations
};
var jsonOutput = JsonConvert.SerializeObject(omsGraphData);
await this.connection.InvokeAsync("NotifyGraphUpdate", jsonOutput);
Logger.LogDebug($"{baseLogString} NotifyGraphUpdate => json output sent to graph hub: {jsonOutput}");
}
catch (Exception e)
{
Logger.LogError($"{baseLogString} NotifyGraphUpdate => Exception: {e.Message}", e);
}
}
public static OmsGraphViewModel ResolveWindings(
this OmsGraphViewModel graph,
IEnumerable <RelationViewModel> firstWindingRelations,
IEnumerable <RelationViewModel> secondWindingRelations)
{
foreach (var firstWindingRelation in firstWindingRelations)
{
NodeViewModel firstWinding
= graph
.Nodes
.First(x => x.Id.Equals(firstWindingRelation.SourceNodeId));
TransformerNodeViewModel transformer
= graph
.Nodes
.First(x => x.Id.Equals(firstWindingRelation.TargetNodeId))
as TransformerNodeViewModel;
transformer.AddFirstWinding(firstWinding);
}
foreach (var secondWindingRelation in secondWindingRelations)
{
NodeViewModel secondWinding
= graph
.Nodes
.First(x => x.Id.Equals(secondWindingRelation.TargetNodeId));
TransformerNodeViewModel transformer
= graph
.Nodes
.First(x => x.Id.Equals(secondWindingRelation.SourceNodeId))
as TransformerNodeViewModel;
transformer.AddSecondWinding(secondWinding);
}
return(graph);
}
public void GivenTopology_WhenSquashWindings_ShouldSquash()
{
OmsGraphViewModel graph = new OmsGraphViewModel();
graph.Nodes = initialNodes;
graph.Relations = initialRelations;
OmsGraphViewModel resultGraph = graph.SquashTransformerWindings();
Assert.NotNull(resultGraph);
Assert.Equal(resultNodes.Count, resultGraph.Nodes.Count);
Assert.Equal(resultRelations.Count, resultGraph.Relations.Count);
Assert.Equal(
((TransformerNodeViewModel)resultNodes[2]).FirstWinding,
((TransformerNodeViewModel)resultGraph.Nodes[2]).FirstWinding
);
Assert.Equal(
((TransformerNodeViewModel)resultNodes[5]).FirstWinding,
((TransformerNodeViewModel)resultGraph.Nodes[5]).FirstWinding
);
}
public async Task <IHttpActionResult> Get()
{
OmsGraphViewModel graph = await _mediator.Send <OmsGraphViewModel>(new GetTopologyQuery());
return(Ok(graph));
}
public static OmsGraphViewModel SquashTransformerWindings(this OmsGraphViewModel graph)
{
IEnumerable <TransformerNodeViewModel> transformerNodes
= graph
.Nodes
.Where(x => x.DMSType.Equals(PowerTransformerDmsTypeName))
?.Select(n => n as TransformerNodeViewModel)
?.ToList();
IEnumerable <NodeViewModel> windingNodes
= graph
.Nodes
.Where(x => x.DMSType.Equals(TransformerWindingDmsTypeName))
?.ToList();
IEnumerable <RelationViewModel> firstWindingRelations
= graph
.Relations
.Where(x => windingNodes.Any(w => w.Id.Equals(x.SourceNodeId)))
.Where(x => transformerNodes.Any(t => t.Id.Equals(x.TargetNodeId)))
?.ToList();
IEnumerable <RelationViewModel> secondWindingRelations
= graph
.Relations
.Where(x => windingNodes.Any(w => w.Id.Equals(x.TargetNodeId)))
.Where(x => transformerNodes.Any(t => t.Id.Equals(x.SourceNodeId)))
?.ToList();
IEnumerable <RelationViewModel> firstWindingSourceRelations
= graph
.Relations
.Where(x => firstWindingRelations.Any(f => f.SourceNodeId.Equals(x.TargetNodeId)))
?.Select(x =>
new RelationViewModel
{
SourceNodeId = x.SourceNodeId,
TargetNodeId = firstWindingRelations
?.First(f => f.SourceNodeId.Equals(x.TargetNodeId))
?.TargetNodeId,
IsActive = x.IsActive
}
)
?.ToList();
IEnumerable <RelationViewModel> secondWindingTargetRelations
= graph
.Relations
.Where(x => secondWindingRelations.Any(f => f.TargetNodeId.Equals(x.SourceNodeId)))
?.Select(x =>
new RelationViewModel
{
TargetNodeId = x.TargetNodeId,
SourceNodeId = secondWindingRelations
?.First(f => f.TargetNodeId.Equals(x.SourceNodeId))
?.SourceNodeId,
IsActive = x.IsActive
}
)
?.ToList();
IEnumerable <RelationViewModel> windingRelationsForDelete
= graph
.Relations
.Where(x => windingNodes
.Any(w =>
x.SourceNodeId.Equals(w.Id) ||
x.TargetNodeId.Equals(w.Id))
)
.ToList();
graph.ResolveWindings(firstWindingRelations, secondWindingRelations);
graph.RemoveNodes(windingNodes);
graph.RemoveRelations(firstWindingRelations);
graph.RemoveRelations(secondWindingRelations);
graph.RemoveRelations(windingRelationsForDelete);
graph.AddRelations(firstWindingSourceRelations);
graph.AddRelations(secondWindingTargetRelations);
return(graph);
}
public async Task Notify(IPublishableMessage message, string publisherName)
{
if (message is ActiveOutageMessage activeOutage)
{
Logger.LogInformation($"{baseLogString} Notify => ActiveOutageMessageReceived. OutageId: 0x{activeOutage.OutageId:x16} ElementId: 0x{activeOutage.OutageElementGid}");
var outageDispatcher = new OutageHubDispatcher(_outageMapper);
outageDispatcher.Connect();
try
{
await outageDispatcher.NotifyActiveOutageUpdate(activeOutage);
}
catch (Exception e)
{
string errorMessage = $"{baseLogString} Notify => exception {e.Message}";
Logger.LogError(errorMessage, e);
}
}
else if (message is ArchivedOutageMessage archivedOutage)
{
var outageDispatcher = new OutageHubDispatcher(_outageMapper);
outageDispatcher.Connect();
try
{
await outageDispatcher.NotifyArchiveOutageUpdate(archivedOutage);
}
catch (Exception e)
{
string errorMessage = $"{baseLogString} Notify => exception {e.Message}";
Logger.LogError(errorMessage, e);
}
}
else if (message is TopologyForUIMessage topologyMessage)
{
OmsGraphViewModel graph = _graphMapper.Map(topologyMessage.UIModel);
var graphDispatcher = new GraphHubDispatcher();
graphDispatcher.Connect();
try
{
await graphDispatcher.NotifyGraphUpdate(graph.Nodes, graph.Relations);
}
catch (Exception e)
{
string errorMessage = $"{baseLogString} Notify => exception {e.Message}";
Logger.LogError(errorMessage, e);
}
}
else if (message is MultipleAnalogValueSCADAMessage analogValuesMessage)
{
Dictionary <long, AnalogModbusData> analogModbusData = new Dictionary <long, AnalogModbusData>(analogValuesMessage.Data);
var scadaDispatcher = new ScadaHubDispatcher();
scadaDispatcher.Connect();
try
{
await scadaDispatcher.NotifyScadaDataUpdate(analogModbusData);
}
catch (Exception e)
{
string errorMessage = $"{baseLogString} Notify => exception {e.Message}";
Logger.LogError(errorMessage, e);
}
}
}
