projectx/internal/router/manage/system/sys_menu.go

package system

import (
	"encoding/json"
	"net/http"
	"strconv"
	"strings"
	"time"

	"management/internal/db/model/dto"
	db "management/internal/db/sqlc"
	"management/internal/global/auth"
	"management/internal/pkg/session"
	"management/internal/router/manage/util"
	systemservice "management/internal/service/system"
	"management/internal/tpl"

	"github.com/google/uuid"
)

type SysMenuHandler struct{}

func NewSysMenuHandler() *SysMenuHandler {
	return &SysMenuHandler{}
}

func (h *SysMenuHandler) Tree(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	vars := r.URL.Query()
	id := util.DefaultInt(vars, "id", 0)
	res, err := systemservice.ToTreeMenu(ctx, id, true)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	tpl.JSON(w, res)
}

func (h *SysMenuHandler) List(w http.ResponseWriter, r *http.Request) {
	tpl.HTML(w, r, "menu/list.tmpl", nil)
}

func (h *SysMenuHandler) PostList(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	res, err := systemservice.ListMenuTree(ctx)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}

	data := tpl.ResponseList{
		Code:    0,
		Message: "ok",
		Count:   0,
		Data:    res,
	}
	tpl.JSON(w, data)
}

func (h *SysMenuHandler) Add(w http.ResponseWriter, r *http.Request) {
	tpl.HTML(w, r, "menu/edit.tmpl", map[string]any{
		"Item": &db.SysMenu{Style: "pear-btn-primary pear-btn-sm", Visible: true, Sort: 6666},
	})
}

func (h *SysMenuHandler) AddChildren(w http.ResponseWriter, r *http.Request) {
	vars := r.URL.Query()
	parentID := util.DefaultInt(vars, "parentID", 0)
	vm := &db.SysMenu{ParentID: int32(parentID), Style: "pear-btn-primary pear-btn-sm", Visible: true, Sort: 6666}
	ctx := r.Context()
	parent, err := systemservice.GetSysMenu(ctx, int32(parentID))
	if err == nil {
		if parent.Type == "node" {
			vm.Type = "menu"
		} else if parent.Type == "menu" {
			vm.Type = "btn"
		}
	}
	tpl.HTML(w, r, "menu/edit.tmpl", map[string]any{
		"Item": vm,
	})
}

func (h *SysMenuHandler) Edit(w http.ResponseWriter, r *http.Request) {
	vars := r.URL.Query()
	id := util.DefaultInt(vars, "id", 0)
	vm := &db.SysMenu{Style: "pear-btn-primary pear-btn-sm", Sort: 6666}
	if id > 0 {
		ctx := r.Context()
		vm, _ = systemservice.GetSysMenu(ctx, int32(id))
	}
	tpl.HTML(w, r, "menu/edit.tmpl", map[string]any{
		"Item": vm,
	})
}

func (h *SysMenuHandler) Save(w http.ResponseWriter, r *http.Request) {
	id := util.ConvertInt(r.PostFormValue("ID"), 0)
	name := r.PostFormValue("Name")
	dispalyName := r.PostFormValue("DisplayName")
	t := r.PostFormValue("Type")
	url := r.PostFormValue("Url")
	if len(url) == 0 {
		url = uuid.Must(uuid.NewRandom()).String()
	}
	avatar := r.PostFormValue("Avatar")
	style := r.PostFormValue("Style")
	parentID := util.ConvertInt(r.PostFormValue("ParentID"), 0)
	visible := util.ConvertBool(r.PostFormValue("Visible"), false)
	isList := util.ConvertBool(r.PostFormValue("IsList"), false)
	sort := util.ConvertInt(r.PostFormValue("Sort"), 6666)
	status := util.ConvertInt(r.PostFormValue("Status"), 9999)

	ctx := r.Context()
	if len(avatar) > 0 && !strings.Contains(avatar, "layui-icon ") {
		avatar = "layui-icon " + avatar
	}

	parentPath := ""
	if parentID > 0 {
		parent, err := systemservice.GetSysMenu(ctx, int32(parentID))
		if err != nil {
			tpl.JSON(w, tpl.Response{Success: false, Message: err.Error()})
			return
		}
		parentPath = parent.ParentPath + "," + strconv.Itoa(parentID) + ","
		parentPath = strings.ReplaceAll(parentPath, ",,", ",")
	}

	if id == 0 {
		arg := &db.CreateSysMenuParams{
			Name:        name,
			DisplayName: dispalyName,
			Url:         url,
			Type:        t,
			ParentID:    int32(parentID),
			ParentPath:  parentPath,
			Avatar:      avatar,
			Style:       style,
			Visible:     visible,
			IsList:      isList,
			Status:      int32(status),
			Sort:        int32(sort),
			CreatedAt:   time.Now(),
			UpdatedAt:   time.Now(),
		}
		_, err := systemservice.CreateSysMenu(ctx, arg)
		if err != nil {
			if db.IsUniqueViolation(err) {
				tpl.JSON(w, tpl.Response{Success: false, Message: "菜单已存在"})
				return
			}
			tpl.JSON(w, tpl.Response{Success: false, Message: err.Error()})
			return
		}

		tpl.JSON(w, tpl.Response{Success: true, Message: "添加成功"})
	} else {
		res, err := systemservice.GetSysMenu(ctx, int32(id))
		if err != nil {
			tpl.JSON(w, tpl.Response{Success: false, Message: err.Error()})
			return
		}

		arg := &db.UpdateSysMenuParams{
			ID:          res.ID,
			Name:        name,
			DisplayName: dispalyName,
			Url:         url,
			Type:        t,
			ParentID:    int32(parentID),
			ParentPath:  parentPath,
			Avatar:      avatar,
			Style:       style,
			Visible:     visible,
			IsList:      isList,
			Status:      int32(status),
			Sort:        int32(sort),
			UpdatedAt:   time.Now(),
		}
		_, err = systemservice.UpdateSysMenu(ctx, arg)
		if err != nil {
			tpl.JSON(w, tpl.Response{Success: false, Message: err.Error()})
			return
		}

		tpl.JSON(w, tpl.Response{Success: true, Message: "更新成功"})
	}
}

func (h *SysMenuHandler) UserMenus(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	b := session.GetBytes(ctx, auth.StoreName)
	var u dto.AuthorizeUser
	if err := json.Unmarshal(b, &u); err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	menus, err := systemservice.RecursiveSysMenus(ctx, u.RoleID)
	if err != nil {
		tpl.JSON(w, tpl.Response{Success: false, Message: err.Error()})
		return
	}

	tpl.JSON(w, menus)
}

func (h *SysMenuHandler) XmSelectTree(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	res, err := systemservice.ToTreeMenu(ctx, 0, false)
	if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
	}
	tpl.JSON(w, res)
}

func (h *SysMenuHandler) Refresh(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	err := systemservice.RefreshMenus(ctx)
	if err != nil {
		tpl.JSON(w, tpl.Response{Success: false, Message: err.Error()})
		return
	}

	tpl.JSON(w, tpl.Response{Success: true, Message: "刷新成功"})
}