public async void ValidateValidWalkWithBothNodeAndSegmentIds_ShouldSucceed()
{
var walk = new RouteNetworkElementIdList()
{
TestRouteNetwork.CO_1, TestRouteNetwork.S1, TestRouteNetwork.HH_1, TestRouteNetwork.S2, TestRouteNetwork.HH_2, TestRouteNetwork.S4, TestRouteNetwork.CC_1
};
var validateInterestCommand = new ValidateWalkOfInterest(Guid.NewGuid(), new UserContext("test", Guid.Empty), walk);
var validateResult = await _commandDispatcher.HandleAsync <ValidateWalkOfInterest, Result <ValidatedRouteNetworkWalk> >(validateInterestCommand);
// Assert
validateResult.IsSuccess.Should().BeTrue();
validateResult.Value.NodeIds.Count.Should().Be(4);
validateResult.Value.SegmentIds.Count.Should().Be(3);
validateResult.Value.NodeIds[0].Should().Be(TestRouteNetwork.CO_1);
validateResult.Value.NodeIds[1].Should().Be(TestRouteNetwork.HH_1);
validateResult.Value.NodeIds[2].Should().Be(TestRouteNetwork.HH_2);
validateResult.Value.NodeIds[3].Should().Be(TestRouteNetwork.CC_1);
validateResult.Value.SegmentIds[0].Should().Be(TestRouteNetwork.S1);
validateResult.Value.SegmentIds[1].Should().Be(TestRouteNetwork.S2);
validateResult.Value.SegmentIds[2].Should().Be(TestRouteNetwork.S4);
}
public async void ValidatedWalkEqualTest_ShouldFail()
{
// We create two walks that are not equal
var validateInterestCommand1 = new ValidateWalkOfInterest(Guid.NewGuid(), new UserContext("test", Guid.Empty), new RouteNetworkElementIdList()
{
TestRouteNetwork.S1, TestRouteNetwork.S2
});
var validateResult1 = await _commandDispatcher.HandleAsync <ValidateWalkOfInterest, Result <ValidatedRouteNetworkWalk> >(validateInterestCommand1);
var validateInterestCommand2 = new ValidateWalkOfInterest(Guid.NewGuid(), new UserContext("test", Guid.Empty), new RouteNetworkElementIdList()
{
TestRouteNetwork.S1
});
var validateResult2 = await _commandDispatcher.HandleAsync <ValidateWalkOfInterest, Result <ValidatedRouteNetworkWalk> >(validateInterestCommand2);
// Assert
validateResult1.IsSuccess.Should().BeTrue();
validateResult2.IsSuccess.Should().BeTrue();
var walk1 = new ValidatedRouteNetworkWalk(validateResult1.Value.RouteNetworkElementRefs);
var walk2 = new ValidatedRouteNetworkWalk(validateResult2.Value.RouteNetworkElementRefs);
walk1.Equals(walk2).Should().BeFalse();
}
public async void ValidatedWalkEqualTest_ShouldSucceed()
{
// We create two walks. One that goes CO_1 -> HH_1 -> HH_2 -> to CC_1, and one that goes the opposite way.
// These two walks are to be treated as equal
var validateInterestForwardCommand = new ValidateWalkOfInterest(Guid.NewGuid(), new UserContext("test", Guid.Empty), new RouteNetworkElementIdList()
{
TestRouteNetwork.S2, TestRouteNetwork.S1, TestRouteNetwork.S4
});
var validateResultForward = await _commandDispatcher.HandleAsync <ValidateWalkOfInterest, Result <ValidatedRouteNetworkWalk> >(validateInterestForwardCommand);
var validateInterestReversedCommand = new ValidateWalkOfInterest(Guid.NewGuid(), new UserContext("test", Guid.Empty), new RouteNetworkElementIdList()
{
TestRouteNetwork.S4, TestRouteNetwork.S2, TestRouteNetwork.S1
});
var validateResultReversed = await _commandDispatcher.HandleAsync <ValidateWalkOfInterest, Result <ValidatedRouteNetworkWalk> >(validateInterestReversedCommand);
// Assert
validateResultForward.IsSuccess.Should().BeTrue();
validateResultReversed.IsSuccess.Should().BeTrue();
validateResultForward.Value.FromNodeId.Should().Be(TestRouteNetwork.CO_1);
validateResultReversed.Value.FromNodeId.Should().Be(TestRouteNetwork.CC_1);
var walk1 = new ValidatedRouteNetworkWalk(validateResultForward.Value.RouteNetworkElementRefs);
var walk2 = new ValidatedRouteNetworkWalk(validateResultReversed.Value.RouteNetworkElementRefs);
walk1.Equals(walk2).Should().BeTrue();
}
public async void ValidateInvalidWalkWithBothNodeAndSegmentIds_ShouldFail()
{
// There's a hole in this walk
var walk = new RouteNetworkElementIdList()
{
TestRouteNetwork.HH_1, TestRouteNetwork.S1, TestRouteNetwork.CO_1, TestRouteNetwork.S1, TestRouteNetwork.HH_1, TestRouteNetwork.S4, TestRouteNetwork.CC_1
};
var validateInterestCommand = new ValidateWalkOfInterest(Guid.NewGuid(), new UserContext("test", Guid.Empty), walk);
var validateResult = await _commandDispatcher.HandleAsync <ValidateWalkOfInterest, Result <ValidatedRouteNetworkWalk> >(validateInterestCommand);
// Assert
validateResult.IsFailed.Should().BeTrue();
}
public Task <Result <ValidatedRouteNetworkWalk> > HandleAsync(ValidateWalkOfInterest command)
{
var walkValidator = new WalkValidator(_routeNetworkRepository);
var validateResult = walkValidator.ValidateWalk(command.WalkIds);
if (validateResult.IsFailed)
{
return(Task.FromResult(Result.Fail <ValidatedRouteNetworkWalk>(validateResult.Errors.First())));
}
else
{
return(Task.FromResult(Result.Ok <ValidatedRouteNetworkWalk>(new ValidatedRouteNetworkWalk(validateResult.Value))));
}
}
public Result PlaceCableSpanEquipment(NpgsqlCommand logCmd, Guid spanEquipmentId, string externalId, Guid specificationId, List <Guid> routeSegmentIds, List <CableConduitRel> conduitRels)
{
Guid correlationId = Guid.NewGuid();
RouteNetworkElementIdList walkIds = new RouteNetworkElementIdList();
walkIds.AddRange(routeSegmentIds);
// Cable name
var nextConduitSeqStr = _eventStore.Sequences.GetNextVal("cable").ToString();
var conduitName = "K" + nextConduitSeqStr.PadLeft(6, '0');
var namingInfo = new NamingInfo(conduitName, null);
// HACK use NE id
var neIdSplit = externalId.Split(':');
namingInfo = new NamingInfo("K" + neIdSplit.Last(), null);
System.Diagnostics.Debug.WriteLine("---------------------------------------------------------------------------------------------------------------------------------------");
System.Diagnostics.Debug.WriteLine($"*** Place cable: {externalId} ***");
System.Diagnostics.Debug.WriteLine("---------------------------------------------------------------------------------------------------------------------------------------");
// Get validated walk of interest
var walk = new RouteNetworkElementIdList();
walk.AddRange(routeSegmentIds);
var validateInterestCommand = new ValidateWalkOfInterest(correlationId, new UserContext("conversion", _workTaskId), walk);
var validateInterestResult = _commandDispatcher.HandleAsync <ValidateWalkOfInterest, Result <ValidatedRouteNetworkWalk> >(validateInterestCommand).Result;
if (validateInterestResult.IsFailed)
{
return(Result.Fail(validateInterestResult.Errors.First()));
}
// trace all conduits
var conduitsTraceResult = TraceAllConduits(conduitRels);
foreach (var conduitTrace in conduitsTraceResult)
{
System.Diagnostics.Debug.WriteLine($"NE conduit path found starting in {conduitTrace.ConduitName} node {conduitTrace.OriginalTrace.FromRouteNodeName} ({conduitTrace.OriginalTrace.FromRouteNodeId}) <-> {conduitTrace.OriginalTrace.ToRouteNodeName} ({conduitTrace.OriginalTrace.ToRouteNodeId}) span segment id: {conduitTrace.SpanSegmentId}");
}
var routingHops = BuildRouteHops(validateInterestResult.Value, conduitsTraceResult, externalId);
System.Diagnostics.Debug.WriteLine("---------------------------------------------------------------------------------------------------------------------------------------");
foreach (var hop in routingHops)
{
System.Diagnostics.Debug.WriteLine($"Routing hop: start route node id: {hop.StartRouteNode} span equipment id: {hop.StartSpanSegmentId}");
}
// Place cable
var placeSpanEquipmentCommand = new PlaceSpanEquipmentInUtilityNetwork(correlationId, new UserContext("conversion", _workTaskId), spanEquipmentId, specificationId, routingHops.ToArray())
{
NamingInfo = namingInfo,
};
var placeSpanEquipmentResult = _commandDispatcher.HandleAsync <PlaceSpanEquipmentInUtilityNetwork, Result>(placeSpanEquipmentCommand).Result;
if (placeSpanEquipmentResult.IsFailed)
{
var errorMsg = "Failed to route cable: " + externalId + " through conduit network: " + placeSpanEquipmentResult.Errors.First().Message;
System.Diagnostics.Debug.WriteLine("---------------------------------------------------------------------------------------------------------------------------------------");
System.Diagnostics.Debug.WriteLine(errorMsg);
_logger.LogInformation(errorMsg);
// Try place cable directly in route network
var placeSpanEquipmentDirectlyInRouteNetworkCmd = new PlaceSpanEquipmentInUtilityNetwork(correlationId, new UserContext("conversion", _workTaskId), spanEquipmentId, specificationId,
new RoutingHop[] { new RoutingHop(validateInterestResult.Value.RouteNetworkElementRefs.ToArray()) }
)
{
NamingInfo = namingInfo,
};
var placeSpanEquipmentDirectlyInRouteNetworkResult = _commandDispatcher.HandleAsync <PlaceSpanEquipmentInUtilityNetwork, Result>(placeSpanEquipmentDirectlyInRouteNetworkCmd).Result;
if (placeSpanEquipmentDirectlyInRouteNetworkResult.IsFailed)
{
errorMsg = "GENERAL FAILURE PLACING DIRECTLY IN ROUTE NETWORK: " + placeSpanEquipmentResult.Errors.First().Message + " " + errorMsg;
}
LogStatus((NpgsqlCommand)logCmd, _tableName, errorMsg, externalId);
return(placeSpanEquipmentResult);
}
return(Result.Ok());
}
