eta_api/services/system.go

package services

import (
	"encoding/json"
	"eta_gn/eta_api/global"
	"eta_gn/eta_api/models/system"
	"eta_gn/eta_api/services/third"
	"eta_gn/eta_api/utils"
	"fmt"
	"strconv"
	"time"
)

func GetRoleTypeCode(roleType string) string {
	var roleTypeCode string
	switch roleType {
	case utils.ROLE_TYPE_ADMIN:
		roleTypeCode = utils.ROLE_TYPE_CODE_ADMIN
	case utils.ROLE_TYPE_FICC_ADMIN:
		roleTypeCode = utils.ROLE_TYPE_CODE_FICC_ADMIN
	case utils.ROLE_TYPE_FICC_SELLER:
		roleTypeCode = utils.ROLE_TYPE_CODE_FICC_SELLER
	case utils.ROLE_TYPE_RAI_ADMIN:
		roleTypeCode = utils.ROLE_TYPE_CODE_RAI_ADMIN
	case utils.ROLE_TYPE_FICC_GROUP, utils.ROLE_TYPE_FICC_MANAGER:
		roleTypeCode = utils.ROLE_TYPE_CODE_FICC_GROUP
	case utils.ROLE_TYPE_RAI_GROUP:
		roleTypeCode = utils.ROLE_TYPE_CODE_RAI_GROUP
	case utils.ROLE_TYPE_FICC_DEPARTMENT:
		roleTypeCode = utils.ROLE_TYPE_CODE_FICC_DEPARTMENT
	case utils.ROLE_TYPE_RAI_DEPARTMENT:
		roleTypeCode = utils.ROLE_TYPE_CODE_RAI_DEPARTMENT
	case utils.ROLE_TYPE_FICC_RESEARCHR:
		roleTypeCode = utils.ROLE_TYPE_CODE_FICC_RESEARCHR
	case utils.ROLE_TYPE_RAI_RESEARCHR:
		roleTypeCode = utils.ROLE_TYPE_CODE_RAI_RESEARCHR
	default:
		roleTypeCode = utils.ROLE_TYPE_ADMIN
	}
	return roleTypeCode
}

type GroupNode struct {
	GroupId   int
	GroupName string
	Child     []*GroupNode
}

// GetMenuTreeRecursive 递归菜单树
func GetMenuTreeRecursive(list []*system.SysMenuItem, parentId int) []*system.SysMenuItem {
	res := make([]*system.SysMenuItem, 0)
	for _, v := range list {
		if v.ParentId == parentId {
			v.Children = GetMenuTreeRecursive(list, v.MenuId)
			res = append(res, v)
		}
	}
	return res
}

func BuildGroupTree(list []*system.SysGroupList, current, depth int, node *GroupNode) {
	if current == depth {
		utils.FileLog.Info("到达组织最深层,停止递归")
		return
	}
	for _, v := range list {
		if v.ParentId == node.GroupId {
			subNode := &GroupNode{
				GroupId:   v.GroupId,
				GroupName: v.GroupName,
				Child:     make([]*GroupNode, 0),
			}
			node.Child = append(node.Child, subNode)
			BuildGroupTree(list, current+1, depth, subNode)
		}
	}
}

func DeleteSysGroupByIds(ids []int) (err error) {
	tx := global.DEFAULT_DmSQL.Begin()
	defer func() {
		if err != nil {
			tx.Rollback()
		} else {
			tx.Commit()
		}
	}()
	err = system.DeleteSysGroupByIds(tx, ids)
	if err != nil {
		return
	}
	err = system.ClearSysUserGroupByIds(tx, ids)
	return
}

// BuildGroupTreeV2 构建分组树
func BuildGroupTreeV2(groups []*system.SysFullGroup, groupAdmins map[int][]*system.DepartmentUserTree) map[int][]*system.DepartmentUserTree {
	// 创建分组ID到节点的映射
	groupMap := make(map[int]*system.DepartmentUserTree)
	idList := make([]int, 0, len(groups))

	// 初始化所有节点，不管父子顺序
	for _, g := range groups {
		idList = append(idList, g.GroupId)
		node := &system.DepartmentUserTree{
			NodeId:   g.GroupId,
			NodeType: 2,
			NodeName: g.GroupName,
			Children: make([]*system.DepartmentUserTree, 0),
		}

		// 添加该分组的管理员
		if admins, ok := groupAdmins[g.GroupId]; ok {
			node.Children = append(node.Children, admins...)
		}

		groupMap[g.GroupId] = node
	}

	// 构建父子关系
	//rootNodes := make([]*system.DepartmentUserTree, 0)

	// 部门与分组的关系
	groupTree := make(map[int][]*system.DepartmentUserTree)

	for _, g := range groups {
		node := groupMap[g.GroupId]

		if g.ParentId == 0 || g.ParentId == -1 {
			// 如果是根节点
			//rootNodes = append(rootNodes, node)
			nodeList, ok := groupTree[g.DepartmentId]
			if !ok {
				nodeList = make([]*system.DepartmentUserTree, 0)
			}
			groupTree[g.DepartmentId] = append(nodeList, node)
		} else {
			// 如果是非根节点，找到父节点并添加到父节点的Children中
			parentNode, ok := groupMap[g.ParentId]
			if !ok {
				// 父节点不存在，继续处理下一个
				continue
			}
			parentNode.Children = append(parentNode.Children, node)
		}
	}

	return groupTree
}

// GetMenuList
// @Description: 获取菜单列表
// @author: Roc
// @datetime 2025-06-10 11:16:34
// @param token string
// @param roleId int
// @return items []*system.SysMenu
// @return err error
func GetMenuList(token string, roleId int) (items []*system.SysMenu, err error) {
	items = make([]*system.SysMenu, 0)
	if token == `` || utils.GnSciUserApiUrl == `` {
		// 没有token，那么就直接通过角色吧
		items, err = system.GetMenuButtonApisByRoleId(roleId)
		if err != nil {
			return
		}

		return
	}

	// 先从缓存里面获取，如果取不到，那么再去调用接口
	key := fmt.Sprintf("%s%s", utils.CACHE_USER_MENU, utils.MD5(token))
	menuJsonStr, tmpErr := utils.Rc.RedisString(key)
	if tmpErr == nil && menuJsonStr != `` {
		err = json.Unmarshal([]byte(menuJsonStr), &items)
		if err == nil {
			return
		}
	}

	resp, err := third.GetUserInfo(token)
	if err != nil {
		fmt.Println(err)
		return
	}

	if resp.Info.Resource != nil && len(resp.Info.Resource) > 0 {
		for _, v := range resp.Info.Resource {
			var nameEn, path, iconPath, component, levelPath, buttonCode, api string
			if v.NameEn != nil {
				nameEn = *v.NameEn
			}
			if v.PATH != nil {
				path = *v.PATH
			}
			if v.Icon != nil {
				iconPath = *v.Icon
			}
			if v.Component != nil {
				component = *v.Component
			}
			if v.LevelPath != nil {
				levelPath = *v.LevelPath
			}
			if v.ButtonCode != nil {
				buttonCode = *v.ButtonCode
			}
			if v.Api != nil {
				api = *v.Api
			}

			var menuType int
			if v.MenuType != `` {
				menuType, _ = strconv.Atoi(v.MenuType)
			}

			items = append(items, &system.SysMenu{
				MenuId:    v.MenuId,
				ParentId:  v.ParentId,
				Name:      v.MenuName,
				Sort:      fmt.Sprint(v.OrderNum),
				Path:      path,
				IconPath:  iconPath,
				Component: component,
				//Hidden:     v.Hi,
				IsLevel:    v.IsLevel,
				LevelPath:  levelPath,
				MenuType:   menuType,
				ButtonCode: buttonCode,
				//CreateTime: time.Time{},
				//ModifyTime: time.Time{},
				Api:    api,
				NameEn: nameEn,
			})
		}
	}

	// 30分钟缓存，避免多次调用接口获取数据
	menuJsonByte, tmpErr := json.Marshal(items)
	if tmpErr == nil {
		_ = utils.Rc.Put(key, menuJsonByte, 30*time.Minute)
	}

	return
}

type TopMenuItemResp struct {
	OrderNum int
	MenuId   int
	MenuName string
	IsFrame  int    ` description:"1左边，0右边"`
	Path     string `description:"跳转地址"`
}

// GetTopMenuList
// @Description: 获取顶部的菜单
// @author: Roc
// @datetime 2025-06-19 17:11:31
// @param userId int
// @return items []TopMenuItemResp
// @return err error
func GetTopMenuList(token string) (items []TopMenuItemResp, err error) {
	items = make([]TopMenuItemResp, 0)
	if utils.GnSciUserApiUrl == `` || token == `` {
		return
	}

	// 先从缓存里面获取，如果取不到，那么再去调用接口
	key := fmt.Sprintf("%s%d", utils.CACHE_SCI_TOP_MENU, utils.MD5(token))
	menuJsonStr, tmpErr := utils.Rc.RedisString(key)
	if tmpErr == nil && menuJsonStr != `` {
		err = json.Unmarshal([]byte(menuJsonStr), &items)
		if err == nil {
			return
		}
	}

	resp, err := third.GetTopMenuInfo(token)
	if err != nil {
		fmt.Println(err)
		return
	}

	if resp.Info != nil && len(resp.Info) > 0 {
		for _, v := range resp.Info {

			items = append(items, TopMenuItemResp{
				MenuId:   v.MenuId,
				MenuName: v.MenuName,
				IsFrame:  v.IsFrame,
				Path:     v.Path,
				OrderNum: v.OrderNum,
			})
		}
	}

	// 30分钟缓存，避免多次调用接口获取数据
	menuJsonByte, tmpErr := json.Marshal(items)
	if tmpErr == nil {
		_ = utils.Rc.Put(key, menuJsonByte, 30*time.Minute)
	}

	return
}