public async Task <bool> SendLocationIsolationCrew(long outageId)
{
Logger.LogVerbose($"{baseLogString} SendLocationIsolationCrew method started. OutageId {outageId}");
while (!ReliableDictionariesInitialized)
{
await Task.Delay(1000);
}
try
{
var result = await lifecycleHelper.GetCreatedOutage(outageId);
if (!result.HasValue)
{
Logger.LogError($"{baseLogString} SendLocationIsolationCrew => Created Outage is null. OutageId {outageId}");
return(false);
}
var outageEntity = result.Value;
var enumerableTopology = await OutageTopologyModel.GetEnumerableDictionaryAsync();
if (!enumerableTopology.ContainsKey(ReliableDictionaryNames.OutageTopologyModel))
{
Logger.LogError($"{baseLogString} Start => Topology not found in Rel Dictionary: {ReliableDictionaryNames.OutageTopologyModel}.");
return(false);
}
var topology = enumerableTopology[ReliableDictionaryNames.OutageTopologyModel];
if (!await StartLocationAndIsolationAlgorithm(outageEntity, topology))
{
return(false);
}
return(await lifecycleHelper.PublishOutageAsync(Topic.ACTIVE_OUTAGE, outageMessageMapper.MapOutageEntity(outageEntity)));
}
catch (Exception e)
{
string message = $"{baseLogString} SendLocationIsolationCrew => Exception: {e.Message}";
Logger.LogError(message, e);
return(false);
}
}
public async Task <bool> ResolveOutage(long outageId)
{
Logger.LogVerbose($"{baseLogString} ResolveOutage method started. OutageId: {outageId}");
while (!ReliableDictionariesInitialized)
{
await Task.Delay(1000);
}
try
{
var result = await lifecycleHelper.GetValidatedRepairedOutage(outageId);
if (!result.HasValue)
{
Logger.LogError($"{baseLogString} ResolveOutage => GetValidatedRepairedOutage did not return a value. OutageId: {outageId}");
return(false);
}
var outageDbEntity = result.Value;
outageDbEntity.ArchivedTime = DateTime.UtcNow;
outageDbEntity.OutageState = OutageState.ARCHIVED;
var outageModelAccessClient = OutageModelAccessClient.CreateClient();
await outageModelAccessClient.UpdateOutage(outageDbEntity);
Logger.LogInformation($"{baseLogString} ResolveOutage => Outage on element with gid: 0x{outageDbEntity.OutageElementGid:x16} is SUCCESSFULLY archived.");
return(await lifecycleHelper.PublishOutageAsync(Topic.ARCHIVED_OUTAGE, outageMessageMapper.MapOutageEntity(outageDbEntity)));
}
catch (Exception e)
{
string message = $"{baseLogString} ResolveOutage => Exception: {e.Message}";
Logger.LogError(message, e);
return(false);
}
}
public async Task <bool> ReportPotentialOutage(long elementGid, CommandOriginType commandOriginType, NetworkType networkType)
{
Logger.LogVerbose($"{baseLogString} ReportPotentialOutage method started. ElementGid: 0x{elementGid:X16}, CommandOriginType: {commandOriginType}, NetworkType: {networkType}");
while (!ReliableDictionariesInitialized)
{
await Task.Delay(1000);
}
try
{
#region Preconditions
var ceModelProviderClient = CeModelProviderClient.CreateClient();
if (await ceModelProviderClient.IsRecloser(elementGid))
{
Logger.LogWarning($"{baseLogString} ReportPotentialOutage => Element with gid 0x{elementGid:X16} is a Recloser. Call to ReportPotentialOutage aborted.");
return(false);
}
var enumerableTopology = await OutageTopologyModel.GetEnumerableDictionaryAsync();
if (!enumerableTopology.ContainsKey(ReliableDictionaryNames.OutageTopologyModel))
{
Logger.LogError($"{baseLogString} ReportPotentialOutage => Topology not found in Rel Dictionary: {ReliableDictionaryNames.OutageTopologyModel}.");
return(false);
}
var topology = enumerableTopology[ReliableDictionaryNames.OutageTopologyModel];
var affectedConsumersGids = lifecycleHelper.GetAffectedConsumers(elementGid, topology, networkType);
var historyDBManagerClient = HistoryDBManagerClient.CreateClient();
if (!(await CheckPreconditions(elementGid, commandOriginType, affectedConsumersGids, historyDBManagerClient)))
{
Logger.LogWarning($"{baseLogString} ReportPotentialOutage => Parameters do not satisfy required preconditions. ElementId: 0x{elementGid:X16}, CommandOriginType: {commandOriginType}");
return(false);
}
#endregion Preconditions
Logger.LogInformation($"{baseLogString} ReportPotentialOutage => Reporting outage for gid: 0x{elementGid:X16}, CommandOriginType: {commandOriginType}");
var result = await StoreActiveOutage(elementGid, affectedConsumersGids, topology);
if (!result.HasValue)
{
Logger.LogError($"{baseLogString} ReportPotentialOutage => Storing outage on element 0x{elementGid:X16} FAILED.");
return(false);
}
var createdOutage = result.Value;
Logger.LogInformation($"{baseLogString} ReportPotentialOutage => Outage on element with gid: 0x{createdOutage.OutageElementGid:x16} is successfully stored in database.");
//await historyDBManagerClient.OnSwitchOpened(elementGid, createdOutage.OutageId);
//await historyDBManagerClient.OnConsumerBlackedOut(affectedConsumersGids, createdOutage.OutageId);
return(await lifecycleHelper.PublishOutageAsync(Topic.ACTIVE_OUTAGE, outageMessageMapper.MapOutageEntity(createdOutage)));
}
catch (Exception e)
{
string message = $"{baseLogString} ReportPotentialOutage => exception: {e.Message}";
Logger.LogError(message, e);
return(false);
}
}
private async Task <bool> FinishIndividualAlgorithmCycle(IsolationAlgorithm algorithm, OutageTopologyModel topology)
{
var algorithmBaseLogString = $"{baseLogString} [HeadBreakerGid: 0x{algorithm.HeadBreakerGid:X16}]";
Logger.LogInformation($"{algorithmBaseLogString} entering FinishIndividualAlgorithmCycle.");
if (algorithm.CurrentBreakerGid <= 0 || algorithm.CurrentBreakerGid == algorithm.RecloserGid)
{
string message = $"{algorithmBaseLogString} FinishIndividualAlgorithmCycle => End of the feeder, no outage detected.";
Logger.LogWarning(message);
return(false);
}
var getCreatedOutageResult = await lifecycleHelper.GetCreatedOutage(algorithm.OutageId);
if (!getCreatedOutageResult.HasValue)
{
Logger.LogError($"{algorithmBaseLogString} FinishIndividualAlgorithmCycle => Created Outage is null. OutageId: {algorithm.OutageId}");
return(false);
}
var outageToIsolate = getCreatedOutageResult.Value;
await SetDefaultIsolationPoints(outageToIsolate, algorithm);
await SetOptimumIsolationPoints(outageToIsolate, algorithm, topology);
//ISOLATE on optimum points
var firstOptimumPoint = outageToIsolate.OptimumIsolationPoints[0];
var secondOptimumPoint = outageToIsolate.OptimumIsolationPoints[1];
var commands = new Dictionary <long, DiscreteCommandingType>
{
{ algorithm.HeadBreakerGid, DiscreteCommandingType.CLOSE },
{ firstOptimumPoint.EquipmentId, DiscreteCommandingType.OPEN },
{ secondOptimumPoint.EquipmentId, DiscreteCommandingType.OPEN },
{ algorithm.RecloserGid, DiscreteCommandingType.CLOSE },
};
var enumerableCommandedElements = await CommandedElements.GetEnumerableDictionaryAsync();
if (!await SendCommands(algorithm, commands, enumerableCommandedElements))
{
string message = $"{algorithmBaseLogString} FinishIndividualAlgorithmCycle => Failed on SendMultipleScadaCommandAsync.";
Logger.LogError(message);
return(false);
}
long outageElementGid = topology.OutageTopology[secondOptimumPoint.EquipmentId].FirstEnd; //element iznad donjeg pointa - moze biti samo jedan gornji element (parent)
if (!topology.OutageTopology[firstOptimumPoint.EquipmentId].SecondEnd.Contains(outageElementGid))
{
string message = $"{algorithmBaseLogString} FinishIndividualAlgorithmCycle => Outage element with gid: 0x{outageElementGid:X16} is not on a second end of current breaker id";
Logger.LogError(message);
return(false);
}
outageToIsolate.IsolatedTime = DateTime.UtcNow;
outageToIsolate.OutageElementGid = outageElementGid;
outageToIsolate.OutageState = OutageState.ISOLATED;
var outageModelAccessClient = OutageModelAccessClient.CreateClient();
await outageModelAccessClient.UpdateOutage(outageToIsolate);
Logger.LogInformation($"{algorithmBaseLogString} FinishIndividualAlgorithmCycle => Isolation of outage with id: {outageToIsolate.OutageId}. Optimum isolation points: 0x{outageToIsolate.OptimumIsolationPoints[0].EquipmentId:X16} and 0x{outageToIsolate.OptimumIsolationPoints[1].EquipmentId:X16}, and outage element id is 0x{outageElementGid:X16}");
await lifecycleHelper.PublishOutageAsync(Topic.ACTIVE_OUTAGE, outageMessageMapper.MapOutageEntity(outageToIsolate));
Logger.LogInformation($"{algorithmBaseLogString} FinishIndividualAlgorithmCycle => Outage with id: 0x{outageToIsolate.OutageId:x16} is successfully published.");
await OnEndAlgorithmCleanUp(algorithm.HeadBreakerGid);
return(true);
}
