/// <summary>
/// Provides a database Vulnerability Assessment settings model for the given database
/// </summary>
public DatabaseVulnerabilityAssessmentSettingsModel GetDatabaseVulnerabilityAssessmentSettings(string resourceGroup, string serverName,
string databaseName)
{
var vulnerabilityAssessmentSettings = VulnerabilityAssessmentCommunicator.GetDatabaseVulnerabilityAssessmentSettings(resourceGroup, serverName, databaseName);
return(ConvertSettingsToModel(resourceGroup, serverName, databaseName, vulnerabilityAssessmentSettings));
}
/// <summary>
/// Provides a database Vulnerability Assessment Rule Baseline model for the given database
/// </summary>
public DatabaseVulnerabilityAssessmentRuleBaselineModel GetDatabaseVulnerabilityAssessmentRuleBaseline(string resourceGroup, string serverName,
string databaseName, string ruleId, bool ruleAppliesToMaster)
{
var vulnerabilityAssessmentRuleBaseline = VulnerabilityAssessmentCommunicator.GetDatabaseVulnerabilityAssessmentRuleBaseline(resourceGroup,
serverName, databaseName, ruleId, ruleAppliesToMaster);
var ruleBaselineModel = new DatabaseVulnerabilityAssessmentRuleBaselineModel()
{
ResourceGroupName = resourceGroup,
ServerName = serverName,
DatabaseName = databaseName,
RuleId = ruleId,
RuleAppliesToMaster = ruleAppliesToMaster
};
ruleBaselineModel.BaselineResult = new List <DatabaseVulnerabilityAssessmentRuleBaselineRowModel>();
foreach (var baselineResult in vulnerabilityAssessmentRuleBaseline.BaselineResults)
{
var ruleBaselineItem = new DatabaseVulnerabilityAssessmentRuleBaselineRowModel()
{
Result = baselineResult.Result
};
ruleBaselineModel.BaselineResult.Add(ruleBaselineItem);
}
return(ruleBaselineModel);
}
/// <summary>
/// Transforms the given model to its endpoints acceptable structure and sends it to the endpoint
/// </summary>
public void SetVulnerabilityAssessmentRuleBaseline(VulnerabilityAssessmentRuleBaselineModel model, string serverName, string databaseName, ApplyToType applyToType)
{
var ruleBaseline = new DatabaseVulnerabilityAssessmentRuleBaseline()
{
BaselineResults = new List <DatabaseVulnerabilityAssessmentRuleBaselineItem>()
};
foreach (var baselineResult in model.BaselineResult)
{
var ruleBaselineItem = new DatabaseVulnerabilityAssessmentRuleBaselineItem()
{
Result = baselineResult.Result
};
ruleBaseline.BaselineResults.Add(ruleBaselineItem);
}
if (applyToType == ApplyToType.Database)
{
VulnerabilityAssessmentCommunicator.SetDatabaseVulnerabilityAssessmentRuleBaseline(model.ResourceGroupName, serverName,
databaseName, model.RuleId, model.RuleAppliesToMaster, ruleBaseline);
}
else
{
VulnerabilityAssessmentCommunicator.SetManagedDatabaseVulnerabilityAssessmentRuleBaseline(model.ResourceGroupName, serverName,
databaseName, model.RuleId, model.RuleAppliesToMaster, ruleBaseline);
}
}
/// <summary>
/// Set settings with storage access key
/// </summary>
public VulnerabilityAssessmentSettingsModel SetVulnerabilityAssessmentSettingsWithStorageAccessKey(VulnerabilityAssessmentSettingsModel model, string serverName, string databaseName, ApplyToType applyToType)
{
var resourceGroupName = AzureCommunicator.GetStorageResourceGroup(model.StorageAccountName);
var storageContainerInfo = VulnerabilityAssessmentCommunicator.GetStorageContainerInfo(resourceGroupName, model.StorageAccountName,
model.ScanResultsContainerName);
DatabaseVulnerabilityAssessment settings = new DatabaseVulnerabilityAssessment
{
StorageContainerPath = storageContainerInfo.StorageContainerPath,
StorageAccountAccessKey = storageContainerInfo.StorageAccountAccessKey,
RecurringScans = new VulnerabilityAssessmentRecurringScansProperties()
{
IsEnabled = model.RecurringScansInterval != RecurringScansInterval.None,
EmailSubscriptionAdmins = model.EmailAdmins,
Emails = model.NotificationEmail
}
};
var vulnerabilityAssessmentSettings = (applyToType == ApplyToType.Database) ?
VulnerabilityAssessmentCommunicator.SetDatabaseVulnerabilityAssessmentSettings(model.ResourceGroupName, serverName, databaseName, settings) :
VulnerabilityAssessmentCommunicator.SetManagedDatabaseVulnerabilityAssessmentSettings(model.ResourceGroupName, serverName, databaseName, settings);
return(ConvertSettingsToModel(model.ResourceGroupName, serverName, databaseName, vulnerabilityAssessmentSettings));
}
/// <summary>
/// Transforms the given model to its endpoints acceptable structure and sends it to the endpoint
/// </summary>
public void SetVulnerabilityAssessmentRuleBaseline(VulnerabilityAssessmentRuleBaselineModel model, string workspaceName, string sqlPoolName, ApplyToType applyToType)
{
var ruleBaseline = new SqlPoolVulnerabilityAssessmentRuleBaseline()
{
BaselineResults = new List <SqlPoolVulnerabilityAssessmentRuleBaselineItem>()
};
foreach (var baselineResult in model.BaselineResult)
{
var ruleBaselineItem = new SqlPoolVulnerabilityAssessmentRuleBaselineItem()
{
Result = baselineResult.Result
};
ruleBaseline.BaselineResults.Add(ruleBaselineItem);
}
if (applyToType == ApplyToType.SqlPool)
{
VulnerabilityAssessmentCommunicator.SetSqlPoolVulnerabilityAssessmentRuleBaseline(model.ResourceGroupName, workspaceName,
sqlPoolName, model.RuleId, model.RuleAppliesToMaster, ruleBaseline);
}
else
{
throw new NotSupportedException(Resources.VulnerabilityAssessmentTypeNotSupported);
}
}
/// <summary>
/// Provides a database Vulnerability Assessment Rule Baseline model for the given database
/// </summary>
public VulnerabilityAssessmentRuleBaselineModel GetVulnerabilityAssessmentRuleBaseline(string resourceGroup, string serverName,
string databaseName, string ruleId, bool ruleAppliesToMaster, ApplyToType applyToType)
{
var vulnerabilityAssessmentRuleBaseline = (applyToType == ApplyToType.Database)
? VulnerabilityAssessmentCommunicator.GetDatabaseVulnerabilityAssessmentRuleBaseline(resourceGroup, serverName, databaseName, ruleId, ruleAppliesToMaster)
: VulnerabilityAssessmentCommunicator.GetManagedDatabaseVulnerabilityAssessmentRuleBaseline(resourceGroup, serverName, databaseName, ruleId, ruleAppliesToMaster);
var ruleBaselineModel = new VulnerabilityAssessmentRuleBaselineModel()
{
ResourceGroupName = resourceGroup,
RuleId = ruleId,
RuleAppliesToMaster = ruleAppliesToMaster
};
ruleBaselineModel.BaselineResult = new List <VulnerabilityAssessmentRuleBaselineRowModel>();
foreach (var baselineResult in vulnerabilityAssessmentRuleBaseline.BaselineResults)
{
var ruleBaselineItem = new VulnerabilityAssessmentRuleBaselineRowModel()
{
Result = baselineResult.Result
};
ruleBaselineModel.BaselineResult.Add(ruleBaselineItem);
}
return(ruleBaselineModel);
}
/// <summary>
/// Provides a SQL pool Vulnerability Assessment Rule Baseline model for the given SQL pool
/// </summary>
public VulnerabilityAssessmentRuleBaselineModel GetVulnerabilityAssessmentRuleBaseline(string resourceGroup, string workspaceName,
string sqlPoolName, string ruleId, bool ruleAppliesToMaster, ApplyToType applyToType)
{
var vulnerabilityAssessmentRuleBaseline = (applyToType == ApplyToType.SqlPool)
? VulnerabilityAssessmentCommunicator.GetSqlPoolVulnerabilityAssessmentRuleBaseline(resourceGroup, workspaceName, sqlPoolName, ruleId, ruleAppliesToMaster)
: throw new NotSupportedException(Resources.VulnerabilityAssessmentTypeNotSupported);
var ruleBaselineModel = new VulnerabilityAssessmentRuleBaselineModel()
{
ResourceGroupName = resourceGroup,
RuleId = ruleId,
RuleAppliesToMaster = ruleAppliesToMaster || sqlPoolName == "master"
};
ruleBaselineModel.BaselineResult = new List <VulnerabilityAssessmentRuleBaselineRowModel>();
foreach (var baselineResult in vulnerabilityAssessmentRuleBaseline.BaselineResults)
{
var ruleBaselineItem = new VulnerabilityAssessmentRuleBaselineRowModel()
{
Result = baselineResult.Result
};
ruleBaselineModel.BaselineResult.Add(ruleBaselineItem);
}
return(ruleBaselineModel);
}
/// <summary>
/// Provides a Vulnerability Assessment settings model for the given database
/// </summary>
public VulnerabilityAssessmentSettingsModel GetVulnerabilityAssessmentSettings(string resourceGroup, string serverName, string databaseName, ApplyToType applyToType)
{
var vulnerabilityAssessmentSettings = (applyToType == ApplyToType.Database) ?
VulnerabilityAssessmentCommunicator.GetDatabaseVulnerabilityAssessmentSettings(resourceGroup, serverName, databaseName) :
VulnerabilityAssessmentCommunicator.GetManagedDatabaseVulnerabilityAssessmentSettings(resourceGroup, serverName, databaseName);
return(ConvertSettingsToModel(resourceGroup, serverName, databaseName, vulnerabilityAssessmentSettings));
}
/// <summary>
/// List the Vulnerability Assessment scan records
/// </summary>
public List <VulnerabilityAssessmentScanRecordModel> ListVulnerabilityAssessmentScanRecords(string resourceGroup, string serverName,
string databaseName, ApplyToType applyToType)
{
return((applyToType == ApplyToType.Database)
? VulnerabilityAssessmentCommunicator.ListDatabaseVulnerabilityAssessmentScanRecords(resourceGroup, serverName, databaseName)
.Select(scanRecord => ConvertVulnerabilityAssessmentScanRecord(resourceGroup, scanRecord)).ToList()
: VulnerabilityAssessmentCommunicator.ListManagedDatabaseVulnerabilityAssessmentScanRecords(resourceGroup, serverName, databaseName)
.Select(scanRecord => ConvertVulnerabilityAssessmentScanRecord(resourceGroup, scanRecord)).ToList());
}
/// <summary>
/// Get a the Vulnerability Assessment scan record
/// </summary>
public VulnerabilityAssessmentScanRecordModel GetVulnerabilityAssessmentScanRecord(string resourceGroup, string serverName, string databaseName, string scanId, ApplyToType applyToType)
{
VulnerabilityAssessmentScanRecordModel model = (applyToType == ApplyToType.Database)
? ConvertVulnerabilityAssessmentScanRecord(resourceGroup,
VulnerabilityAssessmentCommunicator.GetDatabaseVulnerabilityAssessmentScanRecord(resourceGroup, serverName, databaseName, scanId))
: ConvertVulnerabilityAssessmentScanRecord(resourceGroup,
VulnerabilityAssessmentCommunicator.GetManagedDatabaseVulnerabilityAssessmentScanRecord(resourceGroup, serverName, databaseName, scanId));
return(model);
}
/// <summary>
/// Remove the Vulnerability Assessment Rule Baseline
/// </summary>
public void ClearVulnerabilityAssessmentRuleBaseline(VulnerabilityAssessmentRuleBaselineModel model, string serverName, string databaseName, ApplyToType applyToType)
{
if (applyToType == ApplyToType.Database)
{
VulnerabilityAssessmentCommunicator.ClearDatabaseVulnerabilityAssessmentRuleBaseline(model.ResourceGroupName, serverName, databaseName, model.RuleId, model.RuleAppliesToMaster);
}
else
{
VulnerabilityAssessmentCommunicator.ClearManagedDatabaseVulnerabilityAssessmentRuleBaseline(model.ResourceGroupName, serverName, databaseName, model.RuleId, model.RuleAppliesToMaster);
}
}
/// <summary>
/// Run a new Vulnerability Assessment scan
/// </summary>
public void StartVulnerabilityAssessmentScan(string resourceGroup, string serverName, string databaseName, string scanId, ApplyToType applyToType)
{
if (applyToType == ApplyToType.Database)
{
VulnerabilityAssessmentCommunicator.TriggerDatabaseVulnerabilityAssessmentScan(resourceGroup, serverName, databaseName, scanId);
}
else
{
VulnerabilityAssessmentCommunicator.TriggerManagedDatabaseVulnerabilityAssessmentScan(resourceGroup, serverName, databaseName, scanId);
}
}
/// <summary>
/// Remove the Vulnerability Assessment Rule Baseline
/// </summary>
public void ClearVulnerabilityAssessmentRuleBaseline(VulnerabilityAssessmentRuleBaselineModel model, string workspaceName, string sqlPoolName, ApplyToType applyToType)
{
if (applyToType == ApplyToType.SqlPool)
{
VulnerabilityAssessmentCommunicator.ClearSqlPoolVulnerabilityAssessmentRuleBaseline(model.ResourceGroupName, workspaceName, sqlPoolName, model.RuleId, model.RuleAppliesToMaster);
}
else
{
throw new NotSupportedException(Resources.VulnerabilityAssessmentTypeNotSupported);
}
}
/// <summary>
/// Remove the Vulnerability Assessment
/// </summary>
public void ClearVulnerabilityAssessmentSettings(VulnerabilityAssessmentSettingsModel model, string serverName, string databaseName, ApplyToType applyToType)
{
if (applyToType == ApplyToType.Database)
{
VulnerabilityAssessmentCommunicator.ClearDatabaseVulnerabilityAssessmentSettings(model.ResourceGroupName, serverName, databaseName);
}
else
{
VulnerabilityAssessmentCommunicator.ClearManagedDatabaseVulnerabilityAssessmentSettings(model.ResourceGroupName, serverName, databaseName);
}
}
/// <summary>
/// Convert a the Vulnerability Assessment scan
/// </summary>
public VulnerabilityAssessmentScanExportModel ConvertVulnerabilityAssessmentScan(string resourceGroup, string serverName, string databaseName, string scanId, ApplyToType applyToType)
{
var vulnerabilityAssessmentExportResponse = (applyToType == ApplyToType.Database)
? VulnerabilityAssessmentCommunicator.ConvertDatabaseVulnerabilityAssessmentScan(resourceGroup, serverName, databaseName, scanId)
: VulnerabilityAssessmentCommunicator.ConvertManagedDatabaseVulnerabilityAssessmentScan(resourceGroup, serverName, databaseName, scanId);
return(new VulnerabilityAssessmentScanExportModel()
{
ResourceGroupName = resourceGroup,
ExportedReportLocation = vulnerabilityAssessmentExportResponse.ExportedReportLocation,
ScanId = scanId
});
}
/// <summary>
/// Convert a the Vulnerability Assessment scan
/// </summary>
public DatabaseVulnerabilityAssessmentScanExportModel ConvertDatabaseVulnerabilityAssessmentScan(string resourceGroup, string serverName,
string databaseName, string scanId)
{
var vulnerabilityAssessmentExportResponse = VulnerabilityAssessmentCommunicator.ConvertDatabaseVulnerabilityAssessmentScan(resourceGroup,
serverName, databaseName, scanId);
return(new DatabaseVulnerabilityAssessmentScanExportModel()
{
ResourceGroupName = resourceGroup,
ServerName = serverName,
DatabaseName = databaseName,
ExportedReportLocation = vulnerabilityAssessmentExportResponse.ExportedReportLocation,
ScanId = scanId
});
}
/// <summary>
/// Transforms the given model to its endpoints acceptable structure and sends it to the endpoint
/// </summary>
public void SetDatabaseVulnerabilityAssessmentRuleBaseline(DatabaseVulnerabilityAssessmentRuleBaselineModel model)
{
var ruleBaseline = new DatabaseVulnerabilityAssessmentRuleBaseline()
{
BaselineResults = new List <DatabaseVulnerabilityAssessmentRuleBaselineItem>()
};
foreach (var baselineResult in model.BaselineResult)
{
var ruleBaselineItem = new DatabaseVulnerabilityAssessmentRuleBaselineItem()
{
Result = baselineResult.Result
};
ruleBaseline.BaselineResults.Add(ruleBaselineItem);
}
VulnerabilityAssessmentCommunicator.SetDatabaseVulnerabilityAssessmentRuleBaseline(model.ResourceGroupName, model.ServerName,
model.DatabaseName, model.RuleId, model.RuleAppliesToMaster, ruleBaseline);
}
/// <summary>
/// Transforms the given model to its endpoints acceptable structure and sends it to the endpoint
/// </summary>
public DatabaseVulnerabilityAssessmentSettingsModel SetDatabaseVulnerabilityAssessmentSettings(DatabaseVulnerabilityAssessmentSettingsModel model, string storageContainerPath,
string storageAccountSasKey)
{
DatabaseVulnerabilityAssessment settings = new DatabaseVulnerabilityAssessment
{
StorageContainerPath = storageContainerPath,
StorageContainerSasKey = storageAccountSasKey,
RecurringScans = new VulnerabilityAssessmentRecurringScansProperties()
{
IsEnabled = model.RecurringScansInterval != RecurringScansInterval.None,
EmailSubscriptionAdmins = model.EmailAdmins,
Emails = model.NotificationEmail
}
};
var vulnerabilityAssessmentSettings = VulnerabilityAssessmentCommunicator.SetDatabaseVulnerabilityAssessmentSettings(model.ResourceGroupName,
model.ServerName, model.DatabaseName, settings);
return(ConvertSettingsToModel(model.ResourceGroupName, model.ServerName, model.DatabaseName, vulnerabilityAssessmentSettings));
}
/// <summary>
/// Remove the Vulnerability Assessment
/// </summary>
public void ClearVulnerabilityAssessmentSettings(VulnerabilityAssessmentSettingsModel model, string serverName, string databaseName, ApplyToType applyToType)
{
switch (applyToType)
{
case ApplyToType.Database:
VulnerabilityAssessmentCommunicator.ClearDatabaseVulnerabilityAssessmentSettings(model.ResourceGroupName, serverName, databaseName);
break;
case ApplyToType.ManagedDatabase:
VulnerabilityAssessmentCommunicator.ClearManagedDatabaseVulnerabilityAssessmentSettings(model.ResourceGroupName, serverName, databaseName);
break;
case ApplyToType.Server:
VulnerabilityAssessmentCommunicator.ClearServerVulnerabilityAssessmentSettings(model.ResourceGroupName, serverName);
break;
case ApplyToType.ManagedInstance:
VulnerabilityAssessmentCommunicator.ClearManagedInstanceVulnerabilityAssessmentSettings(model.ResourceGroupName, serverName);
break;
default:
throw new ArgumentOutOfRangeException(nameof(applyToType), applyToType, null);
}
}
/// <summary>
/// Provides a Vulnerability Assessment settings model for the given database
/// </summary>
public VulnerabilityAssessmentSettingsModel GetVulnerabilityAssessmentSettings(string resourceGroup, string serverName, string databaseName, ApplyToType applyToType)
{
switch (applyToType)
{
case ApplyToType.Database:
var vaDbSettings = VulnerabilityAssessmentCommunicator.GetDatabaseVulnerabilityAssessmentSettings(resourceGroup, serverName, databaseName);
return(ConvertSettingsToModel(resourceGroup, vaDbSettings.RecurringScans, vaDbSettings.StorageContainerPath));
case ApplyToType.ManagedDatabase:
var vaManagedDbSettings = VulnerabilityAssessmentCommunicator.GetManagedDatabaseVulnerabilityAssessmentSettings(resourceGroup, serverName, databaseName);
return(ConvertSettingsToModel(resourceGroup, vaManagedDbSettings.RecurringScans, vaManagedDbSettings.StorageContainerPath));
case ApplyToType.Server:
var vaServerSettings = VulnerabilityAssessmentCommunicator.GetServerVulnerabilityAssessmentSettings(resourceGroup, serverName);
return(ConvertSettingsToModel(resourceGroup, vaServerSettings.RecurringScans, vaServerSettings.StorageContainerPath));
case ApplyToType.ManagedInstance:
var vaManagedInstanceSettings = VulnerabilityAssessmentCommunicator.GetManagedInstanceVulnerabilityAssessmentSettings(resourceGroup, serverName);
return(ConvertSettingsToModel(resourceGroup, vaManagedInstanceSettings.RecurringScans, vaManagedInstanceSettings.StorageContainerPath));
default:
throw new Exception(Properties.Resources.VulnerabilityAssessmentTypeNotSupported);
}
}
/// <summary>
/// List the Vulnerability Assessment scan records
/// </summary>
public List <DatabaseVulnerabilityAssessmentScanRecordModel> ListDatabaseVulnerabilityAssessmentScanRecords(string resourceGroup, string serverName,
string databaseName)
{
return(VulnerabilityAssessmentCommunicator.ListDatabaseVulnerabilityAssessmentScanRecords(resourceGroup, serverName, databaseName)
.Select(scanRecord => ConvertDatabaseVulnerabilityAssessmentScanRecord(resourceGroup, serverName, databaseName, scanRecord)).ToList());
}
/// <summary>
/// Set settings with storage SAS key
/// </summary>
public VulnerabilityAssessmentSettingsModel SetVulnerabilityAssessmentSettingsWithStorageSasKey(VulnerabilityAssessmentSettingsModel model, string storageContainerPath,
string storageAccountSasKey, string serverName, string databaseName, ApplyToType applyToType)
{
switch (applyToType)
{
case ApplyToType.Database:
DatabaseVulnerabilityAssessment vaDbSettings = new DatabaseVulnerabilityAssessment
{
StorageContainerPath = storageContainerPath,
StorageContainerSasKey = storageAccountSasKey,
RecurringScans = new VulnerabilityAssessmentRecurringScansProperties()
{
IsEnabled = model.RecurringScansInterval != RecurringScansInterval.None,
EmailSubscriptionAdmins = model.EmailAdmins,
Emails = model.NotificationEmail
}
};
vaDbSettings = VulnerabilityAssessmentCommunicator.SetDatabaseVulnerabilityAssessmentSettings(model.ResourceGroupName, serverName, databaseName, vaDbSettings);
return(ConvertSettingsToModel(model.ResourceGroupName, vaDbSettings.RecurringScans, vaDbSettings.StorageContainerPath));
case ApplyToType.ManagedDatabase:
DatabaseVulnerabilityAssessment vaManagedDbSettings = new DatabaseVulnerabilityAssessment
{
StorageContainerPath = storageContainerPath,
StorageContainerSasKey = storageAccountSasKey,
RecurringScans = new VulnerabilityAssessmentRecurringScansProperties()
{
IsEnabled = model.RecurringScansInterval != RecurringScansInterval.None,
EmailSubscriptionAdmins = model.EmailAdmins,
Emails = model.NotificationEmail
}
};
vaManagedDbSettings = VulnerabilityAssessmentCommunicator.SetManagedDatabaseVulnerabilityAssessmentSettings(model.ResourceGroupName, serverName, databaseName, vaManagedDbSettings);
return(ConvertSettingsToModel(model.ResourceGroupName, vaManagedDbSettings.RecurringScans, vaManagedDbSettings.StorageContainerPath));
case ApplyToType.Server:
ServerVulnerabilityAssessment vaServerSettings = new ServerVulnerabilityAssessment
{
StorageContainerPath = storageContainerPath,
StorageContainerSasKey = storageAccountSasKey,
RecurringScans = new VulnerabilityAssessmentRecurringScansProperties()
{
IsEnabled = model.RecurringScansInterval != RecurringScansInterval.None,
EmailSubscriptionAdmins = model.EmailAdmins,
Emails = model.NotificationEmail
}
};
vaServerSettings = VulnerabilityAssessmentCommunicator.SetServerVulnerabilityAssessmentSettings(model.ResourceGroupName, serverName, vaServerSettings);
return(ConvertSettingsToModel(model.ResourceGroupName, vaServerSettings.RecurringScans, vaServerSettings.StorageContainerPath));
case ApplyToType.ManagedInstance:
ManagedInstanceVulnerabilityAssessment vaManagedInstanceSettings = new ManagedInstanceVulnerabilityAssessment
{
StorageContainerPath = storageContainerPath,
StorageContainerSasKey = storageAccountSasKey,
RecurringScans = new VulnerabilityAssessmentRecurringScansProperties()
{
IsEnabled = model.RecurringScansInterval != RecurringScansInterval.None,
EmailSubscriptionAdmins = model.EmailAdmins,
Emails = model.NotificationEmail
}
};
vaManagedInstanceSettings = VulnerabilityAssessmentCommunicator.SetManagedInstanceVulnerabilityAssessmentSettings(model.ResourceGroupName, serverName, vaManagedInstanceSettings);
return(ConvertSettingsToModel(model.ResourceGroupName, vaManagedInstanceSettings.RecurringScans, vaManagedInstanceSettings.StorageContainerPath));
default:
throw new ArgumentOutOfRangeException(nameof(applyToType), applyToType, null);
}
}
/// <summary>
/// Remove the Vulnerability Assessment Rule Baseline
/// </summary>
public void ClearDatabaseVulnerabilityAssessmentRuleBaseline(DatabaseVulnerabilityAssessmentRuleBaselineModel model)
{
VulnerabilityAssessmentCommunicator.ClearDatabaseVulnerabilityAssessmentRuleBaseline(model.ResourceGroupName, model.ServerName,
model.DatabaseName, model.RuleId, model.RuleAppliesToMaster);
}
/// <summary>
/// Create a blob storage container ad a SAS URI
/// </summary>
public async Task <StorageContainerInfo> CreateBlobStorageContainerAndSAS(string storageAccountName, string containerName)
{
var resourceGroupName = AzureCommunicator.GetStorageResourceGroup(storageAccountName);
return(await VulnerabilityAssessmentCommunicator.CreateBlobStorageContainer(resourceGroupName, storageAccountName, containerName));
}
/// <summary>
/// Remove the Vulnerability Assessment
/// </summary>
public void ClearDatabaseVulnerabilityAssessmentSettings(DatabaseVulnerabilityAssessmentSettingsModel model)
{
VulnerabilityAssessmentCommunicator.ClearDatabaseVulnerabilityAssessmentSettings(model.ResourceGroupName, model.ServerName, model.DatabaseName);
}
/// <summary>
/// Run a new Vulnerability Assessment scan
/// </summary>
public void StartDatabaseVulnerabilityAssessmentScan(string resourceGroup, string serverName,
string databaseName, string scanId)
{
VulnerabilityAssessmentCommunicator.TriggerDatabaseVulnerabilityAssessmentScan(resourceGroup, serverName, databaseName, scanId);
}
/// <summary>
/// Get a the Vulnerability Assessment scan record
/// </summary>
public DatabaseVulnerabilityAssessmentScanRecordModel GetDatabaseVulnerabilityAssessmentScanRecord(string resourceGroup, string serverName,
string databaseName, string scanId)
{
DatabaseVulnerabilityAssessmentScanRecordModel model = ConvertDatabaseVulnerabilityAssessmentScanRecord(resourceGroup, serverName, databaseName,
VulnerabilityAssessmentCommunicator.GetDatabaseVulnerabilityAssessmentScanRecord(resourceGroup, serverName, databaseName, scanId));
return(model);
}
