zhangzengfei
2023-11-28 3a706d3378aa3626501370352963883fd2783558
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
package service
 
import (
    "basic.com/valib/logger.git"
    "errors"
    "sort"
    "strings"
    "vamicro/extend/util"
    "vamicro/system-service/models"
    "vamicro/system-service/vo"
)
 
type SysMenuService struct {
 
}
 
func (sms *SysMenuService) Save(menu models.SysMenu) (bool,models.SysMenu){
    if menu.ParentId == "" || menu.ParentId == "0" {
        menu.ParentId = "0"
        menu.ParentIds= "0"
    } else {
        var pMenu models.SysMenu
 
        rows,_ := pMenu.SelectById(menu.ParentId)
        if rows > 0 {
            menu.ParentIds = pMenu.ParentIds+","+pMenu.Id
        } else {
            menu.ParentId = "0"
            menu.ParentIds= "0"
        }
    }
    if menu.Id == "" {
        menu.Id = util.PseudoUuid()
        if menu.Insert() {
            return true,menu
        } else {
            return false,menu
        }
    } else {
        if menu.Update() {
            return true,menu
        } else {
            return false,menu
        }
    }
}
 
/*
    默认应用可以具体到内部的按钮权限
    可选应用只控制到菜单的显示
*/
func (sms *SysMenuService) GetMenuTree(userId string, myMenuIds map[string]string) ([]vo.SysMenuTree,error) {
    var user models.SysUser
    rows, _ := user.SelectById(userId)
    if rows >0 {
        var menuE models.SysMenu
        allMenus := menuE.FindAll()
 
        var menuM = make(map[string]models.SysMenu, 0)
        if allMenus !=nil {
            for _,mu :=range allMenus {
                menuM[mu.Id] = mu
            }
        }
 
        var role models.SysRole
        roles := role.FindByUserId(user.Id)
        logger.Debug("len(roles):", len(roles))
        if roles !=nil && len(roles) >0 {
            var userMenus []models.SysMenu
            if roles[0].Name == "超级管理员" {
                userMenus = allMenus
            } else if roles[0].Name ==  "管理员" || roles[0].Name == "普通用户" {
                //查本人可以看到的菜单
                userMenus = menuE.FindByUserId(user.Id)
                if len(userMenus) == 0 {
                    userMenus = menuE.FindByRoleId(roles[0].Id)
                }
                //userMenus = allMenus
            }
            logger.Debug("len(userMenus):", len(userMenus))
            var uM = make(map[string]models.SysMenu,0)
            if len(userMenus) >0 {
                for _,srmE := range userMenus{
                    if _,ok :=uM[srmE.Id];!ok{
                        menuModel := menuM[srmE.Id]
                        uM[menuModel.Id] = menuModel
 
                        pidArr := strings.Split(menuModel.ParentIds, ",")
                        for _,pid :=range pidArr {
                            if pid !="" && pid !="0" {
                                if _,k :=uM[pid];!k{
                                    uM[pid] = menuM[pid]
                                }
                            }
                        }
                    }
                }
 
                var allUserMenus []models.SysMenu
                for _,v :=range uM {
                    allUserMenus = append(allUserMenus, v)
                }
                uS := menuFormat(&allUserMenus,"0", myMenuIds)
                var sUs uMenuT
                sUs = uS
                sort.Sort(sUs)
                return sUs,nil
            } else {
                return []vo.SysMenuTree{},nil
            }
        } else {
            return nil,errors.New("user role wrong")
        }
    } else {
        return nil,errors.New("user not found")
    }
}
 
func menuFormat(dbArr *[]models.SysMenu, parentId string, myMenuIds map [string]string) []vo.SysMenuTree {
    var arr []vo.SysMenuTree
    for _, m := range *dbArr {
        if parentId == m.ParentId {
            tmp := vo.SysMenuTree{}
            tmp.Id = m.Id
            tmp.Name = m.Name
            tmp.Sort = m.Sort
            _,ok := myMenuIds[m.Id]
            tmp.Selected = ok
 
            children := menuFormat(dbArr, m.Id, myMenuIds)
            tmp.Children = children
            arr = append(arr, tmp)
        }
    }
    var sUs uMenuT
    sUs = arr
    sort.Sort(sUs)
    return sUs
}
 
type uMenuT []vo.SysMenuTree
 
func (ul uMenuT) Len()int {
    return len(ul)
}
func (ul uMenuT) Swap(i,j int) {
    ul[i],ul[j] = ul[j],ul[i]
}
func (ul uMenuT) Less(i,j int) bool {
    return ul[i].Sort < ul[j].Sort
}