New resource/data source azurerm_logic_app_integration_account

azurerm/internal/services/logic/client/client.go

@@ -6,14 +6,19 @@ import (
 )
 
 type Client struct {
-	WorkflowsClient *logic.WorkflowsClient
+	IntegrationAccountClient *logic.IntegrationAccountsClient
+	WorkflowsClient          *logic.WorkflowsClient
 }
 
 func NewClient(o *common.ClientOptions) *Client {
+	integrationAccountClient := logic.NewIntegrationAccountsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
+	o.ConfigureClient(&integrationAccountClient.Client, o.ResourceManagerAuthorizer)
+
 	WorkflowsClient := logic.NewWorkflowsClientWithBaseURI(o.ResourceManagerEndpoint, o.SubscriptionId)
 	o.ConfigureClient(&WorkflowsClient.Client, o.ResourceManagerAuthorizer)
 
 	return &Client{
-		WorkflowsClient: &WorkflowsClient,
+		WorkflowsClient:          &WorkflowsClient,
+		IntegrationAccountClient: &integrationAccountClient,
 	}
 }

azurerm/internal/services/logic/logic_app_integration_account_data_source.go

@@ -0,0 +1,70 @@
+package logic
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/location"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tags"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
+)
+
+func dataSourceLogicAppIntegrationAccount() *schema.Resource {
+	return &schema.Resource{
+		Read: dataSourceArmLogicAppIntegrationAccountRead,
+
+		Timeouts: &schema.ResourceTimeout{
+			Read: schema.DefaultTimeout(5 * time.Minute),
+		},
+
+		Schema: map[string]*schema.Schema{
+			"name": {
+				Type:     schema.TypeString,
+				Required: true,
+			},
+
+			"resource_group_name": azure.SchemaResourceGroupNameForDataSource(),
+
+			"location": azure.SchemaLocationForDataSource(),
+
+			"sku_name": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+
+			"tags": tags.SchemaDataSource(),
+		},
+	}
+}
+
+func dataSourceArmLogicAppIntegrationAccountRead(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*clients.Client).Logic.IntegrationAccountClient
+	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	name := d.Get("name").(string)
+	resourceGroup := d.Get("resource_group_name").(string)
+
+	resp, err := client.Get(ctx, resourceGroup, name)
+	if err != nil {
+		if utils.ResponseWasNotFound(resp.Response) {
+			return fmt.Errorf("Logic App Integration Account Account %q does not exist in Resource Group %q", name, resourceGroup)
+		}
+		return fmt.Errorf("retrieving Logic App Integration Account Account %q (Resource Group %q): %+v", name, resourceGroup, err)
+	}
+
+	if resp.ID == nil || *resp.ID == "" {
+		return fmt.Errorf("reading Logic App Integration Account Account %q (Resource Group %q): ID is empty or nil", name, resourceGroup)
+	}
+
+	d.SetId(*resp.ID)
+	d.Set("name", name)
+	d.Set("resource_group_name", resourceGroup)
+	d.Set("location", location.NormalizeNilable(resp.Location))
+	d.Set("sku_name", string(resp.Sku.Name))
+	return tags.FlattenAndSet(d, resp.Tags)
+}

azurerm/internal/services/logic/logic_app_integration_account_resource.go

@@ -0,0 +1,151 @@
+package logic
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/Azure/azure-sdk-for-go/services/logic/mgmt/2019-05-01/logic"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/schema"
+	"github.com/hashicorp/terraform-plugin-sdk/helper/validation"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/tf"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/location"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/logic/parse"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/logic/validate"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tags"
+	azSchema "github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tf/schema"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
+)
+
+func resourceArmLogicAppIntegrationAccount() *schema.Resource {
+	return &schema.Resource{
+		Create: resourceArmLogicAppIntegrationAccountCreateUpdate,
+		Read:   resourceArmLogicAppIntegrationAccountRead,
+		Update: resourceArmLogicAppIntegrationAccountCreateUpdate,
+		Delete: resourceArmLogicAppIntegrationAccountDelete,
+
+		Timeouts: &schema.ResourceTimeout{
+			Create: schema.DefaultTimeout(30 * time.Minute),
+			Read:   schema.DefaultTimeout(5 * time.Minute),
+			Update: schema.DefaultTimeout(30 * time.Minute),
+			Delete: schema.DefaultTimeout(30 * time.Minute),
+		},
+
+		Importer: azSchema.ValidateResourceIDPriorToImport(func(id string) error {
+			_, err := parse.IntegrationAccountID(id)
+			return err
+		}),
+
+		Schema: map[string]*schema.Schema{
+			"name": {
+				Type:         schema.TypeString,
+				Required:     true,
+				ForceNew:     true,
+				ValidateFunc: validate.IntegrationAccountName(),
+			},
+
+			"resource_group_name": azure.SchemaResourceGroupName(),
+
+			"location": azure.SchemaLocation(),
+
+			"sku_name": {
+				Type:     schema.TypeString,
+				Required: true,
+				ValidateFunc: validation.StringInSlice([]string{
+					string(logic.IntegrationAccountSkuNameBasic),
+					string(logic.IntegrationAccountSkuNameFree),
+					string(logic.IntegrationAccountSkuNameStandard),
+				}, false),
+			},
+
+			"tags": tags.Schema(),
+		},
+	}
+}
+func resourceArmLogicAppIntegrationAccountCreateUpdate(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*clients.Client).Logic.IntegrationAccountClient
+	ctx, cancel := timeouts.ForCreate(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	name := d.Get("name").(string)
+	resourceGroup := d.Get("resource_group_name").(string)
+
+	if d.IsNewResource() {
+		existing, err := client.Get(ctx, resourceGroup, name)
+		if err != nil {
+			if !utils.ResponseWasNotFound(existing.Response) {
+				return fmt.Errorf("checking for present of existing Integration Account %q (Resource Group %q): %+v", name, resourceGroup, err)
+			}
+		}
+		if existing.ID != nil && *existing.ID != "" {
+			return tf.ImportAsExistsError("azurerm_logic_app_integration_account", *existing.ID)
+		}
+	}
+
+	account := logic.IntegrationAccount{
+		IntegrationAccountProperties: &logic.IntegrationAccountProperties{},
+		Location:                     utils.String(location.Normalize(d.Get("location").(string))),
+		Sku: &logic.IntegrationAccountSku{
+			Name: logic.IntegrationAccountSkuName(d.Get("sku_name").(string)),
+		},
+		Tags: tags.Expand(d.Get("tags").(map[string]interface{})),
+	}
+
+	if _, err := client.CreateOrUpdate(ctx, resourceGroup, name, account); err != nil {
+		return fmt.Errorf("creating Integration Account %q (Resource Group %q): %+v", name, resourceGroup, err)
+	}
+
+	resp, err := client.Get(ctx, resourceGroup, name)
+	if err != nil {
+		return fmt.Errorf("retrieving Integration Account %q (Resource Group %q): %+v", name, resourceGroup, err)
+	}
+
+	if resp.ID == nil || *resp.ID == "" {
+		return fmt.Errorf("reading Integration Account %q (Resource Group %q): ID is empty or nil", name, resourceGroup)
+	}
+
+	d.SetId(*resp.ID)
+
+	return resourceArmLogicAppIntegrationAccountRead(d, meta)
+}
+
+func resourceArmLogicAppIntegrationAccountRead(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*clients.Client).Logic.IntegrationAccountClient
+	ctx, cancel := timeouts.ForRead(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	id, err := parse.IntegrationAccountID(d.Id())
+	if err != nil {
+		return err
+	}
+
+	resp, err := client.Get(ctx, id.ResourceGroup, id.Name)
+	if err != nil {
+		return fmt.Errorf("retrieving Integration Account %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err)
+	}
+	d.Set("name", id.Name)
+	d.Set("resource_group_name", id.ResourceGroup)
+	d.Set("location", location.NormalizeNilable(resp.Location))
+	d.Set("sku_name", string(resp.Sku.Name))
+
+	return tags.FlattenAndSet(d, resp.Tags)
+}
+
+func resourceArmLogicAppIntegrationAccountDelete(d *schema.ResourceData, meta interface{}) error {
+	client := meta.(*clients.Client).Logic.IntegrationAccountClient
+	ctx, cancel := timeouts.ForDelete(meta.(*clients.Client).StopContext, d)
+	defer cancel()
+
+	id, err := parse.IntegrationAccountID(d.Id())
+	if err != nil {
+		return err
+	}
+
+	if _, err := client.Delete(ctx, id.ResourceGroup, id.Name); err != nil {
+		return fmt.Errorf("deleting Integration Account %q (Resource Group %q): %+v", id.Name, id.ResourceGroup, err)
+	}
+
+	return nil
+}

azurerm/internal/services/logic/logic_app_workflow_data_source.go

@@ -32,6 +32,11 @@ func dataSourceArmLogicAppWorkflow() *schema.Resource {
 
 			"location": azure.SchemaLocationForDataSource(),
 
+			"logic_app_integration_account_id": {
+				Type:     schema.TypeString,
+				Computed: true,
+			},
+
 			// TODO: should Parameters be split out into their own object to allow validation on the different sub-types?
 			"parameters": {
 				Type:     schema.TypeMap,
@@ -134,6 +139,10 @@ func dataSourceArmLogicAppWorkflowRead(d *schema.ResourceData, meta interface{})
 				d.Set("workflow_version", v["contentVersion"].(string))
 			}
 		}
+
+		if props.IntegrationAccount != nil && props.IntegrationAccount.ID != nil {
+			d.Set("logic_app_integration_account_id", props.IntegrationAccount.ID)
+		}
 	}
 
 	return tags.FlattenAndSet(d, resp.Tags)

azurerm/internal/services/logic/logic_app_workflow_resource.go

@@ -12,6 +12,7 @@ import (
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/clients"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/features"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/locks"
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/services/logic/validate"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/tags"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/internal/timeouts"
 	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/utils"
@@ -47,6 +48,12 @@ func resourceArmLogicAppWorkflow() *schema.Resource {
 
 			"resource_group_name": azure.SchemaResourceGroupName(),
 
+			"logic_app_integration_account_id": {
+				Type:         schema.TypeString,
+				Optional:     true,
+				ValidateFunc: validate.IntegrationAccountID,
+			},
+
 			// TODO: should Parameters be split out into their own object to allow validation on the different sub-types?
 			"parameters": {
 				Type:     schema.TypeMap,
@@ -145,6 +152,12 @@ func resourceArmLogicAppWorkflowCreate(d *schema.ResourceData, meta interface{})
 		Tags: tags.Expand(t),
 	}
 
+	if v, ok := d.GetOk("logic_app_integration_account_id"); ok {
+		properties.WorkflowProperties.IntegrationAccount = &logic.ResourceReference{
+			ID: utils.String(v.(string)),
+		}
+	}
+
 	if _, err := client.CreateOrUpdate(ctx, resourceGroup, name, properties); err != nil {
 		return fmt.Errorf("[ERROR] Error creating Logic App Workflow %q (Resource Group %q): %+v", name, resourceGroup, err)
 	}
@@ -206,6 +219,12 @@ func resourceArmLogicAppWorkflowUpdate(d *schema.ResourceData, meta interface{})
 		Tags: tags.Expand(t),
 	}
 
+	if v, ok := d.GetOk("logic_app_integration_account_id"); ok {
+		properties.WorkflowProperties.IntegrationAccount = &logic.ResourceReference{
+			ID: utils.String(v.(string)),
+		}
+	}
+
 	if _, err = client.CreateOrUpdate(ctx, resourceGroup, name, properties); err != nil {
 		return fmt.Errorf("Error updating Logic App Workspace %q (Resource Group %q): %+v", name, resourceGroup, err)
 	}
@@ -271,6 +290,10 @@ func resourceArmLogicAppWorkflowRead(d *schema.ResourceData, meta interface{}) e
 				d.Set("workflow_version", v["contentVersion"].(string))
 			}
 		}
+
+		if props.IntegrationAccount != nil && props.IntegrationAccount.ID != nil {
+			d.Set("logic_app_integration_account_id", props.IntegrationAccount.ID)
+		}
 	}
 
 	return tags.FlattenAndSet(d, resp.Tags)

azurerm/internal/services/logic/parse/logic.go

@@ -0,0 +1,31 @@
+package parse
+
+import (
+	"fmt"
+
+	"github.com/terraform-providers/terraform-provider-azurerm/azurerm/helpers/azure"
+)
+
+type IntegrationAccountId struct {
+	ResourceGroup string
+	Name          string
+}
+
+func IntegrationAccountID(input string) (*IntegrationAccountId, error) {
+	id, err := azure.ParseAzureResourceID(input)
+	if err != nil {
+		return nil, fmt.Errorf("parsing Integration Account ID %q: %+v", input, err)
+	}
+
+	IntegrationAccount := IntegrationAccountId{
+		ResourceGroup: id.ResourceGroup,
+	}
+	if IntegrationAccount.Name, err = id.PopSegment("integrationAccounts"); err != nil {
+		return nil, err
+	}
+	if err := id.ValidateNoEmptySegments(input); err != nil {
+		return nil, err
+	}
+
+	return &IntegrationAccount, nil
+}