private Dictionary <Guid, NodeContainerForConversion> LoadNodeContainersFromDatabase()
        {
            Dictionary <Guid, NodeContainerForConversion> nodeContainersForConversions = new();

            using var dbConn = GetConnection();

            // Load node containers
            using var nodeContainerSelectCmd   = dbConn.CreateCommand();
            nodeContainerSelectCmd.CommandText = "SELECT external_id, external_spec, route_node_id, node_container_id, specification FROM " + _nodeContainerTableName + " WHERE status is null ORDER BY external_id";

            using var nodeContainerReader = nodeContainerSelectCmd.ExecuteReader();

            while (nodeContainerReader.Read())
            {
                var externalId      = nodeContainerReader.GetString(0).Trim();
                var externalSpec    = nodeContainerReader.GetString(1).Trim();
                var routeNodeId     = Guid.Parse(nodeContainerReader.GetString(2));
                var nodeContainerId = Guid.Parse(nodeContainerReader.GetString(3));
                var specification   = nodeContainerReader.GetString(4).Trim();

                var nodeCondtainerForConversion = new NodeContainerForConversion(externalId, specification, routeNodeId, nodeContainerId);

                nodeContainersForConversions.Add(nodeContainerId, nodeCondtainerForConversion);
            }

            dbConn.Close();

            return(nodeContainersForConversions);
        }
        private void ConnectSpanEquipmentsInNodeContainer(NpgsqlCommand logCmd, NodeContainerForConversion nodeContainer, RelatedEquipmentInfo relatedInfo)
        {
            foreach (var connectivity in nodeContainer.Connectivity)
            {
                if (!relatedInfo.SpanEquipmentById.ContainsKey(connectivity.FromSpanEquipmentId))
                {
                    LogStatus(logCmd, _connectivityTableName, "ogc_fid", connectivity.Key, $"Span equipment with id: {connectivity.FromSpanEquipmentId} not found in route node with id: {nodeContainer.NodeId}");
                    continue;
                }

                if (!relatedInfo.SpanEquipmentById.ContainsKey(connectivity.ToSpanEquipmentId))
                {
                    LogStatus(logCmd, _connectivityTableName, "ogc_fid", connectivity.Key, $"Span equipment with id: {connectivity.ToSpanEquipmentId} not found in route node with id: {nodeContainer.NodeId}");
                    continue;
                }

                // We need adjust index 1 to index 0 on single conduits
                var fromSpanEquipment = relatedInfo.SpanEquipmentById[connectivity.FromSpanEquipmentId];
                var toSpanEquipment   = relatedInfo.SpanEquipmentById[connectivity.ToSpanEquipmentId];

                int fromStructureIndex = fromSpanEquipment.SpanStructures.Length == 1 ? connectivity.FromStructureIndex - 1 : connectivity.FromStructureIndex;
                int toStructureIndex   = toSpanEquipment.SpanStructures.Length == 1 ? connectivity.ToStructureIndex - 1 : connectivity.ToStructureIndex;

                var connectResult = ConnectSpanEquipments(nodeContainer.NodeId, connectivity.FromSpanEquipmentId, connectivity.ToSpanEquipmentId, (ushort)fromStructureIndex, (ushort)toStructureIndex, connectivity.NumberOfUnits);

                if (connectResult.IsFailed)
                {
                    LogStatus((NpgsqlCommand)logCmd, _connectivityTableName, "ogc_fid", connectivity.Key, connectResult.Errors.First().Message);
                }

                LogStatus(logCmd, _connectivityTableName, "ogc_fid", connectivity.Key, connectResult);
            }
        }
        private Result PlaceNodeContainer(NpgsqlCommand logCmd, NodeContainerForConversion nodeContainer, Guid specId, RelatedEquipmentInfo relatedInfo)
        {
            Guid correlationId = Guid.NewGuid();

            var commandUserContext = new UserContext("conversion", _workTaskId)
            {
                EditingRouteNodeId = nodeContainer.NodeId
            };

            // Check if node container already exists
            if (relatedInfo.NodeContainer != null)
            {
                if (_utilityNetwork.TryGetEquipment <NodeContainer>(relatedInfo.NodeContainer.Id, out var existingNodeContainer))
                {
                    System.Diagnostics.Debug.WriteLine($"Node container alreadu exists in node: {nodeContainer.NodeId}");
                    return(Result.Ok());
                }
            }

            // First register the node of interest where to place the node container
            var nodeOfInterestId = Guid.NewGuid();

            var registerNodeOfInterestCommand = new RegisterNodeOfInterest(correlationId, commandUserContext, nodeOfInterestId, nodeContainer.NodeId);

            var registerNodeOfInterestCommandResult = _commandDispatcher.HandleAsync <RegisterNodeOfInterest, Result <RouteNetworkInterest> >(registerNodeOfInterestCommand).Result;

            if (registerNodeOfInterestCommandResult.IsFailed)
            {
                LogStatus((NpgsqlCommand)logCmd, _nodeContainerTableName, registerNodeOfInterestCommandResult.Errors.First().Message, nodeContainer.ExternalId);
                return(registerNodeOfInterestCommandResult);
            }

            // Now place the node container in the walk
            var placeNodeContainerCommand = new PlaceNodeContainerInRouteNetwork(correlationId, commandUserContext, nodeContainer.NodeContainerId, specId, registerNodeOfInterestCommandResult.Value)
            {
                ManufacturerId = null,
                LifecycleInfo  = new LifecycleInfo(DeploymentStateEnum.InService, null, null)
            };

            var placeNodeContainerResult = _commandDispatcher.HandleAsync <PlaceNodeContainerInRouteNetwork, Result>(placeNodeContainerCommand).Result;

            // Unregister interest if place node container failed
            if (placeNodeContainerResult.IsFailed)
            {
                LogStatus((NpgsqlCommand)logCmd, _nodeContainerTableName, placeNodeContainerResult.Errors.First().Message, nodeContainer.ExternalId);

                var unregisterCommandResult = _commandDispatcher.HandleAsync <UnregisterInterest, Result>(new UnregisterInterest(correlationId, commandUserContext, nodeOfInterestId)).Result;

                if (unregisterCommandResult.IsFailed)
                {
                    return(unregisterCommandResult);
                }
            }

            LogStatus((NpgsqlCommand)logCmd, _nodeContainerTableName, "external_id", nodeContainer.ExternalId, placeNodeContainerResult);

            return(placeNodeContainerResult);
        }
Beispiel #4
0
        private Result PlaceNodeContainer(NodeContainerForConversion nodeContainer, Guid specId)
        {
            var routeNodeId     = Guid.NewGuid();
            var nodeContainerId = Guid.NewGuid();

            Guid correlationId = Guid.NewGuid();

            var commandUserContext = new UserContext("conversion", _workTaskId)
            {
                EditingRouteNodeId = routeNodeId
            };

            // First register the node of interest where to place the node container
            var nodeOfInterestId = Guid.NewGuid();

            var registerNodeOfInterestCommand = new RegisterNodeOfInterest(correlationId, commandUserContext, nodeOfInterestId, routeNodeId);

            var registerNodeOfInterestCommandResult = _commandDispatcher.HandleAsync <RegisterNodeOfInterest, Result <RouteNetworkInterest> >(registerNodeOfInterestCommand).Result;

            if (registerNodeOfInterestCommandResult.IsFailed)
            {
                return(registerNodeOfInterestCommandResult);
            }

            // Now place the node container in the walk
            var placeNodeContainerCommand = new PlaceNodeContainerInRouteNetwork(correlationId, commandUserContext, nodeContainerId, specId, registerNodeOfInterestCommandResult.Value)
            {
                ManufacturerId = null,
                LifecycleInfo  = new LifecycleInfo(DeploymentStateEnum.InService, null, null)
            };

            var placeNodeContainerResult = _commandDispatcher.HandleAsync <PlaceNodeContainerInRouteNetwork, Result>(placeNodeContainerCommand).Result;

            // Unregister interest if place node container failed
            if (placeNodeContainerResult.IsFailed)
            {
                var unregisterCommandResult = _commandDispatcher.HandleAsync <UnregisterInterest, Result>(new UnregisterInterest(correlationId, commandUserContext, nodeOfInterestId)).Result;

                if (unregisterCommandResult.IsFailed)
                {
                    return(unregisterCommandResult);
                }
            }

            return(placeNodeContainerResult);
        }
        private void AffixSpanEquipmentsToNodeContainer(NpgsqlCommand logCmd, NodeContainerForConversion nodeContainer, RelatedEquipmentInfo relatedInfo)
        {
            if (!relatedInfo.SingleConduitsOnly)
            {
                foreach (var ingoingSpanEquipment in relatedInfo.IngoingSpanEquipments)
                {
                    if (ingoingSpanEquipment.SpanStructures.Length == 1)
                    {
                        AffixSpanEquipmentToContainer(nodeContainer.NodeId, ingoingSpanEquipment.Id, nodeContainer.NodeContainerId, NodeContainerSideEnum.North);
                    }
                    else
                    {
                        AffixSpanEquipmentToContainer(nodeContainer.NodeId, ingoingSpanEquipment.Id, nodeContainer.NodeContainerId, NodeContainerSideEnum.West);
                    }
                }

                foreach (var outgoingSpanEquipment in relatedInfo.OutgoingSpanEquipments)
                {
                    if (outgoingSpanEquipment.SpanStructures.Length == 1)
                    {
                        AffixSpanEquipmentToContainer(nodeContainer.NodeId, outgoingSpanEquipment.Id, nodeContainer.NodeContainerId, NodeContainerSideEnum.North);
                    }
                    else
                    {
                        AffixSpanEquipmentToContainer(nodeContainer.NodeId, outgoingSpanEquipment.Id, nodeContainer.NodeContainerId, NodeContainerSideEnum.East);
                    }
                }
            }
            else
            {
                foreach (var ingoingSpanEquipment in relatedInfo.IngoingSpanEquipments)
                {
                    AffixSpanEquipmentToContainer(nodeContainer.NodeId, ingoingSpanEquipment.Id, nodeContainer.NodeContainerId, NodeContainerSideEnum.West);
                }

                foreach (var outgoingSpanEquipment in relatedInfo.OutgoingSpanEquipments)
                {
                    AffixSpanEquipmentToContainer(nodeContainer.NodeId, outgoingSpanEquipment.Id, nodeContainer.NodeContainerId, NodeContainerSideEnum.East);
                }
            }
        }