public async void TryMergeNotConnectedSpanEquipments_ShouldFail()
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
// NB: Both span equipment have from node in J_1
var sutFromSpanEquipmentId = TestUtilityNetwork.MultiConduit_5x10_SDU_1_to_J_1;
var sutToSpanEquipmentId = TestUtilityNetwork.MultiConduit_5x10_HH_1_to_HH_10;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutFromSpanEquipmentId, out var fromSpanEquipmentBeforeConnect);
utilityNetwork.TryGetEquipment <SpanEquipment>(sutToSpanEquipmentId, out var toSpanEquipmentBeforeConnect);
// Connect the two outer conduits, which should result in a merge of the two span equipments
var connectCmd = new ConnectSpanSegmentsAtRouteNode(
routeNodeId: TestRouteNetwork.SDU_1,
spanSegmentsToConnect: new Guid[] {
fromSpanEquipmentBeforeConnect.SpanStructures[0].SpanSegments[0].Id,
toSpanEquipmentBeforeConnect.SpanStructures[0].SpanSegments[0].Id
}
);
var connectResult = await _commandDispatcher.HandleAsync <ConnectSpanSegmentsAtRouteNode, Result>(connectCmd);
// Assert
connectResult.IsFailed.Should().BeTrue();
((MergeSpanEquipmentError)connectResult.Errors.First()).Code.Should().Be(MergeSpanEquipmentErrorCodes.CANNOT_MERGE_SPAN_EQUIPMENT_BECAUSE_ENDS_ARE_NOT_COLOCATED_IN_ROUTE_NODE);
}
public async void TestConnectTwo5x10inCO1_ShouldSucceed()
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var sutConnectFromSpanEquipment = TestUtilityNetwork.MultiConduit_5x10_CO_1_to_HH_1;
var sutConnectToSpanEquipment = TestUtilityNetwork.MultiConduit_5x10_HH_1_to_HH_10;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutConnectFromSpanEquipment, out var sutFromSpanEquipment);
utilityNetwork.TryGetEquipment <SpanEquipment>(sutConnectToSpanEquipment, out var sutToSpanEquipment);
var connectCmd = new ConnectSpanSegmentsAtRouteNode(
routeNodeId: TestRouteNetwork.HH_1,
spanSegmentsToConnect: new Guid[] {
sutFromSpanEquipment.SpanStructures[1].SpanSegments[0].Id,
sutToSpanEquipment.SpanStructures[1].SpanSegments[0].Id,
sutFromSpanEquipment.SpanStructures[2].SpanSegments[0].Id,
sutToSpanEquipment.SpanStructures[2].SpanSegments[0].Id,
sutFromSpanEquipment.SpanStructures[3].SpanSegments[0].Id,
sutToSpanEquipment.SpanStructures[3].SpanSegments[0].Id,
sutFromSpanEquipment.SpanStructures[4].SpanSegments[0].Id,
sutToSpanEquipment.SpanStructures[4].SpanSegments[0].Id,
sutFromSpanEquipment.SpanStructures[5].SpanSegments[0].Id,
sutToSpanEquipment.SpanStructures[5].SpanSegments[0].Id,
}
);
var connectResult = await _commandDispatcher.HandleAsync <ConnectSpanSegmentsAtRouteNode, Result>(connectCmd);
// Assert
connectResult.IsSuccess.Should().BeTrue();
}
public async void TestConnectOneMoreSingleConduitInCC1()
{
var sutRouteNetworkElement = TestRouteNetwork.CC_1;
var sutSpanEquipmentFrom = TestUtilityNetwork.MultiConduit_12x7_HH_1_to_HH_10;
var sutSpanEquipmentTo = TestUtilityNetwork.CustomerConduit_CC_1_to_SDU_2;
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
// Act
utilityNetwork.TryGetEquipment <SpanEquipment>(sutSpanEquipmentFrom, out var fromSpanEquipment);
utilityNetwork.TryGetEquipment <SpanEquipment>(sutSpanEquipmentTo, out var toSpanEquipment);
// Connect segments
var connectCmd = new ConnectSpanSegmentsAtRouteNode(Guid.NewGuid(), new UserContext("test", Guid.Empty),
routeNodeId: TestRouteNetwork.CC_1,
spanSegmentsToConnect: new Guid[] {
fromSpanEquipment.SpanStructures[7].SpanSegments[0].Id,
toSpanEquipment.SpanStructures[0].SpanSegments[0].Id
}
);
var connectResult = await _commandDispatcher.HandleAsync <ConnectSpanSegmentsAtRouteNode, Result>(connectCmd);
connectResult.IsSuccess.Should().BeTrue();
var getDiagramQueryResult = await _queryDispatcher.HandleAsync <GetDiagram, Result <GetDiagramResult> >(new GetDiagram(TestRouteNetwork.CC_1));
if (System.Environment.OSVersion.Platform.ToString() == "Win32NT")
{
new GeoJsonExporter(getDiagramQueryResult.Value.Diagram).Export("c:/temp/diagram/test.geojson");
}
}
public async void TestConnectInnerToOuterConduit_ShouldFail()
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var sutConnectFromSpanEquipment = TestUtilityNetwork.MultiConduit_5x10_HH_1_to_HH_10;
var sutConnectToSpanEquipment = TestUtilityNetwork.MultiConduit_3x10_CC_1_to_SP_1;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutConnectFromSpanEquipment, out var sutFromSpanEquipment);
utilityNetwork.TryGetEquipment <SpanEquipment>(sutConnectToSpanEquipment, out var sutToSpanEquipment);
// Connect inner conduit 2 in 5x10 with inner conduit 1 in 3x10
var connectCmd = new ConnectSpanSegmentsAtRouteNode(
routeNodeId: TestRouteNetwork.CC_1,
spanSegmentsToConnect: new Guid[] {
sutFromSpanEquipment.SpanStructures[2].SpanSegments[1].Id,
sutToSpanEquipment.SpanStructures[0].SpanSegments[0].Id
}
);
var connectResult = await _commandDispatcher.HandleAsync <ConnectSpanSegmentsAtRouteNode, Result>(connectCmd);
// Assert
connectResult.IsFailed.Should().BeTrue();
((ConnectSpanSegmentsAtRouteNodeError)connectResult.Errors.First()).Code.Should().Be(ConnectSpanSegmentsAtRouteNodeErrorCodes.OUTER_AND_INNER_SPANS_CANNOT_BE_CONNECTED);
}
public async void TestConnect5x10To3x10ConduitAtCC_1_ShouldSucceed()
{
MakeSureTestConduitIsCutAtCC_1();
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var sutConnectFromSpanEquipment = TestUtilityNetwork.MultiConduit_5x10_HH_1_to_HH_10;
var sutConnectToSpanEquipment = TestUtilityNetwork.MultiConduit_3x10_CC_1_to_SP_1;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutConnectFromSpanEquipment, out var sutFromSpanEquipment);
utilityNetwork.TryGetEquipment <SpanEquipment>(sutConnectToSpanEquipment, out var sutToSpanEquipment);
// Connect inner conduit 2 in 5x10 with inner conduit 3 in 3x10
var connectCmd = new ConnectSpanSegmentsAtRouteNode(
routeNodeId: TestRouteNetwork.CC_1,
spanSegmentsToConnect: new Guid[] {
sutFromSpanEquipment.SpanStructures[4].SpanSegments[0].Id,
sutToSpanEquipment.SpanStructures[3].SpanSegments[0].Id
}
);
var connectResult = await _commandDispatcher.HandleAsync <ConnectSpanSegmentsAtRouteNode, Result>(connectCmd);
var fromEquipmentQueryResult = await _queryDispatcher.HandleAsync <GetEquipmentDetails, Result <GetEquipmentDetailsResult> >(
new GetEquipmentDetails(new EquipmentIdList()
{
sutConnectFromSpanEquipment
})
);
var toEquipmentQueryResult = await _queryDispatcher.HandleAsync <GetEquipmentDetails, Result <GetEquipmentDetailsResult> >(
new GetEquipmentDetails(new EquipmentIdList()
{
sutConnectToSpanEquipment
})
);
// Assert
connectResult.IsSuccess.Should().BeTrue();
fromEquipmentQueryResult.IsSuccess.Should().BeTrue();
toEquipmentQueryResult.IsSuccess.Should().BeTrue();
var fromEquipmentAfterConnect = fromEquipmentQueryResult.Value.SpanEquipment[sutConnectFromSpanEquipment];
fromEquipmentAfterConnect.SpanStructures[4].SpanSegments[0].ToTerminalId.Should().NotBeEmpty();
var terminalId = fromEquipmentAfterConnect.SpanStructures[4].SpanSegments[0].ToTerminalId;
var toEquipmentAfterConnect = toEquipmentQueryResult.Value.SpanEquipment[sutConnectToSpanEquipment];
toEquipmentAfterConnect.SpanStructures[3].SpanSegments[0].FromTerminalId.Should().Be(terminalId);
}
public async void ConnectConduitInSDU1_ShouldSucceed()
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var sutSpanEquipment1 = TestUtilityNetwork.MultiConduit_3x10_SDU_1_to_SDU_2;
var sutSpanEquipment2 = TestUtilityNetwork.MultiConduit_12x7_SDU_1_to_J_1;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutSpanEquipment1, out var spanEquipment1BeforeConnect);
utilityNetwork.TryGetEquipment <SpanEquipment>(sutSpanEquipment2, out var spanEquipment2BeforeConnect);
// Connect inner conduit 1
var connectCmd = new ConnectSpanSegmentsAtRouteNode(
routeNodeId: TestRouteNetwork.SDU_1,
spanSegmentsToConnect: new Guid[] {
spanEquipment1BeforeConnect.SpanStructures[1].SpanSegments[0].Id,
spanEquipment2BeforeConnect.SpanStructures[1].SpanSegments[0].Id
}
);
var connectResult = await _commandDispatcher.HandleAsync <ConnectSpanSegmentsAtRouteNode, Result>(connectCmd);
// Assert
connectResult.IsSuccess.Should().BeTrue();
// Assert trace is correct
var traceQueryResult = await _queryDispatcher.HandleAsync <GetEquipmentDetails, Result <GetEquipmentDetailsResult> >(
new GetEquipmentDetails(new EquipmentIdList()
{
sutSpanEquipment2
})
{
EquipmentDetailsFilter = new EquipmentDetailsFilterOptions()
{
IncludeRouteNetworkTrace = true
}
}
);
traceQueryResult.IsSuccess.Should().BeTrue();
var innerConduit1TraceId = traceQueryResult.Value.SpanEquipment[sutSpanEquipment2].RouteNetworkTraceRefs.First(tr => tr.SpanEquipmentOrSegmentId == spanEquipment2BeforeConnect.SpanStructures[1].SpanSegments[0].Id).TraceId;
var routeNetworkTraces = traceQueryResult.Value.RouteNetworkTraces[innerConduit1TraceId];
routeNetworkTraces.FromRouteNodeId.Should().Be(TestRouteNetwork.J_1);
routeNetworkTraces.ToRouteNodeId.Should().Be(TestRouteNetwork.SDU_2);
}
private async void MakeSureTestConduitIsCutAndConnectedAtCC_1()
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var sutSpanEquipment = TestUtilityNetwork.MultiConduit_5x10_HH_1_to_HH_10;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutSpanEquipment, out var spanEquipment);
// Cut segments in structure 1 (the outer conduit and second inner conduit)
var cutCmd = new CutSpanSegmentsAtRouteNode(
routeNodeId: TestRouteNetwork.CC_1,
spanSegmentsToCut: new Guid[] {
spanEquipment.SpanStructures[0].SpanSegments[0].Id,
spanEquipment.SpanStructures[1].SpanSegments[0].Id,
spanEquipment.SpanStructures[2].SpanSegments[0].Id,
spanEquipment.SpanStructures[3].SpanSegments[0].Id,
spanEquipment.SpanStructures[4].SpanSegments[0].Id
}
);
await _commandDispatcher.HandleAsync <CutSpanSegmentsAtRouteNode, Result>(cutCmd);
var sutConnectFromSpanEquipment = TestUtilityNetwork.MultiConduit_5x10_HH_1_to_HH_10;
var sutConnectToSpanEquipment = TestUtilityNetwork.MultiConduit_3x10_CC_1_to_SP_1;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutConnectFromSpanEquipment, out var sutFromSpanEquipment);
utilityNetwork.TryGetEquipment <SpanEquipment>(sutConnectToSpanEquipment, out var sutToSpanEquipment);
// Connect inner conduit 2 in 5x10 with inner conduit 3 in 3x10
var connectCmd = new ConnectSpanSegmentsAtRouteNode(
routeNodeId: TestRouteNetwork.CC_1,
spanSegmentsToConnect: new Guid[] {
sutFromSpanEquipment.SpanStructures[4].SpanSegments[0].Id,
sutToSpanEquipment.SpanStructures[3].SpanSegments[0].Id
}
);
var connectResult = await _commandDispatcher.HandleAsync <ConnectSpanSegmentsAtRouteNode, Result>(connectCmd);
}
public async void TestConnectWestSegmentToNorthSegmentInCC_1()
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var sutRouteNetworkElement = TestRouteNetwork.CC_1;
var sutSpanEquipment = TestUtilityNetwork.MultiConduit_12x7_HH_1_to_HH_10;
var sutConnectFromSpanEquipment = TestUtilityNetwork.MultiConduit_12x7_HH_1_to_HH_10;
var sutConnectToSpanEquipment = TestUtilityNetwork.MultiConduit_3x10_CC_1_to_SP_1;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutConnectFromSpanEquipment, out var sutFromSpanEquipment);
utilityNetwork.TryGetEquipment <SpanEquipment>(sutConnectToSpanEquipment, out var sutToSpanEquipment);
// Connect inner conduit 2 in 5x10 with inner conduit 3 in 3x10
var connectCmd = new ConnectSpanSegmentsAtRouteNode(Guid.NewGuid(), new UserContext("test", Guid.Empty),
routeNodeId: TestRouteNetwork.CC_1,
spanSegmentsToConnect: new Guid[] {
sutFromSpanEquipment.SpanStructures[2].SpanSegments[0].Id,
sutToSpanEquipment.SpanStructures[3].SpanSegments[0].Id
}
);
var connectResult = await _commandDispatcher.HandleAsync <ConnectSpanSegmentsAtRouteNode, Result>(connectCmd);
var getDiagramQueryResult = await _queryDispatcher.HandleAsync <GetDiagram, Result <GetDiagramResult> >(new GetDiagram(sutRouteNetworkElement));
getDiagramQueryResult.IsSuccess.Should().BeTrue();
var diagram = getDiagramQueryResult.Value.Diagram;
if (System.Environment.OSVersion.Platform.ToString() == "Win32NT")
{
new GeoJsonExporter(diagram).Export("c:/temp/diagram/test.geojson");
}
// Assert
connectResult.IsSuccess.Should().BeTrue();
}
public async void TestMoveSpanEndWithConnections_ShouldFail()
{
MakeSureTestConduitsHasInnerConduitsAndConnections();
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
// Connect flex inner conduit 2 with 5x10 inner conduit 1
utilityNetwork.TryGetEquipment <SpanEquipment>(TestUtilityNetwork.FlexConduit_40_Red_SDU_1_to_SDU_2, out var sutFromSpanEquipment);
utilityNetwork.TryGetEquipment <SpanEquipment>(TestUtilityNetwork.MultiConduit_5x10_SDU_2_to_J_1, out var sutToSpanEquipment);
var connectCmd = new ConnectSpanSegmentsAtRouteNode(
routeNodeId: TestRouteNetwork.J_1,
spanSegmentsToConnect: new Guid[] {
sutFromSpanEquipment.SpanStructures[3].SpanSegments[0].Id,
sutToSpanEquipment.SpanStructures[1].SpanSegments[0].Id
}
);
var connectResult = await _commandDispatcher.HandleAsync <ConnectSpanSegmentsAtRouteNode, Result>(connectCmd);
connectResult.IsSuccess.Should().BeTrue();
// Act
var sutSpanEquipmentId = TestUtilityNetwork.MultiConduit_5x10_SDU_2_to_J_1;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutSpanEquipmentId, out var spanEquipment);
var moveCmd = new MoveSpanEquipment(spanEquipment.Id, new RouteNetworkElementIdList()
{
TestRouteNetwork.S7, TestRouteNetwork.S8
});
var moveCmdResult = await _commandDispatcher.HandleAsync <MoveSpanEquipment, Result>(moveCmd);
// Assert
moveCmdResult.IsFailed.Should().BeTrue();
((MoveSpanEquipmentError)moveCmdResult.Errors.First()).Code.Should().Be(MoveSpanEquipmentErrorCodes.CANNOT_MOVE_FROM_END_BECAUSE_SEGMENTS_ARE_CONNECTED_THERE);
}
public async void ConnectAgainInMergedConduitInJ_1_ShouldSucceed()
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var sutSpanEquipment = TestUtilityNetwork.MultiConduit_12x7_SDU_1_to_J_1;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutSpanEquipment, out var spanEquipmentBeforeCut);
// Connect inner conduit 1
var connectCmd = new ConnectSpanSegmentsAtRouteNode(
routeNodeId: TestRouteNetwork.J_1,
spanSegmentsToConnect: new Guid[] {
spanEquipmentBeforeCut.SpanStructures[1].SpanSegments[0].Id,
spanEquipmentBeforeCut.SpanStructures[1].SpanSegments[1].Id
}
);
var connectResult = await _commandDispatcher.HandleAsync <ConnectSpanSegmentsAtRouteNode, Result>(connectCmd);
utilityNetwork.TryGetEquipment <SpanEquipment>(sutSpanEquipment, out var spanEquipmentAfterConnect);
// Assert
connectResult.IsSuccess.Should().BeTrue();
}
public async void ReconnectInnerConduit1AgainInHH2_ShouldSucceed()
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var sutSpanEquipment = TestUtilityNetwork.MultiConduit_5x10_HH_1_to_HH_10;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutSpanEquipment, out var spanEquipmentBeforeCut);
// Connect inner conduit 1
var connectCmd = new ConnectSpanSegmentsAtRouteNode(
routeNodeId: TestRouteNetwork.HH_2,
spanSegmentsToConnect: new Guid[] {
spanEquipmentBeforeCut.SpanStructures[1].SpanSegments[0].Id,
spanEquipmentBeforeCut.SpanStructures[1].SpanSegments[1].Id
}
);
var connectResult = await _commandDispatcher.HandleAsync <ConnectSpanSegmentsAtRouteNode, Result>(connectCmd);
utilityNetwork.TryGetEquipment <SpanEquipment>(sutSpanEquipment, out var spanEquipmentAfterConnect);
// Assert
connectResult.IsSuccess.Should().BeTrue();
// Check that inner conduit 1 is connected correctly in graph
var innerConduit1Segment1Id = spanEquipmentAfterConnect.SpanStructures[1].SpanSegments[0].Id;
utilityNetwork.Graph.TryGetGraphElement <IUtilityGraphElement>(innerConduit1Segment1Id, out var conduit1segment1UtilityGraphElement);
conduit1segment1UtilityGraphElement.Should().NotBeNull();
var traceResult = utilityNetwork.Graph.TraceSegment(innerConduit1Segment1Id);
((UtilityGraphConnectedTerminal)traceResult.Downstream.Last()).NodeOfInterestId.Should().Be(TestRouteNetwork.CO_1);
((UtilityGraphConnectedTerminal)traceResult.Upstream.Last()).NodeOfInterestId.Should().Be(TestRouteNetwork.SP_1);
}
private async void MakeSureTestConduitsHasInnerConduitsAndConnections()
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var sutSpanEquipmentId = TestUtilityNetwork.FlexConduit_40_Red_SDU_1_to_SDU_2;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutSpanEquipmentId, out var spanEquipment);
if (spanEquipment.SpanStructures.Length > 1)
{
return;
}
// Add 3 inner conduits
var addStructure = new PlaceAdditionalStructuresInSpanEquipment(
spanEquipmentId: sutSpanEquipmentId,
structureSpecificationIds: new Guid[] { TestSpecifications.Ø10_Red, TestSpecifications.Ø10_Black, TestSpecifications.Ø10_Violet }
);
var addStructureResult = await _commandDispatcher.HandleAsync <PlaceAdditionalStructuresInSpanEquipment, Result>(addStructure);
addStructureResult.IsSuccess.Should().BeTrue();
// Cut flex conduit inner conduit 1
utilityNetwork.TryGetEquipment <SpanEquipment>(sutSpanEquipmentId, out var spanEquipment2);
var cutCmd = new CutSpanSegmentsAtRouteNode(
routeNodeId: TestRouteNetwork.J_1,
spanSegmentsToCut: new Guid[] {
spanEquipment2.SpanStructures[0].SpanSegments[0].Id,
spanEquipment2.SpanStructures[1].SpanSegments[0].Id,
spanEquipment2.SpanStructures[2].SpanSegments[0].Id,
spanEquipment2.SpanStructures[3].SpanSegments[0].Id
}
);
var cutCmdResult = await _commandDispatcher.HandleAsync <CutSpanSegmentsAtRouteNode, Result>(cutCmd);
cutCmdResult.IsSuccess.Should().BeTrue();
// Cut 3x10 conduit 1
utilityNetwork.TryGetEquipment <SpanEquipment>(TestUtilityNetwork.MultiConduit_3x10_CC_1_to_HH_11, out var spanEquipment3);
var cutCmd2 = new CutSpanSegmentsAtRouteNode(
routeNodeId: TestRouteNetwork.J_1,
spanSegmentsToCut: new Guid[] {
spanEquipment3.SpanStructures[0].SpanSegments[0].Id,
spanEquipment3.SpanStructures[1].SpanSegments[0].Id
}
);
// Might already be cut in SpanEquipmentCutTests
await _commandDispatcher.HandleAsync <CutSpanSegmentsAtRouteNode, Result>(cutCmd2);
// Connect flex inner conduit 1 with 3-10 inner conduit 1
utilityNetwork.TryGetEquipment <SpanEquipment>(TestUtilityNetwork.FlexConduit_40_Red_SDU_1_to_SDU_2, out var sutFromSpanEquipment);
utilityNetwork.TryGetEquipment <SpanEquipment>(TestUtilityNetwork.MultiConduit_3x10_CC_1_to_HH_11, out var sutToSpanEquipment);
var connectCmd = new ConnectSpanSegmentsAtRouteNode(
routeNodeId: TestRouteNetwork.J_1,
spanSegmentsToConnect: new Guid[] {
sutFromSpanEquipment.SpanStructures[1].SpanSegments[0].Id,
sutToSpanEquipment.SpanStructures[1].SpanSegments[0].Id
}
);
var connectResult = await _commandDispatcher.HandleAsync <ConnectSpanSegmentsAtRouteNode, Result>(connectCmd);
connectResult.IsSuccess.Should().BeTrue();
}
public async void MergeTheTwo12x7inJ_1_ShouldSucceed()
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
// NB: Both span equipment have from node in J_1
var sutFromSpanEquipmentId = TestUtilityNetwork.MultiConduit_12x7_SDU_1_to_J_1;
var sutToSpanEquipmentId = TestUtilityNetwork.MultiConduit_12x7_SDU_2_to_J_1;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutFromSpanEquipmentId, out var fromSpanEquipmentBeforeConnect);
utilityNetwork.TryGetEquipment <SpanEquipment>(sutToSpanEquipmentId, out var toSpanEquipmentBeforeConnect);
// Connect the two outer conduits, which should result in a merge of the two span equipments
var connectCmd = new ConnectSpanSegmentsAtRouteNode(
routeNodeId: TestRouteNetwork.J_1,
spanSegmentsToConnect: new Guid[] {
fromSpanEquipmentBeforeConnect.SpanStructures[0].SpanSegments[0].Id,
toSpanEquipmentBeforeConnect.SpanStructures[0].SpanSegments[0].Id
}
);
var connectResult = await _commandDispatcher.HandleAsync <ConnectSpanSegmentsAtRouteNode, Result>(connectCmd);
utilityNetwork.TryGetEquipment <SpanEquipment>(sutFromSpanEquipmentId, out var fromSpanEquipmentAfterConnect);
utilityNetwork.TryGetEquipment <SpanEquipment>(sutToSpanEquipmentId, out var toSpanEquipmentAfterConnect);
var j1NetworkQueryResult = await _queryDispatcher.HandleAsync <GetRouteNetworkDetails, Result <GetRouteNetworkDetailsResult> >(
new GetRouteNetworkDetails(new RouteNetworkElementIdList()
{
TestRouteNetwork.J_1
})
{
RelatedInterestFilter = RelatedInterestFilterOptions.ReferencesFromRouteElementAndInterestObjects
}
);
// Assert
connectResult.IsSuccess.Should().BeTrue();
j1NetworkQueryResult.IsSuccess.Should().BeTrue();
// from span equipment must still be referenced from J_1
j1NetworkQueryResult.Value.RouteNetworkElements[TestRouteNetwork.J_1].InterestRelations.Any(i => i.RefId == fromSpanEquipmentBeforeConnect.WalkOfInterestId).Should().BeTrue();
// to span equipment must no longer be referenced from J_1
j1NetworkQueryResult.Value.RouteNetworkElements[TestRouteNetwork.J_1].InterestRelations.Any(i => i.RefId == toSpanEquipmentBeforeConnect.WalkOfInterestId).Should().BeFalse();
// to span equipment must no have an interest
j1NetworkQueryResult.Value.Interests.ContainsKey(toSpanEquipmentBeforeConnect.WalkOfInterestId).Should().BeFalse();
// Check interest information of from span equipment
j1NetworkQueryResult.Value.Interests[fromSpanEquipmentBeforeConnect.WalkOfInterestId].RouteNetworkElementRefs.Count().Should().Be(5);
j1NetworkQueryResult.Value.Interests[fromSpanEquipmentBeforeConnect.WalkOfInterestId].RouteNetworkElementRefs[0].Should().Be(TestRouteNetwork.SDU_2);
j1NetworkQueryResult.Value.Interests[fromSpanEquipmentBeforeConnect.WalkOfInterestId].RouteNetworkElementRefs[1].Should().Be(TestRouteNetwork.S8);
j1NetworkQueryResult.Value.Interests[fromSpanEquipmentBeforeConnect.WalkOfInterestId].RouteNetworkElementRefs[2].Should().Be(TestRouteNetwork.J_1);
j1NetworkQueryResult.Value.Interests[fromSpanEquipmentBeforeConnect.WalkOfInterestId].RouteNetworkElementRefs[3].Should().Be(TestRouteNetwork.S7);
j1NetworkQueryResult.Value.Interests[fromSpanEquipmentBeforeConnect.WalkOfInterestId].RouteNetworkElementRefs[4].Should().Be(TestRouteNetwork.SDU_1);
fromSpanEquipmentAfterConnect.Should().NotBeNull();
// To span equipment should be deleted
toSpanEquipmentAfterConnect.Should().BeNull();
// From span segment should still end in SDU_1
fromSpanEquipmentAfterConnect.NodesOfInterestIds.Last().Should().Be(TestRouteNetwork.SDU_1);
// From span segment should now start en SDU 2
fromSpanEquipmentAfterConnect.NodesOfInterestIds.First().Should().Be(TestRouteNetwork.SDU_2);
// Check if an event is published to the notification.utility-network topic having an idlist containing the span equipment id we just created
var utilityNetworkNotifications = _externalEventProducer.GetMessagesByTopic("notification.utility-network").OfType <RouteNetworkElementContainedEquipmentUpdated>();
var utilityNetworkUpdatedEvent = utilityNetworkNotifications.First(n => n.Category == "EquipmentModification.Merge" && n.IdChangeSets != null && n.IdChangeSets.Any(i => i.IdList.Any(i => i == sutFromSpanEquipmentId)));
utilityNetworkUpdatedEvent.AffectedRouteNetworkElementIds.Should().Contain(TestRouteNetwork.J_1);
utilityNetworkUpdatedEvent.AffectedRouteNetworkElementIds.Should().Contain(TestRouteNetwork.SDU_1);
utilityNetworkUpdatedEvent.AffectedRouteNetworkElementIds.Should().Contain(TestRouteNetwork.SDU_2);
// Assert trace is correct
var traceQueryResult = await _queryDispatcher.HandleAsync <GetEquipmentDetails, Result <GetEquipmentDetailsResult> >(
new GetEquipmentDetails(new EquipmentIdList()
{
sutFromSpanEquipmentId
})
{
EquipmentDetailsFilter = new EquipmentDetailsFilterOptions()
{
IncludeRouteNetworkTrace = true
}
}
);
traceQueryResult.IsSuccess.Should().BeTrue();
var innerConduit1TraceId = traceQueryResult.Value.SpanEquipment[sutFromSpanEquipmentId].RouteNetworkTraceRefs.First(tr => tr.SpanEquipmentOrSegmentId == fromSpanEquipmentBeforeConnect.SpanStructures[1].SpanSegments[0].Id).TraceId;
var routeNetworkTraces = traceQueryResult.Value.RouteNetworkTraces[innerConduit1TraceId];
routeNetworkTraces.FromRouteNodeId.Should().Be(TestRouteNetwork.SDU_2);
routeNetworkTraces.ToRouteNodeId.Should().Be(TestRouteNetwork.SDU_2);
}
public SpanEquipmentMutations(ICommandDispatcher commandDispatcher, IEventStore eventStore)
{
Description = "Span equipment mutations";
FieldAsync <CommandResultType>(
"placeSpanEquipmentInRouteNetwork",
description: "Place a span equipment (i.e. conduit, cable whatwever) in the route network",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "spanEquipmentId"
},
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "spanEquipmentSpecificationId"
},
new QueryArgument <NonNullGraphType <ListGraphType <IdGraphType> > > {
Name = "routeSegmentIds"
},
new QueryArgument <IdGraphType> {
Name = "manufacturerId"
},
new QueryArgument <MarkingInfoInputType> {
Name = "markingInfo"
},
new QueryArgument <NamingInfoInputType> {
Name = "namingInfo"
},
new QueryArgument <AddressInfoInputType> {
Name = "addressInfo"
}
),
resolve: async context =>
{
var spanEquipmentId = context.GetArgument <Guid>("spanEquipmentId");
var spanEquipmentSpecificationId = context.GetArgument <Guid>("spanEquipmentSpecificationId");
var routeSegmentIds = context.GetArgument <List <Guid> >("routeSegmentIds");
var manufacturerId = context.GetArgument <Guid>("manufacturerId");
var markingInfo = context.GetArgument <MarkingInfo>("markingInfo");
var namingInfo = context.GetArgument <NamingInfo>("namingInfo");
var addressInfo = context.GetArgument <AddressInfo>("addressInfo");
// Name conduit span equipment
// TODO: Refactor into som class responsible for span equipment naming
var spec = eventStore.Projections.Get <SpanEquipmentSpecificationsProjection>().Specifications[spanEquipmentSpecificationId];
namingInfo = CalculateName(eventStore, namingInfo, spec);
var correlationId = Guid.NewGuid();
var userContext = context.UserContext as GraphQLUserContext;
var userName = userContext.Username;
// TODO: Get from work manager
var workTaskId = Guid.Parse("54800ae5-13a5-4b03-8626-a63b66a25568");
var commandUserContext = new UserContext(userName, workTaskId);
var spanEquipments = eventStore.Projections.Get <UtilityNetworkProjection>().SpanEquipmentsByEquipmentId;
// First register the walk in the route network where the client want to place the span equipment
var walkOfInterestId = Guid.NewGuid();
var walk = new RouteNetworkElementIdList();
walk.AddRange(routeSegmentIds);
var registerWalkOfInterestCommand = new RegisterWalkOfInterest(correlationId, commandUserContext, walkOfInterestId, walk);
var registerWalkOfInterestCommandResult = await commandDispatcher.HandleAsync <RegisterWalkOfInterest, Result <RouteNetworkInterest> >(registerWalkOfInterestCommand);
if (registerWalkOfInterestCommandResult.IsFailed)
{
return(new CommandResult(registerWalkOfInterestCommandResult));
}
// Now place the conduit in the walk
var placeSpanEquipmentCommand = new PlaceSpanEquipmentInRouteNetwork(
correlationId, commandUserContext, spanEquipmentId, spanEquipmentSpecificationId, registerWalkOfInterestCommandResult.Value)
{
ManufacturerId = manufacturerId,
NamingInfo = namingInfo,
MarkingInfo = markingInfo,
LifecycleInfo = new LifecycleInfo(DeploymentStateEnum.InService, null, null),
AddressInfo = addressInfo
};
var placeSpanEquipmentResult = await commandDispatcher.HandleAsync <PlaceSpanEquipmentInRouteNetwork, Result>(placeSpanEquipmentCommand);
// Unregister interest if place span equipment failed
if (placeSpanEquipmentResult.IsFailed)
{
var unregisterCommandResult = await commandDispatcher.HandleAsync <UnregisterInterest, Result>(
new UnregisterInterest(correlationId, commandUserContext, walkOfInterestId));
if (unregisterCommandResult.IsFailed)
{
return(new CommandResult(unregisterCommandResult));
}
}
return(new CommandResult(placeSpanEquipmentResult));
}
);
FieldAsync <CommandResultType>(
"affixSpanEquipmentToNodeContainer",
description: "Affix a span equipment to a node container - i.e. to some condult closure, man hole etc.",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <ListGraphType <IdGraphType> > > {
Name = "spanSegmentIds"
},
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "nodeContainerId"
},
new QueryArgument <NonNullGraphType <NodeContainerSideEnumType> > {
Name = "nodeContainerSide"
}
),
resolve: async context =>
{
var spanSegmentIds = context.GetArgument <List <Guid> >("spanSegmentIds");
var nodeContainerId = context.GetArgument <Guid>("nodeContainerId");
var side = context.GetArgument <NodeContainerSideEnum>("nodeContainerSide");
var correlationId = Guid.NewGuid();
var userContext = context.UserContext as GraphQLUserContext;
var userName = userContext.Username;
// TODO: Get from work manager
var workTaskId = Guid.Parse("54800ae5-13a5-4b03-8626-a63b66a25568");
var commandUserContext = new UserContext(userName, workTaskId);
foreach (var spanSegmentId in spanSegmentIds)
{
var affixCommand = new AffixSpanEquipmentToNodeContainer(correlationId, commandUserContext, spanSegmentId, nodeContainerId, side);
var affixCommandResult = await commandDispatcher.HandleAsync <AffixSpanEquipmentToNodeContainer, Result>(affixCommand);
if (affixCommandResult.IsFailed)
{
return(new CommandResult(affixCommandResult));
}
}
return(new CommandResult(Result.Ok()));
}
);
FieldAsync <CommandResultType>(
"detachSpanEquipmentFromNodeContainer",
description: "Detach a span equipment from a node container - i.e. from some condult closure, man hole etc.",
arguments: new QueryArguments(
new QueryArgument <ListGraphType <IdGraphType> > {
Name = "spanSegmentIds"
},
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "routeNodeId"
}
),
resolve: async context =>
{
var spanSegmentIds = context.GetArgument <List <Guid> >("spanSegmentIds");
var routeNodeId = context.GetArgument <Guid>("routeNodeId");
var correlationId = Guid.NewGuid();
var userContext = context.UserContext as GraphQLUserContext;
var userName = userContext.Username;
// TODO: Get from work manager
var workTaskId = Guid.Parse("54800ae5-13a5-4b03-8626-a63b66a25568");
var commandUserContext = new UserContext(userName, workTaskId)
{
EditingRouteNodeId = routeNodeId
};
foreach (var spanSegmentId in spanSegmentIds)
{
var detachCommand = new DetachSpanEquipmentFromNodeContainer(correlationId, commandUserContext, spanSegmentId, routeNodeId);
var detachCommandResult = await commandDispatcher.HandleAsync <DetachSpanEquipmentFromNodeContainer, Result>(detachCommand);
if (detachCommandResult.IsFailed)
{
return(new CommandResult(detachCommandResult));
}
}
return(new CommandResult(Result.Ok()));
}
);
FieldAsync <CommandResultType>(
"cutSpanSegments",
description: "Cut the span segments belonging to som span equipment at the route node specified",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "routeNodeId"
},
new QueryArgument <NonNullGraphType <ListGraphType <IdGraphType> > > {
Name = "spanSegmentstoCut"
}
),
resolve: async context =>
{
var routeNodeId = context.GetArgument <Guid>("routeNodeId");
var spanSegmentToCut = context.GetArgument <Guid[]>("spanSegmentstoCut");
var correlationId = Guid.NewGuid();
var userContext = context.UserContext as GraphQLUserContext;
var userName = userContext.Username;
// TODO: Get from work manager
var workTaskId = Guid.Parse("54800ae5-13a5-4b03-8626-a63b66a25568");
var commandUserContext = new UserContext(userName, workTaskId)
{
EditingRouteNodeId = routeNodeId
};
var cutCmd = new CutSpanSegmentsAtRouteNode(correlationId, commandUserContext, routeNodeId, spanSegmentToCut);
var cutResult = await commandDispatcher.HandleAsync <CutSpanSegmentsAtRouteNode, Result>(cutCmd);
return(new CommandResult(cutResult));
}
);
FieldAsync <CommandResultType>(
"connectSpanSegments",
description: "Connect the span segments belonging to two different span equipment at the route node specified",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "routeNodeId"
},
new QueryArgument <NonNullGraphType <ListGraphType <IdGraphType> > > {
Name = "spanSegmentsToConnect"
}
),
resolve: async context =>
{
var routeNodeId = context.GetArgument <Guid>("routeNodeId");
var spanSegmentToConnect = context.GetArgument <Guid[]>("spanSegmentsToConnect");
var correlationId = Guid.NewGuid();
var userContext = context.UserContext as GraphQLUserContext;
var userName = userContext.Username;
// TODO: Get from work manager
var workTaskId = Guid.Parse("54800ae5-13a5-4b03-8626-a63b66a25568");
var commandUserContext = new UserContext(userName, workTaskId)
{
EditingRouteNodeId = routeNodeId
};
var connectCmd = new ConnectSpanSegmentsAtRouteNode(correlationId, commandUserContext, routeNodeId, spanSegmentToConnect);
var connectResult = await commandDispatcher.HandleAsync <ConnectSpanSegmentsAtRouteNode, Result>(connectCmd);
return(new CommandResult(connectResult));
}
);
FieldAsync <CommandResultType>(
"disconnectSpanSegments",
description: "Disconnect two span segments belonging to two different span equipment at the route node specified",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "routeNodeId"
},
new QueryArgument <NonNullGraphType <ListGraphType <IdGraphType> > > {
Name = "spanSegmentsToDisconnect"
}
),
resolve: async context =>
{
var routeNodeId = context.GetArgument <Guid>("routeNodeId");
var spanSegmentToDisconnect = context.GetArgument <Guid[]>("spanSegmentsToDisconnect");
var correlationId = Guid.NewGuid();
var userContext = context.UserContext as GraphQLUserContext;
var userName = userContext.Username;
// TODO: Get from work manager
var workTaskId = Guid.Parse("54800ae5-13a5-4b03-8626-a63b66a25568");
var commandUserContext = new UserContext(userName, workTaskId)
{
EditingRouteNodeId = routeNodeId
};
var disconnectCmd = new DisconnectSpanSegmentsAtRouteNode(correlationId, commandUserContext, routeNodeId, spanSegmentToDisconnect);
var disconnectResult = await commandDispatcher.HandleAsync <DisconnectSpanSegmentsAtRouteNode, Result>(disconnectCmd);
return(new CommandResult(disconnectResult));
}
);
FieldAsync <CommandResultType>(
"addAdditionalInnerSpanStructures",
description: "Add inner span structures to an existing span equipment",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "spanEquipmentOrSegmentId"
},
new QueryArgument <NonNullGraphType <ListGraphType <IdGraphType> > > {
Name = "spanStructureSpecificationIds"
}
),
resolve: async context =>
{
var spanEquipmentOrSegmentId = context.GetArgument <Guid>("spanEquipmentOrSegmentId");
var specificationsId = context.GetArgument <Guid[]>("spanStructureSpecificationIds");
var correlationId = Guid.NewGuid();
var userContext = context.UserContext as GraphQLUserContext;
var userName = userContext.Username;
// TODO: Get from work manager
var workTaskId = Guid.Parse("54800ae5-13a5-4b03-8626-a63b66a25568");
var commandUserContext = new UserContext(userName, workTaskId);
var addStructure = new PlaceAdditionalStructuresInSpanEquipment(
correlationId: correlationId,
userContext: commandUserContext,
spanEquipmentId: spanEquipmentOrSegmentId,
structureSpecificationIds: specificationsId
);
var addStructureResult = await commandDispatcher.HandleAsync <PlaceAdditionalStructuresInSpanEquipment, Result>(addStructure);
return(new CommandResult(addStructureResult));
}
);
FieldAsync <CommandResultType>(
"removeSpanStructure",
description: "Remove inner or outer span structure of a span equipment. When the outer span structure is removed the entire span equipment is removed from the network.",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "spanSegmentId"
}
),
resolve: async context =>
{
var spanSegmentId = context.GetArgument <Guid>("spanSegmentId");
var correlationId = Guid.NewGuid();
var userContext = context.UserContext as GraphQLUserContext;
var userName = userContext.Username;
// TODO: Get from work manager
var workTaskId = Guid.Parse("54800ae5-13a5-4b03-8626-a63b66a25568");
var commandUserContext = new UserContext(userName, workTaskId);
var removeStructure = new RemoveSpanStructureFromSpanEquipment(
correlationId: correlationId,
userContext: commandUserContext,
spanSegmentId: spanSegmentId
);
var removeStructureResult = await commandDispatcher.HandleAsync <RemoveSpanStructureFromSpanEquipment, Result>(removeStructure);
return(new CommandResult(removeStructureResult));
}
);
FieldAsync <CommandResultType>(
"move",
description: "Move a span equipment / change its walk in the route network",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "spanEquipmentOrSegmentId"
},
new QueryArgument <NonNullGraphType <ListGraphType <IdGraphType> > > {
Name = "routeSegmentIds"
}
),
resolve: async context =>
{
var spanEquipmentOrSegmentId = context.GetArgument <Guid>("spanEquipmentOrSegmentId");
var correlationId = Guid.NewGuid();
var userContext = context.UserContext as GraphQLUserContext;
var userName = userContext.Username;
// TODO: Get from work manager
var workTaskId = Guid.Parse("54800ae5-13a5-4b03-8626-a63b66a25568");
var commandUserContext = new UserContext(userName, workTaskId);
Guid[] routeSegmentIds = context.GetArgument <Guid[]>("routeSegmentIds");
RouteNetworkElementIdList newWalkIds = new();
newWalkIds.AddRange(routeSegmentIds);
var moveCmd = new MoveSpanEquipment(
correlationId: correlationId,
userContext: commandUserContext,
spanEquipmentId: spanEquipmentOrSegmentId,
newWalkIds: newWalkIds
);
var moveCmdResult = await commandDispatcher.HandleAsync <MoveSpanEquipment, Result>(moveCmd);
return(new CommandResult(moveCmdResult));
}
);
FieldAsync <CommandResultType>(
"updateProperties",
description: "Mutation that can be used to change the span equipment specification, manufacturer and/or marking information",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "spanEquipmentOrSegmentId"
},
new QueryArgument <IdGraphType> {
Name = "spanEquipmentSpecificationId"
},
new QueryArgument <IdGraphType> {
Name = "manufacturerId"
},
new QueryArgument <MarkingInfoInputType> {
Name = "markingInfo"
},
new QueryArgument <AddressInfoInputType> {
Name = "addressInfo"
}
),
resolve: async context =>
{
var spanEquipmentOrSegmentId = context.GetArgument <Guid>("spanEquipmentOrSegmentId");
var correlationId = Guid.NewGuid();
var userContext = context.UserContext as GraphQLUserContext;
var userName = userContext.Username;
// TODO: Get from work manager
var workTaskId = Guid.Parse("54800ae5-13a5-4b03-8626-a63b66a25568");
var commandUserContext = new UserContext(userName, workTaskId);
var updateCmd = new UpdateSpanEquipmentProperties(correlationId, commandUserContext, spanEquipmentOrSegmentId: spanEquipmentOrSegmentId)
{
SpecificationId = context.HasArgument("spanEquipmentSpecificationId") ? context.GetArgument <Guid>("spanEquipmentSpecificationId") : null,
ManufacturerId = context.HasArgument("manufacturerId") ? context.GetArgument <Guid>("manufacturerId") : null,
MarkingInfo = context.HasArgument("markingInfo") ? context.GetArgument <MarkingInfo>("markingInfo") : null,
AddressInfo = context.HasArgument("addressInfo") ? context.GetArgument <AddressInfo>("addressInfo") : null
};
var updateResult = await commandDispatcher.HandleAsync <UpdateSpanEquipmentProperties, Result>(updateCmd);
return(new CommandResult(updateResult));
}
);
FieldAsync <CommandResultType>(
"affixSpanEquipmentToParent",
description: "Affix a span equipment to a parent span equipment - i.e. put a cable inside a conduit",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "routeNodeId"
},
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "spanSegmentId1"
},
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "spanSegmentId2"
}
),
resolve: async context =>
{
var routeNodeId = context.GetArgument <Guid>("routeNodeId");
var spanSegmentId1 = context.GetArgument <Guid>("spanSegmentId1");
var spanSegmentId2 = context.GetArgument <Guid>("spanSegmentId2");
var correlationId = Guid.NewGuid();
var userContext = context.UserContext as GraphQLUserContext;
var userName = userContext.Username;
// TODO: Get from work manager
var workTaskId = Guid.Parse("54800ae5-13a5-4b03-8626-a63b66a25568");
var commandUserContext = new UserContext(userName, workTaskId);
var affixCommand = new AffixSpanEquipmentToParent(correlationId, commandUserContext, routeNodeId, spanSegmentId1, spanSegmentId2);
var affixCommandResult = await commandDispatcher.HandleAsync <AffixSpanEquipmentToParent, Result>(affixCommand);
if (affixCommandResult.IsFailed)
{
return(new CommandResult(affixCommandResult));
}
return(new CommandResult(Result.Ok()));
}
);
FieldAsync <CommandResultType>(
"connectToTerminalEquipment",
description: "Connect one or more span segments inside a span equipment to terminals inside a terminal equipmment",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "routeNodeId"
},
new QueryArgument <NonNullGraphType <ListGraphType <ConnectSpanSegmentToTerminalOperationInputType> > > {
Name = "connects"
}
),
resolve: async context =>
{
var routeNodeId = context.GetArgument <Guid>("routeNodeId");
var connects = context.GetArgument <ConnectSpanSegmentToTerminalOperation[]>("connects");
var correlationId = Guid.NewGuid();
var userContext = context.UserContext as GraphQLUserContext;
var userName = userContext.Username;
// TODO: Get from work manager
var workTaskId = Guid.Parse("54800ae5-13a5-4b03-8626-a63b66a25568");
var commandUserContext = new UserContext(userName, workTaskId);
var connectCommand = new ConnectSpanSegmentsWithTerminalsAtRouteNode(correlationId, commandUserContext, routeNodeId, connects);
var connectCommandResult = await commandDispatcher.HandleAsync <ConnectSpanSegmentsWithTerminalsAtRouteNode, Result>(connectCommand);
if (connectCommandResult.IsFailed)
{
return(new CommandResult(connectCommandResult));
}
return(new CommandResult(Result.Ok()));
}
);
FieldAsync <CommandResultType>(
"disconnectFromTerminalEquipment",
description: "Disconnect one or more span segments inside a span equipment from terminals inside a terminal equipmment",
arguments: new QueryArguments(
new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "routeNodeId"
},
new QueryArgument <NonNullGraphType <ListGraphType <DisconnectSpanSegmentFromTerminalOperationInputType> > > {
Name = "disconnects"
}
),
resolve: async context =>
{
var routeNodeId = context.GetArgument <Guid>("routeNodeId");
var connects = context.GetArgument <DisconnectSpanSegmentFromTerminalOperation[]>("disconnects");
var correlationId = Guid.NewGuid();
var userContext = context.UserContext as GraphQLUserContext;
var userName = userContext.Username;
// TODO: Get from work manager
var workTaskId = Guid.Parse("54800ae5-13a5-4b03-8626-a63b66a25568");
var commandUserContext = new UserContext(userName, workTaskId);
var connectCommand = new DisconnectSpanSegmentsFromTerminalsAtRouteNode(correlationId, commandUserContext, routeNodeId, connects);
var connectCommandResult = await commandDispatcher.HandleAsync <DisconnectSpanSegmentsFromTerminalsAtRouteNode, Result>(connectCommand);
if (connectCommandResult.IsFailed)
{
return(new CommandResult(connectCommandResult));
}
return(new CommandResult(Result.Ok()));
}
);
}
public async Task ConnectInnerDuct2In3x10sIn_HH_10()
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var nodeOfInterestId = Guid.NewGuid();
var registerNodeOfInterestCommand = new RegisterNodeOfInterest(Guid.NewGuid(), new UserContext("test", Guid.Empty), nodeOfInterestId, TestRouteNetwork.HH_10);
var registerNodeOfInterestCommandResult = _commandDispatcher.HandleAsync <RegisterNodeOfInterest, Result <RouteNetworkInterest> >(registerNodeOfInterestCommand).Result;
var placeNodeContainerCommand = new PlaceNodeContainerInRouteNetwork(Guid.NewGuid(), new UserContext("test", Guid.Empty), Guid.NewGuid(), TestSpecifications.Conduit_Closure_Emtelle_Branch_Box, registerNodeOfInterestCommandResult.Value)
{
ManufacturerId = TestSpecifications.Manu_Emtelle
};
// Place node container
var placeNodeContainerResult = await _commandDispatcher.HandleAsync <PlaceNodeContainerInRouteNetwork, Result>(placeNodeContainerCommand);
// Affix conduit 1
var testConduitId1 = TestConduits.Conduit_3x10_HH_10_to_HH_11;
var testConduit1 = _eventStore.Projections.Get <UtilityNetworkProjection>().SpanEquipmentsByEquipmentId[testConduitId1];
var affixConduitToContainerCommand1 = new AffixSpanEquipmentToNodeContainer(Guid.NewGuid(), new UserContext("test", Guid.Empty),
spanEquipmentOrSegmentId: testConduit1.SpanStructures[0].SpanSegments[0].Id,
nodeContainerId: placeNodeContainerCommand.NodeContainerId,
nodeContainerIngoingSide: NodeContainerSideEnum.North
);
var affixResult1 = await _commandDispatcher.HandleAsync <AffixSpanEquipmentToNodeContainer, Result>(affixConduitToContainerCommand1);
affixResult1.IsSuccess.Should().BeTrue();
// Affix conduit 2
var testConduitId2 = TestConduits.Conduit_5x10_HH_1_to_HH_10;
var testConduit2 = _eventStore.Projections.Get <UtilityNetworkProjection>().SpanEquipmentsByEquipmentId[testConduitId2];
var affixConduitToContainerCommand2 = new AffixSpanEquipmentToNodeContainer(Guid.NewGuid(), new UserContext("test", Guid.Empty),
spanEquipmentOrSegmentId: testConduit2.SpanStructures[0].SpanSegments[0].Id,
nodeContainerId: placeNodeContainerCommand.NodeContainerId,
nodeContainerIngoingSide: NodeContainerSideEnum.South
);
var affixResult2 = await _commandDispatcher.HandleAsync <AffixSpanEquipmentToNodeContainer, Result>(affixConduitToContainerCommand2);
affixResult2.IsSuccess.Should().BeTrue();
// Connect inner conduit 2
var sutConnectFromSpanEquipment = TestConduits.Conduit_5x10_HH_1_to_HH_10;
var sutConnectToSpanEquipment = TestConduits.Conduit_3x10_HH_10_to_HH_11;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutConnectFromSpanEquipment, out var sutFromSpanEquipment);
utilityNetwork.TryGetEquipment <SpanEquipment>(sutConnectToSpanEquipment, out var sutToSpanEquipment);
// Connect inner conduit 2 in 3x10 with inner conduit 2 in the other 3x10 in node HH 10
var connectCmd = new ConnectSpanSegmentsAtRouteNode(Guid.NewGuid(), new UserContext("test", Guid.Empty),
routeNodeId: TestRouteNetwork.HH_10,
spanSegmentsToConnect: new Guid[] {
sutFromSpanEquipment.SpanStructures[2].SpanSegments[0].Id,
sutToSpanEquipment.SpanStructures[2].SpanSegments[0].Id
}
);
var connectResult = await _commandDispatcher.HandleAsync <ConnectSpanSegmentsAtRouteNode, Result>(connectCmd);
connectResult.IsSuccess.Should().BeTrue();
}
