Esempio n. 1
0
        public void GetLineString_ShouldReturnLineString_OnBeingPassedLineString()
        {
            var routeSegment = new RouteSegment
            {
                Coord = Convert.FromBase64String("AQIAACDoZAAAAgAAAEu6uBZURSFBSjSrSRikV0HVZEzDYkUhQZKMQUgZpFdB")
            };

            var result = routeSegment.GetLineString();

            result.AsText().Should().BeEquivalentTo("LINESTRING (565930.04437811056 6197345.1510744784, 565937.381442214 6197349.1290008)");
        }
Esempio n. 2
0
        private RouteSegment CreateRouteSegmentClone(RouteSegment routeSegment)
        {
            var routeSegmentClone = _routeSegmentFactory.Create(routeSegment.GetLineString());

            routeSegmentClone.WorkTaskMrid     = routeSegment.WorkTaskMrid;
            routeSegmentClone.ApplicationInfo  = routeSegment.ApplicationInfo;
            routeSegmentClone.MappingInfo      = routeSegment.MappingInfo;
            routeSegmentClone.LifeCycleInfo    = routeSegment.LifeCycleInfo;
            routeSegmentClone.NamingInfo       = routeSegment.NamingInfo;
            routeSegmentClone.RouteSegmentInfo = routeSegment.RouteSegmentInfo;
            routeSegmentClone.SafetyInfo       = routeSegment.SafetyInfo;
            routeSegmentClone.Username         = routeSegment.Username;

            return(routeSegmentClone);
        }
        public async Task <IEnumerable <INotification> > CreateUpdatedEvent(RouteSegment before, RouteSegment after)
        {
            var routeSegmentShadowTableBeforeUpdate = await _geoDatabase.GetRouteSegmentShadowTable(after.Mrid);

            if (routeSegmentShadowTableBeforeUpdate is null)
            {
                return new List <INotification> {
                           new DoNothing($"{nameof(RouteSegment)} is already deleted, therefore do nothing")
                }
            }
            ;

            if (AlreadyUpdated(after, routeSegmentShadowTableBeforeUpdate))
            {
                return new List <INotification> {
                           new DoNothing($"{nameof(RouteSegment)} is already updated, therefore do nothing.")
                }
            }
            ;

            if (!_routeSegmentValidator.LineIsValid(after.GetLineString()))
            {
                throw new Exception("Linestring is not valid.");
            }

            await _geoDatabase.UpdateRouteSegmentShadowTable(after);

            if (after.MarkAsDeleted)
            {
                return new List <INotification> {
                           CreateRouteSegmentDeleted(after)
                }
            }
            ;

            var intersectingStartSegments = await _geoDatabase.GetIntersectingStartRouteSegments(after);

            var intersectingEndSegments = await _geoDatabase.GetIntersectingEndRouteSegments(after);

            var intersectingStartNodes = await _geoDatabase.GetIntersectingStartRouteNodes(after);

            var intersectingEndNodes = await _geoDatabase.GetIntersectingEndRouteNodes(after);

            var allIntersectingRouteNodesNoEdges = await _geoDatabase.GetAllIntersectingRouteNodesNotIncludingEdges(after);

            if (intersectingStartNodes.Count >= 2 || intersectingEndNodes.Count >= 2)
            {
                throw new Exception("Has more than 2 intersecting start or end nodes.");
            }

            if (await IsGeometryChanged(intersectingStartNodes.FirstOrDefault(), intersectingEndNodes.FirstOrDefault(), routeSegmentShadowTableBeforeUpdate))
            {
                var events = new List <INotification>();
                events.Add(new RouteSegmentLocationChanged {
                    RouteSegment = after
                });

                if (allIntersectingRouteNodesNoEdges.Count > 0)
                {
                    foreach (var intersectingRouteNode in allIntersectingRouteNodesNoEdges)
                    {
                        var routeSegmentSplitted = CreateExistingRouteSegmentSplitted(null, intersectingRouteNode, false);
                        events.Add(routeSegmentSplitted);
                    }
                }

                return(events);
            }

            var notifications = new List <INotification>();

            notifications.AddRange(HandleExistingRouteSegmentSplitted(intersectingStartSegments.Count, intersectingStartNodes.Count, after.FindStartPoint(), after));
            notifications.AddRange(HandleExistingRouteSegmentSplitted(intersectingEndSegments.Count, intersectingEndNodes.Count, after.FindEndPoint(), after));

            notifications.Add(new RouteSegmentConnectivityChanged(before, after));

            return(notifications);
        }
        public async Task <IEnumerable <INotification> > CreateDigitizedEvent(RouteSegment routeSegment)
        {
            if (routeSegment is null)
            {
                throw new ArgumentNullException($"Parameter {nameof(routeSegment)} must not be null");
            }

            if (IsCreatedByApplication(routeSegment))
            {
                return(new List <INotification>());
            }

            // Update integrator "shadow table" with the used digitized segment
            await _geoDatabase.InsertRouteSegmentShadowTable(routeSegment);

            if (!_routeSegmentValidator.LineIsValid(routeSegment.GetLineString()))
            {
                return new List <INotification> {
                           new InvalidRouteSegmentOperation {
                               RouteSegment = routeSegment
                           }
                }
            }
            ;

            var intersectingStartNodes = await _geoDatabase.GetIntersectingStartRouteNodes(routeSegment);

            var intersectingEndNodes = await _geoDatabase.GetIntersectingEndRouteNodes(routeSegment);

            var intersectingStartSegments = await _geoDatabase.GetIntersectingStartRouteSegments(routeSegment);

            var intersectingEndSegments = await _geoDatabase.GetIntersectingEndRouteSegments(routeSegment);

            var allIntersectingRouteNodesNoEdges = await _geoDatabase.GetAllIntersectingRouteNodesNotIncludingEdges(routeSegment);

            if (intersectingStartNodes.Count >= 2 || intersectingEndNodes.Count >= 2)
            {
                return new List <INotification> {
                           new InvalidRouteSegmentOperation {
                               RouteSegment = routeSegment
                           }
                }
            }
            ;

            var notifications = new List <INotification>();

            notifications.AddRange(HandleExistingRouteSegmentSplitted(intersectingStartSegments.Count, intersectingStartNodes.Count, routeSegment.FindStartPoint(), routeSegment));
            notifications.AddRange(HandleExistingRouteSegmentSplitted(intersectingEndSegments.Count, intersectingEndNodes.Count, routeSegment.FindEndPoint(), routeSegment));

            notifications.Add(CreateNewRouteSegmentDigitized(routeSegment));

            if (allIntersectingRouteNodesNoEdges.Count > 0)
            {
                foreach (var intersectingRouteNode in allIntersectingRouteNodesNoEdges)
                {
                    var routeSegmentSplitted = CreateExistingRouteSegmentSplitted(null, intersectingRouteNode, false);
                    notifications.Add(routeSegmentSplitted);
                }
            }

            return(notifications);
        }