示例#1
0
        internal int AddInnerConduit(ConduitColorEnum color, int outerDiameter, int innerDiameter, IRouteNetworkState routeNetworkQueryService, IConduitNetworkQueryService conduitNetworkQueryService)
        {
            var multiConduitInfo = conduitNetworkQueryService.GetMultiConduitInfo(Id);

            int seqNo = 1;

            if (multiConduitInfo.Children != null && multiConduitInfo.Children.Count > 0)
            {
                var lastInnerConduitSeqNo = multiConduitInfo.Children.OfType <ConduitInfo>().Max(c => c.SequenceNumber);
                seqNo = lastInnerConduitSeqNo + 1;
            }

            var innerConduitInfo = new ConduitInfo()
            {
                Id            = Guid.NewGuid(),
                Name          = "Subrør " + seqNo,
                Color         = color,
                Kind          = ConduitKindEnum.InnerConduit,
                InnerDiameter = innerDiameter,
                OuterDiameter = outerDiameter,
                Shape         = ConduitShapeKindEnum.Round,
                ColorMarking  = ConduitColorEnum.None
            };

            var innerConduitAddedEvent = new MultiConduitInnerConduitAdded()
            {
                MultiConduitId    = Id,
                MultiConduitIndex = seqNo,
                ConduitInfo       = innerConduitInfo
            };

            RaiseEvent(innerConduitAddedEvent);

            return(seqNo);
        }
示例#2
0
        private void InnerConduitAdded(SingleConduitInfo singleConduitInfo, MultiConduitInnerConduitAdded @event)
        {
            singleConduitInfo.MultiConduitId = @event.MultiConduitId;
            singleConduitInfo.Kind           = ConduitKindEnum.InnerConduit;
            singleConduitInfo.SequenceNumber = @event.MultiConduitIndex;
            singleConduitInfo.Id             = @event.ConduitInfo.Id;
            singleConduitInfo.Color          = @event.ConduitInfo.Color;
            singleConduitInfo.Shape          = @event.ConduitInfo.Shape;
            singleConduitInfo.ColorMarking   = @event.ConduitInfo.ColorMarking;
            singleConduitInfo.TextMarking    = @event.ConduitInfo.TextMarking;
            singleConduitInfo.Name           = @event.ConduitInfo.Name;
            singleConduitInfo.InnerDiameter  = @event.ConduitInfo.InnerDiameter;
            singleConduitInfo.OuterDiameter  = @event.ConduitInfo.OuterDiameter;

            // Create segment info (as is looks before any cuts or connections)
            var multiConduitInfo = conduitNetworkQueryService.GetMultiConduitInfo(@event.MultiConduitId);

            var segment = new SingleConduitSegmentInfo();

            segment.Id              = Guid.NewGuid();
            segment.SequenceNumber  = 1;
            segment.ConduitId       = @event.ConduitInfo.Id;
            segment.FromRouteNodeId = routeNetworkQueryService.GetWalkOfInterestInfo(multiConduitInfo.WalkOfInterestId).StartNodeId;
            segment.ToRouteNodeId   = routeNetworkQueryService.GetWalkOfInterestInfo(multiConduitInfo.WalkOfInterestId).EndNodeId;

            singleConduitInfo.Segments = new List <ISegment>()
            {
                segment
            };


            conduitNetworkQueryService.UpdateSingleConduitInfo(singleConduitInfo);
        }
        public static List <MultiConduitInnerConduitAdded> CreateInnerConduitAddedEvents(MultiConduitPlaced multiConduitPlacedEvent, string demoDataSpec)
        {
            List <MultiConduitInnerConduitAdded> result = new List <MultiConduitInnerConduitAdded>();

            string[] specSplit   = demoDataSpec.Split('-');
            var      conduitType = specSplit[0];

            int nInnerConduits = Convert.ToInt32(conduitType.Replace("G", "").Replace("E", "").Replace("R", "").Replace("F", ""));

            for (int i = 0; i < nInnerConduits; i++)
            {
                int parentIndex = i + 1;

                var conduitInfo = new ConduitInfo()
                {
                    Id            = Guid.NewGuid(),
                    Name          = "Subrør " + parentIndex,
                    Color         = (ConduitColorEnum)parentIndex,
                    InnerDiameter = 8,
                    OuterDiameter = 12,
                    Shape         = ConduitShapeKindEnum.Round,
                    ColorMarking  = ConduitColorEnum.None
                };

                var innerConduitAddedEvent = new MultiConduitInnerConduitAdded()
                {
                    MultiConduitId    = multiConduitPlacedEvent.ConduitInfo.Id,
                    MultiConduitIndex = parentIndex,
                    ConduitInfo       = conduitInfo
                };

                result.Add(innerConduitAddedEvent);
            }

            return(result);
        }
示例#4
0
 // Apply inner conduit addition event
 private void Apply(MultiConduitInnerConduitAdded @event)
 {
 }
示例#5
0
        public MultiConduit(Guid conduitId, Guid walkOfInterestId, Guid conduitSpecificationId, string name, ConduitColorEnum markingColor, string markingText, IConduitNetworkQueryService conduitNetworkQueryService, IConduitSpecificationRepository conduitSpecificationRepository, string demoDataSpec = null) : this()
        {
            // Conduit Id check
            if (conduitId == null || conduitId == Guid.Empty)
            {
                throw new ArgumentException("Id cannot be null or empty");
            }

            // Walk of interest id check
            if (walkOfInterestId == null || walkOfInterestId == Guid.Empty)
            {
                throw new ArgumentException("WalkOfInterestId cannot be null or empty");
            }

            // Check that not already exists
            if (conduitNetworkQueryService.CheckIfMultiConduitIdExists(conduitId))
            {
                throw new ArgumentException("A multi conduit id: " + conduitId + " already exists");
            }

            // Create the multi conduit itself
            if (demoDataSpec != null && demoDataSpec != "")
            {
                var multiConduitPlaced = ConduitEventBuilder.CreateMultiConduitPlacedEvent(conduitId, walkOfInterestId, demoDataSpec);
                RaiseEvent(multiConduitPlaced);

                // Create all the inner conduits (if the multi conduit has such - the demo data builder will know)
                if (!demoDataSpec.StartsWith("FLEX"))
                {
                    var innerConduitAddedEvents = ConduitEventBuilder.CreateInnerConduitAddedEvents(multiConduitPlaced, demoDataSpec);

                    foreach (var innerConduitAddedEvent in innerConduitAddedEvents)
                    {
                        RaiseEvent(innerConduitAddedEvent);
                    }
                }
            }
            else
            {
                var conduitSpec = conduitSpecificationRepository.GetConduitSpecification(conduitSpecificationId);

                var assetInfo = new AssetInfo();
                assetInfo.Model        = conduitSpec.ProductModels[0];
                assetInfo.Manufacturer = conduitSpec.ProductModels[0].Manufacturer;

                var conduitInfo = new ConduitInfo()
                {
                    Id            = conduitId,
                    Name          = name,
                    Shape         = conduitSpec.Shape,
                    Color         = conduitSpec.Color,
                    ColorMarking  = markingColor,
                    TextMarking   = markingText,
                    OuterDiameter = conduitSpec.OuterDiameter,
                    InnerDiameter = conduitSpec.InnerDiameter
                };

                var multiConduitEvent = new MultiConduitPlaced()
                {
                    WalkOfInterestId = walkOfInterestId,
                    MultiConduitId   = conduitId,
                    ConduitInfo      = conduitInfo,
                    AssetInfo        = assetInfo
                };

                RaiseEvent(multiConduitEvent);


                // Create all the inner conduit
                foreach (var innerConduitSpec in conduitSpec.ChildSpecifications)
                {
                    var innerConduitInfo = new ConduitInfo()
                    {
                        Id            = Guid.NewGuid(),
                        Name          = "Subrør " + innerConduitSpec.SequenceNumber,
                        Color         = innerConduitSpec.Color,
                        InnerDiameter = innerConduitSpec.InnerDiameter,
                        OuterDiameter = innerConduitSpec.OuterDiameter,
                        Shape         = innerConduitSpec.Shape,
                        ColorMarking  = ConduitColorEnum.None
                    };

                    var innerConduitAddedEvent = new MultiConduitInnerConduitAdded()
                    {
                        MultiConduitId    = conduitId,
                        MultiConduitIndex = innerConduitSpec.SequenceNumber,
                        ConduitInfo       = innerConduitInfo
                    };

                    RaiseEvent(innerConduitAddedEvent);
                }
            }
        }
        private void OnMultiConduitInnerConduitAdded(ConduitClosureInfo conduitClosureInfo, MultiConduitInnerConduitAdded @event)
        {
            // Get conduit
            var conduit      = conduitNetworkQueryService.GetConduitInfo(@event.MultiConduitId);
            var innerConduit = conduit.Children.OfType <ConduitInfo>().Single(c => c.SequenceNumber == @event.MultiConduitIndex);

            // Find port where multi conduit is connected

            ConduitClosureSideInfo foundSide = null;
            ConduitClosurePortInfo foundPort = null;

            foreach (var side in conduitClosureInfo.Sides)
            {
                foreach (var port in side.Ports)
                {
                    if (port.MultiConduitId == @event.MultiConduitId)
                    {
                        foundSide = side;
                        foundPort = port;
                    }
                }
            }

            if (foundPort != null)
            {
                AttachSingleConduitToPortTerminal(conduitClosureInfo, innerConduit.Id, foundSide.Position, foundPort.Position, @event.MultiConduitIndex);
                conduitClosureRepository.UpdateConduitClosureInfo(conduitClosureInfo);
            }
        }