merged

nutanix/data_source_nutanix_access_control_policies.go

@@ -309,7 +309,7 @@ func dataSourceNutanixAccessControlPoliciesRead(d *schema.ResourceData, meta int
 
 	metadata, filtersOk := d.GetOk("metadata")
 	if filtersOk {
-		req = buildDataSourceSubnetsMetadata(metadata.(*schema.Set))
+		req = buildDataSourceListMetadata(metadata.(*schema.Set))
 	}
 
 	resp, err := conn.V3.ListAccessControlPolicy(req)

nutanix/data_source_nutanix_access_control_policy_test.go

@@ -12,14 +12,13 @@ import (
 func TestAccNutanixAccessControlPolicyDataSource_basic(t *testing.T) {
 	name := acctest.RandomWithPrefix("accest-access-policy")
 	description := "Description of my access control policy"
-	uuidRole := "760dac6c-be97-4b24-adb0-e3c3026dc8d5"
 
 	resource.Test(t, resource.TestCase{
 		PreCheck:  func() { testAccPreCheck(t) },
 		Providers: testAccProviders,
 		Steps: []resource.TestStep{
 			{
-				Config: testAccAccessControlPolicyDataSourceConfig(uuidRole, name, description),
+				Config: testAccAccessControlPolicyDataSourceConfig(name, description),
 				Check: resource.ComposeTestCheckFunc(
 					resource.TestCheckResourceAttr(
 						"data.nutanix_access_control_policy.test", "name", name),
@@ -32,19 +31,27 @@ func TestAccNutanixAccessControlPolicyDataSource_basic(t *testing.T) {
 	})
 }
 
-func testAccAccessControlPolicyDataSourceConfig(uuidRole, name, description string) string {
+func testAccAccessControlPolicyDataSourceConfig(name, description string) string {
 	return fmt.Sprintf(`
+resource "nutanix_role" "test" {
+	name        = "test role"
+	description = "description role"
+	permission_reference_list {
+		kind = "permission"
+		uuid = "2e9988df-47ae-44ae-9114-ada346657b90"
+	}
+}
 resource "nutanix_access_control_policy" "test" {
 	name        = "%[1]s"
 	description = "%[2]s"
 	role_reference{
 		kind = "role"
-		uuid = "%[3]s"
+		uuid = nutanix_role.test.id
 	}
 }
 
 data "nutanix_access_control_policy" "test" {
 	access_control_policy_id = nutanix_access_control_policy.test.id
 }
-`, name, description, uuidRole)
+`, name, description)
 }

nutanix/data_source_nutanix_permission.go

@@ -0,0 +1,256 @@
+package nutanix
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	v3 "github.com/terraform-providers/terraform-provider-nutanix/client/v3"
+	"github.com/terraform-providers/terraform-provider-nutanix/utils"
+)
+
+func dataSourceNutanixPermission() *schema.Resource {
+	return &schema.Resource{
+		Read: dataSourceNutanixPermissionRead,
+		Schema: map[string]*schema.Schema{
+			"permission_id": {
+				Type:          schema.TypeString,
+				Optional:      true,
+				ConflictsWith: []string{"permission_name"},
+			},
+			"permission_name": {
+				Type:          schema.TypeString,
+				Optional:      true,
+				ConflictsWith: []string{"permission_id"},
+			},
+			"api_version": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"metadata": {
+				Type:     schema.TypeMap,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"last_update_time": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"kind": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"uuid": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"creation_time": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"spec_version": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"spec_hash": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"name": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
+			"categories": categoriesSchema(),
+			"owner_reference": {
+				Type:     schema.TypeMap,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"kind": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"uuid": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"name": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
+			"project_reference": {
+				Type:     schema.TypeMap,
+				Computed: true,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"kind": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"uuid": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"name": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+					},
+				},
+			},
+			"name": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"state": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"description": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"operation": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"kind": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+			"fields": {
+				Type:     schema.TypeList,
+				Computed: true,
+				MaxItems: 1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"field_mode": {
+							Type:     schema.TypeString,
+							Computed: true,
+						},
+						"field_name_list": {
+							Type:     schema.TypeList,
+							Computed: true,
+							Elem: &schema.Schema{
+								Type: schema.TypeString,
+							},
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func dataSourceNutanixPermissionRead(d *schema.ResourceData, meta interface{}) error {
+	// Get client connection
+	conn := meta.(*Client).API
+
+	permissionID, iok := d.GetOk("permission_id")
+	permissionName, rnOk := d.GetOk("permission_name")
+
+	if !iok && !rnOk {
+		return fmt.Errorf("please provide `permission_id` or `permission_name`")
+	}
+
+	var err error
+	var resp *v3.PermissionIntentResponse
+
+	if iok {
+		resp, err = conn.V3.GetPermission(permissionID.(string))
+	}
+	if rnOk {
+		resp, err = findPermissionByName(conn, permissionName.(string))
+	}
+	utils.PrintToJSON(resp, "Permission: ")
+	if err != nil {
+		return err
+	}
+
+	m, c := setRSEntityMetadata(resp.Metadata)
+
+	if err := d.Set("metadata", m); err != nil {
+		return err
+	}
+	if err := d.Set("categories", c); err != nil {
+		return err
+	}
+	if err := d.Set("project_reference", flattenReferenceValues(resp.Metadata.ProjectReference)); err != nil {
+		return err
+	}
+	if err := d.Set("owner_reference", flattenReferenceValues(resp.Metadata.OwnerReference)); err != nil {
+		return err
+	}
+	if err := d.Set("api_version", resp.APIVersion); err != nil {
+		return err
+	}
+
+	if status := resp.Status; status != nil {
+		if err := d.Set("name", utils.StringValue(resp.Status.Name)); err != nil {
+			return err
+		}
+		if err := d.Set("description", utils.StringValue(resp.Status.Description)); err != nil {
+			return err
+		}
+		if err := d.Set("state", utils.StringValue(resp.Status.State)); err != nil {
+			return err
+		}
+
+		if res := status.Resources; res != nil {
+			if err := d.Set("operation", utils.StringValue(res.Operation)); err != nil {
+				return err
+			}
+			if err := d.Set("kind", utils.StringValue(res.Kind)); err != nil {
+				return err
+			}
+			if err := d.Set("fields", flattenFieldsPermission(res.Fields)); err != nil {
+				return err
+			}
+		}
+	}
+	d.SetId(utils.StringValue(resp.Metadata.UUID))
+
+	return nil
+}
+
+func flattenFieldsPermission(fieldPermissions *v3.FieldsPermission) []map[string]interface{} {
+	flatFieldsPermissions := make([]map[string]interface{}, 0)
+	n := map[string]interface{}{
+		"field_mode":      fieldPermissions.FieldMode,
+		"field_name_list": fieldPermissions.FieldNameList,
+	}
+	flatFieldsPermissions = append(flatFieldsPermissions, n)
+	return flatFieldsPermissions
+}
+
+func findPermissionByName(conn *v3.Client, name string) (*v3.PermissionIntentResponse, error) {
+	filter := fmt.Sprintf("name==%s", name)
+	resp, err := conn.V3.ListAllPermission(filter)
+	if err != nil {
+		return nil, err
+	}
+
+	entities := resp.Entities
+
+	found := make([]*v3.PermissionIntentResponse, 0)
+	for _, v := range entities {
+		if *v.Spec.Name == name {
+			found = append(found, v)
+		}
+	}
+
+	if len(found) > 1 {
+		return nil, fmt.Errorf("your query returned more than one result. Please use permission_id argument instead")
+	}
+
+	if len(found) == 0 {
+		return nil, fmt.Errorf("permission with the given name, not found")
+	}
+	found[0].APIVersion = resp.APIVersion
+	return found[0], nil
+}

nutanix/data_source_nutanix_permission_test.go

@@ -0,0 +1,69 @@
+package nutanix
+
+import (
+	"fmt"
+	"testing"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/resource"
+)
+
+const (
+	PERMISSIONNAME = "Access_Console_Virtual_Machine"
+	PERMISSINOUUID = "16b81a55-2bca-48c6-9fab-4f82c6bb4284"
+)
+
+func TestAccNutanixPermissionDataSource_basic(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccPermissionDataSourceConfig(PERMISSINOUUID),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(
+						"data.nutanix_permission.test", "name", PERMISSIONNAME),
+					resource.TestCheckResourceAttr(
+						"data.nutanix_permission.test", "operation", "console_access"),
+					resource.TestCheckResourceAttr(
+						"data.nutanix_permission.test", "fields.0.field_mode", "DISALLOWED"),
+				),
+			},
+		},
+	})
+}
+
+func testAccPermissionDataSourceConfig(uuid string) string {
+	return fmt.Sprintf(`
+data "nutanix_permission" "test" {
+	permission_id = "%s"
+}
+`, uuid)
+}
+
+func TestAccNutanixPermissionDataSource_basicByName(t *testing.T) {
+	resource.Test(t, resource.TestCase{
+		PreCheck:  func() { testAccPreCheck(t) },
+		Providers: testAccProviders,
+		Steps: []resource.TestStep{
+			{
+				Config: testAccPermissionDataSourceConfigByName(PERMISSIONNAME),
+				Check: resource.ComposeTestCheckFunc(
+					resource.TestCheckResourceAttr(
+						"data.nutanix_permission.test", "name", PERMISSIONNAME),
+					resource.TestCheckResourceAttr(
+						"data.nutanix_permission.test", "operation", "console_access"),
+					resource.TestCheckResourceAttr(
+						"data.nutanix_permission.test", "fields.0.field_mode", "DISALLOWED"),
+				),
+			},
+		},
+	})
+}
+
+func testAccPermissionDataSourceConfigByName(name string) string {
+	return fmt.Sprintf(`
+data "nutanix_permission" "test" {
+	permission_name = "%s"
+}
+`, name)
+}