diff --git a/.changelog/23531.txt b/.changelog/23531.txt new file mode 100644 index 000000000000..1ac734c96a7d --- /dev/null +++ b/.changelog/23531.txt @@ -0,0 +1,3 @@ +```release-note:new-resource +aws_connect_user_hierarchy_group +``` \ No newline at end of file diff --git a/internal/provider/provider.go b/internal/provider/provider.go index 740144a03e3f..112133e2d9b7 100644 --- a/internal/provider/provider.go +++ b/internal/provider/provider.go @@ -1095,6 +1095,7 @@ func Provider() *schema.Provider { "aws_connect_quick_connect": connect.ResourceQuickConnect(), "aws_connect_routing_profile": connect.ResourceRoutingProfile(), "aws_connect_security_profile": connect.ResourceSecurityProfile(), + "aws_connect_user_hierarchy_group": connect.ResourceUserHierarchyGroup(), "aws_connect_user_hierarchy_structure": connect.ResourceUserHierarchyStructure(), "aws_cur_report_definition": cur.ResourceReportDefinition(), diff --git a/internal/service/connect/user_hierarchy_group.go b/internal/service/connect/user_hierarchy_group.go new file mode 100644 index 000000000000..01dc6fb78334 --- /dev/null +++ b/internal/service/connect/user_hierarchy_group.go @@ -0,0 +1,308 @@ +package connect + +import ( + "context" + "fmt" + "log" + "strings" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/service/connect" + "github.com/hashicorp/aws-sdk-go-base/v2/awsv1shim/v2/tfawserr" + "github.com/hashicorp/terraform-plugin-sdk/v2/diag" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/schema" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/validation" + "github.com/hashicorp/terraform-provider-aws/internal/conns" + tftags "github.com/hashicorp/terraform-provider-aws/internal/tags" +) + +func ResourceUserHierarchyGroup() *schema.Resource { + return &schema.Resource{ + CreateContext: resourceUserHierarchyGroupCreate, + ReadContext: resourceUserHierarchyGroupRead, + UpdateContext: resourceUserHierarchyGroupUpdate, + DeleteContext: resourceUserHierarchyGroupDelete, + Importer: &schema.ResourceImporter{ + StateContext: schema.ImportStatePassthroughContext, + }, + Schema: map[string]*schema.Schema{ + "arn": { + Type: schema.TypeString, + Computed: true, + }, + "hierarchy_group_id": { + Type: schema.TypeString, + Computed: true, + }, + "hierarchy_path": { + Type: schema.TypeList, + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "level_one": func() *schema.Schema { + schema := connectUserHierarchyPathLevelSchema() + return schema + }(), + "level_two": func() *schema.Schema { + schema := connectUserHierarchyPathLevelSchema() + return schema + }(), + "level_three": func() *schema.Schema { + schema := connectUserHierarchyPathLevelSchema() + return schema + }(), + "level_four": func() *schema.Schema { + schema := connectUserHierarchyPathLevelSchema() + return schema + }(), + "level_five": func() *schema.Schema { + schema := connectUserHierarchyPathLevelSchema() + return schema + }(), + }, + }, + }, + "instance_id": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.StringLenBetween(1, 100), + }, + "level_id": { + Type: schema.TypeString, + Computed: true, + }, + "name": { + Type: schema.TypeString, + Required: true, + ValidateFunc: validation.StringLenBetween(1, 100), + }, + "parent_group_id": { + Type: schema.TypeString, + Optional: true, + ForceNew: true, + }, + "tags": tftags.TagsSchema(), + "tags_all": tftags.TagsSchemaComputed(), + }, + } +} + +// Each level shares the same schema +func connectUserHierarchyPathLevelSchema() *schema.Schema { + return &schema.Schema{ + Type: schema.TypeList, + Computed: true, + Elem: &schema.Resource{ + Schema: map[string]*schema.Schema{ + "arn": { + Type: schema.TypeString, + Computed: true, + }, + "id": { + Type: schema.TypeString, + Computed: true, + }, + "name": { + Type: schema.TypeString, + Computed: true, + }, + }, + }, + } +} + +func resourceUserHierarchyGroupCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { + conn := meta.(*conns.AWSClient).ConnectConn + defaultTagsConfig := meta.(*conns.AWSClient).DefaultTagsConfig + tags := defaultTagsConfig.MergeTags(tftags.New(d.Get("tags").(map[string]interface{}))) + + instanceID := d.Get("instance_id").(string) + userHierarchyGroupName := d.Get("name").(string) + + input := &connect.CreateUserHierarchyGroupInput{ + InstanceId: aws.String(instanceID), + Name: aws.String(userHierarchyGroupName), + } + + if v, ok := d.GetOk("parent_group_id"); ok { + input.ParentGroupId = aws.String(v.(string)) + } + + if len(tags) > 0 { + input.Tags = Tags(tags.IgnoreAWS()) + } + + log.Printf("[DEBUG] Creating Connect User Hierarchy Group %s", input) + output, err := conn.CreateUserHierarchyGroupWithContext(ctx, input) + + if err != nil { + return diag.FromErr(fmt.Errorf("error creating Connect User Hierarchy Group (%s): %w", userHierarchyGroupName, err)) + } + + if output == nil { + return diag.FromErr(fmt.Errorf("error creating Connect User Hierarchy Group (%s): empty output", userHierarchyGroupName)) + } + + d.SetId(fmt.Sprintf("%s:%s", instanceID, aws.StringValue(output.HierarchyGroupId))) + + return resourceUserHierarchyGroupRead(ctx, d, meta) +} + +func resourceUserHierarchyGroupRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { + conn := meta.(*conns.AWSClient).ConnectConn + defaultTagsConfig := meta.(*conns.AWSClient).DefaultTagsConfig + ignoreTagsConfig := meta.(*conns.AWSClient).IgnoreTagsConfig + + instanceID, userHierarchyGroupID, err := UserHierarchyGroupParseID(d.Id()) + + if err != nil { + return diag.FromErr(err) + } + + resp, err := conn.DescribeUserHierarchyGroupWithContext(ctx, &connect.DescribeUserHierarchyGroupInput{ + HierarchyGroupId: aws.String(userHierarchyGroupID), + InstanceId: aws.String(instanceID), + }) + + if !d.IsNewResource() && tfawserr.ErrCodeEquals(err, connect.ErrCodeResourceNotFoundException) { + log.Printf("[WARN] Connect User Hierarchy Group (%s) not found, removing from state", d.Id()) + d.SetId("") + return nil + } + + if err != nil { + return diag.FromErr(fmt.Errorf("error getting Connect User Hierarchy Group (%s): %w", d.Id(), err)) + } + + if resp == nil || resp.HierarchyGroup == nil { + return diag.FromErr(fmt.Errorf("error getting Connect User Hierarchy Group (%s): empty response", d.Id())) + } + + d.Set("arn", resp.HierarchyGroup.Arn) + d.Set("hierarchy_group_id", resp.HierarchyGroup.Id) + d.Set("instance_id", instanceID) + d.Set("level_id", resp.HierarchyGroup.LevelId) + d.Set("name", resp.HierarchyGroup.Name) + + if err := d.Set("hierarchy_path", flattenUserHierarchyPath(resp.HierarchyGroup.HierarchyPath)); err != nil { + return diag.FromErr(fmt.Errorf("error setting Connect User Hierarchy Group hierarchy_path (%s): %w", d.Id(), err)) + } + + tags := KeyValueTags(resp.HierarchyGroup.Tags).IgnoreAWS().IgnoreConfig(ignoreTagsConfig) + + //lintignore:AWSR002 + if err := d.Set("tags", tags.RemoveDefaultConfig(defaultTagsConfig).Map()); err != nil { + return diag.FromErr(fmt.Errorf("error setting tags: %w", err)) + } + + if err := d.Set("tags_all", tags.Map()); err != nil { + return diag.FromErr(fmt.Errorf("error setting tags_all: %w", err)) + } + + return nil +} + +func resourceUserHierarchyGroupUpdate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { + conn := meta.(*conns.AWSClient).ConnectConn + + instanceID, userHierarchyGroupID, err := UserHierarchyGroupParseID(d.Id()) + + if err != nil { + return diag.FromErr(err) + } + + if d.HasChange("name") { + _, err = conn.UpdateUserHierarchyGroupNameWithContext(ctx, &connect.UpdateUserHierarchyGroupNameInput{ + HierarchyGroupId: aws.String(userHierarchyGroupID), + InstanceId: aws.String(instanceID), + Name: aws.String(d.Get("name").(string)), + }) + if err != nil { + return diag.FromErr(fmt.Errorf("[ERROR] Error updating User Hierarchy Group (%s): %w", d.Id(), err)) + } + } + + if d.HasChange("tags_all") { + o, n := d.GetChange("tags_all") + if err := UpdateTags(conn, d.Id(), o, n); err != nil { + return diag.FromErr(fmt.Errorf("error updating tags: %w", err)) + } + } + + return resourceUserHierarchyGroupRead(ctx, d, meta) +} + +func resourceUserHierarchyGroupDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics { + conn := meta.(*conns.AWSClient).ConnectConn + + instanceID, userHierarchyGroupID, err := UserHierarchyGroupParseID(d.Id()) + + if err != nil { + return diag.FromErr(err) + } + + _, err = conn.DeleteUserHierarchyGroupWithContext(ctx, &connect.DeleteUserHierarchyGroupInput{ + HierarchyGroupId: aws.String(userHierarchyGroupID), + InstanceId: aws.String(instanceID), + }) + + if err != nil { + return diag.FromErr(fmt.Errorf("error deleting User Hierarchy Group (%s): %w", d.Id(), err)) + } + + return nil +} + +func UserHierarchyGroupParseID(id string) (string, string, error) { + parts := strings.SplitN(id, ":", 2) + + if len(parts) != 2 || parts[0] == "" || parts[1] == "" { + return "", "", fmt.Errorf("unexpected format of ID (%s), expected instanceID:userHierarchyGroupID", id) + } + + return parts[0], parts[1], nil +} + +func flattenUserHierarchyPath(userHierarchyPath *connect.HierarchyPath) []interface{} { + if userHierarchyPath == nil { + return []interface{}{} + } + + values := map[string]interface{}{} + + if userHierarchyPath.LevelOne != nil { + values["level_one"] = flattenUserHierarchyPathLevel(userHierarchyPath.LevelOne) + } + + if userHierarchyPath.LevelTwo != nil { + values["level_two"] = flattenUserHierarchyPathLevel(userHierarchyPath.LevelTwo) + } + + if userHierarchyPath.LevelThree != nil { + values["level_three"] = flattenUserHierarchyPathLevel(userHierarchyPath.LevelThree) + } + + if userHierarchyPath.LevelFour != nil { + values["level_four"] = flattenUserHierarchyPathLevel(userHierarchyPath.LevelFour) + } + + if userHierarchyPath.LevelFive != nil { + values["level_five"] = flattenUserHierarchyPathLevel(userHierarchyPath.LevelFive) + } + + return []interface{}{values} +} + +func flattenUserHierarchyPathLevel(userHierarchyPathLevel *connect.HierarchyGroupSummary) []interface{} { + if userHierarchyPathLevel == nil { + return []interface{}{} + } + + level := map[string]interface{}{ + "arn": aws.StringValue(userHierarchyPathLevel.Arn), + "id": aws.StringValue(userHierarchyPathLevel.Id), + "name": aws.StringValue(userHierarchyPathLevel.Name), + } + + return []interface{}{level} +} diff --git a/internal/service/connect/user_hierarchy_group_test.go b/internal/service/connect/user_hierarchy_group_test.go new file mode 100644 index 000000000000..410de7c4f653 --- /dev/null +++ b/internal/service/connect/user_hierarchy_group_test.go @@ -0,0 +1,301 @@ +package connect_test + +import ( + "fmt" + "testing" + + "github.com/aws/aws-sdk-go/aws" + "github.com/aws/aws-sdk-go/aws/awserr" + "github.com/aws/aws-sdk-go/service/connect" + sdkacctest "github.com/hashicorp/terraform-plugin-sdk/v2/helper/acctest" + "github.com/hashicorp/terraform-plugin-sdk/v2/helper/resource" + "github.com/hashicorp/terraform-plugin-sdk/v2/terraform" + "github.com/hashicorp/terraform-provider-aws/internal/acctest" + "github.com/hashicorp/terraform-provider-aws/internal/conns" + tfconnect "github.com/hashicorp/terraform-provider-aws/internal/service/connect" +) + +//Serialized acceptance tests due to Connect account limits (max 2 parallel tests) +func TestAccConnectUserHierarchyGroup_serial(t *testing.T) { + testCases := map[string]func(t *testing.T){ + "basic": testAccUserHierarchyGroup_basic, + "disappears": testAccUserHierarchyGroup_disappears, + "set_parent_group_id": testAccUserHierarchyGroup_parentGroupId, + } + + for name, tc := range testCases { + tc := tc + t.Run(name, func(t *testing.T) { + tc(t) + }) + } +} + +func testAccUserHierarchyGroup_basic(t *testing.T) { + var v connect.DescribeUserHierarchyGroupOutput + rName := sdkacctest.RandomWithPrefix("resource-test-terraform") + rName2 := sdkacctest.RandomWithPrefix("resource-test-terraform") + rName3 := sdkacctest.RandomWithPrefix("resource-test-terraform") + resourceName := "aws_connect_user_hierarchy_group.test" + + resource.Test(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(t) }, + ErrorCheck: acctest.ErrorCheck(t, connect.EndpointsID), + Providers: acctest.Providers, + CheckDestroy: testAccCheckUserHierarchyGroupDestroy, + Steps: []resource.TestStep{ + { + Config: testAccUserHierarchyGroupBasicConfig(rName, rName2), + Check: resource.ComposeTestCheckFunc( + testAccCheckUserHierarchyGroupExists(resourceName, &v), + resource.TestCheckResourceAttrSet(resourceName, "arn"), + resource.TestCheckResourceAttrSet(resourceName, "hierarchy_group_id"), + resource.TestCheckResourceAttr(resourceName, "hierarchy_path.#", "1"), + resource.TestCheckResourceAttrPair(resourceName, "hierarchy_path.0.level_one.0.arn", resourceName, "arn"), + resource.TestCheckResourceAttrPair(resourceName, "hierarchy_path.0.level_one.0.id", resourceName, "hierarchy_group_id"), + resource.TestCheckResourceAttrPair(resourceName, "hierarchy_path.0.level_one.0.name", resourceName, "name"), + resource.TestCheckResourceAttrPair(resourceName, "instance_id", "aws_connect_instance.test", "id"), + resource.TestCheckResourceAttr(resourceName, "level_id", "1"), + resource.TestCheckResourceAttr(resourceName, "name", rName2), + resource.TestCheckResourceAttr(resourceName, "tags.%", "1"), + resource.TestCheckResourceAttr(resourceName, "tags.Name", "Test User Hierarchy Group"), + ), + }, + { + ResourceName: resourceName, + ImportState: true, + ImportStateVerify: true, + }, + { + // Update name + Config: testAccUserHierarchyGroupBasicConfig(rName, rName3), + Check: resource.ComposeAggregateTestCheckFunc( + testAccCheckUserHierarchyGroupExists(resourceName, &v), + resource.TestCheckResourceAttrSet(resourceName, "arn"), + resource.TestCheckResourceAttrSet(resourceName, "hierarchy_group_id"), + resource.TestCheckResourceAttr(resourceName, "hierarchy_path.#", "1"), + resource.TestCheckResourceAttrPair(resourceName, "hierarchy_path.0.level_one.0.arn", resourceName, "arn"), + resource.TestCheckResourceAttrPair(resourceName, "hierarchy_path.0.level_one.0.id", resourceName, "hierarchy_group_id"), + resource.TestCheckResourceAttrPair(resourceName, "hierarchy_path.0.level_one.0.name", resourceName, "name"), + resource.TestCheckResourceAttrPair(resourceName, "instance_id", "aws_connect_instance.test", "id"), + resource.TestCheckResourceAttr(resourceName, "level_id", "1"), + resource.TestCheckResourceAttr(resourceName, "name", rName3), + resource.TestCheckResourceAttr(resourceName, "tags.%", "1"), + resource.TestCheckResourceAttr(resourceName, "tags.Name", "Test User Hierarchy Group"), + ), + }, + }, + }) +} + +func testAccUserHierarchyGroup_parentGroupId(t *testing.T) { + var v connect.DescribeUserHierarchyGroupOutput + rName := sdkacctest.RandomWithPrefix("resource-test-terraform") + rName2 := sdkacctest.RandomWithPrefix("resource-test-terraform") + rName3 := sdkacctest.RandomWithPrefix("resource-test-terraform") + resourceName := "aws_connect_user_hierarchy_group.test" + + resource.Test(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(t) }, + ErrorCheck: acctest.ErrorCheck(t, connect.EndpointsID), + Providers: acctest.Providers, + CheckDestroy: testAccCheckUserHierarchyGroupDestroy, + Steps: []resource.TestStep{ + { + Config: testAccUserHierarchyGroupParentGroupIdConfig(rName, rName2, rName3), + Check: resource.ComposeTestCheckFunc( + testAccCheckUserHierarchyGroupExists(resourceName, &v), + resource.TestCheckResourceAttrSet(resourceName, "arn"), + resource.TestCheckResourceAttrSet(resourceName, "hierarchy_group_id"), + resource.TestCheckResourceAttr(resourceName, "hierarchy_path.#", "1"), + resource.TestCheckResourceAttrPair(resourceName, "hierarchy_path.0.level_one.0.arn", "aws_connect_user_hierarchy_group.parent", "arn"), + resource.TestCheckResourceAttrPair(resourceName, "hierarchy_path.0.level_one.0.id", "aws_connect_user_hierarchy_group.parent", "hierarchy_group_id"), + resource.TestCheckResourceAttrPair(resourceName, "hierarchy_path.0.level_one.0.name", "aws_connect_user_hierarchy_group.parent", "name"), + resource.TestCheckResourceAttrPair(resourceName, "hierarchy_path.0.level_two.0.arn", resourceName, "arn"), + resource.TestCheckResourceAttrPair(resourceName, "hierarchy_path.0.level_two.0.id", resourceName, "hierarchy_group_id"), + resource.TestCheckResourceAttrPair(resourceName, "hierarchy_path.0.level_two.0.name", resourceName, "name"), + resource.TestCheckResourceAttrPair(resourceName, "instance_id", "aws_connect_instance.test", "id"), + resource.TestCheckResourceAttr(resourceName, "level_id", "2"), + resource.TestCheckResourceAttr(resourceName, "name", rName3), + resource.TestCheckResourceAttrPair(resourceName, "parent_group_id", "aws_connect_user_hierarchy_group.parent", "hierarchy_group_id"), + resource.TestCheckResourceAttr(resourceName, "tags.%", "1"), + resource.TestCheckResourceAttr(resourceName, "tags.Name", "Test User Hierarchy Group Child"), + ), + }, + }, + }) +} + +func testAccUserHierarchyGroup_disappears(t *testing.T) { + var v connect.DescribeUserHierarchyGroupOutput + rName := sdkacctest.RandomWithPrefix("resource-test-terraform") + rName2 := sdkacctest.RandomWithPrefix("resource-test-terraform") + resourceName := "aws_connect_user_hierarchy_group.test" + + resource.Test(t, resource.TestCase{ + PreCheck: func() { acctest.PreCheck(t) }, + ErrorCheck: acctest.ErrorCheck(t, connect.EndpointsID), + Providers: acctest.Providers, + CheckDestroy: testAccCheckUserHierarchyGroupDestroy, + Steps: []resource.TestStep{ + { + Config: testAccUserHierarchyGroupBasicConfig(rName, rName2), + Check: resource.ComposeTestCheckFunc( + testAccCheckUserHierarchyGroupExists(resourceName, &v), + acctest.CheckResourceDisappears(acctest.Provider, tfconnect.ResourceUserHierarchyGroup(), resourceName), + ), + ExpectNonEmptyPlan: true, + }, + }, + }) +} + +func testAccCheckUserHierarchyGroupExists(resourceName string, function *connect.DescribeUserHierarchyGroupOutput) resource.TestCheckFunc { + return func(s *terraform.State) error { + rs, ok := s.RootModule().Resources[resourceName] + if !ok { + return fmt.Errorf("Connect User Hierarchy Group not found: %s", resourceName) + } + + if rs.Primary.ID == "" { + return fmt.Errorf("Connect User Hierarchy Group ID not set") + } + instanceID, userHierarchyGroupID, err := tfconnect.UserHierarchyGroupParseID(rs.Primary.ID) + + if err != nil { + return err + } + + conn := acctest.Provider.Meta().(*conns.AWSClient).ConnectConn + + params := &connect.DescribeUserHierarchyGroupInput{ + HierarchyGroupId: aws.String(userHierarchyGroupID), + InstanceId: aws.String(instanceID), + } + + getFunction, err := conn.DescribeUserHierarchyGroup(params) + if err != nil { + return err + } + + *function = *getFunction + + return nil + } +} + +func testAccCheckUserHierarchyGroupDestroy(s *terraform.State) error { + for _, rs := range s.RootModule().Resources { + if rs.Type != "aws_connect_user_hierarchy_group" { + continue + } + + conn := acctest.Provider.Meta().(*conns.AWSClient).ConnectConn + + instanceID, userHierarchyGroupID, err := tfconnect.UserHierarchyGroupParseID(rs.Primary.ID) + + if err != nil { + return err + } + + params := &connect.DescribeUserHierarchyGroupInput{ + HierarchyGroupId: aws.String(userHierarchyGroupID), + InstanceId: aws.String(instanceID), + } + + _, experr := conn.DescribeUserHierarchyGroup(params) + // Verify the error is what we want + if experr != nil { + if awsErr, ok := experr.(awserr.Error); ok && awsErr.Code() == "ResourceNotFoundException" { + continue + } + return experr + } + } + return nil +} + +func testAccUserHierarchyGroupBaseConfig(rName string) string { + return fmt.Sprintf(` +resource "aws_connect_instance" "test" { + identity_management_type = "CONNECT_MANAGED" + inbound_calls_enabled = true + instance_alias = %[1]q + outbound_calls_enabled = true +} + +resource "aws_connect_user_hierarchy_structure" "test" { + instance_id = aws_connect_instance.test.id + + hierarchy_structure { + level_one { + name = "levelone" + } + + level_two { + name = "leveltwo" + } + + level_three { + name = "levelthree" + } + + level_four { + name = "levelfour" + } + + level_five { + name = "levelfive" + } + } +} +`, rName) +} + +func testAccUserHierarchyGroupBasicConfig(rName, rName2 string) string { + return acctest.ConfigCompose( + testAccUserHierarchyGroupBaseConfig(rName), + fmt.Sprintf(` +resource "aws_connect_user_hierarchy_group" "test" { + instance_id = aws_connect_instance.test.id + name = %[1]q + + tags = { + "Name" = "Test User Hierarchy Group" + } + + depends_on = [ + aws_connect_user_hierarchy_structure.test, + ] +} +`, rName2)) +} + +func testAccUserHierarchyGroupParentGroupIdConfig(rName, rName2, rName3 string) string { + return acctest.ConfigCompose( + testAccUserHierarchyGroupBaseConfig(rName), + fmt.Sprintf(` +resource "aws_connect_user_hierarchy_group" "parent" { + instance_id = aws_connect_instance.test.id + name = %[1]q + + tags = { + "Name" = "Test User Hierarchy Group Parent" + } + + depends_on = [ + aws_connect_user_hierarchy_structure.test, + ] +} + +resource "aws_connect_user_hierarchy_group" "test" { + instance_id = aws_connect_instance.test.id + name = %[2]q + parent_group_id = aws_connect_user_hierarchy_group.parent.hierarchy_group_id + + tags = { + "Name" = "Test User Hierarchy Group Child" + } +} +`, rName2, rName3)) +} diff --git a/website/docs/r/connect_user_hierarchy_group.html.markdown b/website/docs/r/connect_user_hierarchy_group.html.markdown new file mode 100644 index 000000000000..a617929c7e65 --- /dev/null +++ b/website/docs/r/connect_user_hierarchy_group.html.markdown @@ -0,0 +1,97 @@ +--- +subcategory: "Connect" +layout: "aws" +page_title: "AWS: aws_connect_user_hierarchy_group" +description: |- + Provides details about a specific Amazon Connect User Hierarchy Group +--- + +# Resource: aws_connect_user_hierarchy_group + +Provides an Amazon Connect User Hierarchy Group resource. For more information see +[Amazon Connect: Getting Started](https://docs.aws.amazon.com/connect/latest/adminguide/amazon-connect-get-started.html) + +~> **NOTE:** The User Hierarchy Structure must be created before creating a User Hierarchy Group. + +## Example Usage + +### Basic + +```terraform +resource "aws_connect_user_hierarchy_group" "example" { + instance_id = "aaaaaaaa-bbbb-cccc-dddd-111111111111" + name = "example" + + tags = { + "Name" = "Example User Hierarchy Group" + } +} +``` + +### With a parent group + +```terraform +resource "aws_connect_user_hierarchy_group" "parent" { + instance_id = "aaaaaaaa-bbbb-cccc-dddd-111111111111" + name = "parent" + + tags = { + "Name" = "Example User Hierarchy Group Parent" + } +} + +resource "aws_connect_user_hierarchy_group" "child" { + instance_id = "aaaaaaaa-bbbb-cccc-dddd-111111111111" + name = "child" + parent_group_id = aws_connect_user_hierarchy_group.parent.hierarchy_group_id + + tags = { + "Name" = "Example User Hierarchy Group Child" + } +} +``` + +## Argument Reference + +The following arguments are supported: + +* `instance_id` - (Required) Specifies the identifier of the hosting Amazon Connect Instance. +* `name` - (Required) The name of the user hierarchy group. Must not be more than 100 characters. +* `parent_group_id` - (Optional) The identifier for the parent hierarchy group. The user hierarchy is created at level one if the parent group ID is null. +* `tags` - (Optional) Tags to apply to the hierarchy group. If configured with a provider +[`default_tags` configuration block](/docs/providers/aws/index.html#default_tags-configuration-block) present, tags with matching keys will overwrite those defined at the provider-level. + + +## Attributes Reference + +In addition to all arguments above, the following attributes are exported: + +* `arn` - The Amazon Resource Name (ARN) of the hierarchy group. +* `hierarchy_group_id` - The identifier for the hierarchy group. +* `hierarchy_path` - A block that contains information about the levels in the hierarchy group. The `hierarchy_path` block is documented below. +* `id` - The identifier of the hosting Amazon Connect Instance and identifier of the hierarchy group +separated by a colon (`:`). +* `level_id` - The identifier of the level in the hierarchy group. +* `tags_all` - A map of tags assigned to the resource, including those inherited from the provider [`default_tags` configuration block](/docs/providers/aws/index.html#default_tags-configuration-block). + +A `hierarchy_path` block supports the following attributes: + +* `level_one` - A block that defines the details of level one. The level block is documented below. +* `level_two` - A block that defines the details of level two. The level block is documented below. +* `level_three` - A block that defines the details of level three. The level block is documented below. +* `level_four` - A block that defines the details of level four. The level block is documented below. +* `level_five` - A block that defines the details of level five. The level block is documented below. + +A level block supports the following attributes: + +* `arn` - The Amazon Resource Name (ARN) of the hierarchy group. +* `id` - The identifier of the hierarchy group. +* `name` - The name of the hierarchy group. + +## Import + +Amazon Connect User Hierarchy Groups can be imported using the `instance_id` and `hierarchy_group_id` separated by a colon (`:`), e.g., + +``` +$ terraform import aws_connect_user_hierarchy_group.example f1288a1f-6193-445a-b47e-af739b2:c1d4e5f6-1b3c-1b3c-1b3c-c1d4e5f6c1d4e5 +```