terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/instance/functions.go

package postgresflexalpha

import (
	"context"
	"fmt"

	"github.com/hashicorp/terraform-plugin-framework/attr"
	"github.com/hashicorp/terraform-plugin-framework/types"
	"github.com/hashicorp/terraform-plugin-framework/types/basetypes"

	postgresflex "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/pkg_gen/postgresflexalpha"
	postgresflexalphadatasource "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/instance/datasources_gen"
	postgresflexalpharesource "tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/services/postgresflexalpha/instance/resources_gen"
	"tf-provider.git.onstackit.cloud/stackit-dev-tools/terraform-provider-stackitprivatepreview/stackit/internal/utils"
)

func mapGetInstanceResponseToModel(
	ctx context.Context,
	m *postgresflexalpharesource.InstanceModel,
	resp *postgresflex.GetInstanceResponse,
) error {
	m.BackupSchedule = types.StringValue(resp.GetBackupSchedule())
	m.Encryption = postgresflexalpharesource.NewEncryptionValueNull()
	if resp.HasEncryption() {
		m.Encryption = postgresflexalpharesource.NewEncryptionValueMust(
			m.Encryption.AttributeTypes(ctx),
			map[string]attr.Value{
				"kek_key_id":      types.StringValue(resp.Encryption.GetKekKeyId()),
				"kek_key_ring_id": types.StringValue(resp.Encryption.GetKekKeyRingId()),
				"kek_key_version": types.StringValue(resp.Encryption.GetKekKeyVersion()),
				"service_account": types.StringValue(resp.Encryption.GetServiceAccount()),
			},
		)
	}

	isConnectionInfoIncomplete := resp.ConnectionInfo == nil || resp.ConnectionInfo.Write == nil ||
		resp.ConnectionInfo.Write.Host == nil || *resp.ConnectionInfo.Write.Host == "" ||
		resp.ConnectionInfo.Write.Port == nil || *resp.ConnectionInfo.Write.Port == 0

	if isConnectionInfoIncomplete {
		m.ConnectionInfo = postgresflexalpharesource.NewConnectionInfoValueNull()
	} else {
		m.ConnectionInfo = postgresflexalpharesource.NewConnectionInfoValueMust(
			postgresflexalpharesource.ConnectionInfoValue{}.AttributeTypes(ctx),
			map[string]attr.Value{
				"write": postgresflexalpharesource.NewWriteValueMust(
					postgresflexalpharesource.WriteValue{}.AttributeTypes(ctx),
					map[string]attr.Value{
						"host": types.StringPointerValue(resp.ConnectionInfo.Write.Host),
						"port": types.Int64PointerValue(resp.ConnectionInfo.Write.Port),
					},
				),
			},
		)
	}

	m.FlavorId = types.StringValue(resp.GetFlavorId())
	if m.Id.IsNull() || m.Id.IsUnknown() {
		m.Id = utils.BuildInternalTerraformId(
			m.ProjectId.ValueString(),
			m.Region.ValueString(),
			m.InstanceId.ValueString(),
		)
	}
	m.InstanceId = types.StringPointerValue(resp.Id)

	m.IsDeletable = types.BoolValue(resp.GetIsDeletable())

	netAcl, diags := types.ListValueFrom(ctx, types.StringType, resp.Network.GetAcl())
	if diags.HasError() {
		return fmt.Errorf("failed converting network acl from response")
	}

	m.Acl = netAcl

	netInstAdd := types.StringValue("")
	if instAdd, ok := resp.Network.GetInstanceAddressOk(); ok {
		netInstAdd = types.StringValue(instAdd)
	}

	netRtrAdd := types.StringValue("")
	if rtrAdd, ok := resp.Network.GetRouterAddressOk(); ok {
		netRtrAdd = types.StringValue(rtrAdd)
	}

	net, diags := postgresflexalpharesource.NewNetworkValue(
		postgresflexalpharesource.NetworkValue{}.AttributeTypes(ctx),
		map[string]attr.Value{
			"access_scope":     basetypes.NewStringValue(string(resp.Network.GetAccessScope())),
			"acl":              netAcl,
			"instance_address": netInstAdd,
			"router_address":   netRtrAdd,
		},
	)
	if diags.HasError() {
		return fmt.Errorf("failed converting network from response")
	}

	m.Network = net
	m.Replicas = types.Int64Value(int64(resp.GetReplicas()))
	m.RetentionDays = types.Int64Value(resp.GetRetentionDays())

	m.Name = types.StringValue(resp.GetName())

	m.Status = types.StringValue(string(resp.GetStatus()))

	storage, diags := postgresflexalpharesource.NewStorageValue(
		postgresflexalpharesource.StorageValue{}.AttributeTypes(ctx),
		map[string]attr.Value{
			"performance_class": types.StringValue(resp.Storage.GetPerformanceClass()),
			"size":              types.Int64Value(resp.Storage.GetSize()),
		},
	)
	if diags.HasError() {
		return fmt.Errorf("failed converting storage from response")
	}
	m.Storage = storage

	m.Version = types.StringValue(resp.GetVersion())
	return nil
}

func mapGetDataInstanceResponseToModel(
	ctx context.Context,
	m *dataSourceModel,
	resp *postgresflex.GetInstanceResponse,
) error {
	m.BackupSchedule = types.StringValue(resp.GetBackupSchedule())
	handleEncryption(m, resp)
	handleConnectionInfo(ctx, m, resp)

	m.FlavorId = types.StringValue(resp.GetFlavorId())
	m.Id = utils.BuildInternalTerraformId(m.ProjectId.ValueString(), m.Region.ValueString(), m.InstanceId.ValueString())
	m.InstanceId = types.StringPointerValue(resp.Id)
	m.IsDeletable = types.BoolValue(resp.GetIsDeletable())
	m.Name = types.StringValue(resp.GetName())

	err := handleNetwork(ctx, m, resp)
	if err != nil {
		return err
	}

	m.Replicas = types.Int64Value(int64(resp.GetReplicas()))
	m.RetentionDays = types.Int64Value(resp.GetRetentionDays())
	m.Status = types.StringValue(string(resp.GetStatus()))
	storage, diags := postgresflexalphadatasource.NewStorageValue(
		postgresflexalphadatasource.StorageValue{}.AttributeTypes(ctx),
		map[string]attr.Value{
			"performance_class": types.StringValue(resp.Storage.GetPerformanceClass()),
			"size":              types.Int64Value(resp.Storage.GetSize()),
		},
	)
	if diags.HasError() {
		return fmt.Errorf("failed converting storage from response")
	}
	m.Storage = storage
	m.Version = types.StringValue(resp.GetVersion())
	return nil
}

func handleConnectionInfo(ctx context.Context, m *dataSourceModel, resp *postgresflex.GetInstanceResponse) {
	isConnectionInfoIncomplete := resp.ConnectionInfo == nil || resp.ConnectionInfo.Write == nil ||
		resp.ConnectionInfo.Write.Host == nil || *resp.ConnectionInfo.Write.Host == "" ||
		resp.ConnectionInfo.Write.Port == nil || *resp.ConnectionInfo.Write.Port == 0

	if isConnectionInfoIncomplete {
		m.ConnectionInfo = postgresflexalphadatasource.NewConnectionInfoValueNull()
	} else {
		m.ConnectionInfo = postgresflexalphadatasource.NewConnectionInfoValueMust(
			postgresflexalphadatasource.ConnectionInfoValue{}.AttributeTypes(ctx),
			map[string]attr.Value{
				"write": postgresflexalphadatasource.NewWriteValueMust(
					postgresflexalphadatasource.WriteValue{}.AttributeTypes(ctx),
					map[string]attr.Value{
						"host": types.StringPointerValue(resp.ConnectionInfo.Write.Host),
						"port": types.Int64PointerValue(resp.ConnectionInfo.Write.Port),
					},
				),
			},
		)
	}
}

func handleNetwork(ctx context.Context, m *dataSourceModel, resp *postgresflex.GetInstanceResponse) error {
	netAcl, diags := types.ListValueFrom(ctx, types.StringType, resp.Network.GetAcl())
	if diags.HasError() {
		return fmt.Errorf("failed converting network acl from response")
	}

	instAddr := ""
	if iA, ok := resp.Network.GetInstanceAddressOk(); ok {
		instAddr = iA
	}

	rtrAddr := ""
	if rA, ok := resp.Network.GetRouterAddressOk(); ok {
		rtrAddr = rA
	}

	net, diags := postgresflexalphadatasource.NewNetworkValue(
		postgresflexalphadatasource.NetworkValue{}.AttributeTypes(ctx),
		map[string]attr.Value{
			"access_scope":     types.StringValue(string(resp.Network.GetAccessScope())),
			"acl":              netAcl,
			"instance_address": types.StringValue(instAddr),
			"router_address":   types.StringValue(rtrAddr),
		},
	)
	if diags.HasError() {
		return fmt.Errorf("failed converting network from response")
	}
	m.Network = net
	return nil
}

func handleEncryption(m *dataSourceModel, resp *postgresflex.GetInstanceResponse) {
	keyId := ""
	if keyIdVal, ok := resp.Encryption.GetKekKeyIdOk(); ok {
		keyId = keyIdVal
	}

	keyRingId := ""
	if keyRingIdVal, ok := resp.Encryption.GetKekKeyRingIdOk(); ok {
		keyRingId = keyRingIdVal
	}

	keyVersion := ""
	if keyVersionVal, ok := resp.Encryption.GetKekKeyVersionOk(); ok {
		keyVersion = keyVersionVal
	}

	svcAcc := ""
	if svcAccVal, ok := resp.Encryption.GetServiceAccountOk(); ok {
		svcAcc = svcAccVal
	}

	m.Encryption = postgresflexalphadatasource.EncryptionValue{
		KekKeyId:       types.StringValue(keyId),
		KekKeyRingId:   types.StringValue(keyRingId),
		KekKeyVersion:  types.StringValue(keyVersion),
		ServiceAccount: types.StringValue(svcAcc),
	}
}