diff --git a/profiles/preview/preview/security/mgmt/security/models.go b/profiles/preview/preview/security/mgmt/security/models.go index 34926a49a44b..3c2e6461b3f2 100644 --- a/profiles/preview/preview/security/mgmt/security/models.go +++ b/profiles/preview/preview/security/mgmt/security/models.go @@ -81,6 +81,14 @@ const ( AssessedResourceTypeSQLServerVulnerability AssessedResourceType = original.AssessedResourceTypeSQLServerVulnerability ) +type AssessmentType = original.AssessmentType + +const ( + BuiltIn AssessmentType = original.BuiltIn + CustomerManaged AssessmentType = original.CustomerManaged + CustomPolicy AssessmentType = original.CustomPolicy +) + type AutoProvision = original.AutoProvision const ( @@ -88,6 +96,16 @@ const ( AutoProvisionOn AutoProvision = original.AutoProvisionOn ) +type Category = original.Category + +const ( + Compute Category = original.Compute + Data Category = original.Data + IdentityAndAccess Category = original.IdentityAndAccess + IoT Category = original.IoT + Networking Category = original.Networking +) + type ConfigurationStatus = original.ConfigurationStatus const ( @@ -204,6 +222,14 @@ const ( FileTypeUnknown FileType = original.FileTypeUnknown ) +type ImplementationEffort = original.ImplementationEffort + +const ( + High ImplementationEffort = original.High + Low ImplementationEffort = original.Low + Moderate ImplementationEffort = original.Moderate +) + type Issue = original.Issue const ( @@ -336,10 +362,10 @@ const ( type ReportedSeverity = original.ReportedSeverity const ( - High ReportedSeverity = original.High - Informational ReportedSeverity = original.Informational - Low ReportedSeverity = original.Low - Medium ReportedSeverity = original.Medium + ReportedSeverityHigh ReportedSeverity = original.ReportedSeverityHigh + ReportedSeverityInformational ReportedSeverity = original.ReportedSeverityInformational + ReportedSeverityLow ReportedSeverity = original.ReportedSeverityLow + ReportedSeverityMedium ReportedSeverity = original.ReportedSeverityMedium ) type ResourceStatus = original.ResourceStatus @@ -431,6 +457,19 @@ const ( SubAssessmentStatusCodeUnhealthy SubAssessmentStatusCode = original.SubAssessmentStatusCodeUnhealthy ) +type Threats = original.Threats + +const ( + AccountBreach Threats = original.AccountBreach + DataExfiltration Threats = original.DataExfiltration + DataSpillage Threats = original.DataSpillage + DenialOfService Threats = original.DenialOfService + ElevationOfPrivilege Threats = original.ElevationOfPrivilege + MaliciousInsider Threats = original.MaliciousInsider + MissingCoverage Threats = original.MissingCoverage + ThreatResistance Threats = original.ThreatResistance +) + type Type = original.Type const ( @@ -449,6 +488,14 @@ const ( UnmaskedIPLoggingStatusEnabled UnmaskedIPLoggingStatus = original.UnmaskedIPLoggingStatusEnabled ) +type UserImpact = original.UserImpact + +const ( + UserImpactHigh UserImpact = original.UserImpactHigh + UserImpactLow UserImpact = original.UserImpactLow + UserImpactModerate UserImpact = original.UserImpactModerate +) + type ValueType = original.ValueType const ( @@ -488,6 +535,13 @@ type AscLocation = original.AscLocation type AscLocationList = original.AscLocationList type AscLocationListIterator = original.AscLocationListIterator type AscLocationListPage = original.AscLocationListPage +type AssessmentMetadata = original.AssessmentMetadata +type AssessmentMetadataList = original.AssessmentMetadataList +type AssessmentMetadataListIterator = original.AssessmentMetadataListIterator +type AssessmentMetadataListPage = original.AssessmentMetadataListPage +type AssessmentMetadataProperties = original.AssessmentMetadataProperties +type AssessmentsMetadataClient = original.AssessmentsMetadataClient +type AssessmentsMetadataSubscriptionClient = original.AssessmentsMetadataSubscriptionClient type AtaExternalSecuritySolution = original.AtaExternalSecuritySolution type AtaSolutionProperties = original.AtaSolutionProperties type AutoProvisioningSetting = original.AutoProvisioningSetting @@ -766,6 +820,24 @@ func NewAscLocationListIterator(page AscLocationListPage) AscLocationListIterato func NewAscLocationListPage(getNextPage func(context.Context, AscLocationList) (AscLocationList, error)) AscLocationListPage { return original.NewAscLocationListPage(getNextPage) } +func NewAssessmentMetadataListIterator(page AssessmentMetadataListPage) AssessmentMetadataListIterator { + return original.NewAssessmentMetadataListIterator(page) +} +func NewAssessmentMetadataListPage(getNextPage func(context.Context, AssessmentMetadataList) (AssessmentMetadataList, error)) AssessmentMetadataListPage { + return original.NewAssessmentMetadataListPage(getNextPage) +} +func NewAssessmentsMetadataClient(subscriptionID string, ascLocation string) AssessmentsMetadataClient { + return original.NewAssessmentsMetadataClient(subscriptionID, ascLocation) +} +func NewAssessmentsMetadataClientWithBaseURI(baseURI string, subscriptionID string, ascLocation string) AssessmentsMetadataClient { + return original.NewAssessmentsMetadataClientWithBaseURI(baseURI, subscriptionID, ascLocation) +} +func NewAssessmentsMetadataSubscriptionClient(subscriptionID string, ascLocation string) AssessmentsMetadataSubscriptionClient { + return original.NewAssessmentsMetadataSubscriptionClient(subscriptionID, ascLocation) +} +func NewAssessmentsMetadataSubscriptionClientWithBaseURI(baseURI string, subscriptionID string, ascLocation string) AssessmentsMetadataSubscriptionClient { + return original.NewAssessmentsMetadataSubscriptionClientWithBaseURI(baseURI, subscriptionID, ascLocation) +} func NewAutoProvisioningSettingListIterator(page AutoProvisioningSettingListPage) AutoProvisioningSettingListIterator { return original.NewAutoProvisioningSettingListIterator(page) } @@ -1075,9 +1147,15 @@ func PossibleAlertsToAdminsValues() []AlertsToAdmins { func PossibleAssessedResourceTypeValues() []AssessedResourceType { return original.PossibleAssessedResourceTypeValues() } +func PossibleAssessmentTypeValues() []AssessmentType { + return original.PossibleAssessmentTypeValues() +} func PossibleAutoProvisionValues() []AutoProvision { return original.PossibleAutoProvisionValues() } +func PossibleCategoryValues() []Category { + return original.PossibleCategoryValues() +} func PossibleConfigurationStatus1Values() []ConfigurationStatus1 { return original.PossibleConfigurationStatus1Values() } @@ -1120,6 +1198,9 @@ func PossibleFamilyValues() []Family { func PossibleFileTypeValues() []FileType { return original.PossibleFileTypeValues() } +func PossibleImplementationEffortValues() []ImplementationEffort { + return original.PossibleImplementationEffortValues() +} func PossibleIssueValues() []Issue { return original.PossibleIssueValues() } @@ -1195,12 +1276,18 @@ func PossibleStatusValues() []Status { func PossibleSubAssessmentStatusCodeValues() []SubAssessmentStatusCode { return original.PossibleSubAssessmentStatusCodeValues() } +func PossibleThreatsValues() []Threats { + return original.PossibleThreatsValues() +} func PossibleTypeValues() []Type { return original.PossibleTypeValues() } func PossibleUnmaskedIPLoggingStatusValues() []UnmaskedIPLoggingStatus { return original.PossibleUnmaskedIPLoggingStatusValues() } +func PossibleUserImpactValues() []UserImpact { + return original.PossibleUserImpactValues() +} func PossibleValueTypeValues() []ValueType { return original.PossibleValueTypeValues() } diff --git a/profiles/preview/preview/security/mgmt/security/securityapi/models.go b/profiles/preview/preview/security/mgmt/security/securityapi/models.go index 7e83ea774e55..5ad5aa4f97d0 100644 --- a/profiles/preview/preview/security/mgmt/security/securityapi/models.go +++ b/profiles/preview/preview/security/mgmt/security/securityapi/models.go @@ -25,6 +25,8 @@ type AdaptiveApplicationControlsClientAPI = original.AdaptiveApplicationControls type AdvancedThreatProtectionClientAPI = original.AdvancedThreatProtectionClientAPI type AlertsClientAPI = original.AlertsClientAPI type AllowedConnectionsClientAPI = original.AllowedConnectionsClientAPI +type AssessmentsMetadataClientAPI = original.AssessmentsMetadataClientAPI +type AssessmentsMetadataSubscriptionClientAPI = original.AssessmentsMetadataSubscriptionClientAPI type AutoProvisioningSettingsClientAPI = original.AutoProvisioningSettingsClientAPI type AutomationsClientAPI = original.AutomationsClientAPI type ComplianceResultsClientAPI = original.ComplianceResultsClientAPI diff --git a/services/preview/security/mgmt/v3.0/security/assessmentsmetadata.go b/services/preview/security/mgmt/v3.0/security/assessmentsmetadata.go new file mode 100644 index 000000000000..86370dbcd2a6 --- /dev/null +++ b/services/preview/security/mgmt/v3.0/security/assessmentsmetadata.go @@ -0,0 +1,221 @@ +package security + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "context" + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/tracing" + "net/http" +) + +// AssessmentsMetadataClient is the API spec for Microsoft.Security (Azure Security Center) resource provider +type AssessmentsMetadataClient struct { + BaseClient +} + +// NewAssessmentsMetadataClient creates an instance of the AssessmentsMetadataClient client. +func NewAssessmentsMetadataClient(subscriptionID string, ascLocation string) AssessmentsMetadataClient { + return NewAssessmentsMetadataClientWithBaseURI(DefaultBaseURI, subscriptionID, ascLocation) +} + +// NewAssessmentsMetadataClientWithBaseURI creates an instance of the AssessmentsMetadataClient client. +func NewAssessmentsMetadataClientWithBaseURI(baseURI string, subscriptionID string, ascLocation string) AssessmentsMetadataClient { + return AssessmentsMetadataClient{NewWithBaseURI(baseURI, subscriptionID, ascLocation)} +} + +// Get get metadata information on an assessment type +// Parameters: +// assessmentMetadataName - the Assessment Key - Unique key for the assessment type +func (client AssessmentsMetadataClient) Get(ctx context.Context, assessmentMetadataName string) (result AssessmentMetadata, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AssessmentsMetadataClient.Get") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + req, err := client.GetPreparer(ctx, assessmentMetadataName) + if err != nil { + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataClient", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataClient", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataClient", "Get", resp, "Failure responding to request") + } + + return +} + +// GetPreparer prepares the Get request. +func (client AssessmentsMetadataClient) GetPreparer(ctx context.Context, assessmentMetadataName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "assessmentMetadataName": autorest.Encode("path", assessmentMetadataName), + } + + const APIVersion = "2019-01-01-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/providers/Microsoft.Security/assessmentMetadata/{assessmentMetadataName}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetSender sends the Get request. The method will close the +// http.Response Body if it receives an error. +func (client AssessmentsMetadataClient) GetSender(req *http.Request) (*http.Response, error) { + sd := autorest.GetSendDecorators(req.Context(), autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + return autorest.SendWithSender(client, req, sd...) +} + +// GetResponder handles the response to the Get request. The method always +// closes the http.Response Body. +func (client AssessmentsMetadataClient) GetResponder(resp *http.Response) (result AssessmentMetadata, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// List get metadata information on all assessment types +func (client AssessmentsMetadataClient) List(ctx context.Context) (result AssessmentMetadataListPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AssessmentsMetadataClient.List") + defer func() { + sc := -1 + if result.aml.Response.Response != nil { + sc = result.aml.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx) + if err != nil { + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.aml.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataClient", "List", resp, "Failure sending request") + return + } + + result.aml, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataClient", "List", resp, "Failure responding to request") + } + + return +} + +// ListPreparer prepares the List request. +func (client AssessmentsMetadataClient) ListPreparer(ctx context.Context) (*http.Request, error) { + const APIVersion = "2019-01-01-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPath("/providers/Microsoft.Security/assessmentMetadata"), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListSender sends the List request. The method will close the +// http.Response Body if it receives an error. +func (client AssessmentsMetadataClient) ListSender(req *http.Request) (*http.Response, error) { + sd := autorest.GetSendDecorators(req.Context(), autorest.DoRetryForStatusCodes(client.RetryAttempts, client.RetryDuration, autorest.StatusCodesForRetry...)) + return autorest.SendWithSender(client, req, sd...) +} + +// ListResponder handles the response to the List request. The method always +// closes the http.Response Body. +func (client AssessmentsMetadataClient) ListResponder(resp *http.Response) (result AssessmentMetadataList, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// listNextResults retrieves the next set of results, if any. +func (client AssessmentsMetadataClient) listNextResults(ctx context.Context, lastResults AssessmentMetadataList) (result AssessmentMetadataList, err error) { + req, err := lastResults.assessmentMetadataListPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "security.AssessmentsMetadataClient", "listNextResults", nil, "Failure preparing next results request") + } + if req == nil { + return + } + resp, err := client.ListSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "security.AssessmentsMetadataClient", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataClient", "listNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListComplete enumerates all values, automatically crossing page boundaries as required. +func (client AssessmentsMetadataClient) ListComplete(ctx context.Context) (result AssessmentMetadataListIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AssessmentsMetadataClient.List") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.page, err = client.List(ctx) + return +} diff --git a/services/preview/security/mgmt/v3.0/security/assessmentsmetadatasubscription.go b/services/preview/security/mgmt/v3.0/security/assessmentsmetadatasubscription.go new file mode 100644 index 000000000000..6196ed904798 --- /dev/null +++ b/services/preview/security/mgmt/v3.0/security/assessmentsmetadatasubscription.go @@ -0,0 +1,409 @@ +package security + +// Copyright (c) Microsoft and contributors. All rights reserved. +// +// Licensed under the Apache License, Version 2.0 (the "License"); +// you may not use this file except in compliance with the License. +// You may obtain a copy of the License at +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, software +// distributed under the License is distributed on an "AS IS" BASIS, +// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +// +// See the License for the specific language governing permissions and +// limitations under the License. +// +// Code generated by Microsoft (R) AutoRest Code Generator. +// Changes may cause incorrect behavior and will be lost if the code is regenerated. + +import ( + "context" + "github.com/Azure/go-autorest/autorest" + "github.com/Azure/go-autorest/autorest/azure" + "github.com/Azure/go-autorest/autorest/validation" + "github.com/Azure/go-autorest/tracing" + "net/http" +) + +// AssessmentsMetadataSubscriptionClient is the API spec for Microsoft.Security (Azure Security Center) resource +// provider +type AssessmentsMetadataSubscriptionClient struct { + BaseClient +} + +// NewAssessmentsMetadataSubscriptionClient creates an instance of the AssessmentsMetadataSubscriptionClient client. +func NewAssessmentsMetadataSubscriptionClient(subscriptionID string, ascLocation string) AssessmentsMetadataSubscriptionClient { + return NewAssessmentsMetadataSubscriptionClientWithBaseURI(DefaultBaseURI, subscriptionID, ascLocation) +} + +// NewAssessmentsMetadataSubscriptionClientWithBaseURI creates an instance of the AssessmentsMetadataSubscriptionClient +// client. +func NewAssessmentsMetadataSubscriptionClientWithBaseURI(baseURI string, subscriptionID string, ascLocation string) AssessmentsMetadataSubscriptionClient { + return AssessmentsMetadataSubscriptionClient{NewWithBaseURI(baseURI, subscriptionID, ascLocation)} +} + +// Create create metadata information on an assessment type in a specific subscription +// Parameters: +// assessmentMetadataName - the Assessment Key - Unique key for the assessment type +// assessmentMetadata - assessmentMetadata object +func (client AssessmentsMetadataSubscriptionClient) Create(ctx context.Context, assessmentMetadataName string, assessmentMetadata AssessmentMetadata) (result AssessmentMetadata, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AssessmentsMetadataSubscriptionClient.Create") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.Pattern, Rule: `^[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}$`, Chain: nil}}}, + {TargetValue: assessmentMetadata, + Constraints: []validation.Constraint{{Target: "assessmentMetadata.AssessmentMetadataProperties", Name: validation.Null, Rule: false, + Chain: []validation.Constraint{{Target: "assessmentMetadata.AssessmentMetadataProperties.DisplayName", Name: validation.Null, Rule: true, Chain: nil}}}}}}); err != nil { + return result, validation.NewError("security.AssessmentsMetadataSubscriptionClient", "Create", err.Error()) + } + + req, err := client.CreatePreparer(ctx, assessmentMetadataName, assessmentMetadata) + if err != nil { + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataSubscriptionClient", "Create", nil, "Failure preparing request") + return + } + + resp, err := client.CreateSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataSubscriptionClient", "Create", resp, "Failure sending request") + return + } + + result, err = client.CreateResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataSubscriptionClient", "Create", resp, "Failure responding to request") + } + + return +} + +// CreatePreparer prepares the Create request. +func (client AssessmentsMetadataSubscriptionClient) CreatePreparer(ctx context.Context, assessmentMetadataName string, assessmentMetadata AssessmentMetadata) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "assessmentMetadataName": autorest.Encode("path", assessmentMetadataName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2019-01-01-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsContentType("application/json; charset=utf-8"), + autorest.AsPut(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Security/assessmentMetadata/{assessmentMetadataName}", pathParameters), + autorest.WithJSON(assessmentMetadata), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// CreateSender sends the Create request. The method will close the +// http.Response Body if it receives an error. +func (client AssessmentsMetadataSubscriptionClient) CreateSender(req *http.Request) (*http.Response, error) { + sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) + return autorest.SendWithSender(client, req, sd...) +} + +// CreateResponder handles the response to the Create request. The method always +// closes the http.Response Body. +func (client AssessmentsMetadataSubscriptionClient) CreateResponder(resp *http.Response) (result AssessmentMetadata, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// Delete delete metadata information on an assessment type in a specific subscription, will cause the deletion of all +// the assessments of that type in that subscription +// Parameters: +// assessmentMetadataName - the Assessment Key - Unique key for the assessment type +func (client AssessmentsMetadataSubscriptionClient) Delete(ctx context.Context, assessmentMetadataName string) (result autorest.Response, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AssessmentsMetadataSubscriptionClient.Delete") + defer func() { + sc := -1 + if result.Response != nil { + sc = result.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.Pattern, Rule: `^[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}$`, Chain: nil}}}}); err != nil { + return result, validation.NewError("security.AssessmentsMetadataSubscriptionClient", "Delete", err.Error()) + } + + req, err := client.DeletePreparer(ctx, assessmentMetadataName) + if err != nil { + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataSubscriptionClient", "Delete", nil, "Failure preparing request") + return + } + + resp, err := client.DeleteSender(req) + if err != nil { + result.Response = resp + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataSubscriptionClient", "Delete", resp, "Failure sending request") + return + } + + result, err = client.DeleteResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataSubscriptionClient", "Delete", resp, "Failure responding to request") + } + + return +} + +// DeletePreparer prepares the Delete request. +func (client AssessmentsMetadataSubscriptionClient) DeletePreparer(ctx context.Context, assessmentMetadataName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "assessmentMetadataName": autorest.Encode("path", assessmentMetadataName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2019-01-01-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsDelete(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Security/assessmentMetadata/{assessmentMetadataName}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// DeleteSender sends the Delete request. The method will close the +// http.Response Body if it receives an error. +func (client AssessmentsMetadataSubscriptionClient) DeleteSender(req *http.Request) (*http.Response, error) { + sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) + return autorest.SendWithSender(client, req, sd...) +} + +// DeleteResponder handles the response to the Delete request. The method always +// closes the http.Response Body. +func (client AssessmentsMetadataSubscriptionClient) DeleteResponder(resp *http.Response) (result autorest.Response, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByClosing()) + result.Response = resp + return +} + +// Get get metadata information on an assessment type in a specific subscription +// Parameters: +// assessmentMetadataName - the Assessment Key - Unique key for the assessment type +func (client AssessmentsMetadataSubscriptionClient) Get(ctx context.Context, assessmentMetadataName string) (result AssessmentMetadata, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AssessmentsMetadataSubscriptionClient.Get") + defer func() { + sc := -1 + if result.Response.Response != nil { + sc = result.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.Pattern, Rule: `^[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}$`, Chain: nil}}}}); err != nil { + return result, validation.NewError("security.AssessmentsMetadataSubscriptionClient", "Get", err.Error()) + } + + req, err := client.GetPreparer(ctx, assessmentMetadataName) + if err != nil { + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataSubscriptionClient", "Get", nil, "Failure preparing request") + return + } + + resp, err := client.GetSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataSubscriptionClient", "Get", resp, "Failure sending request") + return + } + + result, err = client.GetResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataSubscriptionClient", "Get", resp, "Failure responding to request") + } + + return +} + +// GetPreparer prepares the Get request. +func (client AssessmentsMetadataSubscriptionClient) GetPreparer(ctx context.Context, assessmentMetadataName string) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "assessmentMetadataName": autorest.Encode("path", assessmentMetadataName), + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2019-01-01-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Security/assessmentMetadata/{assessmentMetadataName}", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// GetSender sends the Get request. The method will close the +// http.Response Body if it receives an error. +func (client AssessmentsMetadataSubscriptionClient) GetSender(req *http.Request) (*http.Response, error) { + sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) + return autorest.SendWithSender(client, req, sd...) +} + +// GetResponder handles the response to the Get request. The method always +// closes the http.Response Body. +func (client AssessmentsMetadataSubscriptionClient) GetResponder(resp *http.Response) (result AssessmentMetadata, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// List get metadata information on all assessment types in a specific subscription +func (client AssessmentsMetadataSubscriptionClient) List(ctx context.Context) (result AssessmentMetadataListPage, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AssessmentsMetadataSubscriptionClient.List") + defer func() { + sc := -1 + if result.aml.Response.Response != nil { + sc = result.aml.Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + if err := validation.Validate([]validation.Validation{ + {TargetValue: client.SubscriptionID, + Constraints: []validation.Constraint{{Target: "client.SubscriptionID", Name: validation.Pattern, Rule: `^[0-9A-Fa-f]{8}-([0-9A-Fa-f]{4}-){3}[0-9A-Fa-f]{12}$`, Chain: nil}}}}); err != nil { + return result, validation.NewError("security.AssessmentsMetadataSubscriptionClient", "List", err.Error()) + } + + result.fn = client.listNextResults + req, err := client.ListPreparer(ctx) + if err != nil { + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataSubscriptionClient", "List", nil, "Failure preparing request") + return + } + + resp, err := client.ListSender(req) + if err != nil { + result.aml.Response = autorest.Response{Response: resp} + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataSubscriptionClient", "List", resp, "Failure sending request") + return + } + + result.aml, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataSubscriptionClient", "List", resp, "Failure responding to request") + } + + return +} + +// ListPreparer prepares the List request. +func (client AssessmentsMetadataSubscriptionClient) ListPreparer(ctx context.Context) (*http.Request, error) { + pathParameters := map[string]interface{}{ + "subscriptionId": autorest.Encode("path", client.SubscriptionID), + } + + const APIVersion = "2019-01-01-preview" + queryParameters := map[string]interface{}{ + "api-version": APIVersion, + } + + preparer := autorest.CreatePreparer( + autorest.AsGet(), + autorest.WithBaseURL(client.BaseURI), + autorest.WithPathParameters("/subscriptions/{subscriptionId}/providers/Microsoft.Security/assessmentMetadata", pathParameters), + autorest.WithQueryParameters(queryParameters)) + return preparer.Prepare((&http.Request{}).WithContext(ctx)) +} + +// ListSender sends the List request. The method will close the +// http.Response Body if it receives an error. +func (client AssessmentsMetadataSubscriptionClient) ListSender(req *http.Request) (*http.Response, error) { + sd := autorest.GetSendDecorators(req.Context(), azure.DoRetryWithRegistration(client.Client)) + return autorest.SendWithSender(client, req, sd...) +} + +// ListResponder handles the response to the List request. The method always +// closes the http.Response Body. +func (client AssessmentsMetadataSubscriptionClient) ListResponder(resp *http.Response) (result AssessmentMetadataList, err error) { + err = autorest.Respond( + resp, + client.ByInspecting(), + azure.WithErrorUnlessStatusCode(http.StatusOK), + autorest.ByUnmarshallingJSON(&result), + autorest.ByClosing()) + result.Response = autorest.Response{Response: resp} + return +} + +// listNextResults retrieves the next set of results, if any. +func (client AssessmentsMetadataSubscriptionClient) listNextResults(ctx context.Context, lastResults AssessmentMetadataList) (result AssessmentMetadataList, err error) { + req, err := lastResults.assessmentMetadataListPreparer(ctx) + if err != nil { + return result, autorest.NewErrorWithError(err, "security.AssessmentsMetadataSubscriptionClient", "listNextResults", nil, "Failure preparing next results request") + } + if req == nil { + return + } + resp, err := client.ListSender(req) + if err != nil { + result.Response = autorest.Response{Response: resp} + return result, autorest.NewErrorWithError(err, "security.AssessmentsMetadataSubscriptionClient", "listNextResults", resp, "Failure sending next results request") + } + result, err = client.ListResponder(resp) + if err != nil { + err = autorest.NewErrorWithError(err, "security.AssessmentsMetadataSubscriptionClient", "listNextResults", resp, "Failure responding to next results request") + } + return +} + +// ListComplete enumerates all values, automatically crossing page boundaries as required. +func (client AssessmentsMetadataSubscriptionClient) ListComplete(ctx context.Context) (result AssessmentMetadataListIterator, err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AssessmentsMetadataSubscriptionClient.List") + defer func() { + sc := -1 + if result.Response().Response.Response != nil { + sc = result.page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + result.page, err = client.List(ctx) + return +} diff --git a/services/preview/security/mgmt/v3.0/security/models.go b/services/preview/security/mgmt/v3.0/security/models.go index 41b00dc8f79c..8ea590c78bc0 100644 --- a/services/preview/security/mgmt/v3.0/security/models.go +++ b/services/preview/security/mgmt/v3.0/security/models.go @@ -141,6 +141,25 @@ func PossibleAssessedResourceTypeValues() []AssessedResourceType { return []AssessedResourceType{AssessedResourceTypeAdditionalData, AssessedResourceTypeContainerRegistryVulnerability, AssessedResourceTypeServerVulnerabilityAssessment, AssessedResourceTypeSQLServerVulnerability} } +// AssessmentType enumerates the values for assessment type. +type AssessmentType string + +const ( + // BuiltIn Azure Security Center managed assessments + BuiltIn AssessmentType = "BuiltIn" + // CustomerManaged User assessments pushed directly by the user or other third party to Azure Security + // Center + CustomerManaged AssessmentType = "CustomerManaged" + // CustomPolicy User defined policies that are automatically ingested from Azure Policy to Azure Security + // Center + CustomPolicy AssessmentType = "CustomPolicy" +) + +// PossibleAssessmentTypeValues returns an array of possible values for the AssessmentType const type. +func PossibleAssessmentTypeValues() []AssessmentType { + return []AssessmentType{BuiltIn, CustomerManaged, CustomPolicy} +} + // AutoProvision enumerates the values for auto provision. type AutoProvision string @@ -156,6 +175,27 @@ func PossibleAutoProvisionValues() []AutoProvision { return []AutoProvision{AutoProvisionOff, AutoProvisionOn} } +// Category enumerates the values for category. +type Category string + +const ( + // Compute ... + Compute Category = "Compute" + // Data ... + Data Category = "Data" + // IdentityAndAccess ... + IdentityAndAccess Category = "IdentityAndAccess" + // IoT ... + IoT Category = "IoT" + // Networking ... + Networking Category = "Networking" +) + +// PossibleCategoryValues returns an array of possible values for the Category const type. +func PossibleCategoryValues() []Category { + return []Category{Compute, Data, IdentityAndAccess, IoT, Networking} +} + // ConfigurationStatus enumerates the values for configuration status. type ConfigurationStatus string @@ -402,6 +442,23 @@ func PossibleFileTypeValues() []FileType { return []FileType{FileTypeDll, FileTypeExe, FileTypeExecutable, FileTypeMsi, FileTypeScript, FileTypeUnknown} } +// ImplementationEffort enumerates the values for implementation effort. +type ImplementationEffort string + +const ( + // High ... + High ImplementationEffort = "High" + // Low ... + Low ImplementationEffort = "Low" + // Moderate ... + Moderate ImplementationEffort = "Moderate" +) + +// PossibleImplementationEffortValues returns an array of possible values for the ImplementationEffort const type. +func PossibleImplementationEffortValues() []ImplementationEffort { + return []ImplementationEffort{High, Low, Moderate} +} + // Issue enumerates the values for issue. type Issue string @@ -689,19 +746,19 @@ func PossibleRecommendationTypeValues() []RecommendationType { type ReportedSeverity string const ( - // High ... - High ReportedSeverity = "High" - // Informational ... - Informational ReportedSeverity = "Informational" - // Low ... - Low ReportedSeverity = "Low" - // Medium ... - Medium ReportedSeverity = "Medium" + // ReportedSeverityHigh ... + ReportedSeverityHigh ReportedSeverity = "High" + // ReportedSeverityInformational ... + ReportedSeverityInformational ReportedSeverity = "Informational" + // ReportedSeverityLow ... + ReportedSeverityLow ReportedSeverity = "Low" + // ReportedSeverityMedium ... + ReportedSeverityMedium ReportedSeverity = "Medium" ) // PossibleReportedSeverityValues returns an array of possible values for the ReportedSeverity const type. func PossibleReportedSeverityValues() []ReportedSeverity { - return []ReportedSeverity{High, Informational, Low, Medium} + return []ReportedSeverity{ReportedSeverityHigh, ReportedSeverityInformational, ReportedSeverityLow, ReportedSeverityMedium} } // ResourceStatus enumerates the values for resource status. @@ -894,6 +951,33 @@ func PossibleSubAssessmentStatusCodeValues() []SubAssessmentStatusCode { return []SubAssessmentStatusCode{SubAssessmentStatusCodeHealthy, SubAssessmentStatusCodeNotApplicable, SubAssessmentStatusCodeUnhealthy} } +// Threats enumerates the values for threats. +type Threats string + +const ( + // AccountBreach ... + AccountBreach Threats = "accountBreach" + // DataExfiltration ... + DataExfiltration Threats = "dataExfiltration" + // DataSpillage ... + DataSpillage Threats = "dataSpillage" + // DenialOfService ... + DenialOfService Threats = "denialOfService" + // ElevationOfPrivilege ... + ElevationOfPrivilege Threats = "elevationOfPrivilege" + // MaliciousInsider ... + MaliciousInsider Threats = "maliciousInsider" + // MissingCoverage ... + MissingCoverage Threats = "missingCoverage" + // ThreatResistance ... + ThreatResistance Threats = "threatResistance" +) + +// PossibleThreatsValues returns an array of possible values for the Threats const type. +func PossibleThreatsValues() []Threats { + return []Threats{AccountBreach, DataExfiltration, DataSpillage, DenialOfService, ElevationOfPrivilege, MaliciousInsider, MissingCoverage, ThreatResistance} +} + // Type enumerates the values for type. type Type string @@ -932,6 +1016,23 @@ func PossibleUnmaskedIPLoggingStatusValues() []UnmaskedIPLoggingStatus { return []UnmaskedIPLoggingStatus{UnmaskedIPLoggingStatusDisabled, UnmaskedIPLoggingStatusEnabled} } +// UserImpact enumerates the values for user impact. +type UserImpact string + +const ( + // UserImpactHigh ... + UserImpactHigh UserImpact = "High" + // UserImpactLow ... + UserImpactLow UserImpact = "Low" + // UserImpactModerate ... + UserImpactModerate UserImpact = "Moderate" +) + +// PossibleUserImpactValues returns an array of possible values for the UserImpact const type. +func PossibleUserImpactValues() []UserImpact { + return []UserImpact{UserImpactHigh, UserImpactLow, UserImpactModerate} +} + // ValueType enumerates the values for value type. type ValueType string @@ -1486,7 +1587,7 @@ type AlertProperties struct { RemediationSteps *string `json:"remediationSteps,omitempty"` // ActionTaken - READ-ONLY; The action that was taken as a response to the alert (Active, Blocked etc.) ActionTaken *string `json:"actionTaken,omitempty"` - // ReportedSeverity - READ-ONLY; Estimated severity of this alert. Possible values include: 'Informational', 'Low', 'Medium', 'High' + // ReportedSeverity - READ-ONLY; Estimated severity of this alert. Possible values include: 'ReportedSeverityInformational', 'ReportedSeverityLow', 'ReportedSeverityMedium', 'ReportedSeverityHigh' ReportedSeverity ReportedSeverity `json:"reportedSeverity,omitempty"` // CompromisedEntity - READ-ONLY; The entity that the incident happened on CompromisedEntity *string `json:"compromisedEntity,omitempty"` @@ -2067,6 +2168,248 @@ func NewAscLocationListPage(getNextPage func(context.Context, AscLocationList) ( return AscLocationListPage{fn: getNextPage} } +// AssessmentMetadata security assessment metadata +type AssessmentMetadata struct { + autorest.Response `json:"-"` + *AssessmentMetadataProperties `json:"properties,omitempty"` + // ID - READ-ONLY; Resource Id + ID *string `json:"id,omitempty"` + // Name - READ-ONLY; Resource name + Name *string `json:"name,omitempty"` + // Type - READ-ONLY; Resource type + Type *string `json:"type,omitempty"` +} + +// MarshalJSON is the custom marshaler for AssessmentMetadata. +func (am AssessmentMetadata) MarshalJSON() ([]byte, error) { + objectMap := make(map[string]interface{}) + if am.AssessmentMetadataProperties != nil { + objectMap["properties"] = am.AssessmentMetadataProperties + } + return json.Marshal(objectMap) +} + +// UnmarshalJSON is the custom unmarshaler for AssessmentMetadata struct. +func (am *AssessmentMetadata) UnmarshalJSON(body []byte) error { + var m map[string]*json.RawMessage + err := json.Unmarshal(body, &m) + if err != nil { + return err + } + for k, v := range m { + switch k { + case "properties": + if v != nil { + var assessmentMetadataProperties AssessmentMetadataProperties + err = json.Unmarshal(*v, &assessmentMetadataProperties) + if err != nil { + return err + } + am.AssessmentMetadataProperties = &assessmentMetadataProperties + } + case "id": + if v != nil { + var ID string + err = json.Unmarshal(*v, &ID) + if err != nil { + return err + } + am.ID = &ID + } + case "name": + if v != nil { + var name string + err = json.Unmarshal(*v, &name) + if err != nil { + return err + } + am.Name = &name + } + case "type": + if v != nil { + var typeVar string + err = json.Unmarshal(*v, &typeVar) + if err != nil { + return err + } + am.Type = &typeVar + } + } + } + + return nil +} + +// AssessmentMetadataList list of security assessment metadata +type AssessmentMetadataList struct { + autorest.Response `json:"-"` + // Value - READ-ONLY + Value *[]AssessmentMetadata `json:"value,omitempty"` + // NextLink - READ-ONLY; The URI to fetch the next page. + NextLink *string `json:"nextLink,omitempty"` +} + +// AssessmentMetadataListIterator provides access to a complete listing of AssessmentMetadata values. +type AssessmentMetadataListIterator struct { + i int + page AssessmentMetadataListPage +} + +// NextWithContext advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +func (iter *AssessmentMetadataListIterator) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AssessmentMetadataListIterator.NextWithContext") + defer func() { + sc := -1 + if iter.Response().Response.Response != nil { + sc = iter.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + iter.i++ + if iter.i < len(iter.page.Values()) { + return nil + } + err = iter.page.NextWithContext(ctx) + if err != nil { + iter.i-- + return err + } + iter.i = 0 + return nil +} + +// Next advances to the next value. If there was an error making +// the request the iterator does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (iter *AssessmentMetadataListIterator) Next() error { + return iter.NextWithContext(context.Background()) +} + +// NotDone returns true if the enumeration should be started or is not yet complete. +func (iter AssessmentMetadataListIterator) NotDone() bool { + return iter.page.NotDone() && iter.i < len(iter.page.Values()) +} + +// Response returns the raw server response from the last page request. +func (iter AssessmentMetadataListIterator) Response() AssessmentMetadataList { + return iter.page.Response() +} + +// Value returns the current value or a zero-initialized value if the +// iterator has advanced beyond the end of the collection. +func (iter AssessmentMetadataListIterator) Value() AssessmentMetadata { + if !iter.page.NotDone() { + return AssessmentMetadata{} + } + return iter.page.Values()[iter.i] +} + +// Creates a new instance of the AssessmentMetadataListIterator type. +func NewAssessmentMetadataListIterator(page AssessmentMetadataListPage) AssessmentMetadataListIterator { + return AssessmentMetadataListIterator{page: page} +} + +// IsEmpty returns true if the ListResult contains no values. +func (aml AssessmentMetadataList) IsEmpty() bool { + return aml.Value == nil || len(*aml.Value) == 0 +} + +// assessmentMetadataListPreparer prepares a request to retrieve the next set of results. +// It returns nil if no more results exist. +func (aml AssessmentMetadataList) assessmentMetadataListPreparer(ctx context.Context) (*http.Request, error) { + if aml.NextLink == nil || len(to.String(aml.NextLink)) < 1 { + return nil, nil + } + return autorest.Prepare((&http.Request{}).WithContext(ctx), + autorest.AsJSON(), + autorest.AsGet(), + autorest.WithBaseURL(to.String(aml.NextLink))) +} + +// AssessmentMetadataListPage contains a page of AssessmentMetadata values. +type AssessmentMetadataListPage struct { + fn func(context.Context, AssessmentMetadataList) (AssessmentMetadataList, error) + aml AssessmentMetadataList +} + +// NextWithContext advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +func (page *AssessmentMetadataListPage) NextWithContext(ctx context.Context) (err error) { + if tracing.IsEnabled() { + ctx = tracing.StartSpan(ctx, fqdn+"/AssessmentMetadataListPage.NextWithContext") + defer func() { + sc := -1 + if page.Response().Response.Response != nil { + sc = page.Response().Response.Response.StatusCode + } + tracing.EndSpan(ctx, sc, err) + }() + } + next, err := page.fn(ctx, page.aml) + if err != nil { + return err + } + page.aml = next + return nil +} + +// Next advances to the next page of values. If there was an error making +// the request the page does not advance and the error is returned. +// Deprecated: Use NextWithContext() instead. +func (page *AssessmentMetadataListPage) Next() error { + return page.NextWithContext(context.Background()) +} + +// NotDone returns true if the page enumeration should be started or is not yet complete. +func (page AssessmentMetadataListPage) NotDone() bool { + return !page.aml.IsEmpty() +} + +// Response returns the raw server response from the last page request. +func (page AssessmentMetadataListPage) Response() AssessmentMetadataList { + return page.aml +} + +// Values returns the slice of values for the current page or nil if there are no values. +func (page AssessmentMetadataListPage) Values() []AssessmentMetadata { + if page.aml.IsEmpty() { + return nil + } + return *page.aml.Value +} + +// Creates a new instance of the AssessmentMetadataListPage type. +func NewAssessmentMetadataListPage(getNextPage func(context.Context, AssessmentMetadataList) (AssessmentMetadataList, error)) AssessmentMetadataListPage { + return AssessmentMetadataListPage{fn: getNextPage} +} + +// AssessmentMetadataProperties describes properties of an assessment metadata. +type AssessmentMetadataProperties struct { + // DisplayName - User friendly display name of the assessment + DisplayName *string `json:"displayName,omitempty"` + // PolicyDefinitionID - READ-ONLY; Azure resource ID of the policy definition that turns this assessment calculation on + PolicyDefinitionID *string `json:"policyDefinitionId,omitempty"` + // Description - Human readable description of the assessment + Description *string `json:"description,omitempty"` + // RemediationDescription - Human readable description of what you should do to mitigate this security issue + RemediationDescription *string `json:"remediationDescription,omitempty"` + Category *[]Category `json:"category,omitempty"` + // Severity - The severity level of the assessment. Possible values include: 'SeverityLow', 'SeverityMedium', 'SeverityHigh' + Severity Severity `json:"severity,omitempty"` + // UserImpact - The user impact of the assessment. Possible values include: 'UserImpactLow', 'UserImpactModerate', 'UserImpactHigh' + UserImpact UserImpact `json:"userImpact,omitempty"` + // ImplementationEffort - The implementation effort required to remediate this assessment. Possible values include: 'Low', 'Moderate', 'High' + ImplementationEffort ImplementationEffort `json:"implementationEffort,omitempty"` + Threats *[]Threats `json:"threats,omitempty"` + // Preview - True if this assessment is in preview release status + Preview *bool `json:"preview,omitempty"` + // AssessmentType - BuiltIn if the assessment based on built-in Azure Policy definition, Custom if the assessment based on custom Azure Policy definition. Possible values include: 'BuiltIn', 'CustomPolicy', 'CustomerManaged' + AssessmentType AssessmentType `json:"assessmentType,omitempty"` +} + // AtaExternalSecuritySolution represents an ATA security solution which sends logs to an OMS workspace type AtaExternalSecuritySolution struct { Properties *AtaSolutionProperties `json:"properties,omitempty"` @@ -6241,7 +6584,7 @@ type IoTSecurityAggregatedAlertProperties struct { AggregatedDateUtc *date.Date `json:"aggregatedDateUtc,omitempty"` // VendorName - READ-ONLY; Name of the organization that raised the alert. VendorName *string `json:"vendorName,omitempty"` - // ReportedSeverity - READ-ONLY; Assessed alert severity. Possible values include: 'Informational', 'Low', 'Medium', 'High' + // ReportedSeverity - READ-ONLY; Assessed alert severity. Possible values include: 'ReportedSeverityInformational', 'ReportedSeverityLow', 'ReportedSeverityMedium', 'ReportedSeverityHigh' ReportedSeverity ReportedSeverity `json:"reportedSeverity,omitempty"` // RemediationSteps - READ-ONLY; Recommended steps for remediation. RemediationSteps *string `json:"remediationSteps,omitempty"` @@ -6521,7 +6864,7 @@ type IoTSecurityAggregatedRecommendationProperties struct { DetectedBy *string `json:"detectedBy,omitempty"` // RemediationSteps - READ-ONLY; Recommended steps for remediation RemediationSteps *string `json:"remediationSteps,omitempty"` - // ReportedSeverity - READ-ONLY; Assessed recommendation severity. Possible values include: 'Informational', 'Low', 'Medium', 'High' + // ReportedSeverity - READ-ONLY; Assessed recommendation severity. Possible values include: 'ReportedSeverityInformational', 'ReportedSeverityLow', 'ReportedSeverityMedium', 'ReportedSeverityHigh' ReportedSeverity ReportedSeverity `json:"reportedSeverity,omitempty"` // HealthyDevices - READ-ONLY; Number of healthy devices within the IoT Security solution. HealthyDevices *int32 `json:"healthyDevices,omitempty"` @@ -6545,7 +6888,7 @@ type IoTSecurityAlertedDevice struct { type IoTSecurityDeviceAlert struct { // AlertDisplayName - READ-ONLY; Display name of the alert AlertDisplayName *string `json:"alertDisplayName,omitempty"` - // ReportedSeverity - READ-ONLY; Assessed Alert severity. Possible values include: 'Informational', 'Low', 'Medium', 'High' + // ReportedSeverity - READ-ONLY; Assessed Alert severity. Possible values include: 'ReportedSeverityInformational', 'ReportedSeverityLow', 'ReportedSeverityMedium', 'ReportedSeverityHigh' ReportedSeverity ReportedSeverity `json:"reportedSeverity,omitempty"` // AlertsCount - READ-ONLY; Number of alerts raised for this alert type. AlertsCount *int32 `json:"alertsCount,omitempty"` @@ -6556,7 +6899,7 @@ type IoTSecurityDeviceAlert struct { type IoTSecurityDeviceRecommendation struct { // RecommendationDisplayName - READ-ONLY; Display name of the recommendation. RecommendationDisplayName *string `json:"recommendationDisplayName,omitempty"` - // ReportedSeverity - READ-ONLY; Assessed recommendation severity. Possible values include: 'Informational', 'Low', 'Medium', 'High' + // ReportedSeverity - READ-ONLY; Assessed recommendation severity. Possible values include: 'ReportedSeverityInformational', 'ReportedSeverityLow', 'ReportedSeverityMedium', 'ReportedSeverityHigh' ReportedSeverity ReportedSeverity `json:"reportedSeverity,omitempty"` // DevicesCount - READ-ONLY; Number of devices with this recommendation. DevicesCount *int32 `json:"devicesCount,omitempty"` diff --git a/services/preview/security/mgmt/v3.0/security/securityapi/interfaces.go b/services/preview/security/mgmt/v3.0/security/securityapi/interfaces.go index 8be8f8406950..bbf35bd7838e 100644 --- a/services/preview/security/mgmt/v3.0/security/securityapi/interfaces.go +++ b/services/preview/security/mgmt/v3.0/security/securityapi/interfaces.go @@ -309,3 +309,21 @@ type AutomationsClientAPI interface { } var _ AutomationsClientAPI = (*security.AutomationsClient)(nil) + +// AssessmentsMetadataClientAPI contains the set of methods on the AssessmentsMetadataClient type. +type AssessmentsMetadataClientAPI interface { + Get(ctx context.Context, assessmentMetadataName string) (result security.AssessmentMetadata, err error) + List(ctx context.Context) (result security.AssessmentMetadataListPage, err error) +} + +var _ AssessmentsMetadataClientAPI = (*security.AssessmentsMetadataClient)(nil) + +// AssessmentsMetadataSubscriptionClientAPI contains the set of methods on the AssessmentsMetadataSubscriptionClient type. +type AssessmentsMetadataSubscriptionClientAPI interface { + Create(ctx context.Context, assessmentMetadataName string, assessmentMetadata security.AssessmentMetadata) (result security.AssessmentMetadata, err error) + Delete(ctx context.Context, assessmentMetadataName string) (result autorest.Response, err error) + Get(ctx context.Context, assessmentMetadataName string) (result security.AssessmentMetadata, err error) + List(ctx context.Context) (result security.AssessmentMetadataListPage, err error) +} + +var _ AssessmentsMetadataSubscriptionClientAPI = (*security.AssessmentsMetadataSubscriptionClient)(nil)