hunk.code_window: .switch.business i {
     background-color: var(--BE-only);
     box-shadow: inset 0 0 1px rgb(0 0 0 / 50%), inset 0 0 40px var(--BE-only);
   }
  
hunk.labels: keep keep keep add
hunk.after_edit: .switch input[type='checkbox']:disabled + .slider {
     cursor: not-allowed;
   }
hunk.file_path: app/react/components/form-components/SwitchField/Switch.css
hunk.type: add
file: package edgestacks
  
  import (
  	"errors"
  	"github.com/portainer/portainer/api/internal/endpointutils"
  	"net/http"
  	"strconv"
  
  	httperror "github.com/portainer/libhttp/error"
  	"github.com/portainer/libhttp/request"
  	"github.com/portainer/libhttp/response"
  	portainer "github.com/portainer/portainer/api"
  	"github.com/portainer/portainer/api/filesystem"
  	"github.com/portainer/portainer/api/internal/edge"
  )
  
  type updateEdgeStackPayload struct {
  	StackFileContent string
  	Version          *int
  	EdgeGroups       []portainer.EdgeGroupID
  	DeploymentType   portainer.EdgeStackDeploymentType
  }
  
  func (payload *updateEdgeStackPayload) Validate(r *http.Request) error {
  	if payload.StackFileContent == "" {
  		return errors.New("Invalid stack file content")
  	}
  	if payload.EdgeGroups != nil && len(payload.EdgeGroups) == 0 {
  		return errors.New("Edge Groups are mandatory for an Edge stack")
  	}
  	return nil
  }
  
  // @id EdgeStackUpdate
  // @summary Update an EdgeStack
  // @description **Access policy**: administrator
  // @tags edge_stacks
  // @security ApiKeyAuth
  // @security jwt
  // @accept json
  // @produce json
  // @param id path string true "EdgeStack Id"
  // @param body body updateEdgeStackPayload true "EdgeStack data"
  // @success 200 {object} portainer.EdgeStack
  // @failure 500
  // @failure 400
  // @failure 503 "Edge compute features are disabled"
  // @router /edge_stacks/{id} [put]
  func (handler *Handler) edgeStackUpdate(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
  	stackID, err := request.RetrieveNumericRouteVariableValue(r, "id")
  	if err != nil {
  		return &httperror.HandlerError{http.StatusBadRequest, "Invalid stack identifier route variable", err}
  	}
  
  	stack, err := handler.DataStore.EdgeStack().EdgeStack(portainer.EdgeStackID(stackID))
  	if handler.DataStore.IsErrObjectNotFound(err) {
  		return &httperror.HandlerError{http.StatusNotFound, "Unable to find a stack with the specified identifier inside the database", err}
  	} else if err != nil {
  		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to find a stack with the specified identifier inside the database", err}
  	}
  
  	var payload updateEdgeStackPayload
  	err = request.DecodeAndValidateJSONPayload(r, &payload)
  	if err != nil {
  		return &httperror.HandlerError{http.StatusBadRequest, "Invalid request payload", err}
  	}
  
  	relationConfig, err := fetchEndpointRelationsConfig(handler.DataStore)
  	if err != nil {
  		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve environments relations config from database", err}
  	}
  
  	relatedEndpointIds, err := edge.EdgeStackRelatedEndpoints(stack.EdgeGroups, relationConfig.endpoints, relationConfig.endpointGroups, relationConfig.edgeGroups)
  	if err != nil {
  		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve edge stack related environments from database", err}
  	}
  
  	if payload.EdgeGroups != nil {
  		newRelated, err := edge.EdgeStackRelatedEndpoints(payload.EdgeGroups, relationConfig.endpoints, relationConfig.endpointGroups, relationConfig.edgeGroups)
  		if err != nil {
  			return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve edge stack related environments from database", err}
  		}
  
  		oldRelatedSet := endpointutils.EndpointSet(relatedEndpointIds)
  		newRelatedSet := endpointutils.EndpointSet(newRelated)
  
  		endpointsToRemove := map[portainer.EndpointID]bool{}
  		for endpointID := range oldRelatedSet {
  			if !newRelatedSet[endpointID] {
  				endpointsToRemove[endpointID] = true
  			}
  		}
  
  		for endpointID := range endpointsToRemove {
  			relation, err := handler.DataStore.EndpointRelation().EndpointRelation(endpointID)
  			if err != nil {
  				return &httperror.HandlerError{http.StatusInternalServerError, "Unable to find environment relation in database", err}
  			}
  
  			delete(relation.EdgeStacks, stack.ID)
  
  			err = handler.DataStore.EndpointRelation().UpdateEndpointRelation(endpointID, relation)
  			if err != nil {
  				return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist environment relation in database", err}
  			}
  		}
  
  		endpointsToAdd := map[portainer.EndpointID]bool{}
  		for endpointID := range newRelatedSet {
  			if !oldRelatedSet[endpointID] {
  				endpointsToAdd[endpointID] = true
  			}
  		}
  
  		for endpointID := range endpointsToAdd {
  			relation, err := handler.DataStore.EndpointRelation().EndpointRelation(endpointID)
  			if err != nil {
  				return &httperror.HandlerError{http.StatusInternalServerError, "Unable to find environment relation in database", err}
  			}
  
  			relation.EdgeStacks[stack.ID] = true
  
  			err = handler.DataStore.EndpointRelation().UpdateEndpointRelation(endpointID, relation)
  			if err != nil {
  				return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist environment relation in database", err}
  			}
  		}
  
  		stack.EdgeGroups = payload.EdgeGroups
  		relatedEndpointIds = newRelated
  	}
  
  	if stack.DeploymentType != payload.DeploymentType {
  		// deployment type was changed - need to delete the old file
  		err = handler.FileService.RemoveDirectory(stack.ProjectPath)
  		if err != nil {
  			return &httperror.HandlerError{http.StatusInternalServerError, "Unable to clear old files", err}
  		}
  
  		stack.EntryPoint = ""
  		stack.ManifestPath = ""
  		stack.DeploymentType = payload.DeploymentType
  	}
  
  	stackFolder := strconv.Itoa(int(stack.ID))
  	if payload.DeploymentType == portainer.EdgeStackDeploymentCompose {
  		if stack.EntryPoint == "" {
  			stack.EntryPoint = filesystem.ComposeFileDefaultName
  		}
  
  		_, err = handler.FileService.StoreEdgeStackFileFromBytes(stackFolder, stack.EntryPoint, []byte(payload.StackFileContent))
  		if err != nil {
  			return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist updated Compose file on disk", err}
  		}
  
  		err = handler.convertAndStoreKubeManifestIfNeeded(stack, relatedEndpointIds)
  		if err != nil {
  			return &httperror.HandlerError{http.StatusInternalServerError, "Unable to convert and persist updated Kubernetes manifest file on disk", err}
  		}
  
  	} else {
  		if stack.ManifestPath == "" {
  			stack.ManifestPath = filesystem.ManifestFileDefaultName
  		}
  
  		hasDockerEndpoint, err := hasDockerEndpoint(handler.DataStore.Endpoint(), relatedEndpointIds)
  		if err != nil {
  			return &httperror.HandlerError{http.StatusInternalServerError, "Unable to check for existence of docker environment", err}
  		}
  
  		if hasDockerEndpoint {
  			return &httperror.HandlerError{http.StatusBadRequest, "Edge stack with docker environment cannot be deployed with kubernetes config", err}
  		}
  
  		_, err = handler.FileService.StoreEdgeStackFileFromBytes(stackFolder, stack.ManifestPath, []byte(payload.StackFileContent))
  		if err != nil {
  			return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist updated Compose file on disk", err}
  		}
  	}
  
  	if payload.Version != nil && *payload.Version != stack.Version {
  		stack.Version = *payload.Version
  		stack.Status = map[portainer.EndpointID]portainer.EdgeStackStatus{}
  	}
  
  	err = handler.DataStore.EdgeStack().UpdateEdgeStack(stack.ID, stack)
  	if err != nil {
  		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist the stack changes inside the database", err}
  	}
  
  	return response.JSON(w, stack)
  }
  