first commit

internal/service/system/auth.go

@@ -0,0 +1 @@
+package system

internal/service/system/sys_audit_log.go

@@ -0,0 +1,59 @@
+package system
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"management/internal/db/model/dto"
+	db "management/internal/db/sqlc"
+)
+
+func CreateSysAuditLog(ctx context.Context, arg *db.CreateSysAuditLogParams) error {
+	return db.Engine.CreateSysAuditLog(ctx, arg)
+}
+
+func ListSysAuditLog(ctx context.Context, q dto.SearchDto) ([]*db.SysAuditLog, int64, error) {
+	start, err := time.ParseInLocation(time.DateTime, q.SearchTimeBegin, time.Local)
+	if err != nil {
+		return nil, 0, err
+	}
+	end, err := time.ParseInLocation(time.DateTime, q.SearchTimeEnd, time.Local)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	countArg := &db.CountSysAuditLogConditionParams{
+		StartAt: start,
+		EndAt:   end,
+	}
+
+	dataArg := &db.ListSysAuditLogConditionParams{
+		StartAt: start,
+		EndAt:   end,
+		Skip:    (int32(q.Page) - 1) * int32(q.Rows),
+		Size:    int32(q.Rows),
+	}
+
+	if len(q.SearchKey) > 0 {
+		switch strings.ToLower(q.SearchName) {
+		case "email":
+			countArg.Email = q.SearchKey
+			dataArg.Email = q.SearchKey
+		case "username":
+			countArg.Username = q.SearchKey
+			dataArg.Username = q.SearchKey
+		}
+	}
+	count, err := db.Engine.CountSysAuditLogCondition(ctx, countArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	audits, err := db.Engine.ListSysAuditLogCondition(ctx, dataArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return audits, count, nil
+}

internal/service/system/sys_config.go

@@ -0,0 +1,72 @@
+package system
+
+import (
+	"context"
+	"encoding/json"
+	"time"
+
+	"management/internal/db/model/dto"
+	db "management/internal/db/sqlc"
+	"management/internal/global/keys"
+	"management/internal/global/pearadmin"
+	"management/internal/pkg/redis"
+)
+
+func CreateSysConfig(ctx context.Context, arg *db.CreateSysConfigParams) error {
+	return db.Engine.CreateSysConfig(ctx, arg)
+}
+
+func UpdateSysConfigByKey(ctx context.Context, arg *db.UpdateSysConfigByKeyParams) error {
+	return db.Engine.UpdateSysConfigByKey(ctx, arg)
+}
+
+func GetSysConfig(ctx context.Context, id int32) (*db.SysConfig, error) {
+	return db.Engine.GetSysConfig(ctx, id)
+}
+
+func GetSysConfigByKey(ctx context.Context, key string) (*db.SysConfig, error) {
+	return db.Engine.GetSysConfigByKey(ctx, key)
+}
+
+func PearConfig(ctx context.Context) (*dto.PearConfig, error) {
+	// 判断redis是否存储
+	key := keys.GetManageKey(ctx, keys.PearAdmin)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		var res *dto.PearConfig
+		if err := json.Unmarshal(b, &res); err == nil {
+			return res, nil
+		}
+	}
+
+	conf, err := db.Engine.GetSysConfigByKey(ctx, pearadmin.PearKey)
+	if err != nil {
+		return nil, err
+	}
+
+	var pear dto.PearConfig
+	if err := json.Unmarshal(conf.Value, &pear); err != nil {
+		return nil, err
+	}
+
+	_ = redis.Set(ctx, key, conf.Value, time.Hour*6)
+	return &pear, nil
+}
+
+func ListSysConfigCondition(ctx context.Context, q dto.SearchDto) ([]*db.SysConfig, int64, error) {
+	count, err := db.Engine.CountSysConfigCondition(ctx, q.SearchKey)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	configs, err := db.Engine.ListSysConfigCondition(ctx, &db.ListSysConfigConditionParams{
+		Key:  q.SearchKey,
+		Skip: (int32(q.Page) - 1) * int32(q.Rows),
+		Size: int32(q.Rows),
+	})
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return configs, count, nil
+}

internal/service/system/sys_department.go

@@ -0,0 +1,232 @@
+package system
+
+import (
+	"context"
+	"encoding/json"
+	"strconv"
+	"strings"
+	"time"
+
+	"management/internal/db/model/dto"
+	db "management/internal/db/sqlc"
+	"management/internal/global/keys"
+	"management/internal/pkg/redis"
+)
+
+func CreateSysDepartment(ctx context.Context, arg *db.CreateSysDepartmentParams) (*db.SysDepartment, error) {
+	return db.Engine.CreateSysDepartment(ctx, arg)
+}
+
+func UpdateSysDepartment(ctx context.Context, arg *db.UpdateSysDepartmentParams) (*db.SysDepartment, error) {
+	return db.Engine.UpdateSysDepartment(ctx, arg)
+}
+
+func GetSysDepartment(ctx context.Context, id int32) (*db.SysDepartment, error) {
+	return db.Engine.GetSysDepartment(ctx, id)
+}
+
+func AllCache(ctx context.Context) ([]*db.SysDepartment, error) {
+	key := keys.GetManageKey(ctx, keys.AllDepartments)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		var res []*db.SysDepartment
+		if err := json.Unmarshal(b, &res); err == nil {
+			return res, nil
+		}
+	}
+
+	all, err := db.Engine.AllSysDepartment(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	b, err = json.Marshal(all)
+	if err != nil {
+		return nil, err
+	}
+
+	_ = redis.Set(ctx, key, b, time.Hour*6)
+	return all, nil
+}
+
+func ListSysDepartmentCondition(ctx context.Context, q dto.SearchDto) ([]*db.SysDepartment, int64, error) {
+	countArg := &db.CountSysDepartmentConditionParams{
+		IsStatus:   q.SearchStatus != 9999,
+		Status:     int32(q.SearchStatus),
+		IsParentID: q.SearchParentID != 0,
+		ParentID:   int32(q.SearchParentID),
+	}
+
+	dataArg := &db.ListSysDepartmentConditionParams{
+		IsStatus:   q.SearchStatus != 9999,
+		Status:     int32(q.SearchStatus),
+		IsParentID: q.SearchParentID != 0,
+		ParentID:   int32(q.SearchParentID),
+		Skip:       (int32(q.Page) - 1) * int32(q.Rows),
+		Size:       int32(q.Rows),
+	}
+
+	if len(q.SearchKey) > 0 {
+		switch strings.ToLower(q.SearchName) {
+		case "id":
+			id, err := strconv.Atoi(q.SearchKey)
+			if err == nil {
+				countArg.IsID = true
+				countArg.ID = int32(id)
+
+				dataArg.IsID = true
+				dataArg.ID = int32(id)
+			}
+		case "name":
+			countArg.Name = q.SearchKey
+			dataArg.Name = q.SearchKey
+		}
+	}
+	count, err := db.Engine.CountSysDepartmentCondition(ctx, countArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	departs, err := db.Engine.ListSysDepartmentCondition(ctx, dataArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return departs, count, nil
+}
+
+func ListTreeSysDepartment(ctx context.Context) ([]*db.SysDepartmentDto, error) {
+	all, err := db.Engine.ListSysDepartment(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return ToDtoTreeSysDepartment(0, all), nil
+}
+
+func DTreeSysDepartment(ctx context.Context, id int32) ([]*dto.DTreeDto, error) {
+	all, err := db.Engine.AllSysDepartment(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return toDtree(id, all), nil
+}
+
+func RebuildSysDepartmentParentPath(ctx context.Context) error {
+	return db.Engine.SysDepartmentRebuildPath(ctx)
+}
+
+func toDtree(parentId int32, data []*db.SysDepartment) []*dto.DTreeDto {
+	var res []*dto.DTreeDto
+	for _, v := range data {
+		if v.ParentID == parentId {
+			item := dto.DTreeDto{}
+			item.ID = strconv.FormatInt(int64(v.ID), 10)
+			item.Title = v.Name
+			item.Last = !hasChildren(v.ID, data)
+			item.ParentId = strconv.FormatInt(int64(v.ParentID), 10)
+			item.Children = toDtree(v.ID, data)
+			res = append(res, &item)
+		}
+	}
+
+	return res
+}
+
+func hasChildren(parentId int32, data []*db.SysDepartment) bool {
+	if len(data) > 0 {
+		for _, v := range data {
+			if v.ParentID == parentId {
+				return true
+			}
+		}
+	}
+
+	return false
+}
+
+func ToTreeSysDepartment(ctx context.Context, id int, isRoot bool) ([]*dto.TreeDto, error) {
+	all, err := db.Engine.AllSysDepartment(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	if isRoot {
+		root := getSysDepartmentRootParentId(int32(id), all)
+		if root == nil {
+			root = &dto.TreeDto{
+				ID:    0,
+				Title: "根节点",
+			}
+		}
+
+		root.Children = toDtoTreeSysDepartment(int32(id), all)
+		return []*dto.TreeDto{root}, nil
+	}
+
+	return toDtoTreeSysDepartment(int32(id), all), nil
+}
+
+func RefreshSysDepartment(ctx context.Context) error {
+	all, err := db.Engine.AllSysDepartment(ctx)
+	if err != nil {
+		return err
+	}
+
+	b, err := json.Marshal(all)
+	if err != nil {
+		return err
+	}
+
+	key := keys.GetManageKey(ctx, keys.AllDepartments)
+	err = redis.Set(ctx, key, b, time.Hour*6)
+	return err
+}
+
+func getSysDepartmentRootParentId(parentId int32, data []*db.SysDepartment) *dto.TreeDto {
+	for _, v := range data {
+		if v.ID == parentId {
+			return &dto.TreeDto{
+				ID:    int(v.ID),
+				Title: v.Name,
+			}
+		}
+	}
+	return nil
+}
+
+func ToDtoTreeSysDepartment(parentId int32, data []*db.SysDepartment) []*db.SysDepartmentDto {
+	var res []*db.SysDepartmentDto
+	for _, v := range data {
+		if v.ParentID == parentId {
+			item := db.SysDepartmentDto{}
+			item.ID = v.ID
+			item.Name = v.Name
+			item.ParentID = v.ParentID
+			item.ParentPath = v.ParentPath
+			item.Status = v.Status
+			item.CreatedAt = v.CreatedAt
+			item.UpdatedAt = v.UpdatedAt
+			item.Children = ToDtoTreeSysDepartment(v.ID, data)
+			res = append(res, &item)
+		}
+	}
+
+	return res
+}
+
+func toDtoTreeSysDepartment(parentId int32, data []*db.SysDepartment) []*dto.TreeDto {
+	var res []*dto.TreeDto
+	for _, v := range data {
+		if v.ParentID == parentId {
+			item := dto.TreeDto{}
+			item.ID = int(v.ID)
+			item.Title = v.Name
+			item.Children = toDtoTreeSysDepartment(v.ID, data)
+			res = append(res, &item)
+		}
+	}
+
+	return res
+}

internal/service/system/sys_menu.go

@@ -0,0 +1,567 @@
+package system
+
+import (
+	"context"
+	"encoding/json"
+	"strconv"
+	"strings"
+	"time"
+
+	"management/internal/db/model/dto"
+	db "management/internal/db/sqlc"
+	"management/internal/global/keys"
+	"management/internal/pkg/redis"
+)
+
+func CreateSysMenu(ctx context.Context, arg *db.CreateSysMenuParams) (*db.SysMenu, error) {
+	return db.Engine.CreateSysMenu(ctx, arg)
+}
+
+func UpdateSysMenu(ctx context.Context, arg *db.UpdateSysMenuParams) (*db.SysMenu, error) {
+	return db.Engine.UpdateSysMenu(ctx, arg)
+}
+
+func GetSysMenu(ctx context.Context, id int32) (*db.SysMenu, error) {
+	return db.Engine.GetSysMenu(ctx, id)
+}
+
+func GetSysMenuByUrl(ctx context.Context, url string) (*db.SysMenu, error) {
+	return db.Engine.GetSysMenuByUrl(ctx, url)
+}
+
+func ListSysMenuByRoleID(ctx context.Context, roleID int32) ([]*db.SysMenu, error) {
+	return db.Engine.ListSysMenuByRoleID(ctx, roleID)
+}
+
+func AllMenusCache(ctx context.Context) ([]*db.SysMenu, error) {
+	key := keys.GetManageKey(ctx, keys.AllMenus)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		var res []*db.SysMenu
+		if err := json.Unmarshal(b, &res); err == nil {
+			return res, nil
+		}
+	}
+
+	all, err := db.Engine.AllSysMenu(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	b, err = json.Marshal(all)
+	if err != nil {
+		return nil, err
+	}
+
+	_ = redis.Set(ctx, key, b, time.Hour*6)
+	return all, nil
+}
+
+func ListMenuTree(ctx context.Context) ([]*db.SysMenuDto, error) {
+	all, err := AllMenusCache(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return toTreeSysMenu(0, all), nil
+}
+
+func ListMenuByRoles(ctx context.Context, roles []*db.SysRole) ([]*db.SysMenu, error) {
+	// 判断角色是否有vip
+	var vip bool
+	for _, item := range roles {
+		if item.Vip {
+			vip = true
+			break
+		}
+	}
+
+	var err error
+	var userMenus []*db.SysMenu
+	if vip {
+		userMenus, err = AllMenusCache(ctx)
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		for _, item := range roles {
+			ums, err := db.Engine.ListSysMenuByRoleID(ctx, item.ID)
+			if err != nil {
+				return nil, err
+			}
+			userMenus = append(userMenus, ums...)
+		}
+	}
+
+	return userMenus, nil
+}
+
+func IListMenuByUserID(ctx context.Context, userID int32) ([]*db.SysMenu, error) {
+	// 判断redis是否存储
+	key := keys.GetManageKey(ctx, keys.AdminMenus, userID)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		var res []*db.SysMenu
+		if err := json.Unmarshal(b, &res); err == nil {
+			return res, nil
+		}
+	}
+
+	return SetListMenuByUserID(ctx, userID)
+}
+
+func SetListMenuByUserID(ctx context.Context, userID int32) ([]*db.SysMenu, error) {
+	// 判断当前用户是否有vip角色
+	role, err := db.Engine.GetSysRoleByUserID(ctx, userID)
+	if err != nil {
+		return nil, err
+	}
+
+	var e error
+	var menus []*db.SysMenu
+	if role.Vip {
+		// vip 用户
+		menus, e = db.Engine.AllSysMenu(ctx)
+		if e != nil {
+			return nil, err
+		}
+
+	} else {
+		// not vip
+		menus, e = db.Engine.AllSysMenu(ctx) // db.Engine.ListSysMenuByUserID(ctx, userID)
+		if e != nil {
+			return nil, err
+		}
+	}
+
+	b, err := json.Marshal(menus)
+	if err != nil {
+		return nil, err
+	}
+
+	key := keys.GetManageKey(ctx, keys.AdminMenus, userID)
+	_ = redis.Set(ctx, key, b, time.Hour*6)
+	return menus, nil
+}
+
+func MapOwnerMenuByRoleID(ctx context.Context, roleID int32) (map[string]*dto.OwnerMenuDto, error) {
+	// 判断redis是否存储
+	key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		var res map[string]*dto.OwnerMenuDto
+		if err := json.Unmarshal(b, &res); err == nil {
+			return res, nil
+		}
+	}
+
+	return SetOwnerMapMenuByRoleID(ctx, roleID)
+}
+
+func ListOwnerMenuByRoleID(ctx context.Context, roleID int32) ([]*dto.OwnerMenuDto, error) {
+	// 判断redis是否存储
+	key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		var res []*dto.OwnerMenuDto
+		if err := json.Unmarshal(b, &res); err == nil {
+			return res, nil
+		}
+	}
+
+	return SetOwnerListMenuByRoleID(ctx, roleID)
+}
+
+func ownerMenusByRoleID(ctx context.Context, roleID int32) ([]*db.SysMenu, error) {
+	// 判断当前用户是否有vip角色
+	role, err := db.Engine.GetSysRole(ctx, roleID)
+	if err != nil {
+		return nil, err
+	}
+
+	var e error
+	var menus []*db.SysMenu
+	if role.Vip {
+		// vip 用户
+		menus, e = db.Engine.AllSysMenu(ctx)
+		if e != nil {
+			return nil, err
+		}
+
+	} else {
+		// not vip
+		menus, e = db.Engine.ListSysMenuByRoleID(ctx, roleID)
+		if e != nil {
+			return nil, err
+		}
+	}
+
+	return menus, nil
+}
+
+func SetOwnerListMenuByRoleID(ctx context.Context, roleID int32) ([]*dto.OwnerMenuDto, error) {
+	menus, err := ownerMenusByRoleID(ctx, roleID)
+	if err != nil {
+		return nil, err
+	}
+
+	var res []*dto.OwnerMenuDto
+	for _, menu := range menus {
+		res = append(res, &dto.OwnerMenuDto{
+			ID:          menu.ID,
+			DisplayName: menu.DisplayName,
+			Url:         menu.Url,
+			ParentID:    menu.ParentID,
+			Avatar:      menu.Avatar,
+			Style:       menu.Style,
+			IsList:      menu.IsList,
+		})
+	}
+
+	b, err := json.Marshal(res)
+	if err != nil {
+		return nil, err
+	}
+
+	key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
+	_ = redis.Set(ctx, key, b, time.Hour*6)
+	return res, nil
+}
+
+func SetOwnerMapMenuByRoleID(ctx context.Context, roleID int32) (map[string]*dto.OwnerMenuDto, error) {
+	result := make(map[string]*dto.OwnerMenuDto)
+	menus, err := ownerMenusByRoleID(ctx, roleID)
+	if err != nil {
+		return result, err
+	}
+
+	for _, menu := range menus {
+		result[menu.Url] = &dto.OwnerMenuDto{
+			ID:          menu.ID,
+			DisplayName: menu.DisplayName,
+			Url:         menu.Url,
+			ParentID:    menu.ParentID,
+			Avatar:      menu.Avatar,
+			Style:       menu.Style,
+			IsList:      menu.IsList,
+		}
+	}
+
+	b, err := json.Marshal(result)
+	if err != nil {
+		return nil, err
+	}
+
+	key := keys.GetManageKey(ctx, keys.OwnerMenus, roleID)
+	_ = redis.Set(ctx, key, b, time.Hour*6)
+	return result, nil
+}
+
+// RecursiveSysMenus 递归查询菜单 (pear layui 展示菜单的格式)
+func RecursiveSysMenus(ctx context.Context, roleID int32) ([]*dto.MenuUIDto, error) {
+	// 判断redis是否存储
+	key := keys.GetManageKey(ctx, keys.RecursiveMenus, roleID)
+	b, err := redis.GetBytes(ctx, key)
+	if err == nil {
+		var res []*dto.MenuUIDto
+		if err := json.Unmarshal(b, &res); err == nil {
+			return res, nil
+		}
+	}
+
+	return SetRecursiveSysMenus(ctx, roleID)
+}
+
+func SetRecursiveSysMenus(ctx context.Context, roleID int32) ([]*dto.MenuUIDto, error) {
+	// 判断当前用户是否有vip角色
+	role, err := db.Engine.GetSysRole(ctx, roleID)
+	if err != nil {
+		return nil, err
+	}
+
+	var menus []*db.SysMenu
+	if role.Vip {
+		// vip 用户
+		all, err := db.Engine.RecursiveSysMenus(ctx)
+		if err != nil {
+			return nil, err
+		}
+		menus = convertToMenuUIDto(all)
+
+	} else {
+		// not vip
+		all, err := db.Engine.RecursiveSysMenusByRoleID(ctx, roleID)
+		if err != nil {
+			return nil, err
+		}
+		menus = convertToMenuUIDto2(all)
+	}
+	menuList := uniqueSysMenus(menus)
+	if len(menuList) == 0 {
+		return nil, nil
+	}
+
+	tree := convertToUITree(menuList, 0)
+	b, err := json.Marshal(tree)
+	if err != nil {
+		return nil, err
+	}
+
+	key := keys.GetManageKey(ctx, keys.RecursiveMenus, roleID)
+	_ = redis.Set(ctx, key, b, time.Hour*6)
+	return tree, nil
+}
+
+func convertToMenuUIDto(data []*db.RecursiveSysMenusRow) []*db.SysMenu {
+	var res []*db.SysMenu
+
+	for _, item := range data {
+		temp := &db.SysMenu{
+			ID:          item.ID,
+			Name:        item.Name,
+			DisplayName: item.DisplayName,
+			Url:         item.Url,
+			Type:        item.Type,
+			ParentID:    item.ParentID,
+			ParentPath:  item.ParentPath,
+			Avatar:      item.Avatar,
+			Style:       item.Style,
+			Visible:     item.Visible,
+			IsList:      item.IsList,
+			Status:      item.Status,
+			Sort:        item.Sort,
+			CreatedAt:   item.CreatedAt,
+			UpdatedAt:   item.UpdatedAt,
+		}
+		res = append(res, temp)
+	}
+
+	return res
+}
+
+func convertToMenuUIDto2(data []*db.RecursiveSysMenusByRoleIDRow) []*db.SysMenu {
+	var res []*db.SysMenu
+
+	for _, item := range data {
+		temp := &db.SysMenu{
+			ID:          item.ID,
+			Name:        item.Name,
+			DisplayName: item.DisplayName,
+			Url:         item.Url,
+			Type:        item.Type,
+			ParentID:    item.ParentID,
+			ParentPath:  item.ParentPath,
+			Avatar:      item.Avatar,
+			Style:       item.Style,
+			Visible:     item.Visible,
+			IsList:      item.IsList,
+			Status:      item.Status,
+			Sort:        item.Sort,
+			CreatedAt:   item.CreatedAt,
+			UpdatedAt:   item.UpdatedAt,
+		}
+		res = append(res, temp)
+	}
+
+	return res
+}
+
+func convertToUITree(data []*db.SysMenu, parentID int32) []*dto.MenuUIDto {
+	var root []*dto.MenuUIDto
+	for _, item := range data {
+		if item.ParentID == parentID {
+			if item.IsList {
+				temp := &dto.MenuUIDto{
+					ID:       strings.ToLower(item.Url),
+					Title:    item.DisplayName,
+					Icon:     item.Avatar,
+					Type:     1,
+					OpenType: "_iframe",
+					Href:     item.Url,
+				}
+				root = append(root, temp)
+			} else {
+				temp := &dto.MenuUIDto{
+					ID:    strconv.Itoa(int(item.ID)),
+					Title: item.DisplayName,
+					Icon:  item.Avatar,
+					Type:  0,
+				}
+				temp.Children = convertToUITree(data, item.ID)
+				root = append(root, temp)
+			}
+		}
+	}
+	return root
+}
+
+func uniqueSysMenus(sm []*db.SysMenu) []*db.SysMenu {
+	res := make([]*db.SysMenu, 0) // 返回的新切片
+	m1 := make(map[int32]byte)    // 用来去重的临时map
+	for _, v := range sm {
+		if _, ok := m1[v.ID]; !ok {
+			m1[v.ID] = 1
+			res = append(res, v)
+		}
+	}
+	return res
+}
+
+func ToTreeMenu(ctx context.Context, id int, hasRoot bool) ([]*dto.TreeDto, error) {
+	all, err := AllMenusCache(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	if hasRoot {
+		root := getSysMenuRootParentId(int32(id), all)
+		if root == nil {
+			root = &dto.TreeDto{
+				ID:    0,
+				Title: "根节点",
+			}
+		}
+
+		root.Children = toDtoTreeSysMenu(int32(id), all)
+		return []*dto.TreeDto{root}, nil
+	}
+
+	return toDtoTreeSysMenu(int32(id), all), nil
+}
+
+func RefreshMenus(ctx context.Context) error {
+	key := keys.GetManageKey(ctx, keys.AllMenus)
+	all, err := db.Engine.AllSysMenu(ctx)
+	if err != nil {
+		return err
+	}
+
+	b, err := json.Marshal(all)
+	if err != nil {
+		return err
+	}
+
+	err = redis.Set(ctx, key, b, time.Hour*6)
+	return err
+}
+
+func getSysMenuRootParentId(parentId int32, data []*db.SysMenu) *dto.TreeDto {
+	for _, v := range data {
+		if v.ID == parentId {
+			return &dto.TreeDto{
+				ID:    int(v.ID),
+				Title: v.Name,
+			}
+		}
+	}
+	return nil
+}
+
+func toTreeSysMenu(parentId int32, data []*db.SysMenu) []*db.SysMenuDto {
+	var res []*db.SysMenuDto
+	for _, v := range data {
+		if v.ParentID == parentId {
+			item := db.SysMenuDto{}
+			item.ID = v.ID
+			item.Name = v.Name
+			item.DisplayName = v.DisplayName
+			item.Url = v.Url
+			item.Type = v.Type
+			item.ParentID = v.ParentID
+			item.ParentPath = v.ParentPath
+			item.Avatar = v.Avatar
+			item.Style = v.Style
+			item.Visible = v.Visible
+			item.IsList = v.IsList
+			item.Status = v.Status
+			item.Sort = v.Sort
+			item.CreatedAt = v.CreatedAt
+			item.UpdatedAt = v.UpdatedAt
+			item.Children = toTreeSysMenu(v.ID, data)
+			res = append(res, &item)
+		}
+	}
+
+	return res
+}
+
+func toDtoTreeSysMenu(parentId int32, data []*db.SysMenu) []*dto.TreeDto {
+	var res []*dto.TreeDto
+	for _, v := range data {
+		if v.ParentID == parentId {
+			item := dto.TreeDto{}
+			item.ID = int(v.ID)
+			item.Title = v.Name
+			item.Children = toDtoTreeSysMenu(v.ID, data)
+			res = append(res, &item)
+		}
+	}
+
+	return res
+}
+
+func SetMenuViewData(ctx context.Context, roleID int32) ([]*dto.SetMenuDto, error) {
+	// 获取该用户已经有的权限
+	hs, err := db.Engine.ListSysMenuIDByRoleID(ctx, roleID)
+	if err != nil {
+		return nil, err
+	}
+
+	all, err := AllMenusCache(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return toSetMenuTree(all, hs, 0), nil
+}
+
+func toSetMenuTree(data []*db.SysMenu, ids []int32, parentID int32) []*dto.SetMenuDto {
+	var res []*dto.SetMenuDto
+	for _, v := range data {
+		if v.ParentID == parentID {
+			isSelect := hasValueInArray(ids, v.ID)
+			if v.IsList {
+				item := dto.SetMenuDto{
+					ID:       v.ID,
+					Name:     v.DisplayName,
+					Link:     v.Type,
+					IsList:   v.IsList,
+					IsSelect: isSelect,
+				}
+				item.Items = []*dto.SetMenuDto{
+					{
+						ID:       v.ID,
+						Name:     "列表",
+						Link:     "btn",
+						IsList:   false,
+						IsSelect: isSelect,
+						Items:    toSetMenuTree(data, ids, v.ID),
+					},
+				}
+				item.Items = append(item.Items, toSetMenuTree(data, ids, v.ID)...)
+				res = append(res, &item)
+			} else {
+				item := dto.SetMenuDto{
+					ID:       v.ID,
+					Name:     v.DisplayName,
+					Link:     v.Type,
+					IsList:   v.IsList,
+					IsSelect: isSelect,
+					Items:    toSetMenuTree(data, ids, v.ID),
+				}
+				res = append(res, &item)
+			}
+		}
+	}
+
+	return res
+}
+
+func hasValueInArray(data []int32, id int32) bool {
+	for _, v := range data {
+		if id == v {
+			return true
+		}
+	}
+	return false
+}

internal/service/system/sys_role.go

@@ -0,0 +1,165 @@
+package system
+
+import (
+	"context"
+	"encoding/json"
+	"strconv"
+	"strings"
+	"time"
+
+	"management/internal/db/model/dto"
+	db "management/internal/db/sqlc"
+	"management/internal/global/keys"
+	"management/internal/pkg/redis"
+)
+
+func CreateSysRole(ctx context.Context, arg *db.CreateSysRoleParams) (*db.SysRole, error) {
+	return db.Engine.CreateSysRole(ctx, arg)
+}
+
+func UpdateSysRole(ctx context.Context, arg *db.UpdateSysRoleParams) (*db.SysRole, error) {
+	return db.Engine.UpdateSysRole(ctx, arg)
+}
+
+func GetSysRole(ctx context.Context, id int32) (*db.SysRole, error) {
+	return db.Engine.GetSysRole(ctx, id)
+}
+
+func ListSysRoleCondition(ctx context.Context, q dto.SearchDto) ([]*db.SysRole, int64, error) {
+	countArg := &db.CountSysRoleConditionParams{
+		IsStatus:   q.SearchStatus != 9999,
+		Status:     int32(q.SearchStatus),
+		IsParentID: q.SearchParentID != 0,
+		ParentID:   int32(q.SearchParentID),
+	}
+
+	dataArg := &db.ListSysRoleConditionParams{
+		IsStatus:   q.SearchStatus != 9999,
+		Status:     int32(q.SearchStatus),
+		IsParentID: q.SearchParentID != 0,
+		ParentID:   int32(q.SearchParentID),
+		Skip:       (int32(q.Page) - 1) * int32(q.Rows),
+		Size:       int32(q.Rows),
+	}
+
+	if len(q.SearchKey) > 0 {
+		switch strings.ToLower(q.SearchName) {
+		case "id":
+			id, err := strconv.Atoi(q.SearchKey)
+			if err == nil {
+				countArg.IsID = true
+				countArg.ID = int32(id)
+
+				dataArg.IsID = true
+				dataArg.ID = int32(id)
+			}
+		case "name":
+			countArg.DisplayName = q.SearchKey
+			dataArg.DisplayName = q.SearchKey
+		}
+	}
+	count, err := db.Engine.CountSysRoleCondition(ctx, countArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	roles, err := db.Engine.ListSysRoleCondition(ctx, dataArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return roles, count, nil
+}
+
+func XmSelectSysRole(ctx context.Context) ([]*dto.XmSelectDto, error) {
+	all, err := db.Engine.AllSysRole(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	var res []*dto.XmSelectDto
+	for _, item := range all {
+		res = append(res, &dto.XmSelectDto{Name: item.DisplayName, Value: int(item.ID)})
+	}
+
+	return res, nil
+}
+
+func SetMenu(ctx context.Context, roleID int32, menus []*db.SysMenu) error {
+	return db.Engine.ExecTx(ctx, func(q *db.Queries) error {
+		err := db.Engine.DeleteRoleMneuByRoleID(ctx, roleID)
+		if err != nil {
+			return err
+		}
+
+		for _, m := range menus {
+			err := db.Engine.CreateRoleMenu(ctx, &db.CreateRoleMenuParams{
+				RoleID: roleID,
+				MenuID: m.ID,
+			})
+			if err != nil {
+				return err
+			}
+		}
+
+		return nil
+	})
+}
+
+func DTreeSysRole(ctx context.Context, id int32) ([]*dto.DTreeDto, error) {
+	all, err := db.Engine.AllSysRole(ctx)
+	if err != nil {
+		return nil, err
+	}
+
+	return toDtreeSysRole(id, all), nil
+}
+
+func RefreshSysRole(ctx context.Context) error {
+	all, err := db.Engine.AllSysRole(ctx)
+	if err != nil {
+		return err
+	}
+
+	b, err := json.Marshal(all)
+	if err != nil {
+		return err
+	}
+
+	key := keys.GetManageKey(ctx, keys.AllRoles)
+	err = redis.Set(ctx, key, b, time.Hour*6)
+	return err
+}
+
+func RebuildSysRoleParentPath(ctx context.Context) error {
+	return db.Engine.SysRoleRebuildPath(ctx)
+}
+
+func toDtreeSysRole(parentId int32, data []*db.SysRole) []*dto.DTreeDto {
+	var res []*dto.DTreeDto
+	for _, v := range data {
+		if v.ParentID == parentId {
+			item := dto.DTreeDto{}
+			item.ID = strconv.FormatInt(int64(v.ID), 10)
+			item.Title = v.DisplayName
+			item.Last = !hasSysRoleChildren(v.ID, data)
+			item.ParentId = strconv.FormatInt(int64(v.ParentID), 10)
+			item.Children = toDtreeSysRole(v.ID, data)
+			res = append(res, &item)
+		}
+	}
+
+	return res
+}
+
+func hasSysRoleChildren(parentId int32, data []*db.SysRole) bool {
+	if len(data) > 0 {
+		for _, v := range data {
+			if v.ParentID == parentId {
+				return true
+			}
+		}
+	}
+
+	return false
+}

internal/service/system/sys_user.go

@@ -0,0 +1,48 @@
+package system
+
+import (
+	"context"
+
+	"management/internal/db/model/dto"
+	db "management/internal/db/sqlc"
+)
+
+func CreateSysUser(ctx context.Context, arg *db.CreateSysUserParams) (*db.SysUser, error) {
+	return db.Engine.CreateSysUser(ctx, arg)
+}
+
+func UpdateSysUser(ctx context.Context, arg *db.UpdateSysUserParams) (*db.SysUser, error) {
+	return db.Engine.UpdateSysUser(ctx, arg)
+}
+
+func GetSysUser(ctx context.Context, id int32) (*db.SysUser, error) {
+	return db.Engine.GetSysUser(ctx, id)
+}
+
+func GetSysUserByEmail(ctx context.Context, email string) (*db.SysUser, error) {
+	return db.Engine.GetSysUserByEmail(ctx, email)
+}
+
+func ListSysUserCondition(ctx context.Context, q dto.SearchDto) ([]*db.ListSysUserConditionRow, int64, error) {
+	count, err := db.Engine.CountSysUserCondition(ctx, &db.CountSysUserConditionParams{
+		IsStatus: q.SearchStatus != 9999,
+		Status:   int32(q.SearchStatus),
+		Username: q.SearchKey,
+	})
+	if err != nil {
+		return nil, 0, err
+	}
+
+	users, err := db.Engine.ListSysUserCondition(ctx, &db.ListSysUserConditionParams{
+		IsStatus: q.SearchStatus != 9999,
+		Status:   int32(q.SearchStatus),
+		Username: q.SearchKey,
+		Skip:     (int32(q.Page) - 1) * int32(q.Rows),
+		Size:     int32(q.Rows),
+	})
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return users, count, nil
+}

internal/service/system/sys_user_login_log.go

@@ -0,0 +1,59 @@
+package system
+
+import (
+	"context"
+	"strings"
+	"time"
+
+	"management/internal/db/model/dto"
+	db "management/internal/db/sqlc"
+)
+
+func CreateSysUserLoginLog(ctx context.Context, arg *db.CreateSysUserLoginLogParams) error {
+	return db.Engine.CreateSysUserLoginLog(ctx, arg)
+}
+
+func ListSysUserLoginLog(ctx context.Context, q dto.SearchDto) ([]*db.SysUserLoginLog, int64, error) {
+	start, err := time.ParseInLocation(time.DateTime, q.SearchTimeBegin, time.Local)
+	if err != nil {
+		return nil, 0, err
+	}
+	end, err := time.ParseInLocation(time.DateTime, q.SearchTimeEnd, time.Local)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	countArg := &db.CountSysUserLoginLogConditionParams{
+		StartAt: start,
+		EndAt:   end,
+	}
+
+	dataArg := &db.ListSysUserLoginLogConditionParams{
+		StartAt: start,
+		EndAt:   end,
+		Skip:    (int32(q.Page) - 1) * int32(q.Rows),
+		Size:    int32(q.Rows),
+	}
+
+	if len(q.SearchKey) > 0 {
+		switch strings.ToLower(q.SearchName) {
+		case "email":
+			countArg.Email = q.SearchKey
+			dataArg.Email = q.SearchKey
+		case "username":
+			countArg.Username = q.SearchKey
+			dataArg.Username = q.SearchKey
+		}
+	}
+	count, err := db.Engine.CountSysUserLoginLogCondition(ctx, countArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	logs, err := db.Engine.ListSysUserLoginLogCondition(ctx, dataArg)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	return logs, count, nil
+}