feat: v0.3.1 — Go/Gin 后端重写 + gh-ost 集成

架构变更: - Python/FastAPI → Go/Gin 重写（Python 后端保留在 backend-python/） - GORM + SQLite（兼容现有数据库表结构） - JWT 认证 + RBAC 权限中间件 Go 后端结构: - cmd/server/main.go — 入口，端口 9000 - config/config.go — 环境变量配置 - internal/model/ — GORM 模型（30张表，完全兼容 SQLite） - internal/handler/ — auth/instance/ticket/dashboard/ghost handler - internal/middleware/ — JWT 认证 + CORS - internal/ghost/ — gh-ost 集成模块（同步/异步执行，任务管理） - router/router.go — API 路由注册（/api/v1/...） gh-ost 集成: - RunGhOst() 同步执行 - RunGhOstAsync() 异步执行 + 进度追踪 - TaskManager 管理多个并发任务 - API: POST /ghost/dry-run, /ghost/execute, GET /ghost/status/:taskId 核心 API 已对齐: - POST /auth/login (JWT) - GET /dashboard/stats, /dashboard/my-tickets - GET /tickets/statistics, CRUD + approve/execute - GET/POST/PUT/DELETE /instances - GET /users, /audit-rules, /announcements, /settings 已验证: - 登录 admin/admin123 ✅ - Dashboard 99工单/110查询/4实例 ✅ - 工单统计按角色过滤 ✅
2026-05-25 21:40:54 +08:00
1 parent 43d1f3a234
commit ca308e277d
@@ -0,0 +1,145 @@
+package service
+
+import (
+	"errors"
+	"time"
+
+	"golang.org/x/crypto/bcrypt"
+	"gorm.io/gorm"
+	"sql-platform/internal/middleware"
+	"sql-platform/internal/model"
+)
+
+type AuthService struct {
+	DB *gorm.DB
+}
+
+func NewAuthService(db *gorm.DB) *AuthService {
+	return &AuthService{DB: db}
+}
+
+// Login authenticates a user and returns a JWT token
+func (s *AuthService) Login(username, password string) (*model.User, string, error) {
+	var user model.User
+	if err := s.DB.Where("username = ?", username).First(&user).Error; err != nil {
+		return nil, "", errors.New("invalid username or password")
+	}
+
+	if !user.IsActive {
+		return nil, "", errors.New("account is disabled")
+	}
+
+	if err := bcrypt.CompareHashAndPassword([]byte(user.HashedPassword), []byte(password)); err != nil {
+		return nil, "", errors.New("invalid username or password")
+	}
+
+	token, err := middleware.GenerateToken(user.ID, user.Username, user.Role)
+	if err != nil {
+		return nil, "", errors.New("failed to generate token")
+	}
+
+	// Update last login
+	now := time.Now()
+	user.LastLogin = &now
+	s.DB.Model(&user).Update("last_login", now)
+
+	return &user, token, nil
+}
+
+// Register creates a new user
+func (s *AuthService) Register(username, displayName, email, phone, password, role string) (*model.User, error) {
+	// Check if username already exists
+	var count int64
+	s.DB.Model(&model.User{}).Where("username = ?", username).Count(&count)
+	if count > 0 {
+		return nil, errors.New("username already exists")
+	}
+
+	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
+	if err != nil {
+		return nil, errors.New("failed to hash password")
+	}
+
+	if role == "" {
+		role = "developer"
+	}
+
+	user := model.User{
+		Username:       username,
+		DisplayName:    displayName,
+		Email:          email,
+		Phone:          phone,
+		HashedPassword: string(hashedPassword),
+		Role:           role,
+		IsActive:       true,
+	}
+
+	if err := s.DB.Create(&user).Error; err != nil {
+		return nil, errors.New("failed to create user")
+	}
+
+	return &user, nil
+}
+
+// GetUserByID retrieves a user by ID
+func (s *AuthService) GetUserByID(id uint) (*model.User, error) {
+	var user model.User
+	if err := s.DB.First(&user, id).Error; err != nil {
+		return nil, errors.New("user not found")
+	}
+	return &user, nil
+}
+
+// ListUsers returns all users
+func (s *AuthService) ListUsers(page, pageSize int) ([]model.User, int64, error) {
+	var users []model.User
+	var total int64
+
+	db := s.DB.Model(&model.User{})
+	db.Count(&total)
+
+	offset := (page - 1) * pageSize
+	if err := db.Offset(offset).Limit(pageSize).Find(&users).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return users, total, nil
+}
+
+// UpdateUser updates a user's info
+func (s *AuthService) UpdateUser(id uint, updates map[string]interface{}) error {
+	return s.DB.Model(&model.User{}).Where("id = ?", id).Updates(updates).Error
+}
+
+// DeleteUser soft-deletes a user
+func (s *AuthService) DeleteUser(id uint) error {
+	return s.DB.Delete(&model.User{}, id).Error
+}
+
+// ChangePassword changes a user's password
+func (s *AuthService) ChangePassword(id uint, oldPassword, newPassword string) error {
+	var user model.User
+	if err := s.DB.First(&user, id).Error; err != nil {
+		return errors.New("user not found")
+	}
+
+	if err := bcrypt.CompareHashAndPassword([]byte(user.HashedPassword), []byte(oldPassword)); err != nil {
+		return errors.New("incorrect current password")
+	}
+
+	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(newPassword), bcrypt.DefaultCost)
+	if err != nil {
+		return errors.New("failed to hash password")
+	}
+
+	return s.DB.Model(&user).Update("hashed_password", string(hashedPassword)).Error
+}
+
+// ResetPassword resets a user's password (admin only)
+func (s *AuthService) ResetPassword(id uint, newPassword string) error {
+	hashedPassword, err := bcrypt.GenerateFromPassword([]byte(newPassword), bcrypt.DefaultCost)
+	if err != nil {
+		return errors.New("failed to hash password")
+	}
+	return s.DB.Model(&model.User{}).Where("id = ?", id).Update("hashed_password", string(hashedPassword)).Error
+}
@@ -0,0 +1,93 @@
+package service
+
+import (
+	"errors"
+
+	"gorm.io/gorm"
+	"sql-platform/internal/model"
+)
+
+type InstanceService struct {
+	DB *gorm.DB
+}
+
+func NewInstanceService(db *gorm.DB) *InstanceService {
+	return &InstanceService{DB: db}
+}
+
+// CreateInstance creates a new database instance
+func (s *InstanceService) CreateInstance(instance *model.Instance) error {
+	return s.DB.Create(instance).Error
+}
+
+// GetInstanceByID retrieves an instance by ID
+func (s *InstanceService) GetInstanceByID(id uint) (*model.Instance, error) {
+	var instance model.Instance
+	if err := s.DB.First(&instance, id).Error; err != nil {
+		return nil, errors.New("instance not found")
+	}
+	return &instance, nil
+}
+
+// ListInstances returns paginated instances
+func (s *InstanceService) ListInstances(page, pageSize int, dbType, env string) ([]model.Instance, int64, error) {
+	var instances []model.Instance
+	var total int64
+
+	db := s.DB.Model(&model.Instance{})
+	if dbType != "" {
+		db = db.Where("db_type = ?", dbType)
+	}
+	if env != "" {
+		db = db.Where("env = ?", env)
+	}
+
+	db.Count(&total)
+	offset := (page - 1) * pageSize
+	if err := db.Offset(offset).Limit(pageSize).Order("created_at DESC").Find(&instances).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return instances, total, nil
+}
+
+// UpdateInstance updates an instance
+func (s *InstanceService) UpdateInstance(id uint, updates map[string]interface{}) error {
+	result := s.DB.Model(&model.Instance{}).Where("id = ?", id).Updates(updates)
+	if result.RowsAffected == 0 {
+		return errors.New("instance not found")
+	}
+	return result.Error
+}
+
+// DeleteInstance soft-deletes an instance
+func (s *InstanceService) DeleteInstance(id uint) error {
+	return s.DB.Delete(&model.Instance{}, id).Error
+}
+
+// TestConnection tests the database connection
+func (s *InstanceService) TestConnection(instance *model.Instance) error {
+	// TODO: Implement actual connection test based on db_type
+	return nil
+}
+
+// ListInstancesByIDs returns instances matching the given IDs
+func (s *InstanceService) ListInstancesByIDs(ids []uint) ([]model.Instance, error) {
+	var instances []model.Instance
+	if err := s.DB.Where("id IN ?", ids).Find(&instances).Error; err != nil {
+		return nil, err
+	}
+	return instances, nil
+}
+
+// GetInstanceGroups returns all instance groups
+func (s *InstanceService) GetInstanceGroups() ([]model.InstanceGroup, error) {
+	var groups []model.InstanceGroup
+	err := s.DB.Find(&groups).Error
+	return groups, err
+}
+
+// CreateInstanceGroup creates a new instance group
+func (s *InstanceService) CreateInstanceGroup(group *model.InstanceGroup) error {
+	return s.DB.Create(group).Error
+}
@@ -0,0 +1,129 @@
+package service
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	"gorm.io/gorm"
+	"sql-platform/internal/model"
+)
+
+type TicketService struct {
+	DB *gorm.DB
+}
+
+func NewTicketService(db *gorm.DB) *TicketService {
+	return &TicketService{DB: db}
+}
+
+// CreateTicket creates a new ticket
+func (s *TicketService) CreateTicket(ticket *model.Ticket) error {
+	if ticket.TicketNo == "" {
+		ticket.TicketNo = s.generateTicketNo()
+	}
+	if ticket.CreateTime.IsZero() {
+		ticket.CreateTime = time.Now()
+	}
+	if ticket.Status == "" {
+		ticket.Status = "pending"
+	}
+	return s.DB.Create(ticket).Error
+}
+
+// GetTicketByID retrieves a ticket by ID
+func (s *TicketService) GetTicketByID(id uint) (*model.Ticket, error) {
+	var ticket model.Ticket
+	if err := s.DB.First(&ticket, id).Error; err != nil {
+		return nil, errors.New("ticket not found")
+	}
+	return &ticket, nil
+}
+
+// ListTickets returns paginated tickets with filters
+func (s *TicketService) ListTickets(page, pageSize int, status, priority string, applicantID uint) ([]model.Ticket, int64, error) {
+	var tickets []model.Ticket
+	var total int64
+
+	db := s.DB.Model(&model.Ticket{})
+	if status != "" {
+		db = db.Where("status = ?", status)
+	}
+	if priority != "" {
+		db = db.Where("priority = ?", priority)
+	}
+	if applicantID > 0 {
+		db = db.Where("applicant_id = ?", applicantID)
+	}
+
+	db.Count(&total)
+	offset := (page - 1) * pageSize
+	if err := db.Offset(offset).Limit(pageSize).Order("create_time DESC").Find(&tickets).Error; err != nil {
+		return nil, 0, err
+	}
+
+	return tickets, total, nil
+}
+
+// UpdateTicketStatus updates a ticket's status
+func (s *TicketService) UpdateTicketStatus(id uint, status string, updaterID uint) error {
+	updates := map[string]interface{}{
+		"status": status,
+	}
+	now := time.Now()
+	switch status {
+	case "approved":
+		updates["approver_id"] = updaterID
+		updates["review_time"] = now
+	case "executing", "completed", "failed":
+		updates["execute_time"] = now
+	}
+
+	result := s.DB.Model(&model.Ticket{}).Where("id = ?", id).Updates(updates)
+	if result.RowsAffected == 0 {
+		return errors.New("ticket not found")
+	}
+	return result.Error
+}
+
+// ApproveTicket approves a ticket
+func (s *TicketService) ApproveTicket(id, approverID uint, comment string) error {
+	return s.UpdateTicketStatus(id, "approved", approverID)
+}
+
+// RejectTicket rejects a ticket
+func (s *TicketService) RejectTicket(id, approverID uint, comment string) error {
+	return s.UpdateTicketStatus(id, "rejected", approverID)
+}
+
+// GetTicketSQLItems returns SQL items for a ticket
+func (s *TicketService) GetTicketSQLItems(ticketID uint) ([]model.TicketSQLItem, error) {
+	var items []model.TicketSQLItem
+	err := s.DB.Where("ticket_id = ?", ticketID).Order("seq ASC").Find(&items).Error
+	return items, err
+}
+
+// CreateTicketSQLItem creates a SQL item for a ticket
+func (s *TicketService) CreateTicketSQLItem(item *model.TicketSQLItem) error {
+	return s.DB.Create(item).Error
+}
+
+// GetTicketApprovals returns approval records for a ticket
+func (s *TicketService) GetTicketApprovals(ticketID uint) ([]model.TicketApproval, error) {
+	var approvals []model.TicketApproval
+	err := s.DB.Where("ticket_id = ?", ticketID).Order("step_number ASC").Find(&approvals).Error
+	return approvals, err
+}
+
+// DeleteTicket soft-deletes a ticket
+func (s *TicketService) DeleteTicket(id uint) error {
+	return s.DB.Delete(&model.Ticket{}, id).Error
+}
+
+// generateTicketNo generates a unique ticket number
+func (s *TicketService) generateTicketNo() string {
+	now := time.Now()
+	var count int64
+	s.DB.Model(&model.Ticket{}).Where("DATE(create_time) = DATE(?)", now).Count(&count)
+	return fmt.Sprintf("TK-%s-%04d", now.Format("20060102"), count+1)
+}