public ArchivedOutageMessage MapOutageEntityToArchived(OutageEntity outage) { ArchivedOutageMessage outageMessage; if (outage.OutageState == OutageState.ARCHIVED) { outageMessage = new ArchivedOutageMessage { OutageId = outage.OutageId, ReportTime = outage.ReportTime, IsolatedTime = outage.IsolatedTime, RepairedTime = outage.RepairedTime, ArchivedTime = outage.ArchivedTime ?? DateTime.UtcNow, OutageElementGid = outage.OutageElementGid, DefaultIsolationPoints = equipmentMapper.MapEquipments(outage.DefaultIsolationPoints), OptimumIsolationPoints = equipmentMapper.MapEquipments(outage.OptimumIsolationPoints), AffectedConsumers = consumerMapper.MapConsumers(outage.AffectedConsumers) }; } else { throw new ArgumentException($"MapOutageEntityToArchived => Outage state: {outage.OutageState}, but {OutageState.ARCHIVED} was expected."); } return(outageMessage); }
public ActiveOutageMessage MapOutageEntityToActive(OutageEntity outage) { ActiveOutageMessage outageMessage; if (outage.OutageState != OutageState.ARCHIVED) { outageMessage = new ActiveOutageMessage() { OutageId = outage.OutageId, OutageState = outage.OutageState, ReportTime = outage.ReportTime, IsolatedTime = outage.IsolatedTime, RepairedTime = outage.RepairedTime, OutageElementGid = outage.OutageElementGid, DefaultIsolationPoints = equipmentMapper.MapEquipments(outage.DefaultIsolationPoints), OptimumIsolationPoints = equipmentMapper.MapEquipments(outage.OptimumIsolationPoints), AffectedConsumers = consumerMapper.MapConsumers(outage.AffectedConsumers), IsResolveConditionValidated = outage.IsResolveConditionValidated, }; } else { throw new ArgumentException($"MapOutageEntityToActive => Outage state: { OutageState.ARCHIVED}."); } return(outageMessage); }
public Task <OutageEntity> AddOutage(OutageEntity outage) { return(Task.Run(() => { //MODO: razmisliti o ConditonalValue<OutageEntity> OutageEntity outageEntityDb = null; using (var unitOfWork = new UnitOfWork()) { try { List <Consumer> consumersFromDb = GetConsumersFromDb(outage.AffectedConsumers, unitOfWork); if (consumersFromDb.Count != outage.AffectedConsumers.Count) { Logger.LogError($"{baseLogString} AddOutage => Some of AffectedConsumers are not present in database."); return outageEntityDb; } List <Equipment> defaultIsolationPointsFromDb = GetEquipmentFromDb(outage.DefaultIsolationPoints, unitOfWork); if (defaultIsolationPointsFromDb.Count != outage.DefaultIsolationPoints.Count) { Logger.LogError($"{baseLogString} AddOutage => Some of DefaultIsolationPoints are not present in database."); return outageEntityDb; } List <Equipment> optimumIsolationPointsFromDb = GetEquipmentFromDb(outage.OptimumIsolationPoints, unitOfWork); if (optimumIsolationPointsFromDb.Count != outage.OptimumIsolationPoints.Count) { Logger.LogError($"{baseLogString} AddOutage => Some of OptimumIsolationPoints are not present in database."); return outageEntityDb; } outage.AffectedConsumers.Clear(); outage.AffectedConsumers.AddRange(consumersFromDb); outage.DefaultIsolationPoints.Clear(); outage.DefaultIsolationPoints.AddRange(defaultIsolationPointsFromDb); outage.OptimumIsolationPoints.Clear(); outage.OptimumIsolationPoints.AddRange(optimumIsolationPointsFromDb); outageEntityDb = unitOfWork.OutageRepository.Add(outage); unitOfWork.Complete(); } catch (Exception e) { string message = $"{baseLogString} AddOutage => Exception: {e.Message}"; Logger.LogError(message, e); } } return outageEntityDb; })); }
public ArchivedOutageViewModel MapArchivedOutage(OutageEntity outage) => new ArchivedOutageViewModel { Id = outage.OutageId, ReportedAt = outage.ReportTime, IsolatedAt = outage.IsolatedTime, RepairedAt = outage.RepairedTime, ArchivedAt = (DateTime)outage.ArchivedTime, ElementId = outage.OutageElementGid, DefaultIsolationPoints = _equipmentMapper.MapEquipments(outage.DefaultIsolationPoints), OptimalIsolationPoints = _equipmentMapper.MapEquipments(outage.OptimumIsolationPoints), AffectedConsumers = _consumerMapper.MapConsumers(outage.AffectedConsumers), };
public ActiveOutageViewModel MapActiveOutage(OutageEntity outage) => new ActiveOutageViewModel { Id = outage.OutageId, State = (OutageLifecycleState)outage.OutageState, ReportedAt = outage.ReportTime, IsolatedAt = outage.IsolatedTime, RepairedAt = outage.RepairedTime, ElementId = outage.OutageElementGid, IsResolveConditionValidated = outage.IsResolveConditionValidated, DefaultIsolationPoints = _equipmentMapper.MapEquipments(outage.DefaultIsolationPoints), OptimalIsolationPoints = _equipmentMapper.MapEquipments(outage.OptimumIsolationPoints), AffectedConsumers = _consumerMapper.MapConsumers(outage.AffectedConsumers), };
public bool SendLocationIsolationCrew(long outageId) { OutageEntity outageEntity = null; List <OutageEntity> activeOutages = null; long reportedGid = 0; bool result = false; try { outageEntity = dbContext.OutageRepository.Get(outageId); } catch (Exception ex) { Logger.LogError($"OutageModel::SendLocationIsolationCrew => exception in UnitOfWork.OutageRepository.Get()", ex); } try { activeOutages = dbContext.OutageRepository.GetAllActive().ToList(); } catch (Exception ex) { Logger.LogError("OutageModel::SendLocationIsolationCrew => excpetion in UnitOfWork.OutageRepository.GetAllActive()", ex); return(false); } if (outageEntity == null) { Logger.LogError($"Outage with id 0x{outageId:X16} is not found in database."); return(false); } reportedGid = outageEntity.DefaultIsolationPoints.First().EquipmentId; Task algorithm = Task.Run(() => StartLocationAndIsolationAlgorithm(outageEntity)).ContinueWith(task => { result = task.Result; if (task.IsCompleted) { dbContext.Complete(); } }, TaskContinuationOptions.OnlyOnRanToCompletion).ContinueWith(task => { outageModel.PublishOutage(Topic.ACTIVE_OUTAGE, outageMessageMapper.MapOutageEntity(outageEntity)); }, TaskContinuationOptions.OnlyOnRanToCompletion); algorithm.Wait(); return(result); }
private async Task <ConditionalValue <OutageEntity> > StoreActiveOutage(long elementGid, List <long> affectedConsumersGids, OutageTopologyModel topology) { var outageModelAccessClient = OutageModelAccessClient.CreateClient(); var allOutages = await outageModelAccessClient.GetAllOutages(); var targetedOutages = allOutages.Where(outage => outage.OutageElementGid == elementGid && outage.OutageState != OutageState.ARCHIVED); if (targetedOutages.FirstOrDefault() != null) { Logger.LogWarning($"{baseLogString} StoreActiveOutage => Malfunction on element with gid: 0x{elementGid:x16} has already been reported."); return(new ConditionalValue <OutageEntity>(false, null)); } List <Consumer> consumerDbEntities = await lifecycleHelper.GetAffectedConsumersFromDatabase(affectedConsumersGids); if (consumerDbEntities.Count != affectedConsumersGids.Count) { Logger.LogWarning($"{baseLogString} StoreActiveOutage => Some of affected consumers are not present in database."); return(new ConditionalValue <OutageEntity>(false, null)); } long recloserId = GetRecloserForHeadBreaker(elementGid, topology); List <Equipment> defaultIsolationPoints = await lifecycleHelper.GetEquipmentEntityAsync(new List <long> { elementGid, recloserId }); OutageEntity createdActiveOutage = new OutageEntity { OutageElementGid = elementGid, AffectedConsumers = consumerDbEntities, OutageState = OutageState.CREATED, ReportTime = DateTime.UtcNow, DefaultIsolationPoints = defaultIsolationPoints, }; var activeOutageDbEntity = await outageModelAccessClient.AddOutage(createdActiveOutage); if (activeOutageDbEntity == null) { Logger.LogError($"{baseLogString} StoreActiveOutage => activeOutageDbEntity is null."); return(new ConditionalValue <OutageEntity>(false, null)); } await UpdateRecloserOutageMap(recloserId, affectedConsumersGids, activeOutageDbEntity); return(new ConditionalValue <OutageEntity>(true, activeOutageDbEntity)); }
public void IsolateOutage(long outageId) { //bool success = false; OutageEntity outageToIsolate = dbContext.OutageRepository.Get(outageId); if (outageToIsolate != null) { if (outageToIsolate.OutageState == OutageState.CREATED) { Task.Run(() => StartIsolationAlgorthm(outageToIsolate)) .ContinueWith(task => { if (task.Result) { dbContext.Complete(); } }, TaskContinuationOptions.OnlyOnRanToCompletion) .ContinueWith(task => { try { outageModel.PublishOutage(Topic.ACTIVE_OUTAGE, outageMessageMapper.MapOutageEntity(outageToIsolate)); Logger.LogInfo($"Outage with id: 0x{outageToIsolate.OutageId:x16} is successfully published."); } catch (Exception e) { //TODO: mozda publish neke greske?? Logger.LogError("Error occured while trying to publish outage.", e); } }, TaskContinuationOptions.OnlyOnRanToCompletion); } else { Logger.LogWarn($"Outage with id 0x{outageId:X16} is in state {outageToIsolate.OutageState}, and thus cannot be isolated."); } } else { Logger.LogWarn($"Outage with id 0x{outageId:X16} is not found in database."); //success = false; } //return success; }
public Task RemoveOutage(OutageEntity outage) { return(Task.Run(() => { using (var unitOfWork = new UnitOfWork()) { try { unitOfWork.OutageRepository.Remove(outage); unitOfWork.Complete(); } catch (Exception e) { string message = $"{baseLogString} RemoveOutage => Exception: {e.Message}"; Logger.LogError(message, e); } } })); }
private async Task SetOptimumIsolationPoints(OutageEntity outageEntity, IsolationAlgorithm algorithm, OutageTopologyModel topology) { var algorithmBaseLogString = $"{baseLogString} [HeadBreakerGid: 0x{algorithm.HeadBreakerGid:X16}]"; long firstOptimumIsolationPointGid = algorithm.CurrentBreakerGid; long secondOptimumIsolationPointGid = lifecycleHelper.GetNextBreaker(firstOptimumIsolationPointGid, topology); if (!topology.OutageTopology.ContainsKey(secondOptimumIsolationPointGid)) { string message = $"{algorithmBaseLogString} SetOptimumIsolationPoints => Breaker (next breaker) with id: 0x{secondOptimumIsolationPointGid:X16} is not in topology"; Logger.LogError(message); throw new Exception(message); } long outageElement = topology.OutageTopology[secondOptimumIsolationPointGid].FirstEnd; if (!topology.OutageTopology[firstOptimumIsolationPointGid].SecondEnd.Contains(outageElement)) { string message = $"{algorithmBaseLogString} SetOptimumIsolationPoints => Outage element with gid: 0x{outageElement:X16} is not on a second end of current breaker id"; Logger.LogError(message); throw new Exception(message); } outageEntity.OptimumIsolationPoints = await lifecycleHelper.GetEquipmentEntityAsync(new List <long>() { firstOptimumIsolationPointGid, secondOptimumIsolationPointGid }); if (outageEntity.OptimumIsolationPoints.Count != 2 || !outageEntity.OptimumIsolationPoints.Any(point => point.EquipmentId == firstOptimumIsolationPointGid) || !outageEntity.OptimumIsolationPoints.Any(point => point.EquipmentId == secondOptimumIsolationPointGid)) { string message = $"{algorithmBaseLogString} SetOptimumIsolationPoints => first OptimumIsolationPointGid [0x{firstOptimumIsolationPointGid:X16}] or second OptimumIsolationPointGid [0x{secondOptimumIsolationPointGid:X16}] were not found or created successfully."; Logger.LogError(message); throw new Exception(message); } await OptimumIsolationPoints.SetAsync(firstOptimumIsolationPointGid, algorithm.HeadBreakerGid); await OptimumIsolationPoints.SetAsync(secondOptimumIsolationPointGid, algorithm.HeadBreakerGid); Logger.LogInformation($"{algorithmBaseLogString} SetOptimumIsolationPoints => Optimum points 0x{firstOptimumIsolationPointGid:X16} and 0x{secondOptimumIsolationPointGid:X16}"); }
public OutageMessage MapOutageEntity(OutageEntity outage) { OutageMessage outageMessage; if (outage.OutageState != OutageState.ARCHIVED) { outageMessage = new ActiveOutageMessage() { OutageId = outage.OutageId, OutageState = outage.OutageState, ReportTime = outage.ReportTime, IsolatedTime = outage.IsolatedTime, RepairedTime = outage.RepairedTime, OutageElementGid = outage.OutageElementGid, DefaultIsolationPoints = equipmentMapper.MapEquipments(outage.DefaultIsolationPoints), OptimumIsolationPoints = equipmentMapper.MapEquipments(outage.OptimumIsolationPoints), AffectedConsumers = consumerMapper.MapConsumers(outage.AffectedConsumers), IsResolveConditionValidated = outage.IsResolveConditionValidated, }; } else { outageMessage = new ArchivedOutageMessage { OutageId = outage.OutageId, ReportTime = outage.ReportTime, IsolatedTime = outage.IsolatedTime, RepairedTime = outage.RepairedTime, ArchivedTime = outage.ArchivedTime ?? DateTime.UtcNow, OutageElementGid = outage.OutageElementGid, DefaultIsolationPoints = equipmentMapper.MapEquipments(outage.DefaultIsolationPoints), OptimumIsolationPoints = equipmentMapper.MapEquipments(outage.OptimumIsolationPoints), AffectedConsumers = consumerMapper.MapConsumers(outage.AffectedConsumers) }; } return(outageMessage); }
public Task <OutageEntity> GetOutage(long gid) { return(Task.Run(() => { //MODO: razmisliti o ConditonalValue<OutageEntity> OutageEntity outageEntityDb = null; using (var unitOfWork = new UnitOfWork()) { try { outageEntityDb = unitOfWork.OutageRepository.Get(gid); } catch (Exception e) { string message = $"{baseLogString} GetOutage => Exception: {e.Message}"; Logger.LogError(message, e); } } return outageEntityDb; })); }
private async Task SetDefaultIsolationPoints(OutageEntity outageEntity, IsolationAlgorithm algorithm) { var algorithmBaseLogString = $"{baseLogString} [HeadBreakerGid: 0x{algorithm.HeadBreakerGid:X16}]"; var equipmentAccessClient = EquipmentAccessClient.CreateClient(); Equipment headBreakerEquipment = await equipmentAccessClient.GetEquipment(algorithm.HeadBreakerGid); Equipment recloserEquipment = await equipmentAccessClient.GetEquipment(algorithm.RecloserGid); if (headBreakerEquipment == null || recloserEquipment == null) { string message = $"{algorithmBaseLogString} SetDefaultIsolationPoints => Recloser [0x{algorithm.HeadBreakerGid:X16}] or HeadBreaker [0x{algorithm.RecloserGid:X16}] were not found in database"; Logger.LogError(message); throw new Exception(message); } outageEntity.DefaultIsolationPoints = new List <Equipment>() { headBreakerEquipment, recloserEquipment }; Logger.LogInformation($"{algorithmBaseLogString} SetDefaultIsolationPoints => Optimum points 0x{headBreakerEquipment:X16} and 0x{recloserEquipment:X16}"); }
private async Task <bool> StartIsolationAlgorthm(OutageEntity outageToIsolate) { var result = await CreateIsolatingAlgorithm(outageToIsolate); if (!result.HasValue) { Logger.LogError($"{baseLogString} StartIsolationAlgorthm => CreateIsolatingAlgorithm did not return a vaule."); return(false); } var algorithm = result.Value; Logger.LogInformation($"{baseLogString} StartIsolationAlgorthm => HeadBreakerGid: 0x{algorithm.HeadBreakerGid:X16}, RecloserGd: 0x{algorithm.RecloserGid:X16} (Recloser gid is -1 if there is no recloser...)."); var scadaClient = ScadaIntegrityUpdateClient.CreateClient(); var scadaPublication = await scadaClient.GetIntegrityUpdateForSpecificTopic(Topic.SWITCH_STATUS); if (!(scadaPublication.Message is MultipleDiscreteValueSCADAMessage multipleDiscreteValueSCADAMessage)) { Logger.LogError($"{baseLogString} StartIsolationAlgorthm => ScadaPublication message is not of expected type: {typeof(MultipleDiscreteValueSCADAMessage)}, but of type: {scadaPublication.Message.GetType()}"); return(false); } if (!multipleDiscreteValueSCADAMessage.Data.ContainsKey(algorithm.HeadBreakerMeasurementGid)) { Logger.LogError($"{baseLogString} StartIsolationAlgorthm => HeadBreakerMeasurement with gid: 0x{algorithm.HeadBreakerMeasurementGid:X16} not found in integrity update data received from scada."); return(false); } var discreteModbusData = multipleDiscreteValueSCADAMessage.Data[algorithm.HeadBreakerMeasurementGid]; await MonitoredHeadBreakerMeasurements.SetAsync(algorithm.HeadBreakerMeasurementGid, discreteModbusData); await StartedIsolationAlgorithms.SetAsync(algorithm.HeadBreakerGid, algorithm); return(true); }
private async Task <ConditionalValue <IsolationAlgorithm> > CreateIsolatingAlgorithm(OutageEntity outageToIsolate) { List <long> defaultIsolationPoints = outageToIsolate.DefaultIsolationPoints.Select(point => point.EquipmentId).ToList(); if (defaultIsolationPoints.Count != 1 && defaultIsolationPoints.Count != 2) { Logger.LogWarning($"{baseLogString} CreateIsolatingAlgorithm => Number of defaultIsolationPoints ({defaultIsolationPoints.Count}) is out of range [1, 2]."); return(new ConditionalValue <IsolationAlgorithm>(false, null)); } var measurementMapClient = MeasurementMapClient.CreateClient(); var ceModelProvider = CeModelProviderClient.CreateClient(); bool isFirstBreakerRecloser = await ceModelProvider.IsRecloser(defaultIsolationPoints[0]); #region HeadBreaker long headBreakerGid = await GetHeadBreakerAsync(defaultIsolationPoints, isFirstBreakerRecloser); if (headBreakerGid <= 0) { Logger.LogWarning($"{baseLogString} CreateIsolatingAlgorithm => Head breaker not found."); return(new ConditionalValue <IsolationAlgorithm>(false, null)); } ModelCode headBreakerModelCode = modelResourcesDesc.GetModelCodeFromId(headBreakerGid); if (headBreakerModelCode != ModelCode.BREAKER) { Logger.LogError($"{baseLogString} CreateIsolatingAlgorithm => Head breaker type is {headBreakerModelCode}, not a {ModelCode.BREAKER}."); return(new ConditionalValue <IsolationAlgorithm>(false, null)); } var headBreakerMeasurementGid = (await measurementMapClient.GetMeasurementsOfElement(headBreakerGid)).FirstOrDefault(); if (headBreakerMeasurementGid <= 0) { Logger.LogWarning($"{baseLogString} CreateIsolatingAlgorithm => Head breaker measurement not found."); return(new ConditionalValue <IsolationAlgorithm>(false, null)); } #endregion HeadBreaker #region Recloser long recloserGid = await GetRecloserAsync(defaultIsolationPoints, isFirstBreakerRecloser); long recloserMeasurementGid = -1; if (recloserGid > 0) //ne mora postojati recloser { ModelCode recloserModelCode = modelResourcesDesc.GetModelCodeFromId(recloserGid); if (recloserModelCode != ModelCode.BREAKER) { Logger.LogError($"{baseLogString} CreateIsolatingAlgorithm => Recloser type is {headBreakerModelCode}, not a {ModelCode.BREAKER}."); return(new ConditionalValue <IsolationAlgorithm>(false, null)); } var ceModelProviderClient = CeModelProviderClient.CreateClient(); if (!await ceModelProviderClient.IsRecloser(recloserGid)) { Logger.LogError($"{baseLogString} CreateIsolatingAlgorithm => Breaker with gid 0x{recloserGid:X16} is not a Recloser."); return(new ConditionalValue <IsolationAlgorithm>(false, null)); } recloserMeasurementGid = (await measurementMapClient.GetMeasurementsOfElement(headBreakerGid)).FirstOrDefault(); if (recloserMeasurementGid <= 0) { Logger.LogWarning($"{baseLogString} CreateIsolatingAlgorithm => Head breaker measurement not found."); return(new ConditionalValue <IsolationAlgorithm>(false, null)); } } #endregion Recloser var algorithm = new IsolationAlgorithm() { OutageId = outageToIsolate.OutageId, HeadBreakerGid = headBreakerGid, HeadBreakerMeasurementGid = headBreakerMeasurementGid, CurrentBreakerGid = headBreakerGid, CurrentBreakerMeasurementGid = headBreakerMeasurementGid, RecloserGid = recloserGid, RecloserMeasurementGid = recloserMeasurementGid, CycleCounter = 0, }; return(new ConditionalValue <IsolationAlgorithm>(true, algorithm)); }
public bool StartIsolationAlgorthm(OutageEntity outageToIsolate) { List <long> defaultIsolationPoints = outageToIsolate.DefaultIsolationPoints.Select(point => point.EquipmentId).ToList(); bool isIsolated; bool isFirstBreakerRecloser; if (defaultIsolationPoints.Count > 0 && defaultIsolationPoints.Count < 3) { long headBreaker = -1; long recloser = -1; try { isFirstBreakerRecloser = CheckIfBreakerIsRecloser(defaultIsolationPoints[0]); //TODO is second recloser (future) } catch (Exception e) { Logger.LogWarn("Exception on method CheckIfBreakerIsRecloser()", e); throw e; } GetHeadBreakerAndRecloser(defaultIsolationPoints, isFirstBreakerRecloser, ref headBreaker, ref recloser); if (headBreaker != -1) { ModelCode mc = outageModel.modelResourcesDesc.GetModelCodeFromId(headBreaker); if (mc == ModelCode.BREAKER) { long headBreakerMeasurementId, recloserMeasurementId; using (MeasurementMapProxy measurementMapProxy = proxyFactory.CreateProxy <MeasurementMapProxy, IMeasurementMapContract>(EndpointNames.MeasurementMapEndpoint)) { try { headBreakerMeasurementId = measurementMapProxy.GetMeasurementsOfElement(headBreaker)[0]; if (recloser != -1) { recloserMeasurementId = measurementMapProxy.GetMeasurementsOfElement(recloser)[0]; } else { recloserMeasurementId = -1; } } catch (Exception e) { Logger.LogError("Error on GetMeasurementsForElement() method.", e); throw e; } } Logger.LogInfo($"Head breaker id: 0x{headBreaker:X16}, recloser id: 0x{recloser:X16} (-1 if no recloser)."); //ALGORITHM AutoResetEvent autoResetEvent = new AutoResetEvent(false); CancelationObject cancelationObject = new CancelationObject() { CancelationSignal = false }; Timer timer = InitalizeAlgorthmTimer(cancelationObject, autoResetEvent); ScadaNotification scadaNotification = new ScadaNotification("OutageModel_SCADA_Subscriber", new OutageIsolationAlgorithm.OutageIsolationAlgorithmParameters(headBreakerMeasurementId, recloserMeasurementId, autoResetEvent)); SubscriberProxy subscriberProxy = proxyFactory.CreateProxy <SubscriberProxy, ISubscriber>(scadaNotification, EndpointNames.SubscriberEndpoint); subscriberProxy.Subscribe(Topic.SWITCH_STATUS); long currentBreakerId = headBreaker; while (!cancelationObject.CancelationSignal) { if (outageModel.TopologyModel.OutageTopology.ContainsKey(currentBreakerId)) { currentBreakerId = outageModel.GetNextBreaker(currentBreakerId); Logger.LogDebug($"Next breaker is 0x{currentBreakerId:X16}."); if (currentBreakerId == -1 || currentBreakerId == recloser) { //TODO: planned outage string message = "End of the feeder, no outage detected."; Logger.LogWarn(message); isIsolated = false; subscriberProxy.Close(); outageModel.commandedElements.Clear(); throw new Exception(message); } //TODO: SCADACommand SendSCADACommand(currentBreakerId, DiscreteCommandingType.OPEN); SendSCADACommand(headBreaker, DiscreteCommandingType.CLOSE); timer.Start(); Logger.LogDebug("Timer started."); autoResetEvent.WaitOne(); if (timer.Enabled) { timer.Stop(); Logger.LogDebug("Timer stoped"); SendSCADACommand(currentBreakerId, DiscreteCommandingType.CLOSE); } } } long nextBreakerId = outageModel.GetNextBreaker(currentBreakerId); if (currentBreakerId != 0 && currentBreakerId != recloser) { outageToIsolate.OptimumIsolationPoints = outageModel.GetEquipmentEntity(new List <long> { currentBreakerId, nextBreakerId }); if (!outageModel.TopologyModel.OutageTopology.ContainsKey(nextBreakerId)) { string message = $"Breaker (next breaker) with id: 0x{nextBreakerId:X16} is not in topology"; Logger.LogError(message); throw new Exception(message); } long outageElement = outageModel.TopologyModel.OutageTopology[nextBreakerId].FirstEnd; if (!outageModel.TopologyModel.OutageTopology[currentBreakerId].SecondEnd.Contains(outageElement)) { string message = $"Outage element with gid: 0x{outageElement:X16} is not on a second end of current breaker id"; Logger.LogError(message); throw new Exception(message); } //TODO: SCADA Command subscriberProxy.Close(); outageModel.optimumIsolationPoints.Add(currentBreakerId); outageModel.optimumIsolationPoints.Add(nextBreakerId); SendSCADACommand(currentBreakerId, DiscreteCommandingType.OPEN); SendSCADACommand(nextBreakerId, DiscreteCommandingType.OPEN); outageToIsolate.IsolatedTime = DateTime.UtcNow; outageToIsolate.OutageElementGid = outageElement; outageToIsolate.OutageState = OutageState.ISOLATED; Logger.LogInfo($"Isolation of outage with id {outageToIsolate.OutageId}. Optimum isolation points: 0x{currentBreakerId:X16} and 0x{nextBreakerId:X16}, and outage element id is 0x{outageElement:X16}"); isIsolated = true; } else { string message = "End of the feeder, no outage detected."; Logger.LogWarn(message); isIsolated = false; subscriberProxy.Close(); outageModel.commandedElements.Clear(); throw new Exception(message); } } else { Logger.LogWarn($"Head breaker type is {mc}, not a {ModelCode.BREAKER}."); isIsolated = false; } } else { Logger.LogWarn("Head breaker not found."); isIsolated = false; } } else { Logger.LogWarn($"Number of defaultIsolationPoints ({defaultIsolationPoints.Count}) is out of range [1, 2]."); isIsolated = false; } outageModel.commandedElements.Clear(); return(isIsolated); }
public bool ReportPotentialOutage(long gid, CommandOriginType commandOriginType) { bool success = false; List <long> affectedConsumersIds = new List <long>(); affectedConsumersIds = GetAffectedConsumers(gid); if (commandOriginType != CommandOriginType.USER_COMMAND && commandOriginType != CommandOriginType.ISOLATING_ALGORITHM_COMMAND) { Logger.LogDebug($"Reporting outage for gid: 0x{gid:X16}"); if (outageModel.commandedElements.Contains(gid) || outageModel.optimumIsolationPoints.Contains(gid)) { outageModel.SwitchOpened?.Invoke(gid, null); outageModel.ConsumersBlackedOut?.Invoke(affectedConsumersIds, null); return(false); } if (affectedConsumersIds.Count == 0) { bool isSwitchInvoked = false; if (recloserOutageMap.TryGetValue(gid, out Dictionary <long, List <long> > outageAffectedPair)) { foreach (var pair in outageAffectedPair) { outageModel.ConsumersBlackedOut?.Invoke(pair.Value, pair.Key); outageModel.SwitchOpened?.Invoke(gid, pair.Key); isSwitchInvoked = true; } } if (!isSwitchInvoked) { outageModel.SwitchOpened?.Invoke(gid, null); } Logger.LogInfo("There is no affected consumers => outage report is not valid."); return(false); } OutageEntity activeOutageDbEntity = null; if (dbContext.OutageRepository.Find(o => o.OutageElementGid == gid && o.OutageState != OutageState.ARCHIVED).FirstOrDefault() != null) { Logger.LogWarn($"Malfunction on element with gid: 0x{gid:x16} has already been reported."); return(false); } List <Consumer> consumerDbEntities = outageModel.GetAffectedConsumersFromDatabase(affectedConsumersIds); if (consumerDbEntities.Count != affectedConsumersIds.Count) { Logger.LogWarn("Some of affected consumers are not present in database"); return(false); } long recloserId; try { recloserId = outageModel.GetRecloserForHeadBreaker(gid); } catch (Exception) { return(false); } List <Equipment> defaultIsolationPoints = outageModel.GetEquipmentEntity(new List <long> { gid, recloserId }); OutageEntity createdActiveOutage = new OutageEntity { AffectedConsumers = consumerDbEntities, OutageState = OutageState.CREATED, ReportTime = DateTime.UtcNow, DefaultIsolationPoints = defaultIsolationPoints, }; activeOutageDbEntity = dbContext.OutageRepository.Add(createdActiveOutage); try { dbContext.Complete(); Logger.LogDebug($"Outage on element with gid: 0x{activeOutageDbEntity.OutageElementGid:x16} is successfully stored in database."); success = true; if (recloserOutageMap.TryGetValue(recloserId, out Dictionary <long, List <long> > outageAffectedPair)) { if (outageAffectedPair.TryGetValue(createdActiveOutage.OutageId, out List <long> affected)) { affected = new List <long>(affectedConsumersIds); } else { outageAffectedPair.Add(createdActiveOutage.OutageId, affectedConsumersIds); } } else { Dictionary <long, List <long> > dict = new Dictionary <long, List <long> >() { { createdActiveOutage.OutageId, affectedConsumersIds } }; recloserOutageMap.Add(recloserId, dict); } outageModel.SwitchOpened?.Invoke(gid, createdActiveOutage.OutageId); outageModel.ConsumersBlackedOut?.Invoke(affectedConsumersIds, createdActiveOutage.OutageId); } catch (Exception e) { string message = "OutageModel::ReportPotentialOutage method => exception on Complete()"; Logger.LogError(message, e); Console.WriteLine($"{message}, Message: {e.Message}, Inner Message: {e.InnerException.Message})"); //TODO: da li je dobar handle? dbContext.Dispose(); dbContext = new UnitOfWork(); success = false; } if (success && activeOutageDbEntity != null) { try { success = outageModel.PublishOutage(Topic.ACTIVE_OUTAGE, outageMessageMapper.MapOutageEntity(activeOutageDbEntity)); if (success) { Logger.LogInfo($"Outage on element with gid: 0x{activeOutageDbEntity.OutageElementGid:x16} is successfully published"); } } catch (Exception e) //TODO: Exception over proxy or enum... { Logger.LogError("OutageModel::ReportPotentialOutage => exception on PublishActiveOutage()", e); success = false; } } } else { //USER COMANDA - korisnik rucno otvara neki breaker -> nije outage ali korisnici potencijalno ostaju bez napajanja outageModel.SwitchOpened?.Invoke(gid, null); outageModel.ConsumersBlackedOut?.Invoke(affectedConsumersIds, null); } return(success); }
public bool SendRepairCrew(long outageId) { OutageEntity outageDbEntity = null; try { outageDbEntity = dbContext.OutageRepository.Get(outageId); } catch (Exception e) { string message = "OutageModel::SendRepairCrew => exception in UnitOfWork.ActiveOutageRepository.Get()"; Logger.LogError(message, e); throw e; } if (outageDbEntity == null) { Logger.LogError($"Outage with id 0x{outageId:X16} is not found in database."); return(false); } if (outageDbEntity.OutageState != OutageState.ISOLATED) { Logger.LogError($"Outage with id 0x{outageId:X16} is in state {outageDbEntity.OutageState}, and thus repair crew can not be sent. (Expected state: {OutageState.ISOLATED})"); return(false); } Task task = Task.Run(() => { Task.Delay(10000).Wait(); using (OutageSimulatorServiceProxy proxy = proxyFactory.CreateProxy <OutageSimulatorServiceProxy, IOutageSimulatorContract>(EndpointNames.OutageSimulatorServiceEndpoint)) { if (proxy == null) { string message = "OutageModel::SendRepairCrew => OutageSimulatorServiceProxy is null"; Logger.LogError(message); throw new NullReferenceException(message); } if (proxy.StopOutageSimulation(outageDbEntity.OutageElementGid)) { outageDbEntity.OutageState = OutageState.REPAIRED; outageDbEntity.RepairedTime = DateTime.UtcNow; dbContext.OutageRepository.Update(outageDbEntity); try { dbContext.Complete(); outageModel.PublishOutage(Topic.ACTIVE_OUTAGE, outageMessageMapper.MapOutageEntity(outageDbEntity)); } catch (Exception e) { string message = "OutageModel::SendRepairCrew => exception in Complete method."; Logger.LogError(message, e); } } else { string message = "OutageModel::SendRepairCrew => ResolvedOutage() not finished with SUCCESS"; Logger.LogError(message); } } }); return(true); }
public bool ResolveOutage(long outageId) { OutageEntity activeOutageDbEntity = null; try { activeOutageDbEntity = dbContext.OutageRepository.Get(outageId); } catch (Exception e) { string message = "OutageModel::SendRepairCrew => exception in UnitOfWork.ActiveOutageRepository.Get()"; Logger.LogError(message, e); throw e; } if (activeOutageDbEntity == null) { Logger.LogError($"Outage with id 0x{outageId:X16} is not found in database."); return(false); } if (activeOutageDbEntity.OutageState != OutageState.REPAIRED) { Logger.LogError($"Outage with id 0x{outageId:X16} is in state {activeOutageDbEntity.OutageState}, and thus repair crew can not be sent. (Expected state: {OutageState.REPAIRED})"); return(false); } if (!activeOutageDbEntity.IsResolveConditionValidated) { //TODO: mozda i ovde odraditi proveru uslova? Logger.LogWarn("ResolveOutage => resolve conditions not validated."); return(false); } OutageEntity createdArchivedOutage = new OutageEntity() { OutageId = activeOutageDbEntity.OutageId, OutageState = OutageState.ARCHIVED, OutageElementGid = activeOutageDbEntity.OutageElementGid, IsResolveConditionValidated = activeOutageDbEntity.IsResolveConditionValidated, ReportTime = activeOutageDbEntity.ReportTime, IsolatedTime = activeOutageDbEntity.IsolatedTime, RepairedTime = activeOutageDbEntity.RepairedTime, ArchivedTime = DateTime.UtcNow, DefaultIsolationPoints = new List <Equipment>(activeOutageDbEntity.DefaultIsolationPoints), OptimumIsolationPoints = new List <Equipment>(activeOutageDbEntity.OptimumIsolationPoints), AffectedConsumers = new List <Consumer>(activeOutageDbEntity.AffectedConsumers), }; bool success; dbContext.OutageRepository.Remove(activeOutageDbEntity); OutageEntity archivedOutageDbEntity = dbContext.OutageRepository.Add(createdArchivedOutage); try { dbContext.Complete(); Logger.LogDebug($"ArchivedOutage on element with gid: 0x{archivedOutageDbEntity.OutageElementGid:x16} is successfully stored in database."); success = true; } catch (Exception e) { string message = "OutageModel::ResolveOutage method => exception on Complete()"; Logger.LogError(message, e); Console.WriteLine($"{message}, Message: {e.Message})"); //TODO: da li je dobar handle? dbContext.Dispose(); dbContext = new UnitOfWork(); success = false; } if (success && archivedOutageDbEntity != null) //TODO: ne svidja mi se ova konstrukcija... { try { success = outageModel.PublishOutage(Topic.ARCHIVED_OUTAGE, outageMessageMapper.MapOutageEntity(archivedOutageDbEntity)); if (success) { Logger.LogInfo($"ArchivedOutage on element with gid: 0x{archivedOutageDbEntity.OutageElementGid:x16} is successfully published"); } } catch (Exception e) //TODO: Exception over proxy or enum... { Logger.LogError("OutageModel::ResolveOutage => exception on PublishActiveOutage()", e); success = false; } } return(success); }
public Task UpdateOutage(OutageEntity outage) { return(Task.Run(() => { using (var unitOfWork = new UnitOfWork()) { try { OutageEntity outageFromDb = unitOfWork.OutageRepository.Get(outage.OutageId); if (outageFromDb == null) { Logger.LogError($"{baseLogString} UpdateOutage => Outage with id {outage.OutageId} is not present in database."); return; } List <Consumer> consumersFromDb = GetConsumersFromDb(outage.AffectedConsumers, unitOfWork); if (consumersFromDb.Count != outage.AffectedConsumers.Count) { Logger.LogError($"{baseLogString} UpdateOutage => Some of AffectedConsumers are not present in database."); return; } List <Equipment> defaultIsolationPointsFromDb = GetEquipmentFromDb(outage.DefaultIsolationPoints, unitOfWork); if (defaultIsolationPointsFromDb.Count != outage.DefaultIsolationPoints.Count) { Logger.LogError($"{baseLogString} UpdateOutage => Some of DefaultIsolationPoints are not present in database."); return; } List <Equipment> optimumIsolationPointsFromDb = GetEquipmentFromDb(outage.OptimumIsolationPoints, unitOfWork); if (optimumIsolationPointsFromDb.Count != outage.OptimumIsolationPoints.Count) { Logger.LogError($"{baseLogString} UpdateOutage => Some of OptimumIsolationPoints are not present in database."); return; } outageFromDb.AffectedConsumers.Clear(); outageFromDb.AffectedConsumers.AddRange(consumersFromDb); outageFromDb.DefaultIsolationPoints.Clear(); outageFromDb.DefaultIsolationPoints.AddRange(defaultIsolationPointsFromDb); outageFromDb.OptimumIsolationPoints.Clear(); outageFromDb.OptimumIsolationPoints.AddRange(optimumIsolationPointsFromDb); outageFromDb.OutageState = outage.OutageState; outageFromDb.ArchivedTime = outage.ArchivedTime; outageFromDb.IsolatedTime = outage.IsolatedTime; outageFromDb.IsResolveConditionValidated = outage.IsResolveConditionValidated; outageFromDb.OutageElementGid = outage.OutageElementGid; outageFromDb.RepairedTime = outage.RepairedTime; outageFromDb.ReportTime = outage.ReportTime; unitOfWork.OutageRepository.Update(outageFromDb); unitOfWork.Complete(); } catch (Exception e) { string message = $"{baseLogString} UpdateOutage => Exception: {e.Message}"; Logger.LogError(message, e); } } })); }
private async Task <bool> StartLocationAndIsolationAlgorithm(OutageEntity outageEntity, OutageTopologyModel topology) { long reportedGid = outageEntity.DefaultIsolationPoints.First().EquipmentId; if (!topology.GetElementByGid(reportedGid, out OutageTopologyElement topologyElement)) { Logger.LogError($"{baseLogString} StartLocationAndIsolationAlgorithm => element with gid 0x{reportedGid:X16} not found in outage topology model."); return(false); } long upBreaker; long outageElementGid = -1; Logger.LogInformation($"{baseLogString} StartLocationAndIsolationAlgorithm => Entering 10 sec delay."); await Task.Delay(10_000); Logger.LogInformation($"{baseLogString} StartLocationAndIsolationAlgorithm => 10 sec delay ended."); var outageSimulatorClient = OutageSimulatorClient.CreateClient(); var outageModelAccessClient = OutageModelAccessClient.CreateClient(); //Da li je prijaveljen element OutageElement if (await outageSimulatorClient.IsOutageElement(reportedGid)) { outageElementGid = reportedGid; } //Da li je mozda na ACL-novima ispod prijavljenog elementa else { for (int i = 0; i < topologyElement.SecondEnd.Count; i++) { var potentialOutageElementGid = topologyElement.SecondEnd[i]; if (!(await outageSimulatorClient.IsOutageElement(potentialOutageElementGid))) { continue; } if (outageElementGid == -1) { outageElementGid = potentialOutageElementGid; outageEntity.OutageElementGid = outageElementGid; //outageEntity.AffectedConsumers = await lifecycleHelper.GetAffectedConsumersFromDatabase(lifecycleHelper.GetAffectedConsumers(outageElementGid, topology, NetworkType.NON_SCADA_NETWORK)); } else { //KAKO SE ULAZI U OVAJ ELSE? => u else se ulazi tako sto se ide kroz for i prvi element se oznaci kao outage element, zatim se pronaje jos neki... znaci ovo je nacin da se kreira drugi, treci outage, na racvanju ispod elementa, po for-u.... var entity = new OutageEntity() { OutageElementGid = potentialOutageElementGid, ReportTime = DateTime.UtcNow }; await outageModelAccessClient.AddOutage(entity); } } } //Tragamo za ACL-om gore ka source-u while (outageElementGid == -1 && !topologyElement.IsRemote && topologyElement.DmsType != "ENERGYSOURCE") { if (await outageSimulatorClient.IsOutageElement(topologyElement.Id)) { outageElementGid = topologyElement.Id; outageEntity.OutageElementGid = outageElementGid; } topology.GetElementByGid(topologyElement.FirstEnd, out topologyElement); } if (outageElementGid == -1) { outageEntity.OutageState = OutageState.REMOVED; await outageModelAccessClient.RemoveOutage(outageEntity); Logger.LogError($"{baseLogString} StartLocationAndIsolationAlgorithm => End of feeder no outage detected."); return(false); } topology.GetElementByGidFirstEnd(outageEntity.OutageElementGid, out topologyElement); while (topologyElement.DmsType != "BREAKER") { topology.GetElementByGidFirstEnd(topologyElement.Id, out topologyElement); } upBreaker = topologyElement.Id; long nextBreaker = lifecycleHelper.GetNextBreaker(outageEntity.OutageElementGid, topology); if (!topology.OutageTopology.ContainsKey(nextBreaker)) { string message = $"{baseLogString} StartLocationAndIsolationAlgorithm => Breaker (next breaker) with id: 0x{nextBreaker:X16} is not in topology"; Logger.LogError(message); throw new Exception(message); } long outageElement = topology.OutageTopology[nextBreaker].FirstEnd; if (!topology.OutageTopology[upBreaker].SecondEnd.Contains(outageElement)) { string message = $"{baseLogString} StartLocationAndIsolationAlgorithm => Outage element with gid: 0x{outageElement:X16} is not on a second end of current breaker id"; Logger.LogError(message); throw new Exception(message); } outageEntity.OptimumIsolationPoints = await lifecycleHelper.GetEquipmentEntityAsync(new List <long>() { upBreaker, nextBreaker }); outageEntity.IsolatedTime = DateTime.UtcNow; outageEntity.OutageState = OutageState.ISOLATED; await outageModelAccessClient.UpdateOutage(outageEntity); var commands = new Dictionary <long, DiscreteCommandingType> { { upBreaker, DiscreteCommandingType.OPEN }, { nextBreaker, DiscreteCommandingType.OPEN }, }; var enumerableCommandedElements = await CommandedElements.GetEnumerableDictionaryAsync(); if (!await lifecycleHelper.SendMultipleScadaCommandAsync(commands, enumerableCommandedElements, CommandOriginType.LOCATION_AND_ISOLATING_ALGORITHM_COMMAND)) { string message = $"{baseLogString} StartLocationAndIsolationAlgorithm => Sending multiple command failed."; Logger.LogError(message); return(false); } commands.Keys.ToList().ForEach(async commandedElementGid => { await ElementsToBeIgnoredInReportPotentialOutage.SetAsync(commandedElementGid, DateTime.UtcNow); Logger.LogDebug($"{baseLogString} SendCommands => Element 0x{commandedElementGid:X16} set to collection '{ReliableDictionaryNames.ElementsToBeIgnoredInReportPotentialOutage}' at {DateTime.UtcNow}."); }); return(true); }
public Task UpdateOutage(OutageEntity outage) { return(InvokeWithRetryAsync(client => client.Channel.UpdateOutage(outage))); }
public bool StartLocationAndIsolationAlgorithm(OutageEntity outageEntity) { IOutageTopologyElement topologyElement = null; long reportedGid = outageEntity.DefaultIsolationPoints.First().EquipmentId; long outageElementId = -1; long UpBreaker; Task.Delay(5000).Wait(); using (OutageSimulatorServiceProxy proxy = proxyFactory.CreateProxy <OutageSimulatorServiceProxy, IOutageSimulatorContract>(EndpointNames.OutageSimulatorServiceEndpoint)) { if (proxy == null) { string message = "OutageModel::SendLocationIsolationCrew => OutageSimulatorProxy is null"; Logger.LogError(message); throw new NullReferenceException(message); } //Da li je prijaveljen element OutageElement if (proxy.IsOutageElement(reportedGid)) { outageElementId = reportedGid; } else { //Da li je mozda na ACL-novima ispod prijavljenog elementa if (outageModel.TopologyModel.GetElementByGid(reportedGid, out topologyElement)) { try { for (int i = 0; i < topologyElement.SecondEnd.Count; i++) { if (proxy.IsOutageElement(topologyElement.SecondEnd[i])) { if (outageElementId == -1) { outageElementId = topologyElement.SecondEnd[i]; outageEntity.OutageElementGid = outageElementId; } else { OutageEntity entity = new OutageEntity() { OutageElementGid = topologyElement.SecondEnd[i], ReportTime = DateTime.UtcNow }; dbContext.OutageRepository.Add(entity); } } } } catch (Exception ex) { Logger.LogError("OutageModel::SendLocationIsolationCrew => failed with error", ex); throw; } } } //Tragamo za ACL-om gore ka source-u while (outageElementId == -1 && !topologyElement.IsRemote && topologyElement.DmsType != "ENERGYSOURCE") { if (proxy.IsOutageElement(topologyElement.Id)) { outageElementId = topologyElement.Id; outageEntity.OutageElementGid = outageElementId; } outageModel.TopologyModel.GetElementByGid(topologyElement.FirstEnd, out topologyElement); } if (outageElementId == -1) { outageEntity.OutageState = OutageState.REMOVED; dbContext.OutageRepository.Remove(outageEntity); Logger.LogError("End of feeder no outage detected."); return(false); } outageModel.TopologyModel.GetElementByGidFirstEnd(outageEntity.OutageElementGid, out topologyElement); while (topologyElement.DmsType != "BREAKER") { outageModel.TopologyModel.GetElementByGidFirstEnd(topologyElement.Id, out topologyElement); } UpBreaker = topologyElement.Id; long nextBreaker = outageModel.GetNextBreaker(outageEntity.OutageElementGid); if (!outageModel.TopologyModel.OutageTopology.ContainsKey(nextBreaker)) { string message = $"Breaker (next breaker) with id: 0x{nextBreaker:X16} is not in topology"; Logger.LogError(message); throw new Exception(message); } long outageElement = outageModel.TopologyModel.OutageTopology[nextBreaker].FirstEnd; if (!outageModel.TopologyModel.OutageTopology[UpBreaker].SecondEnd.Contains(outageElement)) { string message = $"Outage element with gid: 0x{outageElement:X16} is not on a second end of current breaker id"; Logger.LogError(message); throw new Exception(message); } outageEntity.OptimumIsolationPoints = outageModel.GetEquipmentEntity(new List <long>() { UpBreaker, nextBreaker }); outageEntity.IsolatedTime = DateTime.UtcNow; outageEntity.OutageState = OutageState.ISOLATED; dbContext.OutageRepository.Update(outageEntity); SendSCADACommand(UpBreaker, DiscreteCommandingType.OPEN); SendSCADACommand(nextBreaker, DiscreteCommandingType.OPEN); } return(true); }
public bool ValidateResolveConditions(long outageId) { OutageEntity outageDbEntity = null; try { outageDbEntity = dbContext.OutageRepository.Get(outageId); } catch (Exception e) { string message = "OutageModel::SendRepairCrew => exception in UnitOfWork.ActiveOutageRepository.Get()"; Logger.LogError(message, e); throw e; } if (outageDbEntity == null) { Logger.LogError($"Outage with id 0x{outageId:X16} is not found in database."); return(false); } if (outageDbEntity.OutageState != OutageState.REPAIRED) { Logger.LogError($"Outage with id 0x{outageId:X16} is in state {outageDbEntity.OutageState}, and thus repair crew can not be sent. (Expected state: {OutageState.REPAIRED})"); return(false); } List <Equipment> isolationPoints = new List <Equipment>(); isolationPoints.AddRange(outageDbEntity.DefaultIsolationPoints); isolationPoints.AddRange(outageDbEntity.OptimumIsolationPoints); bool resolveCondition = true; foreach (Equipment isolationPoint in isolationPoints) { if (outageModel.TopologyModel.GetElementByGid(isolationPoint.EquipmentId, out IOutageTopologyElement element)) { if (element.NoReclosing != element.IsActive) { resolveCondition = false; break; } } } outageDbEntity.IsResolveConditionValidated = resolveCondition; dbContext.OutageRepository.Update(outageDbEntity); try { dbContext.Complete(); outageModel.PublishOutage(Topic.ACTIVE_OUTAGE, outageMessageMapper.MapOutageEntity(outageDbEntity)); } catch (Exception e) { string message = "OutageModel::ValidateResolveConditions => exception in Complete method."; Logger.LogError(message, e); } return(true); }
private async Task UpdateRecloserOutageMap(long recloserId, List <long> affectedConsumersGids, OutageEntity createdActiveOutage) { var enumerableRecloserOutageMap = await RecloserOutageMap.GetEnumerableDictionaryAsync(); if (enumerableRecloserOutageMap.TryGetValue(recloserId, out Dictionary <long, List <long> > outageToAffectedConsumersMap)) { if (outageToAffectedConsumersMap.ContainsKey(createdActiveOutage.OutageId)) { outageToAffectedConsumersMap[createdActiveOutage.OutageId] = new List <long>(affectedConsumersGids); } else { outageToAffectedConsumersMap.Add(createdActiveOutage.OutageId, affectedConsumersGids); } await RecloserOutageMap.SetAsync(recloserId, outageToAffectedConsumersMap); } else { var outageIdToAffectedConsumersMap = new Dictionary <long, List <long> >() { { createdActiveOutage.OutageId, affectedConsumersGids } }; await RecloserOutageMap.SetAsync(recloserId, outageIdToAffectedConsumersMap); } }
public Task <OutageEntity> AddOutage(OutageEntity outage) { return(InvokeWithRetryAsync(client => client.Channel.AddOutage(outage))); }