r/aws_connect_bot_association - add new resource

.changelog/21097.txt

@@ -0,0 +1,7 @@
+```release-note:new-data-source
+aws_connect_bot_association
+```
+
+```release-note:new-resource
+aws_connect_bot_association
+```

internal/provider/provider.go

@@ -394,8 +394,9 @@ func Provider() *schema.Provider {
 
 			"aws_cognito_user_pools": cognitoidp.DataSourceUserPools(),
 
-			"aws_connect_contact_flow": connect.DataSourceContactFlow(),
-			"aws_connect_instance":     connect.DataSourceInstance(),
+			"aws_connect_bot_association": connect.DataSourceBotAssociation(),
+			"aws_connect_contact_flow":    connect.DataSourceContactFlow(),
+			"aws_connect_instance":        connect.DataSourceInstance(),
 
 			"aws_cur_report_definition": cur.DataSourceReportDefinition(),
 
@@ -926,8 +927,9 @@ func Provider() *schema.Provider {
 			"aws_config_organization_managed_rule":     config.ResourceOrganizationManagedRule(),
 			"aws_config_remediation_configuration":     config.ResourceRemediationConfiguration(),
 
-			"aws_connect_contact_flow": connect.ResourceContactFlow(),
-			"aws_connect_instance":     connect.ResourceInstance(),
+			"aws_connect_bot_association": connect.ResourceBotAssociation(),
+			"aws_connect_contact_flow":    connect.ResourceContactFlow(),
+			"aws_connect_instance":        connect.ResourceInstance(),
 
 			"aws_cur_report_definition": cur.ResourceReportDefinition(),
 

internal/service/connect/bot_association.go

@@ -0,0 +1,222 @@
+package connect
+
+import (
+	"context"
+	"fmt"
+	"log"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"github.com/aws/aws-sdk-go/service/connect"
+	"github.com/hashicorp/aws-sdk-go-base/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"
+	"github.com/hashicorp/terraform-provider-aws/internal/tfresource"
+)
+
+func ResourceBotAssociation() *schema.Resource {
+	return &schema.Resource{
+		CreateContext: resourceBotAssociationCreate,
+		ReadContext:   resourceBotAssociationRead,
+		DeleteContext: resourceBotAssociationDelete,
+		Importer: &schema.ResourceImporter{
+			StateContext: schema.ImportStatePassthroughContext,
+		},
+		Schema: map[string]*schema.Schema{
+			"instance_id": {
+				Type:     schema.TypeString,
+				Required: true,
+				ForceNew: true,
+			},
+
+			"lex_bot": {
+				Type:     schema.TypeList,
+				Required: true,
+				ForceNew: true,
+				MaxItems: 1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"lex_region": {
+							Type:     schema.TypeString,
+							Optional: true,
+							Computed: true,
+							ForceNew: true,
+						},
+						"name": {
+							Type:         schema.TypeString,
+							Required:     true,
+							ForceNew:     true,
+							ValidateFunc: validation.StringLenBetween(2, 50),
+						},
+					},
+				},
+			},
+			/* We would need a schema like this to support a v1/v2 hybrid
+			"lex_v2_bot": {
+				Type:     schema.TypeList,
+				Optional: true,
+				ForceNew: true,
+				MaxItems: 1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"alias_arn": {
+							Type:         schema.TypeString,
+							Required:     true,
+							ValidateFunc: verify.ValidARN,
+							ForceNew: true,
+						},
+					},
+				},
+			},
+			*/
+		},
+	}
+}
+
+func resourceBotAssociationCreate(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	conn := meta.(*conns.AWSClient).ConnectConn
+
+	instanceId := d.Get("instance_id").(string)
+
+	input := &connect.AssociateBotInput{
+		InstanceId: aws.String(instanceId),
+	}
+
+	if v, ok := d.GetOk("lex_bot"); ok && len(v.([]interface{})) > 0 && v.([]interface{})[0] != nil {
+		lexBot := expandLexBot(v.([]interface{}))
+		if lexBot.LexRegion == nil {
+			lexBot.LexRegion = aws.String(meta.(*conns.AWSClient).Region)
+		}
+		input.LexBot = lexBot
+	}
+
+	/* We would need something like this and additionally the opposite on the above
+	if v, ok := d.GetOk("lex_v2_bot"); ok && len(v.([]interface{})) > 0 && v.([]interface{})[0] != nil {
+		input.LexV2Bot = expandLexV2Bot(v.([]interface{}))
+	}
+	*/
+
+	_, err := tfresource.RetryWhen(
+		connectBotAssociationCreateTimeout,
+		func() (interface{}, error) {
+			return conn.AssociateBotWithContext(ctx, input)
+		},
+		func(err error) (bool, error) {
+			if tfawserr.ErrCodeEquals(err, connect.ErrCodeInvalidRequestException) {
+				return true, err
+			}
+
+			return false, err
+		},
+	)
+
+	lbaId := BotV1AssociationCreateResourceID(instanceId, aws.StringValue(input.LexBot.Name), aws.StringValue(input.LexBot.LexRegion))
+
+	if err != nil {
+		return diag.FromErr(fmt.Errorf("error creating Connect Bot Association (%s): %w", lbaId, err))
+	}
+
+	d.SetId(lbaId)
+
+	return resourceBotAssociationRead(ctx, d, meta)
+}
+
+func resourceBotAssociationRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	conn := meta.(*conns.AWSClient).ConnectConn
+
+	instanceId, name, region, err := BotV1AssociationParseResourceID(d.Id())
+
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	lexBot, err := FindBotAssociationV1ByNameAndRegionWithContext(ctx, conn, instanceId, name, region)
+
+	if !d.IsNewResource() && tfresource.NotFound(err) {
+		log.Printf("[WARN] Connect Bot Association (%s) not found, removing from state", d.Id())
+		d.SetId("")
+		return nil
+	}
+
+	if err != nil {
+		return diag.FromErr(fmt.Errorf("error reading Connect Bot Association (%s): %w", d.Id(), err))
+	}
+
+	if lexBot == nil {
+		return diag.FromErr(fmt.Errorf("error reading Connect Bot Association (%s): empty output", d.Id()))
+	}
+
+	d.Set("instance_id", instanceId)
+	if err := d.Set("lex_bot", flattenLexBot(lexBot)); err != nil {
+		return diag.FromErr(fmt.Errorf("error setting lex_bot: %w", err))
+	}
+
+	return nil
+}
+
+func resourceBotAssociationDelete(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	conn := meta.(*conns.AWSClient).ConnectConn
+
+	instanceID, name, region, err := BotV1AssociationParseResourceID(d.Id())
+
+	if err != nil {
+		return diag.FromErr(err)
+	}
+
+	lexBot := &connect.LexBot{
+		Name:      aws.String(name),
+		LexRegion: aws.String(region),
+	}
+
+	input := &connect.DisassociateBotInput{
+		InstanceId: aws.String(instanceID),
+		LexBot:     lexBot,
+	}
+
+	_, err = conn.DisassociateBotWithContext(ctx, input)
+
+	if tfawserr.ErrCodeEquals(err, connect.ErrCodeResourceNotFoundException) {
+		return nil
+	}
+
+	if err != nil {
+		return diag.FromErr(fmt.Errorf("error deleting Connect Bot Association (%s): %w", d.Id(), err))
+	}
+
+	return nil
+}
+
+func expandLexBot(l []interface{}) *connect.LexBot {
+	if len(l) == 0 || l[0] == nil {
+		return nil
+	}
+
+	tfMap, ok := l[0].(map[string]interface{})
+	if !ok {
+		return nil
+	}
+
+	result := &connect.LexBot{
+		Name: aws.String(tfMap["name"].(string)),
+	}
+
+	if v, ok := tfMap["lex_region"].(string); ok && v != "" {
+		result.LexRegion = aws.String(v)
+	}
+
+	return result
+}
+
+func flattenLexBot(bot *connect.LexBot) []interface{} {
+	if bot == nil {
+		return []interface{}{}
+	}
+
+	m := map[string]interface{}{
+		"lex_region": bot.LexRegion,
+		"name":       bot.Name,
+	}
+
+	return []interface{}{m}
+}

internal/service/connect/bot_association_data_source.go

@@ -0,0 +1,74 @@
+package connect
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/aws/aws-sdk-go/aws"
+	"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"
+)
+
+func DataSourceBotAssociation() *schema.Resource {
+	return &schema.Resource{
+		ReadContext: dataSourceBotAssociationRead,
+		Schema: map[string]*schema.Schema{
+			"instance_id": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+			"lex_bot": {
+				Type:     schema.TypeList,
+				Required: true,
+				MaxItems: 1,
+				Elem: &schema.Resource{
+					Schema: map[string]*schema.Schema{
+						"lex_region": {
+							Type:     schema.TypeString,
+							Optional: true,
+							Computed: true,
+						},
+						"name": {
+							Type:         schema.TypeString,
+							Required:     true,
+							ValidateFunc: validation.StringLenBetween(2, 50),
+						},
+					},
+				},
+			},
+		},
+	}
+}
+
+func dataSourceBotAssociationRead(ctx context.Context, d *schema.ResourceData, meta interface{}) diag.Diagnostics {
+	conn := meta.(*conns.AWSClient).ConnectConn
+
+	instanceID := d.Get("instance_id").(string)
+
+	var name, region string
+	if v, ok := d.GetOk("lex_bot"); ok && len(v.([]interface{})) > 0 && v.([]interface{})[0] != nil {
+		lexBot := expandLexBot(v.([]interface{}))
+		name = aws.StringValue(lexBot.Name)
+		region = aws.StringValue(lexBot.LexRegion)
+	}
+
+	lexBot, err := FindBotAssociationV1ByNameAndRegionWithContext(ctx, conn, instanceID, name, region)
+	if err != nil {
+		return diag.FromErr(fmt.Errorf("error finding Connect Bot Association (%s,%s): %w", instanceID, name, err))
+	}
+
+	if lexBot == nil {
+		return diag.FromErr(fmt.Errorf("error finding Connect Bot Association (%s,%s) : not found", instanceID, name))
+	}
+
+	d.SetId(meta.(*conns.AWSClient).Region)
+
+	d.Set("instance_id", instanceID)
+	if err := d.Set("lex_bot", flattenLexBot(lexBot)); err != nil {
+		return diag.FromErr(fmt.Errorf("error setting lex_bot: %w", err))
+	}
+
+	return nil
+}