From 4fcf4c154135cbabbed60fded4558c98dd21128f Mon Sep 17 00:00:00 2001 From: Modular Magician Date: Mon, 12 Jun 2023 16:35:22 +0000 Subject: [PATCH] Added multiple sensitivity_score fields in google_data_loss_prevention_job_trigger (#8114) * Added multiple sensitivity_score fields in google_data_loss_prevention_job_trigger * Adjusted the whitespaces in the test file Signed-off-by: Modular Magician --- .changelog/8114.txt | 3 + ...e_data_loss_prevention_job_trigger_test.go | 433 ++++++++++++++++++ ...source_data_loss_prevention_job_trigger.go | 412 ++++++++++++++++- ..._loss_prevention_job_trigger.html.markdown | 77 ++++ 4 files changed, 912 insertions(+), 13 deletions(-) create mode 100644 .changelog/8114.txt diff --git a/.changelog/8114.txt b/.changelog/8114.txt new file mode 100644 index 00000000000..f097957deda --- /dev/null +++ b/.changelog/8114.txt @@ -0,0 +1,3 @@ +```release-note:enhancement +dlp: added multiple `sensitivity_score` field to `google_data_loss_prevention_job_trigger` resource +``` diff --git a/google/resource_data_loss_prevention_job_trigger_test.go b/google/resource_data_loss_prevention_job_trigger_test.go index 0b1922bb912..5ad3797ee99 100644 --- a/google/resource_data_loss_prevention_job_trigger_test.go +++ b/google/resource_data_loss_prevention_job_trigger_test.go @@ -445,6 +445,49 @@ func TestAccDataLossPreventionJobTrigger_dlpJobTriggerInspectOptionalExample(t * }) } +func TestAccDataLossPreventionJobTrigger_dlpJobTrigger_withSensitivityScore(t *testing.T) { + t.Parallel() + + context := map[string]interface{}{ + "project": acctest.GetTestProjectFromEnv(), + } + + VcrTest(t, resource.TestCase{ + PreCheck: func() { acctest.AccTestPreCheck(t) }, + ProtoV5ProviderFactories: ProtoV5ProviderFactories(t), + CheckDestroy: testAccCheckDataLossPreventionJobTriggerDestroyProducer(t), + Steps: []resource.TestStep{ + { + Config: testAccDataLossPreventionJobTrigger_dlpJobTrigger_withSensitivityScoreBasic(context), + }, + { + ResourceName: "google_data_loss_prevention_job_trigger.basic", + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"parent"}, + }, + { + Config: testAccDataLossPreventionJobTrigger_dlpJobTrigger_withSensitivityScoreUpdate(context), + }, + { + ResourceName: "google_data_loss_prevention_job_trigger.basic", + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"parent"}, + }, + { + Config: testAccDataLossPreventionJobTrigger_dlpJobTrigger_withSensitivityScoreUpdate2(context), + }, + { + ResourceName: "google_data_loss_prevention_job_trigger.basic", + ImportState: true, + ImportStateVerify: true, + ImportStateVerifyIgnore: []string{"parent"}, + }, + }, + }) +} + func testAccDataLossPreventionJobTrigger_dlpJobTriggerBasic(context map[string]interface{}) string { return Nprintf(` resource "google_data_loss_prevention_job_trigger" "basic" { @@ -2320,3 +2363,393 @@ resource "google_data_loss_prevention_job_trigger" "basic" { } `, context) } + +func testAccDataLossPreventionJobTrigger_dlpJobTrigger_withSensitivityScoreBasic(context map[string]interface{}) string { + return Nprintf(` +resource "google_data_loss_prevention_job_trigger" "basic" { + parent = "projects/%{project}" + description = "Starting description" + display_name = "display" + + triggers { + schedule { + recurrence_period_duration = "86400s" + } + } + + inspect_job { + inspect_template_name = "fake" + actions { + save_findings { + output_config { + table { + project_id = "project" + dataset_id = "dataset123" + } + } + } + } + storage_config { + cloud_storage_options { + file_set { + url = "gs://mybucket/directory/" + } + } + } + inspect_config { + custom_info_types { + info_type { + name = "MY_CUSTOM_TYPE" + sensitivity_score { + score = "SENSITIVITY_MODERATE" + } + } + sensitivity_score { + score = "SENSITIVITY_HIGH" + } + } + info_types { + name = "EMAIL_ADDRESS" + sensitivity_score { + score = "SENSITIVITY_LOW" + } + } + info_types { + name = "PERSON_NAME" + } + info_types { + name = "LAST_NAME" + } + info_types { + name = "DOMAIN_NAME" + } + info_types { + name = "PHONE_NUMBER" + } + info_types { + name = "FIRST_NAME" + } + + min_likelihood = "UNLIKELY" + include_quote = false + exclude_info_types = false + rule_set { + info_types { + name = "EMAIL_ADDRESS" + sensitivity_score { + score = "SENSITIVITY_LOW" + } + } + rules { + exclusion_rule { + regex { + pattern = ".+@example.com" + } + matching_type = "MATCHING_TYPE_FULL_MATCH" + } + } + } + rule_set { + info_types { + name = "EMAIL_ADDRESS" + } + info_types { + name = "DOMAIN_NAME" + } + info_types { + name = "PHONE_NUMBER" + } + info_types { + name = "PERSON_NAME" + } + info_types { + name = "FIRST_NAME" + } + rules { + exclusion_rule { + exclude_info_types { + info_types { + name = "LAST_NAME" + sensitivity_score { + score = "SENSITIVITY_HIGH" + } + } + } + matching_type = "MATCHING_TYPE_PARTIAL_MATCH" + } + } + } + + limits { + max_findings_per_item = 10 + max_findings_per_request = 50 + max_findings_per_info_type { + max_findings = "75" + info_type { + name = "PERSON_NAME" + sensitivity_score { + score = "SENSITIVITY_MODERATE" + } + } + } + } + } + } +} +`, context) +} + +func testAccDataLossPreventionJobTrigger_dlpJobTrigger_withSensitivityScoreUpdate(context map[string]interface{}) string { + return Nprintf(` +resource "google_data_loss_prevention_job_trigger" "basic" { + parent = "projects/%{project}" + description = "Starting description" + display_name = "display" + + triggers { + schedule { + recurrence_period_duration = "86400s" + } + } + + inspect_job { + inspect_template_name = "fake" + actions { + save_findings { + output_config { + table { + project_id = "project" + dataset_id = "dataset123" + } + } + } + } + storage_config { + cloud_storage_options { + file_set { + url = "gs://mybucket/directory/" + } + } + } + inspect_config { + custom_info_types { + info_type { + name = "MY_CUSTOM_TYPE" + } + sensitivity_score { + score = "SENSITIVITY_MODERATE" + } + } + info_types { + name = "EMAIL_ADDRESS" + } + info_types { + name = "PERSON_NAME" + } + info_types { + name = "LAST_NAME" + } + info_types { + name = "DOMAIN_NAME" + } + info_types { + name = "PHONE_NUMBER" + } + info_types { + name = "FIRST_NAME" + } + + min_likelihood = "UNLIKELY" + include_quote = false + exclude_info_types = false + rule_set { + info_types { + name = "EMAIL_ADDRESS" + sensitivity_score { + score = "SENSITIVITY_HIGH" + } + } + rules { + exclusion_rule { + regex { + pattern = ".+@example.com" + } + matching_type = "MATCHING_TYPE_FULL_MATCH" + } + } + } + rule_set { + info_types { + name = "EMAIL_ADDRESS" + } + info_types { + name = "DOMAIN_NAME" + } + info_types { + name = "PHONE_NUMBER" + } + info_types { + name = "PERSON_NAME" + } + info_types { + name = "FIRST_NAME" + } + rules { + exclusion_rule { + exclude_info_types { + info_types { + name = "LAST_NAME" + } + } + matching_type = "MATCHING_TYPE_PARTIAL_MATCH" + } + } + } + + limits { + max_findings_per_item = 10 + max_findings_per_request = 50 + max_findings_per_info_type { + max_findings = "75" + info_type { + name = "PERSON_NAME" + sensitivity_score { + score = "SENSITIVITY_LOW" + } + } + } + } + } + } +} +`, context) +} + +func testAccDataLossPreventionJobTrigger_dlpJobTrigger_withSensitivityScoreUpdate2(context map[string]interface{}) string { + return Nprintf(` +resource "google_data_loss_prevention_job_trigger" "basic" { + parent = "projects/%{project}" + description = "Starting description" + display_name = "display" + + triggers { + schedule { + recurrence_period_duration = "86400s" + } + } + + inspect_job { + inspect_template_name = "fake" + actions { + save_findings { + output_config { + table { + project_id = "project" + dataset_id = "dataset123" + } + } + } + } + storage_config { + cloud_storage_options { + file_set { + url = "gs://mybucket/directory/" + } + } + } + inspect_config { + custom_info_types { + info_type { + name = "MY_CUSTOM_TYPE" + sensitivity_score { + score = "SENSITIVITY_HIGH" + } + } + } + info_types { + name = "EMAIL_ADDRESS" + sensitivity_score { + score = "SENSITIVITY_MODERATE" + } + } + info_types { + name = "PERSON_NAME" + } + info_types { + name = "LAST_NAME" + } + info_types { + name = "DOMAIN_NAME" + } + info_types { + name = "PHONE_NUMBER" + } + info_types { + name = "FIRST_NAME" + } + + min_likelihood = "UNLIKELY" + include_quote = false + exclude_info_types = false + rule_set { + info_types { + name = "EMAIL_ADDRESS" + sensitivity_score { + score = "SENSITIVITY_MODERATE" + } + } + rules { + exclusion_rule { + regex { + pattern = ".+@example.com" + } + matching_type = "MATCHING_TYPE_FULL_MATCH" + } + } + } + rule_set { + info_types { + name = "EMAIL_ADDRESS" + } + info_types { + name = "DOMAIN_NAME" + } + info_types { + name = "PHONE_NUMBER" + } + info_types { + name = "PERSON_NAME" + } + info_types { + name = "FIRST_NAME" + } + rules { + exclusion_rule { + exclude_info_types { + info_types { + name = "LAST_NAME" + } + } + matching_type = "MATCHING_TYPE_PARTIAL_MATCH" + } + } + } + + limits { + max_findings_per_item = 10 + max_findings_per_request = 50 + max_findings_per_info_type { + max_findings = "75" + info_type { + name = "PERSON_NAME" + sensitivity_score { + score = "SENSITIVITY_HIGH" + } + } + } + } + } + } +} +`, context) +} diff --git a/google/services/datalossprevention/resource_data_loss_prevention_job_trigger.go b/google/services/datalossprevention/resource_data_loss_prevention_job_trigger.go index cd39accd128..0164dc23af6 100644 --- a/google/services/datalossprevention/resource_data_loss_prevention_job_trigger.go +++ b/google/services/datalossprevention/resource_data_loss_prevention_job_trigger.go @@ -739,6 +739,22 @@ treated as a custom info type.`, Description: `Name of the information type. Either a name of your choosing when creating a CustomInfoType, or one of the names listed at https://cloud.google.com/dlp/docs/infotypes-reference when specifying a built-in type.`, }, + "sensitivity_score": { + Type: schema.TypeList, + Optional: true, + Description: `Optional custom sensitivity for this InfoType. This only applies to data profiling.`, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "score": { + Type: schema.TypeString, + Required: true, + ValidateFunc: verify.ValidateEnum([]string{"SENSITIVITY_LOW", "SENSITIVITY_MODERATE", "SENSITIVITY_HIGH"}), + Description: `The sensitivity score applied to the resource. Possible values: ["SENSITIVITY_LOW", "SENSITIVITY_MODERATE", "SENSITIVITY_HIGH"]`, + }, + }, + }, + }, "version": { Type: schema.TypeString, Optional: true, @@ -829,6 +845,22 @@ Its syntax (https://github.com/google/re2/wiki/Syntax) can be found under the go }, }, }, + "sensitivity_score": { + Type: schema.TypeList, + Optional: true, + Description: `Optional custom sensitivity for this InfoType. This only applies to data profiling.`, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "score": { + Type: schema.TypeString, + Required: true, + ValidateFunc: verify.ValidateEnum([]string{"SENSITIVITY_LOW", "SENSITIVITY_MODERATE", "SENSITIVITY_HIGH"}), + Description: `The sensitivity score applied to the resource. Possible values: ["SENSITIVITY_LOW", "SENSITIVITY_MODERATE", "SENSITIVITY_HIGH"]`, + }, + }, + }, + }, "stored_type": { Type: schema.TypeList, Optional: true, @@ -888,6 +920,22 @@ By default this may be all types, but may change over time as detectors are upda Description: `Name of the information type. Either a name of your choosing when creating a CustomInfoType, or one of the names listed at https://cloud.google.com/dlp/docs/infotypes-reference when specifying a built-in type.`, }, + "sensitivity_score": { + Type: schema.TypeList, + Optional: true, + Description: `Optional custom sensitivity for this InfoType. This only applies to data profiling.`, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "score": { + Type: schema.TypeString, + Required: true, + ValidateFunc: verify.ValidateEnum([]string{"SENSITIVITY_LOW", "SENSITIVITY_MODERATE", "SENSITIVITY_HIGH"}), + Description: `The sensitivity score applied to the resource. Possible values: ["SENSITIVITY_LOW", "SENSITIVITY_MODERATE", "SENSITIVITY_HIGH"]`, + }, + }, + }, + }, "version": { Type: schema.TypeString, Optional: true, @@ -924,6 +972,22 @@ specified in another InfoTypeLimit.`, Description: `Name of the information type. Either a name of your choosing when creating a CustomInfoType, or one of the names listed at https://cloud.google.com/dlp/docs/infotypes-reference when specifying a built-in type.`, }, + "sensitivity_score": { + Type: schema.TypeList, + Optional: true, + Description: `Optional custom sensitivity for this InfoType. This only applies to data profiling.`, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "score": { + Type: schema.TypeString, + Required: true, + ValidateFunc: verify.ValidateEnum([]string{"SENSITIVITY_LOW", "SENSITIVITY_MODERATE", "SENSITIVITY_HIGH"}), + Description: `The sensitivity score applied to the resource. Possible values: ["SENSITIVITY_LOW", "SENSITIVITY_MODERATE", "SENSITIVITY_HIGH"]`, + }, + }, + }, + }, "version": { Type: schema.TypeString, Optional: true, @@ -1111,6 +1175,22 @@ office using the hotword regex '(xxx)', where 'xxx' is the area code in question Description: `Name of the information type. Either a name of your choosing when creating a CustomInfoType, or one of the names listed at https://cloud.google.com/dlp/docs/infotypes-reference when specifying a built-in type.`, }, + "sensitivity_score": { + Type: schema.TypeList, + Optional: true, + Description: `Optional custom sensitivity for this InfoType. This only applies to data profiling.`, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "score": { + Type: schema.TypeString, + Required: true, + ValidateFunc: verify.ValidateEnum([]string{"SENSITIVITY_LOW", "SENSITIVITY_MODERATE", "SENSITIVITY_HIGH"}), + Description: `The sensitivity score applied to the resource. Possible values: ["SENSITIVITY_LOW", "SENSITIVITY_MODERATE", "SENSITIVITY_HIGH"]`, + }, + }, + }, + }, "version": { Type: schema.TypeString, Optional: true, @@ -1249,6 +1329,22 @@ office using the hotword regex '(xxx)', where 'xxx' is the area code in question Description: `Name of the information type. Either a name of your choosing when creating a CustomInfoType, or one of the names listed at https://cloud.google.com/dlp/docs/infotypes-reference when specifying a built-in type.`, }, + "sensitivity_score": { + Type: schema.TypeList, + Optional: true, + Description: `Optional custom sensitivity for this InfoType. This only applies to data profiling.`, + MaxItems: 1, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "score": { + Type: schema.TypeString, + Required: true, + ValidateFunc: verify.ValidateEnum([]string{"SENSITIVITY_LOW", "SENSITIVITY_MODERATE", "SENSITIVITY_HIGH"}), + Description: `The sensitivity score applied to the resource. Possible values: ["SENSITIVITY_LOW", "SENSITIVITY_MODERATE", "SENSITIVITY_HIGH"]`, + }, + }, + }, + }, "version": { Type: schema.TypeString, Optional: true, @@ -1845,6 +1941,8 @@ func flattenDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindings flattenDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeName(original["name"], d, config) transformed["version"] = flattenDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeVersion(original["version"], d, config) + transformed["sensitivity_score"] = + flattenDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeSensitivityScore(original["sensitivityScore"], d, config) return []interface{}{transformed} } func flattenDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeName(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { @@ -1855,6 +1953,23 @@ func flattenDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindings return v } +func flattenDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeSensitivityScore(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { + if v == nil { + return nil + } + original := v.(map[string]interface{}) + if len(original) == 0 { + return nil + } + transformed := make(map[string]interface{}) + transformed["score"] = + flattenDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeSensitivityScoreScore(original["score"], d, config) + return []interface{}{transformed} +} +func flattenDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeSensitivityScoreScore(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { + return v +} + func flattenDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindingsPerInfoTypeMaxFindings(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { // Handles the string fixed64 format if strVal, ok := v.(string); ok { @@ -1885,8 +2000,9 @@ func flattenDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypes(v inter continue } transformed = append(transformed, map[string]interface{}{ - "name": flattenDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypesName(original["name"], d, config), - "version": flattenDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypesVersion(original["version"], d, config), + "name": flattenDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypesName(original["name"], d, config), + "version": flattenDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypesVersion(original["version"], d, config), + "sensitivity_score": flattenDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypesSensitivityScore(original["sensitivityScore"], d, config), }) } return transformed @@ -1899,6 +2015,23 @@ func flattenDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypesVersion( return v } +func flattenDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypesSensitivityScore(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { + if v == nil { + return nil + } + original := v.(map[string]interface{}) + if len(original) == 0 { + return nil + } + transformed := make(map[string]interface{}) + transformed["score"] = + flattenDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypesSensitivityScoreScore(original["score"], d, config) + return []interface{}{transformed} +} +func flattenDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypesSensitivityScoreScore(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { + return v +} + func flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSet(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { if v == nil { return v @@ -1931,8 +2064,9 @@ func flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypes( continue } transformed = append(transformed, map[string]interface{}{ - "name": flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypesName(original["name"], d, config), - "version": flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypesVersion(original["version"], d, config), + "name": flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypesName(original["name"], d, config), + "version": flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypesVersion(original["version"], d, config), + "sensitivity_score": flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypesSensitivityScore(original["sensitivityScore"], d, config), }) } return transformed @@ -1945,6 +2079,23 @@ func flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypesV return v } +func flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypesSensitivityScore(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { + if v == nil { + return nil + } + original := v.(map[string]interface{}) + if len(original) == 0 { + return nil + } + transformed := make(map[string]interface{}) + transformed["score"] = + flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypesSensitivityScoreScore(original["score"], d, config) + return []interface{}{transformed} +} +func flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypesSensitivityScoreScore(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { + return v +} + func flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRules(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { if v == nil { return v @@ -2212,8 +2363,9 @@ func flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclu continue } transformed = append(transformed, map[string]interface{}{ - "name": flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclusionRuleExcludeInfoTypesInfoTypesName(original["name"], d, config), - "version": flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclusionRuleExcludeInfoTypesInfoTypesVersion(original["version"], d, config), + "name": flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclusionRuleExcludeInfoTypesInfoTypesName(original["name"], d, config), + "version": flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclusionRuleExcludeInfoTypesInfoTypesVersion(original["version"], d, config), + "sensitivity_score": flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclusionRuleExcludeInfoTypesInfoTypesSensitivityScore(original["sensitivityScore"], d, config), }) } return transformed @@ -2226,6 +2378,23 @@ func flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclu return v } +func flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclusionRuleExcludeInfoTypesInfoTypesSensitivityScore(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { + if v == nil { + return nil + } + original := v.(map[string]interface{}) + if len(original) == 0 { + return nil + } + transformed := make(map[string]interface{}) + transformed["score"] = + flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclusionRuleExcludeInfoTypesInfoTypesSensitivityScoreScore(original["score"], d, config) + return []interface{}{transformed} +} +func flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclusionRuleExcludeInfoTypesInfoTypesSensitivityScoreScore(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { + return v +} + func flattenDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclusionRuleExcludeByHotword(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { if v == nil { return nil @@ -2326,13 +2495,14 @@ func flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypes(v continue } transformed = append(transformed, map[string]interface{}{ - "info_type": flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesInfoType(original["infoType"], d, config), - "likelihood": flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesLikelihood(original["likelihood"], d, config), - "exclusion_type": flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesExclusionType(original["exclusionType"], d, config), - "regex": flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesRegex(original["regex"], d, config), - "dictionary": flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesDictionary(original["dictionary"], d, config), - "stored_type": flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesStoredType(original["storedType"], d, config), - "surrogate_type": flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesSurrogateType(original["surrogateType"], d, config), + "info_type": flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesInfoType(original["infoType"], d, config), + "likelihood": flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesLikelihood(original["likelihood"], d, config), + "exclusion_type": flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesExclusionType(original["exclusionType"], d, config), + "sensitivity_score": flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesSensitivityScore(original["sensitivityScore"], d, config), + "regex": flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesRegex(original["regex"], d, config), + "dictionary": flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesDictionary(original["dictionary"], d, config), + "stored_type": flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesStoredType(original["storedType"], d, config), + "surrogate_type": flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesSurrogateType(original["surrogateType"], d, config), }) } return transformed @@ -2350,6 +2520,8 @@ func flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesIn flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesInfoTypeName(original["name"], d, config) transformed["version"] = flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesInfoTypeVersion(original["version"], d, config) + transformed["sensitivity_score"] = + flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesInfoTypeSensitivityScore(original["sensitivityScore"], d, config) return []interface{}{transformed} } func flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesInfoTypeName(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { @@ -2360,6 +2532,23 @@ func flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesIn return v } +func flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesInfoTypeSensitivityScore(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { + if v == nil { + return nil + } + original := v.(map[string]interface{}) + if len(original) == 0 { + return nil + } + transformed := make(map[string]interface{}) + transformed["score"] = + flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesInfoTypeSensitivityScoreScore(original["score"], d, config) + return []interface{}{transformed} +} +func flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesInfoTypeSensitivityScoreScore(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { + return v +} + func flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesLikelihood(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { return v } @@ -2368,6 +2557,23 @@ func flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesEx return v } +func flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesSensitivityScore(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { + if v == nil { + return nil + } + original := v.(map[string]interface{}) + if len(original) == 0 { + return nil + } + transformed := make(map[string]interface{}) + transformed["score"] = + flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesSensitivityScoreScore(original["score"], d, config) + return []interface{}{transformed} +} +func flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesSensitivityScoreScore(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { + return v +} + func flattenDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesRegex(v interface{}, d *schema.ResourceData, config *transport_tpg.Config) interface{} { if v == nil { return nil @@ -3467,6 +3673,13 @@ func expandDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindingsP transformed["version"] = transformedVersion } + transformedSensitivityScore, err := expandDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeSensitivityScore(original["sensitivity_score"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedSensitivityScore); val.IsValid() && !tpgresource.IsEmptyValue(val) { + transformed["sensitivityScore"] = transformedSensitivityScore + } + return transformed, nil } @@ -3478,6 +3691,29 @@ func expandDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindingsP return v, nil } +func expandDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeSensitivityScore(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { + l := v.([]interface{}) + if len(l) == 0 || l[0] == nil { + return nil, nil + } + raw := l[0] + original := raw.(map[string]interface{}) + transformed := make(map[string]interface{}) + + transformedScore, err := expandDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeSensitivityScoreScore(original["score"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedScore); val.IsValid() && !tpgresource.IsEmptyValue(val) { + transformed["score"] = transformedScore + } + + return transformed, nil +} + +func expandDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindingsPerInfoTypeInfoTypeSensitivityScoreScore(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { + return v, nil +} + func expandDataLossPreventionJobTriggerInspectJobInspectConfigLimitsMaxFindingsPerInfoTypeMaxFindings(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { return v, nil } @@ -3506,6 +3742,13 @@ func expandDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypes(v interf transformed["version"] = transformedVersion } + transformedSensitivityScore, err := expandDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypesSensitivityScore(original["sensitivity_score"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedSensitivityScore); val.IsValid() && !tpgresource.IsEmptyValue(val) { + transformed["sensitivityScore"] = transformedSensitivityScore + } + req = append(req, transformed) } return req, nil @@ -3519,6 +3762,29 @@ func expandDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypesVersion(v return v, nil } +func expandDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypesSensitivityScore(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { + l := v.([]interface{}) + if len(l) == 0 || l[0] == nil { + return nil, nil + } + raw := l[0] + original := raw.(map[string]interface{}) + transformed := make(map[string]interface{}) + + transformedScore, err := expandDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypesSensitivityScoreScore(original["score"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedScore); val.IsValid() && !tpgresource.IsEmptyValue(val) { + transformed["score"] = transformedScore + } + + return transformed, nil +} + +func expandDataLossPreventionJobTriggerInspectJobInspectConfigInfoTypesSensitivityScoreScore(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { + return v, nil +} + func expandDataLossPreventionJobTriggerInspectJobInspectConfigRuleSet(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { l := v.([]interface{}) req := make([]interface{}, 0, len(l)) @@ -3572,6 +3838,13 @@ func expandDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypes(v transformed["version"] = transformedVersion } + transformedSensitivityScore, err := expandDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypesSensitivityScore(original["sensitivity_score"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedSensitivityScore); val.IsValid() && !tpgresource.IsEmptyValue(val) { + transformed["sensitivityScore"] = transformedSensitivityScore + } + req = append(req, transformed) } return req, nil @@ -3585,6 +3858,29 @@ func expandDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypesVe return v, nil } +func expandDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypesSensitivityScore(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { + l := v.([]interface{}) + if len(l) == 0 || l[0] == nil { + return nil, nil + } + raw := l[0] + original := raw.(map[string]interface{}) + transformed := make(map[string]interface{}) + + transformedScore, err := expandDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypesSensitivityScoreScore(original["score"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedScore); val.IsValid() && !tpgresource.IsEmptyValue(val) { + transformed["score"] = transformedScore + } + + return transformed, nil +} + +func expandDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetInfoTypesSensitivityScoreScore(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { + return v, nil +} + func expandDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRules(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { l := v.([]interface{}) req := make([]interface{}, 0, len(l)) @@ -3949,6 +4245,13 @@ func expandDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclus transformed["version"] = transformedVersion } + transformedSensitivityScore, err := expandDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclusionRuleExcludeInfoTypesInfoTypesSensitivityScore(original["sensitivity_score"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedSensitivityScore); val.IsValid() && !tpgresource.IsEmptyValue(val) { + transformed["sensitivityScore"] = transformedSensitivityScore + } + req = append(req, transformed) } return req, nil @@ -3962,6 +4265,29 @@ func expandDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclus return v, nil } +func expandDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclusionRuleExcludeInfoTypesInfoTypesSensitivityScore(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { + l := v.([]interface{}) + if len(l) == 0 || l[0] == nil { + return nil, nil + } + raw := l[0] + original := raw.(map[string]interface{}) + transformed := make(map[string]interface{}) + + transformedScore, err := expandDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclusionRuleExcludeInfoTypesInfoTypesSensitivityScoreScore(original["score"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedScore); val.IsValid() && !tpgresource.IsEmptyValue(val) { + transformed["score"] = transformedScore + } + + return transformed, nil +} + +func expandDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclusionRuleExcludeInfoTypesInfoTypesSensitivityScoreScore(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { + return v, nil +} + func expandDataLossPreventionJobTriggerInspectJobInspectConfigRuleSetRulesExclusionRuleExcludeByHotword(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { l := v.([]interface{}) if len(l) == 0 || l[0] == nil { @@ -4087,6 +4413,13 @@ func expandDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypes(v transformed["exclusionType"] = transformedExclusionType } + transformedSensitivityScore, err := expandDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesSensitivityScore(original["sensitivity_score"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedSensitivityScore); val.IsValid() && !tpgresource.IsEmptyValue(val) { + transformed["sensitivityScore"] = transformedSensitivityScore + } + transformedRegex, err := expandDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesRegex(original["regex"], d, config) if err != nil { return nil, err @@ -4143,6 +4476,13 @@ func expandDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesInf transformed["version"] = transformedVersion } + transformedSensitivityScore, err := expandDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesInfoTypeSensitivityScore(original["sensitivity_score"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedSensitivityScore); val.IsValid() && !tpgresource.IsEmptyValue(val) { + transformed["sensitivityScore"] = transformedSensitivityScore + } + return transformed, nil } @@ -4154,6 +4494,29 @@ func expandDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesInf return v, nil } +func expandDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesInfoTypeSensitivityScore(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { + l := v.([]interface{}) + if len(l) == 0 || l[0] == nil { + return nil, nil + } + raw := l[0] + original := raw.(map[string]interface{}) + transformed := make(map[string]interface{}) + + transformedScore, err := expandDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesInfoTypeSensitivityScoreScore(original["score"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedScore); val.IsValid() && !tpgresource.IsEmptyValue(val) { + transformed["score"] = transformedScore + } + + return transformed, nil +} + +func expandDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesInfoTypeSensitivityScoreScore(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { + return v, nil +} + func expandDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesLikelihood(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { return v, nil } @@ -4162,6 +4525,29 @@ func expandDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesExc return v, nil } +func expandDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesSensitivityScore(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { + l := v.([]interface{}) + if len(l) == 0 || l[0] == nil { + return nil, nil + } + raw := l[0] + original := raw.(map[string]interface{}) + transformed := make(map[string]interface{}) + + transformedScore, err := expandDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesSensitivityScoreScore(original["score"], d, config) + if err != nil { + return nil, err + } else if val := reflect.ValueOf(transformedScore); val.IsValid() && !tpgresource.IsEmptyValue(val) { + transformed["score"] = transformedScore + } + + return transformed, nil +} + +func expandDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesSensitivityScoreScore(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { + return v, nil +} + func expandDataLossPreventionJobTriggerInspectJobInspectConfigCustomInfoTypesRegex(v interface{}, d tpgresource.TerraformResourceData, config *transport_tpg.Config) (interface{}, error) { l := v.([]interface{}) if len(l) == 0 || l[0] == nil { diff --git a/website/docs/r/data_loss_prevention_job_trigger.html.markdown b/website/docs/r/data_loss_prevention_job_trigger.html.markdown index 00443bbcefb..ab073c0dded 100644 --- a/website/docs/r/data_loss_prevention_job_trigger.html.markdown +++ b/website/docs/r/data_loss_prevention_job_trigger.html.markdown @@ -597,6 +597,19 @@ The following arguments are supported: (Optional) Version of the information type to use. By default, the version is set to stable +* `sensitivity_score` - + (Optional) + Optional custom sensitivity for this InfoType. This only applies to data profiling. + Structure is [documented below](#nested_sensitivity_score). + + +The `sensitivity_score` block supports: + +* `score` - + (Required) + The sensitivity score applied to the resource. + Possible values are: `SENSITIVITY_LOW`, `SENSITIVITY_MODERATE`, `SENSITIVITY_HIGH`. + The `info_types` block supports: * `name` - @@ -608,6 +621,19 @@ The following arguments are supported: (Optional) Version of the information type to use. By default, the version is set to stable +* `sensitivity_score` - + (Optional) + Optional custom sensitivity for this InfoType. This only applies to data profiling. + Structure is [documented below](#nested_sensitivity_score). + + +The `sensitivity_score` block supports: + +* `score` - + (Required) + The sensitivity score applied to the resource. + Possible values are: `SENSITIVITY_LOW`, `SENSITIVITY_MODERATE`, `SENSITIVITY_HIGH`. + The `rule_set` block supports: * `info_types` - @@ -632,6 +658,19 @@ The following arguments are supported: (Optional) Version of the information type to use. By default, the version is set to stable. +* `sensitivity_score` - + (Optional) + Optional custom sensitivity for this InfoType. This only applies to data profiling. + Structure is [documented below](#nested_sensitivity_score). + + +The `sensitivity_score` block supports: + +* `score` - + (Required) + The sensitivity score applied to the resource. + Possible values are: `SENSITIVITY_LOW`, `SENSITIVITY_MODERATE`, `SENSITIVITY_HIGH`. + The `rules` block supports: * `hotword_rule` - @@ -789,6 +828,19 @@ The following arguments are supported: (Optional) Version of the information type to use. By default, the version is set to stable. +* `sensitivity_score` - + (Optional) + Optional custom sensitivity for this InfoType. This only applies to data profiling. + Structure is [documented below](#nested_sensitivity_score). + + +The `sensitivity_score` block supports: + +* `score` - + (Required) + The sensitivity score applied to the resource. + Possible values are: `SENSITIVITY_LOW`, `SENSITIVITY_MODERATE`, `SENSITIVITY_HIGH`. + The `exclude_by_hotword` block supports: * `hotword_regex` - @@ -850,6 +902,11 @@ The following arguments are supported: If set to EXCLUSION_TYPE_EXCLUDE this infoType will not cause a finding to be returned. It still can be used for rules matching. Possible values are: `EXCLUSION_TYPE_EXCLUDE`. +* `sensitivity_score` - + (Optional) + Optional custom sensitivity for this InfoType. This only applies to data profiling. + Structure is [documented below](#nested_sensitivity_score). + * `regex` - (Optional) Regular expression which defines the rule. @@ -881,6 +938,26 @@ The following arguments are supported: (Optional) Version of the information type to use. By default, the version is set to stable. +* `sensitivity_score` - + (Optional) + Optional custom sensitivity for this InfoType. This only applies to data profiling. + Structure is [documented below](#nested_sensitivity_score). + + +The `sensitivity_score` block supports: + +* `score` - + (Required) + The sensitivity score applied to the resource. + Possible values are: `SENSITIVITY_LOW`, `SENSITIVITY_MODERATE`, `SENSITIVITY_HIGH`. + +The `sensitivity_score` block supports: + +* `score` - + (Required) + The sensitivity score applied to the resource. + Possible values are: `SENSITIVITY_LOW`, `SENSITIVITY_MODERATE`, `SENSITIVITY_HIGH`. + The `regex` block supports: * `pattern` -