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]); } ); }