feat: add projects flow and consolidate default project handling
This commit is contained in:
Mikhail Chusavitin
+2
-1
@@ -74,7 +74,7 @@ func main() {
|
||||
localCount := local.CountConfigurations()
|
||||
log.Printf("Found %d configurations in local SQLite", localCount)
|
||||
|
||||
if *dryRun {
|
||||
if *dryRun {
|
||||
log.Println("\n[DRY RUN] Would migrate the following configurations:")
|
||||
for _, c := range configs {
|
||||
userName := c.OwnerUsername
|
||||
@@ -117,6 +117,7 @@ func main() {
|
||||
localConfig := &localdb.LocalConfiguration{
|
||||
UUID: c.UUID,
|
||||
ServerID: &c.ID,
|
||||
ProjectUUID: c.ProjectUUID,
|
||||
Name: c.Name,
|
||||
Items: localItems,
|
||||
TotalPrice: c.TotalPrice,
|
||||
|
||||
@@ -0,0 +1,283 @@
|
||||
package main
|
||||
|
||||
import (
|
||||
"bufio"
|
||||
"flag"
|
||||
"fmt"
|
||||
"log"
|
||||
"os"
|
||||
"regexp"
|
||||
"sort"
|
||||
"strings"
|
||||
|
||||
"git.mchus.pro/mchus/quoteforge/internal/config"
|
||||
"git.mchus.pro/mchus/quoteforge/internal/models"
|
||||
"github.com/google/uuid"
|
||||
"gorm.io/driver/mysql"
|
||||
"gorm.io/gorm"
|
||||
"gorm.io/gorm/logger"
|
||||
)
|
||||
|
||||
type configRow struct {
|
||||
ID uint
|
||||
UUID string
|
||||
OwnerUsername string
|
||||
Name string
|
||||
ProjectUUID *string
|
||||
}
|
||||
|
||||
type migrationAction struct {
|
||||
ConfigID uint
|
||||
ConfigUUID string
|
||||
ConfigName string
|
||||
OwnerUsername string
|
||||
TargetProjectName string
|
||||
CurrentProject string
|
||||
NeedCreateProject bool
|
||||
NeedReactivate bool
|
||||
}
|
||||
|
||||
func main() {
|
||||
configPath := flag.String("config", "config.yaml", "path to config file")
|
||||
apply := flag.Bool("apply", false, "apply migration (default is preview only)")
|
||||
yes := flag.Bool("yes", false, "skip interactive confirmation (works only with -apply)")
|
||||
flag.Parse()
|
||||
|
||||
cfg, err := config.Load(*configPath)
|
||||
if err != nil {
|
||||
log.Fatalf("failed to load config: %v", err)
|
||||
}
|
||||
|
||||
db, err := gorm.Open(mysql.Open(cfg.Database.DSN()), &gorm.Config{
|
||||
Logger: logger.Default.LogMode(logger.Silent),
|
||||
})
|
||||
if err != nil {
|
||||
log.Fatalf("failed to connect database: %v", err)
|
||||
}
|
||||
|
||||
if err := ensureProjectsTable(db); err != nil {
|
||||
log.Fatalf("precheck failed: %v", err)
|
||||
}
|
||||
|
||||
actions, existingProjects, err := buildPlan(db, cfg.Database.User)
|
||||
if err != nil {
|
||||
log.Fatalf("failed to build migration plan: %v", err)
|
||||
}
|
||||
|
||||
printPlan(actions)
|
||||
if len(actions) == 0 {
|
||||
fmt.Println("Nothing to migrate.")
|
||||
return
|
||||
}
|
||||
|
||||
if !*apply {
|
||||
fmt.Println("\nPreview complete. Re-run with -apply to execute.")
|
||||
return
|
||||
}
|
||||
|
||||
if !*yes {
|
||||
ok, confirmErr := askForConfirmation()
|
||||
if confirmErr != nil {
|
||||
log.Fatalf("confirmation failed: %v", confirmErr)
|
||||
}
|
||||
if !ok {
|
||||
fmt.Println("Aborted.")
|
||||
return
|
||||
}
|
||||
}
|
||||
|
||||
if err := executePlan(db, actions, existingProjects); err != nil {
|
||||
log.Fatalf("migration failed: %v", err)
|
||||
}
|
||||
|
||||
fmt.Println("Migration completed successfully.")
|
||||
}
|
||||
|
||||
func ensureProjectsTable(db *gorm.DB) error {
|
||||
var count int64
|
||||
if err := db.Raw("SELECT COUNT(*) FROM information_schema.tables WHERE table_schema = DATABASE() AND table_name = 'qt_projects'").Scan(&count).Error; err != nil {
|
||||
return fmt.Errorf("checking qt_projects table: %w", err)
|
||||
}
|
||||
if count == 0 {
|
||||
return fmt.Errorf("table qt_projects does not exist; run migration 009_add_projects.sql first")
|
||||
}
|
||||
return nil
|
||||
}
|
||||
|
||||
func buildPlan(db *gorm.DB, fallbackOwner string) ([]migrationAction, map[string]*models.Project, error) {
|
||||
var configs []configRow
|
||||
if err := db.Table("qt_configurations").
|
||||
Select("id, uuid, owner_username, name, project_uuid").
|
||||
Find(&configs).Error; err != nil {
|
||||
return nil, nil, fmt.Errorf("load configurations: %w", err)
|
||||
}
|
||||
|
||||
codeRegex := regexp.MustCompile(`^(OPS-[0-9]{4})`)
|
||||
owners := make(map[string]struct{})
|
||||
projectNames := make(map[string]struct{})
|
||||
type candidate struct {
|
||||
config configRow
|
||||
code string
|
||||
owner string
|
||||
}
|
||||
candidates := make([]candidate, 0)
|
||||
|
||||
for _, cfg := range configs {
|
||||
match := codeRegex.FindStringSubmatch(strings.TrimSpace(cfg.Name))
|
||||
if len(match) < 2 {
|
||||
continue
|
||||
}
|
||||
owner := strings.TrimSpace(cfg.OwnerUsername)
|
||||
if owner == "" {
|
||||
owner = strings.TrimSpace(fallbackOwner)
|
||||
}
|
||||
if owner == "" {
|
||||
continue
|
||||
}
|
||||
code := match[1]
|
||||
owners[owner] = struct{}{}
|
||||
projectNames[code] = struct{}{}
|
||||
candidates = append(candidates, candidate{config: cfg, code: code, owner: owner})
|
||||
}
|
||||
|
||||
ownerList := setKeys(owners)
|
||||
nameList := setKeys(projectNames)
|
||||
existingProjects := make(map[string]*models.Project)
|
||||
if len(ownerList) > 0 && len(nameList) > 0 {
|
||||
var projects []models.Project
|
||||
if err := db.Where("owner_username IN ? AND name IN ?", ownerList, nameList).Find(&projects).Error; err != nil {
|
||||
return nil, nil, fmt.Errorf("load existing projects: %w", err)
|
||||
}
|
||||
for i := range projects {
|
||||
p := projects[i]
|
||||
existingProjects[projectKey(p.OwnerUsername, p.Name)] = &p
|
||||
}
|
||||
}
|
||||
|
||||
actions := make([]migrationAction, 0)
|
||||
for _, c := range candidates {
|
||||
key := projectKey(c.owner, c.code)
|
||||
existing := existingProjects[key]
|
||||
|
||||
currentProject := ""
|
||||
if c.config.ProjectUUID != nil {
|
||||
currentProject = *c.config.ProjectUUID
|
||||
}
|
||||
|
||||
if existing != nil && currentProject == existing.UUID {
|
||||
continue
|
||||
}
|
||||
|
||||
action := migrationAction{
|
||||
ConfigID: c.config.ID,
|
||||
ConfigUUID: c.config.UUID,
|
||||
ConfigName: c.config.Name,
|
||||
OwnerUsername: c.owner,
|
||||
TargetProjectName: c.code,
|
||||
CurrentProject: currentProject,
|
||||
}
|
||||
if existing == nil {
|
||||
action.NeedCreateProject = true
|
||||
} else if !existing.IsActive {
|
||||
action.NeedReactivate = true
|
||||
}
|
||||
actions = append(actions, action)
|
||||
}
|
||||
|
||||
return actions, existingProjects, nil
|
||||
}
|
||||
|
||||
func printPlan(actions []migrationAction) {
|
||||
createCount := 0
|
||||
reactivateCount := 0
|
||||
for _, a := range actions {
|
||||
if a.NeedCreateProject {
|
||||
createCount++
|
||||
}
|
||||
if a.NeedReactivate {
|
||||
reactivateCount++
|
||||
}
|
||||
}
|
||||
|
||||
fmt.Printf("Planned actions: %d\n", len(actions))
|
||||
fmt.Printf("Projects to create: %d\n", createCount)
|
||||
fmt.Printf("Projects to reactivate: %d\n", reactivateCount)
|
||||
fmt.Println("\nDetails:")
|
||||
|
||||
for _, a := range actions {
|
||||
extra := ""
|
||||
if a.NeedCreateProject {
|
||||
extra = " [create project]"
|
||||
} else if a.NeedReactivate {
|
||||
extra = " [reactivate project]"
|
||||
}
|
||||
current := a.CurrentProject
|
||||
if current == "" {
|
||||
current = "NULL"
|
||||
}
|
||||
fmt.Printf("- %s | owner=%s | \"%s\" | project: %s -> %s%s\n",
|
||||
a.ConfigUUID, a.OwnerUsername, a.ConfigName, current, a.TargetProjectName, extra)
|
||||
}
|
||||
}
|
||||
|
||||
func askForConfirmation() (bool, error) {
|
||||
fmt.Print("\nApply these changes? type 'yes' to continue: ")
|
||||
reader := bufio.NewReader(os.Stdin)
|
||||
line, err := reader.ReadString('\n')
|
||||
if err != nil {
|
||||
return false, err
|
||||
}
|
||||
return strings.EqualFold(strings.TrimSpace(line), "yes"), nil
|
||||
}
|
||||
|
||||
func executePlan(db *gorm.DB, actions []migrationAction, existingProjects map[string]*models.Project) error {
|
||||
return db.Transaction(func(tx *gorm.DB) error {
|
||||
projectCache := make(map[string]*models.Project, len(existingProjects))
|
||||
for k, v := range existingProjects {
|
||||
cp := *v
|
||||
projectCache[k] = &cp
|
||||
}
|
||||
|
||||
for _, action := range actions {
|
||||
key := projectKey(action.OwnerUsername, action.TargetProjectName)
|
||||
project := projectCache[key]
|
||||
if project == nil {
|
||||
project = &models.Project{
|
||||
UUID: uuid.NewString(),
|
||||
OwnerUsername: action.OwnerUsername,
|
||||
Name: action.TargetProjectName,
|
||||
IsActive: true,
|
||||
IsSystem: false,
|
||||
}
|
||||
if err := tx.Create(project).Error; err != nil {
|
||||
return fmt.Errorf("create project %s for owner %s: %w", action.TargetProjectName, action.OwnerUsername, err)
|
||||
}
|
||||
projectCache[key] = project
|
||||
} else if !project.IsActive {
|
||||
if err := tx.Model(&models.Project{}).Where("uuid = ?", project.UUID).Update("is_active", true).Error; err != nil {
|
||||
return fmt.Errorf("reactivate project %s (%s): %w", project.Name, project.UUID, err)
|
||||
}
|
||||
project.IsActive = true
|
||||
}
|
||||
|
||||
if err := tx.Table("qt_configurations").Where("id = ?", action.ConfigID).Update("project_uuid", project.UUID).Error; err != nil {
|
||||
return fmt.Errorf("move configuration %s to project %s: %w", action.ConfigUUID, project.UUID, err)
|
||||
}
|
||||
}
|
||||
|
||||
return nil
|
||||
})
|
||||
}
|
||||
|
||||
func setKeys(set map[string]struct{}) []string {
|
||||
keys := make([]string, 0, len(set))
|
||||
for k := range set {
|
||||
keys = append(keys, k)
|
||||
}
|
||||
sort.Strings(keys)
|
||||
return keys
|
||||
}
|
||||
|
||||
func projectKey(owner, name string) string {
|
||||
return owner + "||" + name
|
||||
}
|
||||
+336
-2
@@ -14,12 +14,13 @@ import (
|
||||
"path/filepath"
|
||||
"runtime"
|
||||
"strconv"
|
||||
"strings"
|
||||
"syscall"
|
||||
"time"
|
||||
|
||||
qfassets "git.mchus.pro/mchus/quoteforge"
|
||||
"git.mchus.pro/mchus/quoteforge/internal/appstate"
|
||||
"git.mchus.pro/mchus/quoteforge/internal/appmeta"
|
||||
"git.mchus.pro/mchus/quoteforge/internal/appstate"
|
||||
"git.mchus.pro/mchus/quoteforge/internal/config"
|
||||
"git.mchus.pro/mchus/quoteforge/internal/db"
|
||||
"git.mchus.pro/mchus/quoteforge/internal/handlers"
|
||||
@@ -164,6 +165,16 @@ func main() {
|
||||
slog.Info("migrations completed")
|
||||
}
|
||||
|
||||
// Always apply SQL migrations on startup when database is available.
|
||||
// This keeps schema in sync for long-running installations without manual steps.
|
||||
if mariaDB != nil {
|
||||
sqlMigrationsPath := filepath.Join("migrations")
|
||||
if err := models.RunSQLMigrations(mariaDB, sqlMigrationsPath); err != nil {
|
||||
slog.Error("startup SQL migrations failed", "path", sqlMigrationsPath, "error", err)
|
||||
os.Exit(1)
|
||||
}
|
||||
}
|
||||
|
||||
gin.SetMode(cfg.Server.Mode)
|
||||
restartSig := make(chan struct{}, 1)
|
||||
|
||||
@@ -438,6 +449,7 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
|
||||
var alertService *alerts.Service
|
||||
var pricelistService *pricelist.Service
|
||||
var syncService *sync.Service
|
||||
var projectService *services.ProjectService
|
||||
|
||||
// Sync service always uses ConnectionManager (works offline and online)
|
||||
syncService = sync.NewService(connMgr, local)
|
||||
@@ -465,8 +477,81 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
|
||||
}
|
||||
|
||||
// Local-first configuration service (replaces old ConfigurationService)
|
||||
projectService = services.NewProjectService(local)
|
||||
configService := services.NewLocalConfigurationService(local, syncService, quoteService, isOnline)
|
||||
|
||||
// Data hygiene: remove empty nameless projects and ensure every configuration is attached to a project.
|
||||
if removed, err := local.ConsolidateSystemProjects(); err == nil && removed > 0 {
|
||||
slog.Info("consolidated duplicate local system projects", "removed", removed)
|
||||
}
|
||||
if removed, err := local.PurgeEmptyNamelessProjects(); err == nil && removed > 0 {
|
||||
slog.Info("purged empty nameless local projects", "removed", removed)
|
||||
}
|
||||
if err := local.BackfillConfigurationProjects(dbUsername); err != nil {
|
||||
slog.Warn("failed to backfill local configuration projects", "error", err)
|
||||
}
|
||||
if mariaDB != nil {
|
||||
serverProjectRepo := repository.NewProjectRepository(mariaDB)
|
||||
if removed, err := serverProjectRepo.PurgeEmptyNamelessProjects(); err == nil && removed > 0 {
|
||||
slog.Info("purged empty nameless server projects", "removed", removed)
|
||||
}
|
||||
if err := serverProjectRepo.EnsureSystemProjectsAndBackfillConfigurations(); err != nil {
|
||||
slog.Warn("failed to backfill server configuration projects", "error", err)
|
||||
}
|
||||
}
|
||||
|
||||
syncProjectsFromServer := func() {
|
||||
if !connMgr.IsOnline() {
|
||||
return
|
||||
}
|
||||
serverDB, err := connMgr.GetDB()
|
||||
if err != nil || serverDB == nil {
|
||||
return
|
||||
}
|
||||
|
||||
projectRepo := repository.NewProjectRepository(serverDB)
|
||||
serverProjects, _, err := projectRepo.List(0, 10000, true)
|
||||
if err != nil {
|
||||
return
|
||||
}
|
||||
|
||||
now := time.Now()
|
||||
for i := range serverProjects {
|
||||
sp := serverProjects[i]
|
||||
localProject, getErr := local.GetProjectByUUID(sp.UUID)
|
||||
if getErr == nil && localProject != nil {
|
||||
// Keep unsynced local changes intact.
|
||||
if localProject.SyncStatus == "pending" {
|
||||
continue
|
||||
}
|
||||
localProject.OwnerUsername = sp.OwnerUsername
|
||||
localProject.Name = sp.Name
|
||||
localProject.IsActive = sp.IsActive
|
||||
localProject.IsSystem = sp.IsSystem
|
||||
localProject.CreatedAt = sp.CreatedAt
|
||||
localProject.UpdatedAt = sp.UpdatedAt
|
||||
serverID := sp.ID
|
||||
localProject.ServerID = &serverID
|
||||
localProject.SyncStatus = "synced"
|
||||
localProject.SyncedAt = &now
|
||||
_ = local.SaveProject(localProject)
|
||||
continue
|
||||
}
|
||||
|
||||
lp := localdb.ProjectToLocal(&sp)
|
||||
lp.SyncStatus = "synced"
|
||||
lp.SyncedAt = &now
|
||||
_ = local.SaveProject(lp)
|
||||
}
|
||||
}
|
||||
|
||||
syncConfigurationsFromServer := func() {
|
||||
if !connMgr.IsOnline() {
|
||||
return
|
||||
}
|
||||
_, _ = configService.ImportFromServer()
|
||||
}
|
||||
|
||||
// Use filepath.Join for cross-platform path compatibility
|
||||
templatesPath := filepath.Join("web", "templates")
|
||||
|
||||
@@ -581,6 +666,8 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
|
||||
router.GET("/", webHandler.Index)
|
||||
router.GET("/configs", webHandler.Configs)
|
||||
router.GET("/configurator", webHandler.Configurator)
|
||||
router.GET("/projects", webHandler.Projects)
|
||||
router.GET("/projects/:uuid", webHandler.ProjectDetail)
|
||||
router.GET("/pricelists", func(c *gin.Context) {
|
||||
// Redirect to admin/pricing with pricelists tab
|
||||
c.Redirect(http.StatusFound, "/admin/pricing?tab=pricelists")
|
||||
@@ -641,15 +728,18 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
|
||||
configs := api.Group("/configs")
|
||||
{
|
||||
configs.GET("", func(c *gin.Context) {
|
||||
syncConfigurationsFromServer()
|
||||
|
||||
page, _ := strconv.Atoi(c.DefaultQuery("page", "1"))
|
||||
perPage, _ := strconv.Atoi(c.DefaultQuery("per_page", "20"))
|
||||
status := c.DefaultQuery("status", "active")
|
||||
search := c.Query("search")
|
||||
if status != "active" && status != "archived" && status != "all" {
|
||||
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid status"})
|
||||
return
|
||||
}
|
||||
|
||||
cfgs, total, err := configService.ListAllWithStatus(page, perPage, status)
|
||||
cfgs, total, err := configService.ListAllWithStatus(page, perPage, status, search)
|
||||
if err != nil {
|
||||
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
||||
return
|
||||
@@ -661,6 +751,7 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
|
||||
"page": page,
|
||||
"per_page": perPage,
|
||||
"status": status,
|
||||
"search": search,
|
||||
})
|
||||
})
|
||||
|
||||
@@ -790,6 +881,32 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
|
||||
c.JSON(http.StatusOK, config)
|
||||
})
|
||||
|
||||
configs.PATCH("/:uuid/project", func(c *gin.Context) {
|
||||
uuid := c.Param("uuid")
|
||||
var req struct {
|
||||
ProjectUUID string `json:"project_uuid"`
|
||||
}
|
||||
if err := c.ShouldBindJSON(&req); err != nil {
|
||||
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
updated, err := configService.SetProjectNoAuth(uuid, req.ProjectUUID)
|
||||
if err != nil {
|
||||
switch {
|
||||
case errors.Is(err, services.ErrConfigNotFound):
|
||||
c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
|
||||
case errors.Is(err, services.ErrProjectNotFound):
|
||||
c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
|
||||
case errors.Is(err, services.ErrProjectForbidden):
|
||||
c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
|
||||
default:
|
||||
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
||||
}
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusOK, updated)
|
||||
})
|
||||
|
||||
configs.GET("/:uuid/versions", func(c *gin.Context) {
|
||||
uuid := c.Param("uuid")
|
||||
|
||||
@@ -895,6 +1012,223 @@ func setupRouter(cfg *config.Config, local *localdb.LocalDB, connMgr *db.Connect
|
||||
})
|
||||
}
|
||||
|
||||
projects := api.Group("/projects")
|
||||
{
|
||||
projects.GET("", func(c *gin.Context) {
|
||||
syncProjectsFromServer()
|
||||
syncConfigurationsFromServer()
|
||||
|
||||
status := c.DefaultQuery("status", "active")
|
||||
search := strings.ToLower(strings.TrimSpace(c.Query("search")))
|
||||
if status != "active" && status != "archived" && status != "all" {
|
||||
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid status"})
|
||||
return
|
||||
}
|
||||
|
||||
allProjects, err := projectService.ListByUser(dbUsername, true)
|
||||
if err != nil {
|
||||
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
|
||||
filtered := make([]models.Project, 0, len(allProjects))
|
||||
for i := range allProjects {
|
||||
p := allProjects[i]
|
||||
if status == "active" && !p.IsActive {
|
||||
continue
|
||||
}
|
||||
if status == "archived" && p.IsActive {
|
||||
continue
|
||||
}
|
||||
if search != "" && !strings.Contains(strings.ToLower(p.Name), search) {
|
||||
continue
|
||||
}
|
||||
filtered = append(filtered, p)
|
||||
}
|
||||
|
||||
projectRows := make([]gin.H, 0, len(filtered))
|
||||
for i := range filtered {
|
||||
p := filtered[i]
|
||||
configs, err := projectService.ListConfigurations(p.UUID, dbUsername, "active")
|
||||
if err != nil {
|
||||
configs = &services.ProjectConfigurationsResult{
|
||||
ProjectUUID: p.UUID,
|
||||
Configs: []models.Configuration{},
|
||||
Total: 0,
|
||||
}
|
||||
}
|
||||
projectRows = append(projectRows, gin.H{
|
||||
"id": p.ID,
|
||||
"uuid": p.UUID,
|
||||
"owner_username": p.OwnerUsername,
|
||||
"name": p.Name,
|
||||
"is_active": p.IsActive,
|
||||
"is_system": p.IsSystem,
|
||||
"created_at": p.CreatedAt,
|
||||
"updated_at": p.UpdatedAt,
|
||||
"config_count": len(configs.Configs),
|
||||
"total": configs.Total,
|
||||
})
|
||||
}
|
||||
|
||||
c.JSON(http.StatusOK, gin.H{
|
||||
"projects": projectRows,
|
||||
"status": status,
|
||||
"search": search,
|
||||
"total": len(projectRows),
|
||||
})
|
||||
})
|
||||
|
||||
projects.POST("", func(c *gin.Context) {
|
||||
var req services.CreateProjectRequest
|
||||
if err := c.ShouldBindJSON(&req); err != nil {
|
||||
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
if strings.TrimSpace(req.Name) == "" {
|
||||
c.JSON(http.StatusBadRequest, gin.H{"error": "project name is required"})
|
||||
return
|
||||
}
|
||||
project, err := projectService.Create(dbUsername, &req)
|
||||
if err != nil {
|
||||
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusCreated, project)
|
||||
})
|
||||
|
||||
projects.GET("/:uuid", func(c *gin.Context) {
|
||||
project, err := projectService.GetByUUID(c.Param("uuid"), dbUsername)
|
||||
if err != nil {
|
||||
switch {
|
||||
case errors.Is(err, services.ErrProjectNotFound):
|
||||
c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
|
||||
case errors.Is(err, services.ErrProjectForbidden):
|
||||
c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
|
||||
default:
|
||||
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
||||
}
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusOK, project)
|
||||
})
|
||||
|
||||
projects.PUT("/:uuid", func(c *gin.Context) {
|
||||
var req services.UpdateProjectRequest
|
||||
if err := c.ShouldBindJSON(&req); err != nil {
|
||||
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
if strings.TrimSpace(req.Name) == "" {
|
||||
c.JSON(http.StatusBadRequest, gin.H{"error": "project name is required"})
|
||||
return
|
||||
}
|
||||
project, err := projectService.Update(c.Param("uuid"), dbUsername, &req)
|
||||
if err != nil {
|
||||
switch {
|
||||
case errors.Is(err, services.ErrProjectNotFound):
|
||||
c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
|
||||
case errors.Is(err, services.ErrProjectForbidden):
|
||||
c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
|
||||
default:
|
||||
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
||||
}
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusOK, project)
|
||||
})
|
||||
|
||||
projects.POST("/:uuid/archive", func(c *gin.Context) {
|
||||
if err := projectService.Archive(c.Param("uuid"), dbUsername); err != nil {
|
||||
switch {
|
||||
case errors.Is(err, services.ErrProjectNotFound):
|
||||
c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
|
||||
case errors.Is(err, services.ErrProjectForbidden):
|
||||
c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
|
||||
default:
|
||||
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
||||
}
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusOK, gin.H{"message": "project archived"})
|
||||
})
|
||||
|
||||
projects.POST("/:uuid/reactivate", func(c *gin.Context) {
|
||||
if err := projectService.Reactivate(c.Param("uuid"), dbUsername); err != nil {
|
||||
switch {
|
||||
case errors.Is(err, services.ErrProjectNotFound):
|
||||
c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
|
||||
case errors.Is(err, services.ErrProjectForbidden):
|
||||
c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
|
||||
default:
|
||||
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
||||
}
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusOK, gin.H{"message": "project reactivated"})
|
||||
})
|
||||
|
||||
projects.GET("/:uuid/configs", func(c *gin.Context) {
|
||||
syncConfigurationsFromServer()
|
||||
|
||||
status := c.DefaultQuery("status", "active")
|
||||
if status != "active" && status != "archived" && status != "all" {
|
||||
c.JSON(http.StatusBadRequest, gin.H{"error": "invalid status"})
|
||||
return
|
||||
}
|
||||
|
||||
result, err := projectService.ListConfigurations(c.Param("uuid"), dbUsername, status)
|
||||
if err != nil {
|
||||
switch {
|
||||
case errors.Is(err, services.ErrProjectNotFound):
|
||||
c.JSON(http.StatusNotFound, gin.H{"error": err.Error()})
|
||||
case errors.Is(err, services.ErrProjectForbidden):
|
||||
c.JSON(http.StatusForbidden, gin.H{"error": err.Error()})
|
||||
default:
|
||||
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
||||
}
|
||||
return
|
||||
}
|
||||
c.Header("X-Config-Status", status)
|
||||
c.JSON(http.StatusOK, result)
|
||||
})
|
||||
|
||||
projects.POST("/:uuid/configs", func(c *gin.Context) {
|
||||
var req services.CreateConfigRequest
|
||||
if err := c.ShouldBindJSON(&req); err != nil {
|
||||
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
projectUUID := c.Param("uuid")
|
||||
req.ProjectUUID = &projectUUID
|
||||
|
||||
config, err := configService.Create(dbUsername, &req)
|
||||
if err != nil {
|
||||
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusCreated, config)
|
||||
})
|
||||
|
||||
projects.POST("/:uuid/configs/:config_uuid/clone", func(c *gin.Context) {
|
||||
var req struct {
|
||||
Name string `json:"name"`
|
||||
}
|
||||
if err := c.ShouldBindJSON(&req); err != nil {
|
||||
c.JSON(http.StatusBadRequest, gin.H{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
|
||||
projectUUID := c.Param("uuid")
|
||||
config, err := configService.CloneNoAuthToProject(c.Param("config_uuid"), req.Name, dbUsername, &projectUUID)
|
||||
if err != nil {
|
||||
c.JSON(http.StatusInternalServerError, gin.H{"error": err.Error()})
|
||||
return
|
||||
}
|
||||
c.JSON(http.StatusCreated, config)
|
||||
})
|
||||
}
|
||||
|
||||
// Pricing admin (public - RBAC disabled)
|
||||
pricingAdmin := api.Group("/admin/pricing")
|
||||
{
|
||||
|
||||
@@ -136,6 +136,160 @@ func TestConfigurationVersioningAPI(t *testing.T) {
|
||||
}
|
||||
}
|
||||
|
||||
func TestProjectArchiveHidesConfigsAndCloneIntoProject(t *testing.T) {
|
||||
moveToRepoRoot(t)
|
||||
|
||||
local, connMgr, configService := newAPITestStack(t)
|
||||
_ = configService
|
||||
|
||||
cfg := &config.Config{}
|
||||
setConfigDefaults(cfg)
|
||||
router, _, err := setupRouter(cfg, local, connMgr, nil, "tester", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("setup router: %v", err)
|
||||
}
|
||||
|
||||
createProjectReq := httptest.NewRequest(http.MethodPost, "/api/projects", bytes.NewReader([]byte(`{"name":"P1"}`)))
|
||||
createProjectReq.Header.Set("Content-Type", "application/json")
|
||||
createProjectRec := httptest.NewRecorder()
|
||||
router.ServeHTTP(createProjectRec, createProjectReq)
|
||||
if createProjectRec.Code != http.StatusCreated {
|
||||
t.Fatalf("create project status=%d body=%s", createProjectRec.Code, createProjectRec.Body.String())
|
||||
}
|
||||
var project models.Project
|
||||
if err := json.Unmarshal(createProjectRec.Body.Bytes(), &project); err != nil {
|
||||
t.Fatalf("unmarshal project: %v", err)
|
||||
}
|
||||
|
||||
createCfgBody := []byte(`{"name":"Cfg A","items":[{"lot_name":"CPU","quantity":1,"unit_price":100}],"server_count":1}`)
|
||||
createCfgReq := httptest.NewRequest(http.MethodPost, "/api/projects/"+project.UUID+"/configs", bytes.NewReader(createCfgBody))
|
||||
createCfgReq.Header.Set("Content-Type", "application/json")
|
||||
createCfgRec := httptest.NewRecorder()
|
||||
router.ServeHTTP(createCfgRec, createCfgReq)
|
||||
if createCfgRec.Code != http.StatusCreated {
|
||||
t.Fatalf("create project config status=%d body=%s", createCfgRec.Code, createCfgRec.Body.String())
|
||||
}
|
||||
var createdCfg models.Configuration
|
||||
if err := json.Unmarshal(createCfgRec.Body.Bytes(), &createdCfg); err != nil {
|
||||
t.Fatalf("unmarshal project config: %v", err)
|
||||
}
|
||||
if createdCfg.ProjectUUID == nil || *createdCfg.ProjectUUID != project.UUID {
|
||||
t.Fatalf("expected config project_uuid=%s got=%v", project.UUID, createdCfg.ProjectUUID)
|
||||
}
|
||||
|
||||
cloneReq := httptest.NewRequest(http.MethodPost, "/api/projects/"+project.UUID+"/configs/"+createdCfg.UUID+"/clone", bytes.NewReader([]byte(`{"name":"Cfg A Clone"}`)))
|
||||
cloneReq.Header.Set("Content-Type", "application/json")
|
||||
cloneRec := httptest.NewRecorder()
|
||||
router.ServeHTTP(cloneRec, cloneReq)
|
||||
if cloneRec.Code != http.StatusCreated {
|
||||
t.Fatalf("clone in project status=%d body=%s", cloneRec.Code, cloneRec.Body.String())
|
||||
}
|
||||
var cloneCfg models.Configuration
|
||||
if err := json.Unmarshal(cloneRec.Body.Bytes(), &cloneCfg); err != nil {
|
||||
t.Fatalf("unmarshal clone config: %v", err)
|
||||
}
|
||||
if cloneCfg.ProjectUUID == nil || *cloneCfg.ProjectUUID != project.UUID {
|
||||
t.Fatalf("expected clone project_uuid=%s got=%v", project.UUID, cloneCfg.ProjectUUID)
|
||||
}
|
||||
|
||||
projectConfigsReq := httptest.NewRequest(http.MethodGet, "/api/projects/"+project.UUID+"/configs", nil)
|
||||
projectConfigsRec := httptest.NewRecorder()
|
||||
router.ServeHTTP(projectConfigsRec, projectConfigsReq)
|
||||
if projectConfigsRec.Code != http.StatusOK {
|
||||
t.Fatalf("project configs status=%d body=%s", projectConfigsRec.Code, projectConfigsRec.Body.String())
|
||||
}
|
||||
var projectConfigsResp struct {
|
||||
Configurations []models.Configuration `json:"configurations"`
|
||||
}
|
||||
if err := json.Unmarshal(projectConfigsRec.Body.Bytes(), &projectConfigsResp); err != nil {
|
||||
t.Fatalf("unmarshal project configs response: %v", err)
|
||||
}
|
||||
if len(projectConfigsResp.Configurations) != 2 {
|
||||
t.Fatalf("expected 2 project configs after clone, got %d", len(projectConfigsResp.Configurations))
|
||||
}
|
||||
|
||||
archiveReq := httptest.NewRequest(http.MethodPost, "/api/projects/"+project.UUID+"/archive", nil)
|
||||
archiveRec := httptest.NewRecorder()
|
||||
router.ServeHTTP(archiveRec, archiveReq)
|
||||
if archiveRec.Code != http.StatusOK {
|
||||
t.Fatalf("archive project status=%d body=%s", archiveRec.Code, archiveRec.Body.String())
|
||||
}
|
||||
|
||||
activeReq := httptest.NewRequest(http.MethodGet, "/api/configs?status=active&page=1&per_page=20", nil)
|
||||
activeRec := httptest.NewRecorder()
|
||||
router.ServeHTTP(activeRec, activeReq)
|
||||
if activeRec.Code != http.StatusOK {
|
||||
t.Fatalf("active configs status=%d body=%s", activeRec.Code, activeRec.Body.String())
|
||||
}
|
||||
var activeResp struct {
|
||||
Configurations []models.Configuration `json:"configurations"`
|
||||
}
|
||||
if err := json.Unmarshal(activeRec.Body.Bytes(), &activeResp); err != nil {
|
||||
t.Fatalf("unmarshal active configs response: %v", err)
|
||||
}
|
||||
if len(activeResp.Configurations) != 0 {
|
||||
t.Fatalf("expected no active configs after project archive, got %d", len(activeResp.Configurations))
|
||||
}
|
||||
}
|
||||
|
||||
func TestConfigMoveToProjectEndpoint(t *testing.T) {
|
||||
moveToRepoRoot(t)
|
||||
|
||||
local, connMgr, _ := newAPITestStack(t)
|
||||
cfg := &config.Config{}
|
||||
setConfigDefaults(cfg)
|
||||
router, _, err := setupRouter(cfg, local, connMgr, nil, "tester", nil)
|
||||
if err != nil {
|
||||
t.Fatalf("setup router: %v", err)
|
||||
}
|
||||
|
||||
createProjectReq := httptest.NewRequest(http.MethodPost, "/api/projects", bytes.NewReader([]byte(`{"name":"Move Project"}`)))
|
||||
createProjectReq.Header.Set("Content-Type", "application/json")
|
||||
createProjectRec := httptest.NewRecorder()
|
||||
router.ServeHTTP(createProjectRec, createProjectReq)
|
||||
if createProjectRec.Code != http.StatusCreated {
|
||||
t.Fatalf("create project status=%d body=%s", createProjectRec.Code, createProjectRec.Body.String())
|
||||
}
|
||||
var project models.Project
|
||||
if err := json.Unmarshal(createProjectRec.Body.Bytes(), &project); err != nil {
|
||||
t.Fatalf("unmarshal project: %v", err)
|
||||
}
|
||||
|
||||
createConfigReq := httptest.NewRequest(http.MethodPost, "/api/configs", bytes.NewReader([]byte(`{"name":"Move Me","items":[],"notes":"","server_count":1}`)))
|
||||
createConfigReq.Header.Set("Content-Type", "application/json")
|
||||
createConfigRec := httptest.NewRecorder()
|
||||
router.ServeHTTP(createConfigRec, createConfigReq)
|
||||
if createConfigRec.Code != http.StatusCreated {
|
||||
t.Fatalf("create config status=%d body=%s", createConfigRec.Code, createConfigRec.Body.String())
|
||||
}
|
||||
var created models.Configuration
|
||||
if err := json.Unmarshal(createConfigRec.Body.Bytes(), &created); err != nil {
|
||||
t.Fatalf("unmarshal config: %v", err)
|
||||
}
|
||||
|
||||
moveReq := httptest.NewRequest(http.MethodPatch, "/api/configs/"+created.UUID+"/project", bytes.NewReader([]byte(`{"project_uuid":"`+project.UUID+`"}`)))
|
||||
moveReq.Header.Set("Content-Type", "application/json")
|
||||
moveRec := httptest.NewRecorder()
|
||||
router.ServeHTTP(moveRec, moveReq)
|
||||
if moveRec.Code != http.StatusOK {
|
||||
t.Fatalf("move config status=%d body=%s", moveRec.Code, moveRec.Body.String())
|
||||
}
|
||||
|
||||
getReq := httptest.NewRequest(http.MethodGet, "/api/configs/"+created.UUID, nil)
|
||||
getRec := httptest.NewRecorder()
|
||||
router.ServeHTTP(getRec, getReq)
|
||||
if getRec.Code != http.StatusOK {
|
||||
t.Fatalf("get config status=%d body=%s", getRec.Code, getRec.Body.String())
|
||||
}
|
||||
var updated models.Configuration
|
||||
if err := json.Unmarshal(getRec.Body.Bytes(), &updated); err != nil {
|
||||
t.Fatalf("unmarshal updated config: %v", err)
|
||||
}
|
||||
if updated.ProjectUUID == nil || *updated.ProjectUUID != project.UUID {
|
||||
t.Fatalf("expected moved project_uuid=%s, got %v", project.UUID, updated.ProjectUUID)
|
||||
}
|
||||
}
|
||||
|
||||
func newAPITestStack(t *testing.T) (*localdb.LocalDB, *db.ConnectionManager, *services.LocalConfigurationService) {
|
||||
t.Helper()
|
||||
|
||||
|
||||
Reference in New Issue
Block a user