1.0.0

internal/service/cloudapi/lb/flattens/flatten_resource_lb.go

@@ -0,0 +1,148 @@
+package flattens
+
+import (
+	"context"
+	"encoding/json"
+	"fmt"
+
+	"github.com/hashicorp/terraform-plugin-framework/diag"
+	"github.com/hashicorp/terraform-plugin-framework/types"
+	"github.com/hashicorp/terraform-plugin-log/tflog"
+	decort "repository.basistech.ru/BASIS/decort-golang-sdk"
+	"repository.basistech.ru/BASIS/decort-golang-sdk/pkg/cloudapi/lb"
+	"repository.basistech.ru/BASIS/terraform-provider-dynamix/internal/service/cloudapi/lb/models"
+	"repository.basistech.ru/BASIS/terraform-provider-dynamix/internal/service/cloudapi/lb/utilities"
+)
+
+func LBResource(ctx context.Context, plan *models.ResourceLBModel, c *decort.DecortClient) diag.Diagnostics {
+	tflog.Info(ctx, "Start flattens.LBResource")
+
+	diags := diag.Diagnostics{}
+
+	recordItemLB, diags := utilities.LBResourceCheckPresence(ctx, plan, c)
+	if diags.HasError() {
+		return diags
+	}
+
+	acl, _ := json.Marshal(recordItemLB.ACL)
+
+	*plan = models.ResourceLBModel{
+		RGID:     plan.RGID,
+		Name:     plan.Name,
+		ExtNetID: plan.ExtNetID,
+		VINSID:   plan.VINSID,
+		Start:    plan.Start,
+		ID:       plan.ID,
+
+		HAMode:       types.BoolValue(recordItemLB.HAMode),
+		Safe:         plan.Safe,
+		Timeouts:     plan.Timeouts,
+		SysctlParams: plan.SysctlParams,
+		Permanently:  plan.Permanently,
+		Restart:      plan.Restart,
+		Enable:       plan.Enable,
+		ConfigReset:  plan.ConfigReset,
+
+		ACL:           types.StringValue(string(acl)),
+		BackendHAIP:   types.StringValue(recordItemLB.BackendHAIP),
+		Backends:      flattenBackendsInLB(ctx, recordItemLB.Backends),
+		CreatedBy:     types.StringValue(recordItemLB.CreatedBy),
+		CreatedTime:   types.Int64Value(int64(recordItemLB.CreatedTime)),
+		DeletedBy:     types.StringValue(recordItemLB.DeletedBy),
+		DeletedTime:   types.Int64Value(int64(recordItemLB.DeletedTime)),
+		Description:   types.StringValue(recordItemLB.Description),
+		DPAPIUser:     types.StringValue(recordItemLB.DPAPIUser),
+		FrontendHAIP:  types.StringValue(recordItemLB.FrontendHAIP),
+		Frontends:     flattenFrontendsInLB(ctx, recordItemLB.Frontends),
+		GID:           types.Int64Value(int64(recordItemLB.GID)),
+		GUID:          types.Int64Value(int64(recordItemLB.GUID)),
+		ImageID:       types.Int64Value(int64(recordItemLB.ImageID)),
+		LBID:          types.Int64Value(int64(recordItemLB.ID)),
+		Milestones:    types.Int64Value(int64(recordItemLB.Milestones)),
+		ManagerId:     types.Int64Value(int64(recordItemLB.ManagerId)),
+		ManagerType:   types.StringValue(recordItemLB.ManagerType),
+		PartK8s:       types.BoolValue(recordItemLB.PartK8s),
+		PrimaryNode:   flattenNodeInLB(ctx, recordItemLB.PrimaryNode),
+		RGName:        types.StringValue(recordItemLB.RGName),
+		SecondaryNode: flattenNodeInLB(ctx, recordItemLB.SecondaryNode),
+		Status:        types.StringValue(recordItemLB.Status),
+		TechStatus:    types.StringValue(recordItemLB.TechStatus),
+		UpdatedBy:     types.StringValue(recordItemLB.UpdatedBy),
+		UpdatedTime:   types.Int64Value(int64(recordItemLB.UpdatedTime)),
+		UserManaged:   types.BoolValue(recordItemLB.UserManaged),
+	}
+
+	tflog.Info(ctx, "End flattens.LBResource", map[string]any{"id": plan.ID.ValueString()})
+	return nil
+}
+
+func flattenBackendsInLB(ctx context.Context, backends []lb.ItemBackend) types.List {
+	tflog.Info(ctx, "Start flattenBackendsInLB")
+	tempSlice := make([]types.Object, 0, len(backends))
+	for _, backend := range backends {
+		b := models.ItemBackendModel{
+			Algorithm:             types.StringValue(backend.Algorithm),
+			GUID:                  types.StringValue(backend.GUID),
+			Name:                  types.StringValue(backend.Name),
+			ServerDefaultSettings: flattenServersSettings(ctx, backend.ServerDefaultSettings),
+			Servers:               flattenServersInLB(ctx, backend.Servers),
+		}
+		obj, diags := types.ObjectValueFrom(ctx, models.ItemBackend, b)
+		if diags != nil {
+			tflog.Error(ctx, fmt.Sprint("Error flattenBackendsInLB struct to obj", diags))
+		}
+		tempSlice = append(tempSlice, obj)
+	}
+
+	res, diags := types.ListValueFrom(ctx, types.ObjectType{AttrTypes: models.ItemBackend}, tempSlice)
+	if diags != nil {
+		tflog.Error(ctx, fmt.Sprint("Error flattenBackendsInLB", diags))
+	}
+
+	tflog.Info(ctx, "End flattenBackendsInLB")
+	return res
+}
+
+func flattenFrontendsInLB(ctx context.Context, frontends []lb.ItemFrontend) types.List {
+	tflog.Info(ctx, "Start flattenFrontendsInLB")
+	tempSlice := make([]types.Object, 0, len(frontends))
+	for _, frontend := range frontends {
+		b := models.ItemFrontendModel{
+			Backend:  types.StringValue(frontend.Backend),
+			Bindings: flattenBindingsInLB(ctx, frontend.Bindings),
+			GUID:     types.StringValue(frontend.GUID),
+			Name:     types.StringValue(frontend.Name),
+		}
+		obj, diags := types.ObjectValueFrom(ctx, models.ItemFrontend, b)
+		if diags != nil {
+			tflog.Error(ctx, fmt.Sprint("Error flattenFrontendsInLB struct to obj", diags))
+		}
+		tempSlice = append(tempSlice, obj)
+	}
+
+	res, diags := types.ListValueFrom(ctx, types.ObjectType{AttrTypes: models.ItemFrontend}, tempSlice)
+	if diags != nil {
+		tflog.Error(ctx, fmt.Sprint("Error flattenFrontendsInLB", diags))
+	}
+
+	tflog.Info(ctx, "End flattenFrontendsInLB")
+	return res
+}
+
+func flattenNodeInLB(ctx context.Context, node lb.RecordNode) types.Object {
+	tflog.Info(ctx, "Start flattenNodeInLB")
+	n := models.RecordNodeModel{
+		BackendIP:  types.StringValue(node.BackendIP),
+		ComputeID:  types.Int64Value(int64(node.ComputeID)),
+		FrontendIP: types.StringValue(node.FrontendIP),
+		GUID:       types.StringValue(node.GUID),
+		MGMTIP:     types.StringValue(node.MGMTIP),
+		NetworkID:  types.Int64Value(int64(node.NetworkID)),
+	}
+	obj, diags := types.ObjectValueFrom(ctx, models.ItemNode, n)
+	if diags != nil {
+		tflog.Error(ctx, fmt.Sprint("Error flattenNodeInLB struct to obj", diags))
+	}
+	tflog.Info(ctx, "End flattenNodeInLB")
+	return obj
+}