private AlertDefinition GetAlertDefinitionFromFileName(string fileName) { TextReader textReader = null; AlertDefinition alertDefinition = null; try { XmlSerializer serializer = new XmlSerializer(typeof(AlertDefinition)); textReader = new StreamReader(fileName); alertDefinition = (AlertDefinition)serializer.Deserialize(textReader); } catch (Exception ex) { MessageBox.Show("An error occurred whilst trying to load the alert definition : " + Environment.NewLine + Environment.NewLine + ex.Message, "AuditWizard", MessageBoxButtons.OK, MessageBoxIcon.Error); // JML TODO log this exception return(null); } finally { // close text writer textReader.Close(); } return(alertDefinition); }
private async Task UpdateAsync(AlertDefinition alertDefinition) { var dataObject = await(from a in _dbContext.AlertDefinitions.IncludeAllAlertCriteria() where a.AlertDefinitionId == alertDefinition.AlertDefinitionId select a).SingleAsync(); var criteria = dataObject.RootCriteria.Traverse(c => c.ChildrenCriteria); var alertCriteriaToDelete = from ac in criteria where !alertDefinition.ContainsAlertCriteriaId(ac.AlertCriteriaId) select ac; foreach (var ac in alertCriteriaToDelete) { if (_dbContext.Entry(ac) != null) { _dbContext.Entry(ac).State = EntityState.Deleted; } else { _dbContext.Remove(ac); } } _mapper.Map(alertDefinition, dataObject); _dbContext.Update(dataObject); await _dbContext.SaveChangesAsync(); _mapper.Map(dataObject, alertDefinition); }
private async Task <IEnumerable <AlertActionResult> > ProcessActionsAsync(AlertDefinition definition, Miner miner, AlertMetadata metadata, CancellationToken token) { var results = new List <AlertActionResult>(); if (!definition.Actions.Any()) { return(results); } _logger.LogInformation($"Processing actions for alert definition {definition.Id}"); foreach (var action in definition.Actions) { foreach (var actionExecutor in _alertActionExecutors.Where(t => t.ShouldExecute(action, miner))) { _logger.LogInformation($"Processing action {action.Name} for alert definition {definition.Id}"); try { results.Add(await actionExecutor.ExecuteActionAsync(action, definition, miner, metadata, token)); } catch (Exception ex) { _logger.LogError(ex, $"Error executing action ({action.Name}) for alert definition {definition.Id}"); results.Add(new AlertActionResult { State = AlertActionState.Error, ActionName = action.Name, Message = "Error executing action" }); } } } _logger.LogInformation($"Finished processing actions for alert definition {definition.Id}"); return(results); }
public override bool EndAlert(AlertDefinition definition, Miner miner, Alert alert, IEnumerable <Snapshot> snapshots, DateTime scanTime) { var snapshotsList = snapshots.ToList(); if (!snapshotsList.Any()) { return(false); } var parameters = (GpuThresholdAlertParameters)definition.Parameters; var conditionPeriods = ( from gpuCondition in snapshotsList.ToGpuConditions(stats => MapToCondition(stats, parameters)) from gpuConditionPeriod in gpuCondition.Periods where gpuConditionPeriod.GpuIndex == alert.Metadata?.GpuIndex orderby gpuConditionPeriod.Period.Start select gpuConditionPeriod).ToList(); var conditionPeriod = conditionPeriods.LastOrDefault(s => s.Condition == alert.Metadata?.Value?.Condition); if (conditionPeriod != null) { alert.Metadata = CreateMetadata(alert?.Metadata, parameters, conditionPeriod); alert.DetailMessages = CreateDetailMessages(alert?.Metadata, parameters); return(conditionPeriod.Period.HasEnd); } return(conditionPeriods.Any()); }
public Scan(AlertDefinition alertDefinition, Miner miner, IAlertScanner scanner, DateTime scanTime) { Definition = alertDefinition; _miner = miner; _scanner = scanner; _scanTime = scanTime; }
private async Task <Alert> CreateAlertAsync(AlertDefinition definition, Miner miner, HashrateAlertParameters parameters, IEnumerable <Snapshot> snapshots, CancellationToken token) { var metadata = CreateMetadata(null, parameters, snapshots); var detailMessages = CreateDetailMessages(metadata, parameters); return(await _alertFactory.CreateAlertAsync(definition, miner, metadata, "Hashrate too low", detailMessages, token)); }
private async Task <Alert> CreateAlertAsync(AlertDefinition definition, Miner miner, GpuThresholdAlertParameters parameters, GpuConditionPeriod conditionPeriod, CancellationToken token) { var metadata = CreateMetadata(null, parameters, conditionPeriod); var detailMessages = CreateDetailMessages(metadata, parameters); return(await _alertFactory.CreateAlertAsync(definition, miner, metadata, DefaultAlertMessage, detailMessages, token)); }
public virtual Period CalculateScanPeriod(AlertDefinition definition, DateTime scanTime) { var duration = definition.Parameters.DurationMinutes.MinutesToTimeSpan(); var paddedDuration = duration + duration; return(definition.NextScanPeriod(scanTime, paddedDuration)); }
public async Task <bool> UpdateAsync(AlertDefinition alertDefinition, CancellationToken token = default) { var current = await _alertDefinitionRepository.FindByIdAsync(alertDefinition.Id, token); if (current == null) { return(false); } alertDefinition.MinerId = current.MinerId; alertDefinition.Created = current.Created; alertDefinition.LastScan = current.LastScan; alertDefinition.Updated = DateTime.UtcNow; if (alertDefinition.Parameters.AlertType != current.Parameters.AlertType) { alertDefinition.Parameters = current.Parameters; } if (!current.Enabled && alertDefinition.Enabled) { alertDefinition.LastEnabled = DateTime.UtcNow; } else { alertDefinition.LastEnabled = current.LastEnabled; } return(await _alertDefinitionRepository.UpdateAsync(alertDefinition, token)); }
private bool PeakReached(AlertDefinition definition, int interval = 1) { var averageCPU = GetAverageCpu(interval); var averageRAM = GetAverageRam(interval); return(CpuOverPeak(definition.AvergareCPU, averageCPU) || RamOverPeak(definition.AvergareRAM, averageRAM)); }
public AlertDefinitionItemViewModel( AlertDefinition alertDefinition, INavigationService navigationService, ILogger logger) : base(navigationService, logger) { _alertDefinition = alertDefinition ?? throw new ArgumentNullException(nameof(alertDefinition)); }
private void AssertAlertDefinition(AlertDefinition expected, AlertDefinition actual) { actual.AlertDefinitionId.Should().Be(expected.AlertDefinitionId); actual.AppUser.AppUserId.Should().Be(expected.AppUser.AppUserId); actual.Stock.StockId.Should().Be(expected.Stock.StockId); AssertCriteria(expected.RootCriteria, actual.RootCriteria); }
public async Task DeleteAsync(AlertDefinition alertDefinition) { var dataObject = _mapper.Map <Data.Model.AlertDefinition>(alertDefinition); var childCriteria = dataObject.RootCriteria.Traverse(x => x.ChildrenCriteria); _dbContext.RemoveRange(childCriteria); _dbContext.AlertDefinitions.Remove(dataObject); await _dbContext.SaveChangesAsync(); }
public FormAlertMonitorWizard(AlertDefinition alertDefinition) { InitializeComponent(); _alertDefinition = alertDefinition; _editing = true; _originalName = alertDefinition.Name; wizardControl1.NextButtonEnabled = true; }
public async Task <AlertDefinition> SaveAlertDefinitionAsync(AlertDefinition alertDefinition) { if (alertDefinition.AlertDefinitionId == Guid.Empty) { return(await PostAsync($"{MiscConstants.StockAlertsApiBaseUri}alert-definitions", alertDefinition)); } return(await PutAsync($"{MiscConstants.StockAlertsApiBaseUri}alert-definitions/{alertDefinition.AlertDefinitionId}", alertDefinition)); }
private async Task InsertAsync(AlertDefinition alertDefinition) { var dataObject = _mapper.Map <Data.Model.AlertDefinition>(alertDefinition); await _dbContext.AlertDefinitions.AddAsync(dataObject); await _dbContext.SaveChangesAsync(); _mapper.Map(dataObject, alertDefinition); }
public override bool EndAlert(AlertDefinition definition, Miner miner, Alert alert, IEnumerable <Snapshot> snapshots, DateTime scanTime) { var snapshotsList = snapshots.ToList(); if (!snapshotsList.Any()) { return(false); } return(!ShouldAlert(definition, snapshotsList, scanTime)); }
public async Task SaveAsync(AlertDefinition alertDefinition) { if (alertDefinition.AlertDefinitionId == Guid.Empty) { await InsertAsync(alertDefinition); } else { await UpdateAsync(alertDefinition); } }
public async Task <ObjectResult> PostAsync([FromBody] AlertDefinition alertDefinition, CancellationToken token = default) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } await _alertDefinitionService.AddAsync(alertDefinition, token); return(Ok(alertDefinition)); }
public async Task AddAsync(AlertDefinition alertDefinition, CancellationToken token = default) { alertDefinition.Id = Guid.NewGuid(); alertDefinition.Created = DateTime.UtcNow; if (alertDefinition.Enabled) { alertDefinition.LastEnabled = DateTime.UtcNow; } await _alertDefinitionRepository.InsertAsync(alertDefinition, token); }
public FormAlertTrigger(AlertDefinition alertDefinition, AlertTrigger alertTrigger) { InitializeComponent(); _alertDefinition = alertDefinition; _alertTrigger = alertTrigger; // Seems as if some attributes simply do not get set for the embedded SelectAuditDataFieldsControl so set them here selectedFields.AllowExpandApplications = false; selectedFields.AllowInternetSelection = true; selectedFields.ReportSpecificItemsShow = false; selectedFields.NodeStyle = NodeStyle.Standard; }
private void InitNotificationManager() { var notificationProvider = new PushbulletNotificationProvider(Settings.Default.PushbulletApiKey); var definition = new AlertDefinition(notificationProvider); definition.AvergareCPU = Settings.Default.AlertAvergareCPU; definition.AvergareRAM = Settings.Default.AlertAvergareRAM; definition.MeasurementTime = Settings.Default.AlertMeasurementTime; _notificationManager = new NotificationManager(new[] { definition }, _processMonitor); }
public async Task <ObjectResult> PutAsync([FromBody] AlertDefinition alertDefinition, CancellationToken token = default) { if (!ModelState.IsValid) { return(BadRequest(ModelState)); } if (!await _alertDefinitionService.UpdateAsync(alertDefinition, token)) { return(NotFound(null)); } return(Ok(alertDefinition)); }
private Notification CreatePeakStartNotification(AlertDefinition definition) { var notification = new Notification(); var interval = definition.MeasurementTime; var body = DateTime.Now.ToString() + Environment.NewLine + "Average peak in the last " + interval + " min:" + Environment.NewLine + GetProcessNotificationLine(definition) + "CPU: " + GetAverageCpu(interval) + "%" + Environment.NewLine + "RAM: " + GetAverageRam(interval) + "%"; notification.Title = "Performance Monitor Alert from " + Environment.MachineName; notification.Body = body; return(notification); }
public void CpuPeakReachedTest() { var definitions = new List <AlertDefinition>(); NotificationManager manager = new NotificationManager(definitions, null); int current = 60, average1 = 59, average2 = current, average3 = 61; var eventT1 = new PerformanceState() { AverageCPU = current }; manager.Update(eventT1); var definition1 = new AlertDefinition(NotificationProviderMock.Object) { AvergareCPU = average1, AvergareRAM = 30, MeasurementTime = 10 }; var definition2 = new AlertDefinition(NotificationProviderMock.Object) { AvergareCPU = average2, AvergareRAM = 30, MeasurementTime = 10 }; var definition3 = new AlertDefinition(NotificationProviderMock.Object) { AvergareCPU = average3, AvergareRAM = 30, MeasurementTime = 10 }; PrivateObject obj = new PrivateObject(manager); var value1 = (bool)obj.Invoke("PeakReached", new object[] { definition1, 1 }); var value2 = (bool)obj.Invoke("PeakReached", new object[] { definition2, 1 }); var value3 = (bool)obj.Invoke("PeakReached", new object[] { definition3, 1 }); Assert.IsTrue(value1); Assert.IsFalse(value2); Assert.IsFalse(value3); }
public EditAlertDefinitionPageViewModel( IAlertDefinitionsService alertDefinitionsService, INavigationService navigationService, ILogger logger) : base(navigationService, logger) { _alertDefinitionsService = alertDefinitionsService ?? throw new ArgumentNullException(nameof(alertDefinitionsService)); _alertDefinition = new AlertDefinition { RootCriteria = new AlertCriteria { Type = CriteriaType.Composite, Operator = CriteriaOperator.And } }; Title = "Create Alert Definition"; }
public void NotifyTest() { var notificationProviderMock = new Mock <INotificationProvider>(); var definition = new AlertDefinition(notificationProviderMock.Object); definition.NotifyDeviceIds.AddRange(new[] { "1", "2", "3" }); var manager = new NotificationManager(new[] { definition }, null); notificationProviderMock.Setup(_ => _.Notify(It.IsAny <Notification>(), definition.NotifyDeviceIds)).Verifiable(); PrivateObject obj = new PrivateObject(manager); obj.Invoke("Notify", new object[] { new Notification(), definition }); notificationProviderMock.Verify(); }
public async Task <Alert> CreateAlertAsync(AlertDefinition definition, Miner miner, AlertMetadata metadata, string defaultMessage, IEnumerable <string> detailMessages, CancellationToken token) { var now = DateTime.UtcNow; return(new Alert { MinerId = definition.MinerId, AlertDefinitionId = definition.Id, Severity = definition.Severity ?? AlertSeverity.None, Message = definition.Parameters?.AlertMessage ?? defaultMessage, DetailMessages = detailMessages, Metadata = metadata, Start = now, LastActive = now, ActionResults = await ProcessActionsAsync(definition, miner, metadata, token) }); }
public async Task <IActionResult> PostAsync([FromBody] AlertDefinition requestBody) { if (requestBody.AlertDefinitionId != Guid.Empty) { throw new BadRequestException("AlertDefinitionId must be empty on a POST."); } var alertDefinition = _mapper.Map <Domain.Model.AlertDefinition>(requestBody); alertDefinition.AppUserId = HttpContext.User.GetAppUserIdClaim(); await alertDefinition.SaveAsync(); alertDefinition = await _alertDefinitionsService.GetAlertDefinitionAsync(alertDefinition.AlertDefinitionId); var resource = _mapper.Map <AlertDefinition>(alertDefinition); return(new OkObjectResult(resource)); }
public void CreateSpecification_AlertDefinitionWithMultipleCriteria_SpecificationCreated() { // Arrange var factory = new AlertCriteriaSpecificationFactory(); var alertDefinitionsRepositoryMock = new Mock <IAlertDefinitionsRepository>(); var notificationServiceMock = new Mock <INotificationsService>(); var rootCriteriaId = Guid.NewGuid(); var alertDefinition = new AlertDefinition(alertDefinitionsRepositoryMock.Object, factory, notificationServiceMock.Object) { RootCriteria = new AlertCriteria { Type = CriteriaType.Composite, Operator = CriteriaOperator.And, ChildrenCriteria = new List <AlertCriteria> { new AlertCriteria { Type = CriteriaType.Price, Operator = CriteriaOperator.LessThanOrEqualTo, Level = 50 }, new AlertCriteria { Type = CriteriaType.DailyPercentageGainLoss, Operator = CriteriaOperator.LessThanOrEqualTo, Level = -0.02M } } } }; // Act var specification = factory.CreateSpecification(alertDefinition); // Assert specification.Should().BeOfType <AndSpecification <AlertEvaluationMessage> >(); var children = (specification as CompositeSpecification <AlertEvaluationMessage>).Children; children.Count.Should().Be(2); children.First().Should().BeOfType <PriceSpecification>(); children.Last().Should().BeOfType <DailyPercentageGainLossSpecification>(); }