private async Task HandleRouteSegment(RouteSegmentMessage routeSegmentMessage)
        {
            if (IsRouteSegmentedDeleted(routeSegmentMessage))
            {
                return;
            }

            if (IsSegmentNewlyDigitized(routeSegmentMessage))
            {
                var routeSegmentDigitizedEvents = await _routeSegmentEventFactory.CreateDigitizedEvent(routeSegmentMessage.After);

                foreach (var routeSegmentDigitizedEvent in routeSegmentDigitizedEvents)
                {
                    if (!(routeSegmentDigitizedEvent is null))
                    {
                        await _mediator.Publish(routeSegmentDigitizedEvent);
                    }
                }
            }
            else if (IsSegmentUpdated(routeSegmentMessage))
            {
                var infoModifiedEvents = await _routeSegmentInfoCommandFactory
                                         .Create(routeSegmentMessage.Before, routeSegmentMessage.After);

                var routeSegmentUpdatedEvents = await _routeSegmentEventFactory
                                                .CreateUpdatedEvent(routeSegmentMessage.Before, routeSegmentMessage.After);

                var possibleIllegalOperation = routeSegmentUpdatedEvents.Any(x => x.GetType() == typeof(RouteSegmentDeleted) || x.GetType() == typeof(RouteSegmentConnectivityChanged));
                if (possibleIllegalOperation)
                {
                    var hasRelatedEquipment = await _validationService.HasRelatedEquipment(routeSegmentMessage.After.Mrid);

                    if (hasRelatedEquipment)
                    {
                        throw new Exception("Cannot update route segment since it has related equipment.");
                    }
                }

                foreach (var modifiedEvent in infoModifiedEvents)
                {
                    if (!(modifiedEvent is null))
                    {
                        await _mediator.Publish(modifiedEvent);
                    }
                }

                foreach (var routeSegmentUpdatedEvent in routeSegmentUpdatedEvents)
                {
                    if (!(routeSegmentUpdatedEvent is null))
                    {
                        await _mediator.Publish(routeSegmentUpdatedEvent);
                    }
                }
            }
            else
            {
                await _mediator.Publish(new InvalidRouteSegmentOperation { RouteSegment = routeSegmentMessage.After });
            }
        }
Beispiel #2
0
        public void Deserialize_ShouldReturnDeserializedSegmentMessage_(string fileData)
        {
            var serializationMapper    = A.Fake <IInfoMapper>();
            var routeSegmentSerializer = new RouteNetworkSerializer(serializationMapper);

            var position = new Position(string.Empty, 0, 0);
            var headers  = new Dictionary <string, string>();
            var body     = Encoding.UTF8.GetBytes(fileData);

            var receivedTransportMessage = new ReceivedTransportMessage(position, headers, body);

            var expectedRouteSegmentBefore = new RouteSegment
            {
                Mrid             = new Guid("57fb87f5-093c-405d-b619-755e3f39073f"),
                Coord            = Convert.FromBase64String("AQIAACDoZAAAAgAAAO79HyV51h/B6DWfEXKJVEGgwmxDUMkfwXuWw252iVRB"),
                WorkTaskMrid     = Guid.Empty,
                ApplicationName  = string.Empty,
                Username         = string.Empty,
                MarkAsDeleted    = false,
                ApplicationInfo  = string.Empty,
                DeleteMe         = false,
                LifeCycleInfo    = null,
                MappingInfo      = null,
                NamingInfo       = null,
                RouteSegmentInfo = null,
                SafetyInfo       = null
            };

            var expectedRouteSegmentAfter = new RouteSegment
            {
                Mrid             = new Guid("57fb87f5-093c-405d-b619-755e3f39073f"),
                Coord            = null,
                WorkTaskMrid     = Guid.Empty,
                ApplicationName  = string.Empty,
                Username         = string.Empty,
                MarkAsDeleted    = true,
                ApplicationInfo  = string.Empty,
                DeleteMe         = false,
                LifeCycleInfo    = null,
                MappingInfo      = null,
                NamingInfo       = null,
                RouteSegmentInfo = null,
                SafetyInfo       = null
            };

            var expectedBody           = new RouteSegmentMessage(expectedRouteSegmentBefore, expectedRouteSegmentAfter);
            var expectedInvalidMessage = new InvalidMessage(expectedBody);

            var expected = new ReceivedLogicalMessage(headers, expectedInvalidMessage, position);
            var result   = routeSegmentSerializer.Deserialize(receivedTransportMessage);

            result.Should().BeEquivalentTo(expected);
        }
Beispiel #3
0
        public void Deserialize_ShouldReturnDeserializedSegmentMessageWithBeforeBeingNull_OnValidReceivedTransportMessageOnBeforeBeingNull(string fileData)
        {
            var serializationMapper    = A.Fake <IInfoMapper>();
            var routeSegmentSerializer = new RouteNetworkSerializer(serializationMapper);

            A.CallTo(() => serializationMapper.MapDeploymentState("InService")).Returns(DeploymentStateEnum.InService);
            A.CallTo(() => serializationMapper.MapMappingMethod("Drafting")).Returns(MappingMethodEnum.Drafting);
            A.CallTo(() => serializationMapper.MapRouteSegmentKind("Indoor")).Returns(RouteSegmentKindEnum.Indoor);

            var position = new Position(string.Empty, 0, 0);
            var headers  = new Dictionary <string, string>();
            var body     = Encoding.UTF8.GetBytes(fileData);

            var receivedTransportMessage = new ReceivedTransportMessage(position, headers, body);

            RouteSegment expectedRouteSegmentBefore = null;

            var expectedRouteSegmentAfter = new RouteSegment
            {
                Mrid             = new Guid("57fb87f5-093c-405d-b619-755e3f39073f"),
                Coord            = Convert.FromBase64String("AQIAACDoZAAAAgAAAO79HyV51h/B6DWfEXKJVEGgwmxDUMkfwXuWw252iVRB"),
                DeleteMe         = false,
                MarkAsDeleted    = false,
                Username         = "******",
                WorkTaskMrid     = Guid.Parse("d80f6250-8132-4893-b38f-b64fafd74316"),
                LifeCycleInfo    = new LifecycleInfo(DeploymentStateEnum.InService, DateTime.Parse("2020-08-12 00:00:00"), DateTime.Parse("2020-08-12 00:00:00")),
                MappingInfo      = new MappingInfo(MappingMethodEnum.Drafting, "1", "2", DateTime.Parse("2020-08-12 00:00:00"), "Source info"),
                NamingInfo       = new NamingInfo("AB13", "AB13 desc"),
                RouteSegmentInfo = new RouteSegmentInfo(RouteSegmentKindEnum.Indoor, "20m", "10m"),
                SafetyInfo       = new SafetyInfo("Very safe", "Nothing to say"),
                ApplicationInfo  = "Application information bla bla",
                ApplicationName  = "GDB_INTEGRATOR"
            };

            var expectedMessage = new RouteSegmentMessage(expectedRouteSegmentBefore, expectedRouteSegmentAfter);

            var expected = new ReceivedLogicalMessage(headers, expectedMessage, position);
            var result   = routeSegmentSerializer.Deserialize(receivedTransportMessage);

            result.Should().BeEquivalentTo(expected);
        }
 private bool IsSegmentUpdated(RouteSegmentMessage routeSegmentMessage)
 {
     return(!(routeSegmentMessage.Before is null));
 }
 private bool IsSegmentNewlyDigitized(RouteSegmentMessage routeSegmentMessage)
 {
     return(routeSegmentMessage.Before is null && routeSegmentMessage.After.Mrid.ToString() != string.Empty);
 }
 private bool IsRouteSegmentedDeleted(RouteSegmentMessage routeSegmentMessage)
 {
     return(routeSegmentMessage.Before is null && routeSegmentMessage.After is null);
 }
 private async Task HandleSubscribedEvent(RouteSegmentMessage routeSegmentMessage)
 {
     _logger.LogDebug($"Received message: {JsonConvert.SerializeObject(routeSegmentMessage, Formatting.Indented)}");
     await _mediator.Send(new GeoDatabaseUpdated { UpdateMessage = routeSegmentMessage });
 }