[ADD] : deployment add command to select existing resources to map to application environments

application/service/models.go

@@ -67,7 +67,7 @@ type Environment struct {
 
 // Application represents an application with its associated environments.
 type Application struct {
-	ID   int           `json:"id"`                     // Unique identifier of the application
+	ID   int64         `json:"id"`                     // Unique identifier of the application
 	Name string        `json:"name"`                   // Name of the application
 	Envs []Environment `json:"environments,omitempty"` // List of associated environments
 }

deploymentspace/handler/deployment.go

@@ -0,0 +1,41 @@
+// Package handler is used to import data from external sources
+// this package has an Add(ctx *gofr.Context) method that is used to configure deployment space
+// for the environments of applications.
+package handler
+
+import "gofr.dev/pkg/gofr"
+
+// Handler is responsible for handling requests related to deployment operations.
+type Handler struct {
+	deployService DeploymentService
+}
+
+// New initializes a new Handler instance.
+//
+// Parameters:
+//   - depSvc: An instance of DeploymentService used to manage deployment-related operations.
+//
+// Returns:
+//   - A pointer to the Handler instance.
+func New(depSvc DeploymentService) *Handler {
+	return &Handler{
+		deployService: depSvc,
+	}
+}
+
+// Add processes a deployment creation request.
+//
+// Parameters:
+//   - ctx: The context object containing request and session details.
+//
+// Returns:
+//   - A success message if the deployment is created successfully.
+//   - An error if the deployment creation fails.
+func (h *Handler) Add(ctx *gofr.Context) (any, error) {
+	err := h.deployService.Add(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return "Deployment Created", nil
+}

deploymentspace/handler/interface.go

@@ -0,0 +1,17 @@
+package handler
+
+import "gofr.dev/pkg/gofr"
+
+// DeploymentService defines the interface for deployment-related operations.
+//
+// It contains methods that allow adding and managing deployments.
+type DeploymentService interface {
+	// Add creates a new deployment.
+	//
+	// Parameters:
+	//  - ctx: The context object containing request and session details.
+	//
+	// Returns:
+	//  - An error if the deployment creation fails.
+	Add(ctx *gofr.Context) error
+}

deploymentspace/service/deployment.go

@@ -0,0 +1,219 @@
+// Package service provides structures and interfaces for managing deployment options and related operations.
+package service
+
+import (
+	"encoding/json"
+	"errors"
+	"fmt"
+	"net/http"
+	"strings"
+
+	"gofr.dev/pkg/gofr"
+	"gofr.dev/pkg/gofr/cmd/terminal"
+
+	"zop.dev/cli/zop/utils"
+)
+
+var (
+
+	// ErrConnectingZopAPI is returned when there is an error connecting to the Zop API.
+	ErrConnectingZopAPI = errors.New("unable to connect to Zop API")
+
+	// ErrGettingDeploymentOptions is returned when there is an error adding an environment.
+	ErrGettingDeploymentOptions = errors.New("unable to get deployment options")
+
+	// ErrorFetchingEnvironments is returned when there is an error fetching environments for a given application.
+	ErrorFetchingEnvironments = errors.New("unable to fetch environments")
+
+	// ErrUnknown is returned when an unknown error occurs while processing the request.
+	ErrUnknown = errors.New("unknown error occurred while processing the request")
+)
+
+// Service represents the core service that handles cloud account and environment-related operations.
+type Service struct {
+	cloudGet CloudAccountService
+	envGet   EnvironmentService
+}
+
+// New initializes a new Service instance.
+//
+// Parameters:
+//   - cloudGet: A CloudAccountService instance for retrieving cloud accounts.
+//   - envGet: An EnvironmentService instance for retrieving environments.
+//
+// Returns:
+//   - A pointer to the Service instance.
+func New(cloudGet CloudAccountService, envGet EnvironmentService) *Service {
+	return &Service{
+		cloudGet: cloudGet,
+		envGet:   envGet,
+	}
+}
+
+// Add handles the addition of a deployment configuration.
+//
+// This function selects a cloud account and environment, retrieves deployment options,
+// processes the options, and submits the deployment request.
+//
+// Parameters:
+//   - ctx: The context object containing request and session details.
+//
+// Returns:
+//   - An error if any step in the process fails.
+func (s *Service) Add(ctx *gofr.Context) error {
+	var request = make(map[string]any)
+
+	cloudAcc, err := s.getSelectedCloudAccount(ctx)
+	if err != nil {
+		return err
+	}
+
+	request["cloudAccount"] = cloudAcc
+
+	ctx.Out.Println("Selected cloud account: ", cloudAcc.Name)
+
+	env, err := s.getSelectedEnvironment(ctx)
+	if err != nil {
+		return err
+	}
+
+	ctx.Out.Println("Selected environment"+
+		":", env.Name)
+
+	options, err := getDeploymentSpaceOptions(ctx, cloudAcc.ID)
+	if err != nil {
+		return err
+	}
+
+	request[options.Type] = options
+
+	if er := processOptions(ctx, request, options.Path); er != nil {
+		return er
+	}
+
+	return submitDeployment(ctx, env.ID, request)
+}
+
+func processOptions(ctx *gofr.Context, request map[string]any, path string) error {
+	var (
+		optionName string
+		sp         = terminal.NewDotSpinner(ctx.Out)
+		api        = ctx.GetHTTPService("api-service")
+	)
+
+	sp.Spin(ctx)
+
+	resp, err := api.Get(ctx, path[1:], nil)
+	if err != nil {
+		ctx.Logger.Errorf("error connecting to zop api! %v", err)
+		return ErrConnectingZopAPI
+	}
+
+	var option apiResponse
+	if er := utils.GetResponse(resp, &option); er != nil {
+		ctx.Logger.Errorf("error fetching deployment options! %v", er)
+
+		return ErrGettingDeploymentOptions
+	}
+
+	resp.Body.Close()
+	sp.Stop()
+
+	for {
+		optionName = "option"
+
+		if option.Data.Metadata != nil {
+			optionName = option.Data.Metadata.Name
+		}
+
+		opt, er := getSelectedOption(ctx, option.Data.Option, optionName)
+		if er != nil {
+			return er
+		}
+
+		sp.Spin(ctx)
+
+		updateRequestWithOption(request, opt)
+
+		if option.Data.Next == nil {
+			break
+		}
+
+		params := getParameters(opt, &option)
+
+		resp, er = api.Get(ctx, option.Data.Next.Path[1:]+params, nil)
+		if er != nil {
+			ctx.Logger.Errorf("error connecting to zop api! %v", er)
+			return ErrConnectingZopAPI
+		}
+
+		option.Data = nil
+
+		er = utils.GetResponse(resp, &option)
+		if er != nil {
+			ctx.Logger.Errorf("error fetching deployment options! %v", er)
+			return ErrGettingDeploymentOptions
+		}
+
+		resp.Body.Close()
+		sp.Stop()
+	}
+
+	return nil
+}
+
+func updateRequestWithOption(request, opt map[string]any) {
+	keys := strings.Split(opt["type"].(string), ".")
+	current := request
+
+	for i, key := range keys {
+		if i == len(keys)-1 {
+			current[key] = opt
+			break
+		}
+
+		if _, exists := current[key]; !exists {
+			current[key] = make(map[string]any)
+		}
+
+		current = current[key].(map[string]any)
+	}
+}
+
+func submitDeployment(ctx *gofr.Context, envID int64, request map[string]any) error {
+	b, err := json.Marshal(request)
+	if err != nil {
+		return err
+	}
+
+	resp, err := ctx.GetHTTPService("api-service").
+		PostWithHeaders(ctx, fmt.Sprintf("environments/%d/deploymentspace", envID), nil, b, map[string]string{
+			"Content-Type": "application/json",
+		})
+	if err != nil {
+		return ErrConnectingZopAPI
+	}
+
+	if resp.StatusCode != http.StatusCreated {
+		var er ErrorResponse
+
+		err = utils.GetResponse(resp, &er)
+		if err != nil {
+			return ErrUnknown
+		}
+
+		return &er
+	}
+
+	return resp.Body.Close()
+}
+
+func getParameters(opt map[string]any, options *apiResponse) string {
+	params := "?"
+
+	for _, v := range options.Data.Next.Params {
+		params += fmt.Sprintf("&%s=%s", v, opt[v])
+	}
+
+	return params
+}

deploymentspace/service/errors.go

@@ -0,0 +1,28 @@
+package service
+
+import "fmt"
+
+// ErrNoItemSelected represents an error that occurs when no item of a specific type is selected.
+type ErrNoItemSelected struct {
+	Type string
+}
+
+// Error returns the error message for ErrNoItemSelected.
+//
+// This method satisfies the error interface.
+//
+// Returns:
+//   - A formatted error message indicating the type of the unselected item.
+func (e *ErrNoItemSelected) Error() string {
+	return fmt.Sprintf("no %s selected", e.Type)
+}
+
+type ErrorResponse struct {
+	Er struct {
+		Message string `json:"message"`
+	} `json:"error"`
+}
+
+func (e *ErrorResponse) Error() string {
+	return e.Er.Message
+}

deploymentspace/service/interface.go

@@ -0,0 +1,36 @@
+package service
+
+import (
+	"gofr.dev/pkg/gofr"
+
+	cloudSvc "zop.dev/cli/zop/cloud/service/list"
+	envSvc "zop.dev/cli/zop/environment/service"
+)
+
+// CloudAccountService defines the interface for managing cloud accounts.
+// It provides methods to retrieve cloud accounts available to the user.
+type CloudAccountService interface {
+	// GetAccounts retrieves a list of cloud accounts.
+	//
+	// Parameters:
+	//  - ctx: The context object containing request and session details.
+	//
+	// Returns:
+	//  - A slice of pointers to CloudAccountResponse objects.
+	//  - An error if the retrieval fails.
+	GetAccounts(ctx *gofr.Context) ([]*cloudSvc.CloudAccountResponse, error)
+}
+
+// EnvironmentService defines the interface for managing environments.
+// It provides methods to list the environments associated with a user.
+type EnvironmentService interface {
+	// List retrieves a list of environments.
+	//
+	// Parameters:
+	//  - ctx: The context object containing request and session details.
+	//
+	// Returns:
+	//  - A slice of Environment objects.
+	//  - An error if the retrieval fails.
+	List(ctx *gofr.Context) ([]envSvc.Environment, error)
+}