chore(handlers): replace structs by functions for HTTP errors EE-4227 (#7664)

api/http/handler/hostmanagement/fdo/configure.go

@@ -64,7 +64,7 @@ func (handler *Handler) fdoConfigureDevice(w http.ResponseWriter, r *http.Reques
 	guid, err := request.RetrieveRouteVariableValue(r, "guid")
 	if err != nil {
 		logrus.WithError(err).Info("fdoConfigureDevice: request.RetrieveRouteVariableValue()")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoConfigureDevice: guid not found", Err: err}
+		return httperror.InternalServerError("fdoConfigureDevice: guid not found", err)
 	}
 
 	var payload deviceConfigurePayload
@@ -72,26 +72,26 @@ func (handler *Handler) fdoConfigureDevice(w http.ResponseWriter, r *http.Reques
 	err = request.DecodeAndValidateJSONPayload(r, &payload)
 	if err != nil {
 		logrus.WithError(err).Error("Invalid request payload")
-		return &httperror.HandlerError{StatusCode: http.StatusBadRequest, Message: "Invalid request payload", Err: err}
+		return httperror.BadRequest("Invalid request payload", err)
 	}
 
 	profile, err := handler.DataStore.FDOProfile().FDOProfile(portainer.FDOProfileID(payload.ProfileID))
 	if handler.DataStore.IsErrObjectNotFound(err) {
-		return &httperror.HandlerError{http.StatusNotFound, "Unable to find a FDO Profile with the specified identifier inside the database", err}
+		return httperror.NotFound("Unable to find a FDO Profile with the specified identifier inside the database", err)
 	} else if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to find a FDO Profile with the specified identifier inside the database", err}
+		return httperror.InternalServerError("Unable to find a FDO Profile with the specified identifier inside the database", err)
 	}
 
 	fileContent, err := handler.FileService.GetFileContent(profile.FilePath, "")
 	if err != nil {
 		logrus.WithError(err).Info("fdoConfigureDevice: GetFileContent")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoConfigureDevice: GetFileContent", Err: err}
+		return httperror.InternalServerError("fdoConfigureDevice: GetFileContent", err)
 	}
 
 	fdoClient, err := handler.newFDOClient()
 	if err != nil {
 		logrus.WithError(err).Info("fdoConfigureDevice: newFDOClient()")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoConfigureDevice: newFDOClient()", Err: err}
+		return httperror.InternalServerError("fdoConfigureDevice: newFDOClient()", err)
 	}
 
 	// enable fdo_sys
@@ -103,7 +103,7 @@ func (handler *Handler) fdoConfigureDevice(w http.ResponseWriter, r *http.Reques
 		"bytes":    []string{"F5"}, // this is "true" in CBOR
 	}, []byte("")); err != nil {
 		logrus.WithError(err).Info("fdoConfigureDevice: PutDeviceSVIRaw()")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoConfigureDevice: PutDeviceSVIRaw()", Err: err}
+		return httperror.InternalServerError("fdoConfigureDevice: PutDeviceSVIRaw()", err)
 	}
 
 	if err = fdoClient.PutDeviceSVIRaw(url.Values{
@@ -114,7 +114,7 @@ func (handler *Handler) fdoConfigureDevice(w http.ResponseWriter, r *http.Reques
 		"filename": []string{"DEVICE_edgeid.txt"},
 	}, []byte(payload.EdgeID)); err != nil {
 		logrus.WithError(err).Info("fdoConfigureDevice: PutDeviceSVIRaw(edgeid)")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoConfigureDevice: PutDeviceSVIRaw(edgeid)", Err: err}
+		return httperror.InternalServerError("fdoConfigureDevice: PutDeviceSVIRaw(edgeid)", err)
 	}
 
 	// write down the edgekey
@@ -126,7 +126,7 @@ func (handler *Handler) fdoConfigureDevice(w http.ResponseWriter, r *http.Reques
 		"filename": []string{"DEVICE_edgekey.txt"},
 	}, []byte(payload.EdgeKey)); err != nil {
 		logrus.WithError(err).Info("fdoConfigureDevice: PutDeviceSVIRaw(edgekey)")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoConfigureDevice: PutDeviceSVIRaw(edgekey)", Err: err}
+		return httperror.InternalServerError("fdoConfigureDevice: PutDeviceSVIRaw(edgekey)", err)
 	}
 
 	// write down the device name
@@ -138,7 +138,7 @@ func (handler *Handler) fdoConfigureDevice(w http.ResponseWriter, r *http.Reques
 		"filename": []string{"DEVICE_name.txt"},
 	}, []byte(payload.Name)); err != nil {
 		logrus.WithError(err).Info("fdoConfigureDevice: PutDeviceSVIRaw(name)")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoConfigureDevice: PutDeviceSVIRaw(name)", Err: err}
+		return httperror.InternalServerError("fdoConfigureDevice: PutDeviceSVIRaw(name)", err)
 	}
 
 	// write down the device GUID - used as the EDGE_DEVICE_GUID too
@@ -150,7 +150,7 @@ func (handler *Handler) fdoConfigureDevice(w http.ResponseWriter, r *http.Reques
 		"filename": []string{"DEVICE_GUID.txt"},
 	}, []byte(guid)); err != nil {
 		logrus.WithError(err).Info("fdoConfigureDevice: PutDeviceSVIRaw()")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoConfigureDevice: PutDeviceSVIRaw()", Err: err}
+		return httperror.InternalServerError("fdoConfigureDevice: PutDeviceSVIRaw()", err)
 	}
 
 	if err = fdoClient.PutDeviceSVIRaw(url.Values{
@@ -161,13 +161,13 @@ func (handler *Handler) fdoConfigureDevice(w http.ResponseWriter, r *http.Reques
 		"filename": []string{deploymentScriptName},
 	}, fileContent); err != nil {
 		logrus.WithError(err).Info("fdoConfigureDevice: PutDeviceSVIRaw()")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoConfigureDevice: PutDeviceSVIRaw()", Err: err}
+		return httperror.InternalServerError("fdoConfigureDevice: PutDeviceSVIRaw()", err)
 	}
 
 	b, err := cbor.Marshal([]string{"/bin/sh", deploymentScriptName})
 	if err != nil {
 		logrus.WithError(err).Error("failed to marshal string to CBOR")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoConfigureDevice: PutDeviceSVIRaw() failed to encode", Err: err}
+		return httperror.InternalServerError("fdoConfigureDevice: PutDeviceSVIRaw() failed to encode", err)
 	}
 
 	cborBytes := strings.ToUpper(hex.EncodeToString(b))
@@ -181,7 +181,7 @@ func (handler *Handler) fdoConfigureDevice(w http.ResponseWriter, r *http.Reques
 		"bytes":    []string{cborBytes},
 	}, []byte("")); err != nil {
 		logrus.WithError(err).Info("fdoConfigureDevice: PutDeviceSVIRaw()")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoConfigureDevice: PutDeviceSVIRaw()", Err: err}
+		return httperror.InternalServerError("fdoConfigureDevice: PutDeviceSVIRaw()", err)
 	}
 
 	return response.Empty(w)

api/http/handler/hostmanagement/fdo/fdo.go

@@ -89,22 +89,22 @@ func (handler *Handler) fdoConfigure(w http.ResponseWriter, r *http.Request) *ht
 	err := request.DecodeAndValidateJSONPayload(r, &payload)
 	if err != nil {
 		logrus.WithError(err).Error("Invalid request payload")
-		return &httperror.HandlerError{StatusCode: http.StatusBadRequest, Message: "Invalid request payload", Err: err}
+		return httperror.BadRequest("Invalid request payload", err)
 	}
 
 	settings := portainer.FDOConfiguration(payload)
 	if err = handler.saveSettings(settings); err != nil {
-		return &httperror.HandlerError{StatusCode: http.StatusBadRequest, Message: "Error saving FDO settings", Err: err}
+		return httperror.BadRequest("Error saving FDO settings", err)
 	}
 
 	profiles, err := handler.DataStore.FDOProfile().FDOProfiles()
 	if err != nil {
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "Error saving FDO settings", Err: err}
+		return httperror.InternalServerError("Error saving FDO settings", err)
 	}
 	if len(profiles) == 0 {
 		err = handler.addDefaultProfile()
 		if err != nil {
-			return &httperror.HandlerError{http.StatusInternalServerError, err.Error(), err}
+			return httperror.InternalServerError(err.Error(), err)
 		}
 	}
 

api/http/handler/hostmanagement/fdo/list.go

@@ -25,14 +25,14 @@ func (handler *Handler) fdoListAll(w http.ResponseWriter, r *http.Request) *http
 	fdoClient, err := handler.newFDOClient()
 	if err != nil {
 		logrus.WithError(err).Info("fdoListAll: newFDOClient()")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoRegisterDevice: newFDOClient()", Err: err}
+		return httperror.InternalServerError("fdoRegisterDevice: newFDOClient()", err)
 	}
 
 	// Get all vouchers
 	guids, err := fdoClient.GetVouchers()
 	if err != nil {
 		logrus.WithError(err).Info("fdoListAll: GetVouchers()")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoListAll: GetVouchers()", Err: err}
+		return httperror.InternalServerError("fdoListAll: GetVouchers()", err)
 	}
 
 	return response.JSON(w, guids)

api/http/handler/hostmanagement/fdo/profile_create.go

@@ -45,29 +45,29 @@ func (payload *createProfileFromFileContentPayload) Validate(r *http.Request) er
 func (handler *Handler) createProfile(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
 	method, err := request.RetrieveQueryParameter(r, "method", false)
 	if err != nil {
-		return &httperror.HandlerError{http.StatusBadRequest, "Invalid query parameter: method", err}
+		return httperror.BadRequest("Invalid query parameter: method", err)
 	}
 
 	switch method {
 	case "editor":
 		return handler.createFDOProfileFromFileContent(w, r)
 	}
-	return &httperror.HandlerError{http.StatusBadRequest, "Invalid method. Value must be one of: editor", errors.New("invalid method")}
+	return httperror.BadRequest("Invalid method. Value must be one of: editor", errors.New("invalid method"))
 }
 
 func (handler *Handler) createFDOProfileFromFileContent(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
 	var payload createProfileFromFileContentPayload
 	err := request.DecodeAndValidateJSONPayload(r, &payload)
 	if err != nil {
-		return &httperror.HandlerError{http.StatusBadRequest, "Invalid request payload", err}
+		return httperror.BadRequest("Invalid request payload", err)
 	}
 
 	isUnique, err := handler.checkUniqueProfileName(payload.Name, -1)
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, err.Error(), err}
+		return httperror.InternalServerError(err.Error(), err)
 	}
 	if !isUnique {
-		return &httperror.HandlerError{http.StatusConflict, fmt.Sprintf("A profile with the name '%s' already exists", payload.Name), errors.New("a profile already exists with this name")}
+		return &httperror.HandlerError{StatusCode: http.StatusConflict, Message: fmt.Sprintf("A profile with the name '%s' already exists", payload.Name), Err: errors.New("a profile already exists with this name")}
 	}
 
 	profileID := handler.DataStore.FDOProfile().GetNextIdentifier()
@@ -78,14 +78,14 @@ func (handler *Handler) createFDOProfileFromFileContent(w http.ResponseWriter, r
 
 	filePath, err := handler.FileService.StoreFDOProfileFileFromBytes(strconv.Itoa(int(profile.ID)), []byte(payload.ProfileFileContent))
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist profile file on disk", err}
+		return httperror.InternalServerError("Unable to persist profile file on disk", err)
 	}
 	profile.FilePath = filePath
 	profile.DateCreated = time.Now().Unix()
 
 	err = handler.DataStore.FDOProfile().Create(profile)
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist the profile inside the database", err}
+		return httperror.InternalServerError("Unable to persist the profile inside the database", err)
 	}
 
 	return response.JSON(w, profile)

api/http/handler/hostmanagement/fdo/profile_delete.go

@@ -24,12 +24,12 @@ import (
 func (handler *Handler) deleteProfile(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
 	id, err := request.RetrieveNumericRouteVariableValue(r, "id")
 	if err != nil {
-		return &httperror.HandlerError{http.StatusBadRequest, "Bad request", errors.New("missing 'id' query parameter")}
+		return httperror.BadRequest("Bad request", errors.New("missing 'id' query parameter"))
 	}
 
 	err = handler.DataStore.FDOProfile().Delete(portainer.FDOProfileID(id))
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to delete Profile", err}
+		return httperror.InternalServerError("Unable to delete Profile", err)
 	}
 
 	return response.Empty(w)

api/http/handler/hostmanagement/fdo/profile_duplicate.go

@@ -26,24 +26,24 @@ import (
 func (handler *Handler) duplicateProfile(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
 	id, err := request.RetrieveNumericRouteVariableValue(r, "id")
 	if err != nil {
-		return &httperror.HandlerError{http.StatusBadRequest, "Bad request", errors.New("missing 'id' query parameter")}
+		return httperror.BadRequest("Bad request", errors.New("missing 'id' query parameter"))
 	}
 
 	originalProfile, err := handler.DataStore.FDOProfile().FDOProfile(portainer.FDOProfileID(id))
 	if handler.DataStore.IsErrObjectNotFound(err) {
-		return &httperror.HandlerError{http.StatusNotFound, "Unable to find a FDO Profile with the specified identifier inside the database", err}
+		return httperror.NotFound("Unable to find a FDO Profile with the specified identifier inside the database", err)
 	} else if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to find a FDO Profile with the specified identifier inside the database", err}
+		return httperror.InternalServerError("Unable to find a FDO Profile with the specified identifier inside the database", err)
 	}
 
 	fileContent, err := handler.FileService.GetFileContent(originalProfile.FilePath, "")
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve Profile file content", err}
+		return httperror.InternalServerError("Unable to retrieve Profile file content", err)
 	}
 
 	profileID := handler.DataStore.FDOProfile().GetNextIdentifier()
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to duplicate Profile", err}
+		return httperror.InternalServerError("Unable to duplicate Profile", err)
 	}
 
 	newProfile := &portainer.FDOProfile{
@@ -53,14 +53,14 @@ func (handler *Handler) duplicateProfile(w http.ResponseWriter, r *http.Request)
 
 	filePath, err := handler.FileService.StoreFDOProfileFileFromBytes(strconv.Itoa(int(newProfile.ID)), fileContent)
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist profile file on disk", err}
+		return httperror.InternalServerError("Unable to persist profile file on disk", err)
 	}
 	newProfile.FilePath = filePath
 	newProfile.DateCreated = time.Now().Unix()
 
 	err = handler.DataStore.FDOProfile().Create(newProfile)
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist the profile inside the database", err}
+		return httperror.InternalServerError("Unable to persist the profile inside the database", err)
 	}
 
 	return response.JSON(w, newProfile)

api/http/handler/hostmanagement/fdo/profile_inspect.go

@@ -29,17 +29,17 @@ type fdoProfileResponse struct {
 func (handler *Handler) fdoProfileInspect(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
 	id, err := request.RetrieveNumericRouteVariableValue(r, "id")
 	if err != nil {
-		return &httperror.HandlerError{http.StatusBadRequest, "Bad request", errors.New("missing 'id' query parameter")}
+		return httperror.BadRequest("Bad request", errors.New("missing 'id' query parameter"))
 	}
 
 	profile, err := handler.DataStore.FDOProfile().FDOProfile(portainer.FDOProfileID(id))
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve Profile", err}
+		return httperror.InternalServerError("Unable to retrieve Profile", err)
 	}
 
 	fileContent, err := handler.FileService.GetFileContent(profile.FilePath, "")
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve Profile file content", err}
+		return httperror.InternalServerError("Unable to retrieve Profile file content", err)
 	}
 
 	return response.JSON(w, fdoProfileResponse{

api/http/handler/hostmanagement/fdo/profile_list.go

@@ -24,7 +24,7 @@ func (handler *Handler) fdoProfileList(w http.ResponseWriter, r *http.Request) *
 
 	profiles, err := handler.DataStore.FDOProfile().FDOProfiles()
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, err.Error(), err}
+		return httperror.InternalServerError(err.Error(), err)
 	}
 
 	return response.JSON(w, profiles)

api/http/handler/hostmanagement/fdo/profile_update.go

@@ -27,40 +27,40 @@ import (
 func (handler *Handler) updateProfile(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
 	id, err := request.RetrieveNumericRouteVariableValue(r, "id")
 	if err != nil {
-		return &httperror.HandlerError{http.StatusBadRequest, "Bad request", errors.New("missing 'id' query parameter")}
+		return httperror.BadRequest("Bad request", errors.New("missing 'id' query parameter"))
 	}
 
 	var payload createProfileFromFileContentPayload
 	err = request.DecodeAndValidateJSONPayload(r, &payload)
 	if err != nil {
-		return &httperror.HandlerError{http.StatusBadRequest, "Invalid request payload", err}
+		return httperror.BadRequest("Invalid request payload", err)
 	}
 
 	profile, err := handler.DataStore.FDOProfile().FDOProfile(portainer.FDOProfileID(id))
 	if handler.DataStore.IsErrObjectNotFound(err) {
-		return &httperror.HandlerError{http.StatusNotFound, "Unable to find a FDO Profile with the specified identifier inside the database", err}
+		return httperror.NotFound("Unable to find a FDO Profile with the specified identifier inside the database", err)
 	} else if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to find a FDO Profile with the specified identifier inside the database", err}
+		return httperror.InternalServerError("Unable to find a FDO Profile with the specified identifier inside the database", err)
 	}
 
 	isUnique, err := handler.checkUniqueProfileName(payload.Name, id)
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, err.Error(), err}
+		return httperror.InternalServerError(err.Error(), err)
 	}
 	if !isUnique {
-		return &httperror.HandlerError{http.StatusConflict, fmt.Sprintf("A profile with the name '%s' already exists", payload.Name), errors.New("a profile already exists with this name")}
+		return &httperror.HandlerError{StatusCode: http.StatusConflict, Message: fmt.Sprintf("A profile with the name '%s' already exists", payload.Name), Err: errors.New("a profile already exists with this name")}
 	}
 
 	filePath, err := handler.FileService.StoreFDOProfileFileFromBytes(strconv.Itoa(int(profile.ID)), []byte(payload.ProfileFileContent))
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to update profile", err}
+		return httperror.InternalServerError("Unable to update profile", err)
 	}
 	profile.FilePath = filePath
 	profile.Name = payload.Name
 
 	err = handler.DataStore.FDOProfile().Update(profile.ID, profile)
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to update profile", err}
+		return httperror.InternalServerError("Unable to update profile", err)
 	}
 
 	return response.JSON(w, profile)

api/http/handler/hostmanagement/fdo/register.go

@@ -30,19 +30,19 @@ func (handler *Handler) fdoRegisterDevice(w http.ResponseWriter, r *http.Request
 	ov, filename, err := request.RetrieveMultiPartFormFile(r, "voucher")
 	if err != nil {
 		logrus.WithField("filename", filename).WithError(err).Info("fdoRegisterDevice: readVoucher()")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoRegisterDevice: read Voucher()", Err: err}
+		return httperror.InternalServerError("fdoRegisterDevice: read Voucher()", err)
 	}
 
 	fdoClient, err := handler.newFDOClient()
 	if err != nil {
 		logrus.WithError(err).Info("fdoRegisterDevice: newFDOClient()")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoRegisterDevice: newFDOClient()", Err: err}
+		return httperror.InternalServerError("fdoRegisterDevice: newFDOClient()", err)
 	}
 
 	guid, err := fdoClient.PostVoucher(ov)
 	if err != nil {
 		logrus.WithError(err).Info("fdoRegisterDevice: PostVoucher()")
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "fdoRegisterDevice: PostVoucher()", Err: err}
+		return httperror.InternalServerError("fdoRegisterDevice: PostVoucher()", err)
 	}
 
 	return response.JSON(w, registerDeviceResponse{guid})

api/http/handler/hostmanagement/openamt/amtactivation.go

@@ -29,44 +29,44 @@ import (
 func (handler *Handler) openAMTActivate(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
 	endpointID, err := request.RetrieveNumericRouteVariableValue(r, "id")
 	if err != nil {
-		return &httperror.HandlerError{http.StatusBadRequest, "Invalid environment identifier route variable", err}
+		return httperror.BadRequest("Invalid environment identifier route variable", err)
 	}
 
 	endpoint, err := handler.DataStore.Endpoint().Endpoint(portainer.EndpointID(endpointID))
 	if err == bolterrors.ErrObjectNotFound {
-		return &httperror.HandlerError{StatusCode: http.StatusNotFound, Message: "Unable to find an endpoint with the specified identifier inside the database", Err: err}
+		return httperror.NotFound("Unable to find an endpoint with the specified identifier inside the database", err)
 	} else if err != nil {
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "Unable to find an endpoint with the specified identifier inside the database", Err: err}
+		return httperror.InternalServerError("Unable to find an endpoint with the specified identifier inside the database", err)
 	} else if !endpointutils.IsAgentEndpoint(endpoint) {
 		errMsg := fmt.Sprintf("%s is not an agent environment", endpoint.Name)
-		return &httperror.HandlerError{http.StatusBadRequest, errMsg, errors.New(errMsg)}
+		return httperror.BadRequest(errMsg, errors.New(errMsg))
 	}
 
 	settings, err := handler.DataStore.Settings().Settings()
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve settings from the database", err}
+		return httperror.InternalServerError("Unable to retrieve settings from the database", err)
 	}
 
 	err = handler.activateDevice(endpoint, *settings)
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to activate device", err}
+		return httperror.InternalServerError("Unable to activate device", err)
 	}
 
 	hostInfo, _, err := handler.getEndpointAMTInfo(endpoint)
 	if err != nil {
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "Unable to retrieve AMT information", Err: err}
+		return httperror.InternalServerError("Unable to retrieve AMT information", err)
 	}
 	if hostInfo.ControlModeRaw < 1 {
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "Failed to activate device", Err: errors.New("failed to activate device")}
+		return httperror.InternalServerError("Failed to activate device", errors.New("failed to activate device"))
 	}
 	if hostInfo.UUID == "" {
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "Unable to retrieve device UUID", Err: errors.New("unable to retrieve device UUID")}
+		return httperror.InternalServerError("Unable to retrieve device UUID", errors.New("unable to retrieve device UUID"))
 	}
 
 	endpoint.AMTDeviceGUID = hostInfo.UUID
 	err = handler.DataStore.Endpoint().UpdateEndpoint(endpoint.ID, endpoint)
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to persist environment changes inside the database", err}
+		return httperror.InternalServerError("Unable to persist environment changes inside the database", err)
 	}
 
 	return response.Empty(w)

api/http/handler/hostmanagement/openamt/amtconfiguration.go

@@ -74,25 +74,25 @@ func (handler *Handler) openAMTConfigure(w http.ResponseWriter, r *http.Request)
 	err := request.DecodeAndValidateJSONPayload(r, &payload)
 	if err != nil {
 		logrus.WithError(err).Error("Invalid request payload")
-		return &httperror.HandlerError{StatusCode: http.StatusBadRequest, Message: "Invalid request payload", Err: err}
+		return httperror.BadRequest("Invalid request payload", err)
 	}
 
 	if payload.Enabled {
 		certificateErr := validateCertificate(payload.CertFileContent, payload.CertFilePassword)
 		if certificateErr != nil {
-			return &httperror.HandlerError{StatusCode: http.StatusBadRequest, Message: "Error validating certificate", Err: certificateErr}
+			return httperror.BadRequest("Error validating certificate", certificateErr)
 		}
 
 		err = handler.enableOpenAMT(payload)
 		if err != nil {
-			return &httperror.HandlerError{StatusCode: http.StatusBadRequest, Message: "Error enabling OpenAMT", Err: err}
+			return httperror.BadRequest("Error enabling OpenAMT", err)
 		}
 		return response.Empty(w)
 	}
 
 	err = handler.disableOpenAMT()
 	if err != nil {
-		return &httperror.HandlerError{StatusCode: http.StatusBadRequest, Message: "Error disabling OpenAMT", Err: err}
+		return httperror.BadRequest("Error disabling OpenAMT", err)
 	}
 	return response.Empty(w)
 }

api/http/handler/hostmanagement/openamt/amtdevices.go

@@ -28,14 +28,14 @@ import (
 func (handler *Handler) openAMTDevices(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
 	endpointID, err := request.RetrieveNumericRouteVariableValue(r, "id")
 	if err != nil {
-		return &httperror.HandlerError{http.StatusBadRequest, "Invalid environment identifier route variable", err}
+		return httperror.BadRequest("Invalid environment identifier route variable", err)
 	}
 
 	endpoint, err := handler.DataStore.Endpoint().Endpoint(portainer.EndpointID(endpointID))
 	if err == bolterrors.ErrObjectNotFound {
-		return &httperror.HandlerError{StatusCode: http.StatusNotFound, Message: "Unable to find an endpoint with the specified identifier inside the database", Err: err}
+		return httperror.NotFound("Unable to find an endpoint with the specified identifier inside the database", err)
 	} else if err != nil {
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "Unable to find an endpoint with the specified identifier inside the database", Err: err}
+		return httperror.InternalServerError("Unable to find an endpoint with the specified identifier inside the database", err)
 	}
 
 	if endpoint.AMTDeviceGUID == "" {
@@ -44,12 +44,12 @@ func (handler *Handler) openAMTDevices(w http.ResponseWriter, r *http.Request) *
 
 	settings, err := handler.DataStore.Settings().Settings()
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve settings from the database", err}
+		return httperror.InternalServerError("Unable to retrieve settings from the database", err)
 	}
 
 	device, err := handler.OpenAMTService.DeviceInformation(settings.OpenAMTConfiguration, endpoint.AMTDeviceGUID)
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve device information", err}
+		return httperror.InternalServerError("Unable to retrieve device information", err)
 	}
 
 	devices := []portainer.OpenAMTDeviceInformation{
@@ -87,25 +87,25 @@ func (payload *deviceActionPayload) Validate(r *http.Request) error {
 func (handler *Handler) deviceAction(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
 	deviceID, err := request.RetrieveRouteVariableValue(r, "deviceId")
 	if err != nil {
-		return &httperror.HandlerError{http.StatusBadRequest, "Invalid device identifier route variable", err}
+		return httperror.BadRequest("Invalid device identifier route variable", err)
 	}
 
 	var payload deviceActionPayload
 	err = request.DecodeAndValidateJSONPayload(r, &payload)
 	if err != nil {
 		logrus.WithError(err).Error("Invalid request payload")
-		return &httperror.HandlerError{StatusCode: http.StatusBadRequest, Message: "Invalid request payload", Err: err}
+		return httperror.BadRequest("Invalid request payload", err)
 	}
 
 	settings, err := handler.DataStore.Settings().Settings()
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve settings from the database", err}
+		return httperror.InternalServerError("Unable to retrieve settings from the database", err)
 	}
 
 	err = handler.OpenAMTService.ExecuteDeviceAction(settings.OpenAMTConfiguration, deviceID, payload.Action)
 	if err != nil {
 		logrus.WithError(err).Error("Error executing device action")
-		return &httperror.HandlerError{StatusCode: http.StatusBadRequest, Message: "Error executing device action", Err: err}
+		return httperror.BadRequest("Error executing device action", err)
 	}
 
 	return response.Empty(w)
@@ -144,30 +144,30 @@ type AuthorizationResponse struct {
 func (handler *Handler) deviceFeatures(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
 	deviceID, err := request.RetrieveRouteVariableValue(r, "deviceId")
 	if err != nil {
-		return &httperror.HandlerError{http.StatusBadRequest, "Invalid device identifier route variable", err}
+		return httperror.BadRequest("Invalid device identifier route variable", err)
 	}
 
 	var payload deviceFeaturesPayload
 	err = request.DecodeAndValidateJSONPayload(r, &payload)
 	if err != nil {
 		logrus.WithError(err).Error("Invalid request payload")
-		return &httperror.HandlerError{StatusCode: http.StatusBadRequest, Message: "Invalid request payload", Err: err}
+		return httperror.BadRequest("Invalid request payload", err)
 	}
 
 	settings, err := handler.DataStore.Settings().Settings()
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve settings from the database", err}
+		return httperror.InternalServerError("Unable to retrieve settings from the database", err)
 	}
 
 	_, err = handler.OpenAMTService.DeviceInformation(settings.OpenAMTConfiguration, deviceID)
 	if err != nil {
-		return &httperror.HandlerError{http.StatusInternalServerError, "Unable to retrieve device information", err}
+		return httperror.InternalServerError("Unable to retrieve device information", err)
 	}
 
 	token, err := handler.OpenAMTService.EnableDeviceFeatures(settings.OpenAMTConfiguration, deviceID, payload.Features)
 	if err != nil {
 		logrus.WithError(err).Error("Error executing device action")
-		return &httperror.HandlerError{StatusCode: http.StatusBadRequest, Message: "Error executing device action", Err: err}
+		return httperror.BadRequest("Error executing device action", err)
 	}
 
 	authorizationResponse := AuthorizationResponse{

api/http/handler/hostmanagement/openamt/amtrpc.go

@@ -57,21 +57,21 @@ const (
 func (handler *Handler) openAMTHostInfo(w http.ResponseWriter, r *http.Request) *httperror.HandlerError {
 	endpointID, err := request.RetrieveNumericRouteVariableValue(r, "id")
 	if err != nil {
-		return &httperror.HandlerError{http.StatusBadRequest, "Invalid environment identifier route variable", err}
+		return httperror.BadRequest("Invalid environment identifier route variable", err)
 	}
 
 	logrus.WithField("endpointID", endpointID).Info("OpenAMTHostInfo")
 
 	endpoint, err := handler.DataStore.Endpoint().Endpoint(portainer.EndpointID(endpointID))
 	if err == bolterrors.ErrObjectNotFound {
-		return &httperror.HandlerError{StatusCode: http.StatusNotFound, Message: "Unable to find an endpoint with the specified identifier inside the database", Err: err}
+		return httperror.NotFound("Unable to find an endpoint with the specified identifier inside the database", err)
 	} else if err != nil {
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: "Unable to find an endpoint with the specified identifier inside the database", Err: err}
+		return httperror.InternalServerError("Unable to find an endpoint with the specified identifier inside the database", err)
 	}
 
 	amtInfo, output, err := handler.getEndpointAMTInfo(endpoint)
 	if err != nil {
-		return &httperror.HandlerError{StatusCode: http.StatusInternalServerError, Message: output, Err: err}
+		return httperror.InternalServerError(output, err)
 	}
 
 	return response.JSON(w, amtInfo)