Feature scaffolding - added graph example - cloudpc provisioning profile

internal/provider/resources.go

@@ -4,6 +4,7 @@ import (
 	"context"
 
 	graphBetaAssignmentFilter "github.com/deploymenttheory/terraform-provider-microsoft365/internal/resources/deviceandappmanagement/beta/assignmentFilter"
+	graphCloudPcProvisioningPolicy "github.com/deploymenttheory/terraform-provider-microsoft365/internal/resources/devicemanagement/v1.0/cloudPcProvisioningPolicy"
 	"github.com/hashicorp/terraform-plugin-framework/resource"
 )
 
@@ -22,5 +23,6 @@ import (
 func (p *M365Provider) Resources(ctx context.Context) []func() resource.Resource {
 	return []func() resource.Resource{
 		graphBetaAssignmentFilter.NewAssignmentFilterResource,
+		graphCloudPcProvisioningPolicy.NewCloudPcProvisioningPolicyResource,
 	}
 }

internal/resources/deviceandappmanagement/beta/assignmentFilter/resource.go

@@ -89,7 +89,7 @@ func (r *AssignmentFilterResource) Configure(ctx context.Context, req resource.C
 	}
 
 	r.client = clients.BetaClient
-	tflog.Debug(ctx, "Initialized graphBetaAssignmentFilter resource with BetaClient")
+	tflog.Debug(ctx, "Initialized graphBetaAssignmentFilter resource with Graph Beta Client")
 }
 
 // ImportState imports the resource state.

internal/resources/devicemanagement/v1.0/cloudPcProvisioningPolicy/constructs.go

@@ -0,0 +1,142 @@
+package graphCloudPcProvisioningPolicy
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+	"github.com/microsoftgraph/msgraph-sdk-go/models"
+)
+
+// constructResource maps the Terraform schema to the SDK model
+func constructResource(ctx context.Context, data *CloudPcProvisioningPolicyResourceModel) (*models.CloudPcProvisioningPolicy, error) {
+	requestBody := models.NewCloudPcProvisioningPolicy()
+
+	displayName := data.DisplayName.ValueString()
+	requestBody.SetDisplayName(&displayName)
+
+	if !data.Description.IsNull() {
+		description := data.Description.ValueString()
+		requestBody.SetDescription(&description)
+	}
+
+	if !data.CloudPcNamingTemplate.IsNull() {
+		namingTemplate := data.CloudPcNamingTemplate.ValueString()
+		requestBody.SetCloudPcNamingTemplate(&namingTemplate)
+	}
+
+	if !data.EnableSingleSignOn.IsNull() {
+		enableSSO := data.EnableSingleSignOn.ValueBool()
+		requestBody.SetEnableSingleSignOn(&enableSSO)
+	}
+
+	if !data.ImageId.IsNull() {
+		imageId := data.ImageId.ValueString()
+		requestBody.SetImageId(&imageId)
+	}
+
+	if !data.ImageType.IsNull() {
+		imageTypeStr := data.ImageType.ValueString()
+		imageType, err := models.ParseCloudPcProvisioningPolicyImageType(imageTypeStr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid image type: %s", err)
+		}
+		requestBody.SetImageType(imageType.(*models.CloudPcProvisioningPolicyImageType))
+	}
+
+	if !data.LocalAdminEnabled.IsNull() {
+		localAdminEnabled := data.LocalAdminEnabled.ValueBool()
+		requestBody.SetLocalAdminEnabled(&localAdminEnabled)
+	}
+
+	if !data.ProvisioningType.IsNull() {
+		provisioningTypeStr := data.ProvisioningType.ValueString()
+		provisioningType, err := models.ParseCloudPcProvisioningType(provisioningTypeStr)
+		if err != nil {
+			return nil, fmt.Errorf("invalid provisioning type: %s", err)
+		}
+		requestBody.SetProvisioningType(provisioningType.(*models.CloudPcProvisioningType))
+	}
+
+	if data.MicrosoftManagedDesktop != nil {
+		mmd := models.NewMicrosoftManagedDesktop()
+
+		if managedType := data.MicrosoftManagedDesktop.ManagedType; !managedType.IsNull() {
+			managedTypeStr := managedType.ValueString()
+			managedTypeAny, err := models.ParseMicrosoftManagedDesktopType(managedTypeStr)
+			if err != nil {
+				return nil, fmt.Errorf("invalid Microsoft Managed Desktop type: %s", err)
+			}
+			if managedTypeAny != nil {
+				managedTypeEnum, ok := managedTypeAny.(*models.MicrosoftManagedDesktopType)
+				if !ok {
+					return nil, fmt.Errorf("unexpected type for Microsoft Managed Desktop type")
+				}
+				mmd.SetManagedType(managedTypeEnum)
+			}
+		}
+
+		if profile := data.MicrosoftManagedDesktop.Profile; !profile.IsNull() {
+			profileValue := profile.ValueString()
+			mmd.SetProfile(&profileValue)
+		}
+
+		requestBody.SetMicrosoftManagedDesktop(mmd)
+	}
+
+	if len(data.DomainJoinConfigurations) > 0 {
+		var domainJoinConfigs []models.CloudPcDomainJoinConfigurationable
+		for _, config := range data.DomainJoinConfigurations {
+			domainJoinConfig := models.NewCloudPcDomainJoinConfiguration()
+
+			if !config.DomainJoinType.IsNull() {
+				domainJoinTypeStr := config.DomainJoinType.ValueString()
+				domainJoinTypeAny, err := models.ParseCloudPcDomainJoinType(domainJoinTypeStr)
+				if err != nil {
+					return nil, fmt.Errorf("invalid domain join type: %s", err)
+				}
+				if domainJoinTypeAny != nil {
+					domainJoinTypeEnum, ok := domainJoinTypeAny.(*models.CloudPcDomainJoinType)
+					if !ok {
+						return nil, fmt.Errorf("unexpected type for domain join type")
+					}
+					domainJoinConfig.SetDomainJoinType(domainJoinTypeEnum)
+				}
+			}
+
+			if !config.OnPremisesConnectionId.IsNull() {
+				onPremisesConnectionId := config.OnPremisesConnectionId.ValueString()
+				domainJoinConfig.SetOnPremisesConnectionId(&onPremisesConnectionId)
+			}
+
+			if !config.RegionName.IsNull() {
+				regionName := config.RegionName.ValueString()
+				domainJoinConfig.SetRegionName(&regionName)
+			}
+
+			domainJoinConfigs = append(domainJoinConfigs, domainJoinConfig)
+		}
+		requestBody.SetDomainJoinConfigurations(domainJoinConfigs)
+	}
+
+	if data.WindowsSetting != nil {
+		windowsSetting := models.NewCloudPcWindowsSetting()
+
+		if !data.WindowsSetting.Locale.IsNull() {
+			locale := data.WindowsSetting.Locale.ValueString()
+			windowsSetting.SetLocale(&locale)
+		}
+
+		requestBody.SetWindowsSetting(windowsSetting)
+	}
+
+	requestBodyJSON, err := json.MarshalIndent(requestBody, "", "  ")
+	if err != nil {
+		return nil, fmt.Errorf("error marshalling request body to JSON: %s", err)
+	}
+
+	tflog.Debug(ctx, "Constructed provisioning policy resource:\n"+string(requestBodyJSON))
+
+	return requestBody, nil
+}

internal/resources/devicemanagement/v1.0/cloudPcProvisioningPolicy/crud.go

@@ -0,0 +1,158 @@
+package graphCloudPcProvisioningPolicy
+
+import (
+	"context"
+	"fmt"
+	"time"
+
+	"github.com/deploymenttheory/terraform-provider-microsoft365/internal/resources/common"
+	"github.com/hashicorp/terraform-plugin-framework/resource"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+)
+
+// Create handles the Create operation.
+func (r *CloudPcProvisioningPolicyResource) Create(ctx context.Context, req resource.CreateRequest, resp *resource.CreateResponse) {
+	var plan CloudPcProvisioningPolicyResourceModel
+
+	tflog.Debug(ctx, fmt.Sprintf("Starting creation of resource: %s_%s", r.ProviderTypeName, r.TypeName))
+
+	resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	createTimeout, diags := plan.Timeouts.Create(ctx, 30*time.Second)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	ctx, cancel := context.WithTimeout(ctx, createTimeout)
+	defer cancel()
+
+	requestBody, err := constructResource(ctx, &plan)
+	if err != nil {
+		resp.Diagnostics.AddError(
+			"Error constructing provisioning policy",
+			fmt.Sprintf("Could not construct resource: %s_%s: %s", r.ProviderTypeName, r.TypeName, err.Error()),
+		)
+		return
+	}
+
+	provisioningPolicy, err := r.client.DeviceManagement().VirtualEndpoint().ProvisioningPolicies().Post(ctx, requestBody, nil)
+	if err != nil {
+		resp.Diagnostics.AddError(
+			"Error creating provisioning policy",
+			fmt.Sprintf("Could not create provisioning policy: %s", err.Error()),
+		)
+		return
+	}
+
+	plan.ID = types.StringValue(*provisioningPolicy.GetId())
+
+	mapRemoteStateToTerraform(ctx, &plan, provisioningPolicy)
+
+	resp.Diagnostics.Append(resp.State.Set(ctx, &plan)...)
+
+	tflog.Debug(ctx, fmt.Sprintf("Finished Create Method: %s_%s", r.ProviderTypeName, r.TypeName))
+}
+
+// Read handles the Read operation.
+func (r *CloudPcProvisioningPolicyResource) Read(ctx context.Context, req resource.ReadRequest, resp *resource.ReadResponse) {
+	var state CloudPcProvisioningPolicyResourceModel
+	tflog.Debug(ctx, "Starting Read method for provisioning policy")
+
+	resp.Diagnostics.Append(req.State.Get(ctx, &state)...)
+
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	tflog.Debug(ctx, fmt.Sprintf("Reading provisioning policy with ID: %s", state.ID.ValueString()))
+	readTimeout, diags := state.Timeouts.Read(ctx, 30*time.Second)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	ctx, cancel := context.WithTimeout(ctx, readTimeout)
+	defer cancel()
+
+	provisioningPolicy, err := r.client.DeviceManagement().VirtualEndpoint().ProvisioningPolicies().ByCloudPcProvisioningPolicyId(state.ID.ValueString()).Get(ctx, nil)
+	if err != nil {
+		common.HandleReadStateError(ctx, resp, r, &state, err)
+		return
+	}
+
+	mapRemoteStateToTerraform(ctx, &state, provisioningPolicy)
+	resp.Diagnostics.Append(resp.State.Set(ctx, &state)...)
+	tflog.Debug(ctx, fmt.Sprintf("Finished Read Method: %s_%s", r.ProviderTypeName, r.TypeName))
+}
+
+// Update handles the Update operation.
+func (r *CloudPcProvisioningPolicyResource) Update(ctx context.Context, req resource.UpdateRequest, resp *resource.UpdateResponse) {
+	var plan CloudPcProvisioningPolicyResourceModel
+
+	tflog.Debug(ctx, fmt.Sprintf("Starting Update of resource: %s_%s", r.ProviderTypeName, r.TypeName))
+
+	resp.Diagnostics.Append(req.Plan.Get(ctx, &plan)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	updateTimeout, diags := plan.Timeouts.Update(ctx, 30*time.Second)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	ctx, cancel := context.WithTimeout(ctx, updateTimeout)
+	defer cancel()
+
+	requestBody, err := constructResource(ctx, &plan)
+	if err != nil {
+		resp.Diagnostics.AddError(
+			"Error constructing provisioning policy",
+			fmt.Sprintf("Could not construct resource: %s_%s: %s", r.ProviderTypeName, r.TypeName, err.Error()),
+		)
+		return
+	}
+
+	_, err = r.client.DeviceManagement().VirtualEndpoint().ProvisioningPolicies().ByCloudPcProvisioningPolicyId(plan.ID.ValueString()).Patch(ctx, requestBody, nil)
+	if err != nil {
+		common.HandleUpdateStateError(ctx, resp, r, &plan, err)
+		return
+	}
+
+	resp.Diagnostics.Append(resp.State.Set(ctx, &plan)...)
+
+	tflog.Debug(ctx, fmt.Sprintf("Finished Update Method: %s_%s", r.ProviderTypeName, r.TypeName))
+}
+
+// Delete handles the Delete operation.
+func (r *CloudPcProvisioningPolicyResource) Delete(ctx context.Context, req resource.DeleteRequest, resp *resource.DeleteResponse) {
+	var data CloudPcProvisioningPolicyResourceModel
+
+	tflog.Debug(ctx, fmt.Sprintf("Starting deletion of resource: %s_%s", r.ProviderTypeName, r.TypeName))
+
+	resp.Diagnostics.Append(req.State.Get(ctx, &data)...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+
+	deleteTimeout, diags := data.Timeouts.Delete(ctx, 30*time.Second)
+	resp.Diagnostics.Append(diags...)
+	if resp.Diagnostics.HasError() {
+		return
+	}
+	ctx, cancel := context.WithTimeout(ctx, deleteTimeout)
+	defer cancel()
+
+	err := r.client.DeviceManagement().VirtualEndpoint().ProvisioningPolicies().ByCloudPcProvisioningPolicyId(data.ID.ValueString()).Delete(ctx, nil)
+	if err != nil {
+		resp.Diagnostics.AddError(fmt.Sprintf("Client error when deleting %s_%s", r.ProviderTypeName, r.TypeName), err.Error())
+		return
+	}
+
+	tflog.Debug(ctx, fmt.Sprintf("Finished Delete Method: %s_%s", r.ProviderTypeName, r.TypeName))
+
+	resp.State.RemoveResource(ctx)
+}