public async void ReverseVerticalAlligmentInContainerInJ2_ShouldSucceed()
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var sutNodeContainerId = TestUtilityNetwork.NodeContainer_J_1;
utilityNetwork.TryGetEquipment <NodeContainer>(sutNodeContainerId, out var nodeContainerBeforeFlip);
var reverseCmd = new ReverseNodeContainerVerticalContentAlignment(sutNodeContainerId);
var reverseResult = await _commandDispatcher.HandleAsync <ReverseNodeContainerVerticalContentAlignment, Result>(reverseCmd);
var equipmentQueryResult = await _queryDispatcher.HandleAsync <GetEquipmentDetails, Result <GetEquipmentDetailsResult> >(
new GetEquipmentDetails(new InterestIdList()
{
nodeContainerBeforeFlip.InterestId
})
);
// Assert
nodeContainerBeforeFlip.VertialContentAlignmemt.Should().Be(NodeContainerVerticalContentAlignmentEnum.Bottom);
reverseResult.IsSuccess.Should().BeTrue();
equipmentQueryResult.IsSuccess.Should().BeTrue();
equipmentQueryResult.Value.NodeContainers[sutNodeContainerId].VertialContentAlignmemt.Should().Be(NodeContainerVerticalContentAlignmentEnum.Top);
// Check if an event is published to the notification.utility-network topic having an idlist containing the node container we just changed
var utilityNetworkNotifications = _externalEventProducer.GetMessagesByTopic("notification.utility-network").OfType <RouteNetworkElementContainedEquipmentUpdated>();
var utilityNetworkUpdatedEvent = utilityNetworkNotifications.First(n => n.Category == "EquipmentModification" && n.IdChangeSets != null && n.IdChangeSets.Any(i => i.IdList.Any(i => i == sutNodeContainerId)));
utilityNetworkUpdatedEvent.AffectedRouteNetworkElementIds.Should().Contain(TestRouteNetwork.J_1);
}
public async void AddSpanStructureSpecificationTest()
{
// Setup
var spec1 = new SpanStructureSpecification(Guid.NewGuid(), "Conduit", "Ø12", "Red")
{
OuterDiameter = 12,
InnerDiameter = 10
};
var spec2 = new SpanStructureSpecification(Guid.NewGuid(), "Conduit", "Ø50", "Red")
{
OuterDiameter = 50,
InnerDiameter = 45
};
// Act
var cmd1 = new AddSpanStructureSpecification(spec1);
Result cmd1Result = await _commandDispatcher.HandleAsync <AddSpanStructureSpecification, Result>(cmd1);
var cmd2 = new AddSpanStructureSpecification(spec2);
Result cmd2Result = await _commandDispatcher.HandleAsync <AddSpanStructureSpecification, Result>(cmd2);
var spanStructureSpecificationsQueryResult = await _queryDispatcher.HandleAsync <GetSpanStructureSpecifications, Result <LookupCollection <SpanStructureSpecification> > >(new GetSpanStructureSpecifications());
// Assert
cmd1Result.IsSuccess.Should().BeTrue();
cmd2Result.IsSuccess.Should().BeTrue();
spanStructureSpecificationsQueryResult.IsSuccess.Should().BeTrue();
spanStructureSpecificationsQueryResult.Value[spec1.Id].Should().BeEquivalentTo(spec1);
spanStructureSpecificationsQueryResult.Value[spec2.Id].Should().BeEquivalentTo(spec2);
}
public async void QueryHandHoles100MeterRadiusFromJ1_ShouldReturn4HandHandholes()
{
// Setup
var stops = new RouteNodeKindEnum[] { RouteNodeKindEnum.CentralOfficeSmall };
var interests = new RouteNodeKindEnum[] { RouteNodeKindEnum.HandHole };
var nearestNodeQuery = new FindNearestRouteNodes(TestRouteNetwork.J_1, 10, 100, stops, interests);
// Act
var nearestNodeQueryResult = await _queryDispatcher.HandleAsync <FindNearestRouteNodes, Result <FindNearestRouteNodesResult> >(nearestNodeQuery);
// Assert
nearestNodeQueryResult.IsSuccess.Should().BeTrue();
// We should get 4 hand holes back
nearestNodeQueryResult.Value.RouteNetworkTraces.Count().Should().Be(4);
nearestNodeQueryResult.Value.RouteNetworkElements.Count().Should().Be(4);
nearestNodeQueryResult.Value.RouteNetworkElements.Count(r => r.RouteNodeInfo.Kind == RouteNodeKindEnum.HandHole).Should().Be(4);
// Check trace for handhole HH_10
var handHole10Trace = nearestNodeQueryResult.Value.RouteNetworkTraces[TestRouteNetwork.HH_10];
handHole10Trace.Name.Should().Be("HH-10");
handHole10Trace.RouteNetworkSegmentIds.Length.Should().Be(3);
handHole10Trace.RouteNetworkSegmentGeometries.Length.Should().Be(3);
handHole10Trace.RouteNetworkSegmentIds[0].Should().Be(TestRouteNetwork.S13);
handHole10Trace.RouteNetworkSegmentIds[1].Should().Be(TestRouteNetwork.S5);
handHole10Trace.RouteNetworkSegmentIds[2].Should().Be(TestRouteNetwork.S6);
handHole10Trace.Distance.Should().BeInRange(94, 96);
}
public async void TestAffixConduitToContainer_ShouldSucceed()
{
var nodeContainerId = PlaceNodeContainer(TestRouteNetwork.HH_2);
var testNetwork = new TestUtilityNetwork(_commandDispatcher, _queryDispatcher).Run();
var testConduitId = TestUtilityNetwork.MultiConduit_5x10_HH_1_to_HH_10;
var testConduit = _eventStore.Projections.Get <UtilityNetworkProjection>().SpanEquipments[testConduitId];
var affixConduitToContainerCommand = new AffixSpanEquipmentToNodeContainer(
spanEquipmentOrSegmentId: testConduit.SpanStructures[0].SpanSegments[0].Id,
nodeContainerId: nodeContainerId,
nodeContainerIngoingSide: NodeContainerSideEnum.West
);
var affixResult = await _commandDispatcher.HandleAsync <AffixSpanEquipmentToNodeContainer, Result>(affixConduitToContainerCommand);
var equipmentQueryResult = await _queryDispatcher.HandleAsync <GetEquipmentDetails, Result <GetEquipmentDetailsResult> >(
new GetEquipmentDetails(new EquipmentIdList()
{
testConduitId
})
);
equipmentQueryResult.IsSuccess.Should().BeTrue();
equipmentQueryResult.Value.SpanEquipment[testConduitId].NodeContainerAffixes.First(n => n.NodeContainerId == nodeContainerId).NodeContainerIngoingSide.Should().Be(NodeContainerSideEnum.West);
// 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.IdChangeSets != null && n.IdChangeSets.Any(i => i.IdList.Any(i => i == nodeContainerId) && i.ChangeType == Events.Changes.ChangeTypeEnum.Modification));
utilityNetworkUpdatedEvent.AffectedRouteNetworkElementIds.Should().Contain(TestRouteNetwork.HH_2);
}
public async Task CreateRouteNodeContainerInCC_1()
{
var nodeOfInterestId = Guid.NewGuid();
var registerNodeOfInterestCommand = new RegisterNodeOfInterest(Guid.NewGuid(), new UserContext("test", Guid.Empty), nodeOfInterestId, TestRouteNetwork.CC_1);
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
};
// Act
var placeNodeContainerResult = await _commandDispatcher.HandleAsync <PlaceNodeContainerInRouteNetwork, Result>(placeNodeContainerCommand);
var equipmentQueryResult = await _queryDispatcher.HandleAsync <GetEquipmentDetails, Result <GetEquipmentDetailsResult> >(
new GetEquipmentDetails(new InterestIdList()
{
nodeOfInterestId
})
);
// Assert
placeNodeContainerResult.IsSuccess.Should().BeTrue();
equipmentQueryResult.IsSuccess.Should().BeTrue();
equipmentQueryResult.Value.NodeContainers.Count.Should().Be(1);
}
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 static Result <NodeContainer> GetNodeContainerFromRouteNodeId(IQueryDispatcher queryDispatcher, Guid routeNodeId)
{
// Query all route node interests
var routeNetworkInterestQuery = new GetRouteNetworkDetails(new RouteNetworkElementIdList()
{
routeNodeId
})
{
RelatedInterestFilter = RelatedInterestFilterOptions.ReferencesFromRouteElementOnly
};
Result <GetRouteNetworkDetailsResult> interestsQueryResult = queryDispatcher.HandleAsync <GetRouteNetworkDetails, Result <GetRouteNetworkDetailsResult> >(routeNetworkInterestQuery).Result;
if (interestsQueryResult.IsFailed)
{
return(Result.Fail(interestsQueryResult.Errors.First()));
}
var interestIdList = new InterestIdList();
interestIdList.AddRange(interestsQueryResult.Value.RouteNetworkElements[routeNodeId].InterestRelations.Select(r => r.RefId));
// Only query for equipments if interests are returned from the route network query
if (interestIdList.Count > 0)
{
// Query all the equipments related to the route network element
var equipmentQueryResult = queryDispatcher.HandleAsync <GetEquipmentDetails, Result <GetEquipmentDetailsResult> >(
new GetEquipmentDetails(interestIdList)
{
EquipmentDetailsFilter = new EquipmentDetailsFilterOptions()
{
IncludeRouteNetworkTrace = false
}
}
).Result;
if (equipmentQueryResult.IsFailed)
{
return(Result.Fail(equipmentQueryResult.Errors.First()));
}
if (equipmentQueryResult.Value.NodeContainers != null && equipmentQueryResult.Value.NodeContainers.Count > 0)
{
return(Result.Ok(equipmentQueryResult.Value.NodeContainers.First()));
}
}
return(Result.Fail(new Error($"Failed to find node container in route node with id: {routeNodeId}")));
}
public async void QueryReferencesFromRouteElementAndInterestObjects_ShouldReturnAllInterestInformation()
{
// Create interest (CO_1) <- (S1) -> (HH_1) that we can then try query
var interestId = Guid.NewGuid();
var walk = new RouteNetworkElementIdList()
{
TestRouteNetwork.S1
};
var createInterestCommand = new RegisterWalkOfInterest(Guid.NewGuid(), new UserContext("test", Guid.Empty), interestId, walk);
await _commandDispatcher.HandleAsync <RegisterWalkOfInterest, Result <RouteNetworkInterest> >(createInterestCommand);
// Act: Query CO_1, S1, HH_1 and HH_2
var routeNetworkQuery = new GetRouteNetworkDetails(new RouteNetworkElementIdList()
{
TestRouteNetwork.CO_1, TestRouteNetwork.S1, TestRouteNetwork.HH_1, TestRouteNetwork.HH_2
})
{
RelatedInterestFilter = RelatedInterestFilterOptions.ReferencesFromRouteElementAndInterestObjects
};
Result <GetRouteNetworkDetailsResult> queryResult = await _queryDispatcher.HandleAsync <GetRouteNetworkDetails, Result <GetRouteNetworkDetailsResult> >(routeNetworkQuery);
// Assert that we got information back on all 4 network elements queried
Assert.True(queryResult.IsSuccess);
Assert.Equal(4, queryResult.Value.RouteNetworkElements.Count);
// Assert that we got back one interest related to the 3 network elements that the walk of interest covers
Assert.NotNull(queryResult.Value.Interests);
Assert.Contains(queryResult.Value.Interests, i => i.Id == interestId);
Assert.Equal(RouteNetworkInterestKindEnum.WalkOfInterest, queryResult.Value.Interests[interestId].Kind);
Assert.Equal(3, queryResult.Value.Interests[interestId].RouteNetworkElementRefs.Count);
Assert.Contains(TestRouteNetwork.CO_1, queryResult.Value.Interests[interestId].RouteNetworkElementRefs);
Assert.Contains(TestRouteNetwork.S1, queryResult.Value.Interests[interestId].RouteNetworkElementRefs);
Assert.Contains(TestRouteNetwork.HH_1, queryResult.Value.Interests[interestId].RouteNetworkElementRefs);
// Assert that route element 1 (CO_1) has interest information with correct relation type
Assert.NotNull(queryResult.Value.RouteNetworkElements[TestRouteNetwork.CO_1].InterestRelations);
Assert.Contains(queryResult.Value.RouteNetworkElements[TestRouteNetwork.CO_1].InterestRelations, r => r.RefId == interestId && r.RelationKind == RouteNetworkInterestRelationKindEnum.Start);
// Assert that route element 2 (S1) has interest information with correct relation type
Assert.NotNull(queryResult.Value.RouteNetworkElements[TestRouteNetwork.S1].InterestRelations);
Assert.Contains(queryResult.Value.RouteNetworkElements[TestRouteNetwork.S1].InterestRelations, r => r.RefId == interestId && r.RelationKind == RouteNetworkInterestRelationKindEnum.PassThrough);
// Assert that route element 3 (HH_1) has interest information with correct relation type
Assert.NotNull(queryResult.Value.RouteNetworkElements[TestRouteNetwork.HH_1].InterestRelations);
Assert.Contains(queryResult.Value.RouteNetworkElements[TestRouteNetwork.HH_1].InterestRelations, r => r.RefId == interestId && r.RelationKind == RouteNetworkInterestRelationKindEnum.End);
}
public async void TestAddAdditionalStructuresTo5x10_ShouldSucceed()
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var sutSpanEquipmentId = TestUtilityNetwork.FlexConduit_40_Red_CC_1_to_SP_1;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutSpanEquipmentId, out var sutSpanEquipment);
var addStructure = new PlaceAdditionalStructuresInSpanEquipment(
spanEquipmentId: sutSpanEquipmentId,
structureSpecificationIds: new Guid[] { TestSpecifications.Ø10_Red, TestSpecifications.Ø10_Violet }
);
var addStructureResult = await _commandDispatcher.HandleAsync <PlaceAdditionalStructuresInSpanEquipment, Result>(addStructure);
var equipmentQueryResult = await _queryDispatcher.HandleAsync <GetEquipmentDetails, Result <GetEquipmentDetailsResult> >(
new GetEquipmentDetails(new EquipmentIdList()
{
sutSpanEquipmentId
})
);
var equipmentAfterAddingStructure = equipmentQueryResult.Value.SpanEquipment[sutSpanEquipmentId];
// Assert
addStructureResult.IsSuccess.Should().BeTrue();
equipmentQueryResult.IsSuccess.Should().BeTrue();
equipmentAfterAddingStructure.SpanStructures.Count(s => s.Level == 2).Should().Be(2);
equipmentAfterAddingStructure.SpanStructures.Count(s => s.Level == 2 && s.Position == 1).Should().Be(1);
equipmentAfterAddingStructure.SpanStructures.Count(s => s.Level == 2 && s.Position == 2).Should().Be(1);
equipmentAfterAddingStructure.SpanStructures[1].Id.Should().NotBeEmpty();
equipmentAfterAddingStructure.SpanStructures[1].SpanSegments[0].Id.Should().NotBeEmpty();
equipmentAfterAddingStructure.SpanStructures[2].Id.Should().NotBeEmpty();
equipmentAfterAddingStructure.SpanStructures[2].SpanSegments[0].Id.Should().NotBeEmpty();
// Check utility graph
utilityNetwork.Graph.TryGetGraphElement <IUtilityGraphSegmentRef>(equipmentAfterAddingStructure.SpanStructures[2].SpanSegments[0].Id, out var fromGraphSegmentRef);
fromGraphSegmentRef.SpanSegment(utilityNetwork).FromTerminalId.Should().BeEmpty();
fromGraphSegmentRef.SpanSegment(utilityNetwork).ToTerminalId.Should().BeEmpty();
// 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.StructuresAdded" && n.IdChangeSets != null && n.IdChangeSets.Any(i => i.IdList.Any(i => i == sutSpanEquipmentId)));
utilityNetworkUpdatedEvent.AffectedRouteNetworkElementIds.Should().Contain(TestRouteNetwork.CC_1);
}
public async Task <IHttpActionResult> Get(string boardSlug)
{
var result = await queryDispatcher.HandleAsync <GetBoardBySlugQuery, Board>(new GetBoardBySlugQuery
{
BoardSlug = boardSlug
});
if (result == null)
{
return(NotFound());
}
hyperMediaFactory.Apply(result);
return(Ok(result));
}
public static Result <NodeContainer> GetNodeContainer(IQueryDispatcher queryDispatcher, Guid nodeContainerId)
{
var equipmentIdList = new EquipmentIdList();
equipmentIdList.Add(nodeContainerId);
// Query all the equipments related to the route network element
var equipmentQueryResult = queryDispatcher.HandleAsync <GetEquipmentDetails, Result <GetEquipmentDetailsResult> >(
new GetEquipmentDetails(equipmentIdList)
{
EquipmentDetailsFilter = new EquipmentDetailsFilterOptions()
{
IncludeRouteNetworkTrace = false
}
}
).Result;
if (equipmentQueryResult.IsFailed)
{
return(Result.Fail(equipmentQueryResult.Errors.First()));
}
if (equipmentQueryResult.Value.NodeContainers != null && equipmentQueryResult.Value.NodeContainers.Count > 0)
{
return(Result.Ok(equipmentQueryResult.Value.NodeContainers.First()));
}
return(Result.Fail(new Error($"Failed to find node container with id: {nodeContainerId}")));
}
private ValidatedRouteNetworkWalk GetInterestInformation(SpanEquipment spanEquipment)
{
// Get interest information from existing span equipment
var interestQueryResult = _queryDispatcher.HandleAsync <GetRouteNetworkDetails, Result <GetRouteNetworkDetailsResult> >(new GetRouteNetworkDetails(new InterestIdList()
{
spanEquipment.WalkOfInterestId
})).Result;
if (interestQueryResult.IsFailed)
{
throw new ApplicationException($"Got unexpected error result: {interestQueryResult.Errors.First().Message} trying to query interest information for span equipment: {spanEquipment.Id} walk of interest id: {spanEquipment.WalkOfInterestId}");
}
if (interestQueryResult.Value.Interests == null)
{
throw new ApplicationException($"Error querying interest information belonging to span equipment with id: {spanEquipment.Id}. No interest information returned from route network service.");
}
if (!interestQueryResult.Value.Interests.TryGetValue(spanEquipment.WalkOfInterestId, out var routeNetworkInterest))
{
throw new ApplicationException($"Error querying interest information belonging to span equipment with id: {spanEquipment.Id}. No interest information returned from route network service.");
}
return(new ValidatedRouteNetworkWalk(routeNetworkInterest.RouteNetworkElementRefs));
}
public async Task <IActionResult> HasRelatedEquipment(string id)
{
if (!Guid.TryParse(id, out Guid routeNodeId))
{
return(BadRequest($"{id} is not a valid guid"));
}
var routeNodeQuery = new GetRouteNetworkDetails(new RouteNetworkElementIdList()
{
routeNodeId
})
{
RelatedInterestFilter = RelatedInterestFilterOptions.ReferencesFromRouteElementOnly
};
var queryResult = await _queryDispatcher.HandleAsync <GetRouteNetworkDetails, Result <GetRouteNetworkDetailsResult> >(routeNodeQuery);
if (queryResult.IsFailed)
{
return(BadRequest("Request failed"));
}
var routeNetworkElement = queryResult.Value.RouteNetworkElements[routeNodeId];
var hasRelatedEquipment = (routeNetworkElement.InterestRelations != null && routeNetworkElement.InterestRelations.Length > 0);
return(Ok(hasRelatedEquipment));
}
private async Task <(double, double)> GetNodeCoordinates(Guid nodeId, IQueryDispatcher queryDispatcher)
{
var routeNodeQueryResult = await queryDispatcher.HandleAsync <GetRouteNetworkDetails, Result <GetRouteNetworkDetailsResult> >(
new GetRouteNetworkDetails(new OpenFTTH.RouteNetwork.API.Model.RouteNetworkElementIdList()
{
nodeId
})
{
RouteNetworkElementFilter = new RouteNetworkElementFilterOptions()
{
IncludeCoordinates = true
}
}
).ConfigureAwait(false);
if (routeNodeQueryResult.IsSuccess)
{
var etrsCoord = ConvertPointGeojsonToCoordArray(routeNodeQueryResult.Value.RouteNetworkElements.First().Coordinates);
return(etrsCoord[0], etrsCoord[1]);
}
else
{
return(0, 0);
}
}
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);
}
public async Task <IHttpActionResult> Get(string boardSlug, int taskId)
{
var boardTask = await queryDispatcher.HandleAsync <GetBoardTaskByIdQuery, BoardTask>(new GetBoardTaskByIdQuery
{
BoardSlug = boardSlug,
TaskId = taskId
});
if (boardTask == null)
{
return(NotFound());
}
hyperMediaFactory.Apply(boardTask);
return(Ok(boardTask));
}
public async Task <IHttpActionResult> Get(string boardSlug, string boardColumnSlug)
{
var boardColumn =
await queryDispatcher.HandleAsync <GetBoardColumnBySlugQuery, BoardColumn>(new GetBoardColumnBySlugQuery
{
BoardSlug = boardSlug,
BoardColumnSlug = boardColumnSlug
});
if (boardColumn == null)
{
return(NotFound());
}
hyperMediaFactory.Apply(boardColumn);
return(Ok(boardColumn));
}
public Task <Result> HandleAsync(CutSpanSegmentsAtRouteNode command)
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
if (command.SpanSegmentsToCut.Length == 0)
{
return(Task.FromResult(Result.Fail(new CutSpanSegmentsAtRouteNodeError(CutSpanSegmentsAtRouteNodeErrorCodes.INVALID_SPAN_SEGMENT_LIST_CANNOT_BE_EMPTY, "A list of span segments to cut must be provided."))));
}
// Because the client is not required to provide the span equipment id (that we need to lookup the
// aggregate root), we look it up via the utility network graph.
if (!utilityNetwork.Graph.TryGetGraphElement <IUtilityGraphSegmentRef>(command.SpanSegmentsToCut[0], out var spanSegmentGraphElement))
{
return(Task.FromResult(Result.Fail(new CutSpanSegmentsAtRouteNodeError(CutSpanSegmentsAtRouteNodeErrorCodes.SPAN_SEGMENT_NOT_FOUND, $"Cannot find any span segment in the utility graph with id: {command.SpanSegmentsToCut[0]}"))));
}
var spanEquipment = spanSegmentGraphElement.SpanEquipment(utilityNetwork);
var firstSpanSegment = spanSegmentGraphElement.SpanSegment(utilityNetwork);
// Get walk of interest of the span equipment
var interestQueryResult = _queryDispatcher.HandleAsync <GetRouteNetworkDetails, Result <GetRouteNetworkDetailsResult> >(
new GetRouteNetworkDetails(new InterestIdList()
{
spanEquipment.WalkOfInterestId
})
).Result;
if (interestQueryResult.IsFailed)
{
return(Task.FromResult(Result.Fail(new CutSpanSegmentsAtRouteNodeError(CutSpanSegmentsAtRouteNodeErrorCodes.FAILED_TO_GET_SPAN_EQUIPMENT_WALK_OF_INTEREST_INFORMATION, $"Got error trying to query interest information belonging to span equipment with id: {spanEquipment.Id} Error Message: {interestQueryResult.Errors.First().Message}"))));
}
if (interestQueryResult.Value is null || interestQueryResult.Value.Interests is null)
{
throw new ApplicationException($"Got nothing back trying to query interest information belonging to span equipment with id: { spanEquipment.Id } Null was returned.");
}
var spanEquipmentAR = _eventStore.Aggregates.Load <SpanEquipmentAR>(spanEquipment.Id);
var commandContext = new CommandContext(command.CorrelationId, command.CmdId, command.UserContext);
var cuteSpanEquipmentsResult = spanEquipmentAR.CutSpanSegments(
cmdContext: commandContext,
spanEquipmentWalkOfInterest: interestQueryResult.Value.Interests.First(),
routeNodeId: command.RouteNodeId,
spanSegmentsToCut: command.SpanSegmentsToCut
);
if (cuteSpanEquipmentsResult.IsSuccess)
{
_eventStore.Aggregates.Store(spanEquipmentAR);
NotifyExternalServicesAboutChange(spanEquipment.Id, command.RouteNodeId);
}
return(Task.FromResult(cuteSpanEquipmentsResult));
}
public async void TestCut5x10ConduitAtCC_1_ShouldSucceed()
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var sutSpanEquipment = TestUtilityNetwork.MultiConduit_5x10_HH_1_to_HH_10;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutSpanEquipment, out var spanEquipment);
// Cut the outer conduit and 4 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
}
);
var cutResult = await _commandDispatcher.HandleAsync <CutSpanSegmentsAtRouteNode, Result>(cutCmd);
var equipmentQueryResult = await _queryDispatcher.HandleAsync <GetEquipmentDetails, Result <GetEquipmentDetailsResult> >(
new GetEquipmentDetails(new EquipmentIdList()
{
sutSpanEquipment
})
);
equipmentQueryResult.IsSuccess.Should().BeTrue();
// Assert
cutResult.IsSuccess.Should().BeTrue();
var spanEquipmentAfterCut = equipmentQueryResult.Value.SpanEquipment[sutSpanEquipment];
spanEquipmentAfterCut.NodesOfInterestIds.Length.Should().Be(3);
spanEquipmentAfterCut.NodesOfInterestIds[0].Should().Be(spanEquipment.NodesOfInterestIds[0]);
spanEquipmentAfterCut.NodesOfInterestIds[1].Should().Be(TestRouteNetwork.CC_1);
spanEquipmentAfterCut.NodesOfInterestIds[2].Should().Be(spanEquipment.NodesOfInterestIds[1]);
// Outer conduit
spanEquipmentAfterCut.SpanStructures[0].SpanSegments.Length.Should().Be(2);
// Last inner conduit (should not be cut)
spanEquipmentAfterCut.SpanStructures[5].SpanSegments.Length.Should().Be(1);
// Second inner conduit
spanEquipmentAfterCut.SpanStructures[2].SpanSegments.Length.Should().Be(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.IdChangeSets != null && n.IdChangeSets.Any(i => i.IdList.Any(i => i == sutSpanEquipment)));
utilityNetworkUpdatedEvent.AffectedRouteNetworkElementIds.Should().Contain(TestRouteNetwork.CC_1);
}
public async void TestDrawingCableEndOutsideConduitInRouteNode()
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var sutRouteNetworkElement = TestRouteNetwork.CC_1;
// Setup
var specs = new TestSpecifications(_commandDispatcher, _queryDispatcher).Run();
// Cable directly in route network from HH_1 to CC_1
var routingHops = new RoutingHop[]
{
new RoutingHop(
new Guid[] { TestRouteNetwork.HH_1, TestRouteNetwork.S2, TestRouteNetwork.HH_2, TestRouteNetwork.S4, TestRouteNetwork.CC_1 }
),
};
var placeSpanEquipmentCommand = new PlaceSpanEquipmentInUtilityNetwork(Guid.NewGuid(), new UserContext("test", Guid.Empty), Guid.NewGuid(), TestSpecifications.FiberCable_192Fiber, routingHops)
{
NamingInfo = new NamingInfo("K12345678", null),
ManufacturerId = Guid.NewGuid()
};
// Act
var placeSpanEquipmentResult = await _commandDispatcher.HandleAsync <PlaceSpanEquipmentInUtilityNetwork, Result>(placeSpanEquipmentCommand);
utilityNetwork.TryGetEquipment <SpanEquipment>(placeSpanEquipmentCommand.SpanEquipmentId, out var placedSpanEquipment);
// Act
var getDiagramQueryResult = await _queryDispatcher.HandleAsync <GetDiagram, Result <GetDiagramResult> >(new GetDiagram(sutRouteNetworkElement));
var diagram = getDiagramQueryResult.Value.Diagram;
if (System.Environment.OSVersion.Platform.ToString() == "Win32NT")
{
new GeoJsonExporter(diagram).Export("c:/temp/diagram/test.geojson");
}
// Assert
diagram.DiagramObjects.Count(o => o.Style == "FiberCable" && o.Geometry is LineString).Should().Be(1);
diagram.DiagramObjects.Count(o => o.Label != null && o.Label.Contains("K12345678")).Should().Be(1);
}
public async void AddValidMultiLevelSpanEquipmentSpecification_ShouldSucceed()
{
// Create manufacturer
var manufacturer = new Manufacturer(Guid.NewGuid(), "Super Manufacturer");
await _commandDispatcher.HandleAsync <AddManufacturer, Result>(new AddManufacturer(manufacturer));
// Setup some span structure specifications to be used in the span equipment specification
var outerConduitSpanStructureSpec1 = new SpanStructureSpecification(Guid.NewGuid(), "Conduit", "Ø50", "Orange")
{
OuterDiameter = 50,
InnerDiameter = 45
};
await _commandDispatcher.HandleAsync <AddSpanStructureSpecification, Result>(new AddSpanStructureSpecification(outerConduitSpanStructureSpec1));
var innerConduitSpanStructureSpec1 = new SpanStructureSpecification(Guid.NewGuid(), "Conduit", "Ø12/10", "Red")
{
OuterDiameter = 12,
InnerDiameter = 10
};
await _commandDispatcher.HandleAsync <AddSpanStructureSpecification, Result>(new AddSpanStructureSpecification(innerConduitSpanStructureSpec1));
var innerConduitSpanStructureSpec2 = new SpanStructureSpecification(Guid.NewGuid(), "Conduit", "Ø12/10", "Blue")
{
OuterDiameter = 12,
InnerDiameter = 10
};
await _commandDispatcher.HandleAsync <AddSpanStructureSpecification, Result>(new AddSpanStructureSpecification(innerConduitSpanStructureSpec2));
// Setup a span equipment specification with 2 levels
var spanEquipmentSpecification = new SpanEquipmentSpecification(Guid.NewGuid(), "Conduit", "Ø50 2x12",
new SpanStructureTemplate(outerConduitSpanStructureSpec1.Id, 1, 1,
new SpanStructureTemplate[] {
new SpanStructureTemplate(innerConduitSpanStructureSpec1.Id, 2, 1, Array.Empty <SpanStructureTemplate>()),
new SpanStructureTemplate(innerConduitSpanStructureSpec2.Id, 2, 2, Array.Empty <SpanStructureTemplate>())
}
)
)
{
Description = "Ø50 2x12/10",
ManufacturerRefs = new Guid[] { manufacturer.Id }
};
// Act
var addSpanEquipmentSpecificationCommandResult = await _commandDispatcher.HandleAsync <AddSpanEquipmentSpecification, Result>(new AddSpanEquipmentSpecification(spanEquipmentSpecification));
var spanEqipmentSpecificationsQueryResult = await _queryDispatcher.HandleAsync <GetSpanEquipmentSpecifications, Result <LookupCollection <SpanEquipmentSpecification> > >(new GetSpanEquipmentSpecifications());
// Assert
addSpanEquipmentSpecificationCommandResult.IsSuccess.Should().BeTrue();
spanEqipmentSpecificationsQueryResult.IsSuccess.Should().BeTrue();
}
public async void CreateValidWalkOfInterestUsingOneSegmentIdOnly_ShouldReturnSuccess()
{
// Route network subset used in this test:
// (CO_1) <- (S1) -> (HH_1)
var interestId = Guid.NewGuid();
var walk = new RouteNetworkElementIdList()
{
TestRouteNetwork.S1
};
// Act
var registerWalkOfInterestCommand = new RegisterWalkOfInterest(Guid.NewGuid(), new UserContext("test", Guid.Empty), interestId, walk);
var registerWalkOfInterestCommandResult = await _commandDispatcher.HandleAsync <RegisterWalkOfInterest, Result <RouteNetworkInterest> > (registerWalkOfInterestCommand);
var routeNetworkQuery = new GetRouteNetworkDetails(new RouteNetworkElementIdList()
{
TestRouteNetwork.CO_1
})
{
RelatedInterestFilter = RelatedInterestFilterOptions.ReferencesFromRouteElementAndInterestObjects
};
Result <GetRouteNetworkDetailsResult> routeNetworkQueryResult = await _queryDispatcher.HandleAsync <GetRouteNetworkDetails, Result <GetRouteNetworkDetailsResult> > (routeNetworkQuery);
// Assert command result
registerWalkOfInterestCommandResult.IsSuccess.Should().BeTrue();
registerWalkOfInterestCommandResult.Value.Kind.Should().Be(RouteNetworkInterestKindEnum.WalkOfInterest);
registerWalkOfInterestCommandResult.Value.RouteNetworkElementRefs.Count.Should().Be(3);
registerWalkOfInterestCommandResult.Value.RouteNetworkElementRefs.Should().Contain(TestRouteNetwork.CO_1);
registerWalkOfInterestCommandResult.Value.RouteNetworkElementRefs.Should().Contain(TestRouteNetwork.S1);
registerWalkOfInterestCommandResult.Value.RouteNetworkElementRefs.Should().Contain(TestRouteNetwork.HH_1);
// Assert query result
routeNetworkQueryResult.IsSuccess.Should().BeTrue();
routeNetworkQueryResult.Value.Interests[interestId].RouteNetworkElementRefs.Count.Should().Be(3);
routeNetworkQueryResult.Value.Interests[interestId].RouteNetworkElementRefs.Should().Contain(TestRouteNetwork.CO_1);
routeNetworkQueryResult.Value.Interests[interestId].RouteNetworkElementRefs.Should().Contain(TestRouteNetwork.S1);
routeNetworkQueryResult.Value.Interests[interestId].RouteNetworkElementRefs.Should().Contain(TestRouteNetwork.HH_1);
routeNetworkQueryResult.Value.Interests[interestId].RouteNetworkElementRefs.Should().NotContain(TestRouteNetwork.S2);
}
public Task <Result> HandleAsync(PlaceAdditionalStructuresInSpanEquipment command)
{
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var spanStructureSpecifications = _eventStore.Projections.Get <SpanStructureSpecificationsProjection>().Specifications;
// Find span equipment
if (!utilityNetwork.TryGetEquipment <SpanEquipment>(command.SpanEquipmentId, out SpanEquipment spanEquipment))
{
if (!utilityNetwork.Graph.TryGetGraphElement <IUtilityGraphSegmentRef>(command.SpanEquipmentId, out var spanSegmentGraphElement))
{
return(Task.FromResult(Result.Fail(new PlaceAdditionalStructuresInSpanEquipmentError(PlaceAdditionalStructuresInSpanEquipmentErrorCodes.INVALID_SPAN_EQUIPMENT_ID_NOT_FOUND, $"Cannot find any span equipment with id: {command.SpanEquipmentId}"))));
}
}
// Get specification
var specification = _eventStore.Projections.Get <SpanEquipmentSpecificationsProjection>().Specifications[spanEquipment.SpecificationId];
// Get interest information for both span equipment and node container, which is needed for the aggregate to validate the command
var interestQueryResult = _queryDispatcher.HandleAsync <GetRouteNetworkDetails, Result <GetRouteNetworkDetailsResult> >(new GetRouteNetworkDetails(new InterestIdList()
{
spanEquipment.WalkOfInterestId
})).Result;
if (interestQueryResult.IsFailed)
{
throw new ApplicationException($"Got unexpected error result: {interestQueryResult.Errors.First().Message} trying to query interest information for span equipment while processing the PlaceAdditionalStructuresInSpanEquipment command: " + JsonConvert.SerializeObject(command));
}
if (interestQueryResult.Value.Interests == null)
{
throw new ApplicationException($"Got null interest result processing the PlaceAdditionalStructuresInSpanEquipment command: " + JsonConvert.SerializeObject(command));
}
var spanEquipmentAR = _eventStore.Aggregates.Load <SpanEquipmentAR>(spanEquipment.Id);
var commandContext = new CommandContext(command.CorrelationId, command.CmdId, command.UserContext);
var spanEquipmentAddStructuresResult = spanEquipmentAR.AddAdditionalStructures(
cmdContext: commandContext,
specification: specification,
structureSpecifications: spanStructureSpecifications,
structureSpecificationIdsToAdd: command.StructureSpecificationIds
);
if (spanEquipmentAddStructuresResult.IsSuccess)
{
_eventStore.Aggregates.Store(spanEquipmentAR);
NotifyExternalServicesAboutChange(command.SpanEquipmentId, interestQueryResult.Value.Interests[spanEquipment.WalkOfInterestId].RouteNetworkElementRefs);
}
return(Task.FromResult(spanEquipmentAddStructuresResult));
}
public async void TestDrawingFP2_WithNoEquipments()
{
var sutRouteNetworkElement = TestRouteNetwork.FP_2;
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
// Act
var getDiagramQueryResult = await _queryDispatcher.HandleAsync <GetDiagram, Result <GetDiagramResult> >(new GetDiagram(sutRouteNetworkElement));
var diagram = getDiagramQueryResult.Value.Diagram;
if (System.Environment.OSVersion.Platform.ToString() == "Win32NT")
{
new GeoJsonExporter(diagram).Export("c:/temp/diagram/test.geojson");
}
// Assert
getDiagramQueryResult.IsSuccess.Should().BeTrue();
diagram.DiagramObjects.Count(o => o.Style == "Rack").Should().Be(0);
diagram.DiagramObjects.Count(o => o.Style == "SubrackSpace").Should().Be(0);
diagram.DiagramObjects.Count(o => o.Style == "RackLabel").Should().Be(0);
diagram.DiagramObjects.Count(o => o.Style == "RackUnitLabel").Should().Be(0);
}
public async void TestRemoveNonConnectedFixedSpanEquipment_ShouldSucceed()
{
MakeSureTestConduitsHasInnerConduitsAndConnections();
var utilityNetwork = _eventStore.Projections.Get <UtilityNetworkProjection>();
var sutSpanEquipmentId = TestUtilityNetwork.MultiConduit_5x10_SDU_1_to_SDU_2;
utilityNetwork.TryGetEquipment <SpanEquipment>(sutSpanEquipmentId, out var spanEquipment);
var removeStructureCmd = new RemoveSpanStructureFromSpanEquipment(spanEquipment.SpanStructures[0].SpanSegments[0].Id);
var removeStructureCmdResult = await _commandDispatcher.HandleAsync <RemoveSpanStructureFromSpanEquipment, Result>(removeStructureCmd);
var equipmentQueryResult = await _queryDispatcher.HandleAsync <GetEquipmentDetails, Result <GetEquipmentDetailsResult> >(
new GetEquipmentDetails(new EquipmentIdList()
{
sutSpanEquipmentId
})
);
// Assert
removeStructureCmdResult.IsSuccess.Should().BeTrue();
equipmentQueryResult.Value.SpanEquipment.Any(s => s.Id == sutSpanEquipmentId).Should().BeFalse();
// Make sure segment is removed from the graph as well
utilityNetwork.Graph.TryGetGraphElement <IUtilityGraphElement>(spanEquipment.SpanStructures[0].SpanSegments[0].Id, out _).Should().BeFalse();
utilityNetwork.Graph.TryGetGraphElement <IUtilityGraphElement>(spanEquipment.SpanStructures[1].SpanSegments[0].Id, out _).Should().BeFalse();
utilityNetwork.Graph.TryGetGraphElement <IUtilityGraphElement>(spanEquipment.SpanStructures[2].SpanSegments[0].Id, out _).Should().BeFalse();
utilityNetwork.Graph.TryGetGraphElement <IUtilityGraphElement>(spanEquipment.SpanStructures[3].SpanSegments[0].Id, out _).Should().BeFalse();
utilityNetwork.Graph.TryGetGraphElement <IUtilityGraphElement>(spanEquipment.SpanStructures[4].SpanSegments[0].Id, out _).Should().BeFalse();
utilityNetwork.Graph.TryGetGraphElement <IUtilityGraphElement>(spanEquipment.SpanStructures[5].SpanSegments[0].Id, out _).Should().BeFalse();
// 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 == "EquipmentDeletion" && n.IdChangeSets != null && n.IdChangeSets.Any(i => i.IdList.Any(i => i == sutSpanEquipmentId)));
utilityNetworkUpdatedEvent.AffectedRouteNetworkElementIds.Should().Contain(TestRouteNetwork.J_1);
}
public NodeContainerType(ILogger <SpanEquipmentType> logger, IQueryDispatcher queryDispatcher)
{
Field(x => x.Id, type: typeof(IdGraphType)).Description("Master Resource Identifier UUID Property");
Field(x => x.Name, type: typeof(StringGraphType)).Description("Short name");
Field(x => x.Description, type: typeof(StringGraphType)).Description("Long description");
Field(x => x.SpecificationId, type: typeof(IdGraphType)).Description("Span equipment specification id");
Field(x => x.ManufacturerId, type: typeof(IdGraphType)).Description("Span equipment manufacturer id");
Field <NodeContainerSpecificationType>(
name: "specification",
description: "The specification used to create the node container",
resolve: context =>
{
var queryResult = queryDispatcher.HandleAsync <GetNodeContainerSpecifications, Result <LookupCollection <NodeContainerSpecification> > >(new GetNodeContainerSpecifications()).Result;
return(queryResult.Value[context.Source.SpecificationId]);
}
);
Field <ManufacturerType>(
name: "manufacturer",
description: "The manufacturer of the node container",
resolve: context =>
{
if (context.Source.ManufacturerId == null || context.Source.ManufacturerId == Guid.Empty)
{
return(null);
}
var queryResult = queryDispatcher.HandleAsync <GetManufacturer, Result <LookupCollection <Manufacturer> > >(new GetManufacturer()).Result;
return(queryResult.Value[context.Source.ManufacturerId.Value]);
}
);
}
public SchematicQueries(ILogger <SchematicQueries> logger, IQueryDispatcher queryDispatcher)
{
Description = "GraphQL API for generating schematic diagrams";
FieldAsync <DiagramType>(
"buildDiagram",
arguments:
new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> > {
Name = "routeNetworkElementId"
},
new QueryArgument <StringGraphType> {
Name = "exportToGeoJsonFilename"
}
),
resolve: async context =>
{
if (!Guid.TryParse(context.GetArgument <string>("routeNetworkElementId"), out Guid routeNetworkElementId))
{
context.Errors.Add(new ExecutionError("Wrong value for guid"));
return(null);
}
var getDiagramQueryResult = await queryDispatcher.HandleAsync <GetDiagram, Result <GetDiagramResult> >(new GetDiagram(routeNetworkElementId));
if (getDiagramQueryResult.IsFailed)
{
foreach (var error in getDiagramQueryResult.Errors)
{
context.Errors.Add(new ExecutionError(error.Message));
}
return(null);
}
// Export to geojson file (for checking in QGIS etc.) if such filename is specified
var jsonFilename = context.GetArgument <string>("exportToGeoJsonFilename");
if (jsonFilename != null)
{
var export = new GeoJsonExporter(getDiagramQueryResult.Value.Diagram);
export.Export(jsonFilename);
}
return(getDiagramQueryResult.Value.Diagram);
}
);
}
public FluentResults.Result <CreateSpecifications> Run()
{
var nodeContainerSpecification = _queryDispatcher.HandleAsync <GetNodeContainerSpecifications, Result <LookupCollection <NodeContainerSpecification> > >(new GetNodeContainerSpecifications()).Result;
if (nodeContainerSpecification.Value.ContainsKey(Well_Unknown))
{
return(FluentResults.Result.Fail("Additional specification already present in system"));
}
AddNodeContainerSpecifications();
AddSpanEquipmentSpecifications();
Thread.Sleep(100);
return(FluentResults.Result.Ok(this));
}
private async Task <List <GlobalSearchHit> > SearchForNodes(string searchString, int maxHits)
{
var query = new SearchParameters
{
Text = searchString,
QueryBy = "name",
PerPage = maxHits.ToString(),
LimitHits = maxHits.ToString(),
NumberOfTypos = "0"
};
var searchResult = await _typesenseClient.Search <RouteNodeSearchHit>("RouteNodes", query).ConfigureAwait(false);
RouteNetworkElementIdList routeNodeIds = new();
foreach (var hit in searchResult.Hits)
{
routeNodeIds.Add(hit.Document.Id);
}
var routeNodeQueryResult = await _queryDispatcher.HandleAsync <GetRouteNetworkDetails, Result <GetRouteNetworkDetailsResult> >(
new GetRouteNetworkDetails(routeNodeIds)
{
RouteNetworkElementFilter = new RouteNetworkElementFilterOptions()
{
IncludeCoordinates = true
}
}
).ConfigureAwait(false);
List <GlobalSearchHit> result = new();
if (routeNodeQueryResult.IsSuccess)
{
foreach (var hit in searchResult.Hits)
{
var etrsCoord = ConvertPointGeojsonToCoordArray(routeNodeQueryResult.Value.RouteNetworkElements[hit.Document.Id].Coordinates);
var wgs84Coord = UTM32WGS84Converter.ConvertFromUTM32NToWGS84(etrsCoord[0], etrsCoord[1]);
var globalHit = new GlobalSearchHit(hit.Document.Id, "routeNode", hit.Document.Name, wgs84Coord[0], wgs84Coord[1], etrsCoord[0], etrsCoord[1]);
result.Add(globalHit);
}
}
return(result);
}
public RackType(ILogger <SpanEquipmentType> logger, IQueryDispatcher queryDispatcher)
{
Field(x => x.Id, type: typeof(IdGraphType)).Description("Master Resource Identifier UUID Property");
Field(x => x.Name, type: typeof(StringGraphType)).Description("Rack name");
Field(x => x.HeightInUnits, type: typeof(IntGraphType)).Description("Height in rack units");
Field(x => x.SpecificationId, type: typeof(IdGraphType)).Description("Rack specification id");
FieldAsync <RackSpecificationType>(
name: "specification",
description: "The specification used to create the rack",
resolve: async context =>
{
var queryResult = await queryDispatcher.HandleAsync <GetRackSpecifications, Result <LookupCollection <RackSpecification> > >(new GetRackSpecifications());
return(queryResult.Value[context.Source.SpecificationId]);
}
);
}
