Merge pull request #44934 from subham-ibmhc/r/aws_connect_routing_profile

Add support for concurrency cross channel behaviour

Author: jar-b

.changelog/44934.txt

@@ -0,0 +1,7 @@
+```release-note:enhancement
+resource/aws_connect_routing_profile: Add `media_concurrencies.cross_channel_behavior` argument
+```
+
+```release-note:enhancement
+data-source/aws_connect_routing_profile: Add `media_concurrencies.cross_channel_behavior` attribute
+```

internal/service/connect/connect_test.go

@@ -128,6 +128,7 @@ func TestAccConnect_serial(t *testing.T) {
 			acctest.CtDisappears:           testAccRoutingProfile_disappears,
 			"tags":                         testAccRoutingProfile_updateTags,
 			"concurrency":                  testAccRoutingProfile_updateConcurrency,
+			"crossChannelBehavior":         testAccRoutingProfile_crossChannelBehavior,
 			"defaultOutboundQueue":         testAccRoutingProfile_updateDefaultOutboundQueue,
 			"queues":                       testAccRoutingProfile_updateQueues,
 			"createQueueBatchAssociations": testAccRoutingProfile_createQueueConfigsBatchedAssociateDisassociate,

internal/service/connect/routing_profile.go

@@ -78,6 +78,20 @@ func resourceRoutingProfile() *schema.Resource {
 							Required:     true,
 							ValidateFunc: validation.IntBetween(1, 10),
 						},
+						"cross_channel_behavior": {
+							Type:     schema.TypeList,
+							Optional: true,
+							MaxItems: 1,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"behavior_type": {
+										Type:             schema.TypeString,
+										Required:         true,
+										ValidateDiagFunc: enum.Validate[awstypes.BehaviorType](),
+									},
+								},
+							},
+						},
 					},
 				},
 			},
@@ -138,7 +152,7 @@ func resourceRoutingProfileCreate(ctx context.Context, d *schema.ResourceData, m
 
 	instanceID := d.Get(names.AttrInstanceID).(string)
 	name := d.Get(names.AttrName).(string)
-	input := &connect.CreateRoutingProfileInput{
+	input := connect.CreateRoutingProfileInput{
 		DefaultOutboundQueueId: aws.String(d.Get("default_outbound_queue_id").(string)),
 		Description:            aws.String(d.Get(names.AttrDescription).(string)),
 		InstanceId:             aws.String(instanceID),
@@ -156,7 +170,7 @@ func resourceRoutingProfileCreate(ctx context.Context, d *schema.ResourceData, m
 		input.QueueConfigs = queueConfigs
 	}
 
-	output, err := conn.CreateRoutingProfile(ctx, input)
+	output, err := conn.CreateRoutingProfile(ctx, &input)
 
 	if err != nil {
 		return sdkdiag.AppendErrorf(diags, "creating Connect Routing Profile (%s): %s", name, err)
@@ -185,7 +199,7 @@ func resourceRoutingProfileRead(ctx context.Context, d *schema.ResourceData, met
 		return sdkdiag.AppendFromErr(diags, err)
 	}
 
-	routingProfile, err := findRoutingProfileByTwoPartKey(ctx, conn, instanceID, routingProfileID)
+	output, err := findRoutingProfileByTwoPartKey(ctx, conn, instanceID, routingProfileID)
 
 	if !d.IsNewResource() && tfresource.NotFound(err) {
 		log.Printf("[WARN] Connect Routing Profile (%s) not found, removing from state", d.Id())
@@ -197,15 +211,15 @@ func resourceRoutingProfileRead(ctx context.Context, d *schema.ResourceData, met
 		return sdkdiag.AppendErrorf(diags, "reading Connect Routing Profile (%s): %s", d.Id(), err)
 	}
 
-	d.Set(names.AttrARN, routingProfile.RoutingProfileArn)
-	d.Set("default_outbound_queue_id", routingProfile.DefaultOutboundQueueId)
-	d.Set(names.AttrDescription, routingProfile.Description)
+	d.Set(names.AttrARN, output.RoutingProfileArn)
+	d.Set("default_outbound_queue_id", output.DefaultOutboundQueueId)
+	d.Set(names.AttrDescription, output.Description)
 	d.Set(names.AttrInstanceID, instanceID)
-	if err := d.Set("media_concurrencies", flattenMediaConcurrencies(routingProfile.MediaConcurrencies)); err != nil {
+	if err := d.Set("media_concurrencies", flattenMediaConcurrencies(output.MediaConcurrencies, d.Get("media_concurrencies").(*schema.Set).List())); err != nil {
 		return sdkdiag.AppendErrorf(diags, "setting media_concurrencies: %s", err)
 	}
-	d.Set(names.AttrName, routingProfile.Name)
-	d.Set("routing_profile_id", routingProfile.RoutingProfileId)
+	d.Set(names.AttrName, output.Name)
+	d.Set("routing_profile_id", output.RoutingProfileId)
 
 	queueConfigs, err := findRoutingConfigQueueConfigSummariesByTwoPartKey(ctx, conn, instanceID, routingProfileID)
 
@@ -217,7 +231,7 @@ func resourceRoutingProfileRead(ctx context.Context, d *schema.ResourceData, met
 		return sdkdiag.AppendErrorf(diags, "setting queue_configs: %s", err)
 	}
 
-	setTagsOut(ctx, routingProfile.Tags)
+	setTagsOut(ctx, output.Tags)
 
 	return diags
 }
@@ -239,13 +253,13 @@ func resourceRoutingProfileUpdate(ctx context.Context, d *schema.ResourceData, m
 
 	if d.HasChange("media_concurrencies") {
 		// updates to concurrency
-		input := &connect.UpdateRoutingProfileConcurrencyInput{
+		input := connect.UpdateRoutingProfileConcurrencyInput{
 			InstanceId:         aws.String(instanceID),
 			MediaConcurrencies: expandMediaConcurrencies(d.Get("media_concurrencies").(*schema.Set).List()),
 			RoutingProfileId:   aws.String(routingProfileID),
 		}
 
-		_, err = conn.UpdateRoutingProfileConcurrency(ctx, input)
+		_, err = conn.UpdateRoutingProfileConcurrency(ctx, &input)
 
 		if err != nil {
 			return sdkdiag.AppendErrorf(diags, "updating Connect Routing Profile (%s) Concurrency: %s", d.Id(), err)
@@ -254,13 +268,13 @@ func resourceRoutingProfileUpdate(ctx context.Context, d *schema.ResourceData, m
 
 	if d.HasChange("default_outbound_queue_id") {
 		// updates to default outbound queue id
-		input := &connect.UpdateRoutingProfileDefaultOutboundQueueInput{
+		input := connect.UpdateRoutingProfileDefaultOutboundQueueInput{
 			DefaultOutboundQueueId: aws.String(d.Get("default_outbound_queue_id").(string)),
 			InstanceId:             aws.String(instanceID),
 			RoutingProfileId:       aws.String(routingProfileID),
 		}
 
-		_, err = conn.UpdateRoutingProfileDefaultOutboundQueue(ctx, input)
+		_, err = conn.UpdateRoutingProfileDefaultOutboundQueue(ctx, &input)
 
 		if err != nil {
 			return sdkdiag.AppendErrorf(diags, "updating Connect Routing Profile (%s) DefaultOutboundQueue: %s", d.Id(), err)
@@ -269,14 +283,14 @@ func resourceRoutingProfileUpdate(ctx context.Context, d *schema.ResourceData, m
 
 	if d.HasChanges(names.AttrName, names.AttrDescription) {
 		// updates to name and/or description
-		input := &connect.UpdateRoutingProfileNameInput{
+		input := connect.UpdateRoutingProfileNameInput{
 			Description:      aws.String(d.Get(names.AttrDescription).(string)),
 			InstanceId:       aws.String(instanceID),
 			Name:             aws.String(d.Get(names.AttrName).(string)),
 			RoutingProfileId: aws.String(routingProfileID),
 		}
 
-		_, err = conn.UpdateRoutingProfileName(ctx, input)
+		_, err = conn.UpdateRoutingProfileName(ctx, &input)
 
 		if err != nil {
 			return sdkdiag.AppendErrorf(diags, "updating Connect Routing Profile (%s) Name: %s", d.Id(), err)
@@ -368,13 +382,13 @@ func updateRoutingProfileQueueAssociations(ctx context.Context, conn *connect.Cl
 		}
 
 		if len(queueReferences) > 0 {
-			input := &connect.DisassociateRoutingProfileQueuesInput{
+			input := connect.DisassociateRoutingProfileQueuesInput{
 				InstanceId:       aws.String(instanceID),
 				QueueReferences:  queueReferences,
 				RoutingProfileId: aws.String(routingProfileID),
 			}
 
-			_, err := conn.DisassociateRoutingProfileQueues(ctx, input)
+			_, err := conn.DisassociateRoutingProfileQueues(ctx, &input)
 
 			if err != nil {
 				return fmt.Errorf("disassociating Connect Routing Profile (%s) queues: %w", routingProfileID, err)
@@ -383,13 +397,13 @@ func updateRoutingProfileQueueAssociations(ctx context.Context, conn *connect.Cl
 	}
 
 	for chunk := range slices.Chunk(add, routingProfileQueueAssociationChunkSize) {
-		input := &connect.AssociateRoutingProfileQueuesInput{
+		input := connect.AssociateRoutingProfileQueuesInput{
 			InstanceId:       aws.String(instanceID),
 			QueueConfigs:     chunk,
 			RoutingProfileId: aws.String(routingProfileID),
 		}
 
-		_, err := conn.AssociateRoutingProfileQueues(ctx, input)
+		_, err := conn.AssociateRoutingProfileQueues(ctx, &input)
 
 		if err != nil {
 			return fmt.Errorf("associating Connect Routing Profile (%s) queues: %w", routingProfileID, err)
@@ -400,12 +414,12 @@ func updateRoutingProfileQueueAssociations(ctx context.Context, conn *connect.Cl
 }
 
 func findRoutingProfileByTwoPartKey(ctx context.Context, conn *connect.Client, instanceID, routingProfileID string) (*awstypes.RoutingProfile, error) {
-	input := &connect.DescribeRoutingProfileInput{
+	input := connect.DescribeRoutingProfileInput{
 		InstanceId:       aws.String(instanceID),
 		RoutingProfileId: aws.String(routingProfileID),
 	}
 
-	return findRoutingProfile(ctx, conn, input)
+	return findRoutingProfile(ctx, conn, &input)
 }
 
 func findRoutingProfile(ctx context.Context, conn *connect.Client, input *connect.DescribeRoutingProfileInput) (*awstypes.RoutingProfile, error) {
@@ -431,13 +445,13 @@ func findRoutingProfile(ctx context.Context, conn *connect.Client, input *connec
 
 func findRoutingConfigQueueConfigSummariesByTwoPartKey(ctx context.Context, conn *connect.Client, instanceID, routingProfileID string) ([]awstypes.RoutingProfileQueueConfigSummary, error) {
 	const maxResults = 60
-	input := &connect.ListRoutingProfileQueuesInput{
+	input := connect.ListRoutingProfileQueuesInput{
 		InstanceId:       aws.String(instanceID),
 		MaxResults:       aws.Int32(maxResults),
 		RoutingProfileId: aws.String(routingProfileID),
 	}
 
-	return findRoutingConfigQueueConfigSummaries(ctx, conn, input)
+	return findRoutingConfigQueueConfigSummaries(ctx, conn, &input)
 }
 
 func findRoutingConfigQueueConfigSummaries(ctx context.Context, conn *connect.Client, input *connect.ListRoutingProfileQueuesInput) ([]awstypes.RoutingProfileQueueConfigSummary, error) {
@@ -477,13 +491,18 @@ func expandMediaConcurrencies(tfList []any) []awstypes.MediaConcurrency {
 			Channel:     awstypes.Channel(tfMap["channel"].(string)),
 			Concurrency: aws.Int32(int32(tfMap["concurrency"].(int))),
 		}
+
+		if v, ok := tfMap["cross_channel_behavior"].([]any); ok && len(v) > 0 {
+			apiObject.CrossChannelBehavior = expandCrossChannelBehavior(v)
+		}
+
 		apiObjects = append(apiObjects, apiObject)
 	}
 
 	return apiObjects
 }
 
-func flattenMediaConcurrencies(apiObjects []awstypes.MediaConcurrency) []any {
+func flattenMediaConcurrencies(apiObjects []awstypes.MediaConcurrency, mediaConcurrencyCfg []any) []any {
 	tfList := []any{}
 
 	for _, apiObject := range apiObjects {
@@ -492,12 +511,43 @@ func flattenMediaConcurrencies(apiObjects []awstypes.MediaConcurrency) []any {
 			"concurrency": aws.ToInt32(apiObject.Concurrency),
 		}
 
+		// Only write cross_channel_behavior to state when explicitly configured
+		channel := string(apiObject.Channel)
+		ccbChannels := channelsWithCrossChannelBehavior(mediaConcurrencyCfg)
+		if apiObject.CrossChannelBehavior != nil && slices.Contains(ccbChannels, channel) {
+			tfMap["cross_channel_behavior"] = flattenCrossChannelBehavior(apiObject.CrossChannelBehavior)
+		}
+
 		tfList = append(tfList, tfMap)
 	}
 
 	return tfList
 }
 
+func expandCrossChannelBehavior(tfList []any) *awstypes.CrossChannelBehavior {
+	if len(tfList) == 0 {
+		return nil
+	}
+
+	tfMap := tfList[0].(map[string]any)
+
+	return &awstypes.CrossChannelBehavior{
+		BehaviorType: awstypes.BehaviorType(tfMap["behavior_type"].(string)),
+	}
+}
+
+func flattenCrossChannelBehavior(apiObject *awstypes.CrossChannelBehavior) []map[string]any {
+	if apiObject == nil {
+		return nil
+	}
+
+	return []map[string]any{
+		{
+			"behavior_type": string(apiObject.BehaviorType),
+		},
+	}
+}
+
 func expandRoutingProfileQueueConfigs(tfList []any) []awstypes.RoutingProfileQueueConfig {
 	if len(tfList) == 0 {
 		return nil
@@ -540,3 +590,25 @@ func flattenRoutingConfigQueueConfigSummaries(apiObjects []awstypes.RoutingProfi
 
 	return tfList
 }
+
+// channelsWithCrossChannelBehavior returns a list of channel names which have
+// cross_channel_behavior set
+//
+// This data structure can be used to determine when to write the remote cross_channel_behavior
+// value to state. Writing the value when a corresponding congiuration is not present
+// will trigger persistent drift as the object is nested within a required set attribute.
+func channelsWithCrossChannelBehavior(cfgList []any) []string {
+	var c []string
+	for _, l := range cfgList {
+		m := l.(map[string]any)
+		if m == nil {
+			continue
+		}
+
+		if v, ok := m["cross_channel_behavior"].([]any); ok && len(v) > 0 {
+			c = append(c, m["channel"].(string))
+		}
+	}
+
+	return c
+}

internal/service/connect/routing_profile_data_source.go

@@ -59,6 +59,18 @@ func dataSourceRoutingProfile() *schema.Resource {
 							Type:     schema.TypeInt,
 							Computed: true,
 						},
+						"cross_channel_behavior": {
+							Type:     schema.TypeList,
+							Computed: true,
+							Elem: &schema.Resource{
+								Schema: map[string]*schema.Schema{
+									"behavior_type": {
+										Type:     schema.TypeString,
+										Computed: true,
+									},
+								},
+							},
+						},
 					},
 				},
 			},
@@ -146,7 +158,7 @@ func dataSourceRoutingProfileRead(ctx context.Context, d *schema.ResourceData, m
 	d.Set("default_outbound_queue_id", routingProfile.DefaultOutboundQueueId)
 	d.Set(names.AttrDescription, routingProfile.Description)
 	d.Set(names.AttrInstanceID, instanceID)
-	if err := d.Set("media_concurrencies", flattenMediaConcurrencies(routingProfile.MediaConcurrencies)); err != nil {
+	if err := d.Set("media_concurrencies", flattenMediaConcurrencies(routingProfile.MediaConcurrencies, d.Get("media_concurrencies").(*schema.Set).List())); err != nil {
 		return sdkdiag.AppendErrorf(diags, "setting media_concurrencies: %s", err)
 	}
 	d.Set(names.AttrName, routingProfile.Name)