forked from lodastack/registry
-
Notifications
You must be signed in to change notification settings - Fork 0
/
user.go
138 lines (118 loc) · 3.21 KB
/
user.go
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
package authorize
import (
"encoding/json"
"github.com/lodastack/log"
"github.com/lodastack/registry/common"
"github.com/lodastack/registry/config"
m "github.com/lodastack/store/model"
)
// User is the infomation one user has.
type User struct {
Username string `json:"username"`
Mobile string `json:"mobile"`
Groups []string `json:"groups"`
cluster Cluster `json:"-"`
}
func getUKey(gid string) []byte { return []byte("u-" + gid) }
// Byte return the user at []byte format.
func (u *User) Byte() ([]byte, error) {
return json.Marshal(u)
}
// GetUser return user by username.
func (u *User) GetUser(username string) (User, error) {
out := User{}
uByte, err := u.cluster.View([]byte(AuthBuck), getUKey(username))
if err != nil {
return out, err
}
if len(uByte) == 0 {
return out, common.ErrUserNotFound
}
err = json.Unmarshal(uByte, &out)
return out, err
}
// GetUserList return user list by username list.
func (u *User) GetUserList(usernames []string) (map[string]User, error) {
Users := make(map[string]User, len(usernames))
for _, username := range usernames {
if username == "" {
continue
}
user, err := u.GetUser(username)
if err != nil {
log.Errorf("GetUser %s error: %s", username, user)
continue
}
Users[username] = user
}
return Users, nil
}
// CheckUserExist return the username exist or not.
func (u *User) CheckUserExist(username string) (bool, error) {
if username == "" {
return false, common.ErrInvalidParam
}
if _, err := u.GetUser(username); err != nil {
if err == common.ErrUserNotFound {
return false, nil
}
log.Errorf("GetUser %s fail: %s", username, err.Error())
return false, err
}
return true, nil
}
// SetUser create/update user. But will not init/update groups.
func (u *User) SetUser(username, mobile string) error {
if username == "" {
return common.ErrInvalidParam
}
us, err := u.GetUser(username)
if err != nil {
// create a user.
us.Username = username
us.Mobile = mobile
if _, ok := common.ContainString(config.C.Admins, username); ok {
us.Groups = []string{lodaAdminGName}
} else {
us.Groups = []string{lodaDefaultGName}
}
} else {
// update the user.
if mobile != "" {
us.Mobile = mobile
}
}
uByte, err := us.Byte()
if err != nil {
return err
}
return u.cluster.Update([]byte(AuthBuck), getUKey(username), uByte)
}
// UserRemoveUser remove the user and from the groups the user has.
func (u *User) UserRemoveUser(username string) ([]string, error) {
us, err := u.GetUser(username)
if err != nil {
return nil, err
}
return us.Groups, u.cluster.RemoveKey([]byte(AuthBuck), getUKey(username))
}
// UpdateUser add or remove the user to or from group.
func (u *User) UpdateUser(username string, addGroup string, removeGroup string) (m.Row, error) {
updateRow := m.Row{}
user, err := u.GetUser(username)
if err != nil {
return updateRow, err
}
if addGroup != "" {
user.Groups, _ = common.AddIfNotContain(user.Groups, addGroup)
}
if removeGroup != "" {
user.Groups, _ = common.RemoveIfContain(user.Groups, removeGroup)
}
newUserByte, err := user.Byte()
if err != nil {
return updateRow, err
}
updateRow = m.Row{Bucket: []byte(AuthBuck), Key: getUKey(username), Value: newUserByte}
return updateRow, nil
}