Skip to content

PostgreSQL backup tool with Point-In-Time-Recovery and restore verification

FEATURE (workspaces): Add tranasfer between databases, storages and notifiers

Rostislav Dugin33a8d302eba7
diff --git a/backend/cmd/main.go b/backend/cmd/main.go
index a00e4d51..13b8d9aa 100644
--- a/backend/cmd/main.go
+++ b/backend/cmd/main.go
@@ -217,6 +217,7 @@ func setUpDependencies() {
audit_logs.SetupDependencies()
notifiers.SetupDependencies()
storages.SetupDependencies()
+ backups_config.SetupDependencies()
}
func runBackgroundTasks(log *slog.Logger) {
diff --git a/backend/internal/features/audit_logs/controller.go b/backend/internal/features/audit_logs/controller.go
index bd109603..e0a641fb 100644
--- a/backend/internal/features/audit_logs/controller.go
+++ b/backend/internal/features/audit_logs/controller.go
@@ -1,6 +1,7 @@
package audit_logs
import (
+ "errors"
"net/http"
user_models "databasus-backend/internal/features/users/models"
@@ -50,7 +51,7 @@ func (c *AuditLogController) GetGlobalAuditLogs(ctx *gin.Context) {
response, err := c.auditLogService.GetGlobalAuditLogs(user, request)
if err != nil {
- if err.Error() == "only administrators can view global audit logs" {
+ if errors.Is(err, ErrOnlyAdminsCanViewGlobalLogs) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -99,7 +100,7 @@ func (c *AuditLogController) GetUserAuditLogs(ctx *gin.Context) {
response, err := c.auditLogService.GetUserAuditLogs(targetUserID, user, request)
if err != nil {
- if err.Error() == "insufficient permissions to view user audit logs" {
+ if errors.Is(err, ErrInsufficientPermissionsToViewLogs) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
diff --git a/backend/internal/features/audit_logs/errors.go b/backend/internal/features/audit_logs/errors.go
new file mode 100644
index 00000000..0214ac5e
--- /dev/null
+++ b/backend/internal/features/audit_logs/errors.go
@@ -0,0 +1,12 @@
+package audit_logs
+
+import "errors"
+
+var (
+ ErrOnlyAdminsCanViewGlobalLogs = errors.New(
+ "only administrators can view global audit logs",
+ )
+ ErrInsufficientPermissionsToViewLogs = errors.New(
+ "insufficient permissions to view user audit logs",
+ )
+)
diff --git a/backend/internal/features/audit_logs/service.go b/backend/internal/features/audit_logs/service.go
index a29490cb..39e6bc7d 100644
--- a/backend/internal/features/audit_logs/service.go
+++ b/backend/internal/features/audit_logs/service.go
@@ -1,7 +1,6 @@
package audit_logs
import (
- "errors"
"log/slog"
"time"
@@ -44,7 +43,7 @@ func (s *AuditLogService) GetGlobalAuditLogs(
request *GetAuditLogsRequest,
) (*GetAuditLogsResponse, error) {
if user.Role != user_enums.UserRoleAdmin {
- return nil, errors.New("only administrators can view global audit logs")
+ return nil, ErrOnlyAdminsCanViewGlobalLogs
}
limit := request.Limit
@@ -79,7 +78,7 @@ func (s *AuditLogService) GetUserAuditLogs(
) (*GetAuditLogsResponse, error) {
// Users can view their own logs, ADMIN can view any user's logs
if user.Role != user_enums.UserRoleAdmin && user.ID != targetUserID {
- return nil, errors.New("insufficient permissions to view user audit logs")
+ return nil, ErrInsufficientPermissionsToViewLogs
}
limit := request.Limit
diff --git a/backend/internal/features/backups/backups/background_service_test.go b/backend/internal/features/backups/backups/background_service_test.go
index 2d29c931..06a6779b 100644
--- a/backend/internal/features/backups/backups/background_service_test.go
+++ b/backend/internal/features/backups/backups/background_service_test.go
@@ -25,6 +25,20 @@ func Test_MakeBackupForDbHavingBackupDayAgo_BackupCreated(t *testing.T) {
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
+ defer func() {
+ // cleanup backups first
+ backups, _ := backupRepository.FindByDatabaseID(database.ID)
+ for _, backup := range backups {
+ backupRepository.DeleteByID(backup.ID)
+ }
+
+ databases.RemoveTestDatabase(database)
+ time.Sleep(50 * time.Millisecond)
+ notifiers.RemoveTestNotifier(notifier)
+ storages.RemoveTestStorage(storage.ID)
+ workspaces_testing.RemoveTestWorkspace(workspace, router)
+ }()
+
// Enable backups for the database
backupConfig, err := backups_config.GetBackupConfigService().GetBackupConfigByDbId(database.ID)
assert.NoError(t, err)
@@ -54,24 +68,13 @@ func Test_MakeBackupForDbHavingBackupDayAgo_BackupCreated(t *testing.T) {
GetBackupBackgroundService().runPendingBackups()
- time.Sleep(100 * time.Millisecond)
+ // Wait for backup to complete (runs in goroutine)
+ WaitForBackupCompletion(t, database.ID, 1, 10*time.Second)
// assertions
backups, err := backupRepository.FindByDatabaseID(database.ID)
assert.NoError(t, err)
assert.Len(t, backups, 2)
-
- // cleanup
- for _, backup := range backups {
- err := backupRepository.DeleteByID(backup.ID)
- assert.NoError(t, err)
- }
-
- databases.RemoveTestDatabase(database)
- time.Sleep(50 * time.Millisecond) // Wait for cascading deletes
- notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
}
func Test_MakeBackupForDbHavingHourAgoBackup_BackupSkipped(t *testing.T) {
@@ -83,6 +86,20 @@ func Test_MakeBackupForDbHavingHourAgoBackup_BackupSkipped(t *testing.T) {
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
+ defer func() {
+ // cleanup backups first
+ backups, _ := backupRepository.FindByDatabaseID(database.ID)
+ for _, backup := range backups {
+ backupRepository.DeleteByID(backup.ID)
+ }
+
+ databases.RemoveTestDatabase(database)
+ time.Sleep(50 * time.Millisecond)
+ notifiers.RemoveTestNotifier(notifier)
+ storages.RemoveTestStorage(storage.ID)
+ workspaces_testing.RemoveTestWorkspace(workspace, router)
+ }()
+
// Enable backups for the database
backupConfig, err := backups_config.GetBackupConfigService().GetBackupConfigByDbId(database.ID)
assert.NoError(t, err)
@@ -118,18 +135,6 @@ func Test_MakeBackupForDbHavingHourAgoBackup_BackupSkipped(t *testing.T) {
backups, err := backupRepository.FindByDatabaseID(database.ID)
assert.NoError(t, err)
assert.Len(t, backups, 1) // Should still be 1 backup, no new backup created
-
- // cleanup
- for _, backup := range backups {
- err := backupRepository.DeleteByID(backup.ID)
- assert.NoError(t, err)
- }
-
- databases.RemoveTestDatabase(database)
- time.Sleep(50 * time.Millisecond) // Wait for cascading deletes
- notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
}
func Test_MakeBackupHavingFailedBackupWithoutRetries_BackupSkipped(t *testing.T) {
@@ -141,6 +146,20 @@ func Test_MakeBackupHavingFailedBackupWithoutRetries_BackupSkipped(t *testing.T)
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
+ defer func() {
+ // cleanup backups first
+ backups, _ := backupRepository.FindByDatabaseID(database.ID)
+ for _, backup := range backups {
+ backupRepository.DeleteByID(backup.ID)
+ }
+
+ databases.RemoveTestDatabase(database)
+ time.Sleep(50 * time.Millisecond)
+ notifiers.RemoveTestNotifier(notifier)
+ storages.RemoveTestStorage(storage.ID)
+ workspaces_testing.RemoveTestWorkspace(workspace, router)
+ }()
+
// Enable backups for the database with retries disabled
backupConfig, err := backups_config.GetBackupConfigService().GetBackupConfigByDbId(database.ID)
assert.NoError(t, err)
@@ -180,18 +199,6 @@ func Test_MakeBackupHavingFailedBackupWithoutRetries_BackupSkipped(t *testing.T)
backups, err := backupRepository.FindByDatabaseID(database.ID)
assert.NoError(t, err)
assert.Len(t, backups, 1) // Should still be 1 backup, no retry attempted
-
- // cleanup
- for _, backup := range backups {
- err := backupRepository.DeleteByID(backup.ID)
- assert.NoError(t, err)
- }
-
- databases.RemoveTestDatabase(database)
- time.Sleep(50 * time.Millisecond) // Wait for cascading deletes
- notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
}
func Test_MakeBackupHavingFailedBackupWithRetries_BackupCreated(t *testing.T) {
@@ -203,6 +210,20 @@ func Test_MakeBackupHavingFailedBackupWithRetries_BackupCreated(t *testing.T) {
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
+ defer func() {
+ // cleanup backups first
+ backups, _ := backupRepository.FindByDatabaseID(database.ID)
+ for _, backup := range backups {
+ backupRepository.DeleteByID(backup.ID)
+ }
+
+ databases.RemoveTestDatabase(database)
+ time.Sleep(50 * time.Millisecond)
+ notifiers.RemoveTestNotifier(notifier)
+ storages.RemoveTestStorage(storage.ID)
+ workspaces_testing.RemoveTestWorkspace(workspace, router)
+ }()
+
// Enable backups for the database with retries enabled
backupConfig, err := backups_config.GetBackupConfigService().GetBackupConfigByDbId(database.ID)
assert.NoError(t, err)
@@ -236,24 +257,13 @@ func Test_MakeBackupHavingFailedBackupWithRetries_BackupCreated(t *testing.T) {
GetBackupBackgroundService().runPendingBackups()
- time.Sleep(100 * time.Millisecond)
+ // Wait for backup to complete (runs in goroutine)
+ WaitForBackupCompletion(t, database.ID, 1, 10*time.Second)
// assertions
backups, err := backupRepository.FindByDatabaseID(database.ID)
assert.NoError(t, err)
assert.Len(t, backups, 2) // Should have 2 backups, retry was attempted
-
- // cleanup
- for _, backup := range backups {
- err := backupRepository.DeleteByID(backup.ID)
- assert.NoError(t, err)
- }
-
- databases.RemoveTestDatabase(database)
- time.Sleep(100 * time.Millisecond) // Wait for cascading deletes
- notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
}
func Test_MakeBackupHavingFailedBackupWithRetries_RetriesCountNotExceeded(t *testing.T) {
@@ -265,6 +275,20 @@ func Test_MakeBackupHavingFailedBackupWithRetries_RetriesCountNotExceeded(t *tes
notifier := notifiers.CreateTestNotifier(workspace.ID)
database := databases.CreateTestDatabase(workspace.ID, storage, notifier)
+ defer func() {
+ // cleanup backups first
+ backups, _ := backupRepository.FindByDatabaseID(database.ID)
+ for _, backup := range backups {
+ backupRepository.DeleteByID(backup.ID)
+ }
+
+ databases.RemoveTestDatabase(database)
+ time.Sleep(50 * time.Millisecond)
+ notifiers.RemoveTestNotifier(notifier)
+ storages.RemoveTestStorage(storage.ID)
+ workspaces_testing.RemoveTestWorkspace(workspace, router)
+ }()
+
// Enable backups for the database with retries enabled
backupConfig, err := backups_config.GetBackupConfigService().GetBackupConfigByDbId(database.ID)
assert.NoError(t, err)
@@ -306,16 +330,4 @@ func Test_MakeBackupHavingFailedBackupWithRetries_RetriesCountNotExceeded(t *tes
backups, err := backupRepository.FindByDatabaseID(database.ID)
assert.NoError(t, err)
assert.Len(t, backups, 3) // Should have 3 backups, not more than max
-
- // cleanup
- for _, backup := range backups {
- err := backupRepository.DeleteByID(backup.ID)
- assert.NoError(t, err)
- }
-
- databases.RemoveTestDatabase(database)
- time.Sleep(50 * time.Millisecond) // Wait for cascading deletes
- notifiers.RemoveTestNotifier(notifier)
- storages.RemoveTestStorage(storage.ID)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
}
diff --git a/backend/internal/features/backups/backups/testing.go b/backend/internal/features/backups/backups/testing.go
index 279a8bc1..dde177a6 100644
--- a/backend/internal/features/backups/backups/testing.go
+++ b/backend/internal/features/backups/backups/testing.go
@@ -1,12 +1,16 @@
package backups
import (
+ "testing"
+ "time"
+
backups_config "databasus-backend/internal/features/backups/config"
"databasus-backend/internal/features/databases"
workspaces_controllers "databasus-backend/internal/features/workspaces/controllers"
workspaces_testing "databasus-backend/internal/features/workspaces/testing"
"github.com/gin-gonic/gin"
+ "github.com/google/uuid"
)
func CreateTestRouter() *gin.Engine {
@@ -18,3 +22,49 @@ func CreateTestRouter() *gin.Engine {
GetBackupController(),
)
}
+
+// WaitForBackupCompletion waits for a new backup to be created and completed (or failed)
+// for the given database. It checks for backups with count greater than expectedInitialCount.
+func WaitForBackupCompletion(
+ t *testing.T,
+ databaseID uuid.UUID,
+ expectedInitialCount int,
+ timeout time.Duration,
+) {
+ deadline := time.Now().UTC().Add(timeout)
+
+ for time.Now().UTC().Before(deadline) {
+ backups, err := backupRepository.FindByDatabaseID(databaseID)
+ if err != nil {
+ t.Logf("WaitForBackupCompletion: error finding backups: %v", err)
+ time.Sleep(50 * time.Millisecond)
+ continue
+ }
+
+ t.Logf(
+ "WaitForBackupCompletion: found %d backups (expected > %d)",
+ len(backups),
+ expectedInitialCount,
+ )
+
+ if len(backups) > expectedInitialCount {
+ // Check if the newest backup has completed or failed
+ newestBackup := backups[0]
+ t.Logf("WaitForBackupCompletion: newest backup status: %s", newestBackup.Status)
+
+ if newestBackup.Status == BackupStatusCompleted ||
+ newestBackup.Status == BackupStatusFailed ||
+ newestBackup.Status == BackupStatusCanceled {
+ t.Logf(
+ "WaitForBackupCompletion: backup finished with status %s",
+ newestBackup.Status,
+ )
+ return
+ }
+ }
+
+ time.Sleep(50 * time.Millisecond)
+ }
+
+ t.Logf("WaitForBackupCompletion: timeout waiting for backup to complete")
+}
diff --git a/backend/internal/features/backups/config/controller.go b/backend/internal/features/backups/config/controller.go
index fa02b712..222158eb 100644
--- a/backend/internal/features/backups/config/controller.go
+++ b/backend/internal/features/backups/config/controller.go
@@ -1,9 +1,11 @@
package backups_config
import (
- users_middleware "databasus-backend/internal/features/users/middleware"
+ "errors"
"net/http"
+ users_middleware "databasus-backend/internal/features/users/middleware"
+
"github.com/gin-gonic/gin"
"github.com/google/uuid"
)
@@ -16,6 +18,8 @@ func (c *BackupConfigController) RegisterRoutes(router *gin.RouterGroup) {
router.POST("/backup-configs/save", c.SaveBackupConfig)
router.GET("/backup-configs/database/:id", c.GetBackupConfigByDbID)
router.GET("/backup-configs/storage/:id/is-using", c.IsStorageUsing)
+ router.GET("/backup-configs/storage/:id/databases-count", c.CountDatabasesForStorage)
+ router.POST("/backup-configs/database/:id/transfer", c.TransferDatabase)
}
// SaveBackupConfig
@@ -120,3 +124,86 @@ func (c *BackupConfigController) IsStorageUsing(ctx *gin.Context) {
ctx.JSON(http.StatusOK, gin.H{"isUsing": isUsing})
}
+
+// CountDatabasesForStorage
+// @Summary Count databases using a storage
+// @Description Get the count of databases that are using a specific storage
+// @Tags backup-configs
+// @Produce json
+// @Param id path string true "Storage ID"
+// @Success 200 {object} map[string]int
+// @Failure 400
+// @Failure 401
+// @Failure 500
+// @Router /backup-configs/storage/{id}/databases-count [get]
+func (c *BackupConfigController) CountDatabasesForStorage(ctx *gin.Context) {
+ user, ok := users_middleware.GetUserFromContext(ctx)
+ if !ok {
+ ctx.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+
+ id, err := uuid.Parse(ctx.Param("id"))
+ if err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid storage ID"})
+ return
+ }
+
+ count, err := c.backupConfigService.CountDatabasesForStorage(user, id)
+ if err != nil {
+ ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+ return
+ }
+
+ ctx.JSON(http.StatusOK, gin.H{"count": count})
+}
+
+// TransferDatabase
+// @Summary Transfer database to another workspace
+// @Description Transfer a database from one workspace to another. Can transfer to a new storage or transfer with the existing storage. Can also specify target notifiers from the target workspace.
+// @Tags backup-configs
+// @Accept json
+// @Produce json
+// @Param id path string true "Database ID"
+// @Param request body TransferDatabaseRequest true "Transfer request with targetWorkspaceId, storage options (targetStorageId or isTransferWithStorage), and optional targetNotifierIds"
+// @Success 200 {object} map[string]string "Database transferred successfully"
+// @Failure 400 {object} map[string]string "Invalid request, target storage/notifier not in target workspace, or transfer failed"
+// @Failure 401 {object} map[string]string "User not authenticated"
+// @Failure 403 {object} map[string]string "Insufficient permissions"
+// @Router /backup-configs/database/{id}/transfer [post]
+func (c *BackupConfigController) TransferDatabase(ctx *gin.Context) {
+ user, ok := users_middleware.GetUserFromContext(ctx)
+ if !ok {
+ ctx.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+
+ id, err := uuid.Parse(ctx.Param("id"))
+ if err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid database ID"})
+ return
+ }
+
+ var request TransferDatabaseRequest
+ if err := ctx.ShouldBindJSON(&request); err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+ return
+ }
+
+ if request.TargetWorkspaceID == uuid.Nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "targetWorkspaceId is required"})
+ return
+ }
+
+ if err := c.backupConfigService.TransferDatabaseToWorkspace(user, id, &request); err != nil {
+ if errors.Is(err, ErrInsufficientPermissionsInSourceWorkspace) ||
+ errors.Is(err, ErrInsufficientPermissionsInTargetWorkspace) {
+ ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
+ return
+ }
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+ return
+ }
+
+ ctx.JSON(http.StatusOK, gin.H{"message": "database transferred successfully"})
+}
diff --git a/backend/internal/features/backups/config/controller_test.go b/backend/internal/features/backups/config/controller_test.go
index 277846e9..15067efc 100644
--- a/backend/internal/features/backups/config/controller_test.go
+++ b/backend/internal/features/backups/config/controller_test.go
@@ -12,6 +12,7 @@ import (
"databasus-backend/internal/features/databases"
"databasus-backend/internal/features/databases/databases/postgresql"
"databasus-backend/internal/features/intervals"
+ "databasus-backend/internal/features/notifiers"
"databasus-backend/internal/features/storages"
users_enums "databasus-backend/internal/features/users/enums"
users_testing "databasus-backend/internal/features/users/testing"
@@ -442,6 +443,991 @@ func Test_SaveBackupConfig_WithEncryptionEncrypted_ConfigSaved(t *testing.T) {
assert.Equal(t, BackupEncryptionEncrypted, response.Encryption)
}
+func Test_TransferDatabase_PermissionsEnforced(t *testing.T) {
+ tests := []struct {
+ name string
+ sourceRole *users_enums.WorkspaceRole
+ targetRole *users_enums.WorkspaceRole
+ isGlobalAdmin bool
+ expectSuccess bool
+ expectedStatusCode int
+ }{
+ {
+ name: "owner in both workspaces can transfer",
+ sourceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleOwner; return &r }(),
+ targetRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleOwner; return &r }(),
+ isGlobalAdmin: false,
+ expectSuccess: true,
+ expectedStatusCode: http.StatusOK,
+ },
+ {
+ name: "admin in both workspaces can transfer",
+ sourceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleAdmin; return &r }(),
+ targetRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleAdmin; return &r }(),
+ isGlobalAdmin: false,
+ expectSuccess: true,
+ expectedStatusCode: http.StatusOK,
+ },
+ {
+ name: "member in both workspaces can transfer",
+ sourceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleMember; return &r }(),
+ targetRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleMember; return &r }(),
+ isGlobalAdmin: false,
+ expectSuccess: true,
+ expectedStatusCode: http.StatusOK,
+ },
+ {
+ name: "viewer in both workspaces cannot transfer",
+ sourceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleViewer; return &r }(),
+ targetRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleViewer; return &r }(),
+ isGlobalAdmin: false,
+ expectSuccess: false,
+ expectedStatusCode: http.StatusForbidden,
+ },
+ {
+ name: "global admin can transfer",
+ sourceRole: nil,
+ targetRole: nil,
+ isGlobalAdmin: true,
+ expectSuccess: true,
+ expectedStatusCode: http.StatusOK,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ router := createTestRouterWithStorageForTransfer()
+
+ sourceOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ targetOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(
+ "Source Workspace",
+ sourceOwner,
+ router,
+ )
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(
+ "Target Workspace",
+ targetOwner,
+ router,
+ )
+
+ database := createTestDatabaseViaAPI(
+ "Test Database",
+ sourceWorkspace.ID,
+ sourceOwner.Token,
+ router,
+ )
+
+ targetStorage := createTestStorage(targetWorkspace.ID)
+
+ var testUserToken string
+ if tt.isGlobalAdmin {
+ admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ testUserToken = admin.Token
+ } else if tt.sourceRole != nil {
+ testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ if *tt.sourceRole == users_enums.WorkspaceRoleOwner {
+ testUserToken = sourceOwner.Token
+ workspaces_testing.AddMemberToWorkspace(
+ targetWorkspace,
+ sourceOwner,
+ *tt.targetRole,
+ targetOwner.Token,
+ router,
+ )
+ } else {
+ workspaces_testing.AddMemberToWorkspace(
+ sourceWorkspace,
+ testUser,
+ *tt.sourceRole,
+ sourceOwner.Token,
+ router,
+ )
+ workspaces_testing.AddMemberToWorkspace(
+ targetWorkspace,
+ testUser,
+ *tt.targetRole,
+ targetOwner.Token,
+ router,
+ )
+ testUserToken = testUser.Token
+ }
+ }
+
+ request := TransferDatabaseRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ TargetStorageID: &targetStorage.ID,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/database/"+database.ID.String()+"/transfer",
+ "Bearer "+testUserToken,
+ request,
+ tt.expectedStatusCode,
+ )
+
+ if tt.expectSuccess {
+ assert.Contains(t, string(testResp.Body), "database transferred successfully")
+
+ var retrievedDatabase databases.Database
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/databases/"+database.ID.String(),
+ "Bearer "+targetOwner.Token,
+ http.StatusOK,
+ &retrievedDatabase,
+ )
+ assert.Equal(t, targetWorkspace.ID, *retrievedDatabase.WorkspaceID)
+ } else {
+ assert.Contains(t, string(testResp.Body), "insufficient permissions")
+ }
+ })
+ }
+}
+
+func Test_TransferDatabase_NonMemberInSourceWorkspace_CannotTransfer(t *testing.T) {
+ router := createTestRouterWithStorageForTransfer()
+
+ sourceOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ targetOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(
+ "Source Workspace",
+ sourceOwner,
+ router,
+ )
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(
+ "Target Workspace",
+ targetOwner,
+ router,
+ )
+
+ database := createTestDatabaseViaAPI(
+ "Test Database",
+ sourceWorkspace.ID,
+ sourceOwner.Token,
+ router,
+ )
+
+ request := TransferDatabaseRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/database/"+database.ID.String()+"/transfer",
+ "Bearer "+targetOwner.Token,
+ request,
+ http.StatusForbidden,
+ )
+
+ assert.Contains(t, string(testResp.Body), "insufficient permissions")
+}
+
+func Test_TransferDatabase_NonMemberInTargetWorkspace_CannotTransfer(t *testing.T) {
+ router := createTestRouterWithStorageForTransfer()
+
+ sourceOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ targetOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(
+ "Source Workspace",
+ sourceOwner,
+ router,
+ )
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(
+ "Target Workspace",
+ targetOwner,
+ router,
+ )
+
+ database := createTestDatabaseViaAPI(
+ "Test Database",
+ sourceWorkspace.ID,
+ sourceOwner.Token,
+ router,
+ )
+
+ request := TransferDatabaseRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/database/"+database.ID.String()+"/transfer",
+ "Bearer "+sourceOwner.Token,
+ request,
+ http.StatusForbidden,
+ )
+
+ assert.Contains(t, string(testResp.Body), "insufficient permissions")
+}
+
+func Test_TransferDatabase_ToNewStorage_DatabaseTransferd(t *testing.T) {
+ router := createTestRouterWithStorageForTransfer()
+
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+
+ database := createTestDatabaseViaAPI("Test Database", sourceWorkspace.ID, owner.Token, router)
+ sourceStorage := createTestStorage(sourceWorkspace.ID)
+ targetStorage := createTestStorage(targetWorkspace.ID)
+
+ timeOfDay := "04:00"
+ backupConfigRequest := BackupConfig{
+ DatabaseID: database.ID,
+ IsBackupsEnabled: true,
+ StorePeriod: period.PeriodWeek,
+ BackupInterval: &intervals.Interval{
+ Interval: intervals.IntervalDaily,
+ TimeOfDay: &timeOfDay,
+ },
+ Storage: sourceStorage,
+ SendNotificationsOn: []BackupNotificationType{
+ NotificationBackupFailed,
+ },
+ IsRetryIfFailed: true,
+ MaxFailedTriesCount: 3,
+ Encryption: BackupEncryptionNone,
+ }
+
+ var savedConfig BackupConfig
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/backup-configs/save",
+ "Bearer "+owner.Token,
+ backupConfigRequest,
+ http.StatusOK,
+ &savedConfig,
+ )
+
+ request := TransferDatabaseRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ TargetStorageID: &targetStorage.ID,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/database/"+database.ID.String()+"/transfer",
+ "Bearer "+owner.Token,
+ request,
+ http.StatusOK,
+ )
+
+ assert.Contains(t, string(testResp.Body), "database transferred successfully")
+
+ var retrievedDatabase databases.Database
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/databases/"+database.ID.String(),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &retrievedDatabase,
+ )
+ assert.Equal(t, targetWorkspace.ID, *retrievedDatabase.WorkspaceID)
+
+ var retrievedConfig BackupConfig
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/backup-configs/database/"+database.ID.String(),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &retrievedConfig,
+ )
+ assert.NotNil(t, retrievedConfig.StorageID)
+ assert.Equal(t, targetStorage.ID, *retrievedConfig.StorageID)
+}
+
+func Test_TransferDatabase_WithExistingStorage_DatabaseAndStorageTransferd(t *testing.T) {
+ router := createTestRouterWithStorageForTransfer()
+
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+
+ database := createTestDatabaseViaAPI("Test Database", sourceWorkspace.ID, owner.Token, router)
+ storage := createTestStorage(sourceWorkspace.ID)
+
+ timeOfDay := "04:00"
+ backupConfigRequest := BackupConfig{
+ DatabaseID: database.ID,
+ IsBackupsEnabled: true,
+ StorePeriod: period.PeriodWeek,
+ BackupInterval: &intervals.Interval{
+ Interval: intervals.IntervalDaily,
+ TimeOfDay: &timeOfDay,
+ },
+ Storage: storage,
+ SendNotificationsOn: []BackupNotificationType{
+ NotificationBackupFailed,
+ },
+ IsRetryIfFailed: true,
+ MaxFailedTriesCount: 3,
+ Encryption: BackupEncryptionNone,
+ }
+
+ var savedConfig BackupConfig
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/backup-configs/save",
+ "Bearer "+owner.Token,
+ backupConfigRequest,
+ http.StatusOK,
+ &savedConfig,
+ )
+
+ request := TransferDatabaseRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ IsTransferWithStorage: true,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/database/"+database.ID.String()+"/transfer",
+ "Bearer "+owner.Token,
+ request,
+ http.StatusOK,
+ )
+
+ assert.Contains(t, string(testResp.Body), "database transferred successfully")
+
+ var retrievedDatabase databases.Database
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/databases/"+database.ID.String(),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &retrievedDatabase,
+ )
+ assert.Equal(t, targetWorkspace.ID, *retrievedDatabase.WorkspaceID)
+
+ var retrievedStorage storages.Storage
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/storages/"+storage.ID.String(),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &retrievedStorage,
+ )
+ assert.Equal(t, targetWorkspace.ID, retrievedStorage.WorkspaceID)
+}
+
+func Test_TransferDatabase_StorageHasOtherDBs_CannotTransfer(t *testing.T) {
+ router := createTestRouterWithStorageForTransfer()
+
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+
+ database1 := createTestDatabaseViaAPI(
+ "Test Database 1",
+ sourceWorkspace.ID,
+ owner.Token,
+ router,
+ )
+ database2 := createTestDatabaseViaAPI(
+ "Test Database 2",
+ sourceWorkspace.ID,
+ owner.Token,
+ router,
+ )
+ storage := createTestStorage(sourceWorkspace.ID)
+
+ timeOfDay := "04:00"
+ backupConfigRequest1 := BackupConfig{
+ DatabaseID: database1.ID,
+ IsBackupsEnabled: true,
+ StorePeriod: period.PeriodWeek,
+ BackupInterval: &intervals.Interval{
+ Interval: intervals.IntervalDaily,
+ TimeOfDay: &timeOfDay,
+ },
+ Storage: storage,
+ SendNotificationsOn: []BackupNotificationType{
+ NotificationBackupFailed,
+ },
+ IsRetryIfFailed: true,
+ MaxFailedTriesCount: 3,
+ Encryption: BackupEncryptionNone,
+ }
+
+ test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/save",
+ "Bearer "+owner.Token,
+ backupConfigRequest1,
+ http.StatusOK,
+ )
+
+ backupConfigRequest2 := BackupConfig{
+ DatabaseID: database2.ID,
+ IsBackupsEnabled: true,
+ StorePeriod: period.PeriodWeek,
+ BackupInterval: &intervals.Interval{
+ Interval: intervals.IntervalDaily,
+ TimeOfDay: &timeOfDay,
+ },
+ Storage: storage,
+ SendNotificationsOn: []BackupNotificationType{
+ NotificationBackupFailed,
+ },
+ IsRetryIfFailed: true,
+ MaxFailedTriesCount: 3,
+ Encryption: BackupEncryptionNone,
+ }
+
+ test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/save",
+ "Bearer "+owner.Token,
+ backupConfigRequest2,
+ http.StatusOK,
+ )
+
+ request := TransferDatabaseRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ IsTransferWithStorage: true,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/database/"+database1.ID.String()+"/transfer",
+ "Bearer "+owner.Token,
+ request,
+ http.StatusBadRequest,
+ )
+
+ assert.Contains(t, string(testResp.Body), "storage has other attached databases")
+}
+
+func Test_TransferDatabase_WithNotifiers_NotifiersTransferred(t *testing.T) {
+ router := createTestRouterWithNotifiersForTransfer()
+
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+
+ database := createTestDatabaseViaAPI("Test Database", sourceWorkspace.ID, owner.Token, router)
+ sourceStorage := createTestStorage(sourceWorkspace.ID)
+ targetStorage := createTestStorage(targetWorkspace.ID)
+ notifier := notifiers.CreateTestNotifier(sourceWorkspace.ID)
+
+ database.Notifiers = []notifiers.Notifier{*notifier}
+ var updatedDatabase databases.Database
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/databases/update",
+ "Bearer "+owner.Token,
+ database,
+ http.StatusOK,
+ &updatedDatabase,
+ )
+
+ timeOfDay := "04:00"
+ backupConfigRequest := BackupConfig{
+ DatabaseID: database.ID,
+ IsBackupsEnabled: true,
+ StorePeriod: period.PeriodWeek,
+ BackupInterval: &intervals.Interval{
+ Interval: intervals.IntervalDaily,
+ TimeOfDay: &timeOfDay,
+ },
+ Storage: sourceStorage,
+ SendNotificationsOn: []BackupNotificationType{
+ NotificationBackupFailed,
+ },
+ IsRetryIfFailed: true,
+ MaxFailedTriesCount: 3,
+ Encryption: BackupEncryptionNone,
+ }
+
+ test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/save",
+ "Bearer "+owner.Token,
+ backupConfigRequest,
+ http.StatusOK,
+ )
+
+ request := TransferDatabaseRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ TargetStorageID: &targetStorage.ID,
+ IsTransferWithNotifiers: true,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/database/"+database.ID.String()+"/transfer",
+ "Bearer "+owner.Token,
+ request,
+ http.StatusOK,
+ )
+
+ assert.Contains(t, string(testResp.Body), "database transferred successfully")
+
+ var retrievedDatabase databases.Database
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/databases/"+database.ID.String(),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &retrievedDatabase,
+ )
+ assert.Equal(t, targetWorkspace.ID, *retrievedDatabase.WorkspaceID)
+ assert.Len(t, retrievedDatabase.Notifiers, 1)
+
+ var retrievedNotifier notifiers.Notifier
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/notifiers/"+notifier.ID.String(),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &retrievedNotifier,
+ )
+ assert.Equal(t, targetWorkspace.ID, retrievedNotifier.WorkspaceID)
+}
+
+func Test_TransferDatabase_NotifierHasOtherDBs_NotifierSkipped(t *testing.T) {
+ router := createTestRouterWithNotifiersForTransfer()
+
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+
+ database1 := createTestDatabaseViaAPI(
+ "Test Database 1",
+ sourceWorkspace.ID,
+ owner.Token,
+ router,
+ )
+ database2 := createTestDatabaseViaAPI(
+ "Test Database 2",
+ sourceWorkspace.ID,
+ owner.Token,
+ router,
+ )
+ sourceStorage := createTestStorage(sourceWorkspace.ID)
+ targetStorage := createTestStorage(targetWorkspace.ID)
+ sharedNotifier := notifiers.CreateTestNotifier(sourceWorkspace.ID)
+
+ database1.Notifiers = []notifiers.Notifier{*sharedNotifier}
+ test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/databases/update",
+ "Bearer "+owner.Token,
+ database1,
+ http.StatusOK,
+ )
+
+ database2.Notifiers = []notifiers.Notifier{*sharedNotifier}
+ test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/databases/update",
+ "Bearer "+owner.Token,
+ database2,
+ http.StatusOK,
+ )
+
+ timeOfDay := "04:00"
+ backupConfigRequest := BackupConfig{
+ DatabaseID: database1.ID,
+ IsBackupsEnabled: true,
+ StorePeriod: period.PeriodWeek,
+ BackupInterval: &intervals.Interval{
+ Interval: intervals.IntervalDaily,
+ TimeOfDay: &timeOfDay,
+ },
+ Storage: sourceStorage,
+ SendNotificationsOn: []BackupNotificationType{
+ NotificationBackupFailed,
+ },
+ IsRetryIfFailed: true,
+ MaxFailedTriesCount: 3,
+ Encryption: BackupEncryptionNone,
+ }
+
+ test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/save",
+ "Bearer "+owner.Token,
+ backupConfigRequest,
+ http.StatusOK,
+ )
+
+ request := TransferDatabaseRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ TargetStorageID: &targetStorage.ID,
+ IsTransferWithNotifiers: true,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/database/"+database1.ID.String()+"/transfer",
+ "Bearer "+owner.Token,
+ request,
+ http.StatusOK,
+ )
+
+ assert.Contains(t, string(testResp.Body), "database transferred successfully")
+
+ var retrievedDatabase databases.Database
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/databases/"+database1.ID.String(),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &retrievedDatabase,
+ )
+ assert.Equal(t, targetWorkspace.ID, *retrievedDatabase.WorkspaceID)
+
+ var retrievedNotifier notifiers.Notifier
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/notifiers/"+sharedNotifier.ID.String(),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &retrievedNotifier,
+ )
+ assert.Equal(t, sourceWorkspace.ID, retrievedNotifier.WorkspaceID)
+}
+
+func Test_TransferDatabase_WithMultipleNotifiers_OnlyExclusiveOnesTransferred(t *testing.T) {
+ router := createTestRouterWithNotifiersForTransfer()
+
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+
+ database1 := createTestDatabaseViaAPI(
+ "Test Database 1",
+ sourceWorkspace.ID,
+ owner.Token,
+ router,
+ )
+ database2 := createTestDatabaseViaAPI(
+ "Test Database 2",
+ sourceWorkspace.ID,
+ owner.Token,
+ router,
+ )
+ sourceStorage := createTestStorage(sourceWorkspace.ID)
+ targetStorage := createTestStorage(targetWorkspace.ID)
+
+ exclusiveNotifier := notifiers.CreateTestNotifier(sourceWorkspace.ID)
+ sharedNotifier := notifiers.CreateTestNotifier(sourceWorkspace.ID)
+
+ database1.Notifiers = []notifiers.Notifier{*exclusiveNotifier, *sharedNotifier}
+ test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/databases/update",
+ "Bearer "+owner.Token,
+ database1,
+ http.StatusOK,
+ )
+
+ database2.Notifiers = []notifiers.Notifier{*sharedNotifier}
+ test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/databases/update",
+ "Bearer "+owner.Token,
+ database2,
+ http.StatusOK,
+ )
+
+ timeOfDay := "04:00"
+ backupConfigRequest := BackupConfig{
+ DatabaseID: database1.ID,
+ IsBackupsEnabled: true,
+ StorePeriod: period.PeriodWeek,
+ BackupInterval: &intervals.Interval{
+ Interval: intervals.IntervalDaily,
+ TimeOfDay: &timeOfDay,
+ },
+ Storage: sourceStorage,
+ SendNotificationsOn: []BackupNotificationType{
+ NotificationBackupFailed,
+ },
+ IsRetryIfFailed: true,
+ MaxFailedTriesCount: 3,
+ Encryption: BackupEncryptionNone,
+ }
+
+ test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/save",
+ "Bearer "+owner.Token,
+ backupConfigRequest,
+ http.StatusOK,
+ )
+
+ request := TransferDatabaseRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ TargetStorageID: &targetStorage.ID,
+ IsTransferWithNotifiers: true,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/database/"+database1.ID.String()+"/transfer",
+ "Bearer "+owner.Token,
+ request,
+ http.StatusOK,
+ )
+
+ assert.Contains(t, string(testResp.Body), "database transferred successfully")
+
+ var retrievedDatabase databases.Database
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/databases/"+database1.ID.String(),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &retrievedDatabase,
+ )
+ assert.Equal(t, targetWorkspace.ID, *retrievedDatabase.WorkspaceID)
+ assert.Len(t, retrievedDatabase.Notifiers, 2)
+
+ var retrievedExclusiveNotifier notifiers.Notifier
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/notifiers/"+exclusiveNotifier.ID.String(),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &retrievedExclusiveNotifier,
+ )
+ assert.Equal(t, targetWorkspace.ID, retrievedExclusiveNotifier.WorkspaceID)
+
+ var retrievedSharedNotifier notifiers.Notifier
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/notifiers/"+sharedNotifier.ID.String(),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &retrievedSharedNotifier,
+ )
+ assert.Equal(t, sourceWorkspace.ID, retrievedSharedNotifier.WorkspaceID)
+}
+
+func Test_TransferDatabase_WithTargetNotifiers_NotifiersAssigned(t *testing.T) {
+ router := createTestRouterWithNotifiersForTransfer()
+
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+
+ database := createTestDatabaseViaAPI("Test Database", sourceWorkspace.ID, owner.Token, router)
+ sourceStorage := createTestStorage(sourceWorkspace.ID)
+ targetStorage := createTestStorage(targetWorkspace.ID)
+ targetNotifier := notifiers.CreateTestNotifier(targetWorkspace.ID)
+
+ timeOfDay := "04:00"
+ backupConfigRequest := BackupConfig{
+ DatabaseID: database.ID,
+ IsBackupsEnabled: true,
+ StorePeriod: period.PeriodWeek,
+ BackupInterval: &intervals.Interval{
+ Interval: intervals.IntervalDaily,
+ TimeOfDay: &timeOfDay,
+ },
+ Storage: sourceStorage,
+ SendNotificationsOn: []BackupNotificationType{
+ NotificationBackupFailed,
+ },
+ IsRetryIfFailed: true,
+ MaxFailedTriesCount: 3,
+ Encryption: BackupEncryptionNone,
+ }
+
+ test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/save",
+ "Bearer "+owner.Token,
+ backupConfigRequest,
+ http.StatusOK,
+ )
+
+ request := TransferDatabaseRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ TargetStorageID: &targetStorage.ID,
+ TargetNotifierIDs: []uuid.UUID{targetNotifier.ID},
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/database/"+database.ID.String()+"/transfer",
+ "Bearer "+owner.Token,
+ request,
+ http.StatusOK,
+ )
+
+ assert.Contains(t, string(testResp.Body), "database transferred successfully")
+
+ var retrievedDatabase databases.Database
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/databases/"+database.ID.String(),
+ "Bearer "+owner.Token,
+ http.StatusOK,
+ &retrievedDatabase,
+ )
+ assert.Equal(t, targetWorkspace.ID, *retrievedDatabase.WorkspaceID)
+ assert.Len(t, retrievedDatabase.Notifiers, 1)
+ assert.Equal(t, targetNotifier.ID, retrievedDatabase.Notifiers[0].ID)
+}
+
+func Test_TransferDatabase_TargetNotifierFromDifferentWorkspace_ReturnsBadRequest(t *testing.T) {
+ router := createTestRouterWithNotifiersForTransfer()
+
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+ otherWorkspace := workspaces_testing.CreateTestWorkspace("Other Workspace", owner, router)
+
+ database := createTestDatabaseViaAPI("Test Database", sourceWorkspace.ID, owner.Token, router)
+ sourceStorage := createTestStorage(sourceWorkspace.ID)
+ targetStorage := createTestStorage(targetWorkspace.ID)
+ wrongNotifier := notifiers.CreateTestNotifier(otherWorkspace.ID)
+
+ timeOfDay := "04:00"
+ backupConfigRequest := BackupConfig{
+ DatabaseID: database.ID,
+ IsBackupsEnabled: true,
+ StorePeriod: period.PeriodWeek,
+ BackupInterval: &intervals.Interval{
+ Interval: intervals.IntervalDaily,
+ TimeOfDay: &timeOfDay,
+ },
+ Storage: sourceStorage,
+ SendNotificationsOn: []BackupNotificationType{
+ NotificationBackupFailed,
+ },
+ IsRetryIfFailed: true,
+ MaxFailedTriesCount: 3,
+ Encryption: BackupEncryptionNone,
+ }
+
+ test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/save",
+ "Bearer "+owner.Token,
+ backupConfigRequest,
+ http.StatusOK,
+ )
+
+ request := TransferDatabaseRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ TargetStorageID: &targetStorage.ID,
+ TargetNotifierIDs: []uuid.UUID{wrongNotifier.ID},
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/database/"+database.ID.String()+"/transfer",
+ "Bearer "+owner.Token,
+ request,
+ http.StatusBadRequest,
+ )
+
+ assert.Contains(t, string(testResp.Body), "target notifier does not belong to target workspace")
+}
+
+func Test_TransferDatabase_TargetStorageFromDifferentWorkspace_ReturnsBadRequest(t *testing.T) {
+ router := createTestRouterWithNotifiersForTransfer()
+
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace("Source Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+ otherWorkspace := workspaces_testing.CreateTestWorkspace("Other Workspace", owner, router)
+
+ database := createTestDatabaseViaAPI("Test Database", sourceWorkspace.ID, owner.Token, router)
+ sourceStorage := createTestStorage(sourceWorkspace.ID)
+ wrongStorage := createTestStorage(otherWorkspace.ID)
+
+ timeOfDay := "04:00"
+ backupConfigRequest := BackupConfig{
+ DatabaseID: database.ID,
+ IsBackupsEnabled: true,
+ StorePeriod: period.PeriodWeek,
+ BackupInterval: &intervals.Interval{
+ Interval: intervals.IntervalDaily,
+ TimeOfDay: &timeOfDay,
+ },
+ Storage: sourceStorage,
+ SendNotificationsOn: []BackupNotificationType{
+ NotificationBackupFailed,
+ },
+ IsRetryIfFailed: true,
+ MaxFailedTriesCount: 3,
+ Encryption: BackupEncryptionNone,
+ }
+
+ test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/save",
+ "Bearer "+owner.Token,
+ backupConfigRequest,
+ http.StatusOK,
+ )
+
+ request := TransferDatabaseRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ TargetStorageID: &wrongStorage.ID,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/database/"+database.ID.String()+"/transfer",
+ "Bearer "+owner.Token,
+ request,
+ http.StatusBadRequest,
+ )
+
+ assert.Contains(t, string(testResp.Body), "target storage does not belong to target workspace")
+}
+
func createTestDatabaseViaAPI(
name string,
workspaceID uuid.UUID,
@@ -486,3 +1472,37 @@ func createTestDatabaseViaAPI(
func createTestStorage(workspaceID uuid.UUID) *storages.Storage {
return storages.CreateTestStorage(workspaceID)
}
+
+func createTestRouterWithStorageForTransfer() *gin.Engine {
+ router := workspaces_testing.CreateTestRouter(
+ workspaces_controllers.GetWorkspaceController(),
+ workspaces_controllers.GetMembershipController(),
+ databases.GetDatabaseController(),
+ GetBackupConfigController(),
+ storages.GetStorageController(),
+ )
+
+ storages.SetupDependencies()
+ databases.SetupDependencies()
+ SetupDependencies()
+
+ return router
+}
+
+func createTestRouterWithNotifiersForTransfer() *gin.Engine {
+ router := workspaces_testing.CreateTestRouter(
+ workspaces_controllers.GetWorkspaceController(),
+ workspaces_controllers.GetMembershipController(),
+ databases.GetDatabaseController(),
+ GetBackupConfigController(),
+ storages.GetStorageController(),
+ notifiers.GetNotifierController(),
+ )
+
+ storages.SetupDependencies()
+ databases.SetupDependencies()
+ notifiers.SetupDependencies()
+ SetupDependencies()
+
+ return router
+}
diff --git a/backend/internal/features/backups/config/di.go b/backend/internal/features/backups/config/di.go
index d706d130..fc8a4cf7 100644
--- a/backend/internal/features/backups/config/di.go
+++ b/backend/internal/features/backups/config/di.go
@@ -2,6 +2,7 @@ package backups_config
import (
"databasus-backend/internal/features/databases"
+ "databasus-backend/internal/features/notifiers"
"databasus-backend/internal/features/storages"
workspaces_services "databasus-backend/internal/features/workspaces/services"
)
@@ -11,6 +12,7 @@ var backupConfigService = &BackupConfigService{
backupConfigRepository,
databases.GetDatabaseService(),
storages.GetStorageService(),
+ notifiers.GetNotifierService(),
workspaces_services.GetWorkspaceService(),
nil,
}
@@ -25,3 +27,7 @@ func GetBackupConfigController() *BackupConfigController {
func GetBackupConfigService() *BackupConfigService {
return backupConfigService
}
+
+func SetupDependencies() {
+ storages.GetStorageService().SetStorageDatabaseCounter(backupConfigService)
+}
diff --git a/backend/internal/features/backups/config/dto.go b/backend/internal/features/backups/config/dto.go
new file mode 100644
index 00000000..46559cf8
--- /dev/null
+++ b/backend/internal/features/backups/config/dto.go
@@ -0,0 +1,11 @@
+package backups_config
+
+import "github.com/google/uuid"
+
+type TransferDatabaseRequest struct {
+ TargetWorkspaceID uuid.UUID `json:"targetWorkspaceId" binding:"required"`
+ TargetStorageID *uuid.UUID `json:"targetStorageId,omitempty"`
+ IsTransferWithStorage bool `json:"isTransferWithStorage,omitempty"`
+ IsTransferWithNotifiers bool `json:"isTransferWithNotifiers,omitempty"`
+ TargetNotifierIDs []uuid.UUID `json:"targetNotifierIds,omitempty"`
+}
diff --git a/backend/internal/features/backups/config/errors.go b/backend/internal/features/backups/config/errors.go
new file mode 100644
index 00000000..f3db323e
--- /dev/null
+++ b/backend/internal/features/backups/config/errors.go
@@ -0,0 +1,30 @@
+package backups_config
+
+import "errors"
+
+var (
+ ErrInsufficientPermissionsInSourceWorkspace = errors.New(
+ "insufficient permissions to manage database in source workspace",
+ )
+ ErrInsufficientPermissionsInTargetWorkspace = errors.New(
+ "insufficient permissions to manage database in target workspace",
+ )
+ ErrTargetStorageNotInTargetWorkspace = errors.New(
+ "target storage does not belong to target workspace",
+ )
+ ErrTargetNotifierNotInTargetWorkspace = errors.New(
+ "target notifier does not belong to target workspace",
+ )
+ ErrStorageHasOtherAttachedDatabases = errors.New(
+ "storage has other attached databases and cannot be transferred with this database",
+ )
+ ErrDatabaseHasNoStorage = errors.New(
+ "database has no storage attached",
+ )
+ ErrDatabaseHasNoWorkspace = errors.New(
+ "database has no workspace",
+ )
+ ErrTargetStorageNotSpecified = errors.New(
+ "target storage is not specified",
+ )
+)
diff --git a/backend/internal/features/backups/config/notifiers_test.go b/backend/internal/features/backups/config/notifiers_test.go
new file mode 100644
index 00000000..48b4dc4b
--- /dev/null
+++ b/backend/internal/features/backups/config/notifiers_test.go
@@ -0,0 +1,166 @@
+package backups_config
+
+import (
+ "fmt"
+ "net/http"
+ "testing"
+
+ "github.com/gin-gonic/gin"
+ "github.com/stretchr/testify/assert"
+
+ "databasus-backend/internal/features/databases"
+ "databasus-backend/internal/features/notifiers"
+ "databasus-backend/internal/features/storages"
+ users_enums "databasus-backend/internal/features/users/enums"
+ users_testing "databasus-backend/internal/features/users/testing"
+ workspaces_controllers "databasus-backend/internal/features/workspaces/controllers"
+ workspaces_testing "databasus-backend/internal/features/workspaces/testing"
+ test_utils "databasus-backend/internal/util/testing"
+)
+
+func Test_AttachNotifierFromSameWorkspace_SuccessfullyAttached(t *testing.T) {
+ router := createTestRouterWithNotifier()
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+
+ database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
+ notifier := notifiers.CreateTestNotifier(workspace.ID)
+
+ database.Notifiers = []notifiers.Notifier{*notifier}
+
+ var response databases.Database
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/databases/update",
+ "Bearer "+owner.Token,
+ database,
+ http.StatusOK,
+ &response,
+ )
+
+ assert.Equal(t, database.ID, response.ID)
+ assert.Len(t, response.Notifiers, 1)
+ assert.Equal(t, notifier.ID, response.Notifiers[0].ID)
+}
+
+func Test_AttachNotifierFromDifferentWorkspace_ReturnsForbidden(t *testing.T) {
+ router := createTestRouterWithNotifier()
+
+ owner1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace1 := workspaces_testing.CreateTestWorkspace("Workspace 1", owner1, router)
+ database := createTestDatabaseViaAPI("Test Database", workspace1.ID, owner1.Token, router)
+
+ owner2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace2 := workspaces_testing.CreateTestWorkspace("Workspace 2", owner2, router)
+ notifier := notifiers.CreateTestNotifier(workspace2.ID)
+
+ database.Notifiers = []notifiers.Notifier{*notifier}
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/databases/update",
+ "Bearer "+owner1.Token,
+ database,
+ http.StatusBadRequest,
+ )
+
+ assert.Contains(t, string(testResp.Body), "notifier does not belong to this workspace")
+}
+
+func Test_DeleteNotifierWithAttachedDatabases_CannotDelete(t *testing.T) {
+ router := createTestRouterWithNotifier()
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+
+ database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
+ notifier := notifiers.CreateTestNotifier(workspace.ID)
+
+ database.Notifiers = []notifiers.Notifier{*notifier}
+
+ var response databases.Database
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/databases/update",
+ "Bearer "+owner.Token,
+ database,
+ http.StatusOK,
+ &response,
+ )
+
+ testResp := test_utils.MakeDeleteRequest(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/notifiers/%s", notifier.ID.String()),
+ "Bearer "+owner.Token,
+ http.StatusBadRequest,
+ )
+
+ assert.Contains(
+ t,
+ string(testResp.Body),
+ "notifier has attached databases and cannot be deleted",
+ )
+}
+
+func Test_TransferNotifierWithAttachedDatabase_CannotTransfer(t *testing.T) {
+ router := createTestRouterWithNotifier()
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+
+ database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
+ notifier := notifiers.CreateTestNotifier(workspace.ID)
+
+ database.Notifiers = []notifiers.Notifier{*notifier}
+
+ var response databases.Database
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/databases/update",
+ "Bearer "+owner.Token,
+ database,
+ http.StatusOK,
+ &response,
+ )
+
+ transferRequest := notifiers.TransferNotifierRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/notifiers/%s/transfer", notifier.ID.String()),
+ "Bearer "+owner.Token,
+ transferRequest,
+ http.StatusBadRequest,
+ )
+
+ assert.Contains(
+ t,
+ string(testResp.Body),
+ "notifier has attached databases and cannot be transferred",
+ )
+}
+
+func createTestRouterWithNotifier() *gin.Engine {
+ router := workspaces_testing.CreateTestRouter(
+ workspaces_controllers.GetWorkspaceController(),
+ workspaces_controllers.GetMembershipController(),
+ databases.GetDatabaseController(),
+ GetBackupConfigController(),
+ storages.GetStorageController(),
+ notifiers.GetNotifierController(),
+ )
+
+ storages.SetupDependencies()
+ databases.SetupDependencies()
+ notifiers.SetupDependencies()
+ SetupDependencies()
+
+ return router
+}
diff --git a/backend/internal/features/backups/config/repository.go b/backend/internal/features/backups/config/repository.go
index f493c12d..2de68b40 100644
--- a/backend/internal/features/backups/config/repository.go
+++ b/backend/internal/features/backups/config/repository.go
@@ -102,3 +102,19 @@ func (r *BackupConfigRepository) IsStorageUsing(storageID uuid.UUID) (bool, erro
return count > 0, nil
}
+
+func (r *BackupConfigRepository) GetDatabasesIDsByStorageID(
+ storageID uuid.UUID,
+) ([]uuid.UUID, error) {
+ var databasesIDs []uuid.UUID
+
+ if err := storage.
+ GetDb().
+ Table("backup_configs").
+ Where("storage_id = ?", storageID).
+ Pluck("database_id", &databasesIDs).Error; err != nil {
+ return nil, err
+ }
+
+ return databasesIDs, nil
+}
diff --git a/backend/internal/features/backups/config/service.go b/backend/internal/features/backups/config/service.go
index 4cfda9da..4fdfc6d4 100644
--- a/backend/internal/features/backups/config/service.go
+++ b/backend/internal/features/backups/config/service.go
@@ -5,6 +5,7 @@ import (
"databasus-backend/internal/features/databases"
"databasus-backend/internal/features/intervals"
+ "databasus-backend/internal/features/notifiers"
"databasus-backend/internal/features/storages"
users_models "databasus-backend/internal/features/users/models"
workspaces_services "databasus-backend/internal/features/workspaces/services"
@@ -17,6 +18,7 @@ type BackupConfigService struct {
backupConfigRepository *BackupConfigRepository
databaseService *databases.DatabaseService
storageService *storages.StorageService
+ notifierService *notifiers.NotifierService
workspaceService *workspaces_services.WorkspaceService
dbStorageChangeListener BackupConfigStorageChangeListener
@@ -28,6 +30,17 @@ func (s *BackupConfigService) SetDatabaseStorageChangeListener(
s.dbStorageChangeListener = dbStorageChangeListener
}
+func (s *BackupConfigService) GetStorageAttachedDatabasesIDs(
+ storageID uuid.UUID,
+) ([]uuid.UUID, error) {
+ databasesIDs, err := s.backupConfigRepository.GetDatabasesIDsByStorageID(storageID)
+ if err != nil {
+ return nil, err
+ }
+
+ return databasesIDs, nil
+}
+
func (s *BackupConfigService) SaveBackupConfigWithAuth(
user *users_models.User,
backupConfig *BackupConfig,
@@ -53,6 +66,16 @@ func (s *BackupConfigService) SaveBackupConfigWithAuth(
return nil, errors.New("insufficient permissions to modify backup configuration")
}
+ if backupConfig.Storage != nil && backupConfig.Storage.ID != uuid.Nil {
+ storage, err := s.storageService.GetStorageByID(backupConfig.Storage.ID)
+ if err != nil {
+ return nil, err
+ }
+ if storage.WorkspaceID != *database.WorkspaceID {
+ return nil, errors.New("storage does not belong to the same workspace as the database")
+ }
+ }
+
return s.SaveBackupConfig(backupConfig)
}
@@ -129,6 +152,23 @@ func (s *BackupConfigService) IsStorageUsing(
return s.backupConfigRepository.IsStorageUsing(storageID)
}
+func (s *BackupConfigService) CountDatabasesForStorage(
+ user *users_models.User,
+ storageID uuid.UUID,
+) (int, error) {
+ _, err := s.storageService.GetStorage(user, storageID)
+ if err != nil {
+ return 0, err
+ }
+
+ databaseIDs, err := s.backupConfigRepository.GetDatabasesIDsByStorageID(storageID)
+ if err != nil {
+ return 0, err
+ }
+
+ return len(databaseIDs), nil
+}
+
func (s *BackupConfigService) GetBackupConfigsWithEnabledBackups() ([]*BackupConfig, error) {
return s.backupConfigRepository.GetWithEnabledBackups()
}
@@ -176,6 +216,157 @@ func (s *BackupConfigService) initializeDefaultConfig(
return err
}
+func (s *BackupConfigService) TransferDatabaseToWorkspace(
+ user *users_models.User,
+ databaseID uuid.UUID,
+ request *TransferDatabaseRequest,
+) error {
+ database, err := s.databaseService.GetDatabaseByID(databaseID)
+ if err != nil {
+ return err
+ }
+
+ if database.WorkspaceID == nil {
+ return ErrDatabaseHasNoWorkspace
+ }
+
+ canManageSource, err := s.workspaceService.CanUserManageDBs(*database.WorkspaceID, user)
+ if err != nil {
+ return err
+ }
+ if !canManageSource {
+ return ErrInsufficientPermissionsInSourceWorkspace
+ }
+
+ canManageTarget, err := s.workspaceService.CanUserManageDBs(request.TargetWorkspaceID, user)
+ if err != nil {
+ return err
+ }
+ if !canManageTarget {
+ return ErrInsufficientPermissionsInTargetWorkspace
+ }
+
+ if err := s.validateTargetNotifiers(request); err != nil {
+ return err
+ }
+
+ backupConfig, err := s.GetBackupConfigByDbId(databaseID)
+ if err != nil {
+ return err
+ }
+
+ if request.IsTransferWithNotifiers {
+ s.transferNotifiers(user, database, request.TargetWorkspaceID)
+ }
+
+ if request.IsTransferWithStorage {
+ if backupConfig.StorageID == nil {
+ return ErrDatabaseHasNoStorage
+ }
+
+ attachedDatabasesIDs, err := s.GetStorageAttachedDatabasesIDs(*backupConfig.StorageID)
+ if err != nil {
+ return err
+ }
+
+ for _, dbID := range attachedDatabasesIDs {
+ if dbID != databaseID {
+ return ErrStorageHasOtherAttachedDatabases
+ }
+ }
+
+ err = s.storageService.TransferStorageToWorkspace(
+ user,
+ *backupConfig.StorageID,
+ request.TargetWorkspaceID,
+ &databaseID,
+ )
+ if err != nil {
+ return err
+ }
+ } else if request.TargetStorageID != nil {
+ targetStorage, err := s.storageService.GetStorageByID(*request.TargetStorageID)
+ if err != nil {
+ return err
+ }
+
+ if targetStorage.WorkspaceID != request.TargetWorkspaceID {
+ return ErrTargetStorageNotInTargetWorkspace
+ }
+
+ backupConfig.StorageID = request.TargetStorageID
+ backupConfig.Storage = targetStorage
+
+ _, err = s.backupConfigRepository.Save(backupConfig)
+ if err != nil {
+ return err
+ }
+ } else {
+ return ErrTargetStorageNotSpecified
+ }
+
+ err = s.databaseService.TransferDatabaseToWorkspace(databaseID, request.TargetWorkspaceID)
+ if err != nil {
+ return err
+ }
+
+ if len(request.TargetNotifierIDs) > 0 {
+ err = s.assignTargetNotifiers(databaseID, request.TargetNotifierIDs)
+ if err != nil {
+ return err
+ }
+ }
+
+ return nil
+}
+
+func (s *BackupConfigService) transferNotifiers(
+ user *users_models.User,
+ database *databases.Database,
+ targetWorkspaceID uuid.UUID,
+) {
+ for _, notifier := range database.Notifiers {
+ _ = s.notifierService.TransferNotifierToWorkspace(
+ user,
+ notifier.ID,
+ targetWorkspaceID,
+ &database.ID,
+ )
+ }
+}
+
+func (s *BackupConfigService) validateTargetNotifiers(request *TransferDatabaseRequest) error {
+ for _, notifierID := range request.TargetNotifierIDs {
+ notifier, err := s.notifierService.GetNotifierByID(notifierID)
+ if err != nil {
+ return err
+ }
+
+ if notifier.WorkspaceID != request.TargetWorkspaceID {
+ return ErrTargetNotifierNotInTargetWorkspace
+ }
+ }
+ return nil
+}
+
+func (s *BackupConfigService) assignTargetNotifiers(
+ databaseID uuid.UUID,
+ notifierIDs []uuid.UUID,
+) error {
+ targetNotifiers := make([]notifiers.Notifier, 0, len(notifierIDs))
+
+ for _, notifierID := range notifierIDs {
+ notifier, err := s.notifierService.GetNotifierByID(notifierID)
+ if err != nil {
+ return err
+ }
+
+ targetNotifiers = append(targetNotifiers, *notifier)
+ }
+
+ return s.databaseService.UpdateDatabaseNotifiers(databaseID, targetNotifiers)
+}
+
func storageIDsEqual(id1, id2 *uuid.UUID) bool {
if id1 == nil && id2 == nil {
return true
diff --git a/backend/internal/features/backups/config/storages_test.go b/backend/internal/features/backups/config/storages_test.go
new file mode 100644
index 00000000..6ee07535
--- /dev/null
+++ b/backend/internal/features/backups/config/storages_test.go
@@ -0,0 +1,229 @@
+package backups_config
+
+import (
+ "fmt"
+ "net/http"
+ "testing"
+
+ "github.com/gin-gonic/gin"
+ "github.com/stretchr/testify/assert"
+
+ "databasus-backend/internal/features/databases"
+ "databasus-backend/internal/features/intervals"
+ "databasus-backend/internal/features/storages"
+ users_enums "databasus-backend/internal/features/users/enums"
+ users_testing "databasus-backend/internal/features/users/testing"
+ workspaces_controllers "databasus-backend/internal/features/workspaces/controllers"
+ workspaces_testing "databasus-backend/internal/features/workspaces/testing"
+ "databasus-backend/internal/util/period"
+ test_utils "databasus-backend/internal/util/testing"
+)
+
+func Test_AttachStorageFromSameWorkspace_SuccessfullyAttached(t *testing.T) {
+ router := createTestRouterWithStorage()
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+
+ database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
+ storage := createTestStorage(workspace.ID)
+
+ timeOfDay := "04:00"
+ request := BackupConfig{
+ DatabaseID: database.ID,
+ IsBackupsEnabled: true,
+ StorePeriod: period.PeriodWeek,
+ BackupInterval: &intervals.Interval{
+ Interval: intervals.IntervalDaily,
+ TimeOfDay: &timeOfDay,
+ },
+ Storage: storage,
+ SendNotificationsOn: []BackupNotificationType{
+ NotificationBackupFailed,
+ },
+ IsRetryIfFailed: true,
+ MaxFailedTriesCount: 3,
+ Encryption: BackupEncryptionNone,
+ }
+
+ var response BackupConfig
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/backup-configs/save",
+ "Bearer "+owner.Token,
+ request,
+ http.StatusOK,
+ &response,
+ )
+
+ assert.Equal(t, database.ID, response.DatabaseID)
+ assert.NotNil(t, response.StorageID)
+ assert.Equal(t, storage.ID, *response.StorageID)
+}
+
+func Test_AttachStorageFromDifferentWorkspace_ReturnsForbidden(t *testing.T) {
+ router := createTestRouterWithStorage()
+
+ owner1 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace1 := workspaces_testing.CreateTestWorkspace("Workspace 1", owner1, router)
+ database := createTestDatabaseViaAPI("Test Database", workspace1.ID, owner1.Token, router)
+
+ owner2 := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace2 := workspaces_testing.CreateTestWorkspace("Workspace 2", owner2, router)
+ storage := createTestStorage(workspace2.ID)
+
+ timeOfDay := "04:00"
+ request := BackupConfig{
+ DatabaseID: database.ID,
+ IsBackupsEnabled: true,
+ StorePeriod: period.PeriodWeek,
+ BackupInterval: &intervals.Interval{
+ Interval: intervals.IntervalDaily,
+ TimeOfDay: &timeOfDay,
+ },
+ Storage: storage,
+ SendNotificationsOn: []BackupNotificationType{
+ NotificationBackupFailed,
+ },
+ IsRetryIfFailed: true,
+ MaxFailedTriesCount: 3,
+ Encryption: BackupEncryptionNone,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ "/api/v1/backup-configs/save",
+ "Bearer "+owner1.Token,
+ request,
+ http.StatusBadRequest,
+ )
+
+ assert.Contains(t, string(testResp.Body), "storage does not belong to the same workspace")
+}
+
+func Test_DeleteStorageWithAttachedDatabases_CannotDelete(t *testing.T) {
+ router := createTestRouterWithStorage()
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+
+ database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
+ storage := createTestStorage(workspace.ID)
+
+ timeOfDay := "04:00"
+ request := BackupConfig{
+ DatabaseID: database.ID,
+ IsBackupsEnabled: true,
+ StorePeriod: period.PeriodWeek,
+ BackupInterval: &intervals.Interval{
+ Interval: intervals.IntervalDaily,
+ TimeOfDay: &timeOfDay,
+ },
+ Storage: storage,
+ SendNotificationsOn: []BackupNotificationType{
+ NotificationBackupFailed,
+ },
+ IsRetryIfFailed: true,
+ MaxFailedTriesCount: 3,
+ Encryption: BackupEncryptionNone,
+ }
+
+ var response BackupConfig
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/backup-configs/save",
+ "Bearer "+owner.Token,
+ request,
+ http.StatusOK,
+ &response,
+ )
+
+ testResp := test_utils.MakeDeleteRequest(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/storages/%s", storage.ID.String()),
+ "Bearer "+owner.Token,
+ http.StatusBadRequest,
+ )
+
+ assert.Contains(
+ t,
+ string(testResp.Body),
+ "storage has attached databases and cannot be deleted",
+ )
+}
+
+func Test_TransferStorageWithAttachedDatabase_CannotTransfer(t *testing.T) {
+ router := createTestRouterWithStorage()
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
+ targetWorkspace := workspaces_testing.CreateTestWorkspace("Target Workspace", owner, router)
+
+ database := createTestDatabaseViaAPI("Test Database", workspace.ID, owner.Token, router)
+ storage := createTestStorage(workspace.ID)
+
+ timeOfDay := "04:00"
+ request := BackupConfig{
+ DatabaseID: database.ID,
+ IsBackupsEnabled: true,
+ StorePeriod: period.PeriodWeek,
+ BackupInterval: &intervals.Interval{
+ Interval: intervals.IntervalDaily,
+ TimeOfDay: &timeOfDay,
+ },
+ Storage: storage,
+ SendNotificationsOn: []BackupNotificationType{
+ NotificationBackupFailed,
+ },
+ IsRetryIfFailed: true,
+ MaxFailedTriesCount: 3,
+ Encryption: BackupEncryptionNone,
+ }
+
+ var response BackupConfig
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/backup-configs/save",
+ "Bearer "+owner.Token,
+ request,
+ http.StatusOK,
+ &response,
+ )
+
+ transferRequest := storages.TransferStorageRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/storages/%s/transfer", storage.ID.String()),
+ "Bearer "+owner.Token,
+ transferRequest,
+ http.StatusBadRequest,
+ )
+
+ assert.Contains(
+ t,
+ string(testResp.Body),
+ "storage has attached databases and cannot be transferred",
+ )
+}
+
+func createTestRouterWithStorage() *gin.Engine {
+ router := workspaces_testing.CreateTestRouter(
+ workspaces_controllers.GetWorkspaceController(),
+ workspaces_controllers.GetMembershipController(),
+ databases.GetDatabaseController(),
+ GetBackupConfigController(),
+ storages.GetStorageController(),
+ )
+
+ storages.SetupDependencies()
+ databases.SetupDependencies()
+ SetupDependencies()
+
+ return router
+}
diff --git a/backend/internal/features/databases/controller.go b/backend/internal/features/databases/controller.go
index bbfbfe96..cc470ff3 100644
--- a/backend/internal/features/databases/controller.go
+++ b/backend/internal/features/databases/controller.go
@@ -26,6 +26,7 @@ func (c *DatabaseController) RegisterRoutes(router *gin.RouterGroup) {
router.POST("/databases/test-connection-direct", c.TestDatabaseConnectionDirect)
router.POST("/databases/:id/copy", c.CopyDatabase)
router.GET("/databases/notifier/:id/is-using", c.IsNotifierUsing)
+ router.GET("/databases/notifier/:id/databases-count", c.CountDatabasesByNotifier)
router.POST("/databases/is-readonly", c.IsUserReadOnly)
router.POST("/databases/create-readonly-user", c.CreateReadOnlyUser)
}
@@ -299,6 +300,39 @@ func (c *DatabaseController) IsNotifierUsing(ctx *gin.Context) {
ctx.JSON(http.StatusOK, gin.H{"isUsing": isUsing})
}
+// CountDatabasesByNotifier
+// @Summary Count databases using a notifier
+// @Description Get the count of databases that are using a specific notifier
+// @Tags databases
+// @Produce json
+// @Param id path string true "Notifier ID"
+// @Success 200 {object} map[string]int
+// @Failure 400
+// @Failure 401
+// @Failure 500
+// @Router /databases/notifier/{id}/databases-count [get]
+func (c *DatabaseController) CountDatabasesByNotifier(ctx *gin.Context) {
+ user, ok := users_middleware.GetUserFromContext(ctx)
+ if !ok {
+ ctx.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+
+ id, err := uuid.Parse(ctx.Param("id"))
+ if err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid notifier ID"})
+ return
+ }
+
+ count, err := c.databaseService.CountDatabasesByNotifier(user, id)
+ if err != nil {
+ ctx.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
+ return
+ }
+
+ ctx.JSON(http.StatusOK, gin.H{"count": count})
+}
+
// CopyDatabase
// @Summary Copy a database
// @Description Copy an existing database configuration
diff --git a/backend/internal/features/databases/databases/postgresql/readonly_user_test.go b/backend/internal/features/databases/databases/postgresql/readonly_user_test.go
index 79e6905b..1cf0546d 100644
--- a/backend/internal/features/databases/databases/postgresql/readonly_user_test.go
+++ b/backend/internal/features/databases/databases/postgresql/readonly_user_test.go
@@ -13,6 +13,7 @@ import (
"github.com/jmoiron/sqlx"
_ "github.com/lib/pq"
"github.com/stretchr/testify/assert"
+ "github.com/stretchr/testify/require"
"databasus-backend/internal/config"
"databasus-backend/internal/util/tools"
@@ -343,7 +344,7 @@ func Test_CreateReadOnlyUser_Supabase_UserCanReadButNotWrite(t *testing.T) {
)
adminDB, err := sqlx.Connect("postgres", dsn)
- assert.NoError(t, err)
+ require.NoError(t, err)
defer adminDB.Close()
tableName := fmt.Sprintf(
diff --git a/backend/internal/features/databases/di.go b/backend/internal/features/databases/di.go
index 92bdacaa..522e5024 100644
--- a/backend/internal/features/databases/di.go
+++ b/backend/internal/features/databases/di.go
@@ -39,4 +39,5 @@ func GetDatabaseController() *DatabaseController {
func SetupDependencies() {
workspaces_services.GetWorkspaceService().AddWorkspaceDeletionListener(databaseService)
+ notifiers.GetNotifierService().SetNotifierDatabaseCounter(databaseService)
}
diff --git a/backend/internal/features/databases/repository.go b/backend/internal/features/databases/repository.go
index 632f1851..c5dc8a74 100644
--- a/backend/internal/features/databases/repository.go
+++ b/backend/internal/features/databases/repository.go
@@ -243,3 +243,19 @@ func (r *DatabaseRepository) GetAllDatabases() ([]*Database, error) {
return databases, nil
}
+
+func (r *DatabaseRepository) GetDatabasesIDsByNotifierID(
+ notifierID uuid.UUID,
+) ([]uuid.UUID, error) {
+ var databasesIDs []uuid.UUID
+
+ if err := storage.
+ GetDb().
+ Table("database_notifiers").
+ Where("notifier_id = ?", notifierID).
+ Pluck("database_id", &databasesIDs).Error; err != nil {
+ return nil, err
+ }
+
+ return databasesIDs, nil
+}
diff --git a/backend/internal/features/databases/service.go b/backend/internal/features/databases/service.go
index 3fa754ae..bee47888 100644
--- a/backend/internal/features/databases/service.go
+++ b/backend/internal/features/databases/service.go
@@ -52,6 +52,17 @@ func (s *DatabaseService) AddDbCopyListener(
s.dbCopyListener = append(s.dbCopyListener, dbCopyListener)
}
+func (s *DatabaseService) GetNotifierAttachedDatabasesIDs(
+ notifierID uuid.UUID,
+) ([]uuid.UUID, error) {
+ databasesIDs, err := s.dbRepository.GetDatabasesIDsByNotifierID(notifierID)
+ if err != nil {
+ return nil, err
+ }
+
+ return databasesIDs, nil
+}
+
func (s *DatabaseService) CreateDatabase(
user *users_models.User,
workspaceID uuid.UUID,
@@ -126,6 +137,12 @@ func (s *DatabaseService) UpdateDatabase(
return err
}
+ for _, notifier := range database.Notifiers {
+ if notifier.WorkspaceID != *existingDatabase.WorkspaceID {
+ return errors.New("notifier does not belong to this workspace")
+ }
+ }
+
existingDatabase.Update(database)
if err := existingDatabase.Validate(); err != nil {
@@ -251,6 +268,23 @@ func (s *DatabaseService) IsNotifierUsing(
return s.dbRepository.IsNotifierUsing(notifierID)
}
+func (s *DatabaseService) CountDatabasesByNotifier(
+ user *users_models.User,
+ notifierID uuid.UUID,
+) (int, error) {
+ _, err := s.notifierService.GetNotifier(user, notifierID)
+ if err != nil {
+ return 0, err
+ }
+
+ databaseIDs, err := s.dbRepository.GetDatabasesIDsByNotifierID(notifierID)
+ if err != nil {
+ return 0, err
+ }
+
+ return len(databaseIDs), nil
+}
+
func (s *DatabaseService) TestDatabaseConnection(
user *users_models.User,
databaseID uuid.UUID,
@@ -481,6 +515,48 @@ func (s *DatabaseService) CopyDatabase(
return copiedDatabase, nil
}
+func (s *DatabaseService) TransferDatabaseToWorkspace(
+ databaseID uuid.UUID,
+ targetWorkspaceID uuid.UUID,
+) error {
+ database, err := s.dbRepository.FindByID(databaseID)
+ if err != nil {
+ return err
+ }
+
+ sourceWorkspaceID := database.WorkspaceID
+ database.WorkspaceID = &targetWorkspaceID
+
+ _, err = s.dbRepository.Save(database)
+ if err != nil {
+ return err
+ }
+
+ s.auditLogService.WriteAuditLog(
+ fmt.Sprintf("Database transferred: %s from workspace %s to workspace %s",
+ database.Name, sourceWorkspaceID, targetWorkspaceID),
+ nil,
+ &targetWorkspaceID,
+ )
+
+ return nil
+}
+
+func (s *DatabaseService) UpdateDatabaseNotifiers(
+ databaseID uuid.UUID,
+ newNotifiers []notifiers.Notifier,
+) error {
+ database, err := s.dbRepository.FindByID(databaseID)
+ if err != nil {
+ return err
+ }
+
+ database.Notifiers = newNotifiers
+
+ _, err = s.dbRepository.Save(database)
+ return err
+}
+
func (s *DatabaseService) SetHealthStatus(
databaseID uuid.UUID,
healthStatus *HealthStatus,
diff --git a/backend/internal/features/notifiers/controller.go b/backend/internal/features/notifiers/controller.go
index c108117c..aa28d13e 100644
--- a/backend/internal/features/notifiers/controller.go
+++ b/backend/internal/features/notifiers/controller.go
@@ -1,6 +1,8 @@
package notifiers
import (
+ "errors"
+
users_middleware "databasus-backend/internal/features/users/middleware"
workspaces_services "databasus-backend/internal/features/workspaces/services"
"net/http"
@@ -20,6 +22,7 @@ func (c *NotifierController) RegisterRoutes(router *gin.RouterGroup) {
router.GET("/notifiers/:id", c.GetNotifier)
router.DELETE("/notifiers/:id", c.DeleteNotifier)
router.POST("/notifiers/:id/test", c.SendTestNotification)
+ router.POST("/notifiers/:id/transfer", c.TransferNotifierToWorkspace)
router.POST("/notifiers/direct-test", c.SendTestNotificationDirect)
}
@@ -55,7 +58,7 @@ func (c *NotifierController) SaveNotifier(ctx *gin.Context) {
}
if err := c.notifierService.SaveNotifier(user, request.WorkspaceID, &request); err != nil {
- if err.Error() == "insufficient permissions to manage notifier in this workspace" {
+ if errors.Is(err, ErrInsufficientPermissionsToManageNotifier) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -93,7 +96,7 @@ func (c *NotifierController) GetNotifier(ctx *gin.Context) {
notifier, err := c.notifierService.GetNotifier(user, id)
if err != nil {
- if err.Error() == "insufficient permissions to view notifier in this workspace" {
+ if errors.Is(err, ErrInsufficientPermissionsToViewNotifier) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -137,7 +140,7 @@ func (c *NotifierController) GetNotifiers(ctx *gin.Context) {
notifiers, err := c.notifierService.GetNotifiers(user, workspaceID)
if err != nil {
- if err.Error() == "insufficient permissions to view notifiers in this workspace" {
+ if errors.Is(err, ErrInsufficientPermissionsToViewNotifiers) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -174,7 +177,7 @@ func (c *NotifierController) DeleteNotifier(ctx *gin.Context) {
}
if err := c.notifierService.DeleteNotifier(user, id); err != nil {
- if err.Error() == "insufficient permissions to manage notifier in this workspace" {
+ if errors.Is(err, ErrInsufficientPermissionsToManageNotifier) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -211,7 +214,7 @@ func (c *NotifierController) SendTestNotification(ctx *gin.Context) {
}
if err := c.notifierService.SendTestNotification(user, id); err != nil {
- if err.Error() == "insufficient permissions to test notifier in this workspace" {
+ if errors.Is(err, ErrInsufficientPermissionsToTestNotifier) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -222,6 +225,57 @@ func (c *NotifierController) SendTestNotification(ctx *gin.Context) {
ctx.JSON(http.StatusOK, gin.H{"message": "test notification sent successfully"})
}
+// TransferNotifierToWorkspace
+// @Summary Transfer notifier to another workspace
+// @Description Transfer a notifier from one workspace to another
+// @Tags notifiers
+// @Accept json
+// @Produce json
+// @Param Authorization header string true "JWT token"
+// @Param id path string true "Notifier ID"
+// @Param request body TransferNotifierRequest true "Target workspace ID"
+// @Success 200
+// @Failure 400
+// @Failure 401
+// @Failure 403
+// @Router /notifiers/{id}/transfer [post]
+func (c *NotifierController) TransferNotifierToWorkspace(ctx *gin.Context) {
+ user, ok := users_middleware.GetUserFromContext(ctx)
+ if !ok {
+ ctx.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+
+ id, err := uuid.Parse(ctx.Param("id"))
+ if err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid notifier ID"})
+ return
+ }
+
+ var request TransferNotifierRequest
+ if err := ctx.ShouldBindJSON(&request); err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+ return
+ }
+
+ if request.TargetWorkspaceID == uuid.Nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "targetWorkspaceId is required"})
+ return
+ }
+
+ if err := c.notifierService.TransferNotifierToWorkspace(user, id, request.TargetWorkspaceID, nil); err != nil {
+ if errors.Is(err, ErrInsufficientPermissionsInSourceWorkspace) ||
+ errors.Is(err, ErrInsufficientPermissionsInTargetWorkspace) {
+ ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
+ return
+ }
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+ return
+ }
+
+ ctx.JSON(http.StatusOK, gin.H{"message": "notifier transferred successfully"})
+}
+
// SendTestNotificationDirect
// @Summary Send test notification directly
// @Description Send a test notification using a notifier object provided in the request
diff --git a/backend/internal/features/notifiers/controller_test.go b/backend/internal/features/notifiers/controller_test.go
index e3a81d03..bb577fd2 100644
--- a/backend/internal/features/notifiers/controller_test.go
+++ b/backend/internal/features/notifiers/controller_test.go
@@ -202,164 +202,161 @@ func Test_SendTestNotificationExisting_NotificationSent(t *testing.T) {
workspaces_testing.RemoveTestWorkspace(workspace, router)
}
-func Test_ViewerCanViewNotifiers_ButCannotModify(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- viewer := users_testing.CreateTestUser(users_enums.UserRoleMember)
- router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- workspaces_testing.AddMemberToWorkspace(
- workspace,
- viewer,
- users_enums.WorkspaceRoleViewer,
- owner.Token,
- router,
- )
-
- notifier := createNewNotifier(workspace.ID)
-
- var savedNotifier Notifier
- test_utils.MakePostRequestAndUnmarshal(
- t,
- router,
- "/api/v1/notifiers",
- "Bearer "+owner.Token,
- *notifier,
- http.StatusOK,
- &savedNotifier,
- )
-
- // Viewer can GET notifiers
- var notifiers []Notifier
- test_utils.MakeGetRequestAndUnmarshal(
- t,
- router,
- fmt.Sprintf("/api/v1/notifiers?workspace_id=%s", workspace.ID.String()),
- "Bearer "+viewer.Token,
- http.StatusOK,
- &notifiers,
- )
- assert.Len(t, notifiers, 1)
-
- // Viewer cannot CREATE notifier
- newNotifier := createNewNotifier(workspace.ID)
- test_utils.MakePostRequest(
- t, router, "/api/v1/notifiers", "Bearer "+viewer.Token, *newNotifier, http.StatusForbidden,
- )
-
- // Viewer cannot UPDATE notifier
- savedNotifier.Name = "Updated by viewer"
- test_utils.MakePostRequest(
- t, router, "/api/v1/notifiers", "Bearer "+viewer.Token, savedNotifier, http.StatusForbidden,
- )
-
- // Viewer cannot DELETE notifier
- test_utils.MakeDeleteRequest(
- t,
- router,
- fmt.Sprintf("/api/v1/notifiers/%s", savedNotifier.ID.String()),
- "Bearer "+viewer.Token,
- http.StatusForbidden,
- )
-
- deleteNotifier(t, router, savedNotifier.ID, workspace.ID, owner.Token)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
-}
-
-func Test_MemberCanManageNotifiers(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
- router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- workspaces_testing.AddMemberToWorkspace(
- workspace,
- member,
- users_enums.WorkspaceRoleMember,
- owner.Token,
- router,
- )
-
- notifier := createNewNotifier(workspace.ID)
-
- // Member can CREATE notifier
- var savedNotifier Notifier
- test_utils.MakePostRequestAndUnmarshal(
- t,
- router,
- "/api/v1/notifiers",
- "Bearer "+member.Token,
- *notifier,
- http.StatusOK,
- &savedNotifier,
- )
- assert.NotEmpty(t, savedNotifier.ID)
-
- // Member can UPDATE notifier
- savedNotifier.Name = "Updated by member"
- var updatedNotifier Notifier
- test_utils.MakePostRequestAndUnmarshal(
- t,
- router,
- "/api/v1/notifiers",
- "Bearer "+member.Token,
- savedNotifier,
- http.StatusOK,
- &updatedNotifier,
- )
- assert.Equal(t, "Updated by member", updatedNotifier.Name)
-
- // Member can DELETE notifier
- test_utils.MakeDeleteRequest(
- t,
- router,
- fmt.Sprintf("/api/v1/notifiers/%s", savedNotifier.ID.String()),
- "Bearer "+member.Token,
- http.StatusOK,
- )
-
- workspaces_testing.RemoveTestWorkspace(workspace, router)
-}
+func Test_WorkspaceRolePermissions_Notifiers(t *testing.T) {
+ tests := []struct {
+ name string
+ workspaceRole *users_enums.WorkspaceRole
+ isGlobalAdmin bool
+ canCreate bool
+ canUpdate bool
+ canDelete bool
+ }{
+ {
+ name: "owner can manage notifiers",
+ workspaceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleOwner; return &r }(),
+ isGlobalAdmin: false,
+ canCreate: true,
+ canUpdate: true,
+ canDelete: true,
+ },
+ {
+ name: "admin can manage notifiers",
+ workspaceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleAdmin; return &r }(),
+ isGlobalAdmin: false,
+ canCreate: true,
+ canUpdate: true,
+ canDelete: true,
+ },
+ {
+ name: "member can manage notifiers",
+ workspaceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleMember; return &r }(),
+ isGlobalAdmin: false,
+ canCreate: true,
+ canUpdate: true,
+ canDelete: true,
+ },
+ {
+ name: "viewer can view but cannot modify notifiers",
+ workspaceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleViewer; return &r }(),
+ isGlobalAdmin: false,
+ canCreate: false,
+ canUpdate: false,
+ canDelete: false,
+ },
+ {
+ name: "global admin can manage notifiers",
+ workspaceRole: nil,
+ isGlobalAdmin: true,
+ canCreate: true,
+ canUpdate: true,
+ canDelete: true,
+ },
+ }
-func Test_AdminCanManageNotifiers(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- admin := users_testing.CreateTestUser(users_enums.UserRoleMember)
- router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- workspaces_testing.AddMemberToWorkspace(
- workspace,
- admin,
- users_enums.WorkspaceRoleAdmin,
- owner.Token,
- router,
- )
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ router := createRouter()
+ GetNotifierService().SetNotifierDatabaseCounter(&mockNotifierDatabaseCounter{})
- notifier := createNewNotifier(workspace.ID)
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- // Admin can CREATE, UPDATE, DELETE
- var savedNotifier Notifier
- test_utils.MakePostRequestAndUnmarshal(
- t,
- router,
- "/api/v1/notifiers",
- "Bearer "+admin.Token,
- *notifier,
- http.StatusOK,
- &savedNotifier,
- )
+ var testUserToken string
+ if tt.isGlobalAdmin {
+ admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ testUserToken = admin.Token
+ } else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
+ testUserToken = owner.Token
+ } else if tt.workspaceRole != nil {
+ testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspaces_testing.AddMemberToWorkspace(
+ workspace,
+ testUser,
+ *tt.workspaceRole,
+ owner.Token,
+ router,
+ )
+ testUserToken = testUser.Token
+ }
- savedNotifier.Name = "Updated by admin"
- test_utils.MakePostRequest(
- t, router, "/api/v1/notifiers", "Bearer "+admin.Token, savedNotifier, http.StatusOK,
- )
+ // Owner creates initial notifier for all test cases
+ var ownerNotifier Notifier
+ notifier := createNewNotifier(workspace.ID)
+ test_utils.MakePostRequestAndUnmarshal(
+ t, router, "/api/v1/notifiers", "Bearer "+owner.Token,
+ *notifier, http.StatusOK, &ownerNotifier,
+ )
- test_utils.MakeDeleteRequest(
- t,
- router,
- fmt.Sprintf("/api/v1/notifiers/%s", savedNotifier.ID.String()),
- "Bearer "+admin.Token,
- http.StatusOK,
- )
+ // Test GET notifiers
+ var notifiers []Notifier
+ test_utils.MakeGetRequestAndUnmarshal(
+ t, router,
+ fmt.Sprintf("/api/v1/notifiers?workspace_id=%s", workspace.ID.String()),
+ "Bearer "+testUserToken, http.StatusOK, &notifiers,
+ )
+ assert.Len(t, notifiers, 1)
+
+ // Test CREATE notifier
+ createStatusCode := http.StatusOK
+ if !tt.canCreate {
+ createStatusCode = http.StatusForbidden
+ }
+ newNotifier := createNewNotifier(workspace.ID)
+ var savedNotifier Notifier
+ if tt.canCreate {
+ test_utils.MakePostRequestAndUnmarshal(
+ t, router, "/api/v1/notifiers", "Bearer "+testUserToken,
+ *newNotifier, createStatusCode, &savedNotifier,
+ )
+ assert.NotEmpty(t, savedNotifier.ID)
+ } else {
+ test_utils.MakePostRequest(
+ t, router, "/api/v1/notifiers", "Bearer "+testUserToken,
+ *newNotifier, createStatusCode,
+ )
+ }
+
+ // Test UPDATE notifier
+ updateStatusCode := http.StatusOK
+ if !tt.canUpdate {
+ updateStatusCode = http.StatusForbidden
+ }
+ ownerNotifier.Name = "Updated by test user"
+ if tt.canUpdate {
+ var updatedNotifier Notifier
+ test_utils.MakePostRequestAndUnmarshal(
+ t, router, "/api/v1/notifiers", "Bearer "+testUserToken,
+ ownerNotifier, updateStatusCode, &updatedNotifier,
+ )
+ assert.Equal(t, "Updated by test user", updatedNotifier.Name)
+ } else {
+ test_utils.MakePostRequest(
+ t, router, "/api/v1/notifiers", "Bearer "+testUserToken,
+ ownerNotifier, updateStatusCode,
+ )
+ }
+
+ // Test DELETE notifier
+ deleteStatusCode := http.StatusOK
+ if !tt.canDelete {
+ deleteStatusCode = http.StatusForbidden
+ }
+ test_utils.MakeDeleteRequest(
+ t, router,
+ fmt.Sprintf("/api/v1/notifiers/%s", ownerNotifier.ID.String()),
+ "Bearer "+testUserToken, deleteStatusCode,
+ )
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ // Cleanup
+ if tt.canCreate {
+ deleteNotifier(t, router, savedNotifier.ID, workspace.ID, owner.Token)
+ }
+ if !tt.canDelete {
+ deleteNotifier(t, router, ownerNotifier.ID, workspace.ID, owner.Token)
+ }
+ workspaces_testing.RemoveTestWorkspace(workspace, router)
+ })
+ }
}
func Test_UserNotInWorkspace_CannotAccessNotifiers(t *testing.T) {
@@ -965,6 +962,192 @@ func Test_CreateNotifier_AllSensitiveFieldsEncryptedInDB(t *testing.T) {
}
}
+func Test_TransferNotifier_PermissionsEnforced(t *testing.T) {
+ tests := []struct {
+ name string
+ sourceRole *users_enums.WorkspaceRole
+ targetRole *users_enums.WorkspaceRole
+ isGlobalAdmin bool
+ expectSuccess bool
+ expectedStatusCode int
+ }{
+ {
+ name: "owner in both workspaces can transfer",
+ sourceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleOwner; return &r }(),
+ targetRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleOwner; return &r }(),
+ isGlobalAdmin: false,
+ expectSuccess: true,
+ expectedStatusCode: http.StatusOK,
+ },
+ {
+ name: "admin in both workspaces can transfer",
+ sourceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleAdmin; return &r }(),
+ targetRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleAdmin; return &r }(),
+ isGlobalAdmin: false,
+ expectSuccess: true,
+ expectedStatusCode: http.StatusOK,
+ },
+ {
+ name: "member in both workspaces can transfer",
+ sourceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleMember; return &r }(),
+ targetRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleMember; return &r }(),
+ isGlobalAdmin: false,
+ expectSuccess: true,
+ expectedStatusCode: http.StatusOK,
+ },
+ {
+ name: "viewer in both workspaces cannot transfer",
+ sourceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleViewer; return &r }(),
+ targetRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleViewer; return &r }(),
+ isGlobalAdmin: false,
+ expectSuccess: false,
+ expectedStatusCode: http.StatusForbidden,
+ },
+ {
+ name: "global admin can transfer",
+ sourceRole: nil,
+ targetRole: nil,
+ isGlobalAdmin: true,
+ expectSuccess: true,
+ expectedStatusCode: http.StatusOK,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ router := createRouter()
+ GetNotifierService().SetNotifierDatabaseCounter(&mockNotifierDatabaseCounter{})
+
+ sourceOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ targetOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(
+ "Source Workspace",
+ sourceOwner,
+ router,
+ )
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(
+ "Target Workspace",
+ targetOwner,
+ router,
+ )
+
+ notifier := createNewNotifier(sourceWorkspace.ID)
+ var savedNotifier Notifier
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/notifiers",
+ "Bearer "+sourceOwner.Token,
+ *notifier,
+ http.StatusOK,
+ &savedNotifier,
+ )
+
+ var testUserToken string
+ if tt.isGlobalAdmin {
+ admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ testUserToken = admin.Token
+ } else if tt.sourceRole != nil {
+ testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspaces_testing.AddMemberToWorkspace(sourceWorkspace, testUser, *tt.sourceRole, sourceOwner.Token, router)
+ workspaces_testing.AddMemberToWorkspace(targetWorkspace, testUser, *tt.targetRole, targetOwner.Token, router)
+ testUserToken = testUser.Token
+ }
+
+ request := TransferNotifierRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/notifiers/%s/transfer", savedNotifier.ID.String()),
+ "Bearer "+testUserToken,
+ request,
+ tt.expectedStatusCode,
+ )
+
+ if tt.expectSuccess {
+ assert.Contains(t, string(testResp.Body), "transferred successfully")
+
+ var retrievedNotifier Notifier
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/notifiers/%s", savedNotifier.ID.String()),
+ "Bearer "+targetOwner.Token,
+ http.StatusOK,
+ &retrievedNotifier,
+ )
+ assert.Equal(t, targetWorkspace.ID, retrievedNotifier.WorkspaceID)
+
+ deleteNotifier(t, router, savedNotifier.ID, targetWorkspace.ID, targetOwner.Token)
+ } else {
+ assert.Contains(t, string(testResp.Body), "insufficient permissions")
+ deleteNotifier(t, router, savedNotifier.ID, sourceWorkspace.ID, sourceOwner.Token)
+ }
+
+ workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ })
+ }
+}
+
+func Test_TransferNotifierNotManagableWorkspace_TransferFailed(t *testing.T) {
+ router := createRouter()
+ GetNotifierService().SetNotifierDatabaseCounter(&mockNotifierDatabaseCounter{})
+
+ userA := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ userB := users_testing.CreateTestUser(users_enums.UserRoleMember)
+
+ workspace1 := workspaces_testing.CreateTestWorkspace("Workspace 1", userA, router)
+ workspace2 := workspaces_testing.CreateTestWorkspace("Workspace 2", userB, router)
+
+ notifier := createNewNotifier(workspace1.ID)
+ var savedNotifier Notifier
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/notifiers",
+ "Bearer "+userA.Token,
+ *notifier,
+ http.StatusOK,
+ &savedNotifier,
+ )
+
+ request := TransferNotifierRequest{
+ TargetWorkspaceID: workspace2.ID,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/notifiers/%s/transfer", savedNotifier.ID.String()),
+ "Bearer "+userA.Token,
+ request,
+ http.StatusForbidden,
+ )
+
+ assert.Contains(
+ t,
+ string(testResp.Body),
+ "insufficient permissions to manage notifier in target workspace",
+ )
+
+ deleteNotifier(t, router, savedNotifier.ID, workspace1.ID, userA.Token)
+ workspaces_testing.RemoveTestWorkspace(workspace1, router)
+ workspaces_testing.RemoveTestWorkspace(workspace2, router)
+}
+
+type mockNotifierDatabaseCounter struct{}
+
+func (m *mockNotifierDatabaseCounter) GetNotifierAttachedDatabasesIDs(
+ notifierID uuid.UUID,
+) ([]uuid.UUID, error) {
+ return []uuid.UUID{}, nil
+}
+
func createRouter() *gin.Engine {
gin.SetMode(gin.TestMode)
router := gin.New()
@@ -979,6 +1162,7 @@ func createRouter() *gin.Engine {
}
audit_logs.SetupDependencies()
+ GetNotifierService().SetNotifierDatabaseCounter(&mockNotifierDatabaseCounter{})
return router
}
diff --git a/backend/internal/features/notifiers/di.go b/backend/internal/features/notifiers/di.go
index 86a24ed1..410d9434 100644
--- a/backend/internal/features/notifiers/di.go
+++ b/backend/internal/features/notifiers/di.go
@@ -14,6 +14,7 @@ var notifierService = &NotifierService{
workspaces_services.GetWorkspaceService(),
audit_logs.GetAuditLogService(),
encryption.GetFieldEncryptor(),
+ nil,
}
var notifierController = &NotifierController{
notifierService,
diff --git a/backend/internal/features/notifiers/dto.go b/backend/internal/features/notifiers/dto.go
new file mode 100644
index 00000000..2a525b2d
--- /dev/null
+++ b/backend/internal/features/notifiers/dto.go
@@ -0,0 +1,7 @@
+package notifiers
+
+import "github.com/google/uuid"
+
+type TransferNotifierRequest struct {
+ TargetWorkspaceID uuid.UUID `json:"targetWorkspaceId" binding:"required"`
+}
diff --git a/backend/internal/features/notifiers/errors.go b/backend/internal/features/notifiers/errors.go
new file mode 100644
index 00000000..d3fcb9f4
--- /dev/null
+++ b/backend/internal/features/notifiers/errors.go
@@ -0,0 +1,36 @@
+package notifiers
+
+import "errors"
+
+var (
+ ErrInsufficientPermissionsToManageNotifier = errors.New(
+ "insufficient permissions to manage notifier in this workspace",
+ )
+ ErrInsufficientPermissionsToViewNotifier = errors.New(
+ "insufficient permissions to view notifier in this workspace",
+ )
+ ErrInsufficientPermissionsToViewNotifiers = errors.New(
+ "insufficient permissions to view notifiers in this workspace",
+ )
+ ErrInsufficientPermissionsToTestNotifier = errors.New(
+ "insufficient permissions to test notifier in this workspace",
+ )
+ ErrNotifierDoesNotBelongToWorkspace = errors.New(
+ "notifier does not belong to this workspace",
+ )
+ ErrInsufficientPermissionsInSourceWorkspace = errors.New(
+ "insufficient permissions to manage notifier in source workspace",
+ )
+ ErrInsufficientPermissionsInTargetWorkspace = errors.New(
+ "insufficient permissions to manage notifier in target workspace",
+ )
+ ErrNotifierHasAttachedDatabases = errors.New(
+ "notifier has attached databases and cannot be deleted",
+ )
+ ErrNotifierHasAttachedDatabasesCannotTransfer = errors.New(
+ "notifier has attached databases and cannot be transferred",
+ )
+ ErrNotifierHasOtherAttachedDatabasesCannotTransfer = errors.New(
+ "notifier has other attached databases and cannot be transferred",
+ )
+)
diff --git a/backend/internal/features/notifiers/interfaces.go b/backend/internal/features/notifiers/interfaces.go
index a62c11a6..cd961083 100644
--- a/backend/internal/features/notifiers/interfaces.go
+++ b/backend/internal/features/notifiers/interfaces.go
@@ -3,6 +3,8 @@ package notifiers
import (
"databasus-backend/internal/util/encryption"
"log/slog"
+
+ "github.com/google/uuid"
)
type NotificationSender interface {
@@ -19,3 +21,7 @@ type NotificationSender interface {
EncryptSensitiveData(encryptor encryption.FieldEncryptor) error
}
+
+type NotifierDatabaseCounter interface {
+ GetNotifierAttachedDatabasesIDs(notifierID uuid.UUID) ([]uuid.UUID, error)
+}
diff --git a/backend/internal/features/notifiers/service.go b/backend/internal/features/notifiers/service.go
index d6bcfd20..00f13dc7 100644
--- a/backend/internal/features/notifiers/service.go
+++ b/backend/internal/features/notifiers/service.go
@@ -1,7 +1,6 @@
package notifiers
import (
- "errors"
"fmt"
"log/slog"
@@ -14,11 +13,18 @@ import (
)
type NotifierService struct {
- notifierRepository *NotifierRepository
- logger *slog.Logger
- workspaceService *workspaces_services.WorkspaceService
- auditLogService *audit_logs.AuditLogService
- fieldEncryptor encryption.FieldEncryptor
+ notifierRepository *NotifierRepository
+ logger *slog.Logger
+ workspaceService *workspaces_services.WorkspaceService
+ auditLogService *audit_logs.AuditLogService
+ fieldEncryptor encryption.FieldEncryptor
+ notifierDatabaseCounter NotifierDatabaseCounter
+}
+
+func (s *NotifierService) SetNotifierDatabaseCounter(
+ notifierDatabaseCounter NotifierDatabaseCounter,
+) {
+ s.notifierDatabaseCounter = notifierDatabaseCounter
}
func (s *NotifierService) SaveNotifier(
@@ -31,7 +37,7 @@ func (s *NotifierService) SaveNotifier(
return err
}
if !canManage {
- return errors.New("insufficient permissions to manage notifier in this workspace")
+ return ErrInsufficientPermissionsToManageNotifier
}
isUpdate := notifier.ID != uuid.Nil
@@ -43,7 +49,7 @@ func (s *NotifierService) SaveNotifier(
}
if existingNotifier.WorkspaceID != workspaceID {
- return errors.New("notifier does not belong to this workspace")
+ return ErrNotifierDoesNotBelongToWorkspace
}
existingNotifier.Update(notifier)
@@ -106,7 +112,17 @@ func (s *NotifierService) DeleteNotifier(
return err
}
if !canManage {
- return errors.New("insufficient permissions to manage notifier in this workspace")
+ return ErrInsufficientPermissionsToManageNotifier
+ }
+
+ attachedDatabasesIDs, err := s.notifierDatabaseCounter.GetNotifierAttachedDatabasesIDs(
+ notifier.ID,
+ )
+ if err != nil {
+ return err
+ }
+ if len(attachedDatabasesIDs) > 0 {
+ return ErrNotifierHasAttachedDatabases
}
err = s.notifierRepository.Delete(notifier)
@@ -137,13 +153,17 @@ func (s *NotifierService) GetNotifier(
return nil, err
}
if !canView {
- return nil, errors.New("insufficient permissions to view notifier in this workspace")
+ return nil, ErrInsufficientPermissionsToViewNotifier
}
notifier.HideSensitiveData()
return notifier, nil
}
+func (s *NotifierService) GetNotifierByID(id uuid.UUID) (*Notifier, error) {
+ return s.notifierRepository.FindByID(id)
+}
+
func (s *NotifierService) GetNotifiers(
user *users_models.User,
workspaceID uuid.UUID,
@@ -153,7 +173,7 @@ func (s *NotifierService) GetNotifiers(
return nil, err
}
if !canView {
- return nil, errors.New("insufficient permissions to view notifiers in this workspace")
+ return nil, ErrInsufficientPermissionsToViewNotifiers
}
notifiers, err := s.notifierRepository.FindByWorkspaceID(workspaceID)
@@ -182,7 +202,7 @@ func (s *NotifierService) SendTestNotification(
return err
}
if !canView {
- return errors.New("insufficient permissions to test notifier in this workspace")
+ return ErrInsufficientPermissionsToTestNotifier
}
err = notifier.Send(s.fieldEncryptor, s.logger, "Test message", "This is a test message")
@@ -210,7 +230,7 @@ func (s *NotifierService) SendTestNotificationToNotifier(
}
if existingNotifier.WorkspaceID != notifier.WorkspaceID {
- return errors.New("notifier does not belong to this workspace")
+ return ErrNotifierDoesNotBelongToWorkspace
}
existingNotifier.Update(notifier)
@@ -269,6 +289,70 @@ func (s *NotifierService) SendNotification(
}
}
+func (s *NotifierService) TransferNotifierToWorkspace(
+ user *users_models.User,
+ notifierID uuid.UUID,
+ targetWorkspaceID uuid.UUID,
+ transferingWithDbID *uuid.UUID,
+) error {
+ existingNotifier, err := s.notifierRepository.FindByID(notifierID)
+ if err != nil {
+ return err
+ }
+
+ canManageSource, err := s.workspaceService.CanUserManageDBs(existingNotifier.WorkspaceID, user)
+ if err != nil {
+ return err
+ }
+ if !canManageSource {
+ return ErrInsufficientPermissionsInSourceWorkspace
+ }
+
+ canManageTarget, err := s.workspaceService.CanUserManageDBs(targetWorkspaceID, user)
+ if err != nil {
+ return err
+ }
+ if !canManageTarget {
+ return ErrInsufficientPermissionsInTargetWorkspace
+ }
+
+ attachedDatabasesIDs, err := s.notifierDatabaseCounter.GetNotifierAttachedDatabasesIDs(
+ existingNotifier.ID,
+ )
+ if err != nil {
+ return err
+ }
+
+ if transferingWithDbID != nil {
+ for _, dbID := range attachedDatabasesIDs {
+ if dbID != *transferingWithDbID {
+ return ErrNotifierHasOtherAttachedDatabasesCannotTransfer
+ }
+ }
+ } else {
+ if len(attachedDatabasesIDs) > 0 {
+ return ErrNotifierHasAttachedDatabasesCannotTransfer
+ }
+ }
+
+ sourceWorkspaceID := existingNotifier.WorkspaceID
+ existingNotifier.WorkspaceID = targetWorkspaceID
+
+ _, err = s.notifierRepository.Save(existingNotifier)
+ if err != nil {
+ return err
+ }
+
+ s.auditLogService.WriteAuditLog(
+ fmt.Sprintf("Notifier transferred: %s from workspace %s to workspace %s",
+ existingNotifier.Name, sourceWorkspaceID, targetWorkspaceID),
+ &user.ID,
+ &targetWorkspaceID,
+ )
+
+ return nil
+}
+
func (s *NotifierService) OnBeforeWorkspaceDeletion(workspaceID uuid.UUID) error {
notifiers, err := s.notifierRepository.FindByWorkspaceID(workspaceID)
if err != nil {
diff --git a/backend/internal/features/storages/controller.go b/backend/internal/features/storages/controller.go
index 7f7c6595..75eeaa4b 100644
--- a/backend/internal/features/storages/controller.go
+++ b/backend/internal/features/storages/controller.go
@@ -1,6 +1,8 @@
package storages
import (
+ "errors"
+
users_middleware "databasus-backend/internal/features/users/middleware"
workspaces_services "databasus-backend/internal/features/workspaces/services"
"net/http"
@@ -20,6 +22,7 @@ func (c *StorageController) RegisterRoutes(router *gin.RouterGroup) {
router.GET("/storages/:id", c.GetStorage)
router.DELETE("/storages/:id", c.DeleteStorage)
router.POST("/storages/:id/test", c.TestStorageConnection)
+ router.POST("/storages/:id/transfer", c.TransferStorageToWorkspace)
router.POST("/storages/direct-test", c.TestStorageConnectionDirect)
}
@@ -55,7 +58,7 @@ func (c *StorageController) SaveStorage(ctx *gin.Context) {
}
if err := c.storageService.SaveStorage(user, request.WorkspaceID, &request); err != nil {
- if err.Error() == "insufficient permissions to manage storage in this workspace" {
+ if errors.Is(err, ErrInsufficientPermissionsToManageStorage) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -93,7 +96,7 @@ func (c *StorageController) GetStorage(ctx *gin.Context) {
storage, err := c.storageService.GetStorage(user, id)
if err != nil {
- if err.Error() == "insufficient permissions to view storage in this workspace" {
+ if errors.Is(err, ErrInsufficientPermissionsToViewStorage) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -137,7 +140,7 @@ func (c *StorageController) GetStorages(ctx *gin.Context) {
storages, err := c.storageService.GetStorages(user, workspaceID)
if err != nil {
- if err.Error() == "insufficient permissions to view storages in this workspace" {
+ if errors.Is(err, ErrInsufficientPermissionsToViewStorages) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -174,7 +177,7 @@ func (c *StorageController) DeleteStorage(ctx *gin.Context) {
}
if err := c.storageService.DeleteStorage(user, id); err != nil {
- if err.Error() == "insufficient permissions to manage storage in this workspace" {
+ if errors.Is(err, ErrInsufficientPermissionsToManageStorage) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -211,7 +214,7 @@ func (c *StorageController) TestStorageConnection(ctx *gin.Context) {
}
if err := c.storageService.TestStorageConnection(user, id); err != nil {
- if err.Error() == "insufficient permissions to test storage in this workspace" {
+ if errors.Is(err, ErrInsufficientPermissionsToTestStorage) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -222,6 +225,57 @@ func (c *StorageController) TestStorageConnection(ctx *gin.Context) {
ctx.JSON(http.StatusOK, gin.H{"message": "storage connection test successful"})
}
+// TransferStorageToWorkspace
+// @Summary Transfer storage to another workspace
+// @Description Transfer a storage from one workspace to another
+// @Tags storages
+// @Accept json
+// @Produce json
+// @Param Authorization header string true "JWT token"
+// @Param id path string true "Storage ID"
+// @Param request body TransferStorageRequest true "Target workspace ID"
+// @Success 200
+// @Failure 400
+// @Failure 401
+// @Failure 403
+// @Router /storages/{id}/transfer [post]
+func (c *StorageController) TransferStorageToWorkspace(ctx *gin.Context) {
+ user, ok := users_middleware.GetUserFromContext(ctx)
+ if !ok {
+ ctx.JSON(http.StatusUnauthorized, gin.H{"error": "User not authenticated"})
+ return
+ }
+
+ id, err := uuid.Parse(ctx.Param("id"))
+ if err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "invalid storage ID"})
+ return
+ }
+
+ var request TransferStorageRequest
+ if err := ctx.ShouldBindJSON(&request); err != nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+ return
+ }
+
+ if request.TargetWorkspaceID == uuid.Nil {
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": "targetWorkspaceId is required"})
+ return
+ }
+
+ if err := c.storageService.TransferStorageToWorkspace(user, id, request.TargetWorkspaceID, nil); err != nil {
+ if errors.Is(err, ErrInsufficientPermissionsInSourceWorkspace) ||
+ errors.Is(err, ErrInsufficientPermissionsInTargetWorkspace) {
+ ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
+ return
+ }
+ ctx.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
+ return
+ }
+
+ ctx.JSON(http.StatusOK, gin.H{"message": "storage transferred successfully"})
+}
+
// TestStorageConnectionDirect
// @Summary Test storage connection directly
// @Description Test the connection to a storage object provided in the request
diff --git a/backend/internal/features/storages/controller_test.go b/backend/internal/features/storages/controller_test.go
index 9cba0c29..cfd237c9 100644
--- a/backend/internal/features/storages/controller_test.go
+++ b/backend/internal/features/storages/controller_test.go
@@ -29,6 +29,14 @@ import (
"github.com/stretchr/testify/assert"
)
+type mockStorageDatabaseCounter struct{}
+
+func (m *mockStorageDatabaseCounter) GetStorageAttachedDatabasesIDs(
+ storageID uuid.UUID,
+) ([]uuid.UUID, error) {
+ return []uuid.UUID{}, nil
+}
+
func Test_SaveNewStorage_StorageReturnedViaGet(t *testing.T) {
owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
router := createRouter()
@@ -200,161 +208,161 @@ func Test_TestExistingStorageConnection_ConnectionEstablished(t *testing.T) {
workspaces_testing.RemoveTestWorkspace(workspace, router)
}
-func Test_ViewerCanViewStorages_ButCannotModify(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- viewer := users_testing.CreateTestUser(users_enums.UserRoleMember)
- router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- workspaces_testing.AddMemberToWorkspace(
- workspace,
- viewer,
- users_enums.WorkspaceRoleViewer,
- owner.Token,
- router,
- )
- storage := createNewStorage(workspace.ID)
-
- var savedStorage Storage
- test_utils.MakePostRequestAndUnmarshal(
- t,
- router,
- "/api/v1/storages",
- "Bearer "+owner.Token,
- *storage,
- http.StatusOK,
- &savedStorage,
- )
-
- // Viewer can GET storages
- var storages []Storage
- test_utils.MakeGetRequestAndUnmarshal(
- t,
- router,
- fmt.Sprintf("/api/v1/storages?workspace_id=%s", workspace.ID.String()),
- "Bearer "+viewer.Token,
- http.StatusOK,
- &storages,
- )
- assert.Len(t, storages, 1)
-
- // Viewer cannot CREATE storage
- newStorage := createNewStorage(workspace.ID)
- test_utils.MakePostRequest(
- t, router, "/api/v1/storages", "Bearer "+viewer.Token, *newStorage, http.StatusForbidden,
- )
-
- // Viewer cannot UPDATE storage
- savedStorage.Name = "Updated by viewer"
- test_utils.MakePostRequest(
- t, router, "/api/v1/storages", "Bearer "+viewer.Token, savedStorage, http.StatusForbidden,
- )
-
- // Viewer cannot DELETE storage
- test_utils.MakeDeleteRequest(
- t,
- router,
- fmt.Sprintf("/api/v1/storages/%s", savedStorage.ID.String()),
- "Bearer "+viewer.Token,
- http.StatusForbidden,
- )
-
- deleteStorage(t, router, savedStorage.ID, workspace.ID, owner.Token)
- workspaces_testing.RemoveTestWorkspace(workspace, router)
-}
-
-func Test_MemberCanManageStorages(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- member := users_testing.CreateTestUser(users_enums.UserRoleMember)
- router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- workspaces_testing.AddMemberToWorkspace(
- workspace,
- member,
- users_enums.WorkspaceRoleMember,
- owner.Token,
- router,
- )
- storage := createNewStorage(workspace.ID)
-
- // Member can CREATE storage
- var savedStorage Storage
- test_utils.MakePostRequestAndUnmarshal(
- t,
- router,
- "/api/v1/storages",
- "Bearer "+member.Token,
- *storage,
- http.StatusOK,
- &savedStorage,
- )
- assert.NotEmpty(t, savedStorage.ID)
-
- // Member can UPDATE storage
- savedStorage.Name = "Updated by member"
- var updatedStorage Storage
- test_utils.MakePostRequestAndUnmarshal(
- t,
- router,
- "/api/v1/storages",
- "Bearer "+member.Token,
- savedStorage,
- http.StatusOK,
- &updatedStorage,
- )
- assert.Equal(t, "Updated by member", updatedStorage.Name)
-
- // Member can DELETE storage
- test_utils.MakeDeleteRequest(
- t,
- router,
- fmt.Sprintf("/api/v1/storages/%s", savedStorage.ID.String()),
- "Bearer "+member.Token,
- http.StatusOK,
- )
+func Test_WorkspaceRolePermissions(t *testing.T) {
+ tests := []struct {
+ name string
+ workspaceRole *users_enums.WorkspaceRole
+ isGlobalAdmin bool
+ canCreate bool
+ canUpdate bool
+ canDelete bool
+ }{
+ {
+ name: "owner can manage storages",
+ workspaceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleOwner; return &r }(),
+ isGlobalAdmin: false,
+ canCreate: true,
+ canUpdate: true,
+ canDelete: true,
+ },
+ {
+ name: "admin can manage storages",
+ workspaceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleAdmin; return &r }(),
+ isGlobalAdmin: false,
+ canCreate: true,
+ canUpdate: true,
+ canDelete: true,
+ },
+ {
+ name: "member can manage storages",
+ workspaceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleMember; return &r }(),
+ isGlobalAdmin: false,
+ canCreate: true,
+ canUpdate: true,
+ canDelete: true,
+ },
+ {
+ name: "viewer can view but cannot modify storages",
+ workspaceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleViewer; return &r }(),
+ isGlobalAdmin: false,
+ canCreate: false,
+ canUpdate: false,
+ canDelete: false,
+ },
+ {
+ name: "global admin can manage storages",
+ workspaceRole: nil,
+ isGlobalAdmin: true,
+ canCreate: true,
+ canUpdate: true,
+ canDelete: true,
+ },
+ }
- workspaces_testing.RemoveTestWorkspace(workspace, router)
-}
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ router := createRouter()
+ GetStorageService().SetStorageDatabaseCounter(&mockStorageDatabaseCounter{})
-func Test_AdminCanManageStorages(t *testing.T) {
- owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
- admin := users_testing.CreateTestUser(users_enums.UserRoleMember)
- router := createRouter()
- workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- workspaces_testing.AddMemberToWorkspace(
- workspace,
- admin,
- users_enums.WorkspaceRoleAdmin,
- owner.Token,
- router,
- )
- storage := createNewStorage(workspace.ID)
+ owner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspace := workspaces_testing.CreateTestWorkspace("Test Workspace", owner, router)
- // Admin can CREATE, UPDATE, DELETE
- var savedStorage Storage
- test_utils.MakePostRequestAndUnmarshal(
- t,
- router,
- "/api/v1/storages",
- "Bearer "+admin.Token,
- *storage,
- http.StatusOK,
- &savedStorage,
- )
+ var testUserToken string
+ if tt.isGlobalAdmin {
+ admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ testUserToken = admin.Token
+ } else if tt.workspaceRole != nil && *tt.workspaceRole == users_enums.WorkspaceRoleOwner {
+ testUserToken = owner.Token
+ } else if tt.workspaceRole != nil {
+ testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspaces_testing.AddMemberToWorkspace(
+ workspace,
+ testUser,
+ *tt.workspaceRole,
+ owner.Token,
+ router,
+ )
+ testUserToken = testUser.Token
+ }
- savedStorage.Name = "Updated by admin"
- test_utils.MakePostRequest(
- t, router, "/api/v1/storages", "Bearer "+admin.Token, savedStorage, http.StatusOK,
- )
+ // Owner creates initial storage for all test cases
+ var ownerStorage Storage
+ storage := createNewStorage(workspace.ID)
+ test_utils.MakePostRequestAndUnmarshal(
+ t, router, "/api/v1/storages", "Bearer "+owner.Token,
+ *storage, http.StatusOK, &ownerStorage,
+ )
- test_utils.MakeDeleteRequest(
- t,
- router,
- fmt.Sprintf("/api/v1/storages/%s", savedStorage.ID.String()),
- "Bearer "+admin.Token,
- http.StatusOK,
- )
+ // Test GET storages
+ var storages []Storage
+ test_utils.MakeGetRequestAndUnmarshal(
+ t, router,
+ fmt.Sprintf("/api/v1/storages?workspace_id=%s", workspace.ID.String()),
+ "Bearer "+testUserToken, http.StatusOK, &storages,
+ )
+ assert.Len(t, storages, 1)
+
+ // Test CREATE storage
+ createStatusCode := http.StatusOK
+ if !tt.canCreate {
+ createStatusCode = http.StatusForbidden
+ }
+ newStorage := createNewStorage(workspace.ID)
+ var savedStorage Storage
+ if tt.canCreate {
+ test_utils.MakePostRequestAndUnmarshal(
+ t, router, "/api/v1/storages", "Bearer "+testUserToken,
+ *newStorage, createStatusCode, &savedStorage,
+ )
+ assert.NotEmpty(t, savedStorage.ID)
+ } else {
+ test_utils.MakePostRequest(
+ t, router, "/api/v1/storages", "Bearer "+testUserToken,
+ *newStorage, createStatusCode,
+ )
+ }
+
+ // Test UPDATE storage
+ updateStatusCode := http.StatusOK
+ if !tt.canUpdate {
+ updateStatusCode = http.StatusForbidden
+ }
+ ownerStorage.Name = "Updated by test user"
+ if tt.canUpdate {
+ var updatedStorage Storage
+ test_utils.MakePostRequestAndUnmarshal(
+ t, router, "/api/v1/storages", "Bearer "+testUserToken,
+ ownerStorage, updateStatusCode, &updatedStorage,
+ )
+ assert.Equal(t, "Updated by test user", updatedStorage.Name)
+ } else {
+ test_utils.MakePostRequest(
+ t, router, "/api/v1/storages", "Bearer "+testUserToken,
+ ownerStorage, updateStatusCode,
+ )
+ }
+
+ // Test DELETE storage
+ deleteStatusCode := http.StatusOK
+ if !tt.canDelete {
+ deleteStatusCode = http.StatusForbidden
+ }
+ test_utils.MakeDeleteRequest(
+ t, router,
+ fmt.Sprintf("/api/v1/storages/%s", ownerStorage.ID.String()),
+ "Bearer "+testUserToken, deleteStatusCode,
+ )
- workspaces_testing.RemoveTestWorkspace(workspace, router)
+ // Cleanup
+ if tt.canCreate {
+ deleteStorage(t, router, savedStorage.ID, workspace.ID, owner.Token)
+ }
+ if !tt.canDelete {
+ deleteStorage(t, router, ownerStorage.ID, workspace.ID, owner.Token)
+ }
+ workspaces_testing.RemoveTestWorkspace(workspace, router)
+ })
+ }
}
func Test_UserNotInWorkspace_CannotAccessStorages(t *testing.T) {
@@ -975,6 +983,184 @@ func Test_StorageSensitiveDataLifecycle_AllTypes(t *testing.T) {
}
}
+func Test_TransferStorage_PermissionsEnforced(t *testing.T) {
+ tests := []struct {
+ name string
+ sourceRole *users_enums.WorkspaceRole
+ targetRole *users_enums.WorkspaceRole
+ isGlobalAdmin bool
+ expectSuccess bool
+ expectedStatusCode int
+ }{
+ {
+ name: "owner in both workspaces can transfer",
+ sourceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleOwner; return &r }(),
+ targetRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleOwner; return &r }(),
+ isGlobalAdmin: false,
+ expectSuccess: true,
+ expectedStatusCode: http.StatusOK,
+ },
+ {
+ name: "admin in both workspaces can transfer",
+ sourceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleAdmin; return &r }(),
+ targetRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleAdmin; return &r }(),
+ isGlobalAdmin: false,
+ expectSuccess: true,
+ expectedStatusCode: http.StatusOK,
+ },
+ {
+ name: "member in both workspaces can transfer",
+ sourceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleMember; return &r }(),
+ targetRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleMember; return &r }(),
+ isGlobalAdmin: false,
+ expectSuccess: true,
+ expectedStatusCode: http.StatusOK,
+ },
+ {
+ name: "viewer in both workspaces cannot transfer",
+ sourceRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleViewer; return &r }(),
+ targetRole: func() *users_enums.WorkspaceRole { r := users_enums.WorkspaceRoleViewer; return &r }(),
+ isGlobalAdmin: false,
+ expectSuccess: false,
+ expectedStatusCode: http.StatusForbidden,
+ },
+ {
+ name: "global admin can transfer",
+ sourceRole: nil,
+ targetRole: nil,
+ isGlobalAdmin: true,
+ expectSuccess: true,
+ expectedStatusCode: http.StatusOK,
+ },
+ }
+
+ for _, tt := range tests {
+ t.Run(tt.name, func(t *testing.T) {
+ router := createRouter()
+ GetStorageService().SetStorageDatabaseCounter(&mockStorageDatabaseCounter{})
+
+ sourceOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ targetOwner := users_testing.CreateTestUser(users_enums.UserRoleMember)
+
+ sourceWorkspace := workspaces_testing.CreateTestWorkspace(
+ "Source Workspace",
+ sourceOwner,
+ router,
+ )
+ targetWorkspace := workspaces_testing.CreateTestWorkspace(
+ "Target Workspace",
+ targetOwner,
+ router,
+ )
+
+ storage := createNewStorage(sourceWorkspace.ID)
+ var savedStorage Storage
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/storages",
+ "Bearer "+sourceOwner.Token,
+ *storage,
+ http.StatusOK,
+ &savedStorage,
+ )
+
+ var testUserToken string
+ if tt.isGlobalAdmin {
+ admin := users_testing.CreateTestUser(users_enums.UserRoleAdmin)
+ testUserToken = admin.Token
+ } else if tt.sourceRole != nil {
+ testUser := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ workspaces_testing.AddMemberToWorkspace(sourceWorkspace, testUser, *tt.sourceRole, sourceOwner.Token, router)
+ workspaces_testing.AddMemberToWorkspace(targetWorkspace, testUser, *tt.targetRole, targetOwner.Token, router)
+ testUserToken = testUser.Token
+ }
+
+ request := TransferStorageRequest{
+ TargetWorkspaceID: targetWorkspace.ID,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/storages/%s/transfer", savedStorage.ID.String()),
+ "Bearer "+testUserToken,
+ request,
+ tt.expectedStatusCode,
+ )
+
+ if tt.expectSuccess {
+ assert.Contains(t, string(testResp.Body), "transferred successfully")
+
+ var retrievedStorage Storage
+ test_utils.MakeGetRequestAndUnmarshal(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/storages/%s", savedStorage.ID.String()),
+ "Bearer "+targetOwner.Token,
+ http.StatusOK,
+ &retrievedStorage,
+ )
+ assert.Equal(t, targetWorkspace.ID, retrievedStorage.WorkspaceID)
+
+ deleteStorage(t, router, savedStorage.ID, targetWorkspace.ID, targetOwner.Token)
+ } else {
+ assert.Contains(t, string(testResp.Body), "insufficient permissions")
+ deleteStorage(t, router, savedStorage.ID, sourceWorkspace.ID, sourceOwner.Token)
+ }
+
+ workspaces_testing.RemoveTestWorkspace(sourceWorkspace, router)
+ workspaces_testing.RemoveTestWorkspace(targetWorkspace, router)
+ })
+ }
+}
+
+func Test_TransferStorageNotManagableWorkspace_TransferFailed(t *testing.T) {
+ router := createRouter()
+ GetStorageService().SetStorageDatabaseCounter(&mockStorageDatabaseCounter{})
+
+ userA := users_testing.CreateTestUser(users_enums.UserRoleMember)
+ userB := users_testing.CreateTestUser(users_enums.UserRoleMember)
+
+ workspace1 := workspaces_testing.CreateTestWorkspace("Workspace 1", userA, router)
+ workspace2 := workspaces_testing.CreateTestWorkspace("Workspace 2", userB, router)
+
+ storage := createNewStorage(workspace1.ID)
+ var savedStorage Storage
+ test_utils.MakePostRequestAndUnmarshal(
+ t,
+ router,
+ "/api/v1/storages",
+ "Bearer "+userA.Token,
+ *storage,
+ http.StatusOK,
+ &savedStorage,
+ )
+
+ request := TransferStorageRequest{
+ TargetWorkspaceID: workspace2.ID,
+ }
+
+ testResp := test_utils.MakePostRequest(
+ t,
+ router,
+ fmt.Sprintf("/api/v1/storages/%s/transfer", savedStorage.ID.String()),
+ "Bearer "+userA.Token,
+ request,
+ http.StatusForbidden,
+ )
+
+ assert.Contains(
+ t,
+ string(testResp.Body),
+ "insufficient permissions to manage storage in target workspace",
+ )
+
+ deleteStorage(t, router, savedStorage.ID, workspace1.ID, userA.Token)
+ workspaces_testing.RemoveTestWorkspace(workspace1, router)
+ workspaces_testing.RemoveTestWorkspace(workspace2, router)
+}
+
func createRouter() *gin.Engine {
gin.SetMode(gin.TestMode)
router := gin.New()
@@ -989,6 +1175,7 @@ func createRouter() *gin.Engine {
}
audit_logs.SetupDependencies()
+ GetStorageService().SetStorageDatabaseCounter(&mockStorageDatabaseCounter{})
return router
}
diff --git a/backend/internal/features/storages/di.go b/backend/internal/features/storages/di.go
index f7827484..522b9e91 100644
--- a/backend/internal/features/storages/di.go
+++ b/backend/internal/features/storages/di.go
@@ -12,6 +12,7 @@ var storageService = &StorageService{
workspaces_services.GetWorkspaceService(),
audit_logs.GetAuditLogService(),
encryption.GetFieldEncryptor(),
+ nil,
}
var storageController = &StorageController{
storageService,
diff --git a/backend/internal/features/storages/dto.go b/backend/internal/features/storages/dto.go
new file mode 100644
index 00000000..dc94ddfd
--- /dev/null
+++ b/backend/internal/features/storages/dto.go
@@ -0,0 +1,7 @@
+package storages
+
+import "github.com/google/uuid"
+
+type TransferStorageRequest struct {
+ TargetWorkspaceID uuid.UUID `json:"targetWorkspaceId" binding:"required"`
+}
diff --git a/backend/internal/features/storages/errors.go b/backend/internal/features/storages/errors.go
new file mode 100644
index 00000000..ee59b14f
--- /dev/null
+++ b/backend/internal/features/storages/errors.go
@@ -0,0 +1,36 @@
+package storages
+
+import "errors"
+
+var (
+ ErrInsufficientPermissionsToManageStorage = errors.New(
+ "insufficient permissions to manage storage in this workspace",
+ )
+ ErrInsufficientPermissionsToViewStorage = errors.New(
+ "insufficient permissions to view storage in this workspace",
+ )
+ ErrInsufficientPermissionsToViewStorages = errors.New(
+ "insufficient permissions to view storages in this workspace",
+ )
+ ErrInsufficientPermissionsToTestStorage = errors.New(
+ "insufficient permissions to test storage in this workspace",
+ )
+ ErrInsufficientPermissionsInSourceWorkspace = errors.New(
+ "insufficient permissions to manage storage in source workspace",
+ )
+ ErrInsufficientPermissionsInTargetWorkspace = errors.New(
+ "insufficient permissions to manage storage in target workspace",
+ )
+ ErrStorageDoesNotBelongToWorkspace = errors.New(
+ "storage does not belong to this workspace",
+ )
+ ErrStorageHasAttachedDatabases = errors.New(
+ "storage has attached databases and cannot be deleted",
+ )
+ ErrStorageHasAttachedDatabasesCannotTransfer = errors.New(
+ "storage has attached databases and cannot be transferred",
+ )
+ ErrStorageHasOtherAttachedDatabasesCannotTransfer = errors.New(
+ "storage has other attached databases and cannot be transferred",
+ )
+)
diff --git a/backend/internal/features/storages/interfaces.go b/backend/internal/features/storages/interfaces.go
index 7382f6db..009831ea 100644
--- a/backend/internal/features/storages/interfaces.go
+++ b/backend/internal/features/storages/interfaces.go
@@ -30,3 +30,7 @@ type StorageFileSaver interface {
EncryptSensitiveData(encryptor encryption.FieldEncryptor) error
}
+
+type StorageDatabaseCounter interface {
+ GetStorageAttachedDatabasesIDs(storageID uuid.UUID) ([]uuid.UUID, error)
+}
diff --git a/backend/internal/features/storages/models/s3/model.go b/backend/internal/features/storages/models/s3/model.go
index 362fb225..c54cc160 100644
--- a/backend/internal/features/storages/models/s3/model.go
+++ b/backend/internal/features/storages/models/s3/model.go
@@ -356,7 +356,7 @@ func (s *S3Storage) Update(incoming *S3Storage) {
}
// we do not allow to change the prefix after creation,
- // otherwise we will have to migrate all the data to the new prefix
+ // otherwise we will have to transfer all the data to the new prefix
}
func (s *S3Storage) buildObjectKey(fileName string) string {
diff --git a/backend/internal/features/storages/service.go b/backend/internal/features/storages/service.go
index b4eb6b07..3df411a5 100644
--- a/backend/internal/features/storages/service.go
+++ b/backend/internal/features/storages/service.go
@@ -1,7 +1,6 @@
package storages
import (
- "errors"
"fmt"
audit_logs "databasus-backend/internal/features/audit_logs"
@@ -13,10 +12,15 @@ import (
)
type StorageService struct {
- storageRepository *StorageRepository
- workspaceService *workspaces_services.WorkspaceService
- auditLogService *audit_logs.AuditLogService
- fieldEncryptor encryption.FieldEncryptor
+ storageRepository *StorageRepository
+ workspaceService *workspaces_services.WorkspaceService
+ auditLogService *audit_logs.AuditLogService
+ fieldEncryptor encryption.FieldEncryptor
+ storageDatabaseCounter StorageDatabaseCounter
+}
+
+func (s *StorageService) SetStorageDatabaseCounter(storageDatabaseCounter StorageDatabaseCounter) {
+ s.storageDatabaseCounter = storageDatabaseCounter
}
func (s *StorageService) SaveStorage(
@@ -29,7 +33,7 @@ func (s *StorageService) SaveStorage(
return err
}
if !canManage {
- return errors.New("insufficient permissions to manage storage in this workspace")
+ return ErrInsufficientPermissionsToManageStorage
}
isUpdate := storage.ID != uuid.Nil
@@ -41,7 +45,7 @@ func (s *StorageService) SaveStorage(
}
if existingStorage.WorkspaceID != workspaceID {
- return errors.New("storage does not belong to this workspace")
+ return ErrStorageDoesNotBelongToWorkspace
}
existingStorage.Update(storage)
@@ -104,7 +108,15 @@ func (s *StorageService) DeleteStorage(
return err
}
if !canManage {
- return errors.New("insufficient permissions to manage storage in this workspace")
+ return ErrInsufficientPermissionsToManageStorage
+ }
+
+ attachedDatabasesIDs, err := s.storageDatabaseCounter.GetStorageAttachedDatabasesIDs(storage.ID)
+ if err != nil {
+ return err
+ }
+ if len(attachedDatabasesIDs) > 0 {
+ return ErrStorageHasAttachedDatabases
}
err = s.storageRepository.Delete(storage)
@@ -135,7 +147,7 @@ func (s *StorageService) GetStorage(
return nil, err
}
if !canView {
- return nil, errors.New("insufficient permissions to view storage in this workspace")
+ return nil, ErrInsufficientPermissionsToViewStorage
}
storage.HideSensitiveData()
@@ -152,7 +164,7 @@ func (s *StorageService) GetStorages(
return nil, err
}
if !canView {
- return nil, errors.New("insufficient permissions to view storages in this workspace")
+ return nil, ErrInsufficientPermissionsToViewStorages
}
storages, err := s.storageRepository.FindByWorkspaceID(workspaceID)
@@ -181,7 +193,7 @@ func (s *StorageService) TestStorageConnection(
return err
}
if !canView {
- return errors.New("insufficient permissions to test storage in this workspace")
+ return ErrInsufficientPermissionsToTestStorage
}
err = storage.TestConnection(s.fieldEncryptor)
@@ -212,7 +224,7 @@ func (s *StorageService) TestStorageConnectionDirect(
}
if existingStorage.WorkspaceID != storage.WorkspaceID {
- return errors.New("storage does not belong to this workspace")
+ return ErrStorageDoesNotBelongToWorkspace
}
existingStorage.Update(storage)
@@ -235,6 +247,70 @@ func (s *StorageService) GetStorageByID(
return s.storageRepository.FindByID(id)
}
+func (s *StorageService) TransferStorageToWorkspace(
+ user *users_models.User,
+ storageID uuid.UUID,
+ targetWorkspaceID uuid.UUID,
+ transferingWithDbID *uuid.UUID,
+) error {
+ existingStorage, err := s.storageRepository.FindByID(storageID)
+ if err != nil {
+ return err
+ }
+
+ canManageSource, err := s.workspaceService.CanUserManageDBs(existingStorage.WorkspaceID, user)
+ if err != nil {
+ return err
+ }
+ if !canManageSource {
+ return ErrInsufficientPermissionsInSourceWorkspace
+ }
+
+ canManageTarget, err := s.workspaceService.CanUserManageDBs(targetWorkspaceID, user)
+ if err != nil {
+ return err
+ }
+ if !canManageTarget {
+ return ErrInsufficientPermissionsInTargetWorkspace
+ }
+
+ attachedDatabasesIDs, err := s.storageDatabaseCounter.GetStorageAttachedDatabasesIDs(
+ existingStorage.ID,
+ )
+ if err != nil {
+ return err
+ }
+
+ if transferingWithDbID != nil {
+ for _, dbID := range attachedDatabasesIDs {
+ if dbID != *transferingWithDbID {
+ return ErrStorageHasOtherAttachedDatabasesCannotTransfer
+ }
+ }
+ } else {
+ if len(attachedDatabasesIDs) > 0 {
+ return ErrStorageHasAttachedDatabasesCannotTransfer
+ }
+ }
+
+ sourceWorkspaceID := existingStorage.WorkspaceID
+ existingStorage.WorkspaceID = targetWorkspaceID
+
+ _, err = s.storageRepository.Save(existingStorage)
+ if err != nil {
+ return err
+ }
+
+ s.auditLogService.WriteAuditLog(
+ fmt.Sprintf("Storage transferred: %s from workspace %s to workspace %s",
+ existingStorage.Name, sourceWorkspaceID, targetWorkspaceID),
+ &user.ID,
+ &targetWorkspaceID,
+ )
+
+ return nil
+}
+
func (s *StorageService) OnBeforeWorkspaceDeletion(workspaceID uuid.UUID) error {
storages, err := s.storageRepository.FindByWorkspaceID(workspaceID)
if err != nil {
diff --git a/backend/internal/features/users/controllers/user_controller.go b/backend/internal/features/users/controllers/user_controller.go
index f68c7d51..c22380b5 100644
--- a/backend/internal/features/users/controllers/user_controller.go
+++ b/backend/internal/features/users/controllers/user_controller.go
@@ -1,10 +1,12 @@
package users_controllers
import (
+ "errors"
"net/http"
"databasus-backend/internal/config"
user_dto "databasus-backend/internal/features/users/dto"
+ users_errors "databasus-backend/internal/features/users/errors"
user_middleware "databasus-backend/internal/features/users/middleware"
users_services "databasus-backend/internal/features/users/services"
@@ -206,7 +208,7 @@ func (c *UserController) InviteUser(ctx *gin.Context) {
response, err := c.userService.InviteUser(&request, user)
if err != nil {
- if err.Error() == "insufficient permissions to invite users" {
+ if errors.Is(err, users_errors.ErrInsufficientPermissionsToInviteUsers) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
diff --git a/backend/internal/features/users/errors/errors.go b/backend/internal/features/users/errors/errors.go
new file mode 100644
index 00000000..d25ea8a1
--- /dev/null
+++ b/backend/internal/features/users/errors/errors.go
@@ -0,0 +1,7 @@
+package users_errors
+
+import "errors"
+
+var (
+ ErrInsufficientPermissionsToInviteUsers = errors.New("insufficient permissions to invite users")
+)
diff --git a/backend/internal/features/users/services/user_services.go b/backend/internal/features/users/services/user_services.go
index 69c4a00c..6a431dc0 100644
--- a/backend/internal/features/users/services/user_services.go
+++ b/backend/internal/features/users/services/user_services.go
@@ -20,6 +20,7 @@ import (
"databasus-backend/internal/features/encryption/secrets"
users_dto "databasus-backend/internal/features/users/dto"
users_enums "databasus-backend/internal/features/users/enums"
+ users_errors "databasus-backend/internal/features/users/errors"
users_interfaces "databasus-backend/internal/features/users/interfaces"
users_models "databasus-backend/internal/features/users/models"
users_repositories "databasus-backend/internal/features/users/repositories"
@@ -340,7 +341,7 @@ func (s *UserService) InviteUser(
// Check if user has permission to invite
if !invitedBy.CanInviteUsers(settings) {
- return nil, errors.New("insufficient permissions to invite users")
+ return nil, users_errors.ErrInsufficientPermissionsToInviteUsers
}
// Check if user already exists
diff --git a/backend/internal/features/workspaces/controllers/membership_controller.go b/backend/internal/features/workspaces/controllers/membership_controller.go
index a69d528d..ab78bb28 100644
--- a/backend/internal/features/workspaces/controllers/membership_controller.go
+++ b/backend/internal/features/workspaces/controllers/membership_controller.go
@@ -1,10 +1,12 @@
package workspaces_controllers
import (
+ "errors"
"net/http"
users_middleware "databasus-backend/internal/features/users/middleware"
workspaces_dto "databasus-backend/internal/features/workspaces/dto"
+ workspaces_errors "databasus-backend/internal/features/workspaces/errors"
workspaces_services "databasus-backend/internal/features/workspaces/services"
"github.com/gin-gonic/gin"
@@ -53,7 +55,7 @@ func (c *MembershipController) ListMembers(ctx *gin.Context) {
response, err := c.membershipService.GetMembers(workspaceID, user)
if err != nil {
- if err.Error() == "insufficient permissions to view workspace members" {
+ if errors.Is(err, workspaces_errors.ErrInsufficientPermissionsToViewMembers) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -105,8 +107,8 @@ func (c *MembershipController) AddMember(ctx *gin.Context) {
response, err := c.membershipService.AddMember(workspaceID, &request, user)
if err != nil {
- if err.Error() == "insufficient permissions to manage members" ||
- err.Error() == "only workspace owner can add/manage admins" {
+ if errors.Is(err, workspaces_errors.ErrInsufficientPermissionsToManageMembers) ||
+ errors.Is(err, workspaces_errors.ErrOnlyOwnerCanAddManageAdmins) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -160,8 +162,8 @@ func (c *MembershipController) ChangeMemberRole(ctx *gin.Context) {
}
if err := c.membershipService.ChangeMemberRole(workspaceID, userID, &request, user); err != nil {
- if err.Error() == "insufficient permissions to manage members" ||
- err.Error() == "only workspace owner can add/manage admins" {
+ if errors.Is(err, workspaces_errors.ErrInsufficientPermissionsToManageMembers) ||
+ errors.Is(err, workspaces_errors.ErrOnlyOwnerCanAddManageAdmins) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -206,8 +208,8 @@ func (c *MembershipController) RemoveMember(ctx *gin.Context) {
}
if err := c.membershipService.RemoveMember(workspaceID, userID, user); err != nil {
- if err.Error() == "insufficient permissions to remove members" ||
- err.Error() == "only workspace owner can remove admins" {
+ if errors.Is(err, workspaces_errors.ErrInsufficientPermissionsToRemoveMembers) ||
+ errors.Is(err, workspaces_errors.ErrOnlyOwnerCanRemoveAdmins) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -253,7 +255,7 @@ func (c *MembershipController) TransferOwnership(ctx *gin.Context) {
}
if err := c.membershipService.TransferOwnership(workspaceID, &request, user); err != nil {
- if err.Error() == "only workspace owner or admin can transfer ownership" {
+ if errors.Is(err, workspaces_errors.ErrOnlyOwnerOrAdminCanTransferOwnership) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
diff --git a/backend/internal/features/workspaces/controllers/workspace_controller.go b/backend/internal/features/workspaces/controllers/workspace_controller.go
index 09ccc44d..faac0d5c 100644
--- a/backend/internal/features/workspaces/controllers/workspace_controller.go
+++ b/backend/internal/features/workspaces/controllers/workspace_controller.go
@@ -1,11 +1,13 @@
package workspaces_controllers
import (
+ "errors"
"net/http"
audit_logs "databasus-backend/internal/features/audit_logs"
users_middleware "databasus-backend/internal/features/users/middleware"
workspaces_dto "databasus-backend/internal/features/workspaces/dto"
+ workspaces_errors "databasus-backend/internal/features/workspaces/errors"
workspaces_models "databasus-backend/internal/features/workspaces/models"
workspaces_services "databasus-backend/internal/features/workspaces/services"
@@ -56,7 +58,7 @@ func (c *WorkspaceController) CreateWorkspace(ctx *gin.Context) {
response, err := c.workspaceService.CreateWorkspace(&request, user)
if err != nil {
- if err.Error() == "insufficient permissions to create workspaces" {
+ if errors.Is(err, workspaces_errors.ErrInsufficientPermissionsToCreateWorkspaces) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -121,7 +123,7 @@ func (c *WorkspaceController) GetWorkspace(ctx *gin.Context) {
workspace, err := c.workspaceService.GetWorkspace(workspaceID, user)
if err != nil {
- if err.Error() == "insufficient permissions to view workspace" {
+ if errors.Is(err, workspaces_errors.ErrInsufficientPermissionsToViewWorkspace) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -168,7 +170,7 @@ func (c *WorkspaceController) UpdateWorkspace(ctx *gin.Context) {
updatedWorkspace, err := c.workspaceService.UpdateWorkspace(workspaceID, &workspace, user)
if err != nil {
- if err.Error() == "insufficient permissions to update workspace" {
+ if errors.Is(err, workspaces_errors.ErrInsufficientPermissionsToUpdateWorkspace) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -205,7 +207,7 @@ func (c *WorkspaceController) DeleteWorkspace(ctx *gin.Context) {
}
if err := c.workspaceService.DeleteWorkspace(workspaceID, user); err != nil {
- if err.Error() == "only workspace owner or admin can delete workspace" {
+ if errors.Is(err, workspaces_errors.ErrOnlyOwnerOrAdminCanDeleteWorkspace) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
@@ -254,7 +256,7 @@ func (c *WorkspaceController) GetWorkspaceAuditLogs(ctx *gin.Context) {
response, err := c.workspaceService.GetWorkspaceAuditLogs(workspaceID, user, request)
if err != nil {
- if err.Error() == "insufficient permissions to view workspace audit logs" {
+ if errors.Is(err, workspaces_errors.ErrInsufficientPermissionsToViewWorkspaceAuditLogs) {
ctx.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
return
}
diff --git a/backend/internal/features/workspaces/errors/errors.go b/backend/internal/features/workspaces/errors/errors.go
new file mode 100644
index 00000000..b33d2ff5
--- /dev/null
+++ b/backend/internal/features/workspaces/errors/errors.go
@@ -0,0 +1,56 @@
+package workspaces_errors
+
+import "errors"
+
+var (
+ // Workspace errors
+ ErrInsufficientPermissionsToCreateWorkspaces = errors.New(
+ "insufficient permissions to create workspaces",
+ )
+ ErrInsufficientPermissionsToViewWorkspace = errors.New(
+ "insufficient permissions to view workspace",
+ )
+ ErrInsufficientPermissionsToUpdateWorkspace = errors.New(
+ "insufficient permissions to update workspace",
+ )
+ ErrInsufficientPermissionsToViewWorkspaceAuditLogs = errors.New(
+ "insufficient permissions to view workspace audit logs",
+ )
+ ErrOnlyOwnerOrAdminCanDeleteWorkspace = errors.New(
+ "only workspace owner or admin can delete workspace",
+ )
+
+ // Membership errors
+ ErrInsufficientPermissionsToViewMembers = errors.New(
+ "insufficient permissions to view workspace members",
+ )
+ ErrInsufficientPermissionsToManageMembers = errors.New(
+ "insufficient permissions to manage members",
+ )
+ ErrInsufficientPermissionsToRemoveMembers = errors.New(
+ "insufficient permissions to remove members",
+ )
+ ErrInsufficientPermissionsToInviteUsers = errors.New(
+ "insufficient permissions to invite users",
+ )
+ ErrOnlyOwnerCanAddManageAdmins = errors.New(
+ "only workspace owner can add/manage admins",
+ )
+ ErrOnlyOwnerCanRemoveAdmins = errors.New("only workspace owner can remove admins")
+ ErrOnlyOwnerOrAdminCanTransferOwnership = errors.New(
+ "only workspace owner or admin can transfer ownership",
+ )
+ ErrUserAlreadyMember = errors.New(
+ "user is already a member of this workspace",
+ )
+ ErrCannotChangeOwnRole = errors.New("cannot change your own role")
+ ErrUserNotMemberOfWorkspace = errors.New("user is not a member of this workspace")
+ ErrCannotChangeOwnerRole = errors.New("cannot change owner role")
+ ErrUserNotFound = errors.New("user not found")
+ ErrCannotRemoveWorkspaceOwner = errors.New(
+ "cannot remove workspace owner, transfer ownership first",
+ )
+ ErrNewOwnerNotFound = errors.New("new owner not found")
+ ErrNewOwnerMustBeMember = errors.New("new owner must be a workspace member")
+ ErrNoCurrentWorkspaceOwner = errors.New("no current workspace owner found")
+)
diff --git a/backend/internal/features/workspaces/services/membership_service.go b/backend/internal/features/workspaces/services/membership_service.go
index 21411873..fd2c5284 100644
--- a/backend/internal/features/workspaces/services/membership_service.go
+++ b/backend/internal/features/workspaces/services/membership_service.go
@@ -1,7 +1,6 @@
package workspaces_services
import (
- "errors"
"fmt"
audit_logs "databasus-backend/internal/features/audit_logs"
@@ -10,6 +9,7 @@ import (
users_models "databasus-backend/internal/features/users/models"
users_services "databasus-backend/internal/features/users/services"
workspaces_dto "databasus-backend/internal/features/workspaces/dto"
+ workspaces_errors "databasus-backend/internal/features/workspaces/errors"
workspaces_models "databasus-backend/internal/features/workspaces/models"
workspaces_repositories "databasus-backend/internal/features/workspaces/repositories"
@@ -34,7 +34,7 @@ func (s *MembershipService) GetMembers(
return nil, err
}
if !canView {
- return nil, errors.New("insufficient permissions to view workspace members")
+ return nil, workspaces_errors.ErrInsufficientPermissionsToViewMembers
}
members, err := s.membershipRepository.GetWorkspaceMembers(workspaceID)
@@ -74,7 +74,7 @@ func (s *MembershipService) AddMember(
}
if !addedBy.CanInviteUsers(settings) {
- return nil, errors.New("insufficient permissions to invite users")
+ return nil, workspaces_errors.ErrInsufficientPermissionsToInviteUsers
}
inviteRequest := &users_dto.InviteUserRequestDTO{
@@ -118,7 +118,7 @@ func (s *MembershipService) AddMember(
workspaceID,
)
if existingMembership != nil {
- return nil, errors.New("user is already a member of this workspace")
+ return nil, workspaces_errors.ErrUserAlreadyMember
}
membership := &workspaces_models.WorkspaceMembership{
@@ -153,7 +153,7 @@ func (s *MembershipService) ChangeMemberRole(
}
if memberUserID == changedBy.ID {
- return errors.New("cannot change your own role")
+ return workspaces_errors.ErrCannotChangeOwnRole
}
existingMembership, err := s.membershipRepository.GetMembershipByUserAndWorkspace(
@@ -161,16 +161,16 @@ func (s *MembershipService) ChangeMemberRole(
workspaceID,
)
if err != nil {
- return errors.New("user is not a member of this workspace")
+ return workspaces_errors.ErrUserNotMemberOfWorkspace
}
if existingMembership.Role == users_enums.WorkspaceRoleOwner {
- return errors.New("cannot change owner role")
+ return workspaces_errors.ErrCannotChangeOwnerRole
}
targetUser, err := s.userService.GetUserByID(memberUserID)
if err != nil {
- return errors.New("user not found")
+ return workspaces_errors.ErrUserNotFound
}
if err := s.membershipRepository.UpdateMemberRole(memberUserID, workspaceID, request.Role); err != nil {
@@ -202,7 +202,7 @@ func (s *MembershipService) RemoveMember(
}
if !canManage {
- return errors.New("insufficient permissions to remove members")
+ return workspaces_errors.ErrInsufficientPermissionsToRemoveMembers
}
existingMembership, err := s.membershipRepository.GetMembershipByUserAndWorkspace(
@@ -210,11 +210,11 @@ func (s *MembershipService) RemoveMember(
workspaceID,
)
if err != nil {
- return errors.New("user is not a member of this workspace")
+ return workspaces_errors.ErrUserNotMemberOfWorkspace
}
if existingMembership.Role == users_enums.WorkspaceRoleOwner {
- return errors.New("cannot remove workspace owner, transfer ownership first")
+ return workspaces_errors.ErrCannotRemoveWorkspaceOwner
}
if existingMembership.Role == users_enums.WorkspaceRoleAdmin {
@@ -223,13 +223,13 @@ func (s *MembershipService) RemoveMember(
return err
}
if !canManageAdmins {
- return errors.New("only workspace owner can remove admins")
+ return workspaces_errors.ErrOnlyOwnerCanRemoveAdmins
}
}
targetUser, err := s.userService.GetUserByID(memberUserID)
if err != nil {
- return errors.New("user not found")
+ return workspaces_errors.ErrUserNotFound
}
if err := s.membershipRepository.RemoveMember(memberUserID, workspaceID); err != nil {
@@ -257,21 +257,21 @@ func (s *MembershipService) TransferOwnership(
if user.Role != users_enums.UserRoleAdmin &&
(currentRole == nil || *currentRole != users_enums.WorkspaceRoleOwner) {
- return errors.New("only workspace owner or admin can transfer ownership")
+ return workspaces_errors.ErrOnlyOwnerOrAdminCanTransferOwnership
}
newOwner, err := s.userService.GetUserByEmail(request.NewOwnerEmail)
if err != nil {
- return errors.New("new owner not found")
+ return workspaces_errors.ErrNewOwnerNotFound
}
if newOwner == nil {
- return errors.New("new owner not found")
+ return workspaces_errors.ErrNewOwnerNotFound
}
_, err = s.membershipRepository.GetMembershipByUserAndWorkspace(newOwner.ID, workspaceID)
if err != nil {
- return errors.New("new owner must be a workspace member")
+ return workspaces_errors.ErrNewOwnerMustBeMember
}
currentOwner, err := s.membershipRepository.GetWorkspaceOwner(workspaceID)
@@ -280,7 +280,7 @@ func (s *MembershipService) TransferOwnership(
}
if currentOwner == nil {
- return errors.New("no current workspace owner found")
+ return workspaces_errors.ErrNoCurrentWorkspaceOwner
}
if err := s.membershipRepository.UpdateMemberRole(newOwner.ID, workspaceID, users_enums.WorkspaceRoleOwner); err != nil {
@@ -311,7 +311,7 @@ func (s *MembershipService) validateCanManageMembership(
return err
}
if !canManageAdmins {
- return errors.New("only workspace owner can add/manage admins")
+ return workspaces_errors.ErrOnlyOwnerCanAddManageAdmins
}
return nil
}
@@ -322,7 +322,7 @@ func (s *MembershipService) validateCanManageMembership(
}
if !canManageMembership {
- return errors.New("insufficient permissions to manage members")
+ return workspaces_errors.ErrInsufficientPermissionsToManageMembers
}
return nil
diff --git a/backend/internal/features/workspaces/services/workspace_service.go b/backend/internal/features/workspaces/services/workspace_service.go
index b5b61c91..36205dce 100644
--- a/backend/internal/features/workspaces/services/workspace_service.go
+++ b/backend/internal/features/workspaces/services/workspace_service.go
@@ -1,7 +1,6 @@
package workspaces_services
import (
- "errors"
"fmt"
"time"
@@ -10,6 +9,7 @@ import (
users_models "databasus-backend/internal/features/users/models"
users_services "databasus-backend/internal/features/users/services"
workspaces_dto "databasus-backend/internal/features/workspaces/dto"
+ workspaces_errors "databasus-backend/internal/features/workspaces/errors"
workspaces_interfaces "databasus-backend/internal/features/workspaces/interfaces"
workspaces_models "databasus-backend/internal/features/workspaces/models"
workspaces_repositories "databasus-backend/internal/features/workspaces/repositories"
@@ -43,7 +43,7 @@ func (s *WorkspaceService) CreateWorkspace(
}
if !creator.CanCreateWorkspaces(settings) {
- return nil, errors.New("insufficient permissions to create workspaces")
+ return nil, workspaces_errors.ErrInsufficientPermissionsToCreateWorkspaces
}
workspace := &workspaces_models.Workspace{
@@ -91,7 +91,7 @@ func (s *WorkspaceService) GetWorkspace(
return nil, err
}
if !canView {
- return nil, errors.New("insufficient permissions to view workspace")
+ return nil, workspaces_errors.ErrInsufficientPermissionsToViewWorkspace
}
return s.workspaceRepository.GetWorkspaceByID(workspaceID)
@@ -121,7 +121,7 @@ func (s *WorkspaceService) UpdateWorkspace(
return nil, err
}
if !canManage {
- return nil, errors.New("insufficient permissions to update workspace")
+ return nil, workspaces_errors.ErrInsufficientPermissionsToUpdateWorkspace
}
existingWorkspace, err := s.workspaceRepository.GetWorkspaceByID(workspaceID)
@@ -155,7 +155,7 @@ func (s *WorkspaceService) DeleteWorkspace(workspaceID uuid.UUID, user *users_mo
}
if userWorkspaceRole == nil || *userWorkspaceRole != users_enums.WorkspaceRoleOwner {
- return errors.New("only workspace owner or admin can delete workspace")
+ return workspaces_errors.ErrOnlyOwnerOrAdminCanDeleteWorkspace
}
}
@@ -299,7 +299,7 @@ func (s *WorkspaceService) GetWorkspaceAuditLogs(
return nil, err
}
if !canView {
- return nil, errors.New("insufficient permissions to view workspace audit logs")
+ return nil, workspaces_errors.ErrInsufficientPermissionsToViewWorkspaceAuditLogs
}
return s.auditLogService.GetWorkspaceAuditLogs(workspaceID, request)
diff --git a/frontend/src/entity/backups/api/backupConfigApi.ts b/frontend/src/entity/backups/api/backupConfigApi.ts
index 342e156e..26b024c4 100644
--- a/frontend/src/entity/backups/api/backupConfigApi.ts
+++ b/frontend/src/entity/backups/api/backupConfigApi.ts
@@ -2,6 +2,7 @@ import { getApplicationServer } from '../../../constants';
import RequestOptions from '../../../shared/api/RequestOptions';
import { apiHelper } from '../../../shared/api/apiHelper';
import type { BackupConfig } from '../model/BackupConfig';
+import type { TransferDatabaseRequest } from '../model/TransferDatabaseRequest';
export const backupConfigApi = {
async saveBackupConfig(config: BackupConfig) {
@@ -32,4 +33,25 @@ export const backupConfigApi = {
)
.then((res) => res.isUsing);
},
+
+ async getDatabasesCountForStorage(storageId: string): Promise<number> {
+ return await apiHelper
+ .fetchGetJson<{
+ count: number;
+ }>(
+ `${getApplicationServer()}/api/v1/backup-configs/storage/${storageId}/databases-count`,
+ undefined,
+ true,
+ )
+ .then((res) => res.count);
+ },
+
+ async transferDatabase(databaseId: string, request: TransferDatabaseRequest): Promise<void> {
+ const requestOptions: RequestOptions = new RequestOptions();
+ requestOptions.setBody(JSON.stringify(request));
+ await apiHelper.fetchPostJson(
+ `${getApplicationServer()}/api/v1/backup-configs/database/${databaseId}/transfer`,
+ requestOptions,
+ );
+ },
};
diff --git a/frontend/src/entity/backups/index.ts b/frontend/src/entity/backups/index.ts
index 732c3193..59e17b2e 100644
--- a/frontend/src/entity/backups/index.ts
+++ b/frontend/src/entity/backups/index.ts
@@ -5,3 +5,4 @@ export type { Backup } from './model/Backup';
export type { BackupConfig } from './model/BackupConfig';
export { BackupNotificationType } from './model/BackupNotificationType';
export { BackupEncryption } from './model/BackupEncryption';
+export type { TransferDatabaseRequest } from './model/TransferDatabaseRequest';
diff --git a/frontend/src/entity/backups/model/TransferDatabaseRequest.ts b/frontend/src/entity/backups/model/TransferDatabaseRequest.ts
new file mode 100644
index 00000000..99fa2537
--- /dev/null
+++ b/frontend/src/entity/backups/model/TransferDatabaseRequest.ts
@@ -0,0 +1,7 @@
+export interface TransferDatabaseRequest {
+ targetWorkspaceId: string;
+ targetStorageId?: string;
+ isTransferWithStorage: boolean;
+ isTransferWithNotifiers: boolean;
+ targetNotifierIds: string[];
+}
diff --git a/frontend/src/entity/databases/api/databaseApi.ts b/frontend/src/entity/databases/api/databaseApi.ts
index 30bc7d83..f574208e 100644
--- a/frontend/src/entity/databases/api/databaseApi.ts
+++ b/frontend/src/entity/databases/api/databaseApi.ts
@@ -88,6 +88,19 @@ export const databaseApi = {
.then((res) => res.isUsing);
},
+ async getDatabasesCountForNotifier(notifierId: string): Promise<number> {
+ const requestOptions: RequestOptions = new RequestOptions();
+ return apiHelper
+ .fetchGetJson<{
+ count: number;
+ }>(
+ `${getApplicationServer()}/api/v1/databases/notifier/${notifierId}/databases-count`,
+ requestOptions,
+ true,
+ )
+ .then((res) => res.count);
+ },
+
async isUserReadOnly(database: Database) {
const requestOptions: RequestOptions = new RequestOptions();
requestOptions.setBody(JSON.stringify(database));
diff --git a/frontend/src/entity/notifiers/api/notifierApi.ts b/frontend/src/entity/notifiers/api/notifierApi.ts
index 8f2ee7b3..fc8988a1 100644
--- a/frontend/src/entity/notifiers/api/notifierApi.ts
+++ b/frontend/src/entity/notifiers/api/notifierApi.ts
@@ -55,4 +55,13 @@ export const notifierApi = {
requestOptions,
);
},
+
+ async transferNotifier(notifierId: string, targetWorkspaceId: string) {
+ const requestOptions: RequestOptions = new RequestOptions();
+ requestOptions.setBody(JSON.stringify({ targetWorkspaceId }));
+ return apiHelper.fetchPostJson(
+ `${getApplicationServer()}/api/v1/notifiers/${notifierId}/transfer`,
+ requestOptions,
+ );
+ },
};
diff --git a/frontend/src/entity/storages/api/storageApi.ts b/frontend/src/entity/storages/api/storageApi.ts
index 99abf798..5503f303 100644
--- a/frontend/src/entity/storages/api/storageApi.ts
+++ b/frontend/src/entity/storages/api/storageApi.ts
@@ -55,4 +55,13 @@ export const storageApi = {
requestOptions,
);
},
+
+ async transferStorage(storageId: string, targetWorkspaceId: string) {
+ const requestOptions: RequestOptions = new RequestOptions();
+ requestOptions.setBody(JSON.stringify({ targetWorkspaceId }));
+ return apiHelper.fetchPostJson(
+ `${getApplicationServer()}/api/v1/storages/${storageId}/transfer`,
+ requestOptions,
+ );
+ },
};
diff --git a/frontend/src/features/databases/ui/DatabaseComponent.tsx b/frontend/src/features/databases/ui/DatabaseComponent.tsx
index 069e3312..2d54d2e4 100644
--- a/frontend/src/features/databases/ui/DatabaseComponent.tsx
+++ b/frontend/src/features/databases/ui/DatabaseComponent.tsx
@@ -76,6 +76,7 @@ export const DatabaseComponent = ({
isCanManageDBs={isCanManageDBs}
/>
)}
+
{currentTab === 'backups' && (
<>
<HealthckeckAttemptsComponent database={database} />
diff --git a/frontend/src/features/databases/ui/DatabaseConfigComponent.tsx b/frontend/src/features/databases/ui/DatabaseConfigComponent.tsx
index a6d5064a..8db48681 100644
--- a/frontend/src/features/databases/ui/DatabaseConfigComponent.tsx
+++ b/frontend/src/features/databases/ui/DatabaseConfigComponent.tsx
@@ -1,12 +1,20 @@
-import { CloseOutlined, InfoCircleOutlined } from '@ant-design/icons';
+import {
+ ArrowRightOutlined,
+ CloseOutlined,
+ CopyOutlined,
+ DeleteOutlined,
+ InfoCircleOutlined,
+} from '@ant-design/icons';
import { Button, Input } from 'antd';
-import { useState } from 'react';
+import { useEffect, useState } from 'react';
+import { backupConfigApi } from '../../../entity/backups';
import { type Database, databaseApi } from '../../../entity/databases';
import { ToastHelper } from '../../../shared/toast';
import { ConfirmationComponent } from '../../../shared/ui';
import { EditBackupConfigComponent, ShowBackupConfigComponent } from '../../backups';
import { EditHealthcheckConfigComponent, ShowHealthcheckConfigComponent } from '../../healthcheck';
+import { DatabaseTransferDialogComponent } from './DatabaseTransferDialogComponent';
import { EditDatabaseNotifiersComponent } from './edit/EditDatabaseNotifiersComponent';
import { EditDatabaseSpecificDataComponent } from './edit/EditDatabaseSpecificDataComponent';
import { ShowDatabaseNotifiersComponent } from './show/ShowDatabaseNotifiersComponent';
@@ -46,6 +54,15 @@ export const DatabaseConfigComponent = ({
const [isCopying, setIsCopying] = useState(false);
const [isShowRemoveConfirm, setIsShowRemoveConfirm] = useState(false);
const [isRemoving, setIsRemoving] = useState(false);
+ const [isShowCopyConfirm, setIsShowCopyConfirm] = useState(false);
+ const [isShowTransferDialog, setIsShowTransferDialog] = useState(false);
+ const [currentStorageId, setCurrentStorageId] = useState<string | undefined>();
+
+ useEffect(() => {
+ backupConfigApi.getBackupConfigByDbID(database.id).then((config) => {
+ setCurrentStorageId(config.storage?.id);
+ });
+ }, [database.id]);
const loadSettings = () => {
setDatabase(undefined);
@@ -57,6 +74,7 @@ export const DatabaseConfigComponent = ({
if (!database) return;
setIsCopying(true);
+ setIsShowCopyConfirm(false);
databaseApi
.copyDatabase(database.id)
@@ -377,30 +395,50 @@ export const DatabaseConfigComponent = ({
Test connection
</Button>
- <Button
- type="primary"
- className="w-full sm:mr-1 sm:w-auto"
- onClick={copyDatabase}
- loading={isCopying}
- disabled={isCopying}
- >
- Copy
- </Button>
+ {isCanManageDBs && (
+ <>
+ <Button
+ type="primary"
+ ghost
+ icon={<ArrowRightOutlined />}
+ onClick={() => setIsShowTransferDialog(true)}
+ className="sm:mr-1"
+ />
- <Button
- type="primary"
- className="w-full sm:w-auto"
- danger
- onClick={() => setIsShowRemoveConfirm(true)}
- ghost
- loading={isRemoving}
- disabled={isRemoving}
- >
- Remove
- </Button>
+ <Button
+ type="primary"
+ ghost
+ icon={<CopyOutlined />}
+ onClick={() => setIsShowCopyConfirm(true)}
+ loading={isCopying}
+ disabled={isCopying}
+ className="sm:mr-1"
+ />
+
+ <Button
+ type="primary"
+ ghost
+ danger
+ icon={<DeleteOutlined />}
+ onClick={() => setIsShowRemoveConfirm(true)}
+ loading={isRemoving}
+ disabled={isRemoving}
+ />
+ </>
+ )}
</div>
)}
+ {isShowCopyConfirm && (
+ <ConfirmationComponent
+ onConfirm={copyDatabase}
+ onDecline={() => setIsShowCopyConfirm(false)}
+ description="Are you sure you want to copy this database? A new database with the same settings will be created."
+ actionText="Copy"
+ actionButtonColor="blue"
+ />
+ )}
+
{isShowRemoveConfirm && (
<ConfirmationComponent
onConfirm={remove}
@@ -410,6 +448,18 @@ export const DatabaseConfigComponent = ({
actionButtonColor="red"
/>
)}
+
+ {isShowTransferDialog && (
+ <DatabaseTransferDialogComponent
+ database={database}
+ currentStorageId={currentStorageId}
+ onClose={() => setIsShowTransferDialog(false)}
+ onTransferred={() => {
+ setIsShowTransferDialog(false);
+ window.location.reload();
+ }}
+ />
+ )}
</div>
);
};
diff --git a/frontend/src/features/databases/ui/DatabaseTransferDialogComponent.tsx b/frontend/src/features/databases/ui/DatabaseTransferDialogComponent.tsx
new file mode 100644
index 00000000..521d967a
--- /dev/null
+++ b/frontend/src/features/databases/ui/DatabaseTransferDialogComponent.tsx
@@ -0,0 +1,465 @@
+import { CheckCircleOutlined, ExclamationCircleOutlined, SwapOutlined } from '@ant-design/icons';
+import { Button, Modal, Radio, Select, Spin } from 'antd';
+import { useEffect, useState } from 'react';
+
+import { backupConfigApi } from '../../../entity/backups';
+import type { TransferDatabaseRequest } from '../../../entity/backups';
+import { type Database, databaseApi } from '../../../entity/databases';
+import type { Notifier } from '../../../entity/notifiers';
+import { notifierApi } from '../../../entity/notifiers';
+import { type Storage, getStorageLogoFromType, storageApi } from '../../../entity/storages';
+import { type WorkspaceResponse, workspaceApi } from '../../../entity/workspaces';
+import { ToastHelper } from '../../../shared/toast';
+import { EditNotifierComponent } from '../../notifiers/ui/edit/EditNotifierComponent';
+import { EditStorageComponent } from '../../storages/ui/edit/EditStorageComponent';
+
+interface Props {
+ database: Database;
+ currentStorageId?: string;
+ onClose: () => void;
+ onTransferred: () => void;
+}
+
+interface NotifierUsageInfo {
+ notifier: Notifier;
+ databaseCount: number;
+ canTransfer: boolean;
+}
+
+export const DatabaseTransferDialogComponent = ({
+ database,
+ currentStorageId,
+ onClose,
+ onTransferred,
+}: Props) => {
+ const [isLoading, setIsLoading] = useState(true);
+ const [workspaces, setWorkspaces] = useState<WorkspaceResponse[]>([]);
+ const [selectedWorkspaceId, setSelectedWorkspaceId] = useState<string | undefined>();
+
+ const [storageOption, setStorageOption] = useState<'transfer' | 'select'>('select');
+ const [storageUsageCount, setStorageUsageCount] = useState<number>(0);
+ const [isLoadingStorageCount, setIsLoadingStorageCount] = useState(false);
+ const [targetStorages, setTargetStorages] = useState<Storage[]>([]);
+ const [selectedStorageId, setSelectedStorageId] = useState<string | undefined>();
+ const [isShowCreateStorage, setIsShowCreateStorage] = useState(false);
+ const [storageSelectKey, setStorageSelectKey] = useState(0);
+
+ const [notifierOption, setNotifierOption] = useState<'transfer' | 'select'>('select');
+ const [notifierUsageInfo, setNotifierUsageInfo] = useState<NotifierUsageInfo[]>([]);
+ const [isLoadingNotifierCounts, setIsLoadingNotifierCounts] = useState(false);
+ const [targetNotifiers, setTargetNotifiers] = useState<Notifier[]>([]);
+ const [selectedNotifierIds, setSelectedNotifierIds] = useState<string[]>([]);
+ const [isShowCreateNotifier, setIsShowCreateNotifier] = useState(false);
+ const [notifierSelectKey, setNotifierSelectKey] = useState(0);
+
+ const [isTransferring, setIsTransferring] = useState(false);
+
+ const hasCurrentStorage = !!currentStorageId;
+ const hasCurrentNotifiers = database.notifiers && database.notifiers.length > 0;
+
+ const loadWorkspaces = async () => {
+ setIsLoading(true);
+
+ try {
+ const response = await workspaceApi.getWorkspaces();
+ const filteredWorkspaces = response.workspaces.filter((w) => w.id !== database.workspaceId);
+ setWorkspaces(filteredWorkspaces);
+ } catch (e) {
+ alert((e as Error).message);
+ }
+
+ setIsLoading(false);
+ };
+
+ const loadStorageUsageCount = async () => {
+ if (!currentStorageId) return;
+
+ setIsLoadingStorageCount(true);
+
+ try {
+ const count = await backupConfigApi.getDatabasesCountForStorage(currentStorageId);
+ setStorageUsageCount(count);
+ } catch (e) {
+ alert((e as Error).message);
+ }
+
+ setIsLoadingStorageCount(false);
+ };
+
+ const loadNotifierUsageCounts = async () => {
+ if (!database.notifiers || database.notifiers.length === 0) return;
+
+ setIsLoadingNotifierCounts(true);
+
+ try {
+ const usageInfo: NotifierUsageInfo[] = await Promise.all(
+ database.notifiers.map(async (notifier) => {
+ const count = await databaseApi.getDatabasesCountForNotifier(notifier.id);
+ return {
+ notifier,
+ databaseCount: count,
+ canTransfer: count === 1,
+ };
+ }),
+ );
+
+ setNotifierUsageInfo(usageInfo);
+ } catch (e) {
+ alert((e as Error).message);
+ }
+
+ setIsLoadingNotifierCounts(false);
+ };
+
+ const loadTargetWorkspaceData = async (workspaceId: string) => {
+ try {
+ const [storages, notifiers] = await Promise.all([
+ storageApi.getStorages(workspaceId),
+ notifierApi.getNotifiers(workspaceId),
+ ]);
+ setTargetStorages(storages);
+ setTargetNotifiers(notifiers);
+ } catch (e) {
+ alert((e as Error).message);
+ }
+ };
+
+ const handleTransfer = async () => {
+ if (!selectedWorkspaceId) return;
+
+ const request: TransferDatabaseRequest = {
+ targetWorkspaceId: selectedWorkspaceId,
+ isTransferWithStorage: storageOption === 'transfer',
+ isTransferWithNotifiers: notifierOption === 'transfer',
+ targetStorageId: storageOption === 'select' ? selectedStorageId : undefined,
+ targetNotifierIds: notifierOption === 'select' ? selectedNotifierIds : [],
+ };
+
+ setIsTransferring(true);
+
+ try {
+ await backupConfigApi.transferDatabase(database.id, request);
+ ToastHelper.showToast({
+ title: 'Database transferred successfully!',
+ description: `"${database.name}" has been transferred to the new workspace`,
+ });
+ onTransferred();
+ } catch (e) {
+ alert((e as Error).message);
+ }
+
+ setIsTransferring(false);
+ };
+
+ useEffect(() => {
+ loadWorkspaces();
+ loadStorageUsageCount();
+ loadNotifierUsageCounts();
+ }, [database.id]);
+
+ useEffect(() => {
+ if (selectedWorkspaceId) {
+ loadTargetWorkspaceData(selectedWorkspaceId);
+ setSelectedStorageId(undefined);
+ setSelectedNotifierIds([]);
+ }
+ }, [selectedWorkspaceId]);
+
+ const canTransferWithStorage = storageUsageCount <= 1;
+ const notifiersBlockingTransfer = notifierUsageInfo.filter((info) => !info.canTransfer);
+ const notifiersCanTransfer = notifierUsageInfo.filter((info) => info.canTransfer);
+
+ const isStorageValid =
+ storageOption === 'transfer'
+ ? canTransferWithStorage && hasCurrentStorage
+ : !!selectedStorageId;
+
+ const isFormValid = !!selectedWorkspaceId && isStorageValid;
+
+ return (
+ <Modal
+ title={
+ <div className="flex items-center gap-2">
+ <SwapOutlined />
+ Transfer database to another workspace
+ </div>
+ }
+ footer={null}
+ open={true}
+ onCancel={onClose}
+ maskClosable={false}
+ width={550}
+ >
+ {isLoading ? (
+ <div className="flex justify-center py-5">
+ <Spin />
+ </div>
+ ) : (
+ <div className="py-3">
+ {/* Workspace Selection */}
+ <div className="mb-5">
+ <div className="mb-2 font-medium">Target workspace</div>
+ <Select
+ value={selectedWorkspaceId}
+ onChange={setSelectedWorkspaceId}
+ className="w-full"
+ placeholder="Select workspace"
+ options={workspaces.map((w) => ({ label: w.name, value: w.id }))}
+ />
+ </div>
+
+ {selectedWorkspaceId && (
+ <>
+ {/* Storage Transfer Options */}
+ <div className="mb-5">
+ <div className="mb-2 font-medium">Storage</div>
+ <Radio.Group
+ value={storageOption}
+ onChange={(e) => setStorageOption(e.target.value)}
+ className="flex flex-col gap-3"
+ >
+ {hasCurrentStorage && (
+ <div>
+ <Radio value="transfer">
+ <span className="flex items-center gap-2">
+ Transfer with existing storage
+ {isLoadingStorageCount && <Spin size="small" />}
+ </span>
+ </Radio>
+ </div>
+ )}
+ <div>
+ <Radio value="select">Select storage from target workspace</Radio>
+ </div>
+ </Radio.Group>
+
+ {storageOption === 'transfer' && hasCurrentStorage && (
+ <div className="mt-2 ml-6">
+ {isLoadingStorageCount ? (
+ <Spin size="small" />
+ ) : !canTransferWithStorage ? (
+ <div className="flex items-center gap-2 rounded border border-red-300 bg-red-50 p-2 text-sm text-red-600 dark:border-red-600 dark:bg-red-900/20">
+ <ExclamationCircleOutlined />
+ <span>
+ This storage is used by {storageUsageCount} databases. Transfer is blocked
+ because other databases depend on it.
+ </span>
+ </div>
+ ) : (
+ <div className="flex items-center gap-2 text-sm text-green-600 dark:text-green-400">
+ <CheckCircleOutlined />
+ Storage can be transferred
+ </div>
+ )}
+ </div>
+ )}
+
+ {storageOption === 'select' && (
+ <div className="mt-2 ml-6">
+ <div className="flex items-center gap-2">
+ <Select
+ key={storageSelectKey}
+ value={selectedStorageId}
+ onChange={(storageId) => {
+ if (storageId === 'create-new-storage') {
+ setIsShowCreateStorage(true);
+ return;
+ }
+ setSelectedStorageId(storageId);
+ }}
+ className="w-full max-w-[300px]"
+ placeholder="Select storage"
+ options={[
+ ...targetStorages.map((s) => ({ label: s.name, value: s.id })),
+ { label: 'Create new storage', value: 'create-new-storage' },
+ ]}
+ />
+
+ {selectedStorageId &&
+ targetStorages.find((s) => s.id === selectedStorageId)?.type && (
+ <img
+ src={getStorageLogoFromType(
+ targetStorages.find((s) => s.id === selectedStorageId)!.type,
+ )}
+ alt="storageIcon"
+ className="h-4 w-4"
+ />
+ )}
+ </div>
+ </div>
+ )}
+ </div>
+
+ {/* Notifier transfer options */}
+ {hasCurrentNotifiers && (
+ <div className="mb-5">
+ <div className="mb-2 font-medium">Notifiers (optional)</div>
+
+ <Radio.Group
+ value={notifierOption}
+ onChange={(e) => setNotifierOption(e.target.value)}
+ className="flex flex-col gap-3"
+ >
+ <div>
+ <Radio value="transfer">Transfer notifiers with database</Radio>
+ </div>
+ <div>
+ <Radio value="select">Select notifiers from target workspace</Radio>
+ </div>
+ </Radio.Group>
+
+ {notifierOption === 'transfer' && (
+ <div className="mt-2 ml-6">
+ {isLoadingNotifierCounts ? (
+ <Spin size="small" />
+ ) : (
+ <div className="space-y-1">
+ {notifiersCanTransfer.length > 0 && (
+ <div className="text-sm text-green-600 dark:text-green-400">
+ <div className="mb-1 flex items-center gap-1">
+ <CheckCircleOutlined />
+ <span>Will be transferred:</span>
+ </div>
+ <ul className="ml-5 list-disc">
+ {notifiersCanTransfer.map((info) => (
+ <li key={info.notifier.id}>{info.notifier.name}</li>
+ ))}
+ </ul>
+ </div>
+ )}
+
+ {notifiersBlockingTransfer.length > 0 && (
+ <div className="mt-2 rounded border border-red-300 bg-red-50 p-2 text-sm text-red-600 dark:border-red-600 dark:bg-red-900/20 dark:text-red-600">
+ <div className="mb-1 flex items-center gap-1">
+ <ExclamationCircleOutlined />
+ <span>Will NOT be transferred (used by other databases):</span>
+ </div>
+ <ul className="ml-5 list-disc">
+ {notifiersBlockingTransfer.map((info) => (
+ <li key={info.notifier.id}>
+ {info.notifier.name} (used by {info.databaseCount} databases)
+ </li>
+ ))}
+ </ul>
+ </div>
+ )}
+
+ {notifiersCanTransfer.length === 0 &&
+ notifiersBlockingTransfer.length > 0 && (
+ <div className="mt-1 text-sm text-gray-500 dark:text-gray-400">
+ No notifiers will be transferred. You can select notifiers from the
+ target workspace after transfer.
+ </div>
+ )}
+ </div>
+ )}
+ </div>
+ )}
+
+ {notifierOption === 'select' && (
+ <div className="mt-2 ml-6">
+ <Select
+ key={notifierSelectKey}
+ mode="multiple"
+ value={selectedNotifierIds}
+ onChange={(notifierIds) => {
+ if (notifierIds.includes('create-new-notifier')) {
+ setIsShowCreateNotifier(true);
+ return;
+ }
+ setSelectedNotifierIds(notifierIds);
+ }}
+ className="w-full max-w-[300px]"
+ placeholder="Select notifiers (optional)"
+ options={[
+ ...targetNotifiers.map((n) => ({ label: n.name, value: n.id })),
+ { label: 'Create new notifier', value: 'create-new-notifier' },
+ ]}
+ />
+ </div>
+ )}
+ </div>
+ )}
+ </>
+ )}
+
+ {/* Action Buttons */}
+ <div className="mt-5 flex gap-2">
+ <Button type="default" onClick={onClose}>
+ Cancel
+ </Button>
+
+ <Button
+ type="primary"
+ onClick={handleTransfer}
+ loading={isTransferring}
+ disabled={!isFormValid || isTransferring}
+ >
+ Transfer
+ </Button>
+ </div>
+ </div>
+ )}
+
+ {/* Create Storage Modal */}
+ {isShowCreateStorage && selectedWorkspaceId && (
+ <Modal
+ title="Add storage"
+ footer={null}
+ open={isShowCreateStorage}
+ onCancel={() => {
+ setIsShowCreateStorage(false);
+ setStorageSelectKey((prev) => prev + 1);
+ }}
+ maskClosable={false}
+ >
+ <div className="my-3 max-w-[275px] text-gray-500 dark:text-gray-400">
+ Storage - is a place where backups will be stored (local disk, S3, Google Drive, etc.)
+ </div>
+
+ <EditStorageComponent
+ workspaceId={selectedWorkspaceId}
+ isShowName
+ isShowClose={false}
+ onClose={() => setIsShowCreateStorage(false)}
+ onChanged={(storage) => {
+ loadTargetWorkspaceData(selectedWorkspaceId);
+ setSelectedStorageId(storage.id);
+ setIsShowCreateStorage(false);
+ }}
+ />
+ </Modal>
+ )}
+
+ {/* Create Notifier Modal */}
+ {isShowCreateNotifier && selectedWorkspaceId && (
+ <Modal
+ title="Add notifier"
+ footer={null}
+ open={isShowCreateNotifier}
+ onCancel={() => {
+ setIsShowCreateNotifier(false);
+ setNotifierSelectKey((prev) => prev + 1);
+ }}
+ maskClosable={false}
+ >
+ <div className="my-3 max-w-[275px] text-gray-500 dark:text-gray-400">
+ Notifier - is a place where notifications will be sent (email, Slack, Telegram, etc.)
+ </div>
+
+ <EditNotifierComponent
+ workspaceId={selectedWorkspaceId}
+ isShowName
+ isShowClose={false}
+ onClose={() => setIsShowCreateNotifier(false)}
+ onChanged={(notifier) => {
+ loadTargetWorkspaceData(selectedWorkspaceId);
+ setSelectedNotifierIds([...selectedNotifierIds, notifier.id]);
+ setIsShowCreateNotifier(false);
+ }}
+ />
+ </Modal>
+ )}
+ </Modal>
+ );
+};
diff --git a/frontend/src/features/notifiers/ui/NotifierComponent.tsx b/frontend/src/features/notifiers/ui/NotifierComponent.tsx
index dc965f18..1298b663 100644
--- a/frontend/src/features/notifiers/ui/NotifierComponent.tsx
+++ b/frontend/src/features/notifiers/ui/NotifierComponent.tsx
@@ -1,4 +1,9 @@
-import { CloseOutlined, InfoCircleOutlined } from '@ant-design/icons';
+import {
+ ArrowRightOutlined,
+ CloseOutlined,
+ DeleteOutlined,
+ InfoCircleOutlined,
+} from '@ant-design/icons';
import { Button, Input, Spin } from 'antd';
import { useState } from 'react';
import { useEffect } from 'react';
@@ -8,6 +13,7 @@ import { notifierApi } from '../../../entity/notifiers';
import type { Notifier } from '../../../entity/notifiers';
import { ToastHelper } from '../../../shared/toast';
import { ConfirmationComponent } from '../../../shared/ui';
+import { NotifierTransferDialogComponent } from './NotifierTransferDialogComponent';
import { EditNotifierComponent } from './edit/EditNotifierComponent';
import { ShowNotifierComponent } from './show/ShowNotifierComponent';
@@ -15,6 +21,7 @@ interface Props {
notifierId: string;
onNotifierChanged: (notifier: Notifier) => void;
onNotifierDeleted: () => void;
+ onNotifierTransferred: () => void;
isCanManageNotifiers: boolean;
}
@@ -22,6 +29,7 @@ export const NotifierComponent = ({
notifierId,
onNotifierChanged,
onNotifierDeleted,
+ onNotifierTransferred,
isCanManageNotifiers,
}: Props) => {
const [notifier, setNotifier] = useState<Notifier | undefined>();
@@ -38,6 +46,8 @@ export const NotifierComponent = ({
const [isShowRemoveConfirm, setIsShowRemoveConfirm] = useState(false);
const [isRemoving, setIsRemoving] = useState(false);
+ const [isShowTransferDialog, setIsShowTransferDialog] = useState(false);
+
const sendTestNotification = () => {
if (!notifier) return;
@@ -254,16 +264,25 @@ export const NotifierComponent = ({
</Button>
{isCanManageNotifiers && (
- <Button
- type="primary"
- danger
- onClick={() => setIsShowRemoveConfirm(true)}
- ghost
- loading={isRemoving}
- disabled={isRemoving}
- >
- Remove
- </Button>
+ <>
+ <Button
+ type="primary"
+ ghost
+ icon={<ArrowRightOutlined />}
+ onClick={() => setIsShowTransferDialog(true)}
+ className="mr-1"
+ />
+
+ <Button
+ type="primary"
+ ghost
+ danger
+ icon={<DeleteOutlined />}
+ onClick={() => setIsShowRemoveConfirm(true)}
+ loading={isRemoving}
+ disabled={isRemoving}
+ />
+ </>
)}
</div>
)}
@@ -280,6 +299,17 @@ export const NotifierComponent = ({
/>
)}
</div>
+
+ {isShowTransferDialog && notifier && (
+ <NotifierTransferDialogComponent
+ notifier={notifier}
+ onClose={() => setIsShowTransferDialog(false)}
+ onTransferred={() => {
+ setIsShowTransferDialog(false);
+ onNotifierTransferred();
+ }}
+ />
+ )}
</div>
);
};
diff --git a/frontend/src/features/notifiers/ui/NotifierTransferDialogComponent.tsx b/frontend/src/features/notifiers/ui/NotifierTransferDialogComponent.tsx
new file mode 100644
index 00000000..03035d5f
--- /dev/null
+++ b/frontend/src/features/notifiers/ui/NotifierTransferDialogComponent.tsx
@@ -0,0 +1,120 @@
+import { Button, Modal, Select, Spin } from 'antd';
+import { useEffect, useState } from 'react';
+
+import { databaseApi } from '../../../entity/databases';
+import { type Notifier, notifierApi } from '../../../entity/notifiers';
+import { type WorkspaceResponse, workspaceApi } from '../../../entity/workspaces';
+
+interface Props {
+ notifier: Notifier;
+ onClose: () => void;
+ onTransferred: () => void;
+}
+
+export const NotifierTransferDialogComponent = ({ notifier, onClose, onTransferred }: Props) => {
+ const [isLoading, setIsLoading] = useState(true);
+ const [isNotifierInUse, setIsNotifierInUse] = useState(false);
+ const [workspaces, setWorkspaces] = useState<WorkspaceResponse[]>([]);
+ const [selectedWorkspaceId, setSelectedWorkspaceId] = useState<string | undefined>();
+ const [isTransferring, setIsTransferring] = useState(false);
+
+ const loadData = async () => {
+ setIsLoading(true);
+
+ try {
+ const isUsing = await databaseApi.isNotifierUsing(notifier.id);
+ setIsNotifierInUse(isUsing);
+
+ if (!isUsing) {
+ const response = await workspaceApi.getWorkspaces();
+ const filteredWorkspaces = response.workspaces.filter((w) => w.id !== notifier.workspaceId);
+ setWorkspaces(filteredWorkspaces);
+ }
+ } catch (e) {
+ alert((e as Error).message);
+ }
+
+ setIsLoading(false);
+ };
+
+ const transferNotifier = async () => {
+ if (!selectedWorkspaceId) return;
+
+ setIsTransferring(true);
+
+ try {
+ await notifierApi.transferNotifier(notifier.id, selectedWorkspaceId);
+ onTransferred();
+ } catch (e) {
+ alert((e as Error).message);
+ }
+
+ setIsTransferring(false);
+ };
+
+ useEffect(() => {
+ loadData();
+ }, [notifier.id]);
+
+ return (
+ <Modal
+ title="Transfer notifier to another workspace"
+ footer={null}
+ open={true}
+ onCancel={onClose}
+ maskClosable={false}
+ >
+ {isLoading ? (
+ <div className="flex justify-center py-5">
+ <Spin />
+ </div>
+ ) : isNotifierInUse ? (
+ <div className="py-3">
+ <div className="text-gray-700 dark:text-gray-300">
+ This notifier is used by some databases. Please transfer or remove related databases
+ first.
+ </div>
+
+ <div className="mt-5">
+ <Button type="primary" onClick={onClose}>
+ OK
+ </Button>
+ </div>
+ </div>
+ ) : (
+ <div className="py-3">
+ <div className="mb-3 text-gray-500 dark:text-gray-400">
+ Select a workspace to transfer this notifier to.
+ </div>
+
+ <div className="mb-5 flex items-center">
+ <div className="min-w-[120px]">Target workspace</div>
+
+ <Select
+ value={selectedWorkspaceId}
+ onChange={setSelectedWorkspaceId}
+ className="min-w-[200px] grow"
+ placeholder="Select workspace"
+ options={workspaces.map((w) => ({ label: w.name, value: w.id }))}
+ />
+ </div>
+
+ <div className="flex gap-2">
+ <Button type="default" onClick={onClose}>
+ Cancel
+ </Button>
+
+ <Button
+ type="primary"
+ onClick={transferNotifier}
+ loading={isTransferring}
+ disabled={!selectedWorkspaceId || isTransferring}
+ >
+ Transfer
+ </Button>
+ </div>
+ </div>
+ )}
+ </Modal>
+ );
+};
diff --git a/frontend/src/features/notifiers/ui/NotifiersComponent.tsx b/frontend/src/features/notifiers/ui/NotifiersComponent.tsx
index 496d1b05..7f38cce9 100644
--- a/frontend/src/features/notifiers/ui/NotifiersComponent.tsx
+++ b/frontend/src/features/notifiers/ui/NotifiersComponent.tsx
@@ -166,6 +166,13 @@ export const NotifiersComponent = ({ contentHeight, workspace, isCanManageNotifi
updateSelectedNotifierId(remainingNotifiers[0]?.id);
loadNotifiers();
}}
+ onNotifierTransferred={() => {
+ const remainingNotifiers = notifiers.filter(
+ (notifier) => notifier.id !== selectedNotifierId,
+ );
+ updateSelectedNotifierId(remainingNotifiers[0]?.id);
+ loadNotifiers();
+ }}
isCanManageNotifiers={isCanManageNotifiers}
/>
</div>
diff --git a/frontend/src/features/storages/ui/StorageComponent.tsx b/frontend/src/features/storages/ui/StorageComponent.tsx
index daaa8175..224d505c 100644
--- a/frontend/src/features/storages/ui/StorageComponent.tsx
+++ b/frontend/src/features/storages/ui/StorageComponent.tsx
@@ -1,4 +1,9 @@
-import { CloseOutlined, InfoCircleOutlined } from '@ant-design/icons';
+import {
+ ArrowRightOutlined,
+ CloseOutlined,
+ DeleteOutlined,
+ InfoCircleOutlined,
+} from '@ant-design/icons';
import { Button, Input, Spin } from 'antd';
import { useState } from 'react';
import { useEffect } from 'react';
@@ -8,6 +13,7 @@ import { storageApi } from '../../../entity/storages';
import type { Storage } from '../../../entity/storages';
import { ToastHelper } from '../../../shared/toast';
import { ConfirmationComponent } from '../../../shared/ui';
+import { StorageTransferDialogComponent } from './StorageTransferDialogComponent';
import { EditStorageComponent } from './edit/EditStorageComponent';
import { ShowStorageComponent } from './show/ShowStorageComponent';
@@ -15,6 +21,7 @@ interface Props {
storageId: string;
onStorageChanged: (storage: Storage) => void;
onStorageDeleted: () => void;
+ onStorageTransferred: () => void;
isCanManageStorages: boolean;
}
@@ -22,6 +29,7 @@ export const StorageComponent = ({
storageId,
onStorageChanged,
onStorageDeleted,
+ onStorageTransferred,
isCanManageStorages,
}: Props) => {
const [storage, setStorage] = useState<Storage | undefined>();
@@ -38,6 +46,8 @@ export const StorageComponent = ({
const [isShowRemoveConfirm, setIsShowRemoveConfirm] = useState(false);
const [isRemoving, setIsRemoving] = useState(false);
+ const [isShowTransferDialog, setIsShowTransferDialog] = useState(false);
+
const testConnection = () => {
if (!storage) return;
@@ -250,16 +260,25 @@ export const StorageComponent = ({
</Button>
{isCanManageStorages && (
- <Button
- type="primary"
- danger
- onClick={() => setIsShowRemoveConfirm(true)}
- ghost
- loading={isRemoving}
- disabled={isRemoving}
- >
- Remove
- </Button>
+ <>
+ <Button
+ type="primary"
+ ghost
+ icon={<ArrowRightOutlined />}
+ onClick={() => setIsShowTransferDialog(true)}
+ className="mr-1"
+ />
+
+ <Button
+ type="primary"
+ ghost
+ danger
+ icon={<DeleteOutlined />}
+ onClick={() => setIsShowRemoveConfirm(true)}
+ loading={isRemoving}
+ disabled={isRemoving}
+ />
+ </>
)}
</div>
)}
@@ -276,6 +295,17 @@ export const StorageComponent = ({
/>
)}
</div>
+
+ {isShowTransferDialog && storage && (
+ <StorageTransferDialogComponent
+ storage={storage}
+ onClose={() => setIsShowTransferDialog(false)}
+ onTransferred={() => {
+ setIsShowTransferDialog(false);
+ onStorageTransferred();
+ }}
+ />
+ )}
</div>
);
};
diff --git a/frontend/src/features/storages/ui/StorageMigrationDialogComponent.tsx b/frontend/src/features/storages/ui/StorageMigrationDialogComponent.tsx
new file mode 100644
index 00000000..e69de29b
diff --git a/frontend/src/features/storages/ui/StorageTransferDialogComponent.tsx b/frontend/src/features/storages/ui/StorageTransferDialogComponent.tsx
new file mode 100644
index 00000000..531e5efc
--- /dev/null
+++ b/frontend/src/features/storages/ui/StorageTransferDialogComponent.tsx
@@ -0,0 +1,120 @@
+import { Button, Modal, Select, Spin } from 'antd';
+import { useEffect, useState } from 'react';
+
+import { backupConfigApi } from '../../../entity/backups';
+import { type Storage, storageApi } from '../../../entity/storages';
+import { type WorkspaceResponse, workspaceApi } from '../../../entity/workspaces';
+
+interface Props {
+ storage: Storage;
+ onClose: () => void;
+ onTransferred: () => void;
+}
+
+export const StorageTransferDialogComponent = ({ storage, onClose, onTransferred }: Props) => {
+ const [isLoading, setIsLoading] = useState(true);
+ const [isStorageInUse, setIsStorageInUse] = useState(false);
+ const [workspaces, setWorkspaces] = useState<WorkspaceResponse[]>([]);
+ const [selectedWorkspaceId, setSelectedWorkspaceId] = useState<string | undefined>();
+ const [isTransferring, setIsTransferring] = useState(false);
+
+ const loadData = async () => {
+ setIsLoading(true);
+
+ try {
+ const isUsing = await backupConfigApi.isStorageUsing(storage.id);
+ setIsStorageInUse(isUsing);
+
+ if (!isUsing) {
+ const response = await workspaceApi.getWorkspaces();
+ const filteredWorkspaces = response.workspaces.filter((w) => w.id !== storage.workspaceId);
+ setWorkspaces(filteredWorkspaces);
+ }
+ } catch (e) {
+ alert((e as Error).message);
+ }
+
+ setIsLoading(false);
+ };
+
+ const transferStorage = async () => {
+ if (!selectedWorkspaceId) return;
+
+ setIsTransferring(true);
+
+ try {
+ await storageApi.transferStorage(storage.id, selectedWorkspaceId);
+ onTransferred();
+ } catch (e) {
+ alert((e as Error).message);
+ }
+
+ setIsTransferring(false);
+ };
+
+ useEffect(() => {
+ loadData();
+ }, [storage.id]);
+
+ return (
+ <Modal
+ title="Transfer storage to another workspace"
+ footer={null}
+ open={true}
+ onCancel={onClose}
+ maskClosable={false}
+ >
+ {isLoading ? (
+ <div className="flex justify-center py-5">
+ <Spin />
+ </div>
+ ) : isStorageInUse ? (
+ <div className="py-3">
+ <div className="text-gray-700 dark:text-gray-300">
+ This storage is used by some databases. Please transfer or remove related databases
+ first.
+ </div>
+
+ <div className="mt-5">
+ <Button type="primary" onClick={onClose}>
+ OK
+ </Button>
+ </div>
+ </div>
+ ) : (
+ <div className="py-3">
+ <div className="mb-3 text-gray-500 dark:text-gray-400">
+ Select a workspace to transfer this storage to.
+ </div>
+
+ <div className="mb-5 flex items-center">
+ <div className="min-w-[120px]">Target workspace</div>
+
+ <Select
+ value={selectedWorkspaceId}
+ onChange={setSelectedWorkspaceId}
+ className="min-w-[200px] grow"
+ placeholder="Select workspace"
+ options={workspaces.map((w) => ({ label: w.name, value: w.id }))}
+ />
+ </div>
+
+ <div className="flex gap-2">
+ <Button type="default" onClick={onClose}>
+ Cancel
+ </Button>
+
+ <Button
+ type="primary"
+ onClick={transferStorage}
+ loading={isTransferring}
+ disabled={!selectedWorkspaceId || isTransferring}
+ >
+ Transfer
+ </Button>
+ </div>
+ </div>
+ )}
+ </Modal>
+ );
+};
diff --git a/frontend/src/features/storages/ui/StoragesComponent.tsx b/frontend/src/features/storages/ui/StoragesComponent.tsx
index 633784e7..8a61535b 100644
--- a/frontend/src/features/storages/ui/StoragesComponent.tsx
+++ b/frontend/src/features/storages/ui/StoragesComponent.tsx
@@ -136,6 +136,13 @@ export const StoragesComponent = ({ contentHeight, workspace, isCanManageStorage
updateSelectedStorageId(remainingStorages[0]?.id);
loadStorages();
}}
+ onStorageTransferred={() => {
+ const remainingStorages = storages.filter(
+ (storage) => storage.id !== selectedStorageId,
+ );
+ updateSelectedStorageId(remainingStorages[0]?.id);
+ loadStorages();
+ }}
isCanManageStorages={isCanManageStorages}
/>
</div>