352 lines
9.2 KiB
Go
352 lines
9.2 KiB
Go
package handler
|
|
|
|
import (
|
|
"crypto/rand"
|
|
"encoding/hex"
|
|
"kenaito-conf/server/internal/dao"
|
|
"kenaito-conf/server/internal/middleware"
|
|
"kenaito-conf/server/internal/model"
|
|
"net/http"
|
|
"strconv"
|
|
"time"
|
|
|
|
"github.com/gin-gonic/gin"
|
|
)
|
|
|
|
type AppHandler struct{}
|
|
|
|
func NewAppHandler() *AppHandler {
|
|
return &AppHandler{}
|
|
}
|
|
|
|
type AppListRequest struct {
|
|
PageNo int `form:"pageNo" binding:"required"`
|
|
PageSize int `form:"pageSize" binding:"required"`
|
|
AppType string `form:"appType"`
|
|
}
|
|
|
|
func (h *AppHandler) List(c *gin.Context) {
|
|
var req AppListRequest
|
|
if err := c.ShouldBindQuery(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, model.WrapperResponse{Code: 400, Msg: "参数错误"})
|
|
return
|
|
}
|
|
|
|
userInfo := middleware.GetUserInfo(c)
|
|
query := dao.Engine.Where("enabled = 1")
|
|
|
|
if !userInfo.IsSuperAdmin() {
|
|
if userInfo.IsGroupAdmin() && userInfo.GroupId != nil {
|
|
query = query.And("group_id = ?", *userInfo.GroupId)
|
|
} else {
|
|
userId, _ := strconv.Atoi(userInfo.Id)
|
|
query = query.And("(owner_id = ? OR id IN (SELECT app_id FROM user_permissions WHERE user_id = ?))", userId, userId)
|
|
}
|
|
}
|
|
|
|
var apps []model.Application
|
|
total, _ := query.Count(&model.Application{})
|
|
query.Limit(req.PageSize, (req.PageNo-1)*req.PageSize).Find(&apps)
|
|
|
|
// load group names
|
|
groupIds := make(map[int]bool)
|
|
for _, app := range apps {
|
|
if app.GroupId != nil {
|
|
groupIds[*app.GroupId] = true
|
|
}
|
|
}
|
|
groupMap := make(map[int]string)
|
|
for gid := range groupIds {
|
|
var group model.BusinessGroup
|
|
if has, _ := dao.Engine.ID(gid).Get(&group); has {
|
|
groupMap[gid] = group.Name
|
|
}
|
|
}
|
|
for i := range apps {
|
|
if apps[i].GroupId != nil {
|
|
apps[i].GroupName = groupMap[*apps[i].GroupId]
|
|
}
|
|
}
|
|
|
|
c.JSON(http.StatusOK, model.PageResult{PageNo: req.PageNo, PageSize: req.PageSize, Total: total, Data: apps})
|
|
}
|
|
|
|
func (h *AppHandler) GetById(c *gin.Context) {
|
|
id, _ := strconv.Atoi(c.Param("id"))
|
|
var app model.Application
|
|
has, _ := dao.Engine.ID(id).Get(&app)
|
|
if !has {
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 404, Msg: "应用不存在"})
|
|
return
|
|
}
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 0, Data: app})
|
|
}
|
|
|
|
func (h *AppHandler) Tree(c *gin.Context) {
|
|
var apps []model.Application
|
|
dao.Engine.Find(&apps)
|
|
|
|
tree := make(map[string]*AppTreeModel)
|
|
for _, app := range apps {
|
|
node := &AppTreeModel{
|
|
Id: strconv.Itoa(app.Id),
|
|
Name: app.Name,
|
|
Code: app.Code,
|
|
ServiceId: app.ServiceId,
|
|
Children: make([]*AppTreeModel, 0),
|
|
}
|
|
tree[strconv.Itoa(app.Id)] = node
|
|
}
|
|
|
|
result := make([]*AppTreeModel, 0)
|
|
for _, app := range apps {
|
|
node := tree[strconv.Itoa(app.Id)]
|
|
if app.ParentId == nil {
|
|
result = append(result, node)
|
|
} else {
|
|
parentId := strconv.Itoa(*app.ParentId)
|
|
if parent, ok := tree[parentId]; ok {
|
|
parent.Children = append(parent.Children, node)
|
|
}
|
|
}
|
|
}
|
|
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 0, Data: result})
|
|
}
|
|
|
|
type AddAppRequest struct {
|
|
Id int `json:"id"`
|
|
GroupId *int `json:"groupId"`
|
|
ParentId *int `json:"parentId"`
|
|
Name string `json:"name" binding:"required"`
|
|
Code string `json:"code" binding:"required"`
|
|
ServiceId string `json:"serviceId"`
|
|
OwnerId *int `json:"ownerId"`
|
|
Remarks string `json:"remarks"`
|
|
}
|
|
|
|
func (h *AppHandler) Add(c *gin.Context) {
|
|
var req AddAppRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, model.WrapperResponse{Code: 400, Msg: "参数错误"})
|
|
return
|
|
}
|
|
|
|
userInfo := middleware.GetUserInfo(c)
|
|
|
|
// check if code exists
|
|
var existing model.Application
|
|
if has, _ := dao.Engine.Where("code = ?", req.Code).Get(&existing); has {
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 1002, Msg: "应用已存在"})
|
|
return
|
|
}
|
|
|
|
ownerId := req.OwnerId
|
|
if ownerId == nil {
|
|
uid, _ := strconv.Atoi(userInfo.Id)
|
|
ownerId = &uid
|
|
}
|
|
|
|
var owner model.User
|
|
if has, _ := dao.Engine.ID(*ownerId).Get(&owner); !has {
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 400, Msg: "负责人不存在"})
|
|
return
|
|
}
|
|
|
|
app := model.Application{
|
|
GroupId: req.GroupId,
|
|
ParentId: req.ParentId,
|
|
Name: req.Name,
|
|
Code: req.Code,
|
|
ServiceId: req.ServiceId,
|
|
OwnerId: ownerId,
|
|
OwnerName: owner.Name,
|
|
Remarks: req.Remarks,
|
|
Enabled: true,
|
|
CreatedAt: func() *time.Time { t := time.Now(); return &t }(),
|
|
CreatedBy: userInfo.Name,
|
|
}
|
|
|
|
if req.ParentId != nil {
|
|
var parent model.Application
|
|
if has, _ := dao.Engine.ID(*req.ParentId).Get(&parent); has {
|
|
app.GroupId = parent.GroupId
|
|
app.IsModule = true
|
|
app.Code = parent.Code + "-" + req.Code
|
|
}
|
|
}
|
|
|
|
dao.Engine.Insert(&app)
|
|
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 0, Data: true})
|
|
}
|
|
|
|
func (h *AppHandler) Update(c *gin.Context) {
|
|
var req AddAppRequest
|
|
if err := c.ShouldBindJSON(&req); err != nil {
|
|
c.JSON(http.StatusBadRequest, model.WrapperResponse{Code: 400, Msg: "参数错误"})
|
|
return
|
|
}
|
|
|
|
if req.Id == 0 {
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 400, Msg: "id参数缺失"})
|
|
return
|
|
}
|
|
|
|
var app model.Application
|
|
has, _ := dao.Engine.ID(req.Id).Get(&app)
|
|
if !has {
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 404, Msg: "应用不存在"})
|
|
return
|
|
}
|
|
|
|
userInfo := middleware.GetUserInfo(c)
|
|
|
|
app.Name = req.Name
|
|
app.ServiceId = req.ServiceId
|
|
app.Remarks = req.Remarks
|
|
if req.OwnerId != nil {
|
|
if app.OwnerId == nil || *req.OwnerId != *app.OwnerId {
|
|
var owner model.User
|
|
if has, _ := dao.Engine.ID(*req.OwnerId).Get(&owner); has {
|
|
app.OwnerName = owner.Name
|
|
}
|
|
}
|
|
app.OwnerId = req.OwnerId
|
|
}
|
|
app.UpdatedBy = userInfo.Name
|
|
now := time.Now()
|
|
app.UpdatedAt = &now
|
|
|
|
dao.Engine.ID(app.Id).Cols("name", "service_id", "remarks", "owner_id", "owner_name", "updated_by", "updated_at").Update(&app)
|
|
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 0, Data: true})
|
|
}
|
|
|
|
func (h *AppHandler) Delete(c *gin.Context) {
|
|
id, _ := strconv.Atoi(c.Param("id"))
|
|
userInfo := middleware.GetUserInfo(c)
|
|
|
|
if !userInfo.IsSuperAdmin() {
|
|
c.JSON(http.StatusForbidden, model.WrapperResponse{Code: 403, Msg: "超级管理员才能删除"})
|
|
return
|
|
}
|
|
|
|
var app model.Application
|
|
has, _ := dao.Engine.ID(id).Get(&app)
|
|
if !has {
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 404, Msg: "应用不存在"})
|
|
return
|
|
}
|
|
|
|
app.Enabled = false
|
|
app.UpdatedBy = userInfo.Name
|
|
now := time.Now()
|
|
app.UpdatedAt = &now
|
|
dao.Engine.ID(app.Id).Cols("enabled", "updated_by", "updated_at").Update(&app)
|
|
|
|
// soft delete related configs
|
|
dao.Engine.Where("app_id = ?", id).Cols("enabled").Update(&model.AppConfig{Enabled: false})
|
|
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 0})
|
|
}
|
|
|
|
func (h *AppHandler) Switch(c *gin.Context) {
|
|
id, _ := strconv.Atoi(c.Param("id"))
|
|
userInfo := middleware.GetUserInfo(c)
|
|
|
|
var app model.Application
|
|
has, _ := dao.Engine.ID(id).Get(&app)
|
|
if !has {
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 404, Msg: "应用不存在"})
|
|
return
|
|
}
|
|
|
|
app.Enabled = !app.Enabled
|
|
app.UpdatedBy = userInfo.Name
|
|
now := time.Now()
|
|
app.UpdatedAt = &now
|
|
dao.Engine.ID(app.Id).Cols("enabled", "updated_by", "updated_at").Update(&app)
|
|
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 0, Data: true})
|
|
}
|
|
|
|
func (h *AppHandler) Options(c *gin.Context) {
|
|
userInfo := middleware.GetUserInfo(c)
|
|
query := dao.Engine.Where("enabled = 1")
|
|
|
|
if !userInfo.IsSuperAdmin() {
|
|
if userInfo.IsGroupAdmin() && userInfo.GroupId != nil {
|
|
query = query.And("group_id = ?", *userInfo.GroupId)
|
|
} else {
|
|
userId, _ := strconv.Atoi(userInfo.Id)
|
|
query = query.And("owner_id = ?", userId)
|
|
}
|
|
}
|
|
|
|
var apps []model.Application
|
|
query.Find(&apps)
|
|
|
|
options := make([]model.SelectOption, 0)
|
|
for _, app := range apps {
|
|
options = append(options, model.SelectOption{Value: strconv.Itoa(app.Id), Label: app.Name})
|
|
}
|
|
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 0, Data: options})
|
|
}
|
|
|
|
type AppTreeModel struct {
|
|
Id string `json:"id"`
|
|
Name string `json:"name"`
|
|
Code string `json:"code"`
|
|
ServiceId string `json:"serviceId,omitempty"`
|
|
Children []*AppTreeModel `json:"children"`
|
|
}
|
|
|
|
func (h *AppHandler) GenerateToken(c *gin.Context) {
|
|
id, _ := strconv.Atoi(c.Param("id"))
|
|
userInfo := middleware.GetUserInfo(c)
|
|
|
|
var app model.Application
|
|
has, _ := dao.Engine.ID(id).Get(&app)
|
|
if !has {
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 404, Msg: "应用不存在"})
|
|
return
|
|
}
|
|
|
|
bytes := make([]byte, 32)
|
|
if _, err := rand.Read(bytes); err != nil {
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 500, Msg: "生成 Token 失败"})
|
|
return
|
|
}
|
|
token := hex.EncodeToString(bytes)
|
|
|
|
app.Token = token
|
|
app.UpdatedBy = userInfo.Name
|
|
now := time.Now()
|
|
app.UpdatedAt = &now
|
|
dao.Engine.ID(app.Id).Cols("token", "updated_by", "updated_at").Update(&app)
|
|
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 0, Data: token})
|
|
}
|
|
|
|
func (h *AppHandler) DeleteToken(c *gin.Context) {
|
|
id, _ := strconv.Atoi(c.Param("id"))
|
|
userInfo := middleware.GetUserInfo(c)
|
|
|
|
var app model.Application
|
|
has, _ := dao.Engine.ID(id).Get(&app)
|
|
if !has {
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 404, Msg: "应用不存在"})
|
|
return
|
|
}
|
|
|
|
app.Token = ""
|
|
app.UpdatedBy = userInfo.Name
|
|
now := time.Now()
|
|
app.UpdatedAt = &now
|
|
dao.Engine.ID(app.Id).Cols("token", "updated_by", "updated_at").Update(&app)
|
|
|
|
c.JSON(http.StatusOK, model.WrapperResponse{Code: 0, Data: true})
|
|
}
|