Add missing fields to datasource (#596)

* add missing fields to datasource

* split resource and datasource models

Author: GokceGK

stackit/internal/services/iaas/network/datasource.go

@@ -4,17 +4,20 @@ import (
 	"context"
 	"fmt"
 	"net/http"
+	"strings"
 
 	"github.com/hashicorp/terraform-plugin-framework-validators/stringvalidator"
 	"github.com/hashicorp/terraform-plugin-framework/datasource"
 	"github.com/hashicorp/terraform-plugin-framework/datasource/schema"
+	"github.com/hashicorp/terraform-plugin-framework/diag"
 	"github.com/hashicorp/terraform-plugin-framework/schema/validator"
 	"github.com/hashicorp/terraform-plugin-framework/types"
 	"github.com/hashicorp/terraform-plugin-log/tflog"
 	"github.com/stackitcloud/stackit-sdk-go/core/config"
 	"github.com/stackitcloud/stackit-sdk-go/core/oapierror"
 	"github.com/stackitcloud/stackit-sdk-go/services/iaas"
 	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/core"
+	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/utils"
 	"github.com/stackitcloud/terraform-provider-stackit/stackit/internal/validate"
 )
 
@@ -23,6 +26,28 @@ var (
 	_ datasource.DataSource = &networkDataSource{}
 )
 
+type DataSourceModel struct {
+	Id               types.String `tfsdk:"id"` // needed by TF
+	ProjectId        types.String `tfsdk:"project_id"`
+	NetworkId        types.String `tfsdk:"network_id"`
+	Name             types.String `tfsdk:"name"`
+	Nameservers      types.List   `tfsdk:"nameservers"`
+	IPv4Gateway      types.String `tfsdk:"ipv4_gateway"`
+	IPv4Nameservers  types.List   `tfsdk:"ipv4_nameservers"`
+	IPv4Prefix       types.String `tfsdk:"ipv4_prefix"`
+	IPv4PrefixLength types.Int64  `tfsdk:"ipv4_prefix_length"`
+	Prefixes         types.List   `tfsdk:"prefixes"`
+	IPv4Prefixes     types.List   `tfsdk:"ipv4_prefixes"`
+	IPv6Gateway      types.String `tfsdk:"ipv6_gateway"`
+	IPv6Nameservers  types.List   `tfsdk:"ipv6_nameservers"`
+	IPv6Prefix       types.String `tfsdk:"ipv6_prefix"`
+	IPv6PrefixLength types.Int64  `tfsdk:"ipv6_prefix_length"`
+	IPv6Prefixes     types.List   `tfsdk:"ipv6_prefixes"`
+	PublicIP         types.String `tfsdk:"public_ip"`
+	Labels           types.Map    `tfsdk:"labels"`
+	Routed           types.Bool   `tfsdk:"routed"`
+}
+
 // NewNetworkDataSource is a helper function to simplify the provider implementation.
 func NewNetworkDataSource() datasource.DataSource {
 	return &networkDataSource{}
@@ -181,7 +206,7 @@ func (d *networkDataSource) Schema(_ context.Context, _ datasource.SchemaRequest
 
 // Read refreshes the Terraform state with the latest data.
 func (d *networkDataSource) Read(ctx context.Context, req datasource.ReadRequest, resp *datasource.ReadResponse) { // nolint:gocritic // function signature required by Terraform
-	var model Model
+	var model DataSourceModel
 	diags := req.Config.Get(ctx, &model)
 	resp.Diagnostics.Append(diags...)
 	if resp.Diagnostics.HasError() {
@@ -203,7 +228,7 @@ func (d *networkDataSource) Read(ctx context.Context, req datasource.ReadRequest
 		return
 	}
 
-	err = mapFields(ctx, networkResp, &model)
+	err = mapDataSourceFields(ctx, networkResp, &model)
 	if err != nil {
 		core.LogAndAddError(ctx, &resp.Diagnostics, "Error reading network", fmt.Sprintf("Processing API payload: %v", err))
 		return
@@ -215,3 +240,142 @@ func (d *networkDataSource) Read(ctx context.Context, req datasource.ReadRequest
 	}
 	tflog.Info(ctx, "Network read")
 }
+
+func mapDataSourceFields(ctx context.Context, networkResp *iaas.Network, model *DataSourceModel) error {
+	if networkResp == nil {
+		return fmt.Errorf("response input is nil")
+	}
+	if model == nil {
+		return fmt.Errorf("model input is nil")
+	}
+
+	var networkId string
+	if model.NetworkId.ValueString() != "" {
+		networkId = model.NetworkId.ValueString()
+	} else if networkResp.NetworkId != nil {
+		networkId = *networkResp.NetworkId
+	} else {
+		return fmt.Errorf("network id not present")
+	}
+
+	idParts := []string{
+		model.ProjectId.ValueString(),
+		networkId,
+	}
+	model.Id = types.StringValue(
+		strings.Join(idParts, core.Separator),
+	)
+
+	labels, diags := types.MapValueFrom(ctx, types.StringType, map[string]interface{}{})
+	if diags.HasError() {
+		return fmt.Errorf("converting labels to StringValue map: %w", core.DiagsToError(diags))
+	}
+	if networkResp.Labels != nil && len(*networkResp.Labels) != 0 {
+		var diags diag.Diagnostics
+		labels, diags = types.MapValueFrom(ctx, types.StringType, *networkResp.Labels)
+		if diags.HasError() {
+			return fmt.Errorf("converting labels to StringValue map: %w", core.DiagsToError(diags))
+		}
+	} else if model.Labels.IsNull() {
+		labels = types.MapNull(types.StringType)
+	}
+
+	// IPv4
+
+	if networkResp.Nameservers == nil {
+		model.Nameservers = types.ListNull(types.StringType)
+		model.IPv4Nameservers = types.ListNull(types.StringType)
+	} else {
+		respNameservers := *networkResp.Nameservers
+		modelNameservers, err := utils.ListValuetoStringSlice(model.Nameservers)
+		modelIPv4Nameservers, errIpv4 := utils.ListValuetoStringSlice(model.IPv4Nameservers)
+		if err != nil {
+			return fmt.Errorf("get current network nameservers from model: %w", err)
+		}
+		if errIpv4 != nil {
+			return fmt.Errorf("get current IPv4 network nameservers from model: %w", errIpv4)
+		}
+
+		reconciledNameservers := utils.ReconcileStringSlices(modelNameservers, respNameservers)
+		reconciledIPv4Nameservers := utils.ReconcileStringSlices(modelIPv4Nameservers, respNameservers)
+
+		nameserversTF, diags := types.ListValueFrom(ctx, types.StringType, reconciledNameservers)
+		ipv4NameserversTF, ipv4Diags := types.ListValueFrom(ctx, types.StringType, reconciledIPv4Nameservers)
+		if diags.HasError() {
+			return fmt.Errorf("map network nameservers: %w", core.DiagsToError(diags))
+		}
+		if ipv4Diags.HasError() {
+			return fmt.Errorf("map IPv4 network nameservers: %w", core.DiagsToError(ipv4Diags))
+		}
+
+		model.Nameservers = nameserversTF
+		model.IPv4Nameservers = ipv4NameserversTF
+	}
+
+	if networkResp.Prefixes == nil {
+		model.Prefixes = types.ListNull(types.StringType)
+		model.IPv4Prefixes = types.ListNull(types.StringType)
+	} else {
+		respPrefixes := *networkResp.Prefixes
+		prefixesTF, diags := types.ListValueFrom(ctx, types.StringType, respPrefixes)
+		if diags.HasError() {
+			return fmt.Errorf("map network prefixes: %w", core.DiagsToError(diags))
+		}
+
+		model.Prefixes = prefixesTF
+		model.IPv4Prefixes = prefixesTF
+	}
+
+	if networkResp.Gateway != nil {
+		model.IPv4Gateway = types.StringPointerValue(networkResp.GetGateway())
+	} else {
+		model.IPv4Gateway = types.StringNull()
+	}
+
+	// IPv6
+
+	if networkResp.NameserversV6 == nil {
+		model.IPv6Nameservers = types.ListNull(types.StringType)
+	} else {
+		respIPv6Nameservers := *networkResp.NameserversV6
+		modelIPv6Nameservers, errIpv6 := utils.ListValuetoStringSlice(model.IPv6Nameservers)
+		if errIpv6 != nil {
+			return fmt.Errorf("get current IPv6 network nameservers from model: %w", errIpv6)
+		}
+
+		reconciledIPv6Nameservers := utils.ReconcileStringSlices(modelIPv6Nameservers, respIPv6Nameservers)
+
+		ipv6NameserversTF, ipv6Diags := types.ListValueFrom(ctx, types.StringType, reconciledIPv6Nameservers)
+		if ipv6Diags.HasError() {
+			return fmt.Errorf("map IPv6 network nameservers: %w", core.DiagsToError(ipv6Diags))
+		}
+
+		model.IPv6Nameservers = ipv6NameserversTF
+	}
+
+	if networkResp.PrefixesV6 == nil {
+		model.IPv6Prefixes = types.ListNull(types.StringType)
+	} else {
+		respPrefixesV6 := *networkResp.PrefixesV6
+		prefixesV6TF, diags := types.ListValueFrom(ctx, types.StringType, respPrefixesV6)
+		if diags.HasError() {
+			return fmt.Errorf("map network IPv6 prefixes: %w", core.DiagsToError(diags))
+		}
+
+		model.IPv6Prefixes = prefixesV6TF
+	}
+
+	if networkResp.Gatewayv6 != nil {
+		model.IPv6Gateway = types.StringPointerValue(networkResp.GetGatewayv6())
+	} else {
+		model.IPv6Gateway = types.StringNull()
+	}
+
+	model.NetworkId = types.StringValue(networkId)
+	model.Name = types.StringPointerValue(networkResp.Name)
+	model.PublicIP = types.StringPointerValue(networkResp.PublicIp)
+	model.Labels = labels
+	model.Routed = types.BoolPointerValue(networkResp.Routed)
+
+	return nil
+}