public ActionResult UpdateAlert(int id)
{
var settings = AlertSettingsService.GetSettings();
var selected = settings.AlertRules.FirstOrDefault(x => x.Id == id);
var vm = new AlertRules();
if (selected != null)
{
vm = Mapper.Map <AlertRules>(selected);
}
switch (vm.AlertType)
{
case AlertType.Cpu:
return(PartialView("CpuAlertModal", vm));
case AlertType.Network:
vm = LoadNetwork(vm);
return(PartialView("NetworkAlertModal", vm));
case AlertType.Hdd:
vm = LoadHdd(vm);
return(PartialView("DriveAlertModal", vm));
default:
return(View("Error"));
}
}
public void Include(EntityData otherData)
{
Alerts.AddRange(otherData.Alerts);
EmailAlertRecipients.AddRange(otherData.EmailAlertRecipients);
SmsAlertRecipients.AddRange(otherData.SmsAlertRecipients);
AlertReports.AddRange(otherData.AlertReports);
AlertRules.AddRange(otherData.AlertRules);
ApplicationLanguages.AddRange(otherData.ApplicationLanguages);
ContentLanguages.AddRange(otherData.ContentLanguages);
Countries.AddRange(otherData.Countries);
DataCollectors.AddRange(otherData.DataCollectors);
Districts.AddRange(otherData.Districts);
GatewaySettings.AddRange(otherData.GatewaySettings);
HeadManagerConsents.AddRange(otherData.HeadManagerConsents);
HealthRisks.AddRange(otherData.HealthRisks);
HealthRiskLanguageContents.AddRange(otherData.HealthRiskLanguageContents);
Localizations.AddRange(otherData.Localizations);
LocalizedTemplates.AddRange(otherData.LocalizedTemplates);
NationalSocieties.AddRange(otherData.NationalSocieties);
Notifications.AddRange(otherData.Notifications);
Projects.AddRange(otherData.Projects);
SupervisorUserProjects.AddRange(otherData.SupervisorUserProjects);
ProjectHealthRisks.AddRange(otherData.ProjectHealthRisks);
RawReports.AddRange(otherData.RawReports);
Regions.AddRange(otherData.Regions);
Reports.AddRange(otherData.Reports);
Users.AddRange(otherData.Users);
UserNationalSocieties.AddRange(otherData.UserNationalSocieties);
Villages.AddRange(otherData.Villages);
Zones.AddRange(otherData.Zones);
}
private AlertRules LoadNetwork(AlertRules rule)
{
var nics = HardwareService.GetAllNics();
rule.NicDict = new Dictionary <string, int>();
foreach (var nic in nics)
{
rule.NicDict.Add(nic.Key, nic.Value);
}
rule.Nics = new SelectList(rule.NicDict, "Value", "Key", 0);
return(rule);
}
private AlertRules LoadHdd(AlertRules rule)
{
var drives = HardwareService.GetDrives();
rule.Drives = new List <DriveAlertViewModel>();
foreach (var drive in drives.Where(drive => drive.IsReady))
{
var d = new DriveAlertViewModel {
DriveId = drive.DriveId, DriveVolumeLabel = drive.Name
};
rule.Drives.Add(d);
}
return(rule);
}
public void UpdateExistingHddAlertPost()
{
ExpectedDto.AlertRules[0].AlertType = AlertTypeDto.Hdd;
Settings.Setup(x => x.GetSettings()).Returns(ExpectedDto);
Settings.Setup(x => x.SaveSettings(It.IsAny <AlertSettingsDto>())).Returns(true).Verifiable();
CreateController();
var model = new AlertRules {
Id = ExpectedDto.AlertRules[0].Id, ThresholdTime = 90, Percentage = 99999, Enabled = true, AlertType = AlertType.Hdd, NicId = 22
};
_controller.UpdateAlert(model);
Settings.Verify(x => x.SaveSettings(It.Is <AlertSettingsDto>(c => c.AlertRules.Any(y => y.Percentage == 99999))), Times.Once);
Settings.Verify(x => x.SaveSettings(It.Is <AlertSettingsDto>(c => c.AlertRules.Any(y => y.AlertType == AlertTypeDto.Hdd))), Times.Once);
Settings.Verify(x => x.SaveSettings(It.Is <AlertSettingsDto>(c => c.AlertRules.Any(y => y.ThresholdTime == 90))), Times.Once);
Settings.Verify(x => x.SaveSettings(It.Is <AlertSettingsDto>(c => c.AlertRules.Any(y => y.NicId == 22))), Times.Once);
Settings.Verify(x => x.SaveSettings(It.Is <AlertSettingsDto>(c => c.AlertRules.Any(y => y.Enabled))), Times.Once);
}
public INyssContext GetNyssContextMock()
{
var nyssContextMock = Substitute.For <INyssContext>();
var nationalSocietiesDbSet = NationalSocieties.AsQueryable().BuildMockDbSet();
var healthRisksDbSet = HealthRisks.AsQueryable().BuildMockDbSet();
var alertRulesDbSet = AlertRules.AsQueryable().BuildMockDbSet();
var projectsDbSet = Projects.AsQueryable().BuildMockDbSet();
var projectHealthRisksDbSet = ProjectHealthRisks.AsQueryable().BuildMockDbSet();
var dataCollectorsDbSet = DataCollectors.AsQueryable().BuildMockDbSet();
var reportsDbSet = Reports.AsQueryable().BuildMockDbSet();
var rawReportsDbSet = RawReports.AsQueryable().BuildMockDbSet();
var usersDbSet = Users.AsQueryable().BuildMockDbSet();
var supervisorUserProjectsDbSet = SupervisorUserProjects.AsQueryable().BuildMockDbSet();
var userNationalSocietiesDbSet = UserNationalSocieties.AsQueryable().BuildMockDbSet();
var regionsDbSet = Regions.AsQueryable().BuildMockDbSet();
var districtsDbSet = Districts.AsQueryable().BuildMockDbSet();
var villagesDbSet = Villages.AsQueryable().BuildMockDbSet();
var zonesDbSet = Zones.AsQueryable().BuildMockDbSet();
var alertsDbSet = Alerts.AsQueryable().BuildMockDbSet();
nyssContextMock.NationalSocieties.Returns(nationalSocietiesDbSet);
nyssContextMock.HealthRisks.Returns(healthRisksDbSet);
nyssContextMock.AlertRules.Returns(alertRulesDbSet);
nyssContextMock.Projects.Returns(projectsDbSet);
nyssContextMock.ProjectHealthRisks.Returns(projectHealthRisksDbSet);
nyssContextMock.DataCollectors.Returns(dataCollectorsDbSet);
nyssContextMock.Reports.Returns(reportsDbSet);
nyssContextMock.RawReports.Returns(rawReportsDbSet);
nyssContextMock.Users.Returns(usersDbSet);
nyssContextMock.SupervisorUserProjects.Returns(supervisorUserProjectsDbSet);
nyssContextMock.UserNationalSocieties.Returns(userNationalSocietiesDbSet);
nyssContextMock.Regions.Returns(regionsDbSet);
nyssContextMock.Districts.Returns(districtsDbSet);
nyssContextMock.Villages.Returns(villagesDbSet);
nyssContextMock.Zones.Returns(zonesDbSet);
nyssContextMock.Alerts.Returns(alertsDbSet);
return(nyssContextMock);
}
public void UpdateAlertPostInvalidModel()
{
ExpectedDto.AlertRules[0].AlertType = AlertTypeDto.Cpu;
Settings.Setup(x => x.GetSettings()).Returns(ExpectedDto);
Settings.Setup(x => x.SaveSettings(It.IsAny <AlertSettingsDto>())).Returns(true).Verifiable();
CreateController();
var model = new AlertRules {
Id = int.MaxValue, Enabled = true, AlertType = AlertType.Cpu,
};
var result = (PartialViewResult)_controller.UpdateAlert(model);
var resultModel = (AlertRules)result.Model;
Assert.That(resultModel.Errors.ContainsKey(AlertRules.PercentageErrorKey), Is.True);
Assert.That(resultModel.Errors.ContainsKey(AlertRules.ThresholdErrorKey), Is.True);
Settings.Verify(x => x.SaveSettings(It.IsAny <AlertSettingsDto>()), Times.Never);
Settings.Verify(x => x.GetSettings(), Times.Never);
Settings.Verify(x => x.Delete(It.IsAny <AlertSettingsDto>()), Times.Never);
}
public ActionResult OpenModal(AlertType alertType)
{
var model = new AlertRules {
AlertType = alertType
};
var settings = AlertSettingsService.GetSettings();
switch (model.AlertType)
{
case AlertType.Cpu:
if (settings.AlertRules.Any(x => x.AlertType == AlertTypeDto.Cpu))
{
return(PartialView("AlertExistsModal", model.AlertType));
}
return(PartialView("CpuAlertModal", model));
case AlertType.Network:
model = LoadNetwork(model);
return(PartialView("NetworkAlertModal", model));
case AlertType.Hdd:
if (settings.AlertRules.Any(x => x.AlertType == AlertTypeDto.Hdd))
{
return(PartialView("AlertExistsModal", model.AlertType));
}
model = LoadHdd(model);
return(PartialView("DriveAlertModal", model));
default:
Logger.Fatal("ArgumentOutOfRangeException on AlertType: {0}", model.AlertType);
throw new ArgumentOutOfRangeException();
}
}
public ActionResult UpdateAlert(AlertRules model)
{
if (!model.IsValid)
{
switch (model.AlertType)
{
case AlertType.Cpu:
return(PartialView("CpuAlertModal", model));
case AlertType.Network:
model = LoadNetwork(model);
return(PartialView("NetworkAlertModal", model));
case AlertType.Hdd:
model = LoadHdd(model);
return(PartialView("DriveAlertModal", model));
default:
Logger.Fatal("ArgumentOutOfRangeException on AlertType: {0}", model.AlertType);
throw new ArgumentOutOfRangeException();
}
}
var currentSettings = AlertSettingsService.GetSettings();
var maxRecord = 1;
if (currentSettings.AlertRules.Count > 0)
{
maxRecord = currentSettings.AlertRules.Max(x => x.Id);
}
var match = currentSettings.AlertRules.FirstOrDefault(x => x.Id == model.Id);
if (match == null)
{
// We don't yet have any rules so create one
var dtoRule = Mapper.Map <AlertRules, AlertRulesDto>(model);
dtoRule.Id = ++maxRecord;
currentSettings.AlertRules.Add(dtoRule);
Logger.Trace("Saving new rule with id {0}", dtoRule.Id);
var result = AlertSettingsService.SaveSettings(currentSettings);
if (result)
{
return(Json(new { Result = "True" }, JsonRequestBehavior.AllowGet));
}
}
else
{
// We have rules already so let's modify the existing rules, remove the existing and add the new
var dtoModel = new AlertRulesDto();
dtoModel = Mapper.Map <AlertRulesDto>(model);
currentSettings.AlertRules.Remove(match);
currentSettings.AlertRules.Add(dtoModel);
var result = AlertSettingsService.SaveSettings(currentSettings);
if (result)
{
return(Json(new { Result = "True" }, JsonRequestBehavior.AllowGet));
}
}
return(View("Error"));
}
