agent-radar
2ed3415fb7
Publish Claude Code Binaries / Stage and publish binaries (push) Canceled after 0s
Publish Tutti App Runtime / Build darwin-arm64 (push) Canceled after 0s
Publish Tutti App Runtime / Build darwin-amd64 (push) Canceled after 0s
Publish Tutti App Runtime / Build linux-amd64 (push) Canceled after 0s
Publish Tutti App Runtime / Build windows-amd64 (push) Canceled after 0s
Sync Tutti Agent Skills / sync (push) Canceled after 0s
Windows Agent Adapters / Test Windows agent adapters (push) Canceled after 0s
Windows Daemon Adapters / Test Windows daemon adapters (push) Canceled after 0s
Publish Tutti App Runtime / Publish runtime catalog (push) Canceled after 0s
776 lines
29 KiB
Go
776 lines
29 KiB
Go
package api
|
|
|
|
import (
|
|
"context"
|
|
"strings"
|
|
|
|
tuttigenerated "github.com/tutti-os/tutti/services/tuttid/api/generated"
|
|
workspaceapi "github.com/tutti-os/tutti/services/tuttid/api/workspace"
|
|
"github.com/tutti-os/tutti/services/tuttid/apierrors"
|
|
workspaceservice "github.com/tutti-os/tutti/services/tuttid/service/workspace"
|
|
)
|
|
|
|
func workspaceAppServiceUnavailableError() tuttigenerated.ServiceUnavailableErrorJSONResponse {
|
|
return serviceUnavailableError(
|
|
apierrors.WorkspaceAppServiceUnavailable(
|
|
apierrors.WithDeveloperMessage("workspace app service is unavailable"),
|
|
),
|
|
)
|
|
}
|
|
|
|
func (api DaemonAPI) ListWorkspaceApps(ctx context.Context, request tuttigenerated.ListWorkspaceAppsRequestObject) (tuttigenerated.ListWorkspaceAppsResponseObject, error) {
|
|
if api.AppCenterService == nil {
|
|
return tuttigenerated.ListWorkspaceApps503JSONResponse{
|
|
ServiceUnavailableErrorJSONResponse: workspaceAppServiceUnavailableError(),
|
|
}, nil
|
|
}
|
|
|
|
workspaceID := strings.TrimSpace(string(request.WorkspaceID))
|
|
if workspaceID == "" {
|
|
return tuttigenerated.ListWorkspaceApps400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(
|
|
apierrors.MissingWorkspaceID(
|
|
apierrors.WithDeveloperMessage("workspace id is required"),
|
|
apierrors.WithParams(map[string]any{"field": "workspaceId"}),
|
|
),
|
|
),
|
|
}, nil
|
|
}
|
|
|
|
apps, err := api.AppCenterService.List(ctx, workspaceID)
|
|
if err != nil {
|
|
return writeListWorkspaceAppsError(err), nil
|
|
}
|
|
|
|
return tuttigenerated.ListWorkspaceApps200JSONResponse{
|
|
WorkspaceId: workspaceID,
|
|
CatalogStatus: workspaceapi.GeneratedAppCatalogLoadStateFromBiz(api.AppCenterService.CatalogLoadState()),
|
|
Apps: workspaceapi.GeneratedAppsFromBiz(apps),
|
|
}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) RefreshWorkspaceAppCatalog(ctx context.Context, request tuttigenerated.RefreshWorkspaceAppCatalogRequestObject) (tuttigenerated.RefreshWorkspaceAppCatalogResponseObject, error) {
|
|
if api.AppCenterService == nil {
|
|
return tuttigenerated.RefreshWorkspaceAppCatalog503JSONResponse{
|
|
ServiceUnavailableErrorJSONResponse: workspaceAppServiceUnavailableError(),
|
|
}, nil
|
|
}
|
|
|
|
workspaceID := strings.TrimSpace(string(request.WorkspaceID))
|
|
if workspaceID == "" {
|
|
return tuttigenerated.RefreshWorkspaceAppCatalog400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(
|
|
apierrors.MissingWorkspaceID(
|
|
apierrors.WithDeveloperMessage("workspace id is required"),
|
|
apierrors.WithParams(map[string]any{"field": "workspaceId"}),
|
|
),
|
|
),
|
|
}, nil
|
|
}
|
|
|
|
apps, err := api.AppCenterService.RefreshCatalog(ctx, workspaceID)
|
|
if err != nil {
|
|
return writeRefreshWorkspaceAppCatalogError(err), nil
|
|
}
|
|
|
|
return tuttigenerated.RefreshWorkspaceAppCatalog200JSONResponse{
|
|
WorkspaceId: workspaceID,
|
|
CatalogStatus: workspaceapi.GeneratedAppCatalogLoadStateFromBiz(api.AppCenterService.CatalogLoadState()),
|
|
Apps: workspaceapi.GeneratedAppsFromBiz(apps),
|
|
}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) InstallWorkspaceApp(ctx context.Context, request tuttigenerated.InstallWorkspaceAppRequestObject) (tuttigenerated.InstallWorkspaceAppResponseObject, error) {
|
|
if api.AppCenterService == nil {
|
|
return tuttigenerated.InstallWorkspaceApp503JSONResponse{
|
|
ServiceUnavailableErrorJSONResponse: workspaceAppServiceUnavailableError(),
|
|
}, nil
|
|
}
|
|
|
|
workspaceID, appID, errResponse := validateWorkspaceAppPath(request.WorkspaceID, request.AppID)
|
|
if errResponse != nil {
|
|
return tuttigenerated.InstallWorkspaceApp400JSONResponse{InvalidRequestErrorJSONResponse: *errResponse}, nil
|
|
}
|
|
|
|
options := workspaceservice.InstallOptions{}
|
|
if request.Body != nil && request.Body.RestartRunning != nil {
|
|
options.RestartRunning = *request.Body.RestartRunning
|
|
}
|
|
app, err := api.AppCenterService.InstallWithOptions(ctx, workspaceID, appID, options)
|
|
if err != nil {
|
|
return writeInstallWorkspaceAppError(err), nil
|
|
}
|
|
|
|
return tuttigenerated.InstallWorkspaceApp200JSONResponse{
|
|
WorkspaceId: workspaceID,
|
|
App: workspaceapi.GeneratedAppFromBiz(app),
|
|
}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) ImportWorkspaceApp(ctx context.Context, request tuttigenerated.ImportWorkspaceAppRequestObject) (tuttigenerated.ImportWorkspaceAppResponseObject, error) {
|
|
if api.AppCenterService == nil {
|
|
return tuttigenerated.ImportWorkspaceApp503JSONResponse{
|
|
ServiceUnavailableErrorJSONResponse: workspaceAppServiceUnavailableError(),
|
|
}, nil
|
|
}
|
|
workspaceID := strings.TrimSpace(string(request.WorkspaceID))
|
|
if workspaceID == "" {
|
|
return tuttigenerated.ImportWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(
|
|
apierrors.MissingWorkspaceID(
|
|
apierrors.WithDeveloperMessage("workspace id is required"),
|
|
apierrors.WithParams(map[string]any{"field": "workspaceId"}),
|
|
),
|
|
),
|
|
}, nil
|
|
}
|
|
if request.Body == nil || strings.TrimSpace(request.Body.ArchivePath) == "" {
|
|
return tuttigenerated.ImportWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(
|
|
apierrors.MalformedRequest(
|
|
apierrors.WithDeveloperMessage("workspace app archive path is required"),
|
|
apierrors.WithParams(map[string]any{"field": "archivePath"}),
|
|
),
|
|
),
|
|
}, nil
|
|
}
|
|
if _, err := api.WorkspaceService.Get(ctx, workspaceID); err != nil {
|
|
return writeImportWorkspaceAppError(err), nil
|
|
}
|
|
|
|
app, err := api.AppCenterService.ImportPackage(ctx, request.Body.ArchivePath)
|
|
if err != nil {
|
|
return writeImportWorkspaceAppError(err), nil
|
|
}
|
|
return tuttigenerated.ImportWorkspaceApp200JSONResponse{
|
|
WorkspaceId: workspaceID,
|
|
App: workspaceapi.GeneratedAppFromBiz(app),
|
|
}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) LoadLocalWorkspaceApp(ctx context.Context, request tuttigenerated.LoadLocalWorkspaceAppRequestObject) (tuttigenerated.LoadLocalWorkspaceAppResponseObject, error) {
|
|
if api.AppCenterService == nil {
|
|
return tuttigenerated.LoadLocalWorkspaceApp503JSONResponse{
|
|
ServiceUnavailableErrorJSONResponse: workspaceAppServiceUnavailableError(),
|
|
}, nil
|
|
}
|
|
workspaceID := strings.TrimSpace(string(request.WorkspaceID))
|
|
if workspaceID == "" {
|
|
return tuttigenerated.LoadLocalWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(
|
|
apierrors.MissingWorkspaceID(
|
|
apierrors.WithDeveloperMessage("workspace id is required"),
|
|
apierrors.WithParams(map[string]any{"field": "workspaceId"}),
|
|
),
|
|
),
|
|
}, nil
|
|
}
|
|
if request.Body == nil || strings.TrimSpace(request.Body.SourceDir) == "" {
|
|
return tuttigenerated.LoadLocalWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(
|
|
apierrors.MalformedRequest(
|
|
apierrors.WithDeveloperMessage("workspace app source directory is required"),
|
|
apierrors.WithParams(map[string]any{"field": "sourceDir"}),
|
|
),
|
|
),
|
|
}, nil
|
|
}
|
|
|
|
app, err := api.AppCenterService.LoadLocalPackage(ctx, workspaceID, request.Body.SourceDir, installOptionsDefaultRestart(request.Body.RestartRunning))
|
|
if err != nil {
|
|
return writeLoadLocalWorkspaceAppError(err), nil
|
|
}
|
|
return tuttigenerated.LoadLocalWorkspaceApp200JSONResponse{
|
|
WorkspaceId: workspaceID,
|
|
App: workspaceapi.GeneratedAppFromBiz(app),
|
|
}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) ReloadLocalWorkspaceApp(ctx context.Context, request tuttigenerated.ReloadLocalWorkspaceAppRequestObject) (tuttigenerated.ReloadLocalWorkspaceAppResponseObject, error) {
|
|
if api.AppCenterService == nil {
|
|
return tuttigenerated.ReloadLocalWorkspaceApp503JSONResponse{
|
|
ServiceUnavailableErrorJSONResponse: workspaceAppServiceUnavailableError(),
|
|
}, nil
|
|
}
|
|
|
|
workspaceID, appID, errResponse := validateWorkspaceAppPath(request.WorkspaceID, request.AppID)
|
|
if errResponse != nil {
|
|
return tuttigenerated.ReloadLocalWorkspaceApp400JSONResponse{InvalidRequestErrorJSONResponse: *errResponse}, nil
|
|
}
|
|
|
|
var restartRunning *bool
|
|
if request.Body != nil {
|
|
restartRunning = request.Body.RestartRunning
|
|
}
|
|
app, err := api.AppCenterService.ReloadLocalPackage(ctx, workspaceID, appID, installOptionsDefaultRestart(restartRunning))
|
|
if err != nil {
|
|
return writeReloadLocalWorkspaceAppError(err), nil
|
|
}
|
|
return tuttigenerated.ReloadLocalWorkspaceApp200JSONResponse{
|
|
WorkspaceId: workspaceID,
|
|
App: workspaceapi.GeneratedAppFromBiz(app),
|
|
}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) ExportWorkspaceApp(ctx context.Context, request tuttigenerated.ExportWorkspaceAppRequestObject) (tuttigenerated.ExportWorkspaceAppResponseObject, error) {
|
|
if api.AppCenterService == nil {
|
|
return tuttigenerated.ExportWorkspaceApp503JSONResponse{
|
|
ServiceUnavailableErrorJSONResponse: workspaceAppServiceUnavailableError(),
|
|
}, nil
|
|
}
|
|
workspaceID, appID, errResponse := validateWorkspaceAppPath(request.WorkspaceID, request.AppID)
|
|
if errResponse != nil {
|
|
return tuttigenerated.ExportWorkspaceApp400JSONResponse{InvalidRequestErrorJSONResponse: *errResponse}, nil
|
|
}
|
|
if request.Body == nil || strings.TrimSpace(request.Body.DestinationPath) == "" {
|
|
return tuttigenerated.ExportWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(
|
|
apierrors.MalformedRequest(
|
|
apierrors.WithDeveloperMessage("workspace app export destination path is required"),
|
|
apierrors.WithParams(map[string]any{"field": "destinationPath"}),
|
|
),
|
|
),
|
|
}, nil
|
|
}
|
|
if _, err := api.WorkspaceService.Get(ctx, workspaceID); err != nil {
|
|
return writeExportWorkspaceAppError(err), nil
|
|
}
|
|
|
|
version := ""
|
|
if request.Body.Version != nil {
|
|
version = *request.Body.Version
|
|
}
|
|
result, err := api.AppCenterService.ExportPackage(ctx, appID, version, request.Body.DestinationPath)
|
|
if err != nil {
|
|
return writeExportWorkspaceAppError(err), nil
|
|
}
|
|
return tuttigenerated.ExportWorkspaceApp200JSONResponse{
|
|
WorkspaceId: workspaceID,
|
|
AppId: result.AppID,
|
|
Version: result.Version,
|
|
ArchivePath: result.Path,
|
|
ArtifactSha256: result.ArtifactSHA256,
|
|
ArtifactSizeBytes: result.ArtifactSizeBytes,
|
|
}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) ReplaceWorkspaceAppIcon(ctx context.Context, request tuttigenerated.ReplaceWorkspaceAppIconRequestObject) (tuttigenerated.ReplaceWorkspaceAppIconResponseObject, error) {
|
|
if api.AppCenterService == nil {
|
|
return tuttigenerated.ReplaceWorkspaceAppIcon503JSONResponse{
|
|
ServiceUnavailableErrorJSONResponse: workspaceAppServiceUnavailableError(),
|
|
}, nil
|
|
}
|
|
workspaceID, appID, errResponse := validateWorkspaceAppPath(request.WorkspaceID, request.AppID)
|
|
if errResponse != nil {
|
|
return tuttigenerated.ReplaceWorkspaceAppIcon400JSONResponse{InvalidRequestErrorJSONResponse: *errResponse}, nil
|
|
}
|
|
if request.Body == nil || strings.TrimSpace(request.Body.SourcePath) == "" {
|
|
return tuttigenerated.ReplaceWorkspaceAppIcon400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(
|
|
apierrors.MalformedRequest(
|
|
apierrors.WithDeveloperMessage("workspace app icon source path is required"),
|
|
apierrors.WithParams(map[string]any{"field": "sourcePath"}),
|
|
),
|
|
),
|
|
}, nil
|
|
}
|
|
|
|
app, err := api.AppCenterService.ReplaceIcon(ctx, workspaceID, appID, request.Body.SourcePath)
|
|
if err != nil {
|
|
return writeReplaceWorkspaceAppIconError(err), nil
|
|
}
|
|
return tuttigenerated.ReplaceWorkspaceAppIcon200JSONResponse{
|
|
WorkspaceId: workspaceID,
|
|
App: workspaceapi.GeneratedAppFromBiz(app),
|
|
}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) UninstallWorkspaceApp(ctx context.Context, request tuttigenerated.UninstallWorkspaceAppRequestObject) (tuttigenerated.UninstallWorkspaceAppResponseObject, error) {
|
|
if api.AppCenterService == nil {
|
|
return tuttigenerated.UninstallWorkspaceApp503JSONResponse{
|
|
ServiceUnavailableErrorJSONResponse: workspaceAppServiceUnavailableError(),
|
|
}, nil
|
|
}
|
|
|
|
workspaceID, appID, errResponse := validateWorkspaceAppPath(request.WorkspaceID, request.AppID)
|
|
if errResponse != nil {
|
|
return tuttigenerated.UninstallWorkspaceApp400JSONResponse{InvalidRequestErrorJSONResponse: *errResponse}, nil
|
|
}
|
|
|
|
app, err := api.AppCenterService.Uninstall(ctx, workspaceID, appID)
|
|
if err != nil {
|
|
return writeUninstallWorkspaceAppError(err), nil
|
|
}
|
|
|
|
return tuttigenerated.UninstallWorkspaceApp200JSONResponse{
|
|
WorkspaceId: workspaceID,
|
|
App: workspaceapi.GeneratedAppFromBiz(app),
|
|
}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) DeleteWorkspaceApp(ctx context.Context, request tuttigenerated.DeleteWorkspaceAppRequestObject) (tuttigenerated.DeleteWorkspaceAppResponseObject, error) {
|
|
if api.AppCenterService == nil {
|
|
return tuttigenerated.DeleteWorkspaceApp503JSONResponse{
|
|
ServiceUnavailableErrorJSONResponse: workspaceAppServiceUnavailableError(),
|
|
}, nil
|
|
}
|
|
|
|
workspaceID, appID, errResponse := validateWorkspaceAppPath(request.WorkspaceID, request.AppID)
|
|
if errResponse != nil {
|
|
return tuttigenerated.DeleteWorkspaceApp400JSONResponse{InvalidRequestErrorJSONResponse: *errResponse}, nil
|
|
}
|
|
|
|
if err := api.AppCenterService.DeletePackage(ctx, workspaceID, appID); err != nil {
|
|
return writeDeleteWorkspaceAppError(err), nil
|
|
}
|
|
|
|
return tuttigenerated.DeleteWorkspaceApp200JSONResponse{
|
|
WorkspaceId: workspaceID,
|
|
AppId: appID,
|
|
Deleted: true,
|
|
}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) LaunchWorkspaceApp(ctx context.Context, request tuttigenerated.LaunchWorkspaceAppRequestObject) (tuttigenerated.LaunchWorkspaceAppResponseObject, error) {
|
|
if api.AppCenterService == nil {
|
|
return tuttigenerated.LaunchWorkspaceApp503JSONResponse{
|
|
ServiceUnavailableErrorJSONResponse: workspaceAppServiceUnavailableError(),
|
|
}, nil
|
|
}
|
|
|
|
workspaceID, appID, errResponse := validateWorkspaceAppPath(request.WorkspaceID, request.AppID)
|
|
if errResponse != nil {
|
|
return tuttigenerated.LaunchWorkspaceApp400JSONResponse{InvalidRequestErrorJSONResponse: *errResponse}, nil
|
|
}
|
|
|
|
app, err := api.AppCenterService.Launch(ctx, workspaceID, appID)
|
|
if err != nil {
|
|
return writeLaunchWorkspaceAppError(err), nil
|
|
}
|
|
|
|
return tuttigenerated.LaunchWorkspaceApp200JSONResponse{
|
|
WorkspaceId: workspaceID,
|
|
App: workspaceapi.GeneratedAppFromBiz(app),
|
|
}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) RetryWorkspaceApp(ctx context.Context, request tuttigenerated.RetryWorkspaceAppRequestObject) (tuttigenerated.RetryWorkspaceAppResponseObject, error) {
|
|
if api.AppCenterService == nil {
|
|
return tuttigenerated.RetryWorkspaceApp503JSONResponse{
|
|
ServiceUnavailableErrorJSONResponse: workspaceAppServiceUnavailableError(),
|
|
}, nil
|
|
}
|
|
|
|
workspaceID, appID, errResponse := validateWorkspaceAppPath(request.WorkspaceID, request.AppID)
|
|
if errResponse != nil {
|
|
return tuttigenerated.RetryWorkspaceApp400JSONResponse{InvalidRequestErrorJSONResponse: *errResponse}, nil
|
|
}
|
|
|
|
app, err := api.AppCenterService.Retry(ctx, workspaceID, appID)
|
|
if err != nil {
|
|
return writeRetryWorkspaceAppError(err), nil
|
|
}
|
|
|
|
return tuttigenerated.RetryWorkspaceApp200JSONResponse{
|
|
WorkspaceId: workspaceID,
|
|
App: workspaceapi.GeneratedAppFromBiz(app),
|
|
}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) RollbackWorkspaceApp(ctx context.Context, request tuttigenerated.RollbackWorkspaceAppRequestObject) (tuttigenerated.RollbackWorkspaceAppResponseObject, error) {
|
|
if api.AppCenterService == nil {
|
|
return tuttigenerated.RollbackWorkspaceApp503JSONResponse{
|
|
ServiceUnavailableErrorJSONResponse: workspaceAppServiceUnavailableError(),
|
|
}, nil
|
|
}
|
|
workspaceID, appID, errResponse := validateWorkspaceAppPath(request.WorkspaceID, request.AppID)
|
|
if errResponse != nil {
|
|
return tuttigenerated.RollbackWorkspaceApp400JSONResponse{InvalidRequestErrorJSONResponse: *errResponse}, nil
|
|
}
|
|
if request.Body == nil || strings.TrimSpace(request.Body.Version) == "" {
|
|
return tuttigenerated.RollbackWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(
|
|
apierrors.MalformedRequest(
|
|
apierrors.WithDeveloperMessage("workspace app rollback version is required"),
|
|
apierrors.WithParams(map[string]any{"field": "version"}),
|
|
),
|
|
),
|
|
}, nil
|
|
}
|
|
|
|
app, err := api.AppCenterService.Rollback(ctx, workspaceID, appID, request.Body.Version)
|
|
if err != nil {
|
|
return writeRollbackWorkspaceAppError(err), nil
|
|
}
|
|
return tuttigenerated.RollbackWorkspaceApp200JSONResponse{
|
|
WorkspaceId: workspaceID,
|
|
App: workspaceapi.GeneratedAppFromBiz(app),
|
|
}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) StartEnabledWorkspaceApps(ctx context.Context, request tuttigenerated.StartEnabledWorkspaceAppsRequestObject) (tuttigenerated.StartEnabledWorkspaceAppsResponseObject, error) {
|
|
if api.AppCenterService == nil {
|
|
return tuttigenerated.StartEnabledWorkspaceApps503JSONResponse{
|
|
ServiceUnavailableErrorJSONResponse: workspaceAppServiceUnavailableError(),
|
|
}, nil
|
|
}
|
|
|
|
workspaceID := strings.TrimSpace(string(request.WorkspaceID))
|
|
if workspaceID == "" {
|
|
return tuttigenerated.StartEnabledWorkspaceApps400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(
|
|
apierrors.MissingWorkspaceID(
|
|
apierrors.WithDeveloperMessage("workspace id is required"),
|
|
apierrors.WithParams(map[string]any{"field": "workspaceId"}),
|
|
),
|
|
),
|
|
}, nil
|
|
}
|
|
|
|
apps, err := api.AppCenterService.StartEnabled(ctx, workspaceID)
|
|
if err != nil {
|
|
return writeStartEnabledWorkspaceAppsError(err), nil
|
|
}
|
|
|
|
return tuttigenerated.StartEnabledWorkspaceApps200JSONResponse{
|
|
WorkspaceId: workspaceID,
|
|
CatalogStatus: workspaceapi.GeneratedAppCatalogLoadStateFromBiz(api.AppCenterService.CatalogLoadState()),
|
|
Apps: workspaceapi.GeneratedAppsFromBiz(apps),
|
|
}, nil
|
|
}
|
|
|
|
func (api DaemonAPI) StopAllWorkspaceApps(ctx context.Context, request tuttigenerated.StopAllWorkspaceAppsRequestObject) (tuttigenerated.StopAllWorkspaceAppsResponseObject, error) {
|
|
if api.AppCenterService == nil {
|
|
return tuttigenerated.StopAllWorkspaceApps503JSONResponse{
|
|
ServiceUnavailableErrorJSONResponse: workspaceAppServiceUnavailableError(),
|
|
}, nil
|
|
}
|
|
|
|
workspaceID := strings.TrimSpace(string(request.WorkspaceID))
|
|
if workspaceID == "" {
|
|
return tuttigenerated.StopAllWorkspaceApps400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(
|
|
apierrors.MissingWorkspaceID(
|
|
apierrors.WithDeveloperMessage("workspace id is required"),
|
|
apierrors.WithParams(map[string]any{"field": "workspaceId"}),
|
|
),
|
|
),
|
|
}, nil
|
|
}
|
|
|
|
apps, err := api.AppCenterService.StopAll(ctx, workspaceID)
|
|
if err != nil {
|
|
return writeStopAllWorkspaceAppsError(err), nil
|
|
}
|
|
|
|
return tuttigenerated.StopAllWorkspaceApps200JSONResponse{
|
|
WorkspaceId: workspaceID,
|
|
CatalogStatus: workspaceapi.GeneratedAppCatalogLoadStateFromBiz(api.AppCenterService.CatalogLoadState()),
|
|
Apps: workspaceapi.GeneratedAppsFromBiz(apps),
|
|
}, nil
|
|
}
|
|
|
|
func validateWorkspaceAppPath(workspaceIDValue tuttigenerated.WorkspaceID, appIDValue tuttigenerated.WorkspaceAppID) (string, string, *tuttigenerated.InvalidRequestErrorJSONResponse) {
|
|
workspaceID := strings.TrimSpace(string(workspaceIDValue))
|
|
if workspaceID == "" {
|
|
response := invalidRequestError(
|
|
apierrors.MissingWorkspaceID(
|
|
apierrors.WithDeveloperMessage("workspace id is required"),
|
|
apierrors.WithParams(map[string]any{"field": "workspaceId"}),
|
|
),
|
|
)
|
|
return "", "", &response
|
|
}
|
|
|
|
appID := strings.TrimSpace(string(appIDValue))
|
|
if appID == "" {
|
|
response := invalidRequestError(
|
|
apierrors.MalformedRequest(
|
|
apierrors.WithDeveloperMessage("workspace app id is required"),
|
|
apierrors.WithParams(map[string]any{"field": "appId"}),
|
|
),
|
|
)
|
|
return "", "", &response
|
|
}
|
|
|
|
return workspaceID, appID, nil
|
|
}
|
|
|
|
func installOptionsDefaultRestart(restartRunning *bool) workspaceservice.InstallOptions {
|
|
options := workspaceservice.InstallOptions{RestartRunning: true}
|
|
if restartRunning != nil {
|
|
options.RestartRunning = *restartRunning
|
|
}
|
|
return options
|
|
}
|
|
|
|
func writeListWorkspaceAppsError(err error) tuttigenerated.ListWorkspaceAppsResponseObject {
|
|
protocolErr := apierrors.Classify(err)
|
|
switch protocolErr.Code {
|
|
case tuttigenerated.WorkspaceNotFound:
|
|
return tuttigenerated.ListWorkspaceApps404JSONResponse{
|
|
WorkspaceNotFoundErrorJSONResponse: workspaceNotFoundError(protocolErr),
|
|
}
|
|
case tuttigenerated.InvalidRequest:
|
|
return tuttigenerated.ListWorkspaceApps400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(protocolErr),
|
|
}
|
|
default:
|
|
return tuttigenerated.ListWorkspaceApps502JSONResponse{
|
|
WorkspaceOperationErrorJSONResponse: workspaceOperationError(protocolErr),
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeRefreshWorkspaceAppCatalogError(err error) tuttigenerated.RefreshWorkspaceAppCatalogResponseObject {
|
|
protocolErr := apierrors.Classify(err)
|
|
switch protocolErr.Code {
|
|
case tuttigenerated.WorkspaceNotFound:
|
|
return tuttigenerated.RefreshWorkspaceAppCatalog404JSONResponse{
|
|
WorkspaceNotFoundErrorJSONResponse: workspaceNotFoundError(protocolErr),
|
|
}
|
|
case tuttigenerated.InvalidRequest:
|
|
return tuttigenerated.RefreshWorkspaceAppCatalog400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(protocolErr),
|
|
}
|
|
default:
|
|
return tuttigenerated.RefreshWorkspaceAppCatalog502JSONResponse{
|
|
WorkspaceOperationErrorJSONResponse: workspaceOperationError(protocolErr),
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeStartEnabledWorkspaceAppsError(err error) tuttigenerated.StartEnabledWorkspaceAppsResponseObject {
|
|
protocolErr := apierrors.Classify(err)
|
|
switch protocolErr.Code {
|
|
case tuttigenerated.WorkspaceNotFound:
|
|
return tuttigenerated.StartEnabledWorkspaceApps404JSONResponse{
|
|
WorkspaceNotFoundErrorJSONResponse: workspaceNotFoundError(protocolErr),
|
|
}
|
|
case tuttigenerated.InvalidRequest:
|
|
return tuttigenerated.StartEnabledWorkspaceApps400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(protocolErr),
|
|
}
|
|
default:
|
|
return tuttigenerated.StartEnabledWorkspaceApps502JSONResponse{
|
|
WorkspaceOperationErrorJSONResponse: workspaceOperationError(protocolErr),
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeStopAllWorkspaceAppsError(err error) tuttigenerated.StopAllWorkspaceAppsResponseObject {
|
|
protocolErr := apierrors.Classify(err)
|
|
switch protocolErr.Code {
|
|
case tuttigenerated.WorkspaceNotFound:
|
|
return tuttigenerated.StopAllWorkspaceApps404JSONResponse{
|
|
WorkspaceNotFoundErrorJSONResponse: workspaceNotFoundError(protocolErr),
|
|
}
|
|
case tuttigenerated.InvalidRequest:
|
|
return tuttigenerated.StopAllWorkspaceApps400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(protocolErr),
|
|
}
|
|
default:
|
|
return tuttigenerated.StopAllWorkspaceApps502JSONResponse{
|
|
WorkspaceOperationErrorJSONResponse: workspaceOperationError(protocolErr),
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeInstallWorkspaceAppError(err error) tuttigenerated.InstallWorkspaceAppResponseObject {
|
|
protocolErr := apierrors.Classify(err)
|
|
switch protocolErr.Code {
|
|
case tuttigenerated.WorkspaceNotFound, tuttigenerated.WorkspaceAppNotFound:
|
|
return tuttigenerated.InstallWorkspaceApp404JSONResponse{
|
|
WorkspaceAppNotFoundErrorJSONResponse: workspaceAppNotFoundError(protocolErr),
|
|
}
|
|
case tuttigenerated.InvalidRequest:
|
|
return tuttigenerated.InstallWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(protocolErr),
|
|
}
|
|
default:
|
|
return tuttigenerated.InstallWorkspaceApp502JSONResponse{
|
|
WorkspaceOperationErrorJSONResponse: workspaceOperationError(protocolErr),
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeImportWorkspaceAppError(err error) tuttigenerated.ImportWorkspaceAppResponseObject {
|
|
protocolErr := apierrors.Classify(err)
|
|
switch protocolErr.Code {
|
|
case tuttigenerated.WorkspaceNotFound:
|
|
return tuttigenerated.ImportWorkspaceApp404JSONResponse{
|
|
WorkspaceNotFoundErrorJSONResponse: workspaceNotFoundError(protocolErr),
|
|
}
|
|
case tuttigenerated.InvalidRequest:
|
|
return tuttigenerated.ImportWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(protocolErr),
|
|
}
|
|
default:
|
|
return tuttigenerated.ImportWorkspaceApp502JSONResponse{
|
|
WorkspaceOperationErrorJSONResponse: workspaceOperationError(protocolErr),
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeLoadLocalWorkspaceAppError(err error) tuttigenerated.LoadLocalWorkspaceAppResponseObject {
|
|
protocolErr := apierrors.Classify(err)
|
|
switch protocolErr.Code {
|
|
case tuttigenerated.WorkspaceNotFound:
|
|
return tuttigenerated.LoadLocalWorkspaceApp404JSONResponse{
|
|
WorkspaceNotFoundErrorJSONResponse: workspaceNotFoundError(protocolErr),
|
|
}
|
|
case tuttigenerated.InvalidRequest:
|
|
return tuttigenerated.LoadLocalWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(protocolErr),
|
|
}
|
|
default:
|
|
return tuttigenerated.LoadLocalWorkspaceApp502JSONResponse{
|
|
WorkspaceOperationErrorJSONResponse: workspaceOperationError(protocolErr),
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeReloadLocalWorkspaceAppError(err error) tuttigenerated.ReloadLocalWorkspaceAppResponseObject {
|
|
protocolErr := apierrors.Classify(err)
|
|
switch protocolErr.Code {
|
|
case tuttigenerated.WorkspaceNotFound, tuttigenerated.WorkspaceAppNotFound:
|
|
return tuttigenerated.ReloadLocalWorkspaceApp404JSONResponse{
|
|
WorkspaceAppNotFoundErrorJSONResponse: workspaceAppNotFoundError(protocolErr),
|
|
}
|
|
case tuttigenerated.InvalidRequest:
|
|
return tuttigenerated.ReloadLocalWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(protocolErr),
|
|
}
|
|
default:
|
|
return tuttigenerated.ReloadLocalWorkspaceApp502JSONResponse{
|
|
WorkspaceOperationErrorJSONResponse: workspaceOperationError(protocolErr),
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeExportWorkspaceAppError(err error) tuttigenerated.ExportWorkspaceAppResponseObject {
|
|
protocolErr := apierrors.Classify(err)
|
|
switch protocolErr.Code {
|
|
case tuttigenerated.WorkspaceNotFound, tuttigenerated.WorkspaceAppNotFound:
|
|
return tuttigenerated.ExportWorkspaceApp404JSONResponse{
|
|
WorkspaceAppNotFoundErrorJSONResponse: workspaceAppNotFoundError(protocolErr),
|
|
}
|
|
case tuttigenerated.InvalidRequest:
|
|
return tuttigenerated.ExportWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(protocolErr),
|
|
}
|
|
default:
|
|
return tuttigenerated.ExportWorkspaceApp502JSONResponse{
|
|
WorkspaceOperationErrorJSONResponse: workspaceOperationError(protocolErr),
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeReplaceWorkspaceAppIconError(err error) tuttigenerated.ReplaceWorkspaceAppIconResponseObject {
|
|
protocolErr := apierrors.Classify(err)
|
|
switch protocolErr.Code {
|
|
case tuttigenerated.WorkspaceNotFound, tuttigenerated.WorkspaceAppNotFound:
|
|
return tuttigenerated.ReplaceWorkspaceAppIcon404JSONResponse{
|
|
WorkspaceAppNotFoundErrorJSONResponse: workspaceAppNotFoundError(protocolErr),
|
|
}
|
|
case tuttigenerated.InvalidRequest:
|
|
return tuttigenerated.ReplaceWorkspaceAppIcon400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(protocolErr),
|
|
}
|
|
default:
|
|
return tuttigenerated.ReplaceWorkspaceAppIcon502JSONResponse{
|
|
WorkspaceOperationErrorJSONResponse: workspaceOperationError(protocolErr),
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeUninstallWorkspaceAppError(err error) tuttigenerated.UninstallWorkspaceAppResponseObject {
|
|
protocolErr := apierrors.Classify(err)
|
|
switch protocolErr.Code {
|
|
case tuttigenerated.WorkspaceNotFound, tuttigenerated.WorkspaceAppNotFound:
|
|
return tuttigenerated.UninstallWorkspaceApp404JSONResponse{
|
|
WorkspaceAppNotFoundErrorJSONResponse: workspaceAppNotFoundError(protocolErr),
|
|
}
|
|
case tuttigenerated.InvalidRequest:
|
|
return tuttigenerated.UninstallWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(protocolErr),
|
|
}
|
|
default:
|
|
return tuttigenerated.UninstallWorkspaceApp502JSONResponse{
|
|
WorkspaceOperationErrorJSONResponse: workspaceOperationError(protocolErr),
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeDeleteWorkspaceAppError(err error) tuttigenerated.DeleteWorkspaceAppResponseObject {
|
|
protocolErr := apierrors.Classify(err)
|
|
switch protocolErr.Code {
|
|
case tuttigenerated.WorkspaceNotFound, tuttigenerated.WorkspaceAppNotFound:
|
|
return tuttigenerated.DeleteWorkspaceApp404JSONResponse{
|
|
WorkspaceAppNotFoundErrorJSONResponse: workspaceAppNotFoundError(protocolErr),
|
|
}
|
|
case tuttigenerated.InvalidRequest:
|
|
return tuttigenerated.DeleteWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(protocolErr),
|
|
}
|
|
default:
|
|
return tuttigenerated.DeleteWorkspaceApp502JSONResponse{
|
|
WorkspaceOperationErrorJSONResponse: workspaceOperationError(protocolErr),
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeLaunchWorkspaceAppError(err error) tuttigenerated.LaunchWorkspaceAppResponseObject {
|
|
protocolErr := apierrors.Classify(err)
|
|
switch protocolErr.Code {
|
|
case tuttigenerated.WorkspaceNotFound, tuttigenerated.WorkspaceAppNotFound:
|
|
return tuttigenerated.LaunchWorkspaceApp404JSONResponse{
|
|
WorkspaceAppNotFoundErrorJSONResponse: workspaceAppNotFoundError(protocolErr),
|
|
}
|
|
case tuttigenerated.InvalidRequest:
|
|
return tuttigenerated.LaunchWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(protocolErr),
|
|
}
|
|
default:
|
|
return tuttigenerated.LaunchWorkspaceApp502JSONResponse{
|
|
WorkspaceOperationErrorJSONResponse: workspaceOperationError(protocolErr),
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeRetryWorkspaceAppError(err error) tuttigenerated.RetryWorkspaceAppResponseObject {
|
|
protocolErr := apierrors.Classify(err)
|
|
switch protocolErr.Code {
|
|
case tuttigenerated.WorkspaceNotFound, tuttigenerated.WorkspaceAppNotFound:
|
|
return tuttigenerated.RetryWorkspaceApp404JSONResponse{
|
|
WorkspaceAppNotFoundErrorJSONResponse: workspaceAppNotFoundError(protocolErr),
|
|
}
|
|
case tuttigenerated.InvalidRequest:
|
|
return tuttigenerated.RetryWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(protocolErr),
|
|
}
|
|
default:
|
|
return tuttigenerated.RetryWorkspaceApp502JSONResponse{
|
|
WorkspaceOperationErrorJSONResponse: workspaceOperationError(protocolErr),
|
|
}
|
|
}
|
|
}
|
|
|
|
func writeRollbackWorkspaceAppError(err error) tuttigenerated.RollbackWorkspaceAppResponseObject {
|
|
protocolErr := apierrors.Classify(err)
|
|
switch protocolErr.Code {
|
|
case tuttigenerated.WorkspaceNotFound, tuttigenerated.WorkspaceAppNotFound:
|
|
return tuttigenerated.RollbackWorkspaceApp404JSONResponse{
|
|
WorkspaceAppNotFoundErrorJSONResponse: workspaceAppNotFoundError(protocolErr),
|
|
}
|
|
case tuttigenerated.InvalidRequest:
|
|
return tuttigenerated.RollbackWorkspaceApp400JSONResponse{
|
|
InvalidRequestErrorJSONResponse: invalidRequestError(protocolErr),
|
|
}
|
|
default:
|
|
return tuttigenerated.RollbackWorkspaceApp502JSONResponse{
|
|
WorkspaceOperationErrorJSONResponse: workspaceOperationError(protocolErr),
|
|
}
|
|
}
|
|
}
|