public FiberCableInfoProjection(IRouteNetworkState routeNetworkQueryService, IFiberNetworkQueryService fiberNetworkQueryService) { this.routeNetworkQueryService = routeNetworkQueryService; this.fiberNetworkQueryService = (FiberNetworkQueryService)fiberNetworkQueryService; ProjectEvent <FiberCablePlaced>(OnFiberCablePlaced); }
public TestRouteNetworkType1(ContainerFixtureBase container) { this._bus = container.CommandBus; this._queryService = container.ServiceProvider.GetService <IRouteNetworkState>(); BuildInitalNetwork(); }
public DiagramServiceQuery(IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkEqueryService, IConduitClosureRepository conduitClosureRepository, IFiberNetworkQueryService fiberNetworkService, IDataLoaderContextAccessor dataLoader) { Description = "GraphQL API for generating fiber equiment diagrams."; Field <DiagramType>( "buildRouteNodeDiagram", arguments: new QueryArguments( new QueryArgument <NonNullGraphType <IdGraphType> > { Name = "routeNodeId" }, new QueryArgument <StringGraphType> { Name = "exportGeojsonFileName" } ), resolve: context => { var routeNodeId = context.GetArgument <Guid>("routeNodeId"); var jsonFilename = context.GetArgument <string>("exportGeojsonFileName"); var diagram = new ConduitClosureBuilder().Build(routeNodeId, routeNetworkQueryService, conduitNetworkEqueryService, fiberNetworkService, conduitClosureRepository); if (jsonFilename != null) { var export = new GeoJsonExporter(diagram); export.Export(jsonFilename); } return(diagram); } ); }
public FiberCableCommandHandler(IAggregateRepository aggregateRepository, IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkQueryService, IFiberNetworkQueryService fiberNetworkQueryService) { this.repo = aggregateRepository; this.conduitNetworkQueryService = conduitNetworkQueryService; this.routeNetworkQueryService = routeNetworkQueryService; this.fiberNetworkQueryService = fiberNetworkQueryService; }
public void Split(Guid nodeId, IRouteNetworkState routeQueryService) { var segmentInfo = routeQueryService.GetRouteSegmentInfo(this.Id); var nodeInfo = routeQueryService.GetRouteNodeInfo(nodeId); // Check that split node is close enough to the segment to be splitted var line = ConvertFromLineGeoJson(segmentInfo.Geometry.GeoJsonCoordinates); var nodePoint = ConvertFromPointGeoJson(nodeInfo.Geometry.GeoJsonCoordinates); var test = line.Distance(nodePoint); if (test > 0.000001) { throw new ArgumentException("Coordinate of node used for splitting the segment is not within allowed distance to segment. The distance is greather than 0.000001 decimal degress (around 5-10 cm) which is not allowed."); } PlannedRouteSegmentSplitByNode segmentSplitEvent = new PlannedRouteSegmentSplitByNode() { Id = this.Id, SplitNodeId = nodeId }; RaiseEvent(segmentSplitEvent); }
public EquipmentServiceQuery(IRouteNetworkState routeNetwork) { Description = "GraphQL API for querying OpenFTTH data"; Field <StringGraphType>("apiVersion", resolve: context => VersionInfo.VersionString()); Field <ListGraphType <RouteNodeType> >( "routeNodes", resolve: context => { return(routeNetwork.GetAllRouteNodes()); } ); Field <RouteNodeType>( "routeNode", arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> > { Name = "Id" }), resolve: context => { Guid id; if (!Guid.TryParse(context.GetArgument <string>("id"), out id)) { context.Errors.Add(new ExecutionError("Wrong value for guid")); return(null); } return(routeNetwork.GetRouteNodeInfo(id)); } ); Field <ListGraphType <RouteSegmentType> >( "routeSegments", resolve: context => { return(routeNetwork.GetAllRouteSegments()); } ); Field <RouteSegmentType>( "routeSegment", arguments: new QueryArguments(new QueryArgument <NonNullGraphType <IdGraphType> > { Name = "Id" }), resolve: context => { Guid id; if (!Guid.TryParse(context.GetArgument <string>("id"), out id)) { context.Errors.Add(new ExecutionError("Wrong value for guid")); return(null); } return(routeNetwork.GetRouteSegmentInfo(id)); } ); Field <ConduitServiceQuery>("conduitService", resolve: context => new { }); Field <DiagramServiceQuery>("diagramService", resolve: context => new { }); }
public MultiConduitCommandHandler(IAggregateRepository aggregateRepository, IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkQueryService, IConduitSpecificationRepository conduitSpecificationRepository) { this.repo = aggregateRepository; this.conduitNetworkQueryService = conduitNetworkQueryService; this.routeNetworkQueryService = routeNetworkQueryService; this.conduitSpecificationRepository = conduitSpecificationRepository; }
public TestRouteNetworkType1(IMediator bus, IRouteNetworkState routeNetworkState) { this._bus = bus; this._queryService = routeNetworkState; BuildInitalNetwork(); }
public ConduitClosureCommandHandler(IAggregateRepository aggregateRepository, IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkQueryService, IConduitClosureRepository conduitClosureRepository) { this.repo = aggregateRepository; this.routeNetworkQueryService = routeNetworkQueryService; this.conduitNetworkQueryService = conduitNetworkQueryService; this.conduitClosureRepository = conduitClosureRepository; }
public MultiConduitInfoProjection(IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkQueryService) { this.routeNetworkQueryService = routeNetworkQueryService; this.conduitNetworkQueryService = (ConduitNetworkQueryService)conduitNetworkQueryService; ProjectEvent <MultiConduitPlaced>(OnMultiConduitPlaced); ProjectEvent <MultiConduitOuterConduitCut>(OuterConduitCut); }
public ConduitClosureType(IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkEqueryService, IDataLoaderContextAccessor dataLoader) { this.routeNetworkQueryService = routeNetworkQueryService; this.conduitNetworkEqueryService = conduitNetworkEqueryService; Description = "A conduit closure."; Field(x => x.Id, type: typeof(IdGraphType)).Description("Guid property"); Field(x => x.Sides, type: typeof(ListGraphType <ConduitClosureSideType>)).Description("Sides of the closure"); }
public InMemRouteNetworkRepository(ILoggerFactory loggerFactory, IRouteNetworkState routeNetworkState) { if (null == loggerFactory) { throw new ArgumentNullException("loggerFactory is null"); } _logger = loggerFactory.CreateLogger <InMemRouteNetworkRepository>(); _routeNetworkState = routeNetworkState; }
public ConduitClosureSideType(IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkEqueryService, IDataLoaderContextAccessor dataLoader) { this.routeNetworkQueryService = routeNetworkQueryService; this.conduitNetworkEqueryService = conduitNetworkEqueryService; Description = "A specific side of a conduit closure. Sides are numbered clockwise: 1=Top 2=Right 3=Buttom 4=Left"; Field(x => x.DigramLabel, type: typeof(StringGraphType)).Description("Label the user/system like to be placed along the side. Could e.g. be a street name."); Field(x => x.Position, type: typeof(ConduitClosureSideEnumType)).Description("Side position. 1=Top 2=Right 3=Buttom 4=Left"); Field(x => x.Ports, type: typeof(ListGraphType <ConduitClosurePortType>)).Description("Ports on the side"); }
public void CutInnerConduit(int sequenceNumber, Guid pointOfInterestId, IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkQueryService) { var multiConduitInfo = conduitNetworkQueryService.GetMultiConduitInfo(Id); // Point of interest id check if (pointOfInterestId == null || pointOfInterestId == Guid.Empty) { throw new ArgumentException("PointOfInterestId cannot be null or empty"); } // Inner conduit number check if (!multiConduitInfo.Children.OfType <ConduitInfo>().Any(i => i.SequenceNumber == sequenceNumber)) { throw new ArgumentException("Cannot find inner conduit number: " + sequenceNumber + " in multi conduit: " + Id); } var singleConduitInfo = conduitNetworkQueryService.GetSingleConduitInfo(multiConduitInfo.Children.OfType <ConduitInfo>().Single(i => i.SequenceNumber == sequenceNumber).Id); // Multi conduit cut check if (!multiConduitInfo.Segments.Exists(s => s.FromRouteNodeId == pointOfInterestId || s.ToRouteNodeId == pointOfInterestId)) { throw new ArgumentException("Multi conduit: " + Id + " is not cut at: " + pointOfInterestId + " You cannot cut a inner conduit before the outer conduit is cut."); } // Inner conduit cut check if (singleConduitInfo.Segments.Exists(s => s.FromRouteNodeId == pointOfInterestId || s.ToRouteNodeId == pointOfInterestId)) { throw new ArgumentException("Inner conduit number: " + sequenceNumber + " in multi conduit: " + Id + " is already cut at: " + pointOfInterestId); } // Check that conduit is cut at a node part of conduit walk of interest var walkOfInterest = routeNetworkQueryService.GetWalkOfInterestInfo(multiConduitInfo.WalkOfInterestId); if (!walkOfInterest.AllNodeIds.Contains(pointOfInterestId)) { throw new ArgumentException("The point of interest: " + pointOfInterestId + " was not found in walk of interest:" + multiConduitInfo.WalkOfInterestId + " of multi conduit: " + Id); } // Check that conduit is not cut at ends if (walkOfInterest.StartNodeId == pointOfInterestId || walkOfInterest.EndNodeId == pointOfInterestId) { throw new ArgumentException("The point of interest: " + pointOfInterestId + " is one of the ends in walk of interest:" + multiConduitInfo.WalkOfInterestId + " of multi conduit: " + Id + " This is not allowed. You cannot cut a conduit at its ends."); } RaiseEvent(new MultiConduitInnerConduitCut { MultiConduitId = Id, InnerConduitSequenceNumber = sequenceNumber, PointOfInterestId = pointOfInterestId }); }
public ConduitServiceQuery(IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkEqueryService, IConduitSpecificationRepository conduitSpecificationRepository, IDataLoaderContextAccessor dataLoader) { Description = "GraphQL API for querying the conduit service."; Field <ListGraphType <ConduitSpecificationType> >( "conduitSpecifications", resolve: context => { return(conduitSpecificationRepository.GetConduitSpecifications()); } ); }
public SingleConduitInfoProjection(IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkQueryService) { this.routeNetworkQueryService = routeNetworkQueryService; this.conduitNetworkQueryService = (ConduitNetworkQueryService)conduitNetworkQueryService; // New single conduits ProjectEvent <SingleConduitPlaced>( (session, singleConduitPlaced) => { return(singleConduitPlaced.SingleConduitId); }, SingleConduitPlaced); // Single conduits connected ProjectEvent <SingleConduitConnected>( (session, singleConduitConnected) => { return(singleConduitConnected.SingleConduitId); }, SingleConduitConnected); // We also want to update single conduit info when a inner conduit of a multi conduit is added ProjectEvent <MultiConduitInnerConduitAdded>( (session, innerConduitAdded) => { return(innerConduitAdded.ConduitInfo.Id); }, InnerConduitAdded); // We also want to update the single conduit info when a inner conduit of a multi conduit is cut ProjectEvent <MultiConduitInnerConduitCut>( (session, innerConduitAdded) => { // To get to the right single conduit, we need look it up through the multi conduit var mutltiConduitInfo = this.conduitNetworkQueryService.GetMultiConduitInfo(innerConduitAdded.MultiConduitId); return(mutltiConduitInfo.Children.OfType <ConduitInfo>().Single(c => c.SequenceNumber == innerConduitAdded.InnerConduitSequenceNumber).Id); }, InnerConduitCut); // We also want to update the single conduit info when a inner conduit of a multi conduit is connected ProjectEvent <MultiConduitInnerConduitConnected>( (session, innerConduitConnected) => { // To get to the right single conduit, we need look it up through the multi conduit var mutltiConduitInfo = this.conduitNetworkQueryService.GetMultiConduitInfo(innerConduitConnected.MultiConduitId); return(mutltiConduitInfo.Children.OfType <ConduitInfo>().Single(c => c.SequenceNumber == innerConduitConnected.InnerConduitSequenceNumber).Id); }, InnerConduitConnected); }
public RouteNodeInfoProjection(IRouteNetworkState routeNetworkQueryService) { this.routeNetworkQueryService = (RouteNetworkState)routeNetworkQueryService; ProjectEvent <RouteNodePlanned>( (session, domainEvent) => { return(domainEvent.Id); }, OnRouteNodeAdded ); }
public FindNearestRouteNodeQueryHandler(ILoggerFactory loggerFactory, IEventStore eventStore, IRouteNetworkRepository routeNodeRepository, IRouteNetworkState routeNetworkState) { if (null == loggerFactory) { throw new ArgumentNullException("loggerFactory is null"); } _logger = loggerFactory.CreateLogger <FindNearestRouteNodeQueryHandler>(); _eventStore = eventStore; _routeNodeRepository = routeNodeRepository; _routeNetworkState = routeNetworkState; }
public RouteNetworkEventHandler(ILoggerFactory loggerFactory, IRouteNetworkState networkState, IEventStore eventStore, ICommandDispatcher commandDispatcher, IQueryDispatcher queryDispatcher) { if (null == loggerFactory) { throw new ArgumentNullException("loggerFactory is null"); } _logger = loggerFactory.CreateLogger <RouteNetworkEventHandler>(); _networkState = networkState; _eventStore = eventStore; _commandDispatcher = commandDispatcher; _queryDispatcher = queryDispatcher; }
public RouteSegmentGraphFunctions(IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkEqueryService, IConduitClosureRepository conduitClosureRepository, IDataLoaderContextAccessor dataLoader) { this.routeNetworkQueryService = routeNetworkQueryService; this.conduitNetworkEqueryService = conduitNetworkEqueryService; this.conduitClosureRepository = conduitClosureRepository; Description = "Route segment graph functions"; Field <ListGraphType <RouteNodeType> >( "neighborNodes", resolve: context => { List <RouteNodeInfo> result = new List <RouteNodeInfo>(); var routeSegment = context.Source as RouteSegmentInfo; foreach (var neighbor in routeSegment.NeighborElements) { result.Add((RouteNodeInfo)neighbor); } return(result); }); Field <ListGraphType <RouteSegmentType> >( "neighborSegments", resolve: context => { List <RouteSegmentInfo> result = new List <RouteSegmentInfo>(); var routeSegment = context.Source as RouteSegmentInfo; foreach (var neighbor in routeSegment.NeighborElements) { var neighborNeighbors = neighbor.NeighborElements; foreach (var neighborNeighbor in neighborNeighbors) { if (neighborNeighbor != routeSegment) { result.Add((RouteSegmentInfo)neighborNeighbor); } } } return(result); }); }
public RouteNetworkEventConsumer(ILoggerFactory loggerFactory, IEventStore eventStore, IOptions <KafkaSetting> kafkaSetting, IOptions <EventStoreDatabaseSetting> eventStoreDatabaseSetting, IOptions <GeoDatabaseSetting> geoDatabaseSetting, IToposTypedEventObservable <RouteNetworkEditOperationOccuredEvent> eventDispatcher, RouteNetworkEventHandler routeNetworkEventHandler, IRouteNetworkState routeNetworkState, ICommandDispatcher commandDispatcher, IQueryDispatcher queryDispatcher) { _loggerFactory = loggerFactory; _logger = _loggerFactory.CreateLogger <RouteNetworkEventConsumer>(); _eventStore = eventStore; _kafkaSetting = kafkaSetting.Value; _eventStoreDatabaseSetting = eventStoreDatabaseSetting.Value; _geoDatabaseSetting = geoDatabaseSetting.Value; _commandDispatcher = commandDispatcher; _queryDispatcher = queryDispatcher; _eventDispatcher = eventDispatcher; _routeNetworkEventHandler = routeNetworkEventHandler; _routeNetworkState = routeNetworkState; }
public FiberNetworkQueryService(IDocumentStore documentStore, IRouteNetworkState routeNetworkQueryService) { this._documentStore = documentStore; this._routeNetworkQueryService = routeNetworkQueryService; this._pointOfInterestIndex = new PointOfInterestIndex(routeNetworkQueryService); var config = new MapperConfiguration(cfg => { cfg.CreateMap <FiberCableInfo, FiberCableInfo>(); }); _mapper = config.CreateMapper(); Load(); }
public ConduitSpecificationType(IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkEqueryService, IConduitSpecificationRepository conduitSpecificationRepository, IDataLoaderContextAccessor dataLoader) { Description = "A specification of a conduit, that might be shared among manufacturer product models."; Field <ConduitKindEnumType>("Kind", "Kind of conduit (multi or single conduit)"); Field(x => x.Id, type: typeof(IdGraphType)).Description("Guid property"); Field(x => x.SequenceNumber, type: typeof(IdGraphType)).Description("The position of the conduit inside a multi conduit. Field only populated on inner conduits (conduits inside a multi conduit)"); Field <ConduitShapeKindEnumType>("Shape", "Shape of conduit - flat, round etc."); Field <ConduitColorEnumType>("Color", "Color of the conduit itself"); Field(x => x.InnerDiameter, type: typeof(IdGraphType)).Description("Inner diameter of the conduit"); Field(x => x.OuterDiameter, type: typeof(IdGraphType)).Description("Outer diameter of the conduit"); Field(x => x.ProductModels, type: typeof(ListGraphType <ProductModelInfoType>)).Description("Product models that use this specification"); Field(x => x.ChildSpecifications, type: typeof(ListGraphType <ConduitSpecificationType>)).Description("Product models that use this specification"); }
public ConduitNetworkQueryService(IDocumentStore documentStore, IRouteNetworkState routeNetworkQueryService) { this.documentStore = documentStore; this.routeNetworkQueryService = routeNetworkQueryService; this._pointOfInterestIndex = new PointOfInterestIndex(routeNetworkQueryService); var config = new MapperConfiguration(cfg => { cfg.CreateMap <SingleConduitInfo, SingleConduitInfo>(); cfg.CreateMap <MultiConduitInfo, MultiConduitInfo>(); }); _mapper = config.CreateMapper(); Load(); }
private static void PlaceCable(IRouteNetworkState routeNetworkQueryService, IMediator commandBus, Guid cableId, int nFibers, Guid startNodeParam, Guid endNodeId) { var startNode = routeNetworkQueryService.GetRouteNodeInfo(startNodeParam); List <Guid> result = new List <Guid>(); List <IGraphElement> graphElements = new List <IGraphElement>(); graphElements.AddRange(routeNetworkQueryService.GetAllRouteNodes()); graphElements.AddRange(routeNetworkQueryService.GetAllRouteSegments()); // remove element, so it has to be routed left through the pf and junctions var elementToRemove = graphElements.Find(g => g.Id == Guid.Parse("b95000fb-425d-4cd3-9f45-66e8c5000050")); graphElements.Remove(elementToRemove); var graph = new Graph(graphElements); var shortestPathResult = graph.ShortestPath(startNode.Id.ToString(), endNodeId.ToString()).ToList(); var cableWalkOfInterest = new List <Guid>(); foreach (var item in shortestPathResult) { cableWalkOfInterest.Add(item.Id); } // Walk of interest for cable var registerMultiConduitWalk = new RegisterWalkOfInterestCommand() { WalkOfInterestId = Guid.NewGuid(), RouteElementIds = cableWalkOfInterest }; commandBus.Send(registerMultiConduitWalk).Wait(); // Place cable var placeCable1 = new PlaceFiberCableCommand() { FiberCableId = cableId, WalkOfInterestId = registerMultiConduitWalk.WalkOfInterestId, NumberOfFibers = nFibers }; commandBus.Send(placeCable1).Wait(); }
public ConduitClosureTerminalType(IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkQueryService, IDataLoaderContextAccessor dataLoader) { this.routeNetworkQueryService = routeNetworkQueryService; this.conduitNetworkEqueryService = conduitNetworkQueryService; var traversal = new TraversalHelper(routeNetworkQueryService); Description = "A specific terminal part of a condult closure port. Terminal are like sides and ports numbered clockwise reflecting their position. Only single conduits or cables can be attached to terminals."; Field(x => x.Position, type: typeof(IntGraphType)).Description("Terminal position/number."); Field(x => x.LineSegment, type: typeof(ConduitSegmentType)).Description("The single conduit or cable attacthed to the terminal."); Field(x => x.ConnectionKind, type: typeof(ConduitClosureInternalConnectionKindType)).Description("The type of connection the cable or single conduit segment has (or don't have) to another port terminal in the closure."); Field(x => x.ConnectedToSide, type: typeof(ConduitClosureSideEnumType)).Description("The other end side position/number, if the cable/conduit segment is connected to another cable/conduit segment (attached to another port terminal) or passing through to another port terminal."); Field(x => x.ConnectedToPort, type: typeof(IntGraphType)).Description("The other end port position/number, if the cable/conduit segment is connected to another cable/conduit segment (attached to another port terminal) or passing through to another port terminal."); Field(x => x.ConnectedToTerminal, type: typeof(IntGraphType)).Description("The other end terminal position/number, if the cable/conduit segment is connected to another cable/conduit segment (attached to another port terminal) or passing through to another port terminal."); Field <StringGraphType>( "DiagramLabel", resolve: context => { // If conduit segment, show end node name if (context.Source.LineSegment != null && context.Source.LineSegment is ConduitSegmentInfo) { var conduitSegmentInfo = context.Source.LineSegment as ConduitSegmentInfo; var lineInfo = traversal.CreateTraversalInfoFromSegment(conduitSegmentInfo); if (context.Source.LineSegmentEndKind == ConduitEndKindEnum.Incomming) { return(lineInfo.StartRouteNode.Name); } else { return(lineInfo.EndRouteNode.Name); } } return(null); }); }
public ConduitClosureAttachmentProjection(IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkQueryService, IConduitClosureRepository conduitClosureRepository) { this.routeNetworkQueryService = routeNetworkQueryService; this.conduitNetworkQueryService = conduitNetworkQueryService; this.conduitClosureRepository = conduitClosureRepository; // Conduit passing by attached to closure ProjectEvent <ConduitClosurePassingByConduitAttached>( (session, multiConduitEndAttached) => { return(multiConduitEndAttached.ConduitClosureId); }, OnConduitClosurePassingByConduitAttached); // Conduit end attached to closure ProjectEvent <ConduitClosureConduitEndAttached>( (session, e) => { return(e.ConduitClosureId); }, OnConduitClosureConduitEndAttached); // Inner conduit added to multi conduit ProjectEvent <MultiConduitInnerConduitAdded>((session, e) => { // Try find conduit closure affected by inner conduit addition if (conduitClosureRepository.CheckIfConduitClosureIsRelatedToLine(e.MultiConduitId)) { var conduitClosure = conduitClosureRepository.GetConduitClosureInfoByRelatedLineId(e.MultiConduitId); if (conduitClosure.Sides.Exists(s => s.Ports.Exists(p => p.MultiConduitId == e.MultiConduitId))) { return(conduitClosure.Id); } } return(Guid.Empty); }, OnMultiConduitInnerConduitAdded); }
public ConduitClosure(Guid conduitClosureId, Guid pointOfInterestId, IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkQueryService, IConduitClosureRepository conduitClosureRepository) : this() { // Id check if (conduitClosureId == null || conduitClosureId == Guid.Empty) { throw new ArgumentException("ConduitClosureId cannot be null or empty"); } // Point of interest id check if (pointOfInterestId == null || pointOfInterestId == Guid.Empty) { throw new ArgumentException("PointOfInterestId cannot be null or empty"); } // Check that point of interest (node) exists if (!routeNetworkQueryService.CheckIfRouteNodeIdExists(pointOfInterestId)) { throw new ArgumentException("PointOfInterestId: " + pointOfInterestId + " not found in the route network."); } // Check that conduit closure do not already exists if (conduitClosureRepository.CheckIfConduitClosureAlreadyExists(conduitClosureId)) { throw new ArgumentException("A conduit closure with id: " + conduitClosureId + " already exists."); } // Check that a conduit closure is not already added to point of interest. This is not allowed, each conduit closure must be placed in its own node. if (conduitClosureRepository.CheckIfRouteNodeContainsConduitClosure(pointOfInterestId)) { throw new ArgumentException("A conduit closure: " + conduitClosureRepository.GetConduitClosureInfoByRouteNodeId(pointOfInterestId).Id + " is already placed in the specified point of interest (route node): " + pointOfInterestId + " Only one conduit closure is allowed per point of interest (route node)."); } var conduitClosurePlaced = new ConduitClosurePlaced() { ConduitClosureId = conduitClosureId, PointOfInterestId = pointOfInterestId }; RaiseEvent(conduitClosurePlaced); }
public ConduitClosurePortType(IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkEqueryService, IDataLoaderContextAccessor dataLoader) { this.routeNetworkQueryService = routeNetworkQueryService; this.conduitNetworkEqueryService = conduitNetworkEqueryService; Description = "A specific port sitting on a side of a condult closure. Ports are like sides numbered clockwise reflecting their position. Only multi conduits can be attached to ports. A port might have no multi conduit attached, in the case were single conduits or cables are connected to the closure port terminals without being part of (running inside) a multi conduit."; Field(x => x.DiagramLabel, type: typeof(StringGraphType)).Description("Label informaion the user like to be displayed on the port. Could e.g. be a the multi conduit model type."); Field(x => x.Position, type: typeof(IntGraphType)).Description("Port position/number."); Field(x => x.MultiConduitSegment, type: typeof(ConduitSegmentType)).Description("The multi conduit segment attached to the port. Null of no multi conduit is used."); Field(x => x.ConnectionKind, type: typeof(ConduitClosureInternalConnectionKindType)).Description("The type of connection the multi conduit segment has (or don't have) to another port in the closure."); Field(x => x.ConnectedToSide, type: typeof(ConduitClosureSideEnumType)).Description("The other end side position/number, if the multi conduit segment is connected to another multi conduit segment (attached to another port) or passing through to another port."); Field(x => x.ConnectedToPort, type: typeof(IntGraphType)).Description("The other end port position/number, if the multi conduit segment is connected to another multi conduit segment (attached to another port) or passing through to another port."); Field(x => x.Terminals, type: typeof(ListGraphType <ConduitClosureTerminalType>)).Description("Terminals of the port."); }
public ConduitClosureLifecyleEventProjection(IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkQueryService, IConduitClosureRepository conduitClosureRepository) { this.routeNetworkQueryService = routeNetworkQueryService; this.conduitNetworkQueryService = conduitNetworkQueryService; this.conduitClosureRepository = conduitClosureRepository; // Conduits closure placed ProjectEvent <ConduitClosurePlaced>( (session, e) => { return(e.ConduitClosureId); }, OnConduitClosurePlaced); // Conduit closure removed DeleteEvent <ConduitClosureRemoved>( (session, e) => { return(e.ConduitClosureId); }, OnConduitClosureRemoved); }