/// <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>
        /// 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>
 /// 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);
     }
 }