projectx/internal/erpserver/handler/system/role.go

package system

import (
	"net/http"
	"strings"

	"management/internal/erpserver/handler"
	"management/internal/erpserver/model/dto"
	"management/internal/erpserver/model/form"
	"management/internal/erpserver/model/system"
	v1 "management/internal/erpserver/service/v1"
	"management/internal/erpserver/templ/system/role"
	"management/internal/pkg/binding"
	"management/internal/pkg/convertor"
	"management/internal/pkg/render"
)

type RoleHandler struct {
	*handler.Handler
	roleService v1.RoleService
	menuService v1.MenuService
}

func NewRoleHandler(handler *handler.Handler, roleService v1.RoleService, menuService v1.MenuService) *RoleHandler {
	return &RoleHandler{
		Handler:     handler,
		roleService: roleService,
		menuService: menuService,
	}
}

func (h *RoleHandler) List(w http.ResponseWriter, r *http.Request) {
	switch r.Method {
	case http.MethodGet:
		ctx := r.Context()
		h.Render(ctx, w, role.List(ctx))
		//h.HTML(w, r, "role/list.tmpl", nil)
	case http.MethodPost:
		var q dto.SearchDto
		q.SearchTimeBegin, q.SearchTimeEnd = convertor.DefaultStartTimeAndEndTime(r.PostFormValue("timeBegin"), r.PostFormValue("timeEnd"))
		q.SearchStatus = convertor.ConvertInt(r.PostFormValue("status"), 9999)
		q.SearchParentID = convertor.ConvertInt(r.PostFormValue("parentId"), 0)
		q.SearchName = r.PostFormValue("name")
		q.SearchID = convertor.ConvertInt[int64](r.PostFormValue("id"), 0)
		q.Page = convertor.ConvertInt(r.PostFormValue("page"), 1)
		q.Rows = convertor.ConvertInt(r.PostFormValue("rows"), 10)
		res, count, err := h.roleService.List(r.Context(), q)
		if err != nil {
			h.JSONErr(w, err.Error())
			return
		}

		data := render.ResponseList{
			Code:    0,
			Message: "ok",
			Count:   count,
			Data:    res,
		}
		h.JSON(w, data)
	default:
		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
	}
}

func (h *RoleHandler) Add(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	h.Render(ctx, w, role.Edit(ctx, &system.Role{Sort: 6666}))
	//h.HTML(w, r, "role/edit.tmpl", map[string]any{
	//	"Item": &system.Role{Sort: 6666},
	//})
}

func (h *RoleHandler) AddChildren(w http.ResponseWriter, r *http.Request) {
	vars := r.URL.Query()
	parentID := convertor.QueryInt[int32](vars, "parentID", 0)
	vm := &system.Role{ParentID: parentID, Sort: 6666}
	ctx := r.Context()
	h.Render(ctx, w, role.Edit(ctx, vm))
	//h.HTML(w, r, "role/edit.tmpl", map[string]any{
	//	"Item": vm,
	//})
}

func (h *RoleHandler) Edit(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	vars := r.URL.Query()
	id := convertor.QueryInt[int32](vars, "id", 0)
	vm := &system.Role{Sort: 6666}
	if id > 0 {
		vm, _ = h.roleService.Get(ctx, id)
	}
	h.Render(ctx, w, role.Edit(ctx, vm))
	//h.HTML(w, r, "role/edit.tmpl", map[string]any{
	//	"Item": vm,
	//})
}

func (h *RoleHandler) Save(w http.ResponseWriter, r *http.Request) {
	var req form.Role
	if err := binding.Form.Bind(r, &req); err != nil {
		h.JSONErr(w, binding.ValidatorErrors(err))
		return
	}

	ctx := r.Context()
	if *req.ID == 0 {
		err := h.roleService.Create(ctx, &req)
		if err != nil {
			h.JSONErr(w, err.Error())
			return
		}
		h.JSONOk(w, "添加成功")
	} else {
		err := h.roleService.Update(ctx, &req)
		if err != nil {
			h.JSONErr(w, err.Error())
			return
		}
		h.JSONOk(w, "更新成功")
	}
}

func (h *RoleHandler) Data(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	vars := r.URL.Query()
	t := vars.Get("type")
	if t == "tree" {
		res, err := h.roleService.Tree(ctx, 0)
		if err != nil {
			h.JSONErr(w, err.Error())
			return
		}
		h.JSON(w, res)
	} else if t == "xm_select_tree" {
		res, err := h.roleService.XmSelectTree(ctx, 0)
		if err != nil {
			h.JSONErr(w, err.Error())
			return
		}
		h.JSON(w, res)
	}
}

func (h *RoleHandler) RefreshCache(w http.ResponseWriter, r *http.Request) {
	err := h.roleService.RefreshCache(r.Context())
	if err != nil {
		h.JSONErr(w, err.Error())
		return
	}

	h.JSONOk(w, "缓存刷新成功")
}

func (h *RoleHandler) RebuildParentPath(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()
	err := h.roleService.RebuildParentPath(ctx)
	if err != nil {
		h.JSONErr(w, err.Error())
		return
	}

	h.JSONOk(w, "重建成功")
}

func (h *RoleHandler) RefreshRoleMenus(w http.ResponseWriter, r *http.Request) {
	ctx := r.Context()

	// 获取需要刷新的角色ID
	roleID := convertor.ConvertInt[int32](r.PostFormValue("roleID"), 0)
	roleModel, err := h.roleService.Get(ctx, roleID)
	if err != nil {
		h.JSONErr(w, err.Error())
		return
	}
	if roleModel == nil {
		h.JSONErr(w, "角色不存在")
		return
	}

	// 刷新角色菜单 (角色所拥有的菜单集合)
	_, err = h.menuService.SetListByRoleID(ctx, roleModel.ID)
	if err != nil {
		h.JSONErr(w, err.Error())
		return
	}

	// 刷新角色菜单 (角色所拥有的菜单集合)
	_, err = h.menuService.SetListByRoleIDToMap(ctx, roleModel.ID)
	if err != nil {
		h.JSONErr(w, err.Error())
		return
	}

	// 刷新角色菜单树 (pear admin layui 使用的格式)
	_, err = h.menuService.SetOwerMenus(ctx, roleModel.ID)
	if err != nil {
		h.JSONErr(w, err.Error())
		return
	}

	h.JSONOk(w, "刷新成功")
}

func (h *RoleHandler) SetMenu(w http.ResponseWriter, r *http.Request) {
	switch r.Method {
	case http.MethodGet:
		vars := r.URL.Query()
		id := convertor.QueryInt[int32](vars, "id", 0)
		vm := struct {
			Role  *system.Role
			Menus []*dto.SetMenuDto
		}{}
		if id > 0 {
			ctx := r.Context()
			var err error
			vm.Role, err = h.roleService.Get(ctx, id)
			if err == nil {
				vm.Menus, _ = h.menuService.MenuViewData(ctx, vm.Role.ID)
			}
		}

		h.HTML(w, r, "role/set_menu.tmpl", map[string]any{
			"Item": vm,
		})
	case http.MethodPost:
		ctx := r.Context()
		id := convertor.ConvertInt[int32](r.PostFormValue("ID"), 0)
		if id == 0 {
			h.JSONErr(w, "角色异常, 请刷新重试")
			return
		}
		roleModel, err := h.roleService.Get(ctx, id)
		if err != nil {
			h.JSONErr(w, err.Error())
			return
		}

		menus := r.PostFormValue("roleMenu")
		if len(menus) == 0 {
			h.JSONErr(w, "请选择菜单")
			return
		}
		menuArr := strings.Split(menus, ",")
		if len(menuArr) == 0 {
			h.JSONErr(w, "请选择菜单")
			return
		}

		var rms []*system.RoleMenu
		for _, v := range menuArr {
			menuID := convertor.ConvertInt(v, 0)
			if menuID > 0 {
				menu, err := h.menuService.Get(ctx, int32(menuID))
				if err != nil {
					h.JSONErr(w, err.Error())
					return
				}

				rms = append(rms, &system.RoleMenu{
					RoleID: roleModel.ID,
					MenuID: menu.ID,
				})
			}
		}

		if len(rms) == 0 {
			h.JSONErr(w, "请选择正确的菜单")
			return
		}

		err = h.menuService.SetRoleMenu(ctx, id, rms)
		if err != nil {
			h.JSONErr(w, err.Error())
			return
		}

		h.JSONOk(w, "设置成功")
	default:
		http.Error(w, "Method Not Allowed", http.StatusMethodNotAllowed)
	}
}