aiops/backend/controller/deploy_groups.go

package controller

import (
	"net/http"
	"strconv"

	"ezops/model"

	"github.com/gin-gonic/gin"
)

// ==================== 用户组管理 ====================

// ListGroups 用户组列表
func (h *PipelineHandler) ListGroups(c *gin.Context) {
	var groups []model.DeployUserGroup
	h.db.Preload("Members").Order("created_at DESC").Find(&groups)
	c.JSON(http.StatusOK, model.Response{Code: 200, Data: model.ListResponse{List: groups, Total: int64(len(groups))}})
}

// CreateGroup 创建用户组
func (h *PipelineHandler) CreateGroup(c *gin.Context) {
	var req struct {
		Name        string `json:"name" binding:"required"`
		Description string `json:"description"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, model.Response{Code: 400, Message: err.Error()})
		return
	}
	group := model.DeployUserGroup{
		Name: req.Name, Description: req.Description,
		CreatedBy: c.GetString("username"),
	}
	if err := h.db.Create(&group).Error; err != nil {
		c.JSON(http.StatusConflict, model.Response{Code: 409, Message: "组名已存在: " + err.Error()})
		return
	}
	c.JSON(http.StatusOK, model.Response{Code: 200, Data: group})
}

// UpdateGroup 更新用户组
func (h *PipelineHandler) UpdateGroup(c *gin.Context) {
	id, _ := strconv.Atoi(c.Param("id"))
	var group model.DeployUserGroup
	if err := h.db.First(&group, id).Error; err != nil {
		c.JSON(http.StatusNotFound, model.Response{Code: 404, Message: "不存在"})
		return
	}
	var req struct {
		Name        *string `json:"name"`
		Description *string `json:"description"`
	}
	c.ShouldBindJSON(&req)
	updates := map[string]interface{}{}
	if req.Name != nil { updates["name"] = *req.Name }
	if req.Description != nil { updates["description"] = *req.Description }
	h.db.Model(&group).Updates(updates)
	h.db.First(&group, id)
	c.JSON(http.StatusOK, model.Response{Code: 200, Data: group})
}

// DeleteGroup 删除用户组
func (h *PipelineHandler) DeleteGroup(c *gin.Context) {
	id := c.Param("id")
	// 先删组成员和流水线授权
	h.db.Where("group_id = ?", id).Delete(&model.DeployUserGroupMember{})
	h.db.Where("group_id = ?", id).Delete(&model.DeployPipelineMember{})
	h.db.Delete(&model.DeployUserGroup{}, id)
	c.JSON(http.StatusOK, model.Response{Code: 200, Message: "已删除"})
}

// ==================== 用户组成员管理 ====================

// ListGroupMembers 组成员列表
func (h *PipelineHandler) ListGroupMembers(c *gin.Context) {
	groupID, _ := strconv.Atoi(c.Param("id"))
	var members []model.DeployUserGroupMember
	h.db.Where("group_id = ?", groupID).Find(&members)
	c.JSON(http.StatusOK, model.Response{Code: 200, Data: members})
}

// AddGroupMember 添加组成员
func (h *PipelineHandler) AddGroupMember(c *gin.Context) {
	groupID, _ := strconv.Atoi(c.Param("id"))
	var req struct {
		Username string `json:"username" binding:"required"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, model.Response{Code: 400, Message: err.Error()})
		return
	}
	member := model.DeployUserGroupMember{GroupID: uint(groupID), Username: req.Username}
	if err := h.db.Create(&member).Error; err != nil {
		c.JSON(http.StatusConflict, model.Response{Code: 409, Message: "该用户已在组内"})
		return
	}
	c.JSON(http.StatusOK, model.Response{Code: 200, Data: member})
}

// RemoveGroupMember 移除组成员
func (h *PipelineHandler) RemoveGroupMember(c *gin.Context) {
	groupID, _ := strconv.Atoi(c.Param("id"))
	memberID, _ := strconv.Atoi(c.Param("memberId"))
	result := h.db.Where("id = ? AND group_id = ?", memberID, groupID).Delete(&model.DeployUserGroupMember{})
	if result.RowsAffected == 0 {
		c.JSON(http.StatusNotFound, model.Response{Code: 404, Message: "成员不存在"})
		return
	}
	c.JSON(http.StatusOK, model.Response{Code: 200, Message: "已移除"})
}

// ==================== 组授权给流水线 ====================

// AssignGroupToPipeline 将用户组授权到流水线
func (h *PipelineHandler) AssignGroupToPipeline(c *gin.Context) {
	pipelineID := getPipelineID(c)
	var req struct {
		GroupID uint   `json:"group_id" binding:"required"`
		Role    string `json:"role" binding:"required,oneof=owner editor viewer"`
	}
	if err := c.ShouldBindJSON(&req); err != nil {
		c.JSON(http.StatusBadRequest, model.Response{Code: 400, Message: err.Error()})
		return
	}

	var pipeline model.Pipeline
	if err := h.db.First(&pipeline, pipelineID).Error; err != nil {
		c.JSON(http.StatusNotFound, model.Response{Code: 404, Message: "流水线不存在"})
		return
	}
	var group model.DeployUserGroup
	if err := h.db.First(&group, req.GroupID).Error; err != nil {
		c.JSON(http.StatusNotFound, model.Response{Code: 404, Message: "用户组不存在"})
		return
	}

	member := model.DeployPipelineMember{
		PipelineID: uint(pipelineID),
		GroupID:    &req.GroupID,
		Role:       model.MemberRole(req.Role),
	}
	if err := h.db.Create(&member).Error; err != nil {
		c.JSON(http.StatusConflict, model.Response{Code: 409, Message: "该组已被授权到此流水线"})
		return
	}

	// 预加载关联
	member.Group = &group
	c.JSON(http.StatusOK, model.Response{Code: 200, Data: member, Message: "已授权"})
}