You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
187 lines
5.8 KiB
187 lines
5.8 KiB
package auth
|
|
|
|
import (
|
|
"encoding/json"
|
|
"fmt"
|
|
|
|
"github.com/Sirupsen/logrus"
|
|
xql "github.com/archsh/go.xql"
|
|
|
|
"cygnux.net/kepler/restlet"
|
|
)
|
|
|
|
func CheckGroupAvailableHandle(ctx restlet.RequestContext, params, queries restlet.Parameters, data []byte) (int, interface{}, error) {
|
|
name, b := params.GetString("name")
|
|
if !b || name == "" {
|
|
return restlet.ErrorInvalidParams, nil, fmt.Errorf("name required")
|
|
}
|
|
session := xql.MakeSession(ctx.SQL(), "postgres")
|
|
defer session.Close()
|
|
if n, e := session.Table(groupTable, "id").Where("name", name).Count(); nil != e {
|
|
return restlet.FatalDbReadFailed, nil, e
|
|
} else if n > 0 {
|
|
return restlet.ErrorConflict, nil, fmt.Errorf("name '%s' already exists", name)
|
|
}
|
|
return restlet.SuccessOk, map[string]interface{}{}, nil
|
|
}
|
|
|
|
|
|
func GroupListHandle(ctx restlet.RequestContext, params, queries restlet.Parameters, data []byte) (restlet.Result, error) {
|
|
//auth.GetGroup()
|
|
session := xql.MakeSession(ctx.SQL(), "postgres")
|
|
defer session.Close()
|
|
var groups []*Group
|
|
var groupMap = make(map[string]*Group)
|
|
if rows, e := session.Table(groupTable).All(); nil != e {
|
|
return restlet.FailureResult(restlet.FatalDbReadFailed, e.Error())
|
|
} else {
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var group Group
|
|
if e := rows.Scan(&group); nil != e {
|
|
return restlet.FailureResult(restlet.FatalDbReadFailed, e.Error())
|
|
} else {
|
|
groups = append(groups, &group)
|
|
groupMap[group.Id] = &group
|
|
}
|
|
}
|
|
}
|
|
if rows, e := session.Table(groupPermissionTable, "group_id", "role").All(); nil != e {
|
|
return restlet.FailureResult(restlet.FatalDbReadFailed, e.Error())
|
|
} else {
|
|
defer rows.Close()
|
|
for rows.Next() {
|
|
var gid, role string
|
|
if e := rows.Scan(&gid, &role); nil != e {
|
|
return restlet.FailureResult(restlet.FatalDbReadFailed, e.Error())
|
|
} else {
|
|
if g, b := groupMap[gid]; b {
|
|
g.Permissions = append(g.Permissions, role)
|
|
}
|
|
}
|
|
}
|
|
}
|
|
return restlet.Result{
|
|
Control: &restlet.ControlResult{
|
|
Total: int64(len(groups)),
|
|
Count: int64(len(groups)),
|
|
},
|
|
Code: restlet.SuccessOk,
|
|
Data: groups,
|
|
}, nil
|
|
}
|
|
|
|
type groupAddReq struct {
|
|
Name string `json:"name"`
|
|
Description string `json:"description"`
|
|
Permissions []string `json:"permissions"`
|
|
}
|
|
|
|
func GroupAddHandle(ctx restlet.RequestContext, params, queries restlet.Parameters, data []byte) (int, interface{}, error) {
|
|
var req groupAddReq
|
|
if e := json.Unmarshal(data, &req); nil != e {
|
|
logrus.Errorln("GroupAddHandle:> 1:", e)
|
|
return restlet.ErrorInvalidData, nil, e
|
|
} else if req.Name == "" {
|
|
logrus.Errorln("GroupAddHandle:> 2: empty name")
|
|
return restlet.ErrorInvalidData, nil, fmt.Errorf("name can not be empty")
|
|
}
|
|
session := xql.MakeSession(ctx.SQL(), "postgres")
|
|
defer session.Close()
|
|
if e := session.Begin(); nil != e {
|
|
return restlet.FatalDbWriteFailed, nil, e
|
|
}
|
|
if n, e := session.Table(groupTable, "id").Where("name", req.Name).Count(); nil != e {
|
|
return restlet.FatalDbReadFailed, nil, e
|
|
} else if n > 0 {
|
|
return restlet.ErrorConflict, nil, fmt.Errorf("groupname '%s' already exists", req.Name)
|
|
}
|
|
groupId, e := AddGroup(session, req.Name, req.Description, req.Permissions...)
|
|
if nil != e {
|
|
return restlet.FatalDbWriteFailed, nil, e
|
|
}
|
|
if e := session.Commit(); nil != e {
|
|
_ = session.Rollback()
|
|
return restlet.FatalDbWriteFailed, nil, e
|
|
}
|
|
return restlet.SuccessOk, map[string]interface{}{"groupId": groupId}, nil
|
|
}
|
|
|
|
func GroupUpdateHandle(ctx restlet.RequestContext, params, queries restlet.Parameters, data []byte) (int, interface{}, error) {
|
|
groupId, b := params.GetUUID("id")
|
|
if !b {
|
|
return restlet.ErrorInvalidParams, nil, fmt.Errorf("groupId required")
|
|
}
|
|
var updateMap = make(map[string]interface{})
|
|
var testMap = make(map[string]interface{})
|
|
var groupReq groupAddReq
|
|
var permissions []string
|
|
if e := json.Unmarshal(data, &groupReq); nil != e {
|
|
return restlet.ErrorInvalidData, nil, e
|
|
}
|
|
if e := json.Unmarshal(data, &testMap); nil != e {
|
|
return restlet.ErrorInvalidData, nil, e
|
|
}
|
|
//groups = groupReq.Groups
|
|
logrus.Debugln("GroupUpdateHandle:>testMap: ", testMap)
|
|
logrus.Debugln("GroupUpdateHandle:>groupReq: ", groupReq)
|
|
if _, b := testMap["name"]; b {
|
|
updateMap["name"] = groupReq.Name
|
|
}
|
|
if _, b := testMap["description"]; b {
|
|
updateMap["description"] = groupReq.Description
|
|
}
|
|
if _, b := testMap["permissions"]; b {
|
|
permissions = groupReq.Permissions
|
|
logrus.Debugln("GroupUpdateHandle:>permissions: ", permissions)
|
|
}
|
|
for _, k := range []string{"id", "created", "updated"} {
|
|
if _, b := updateMap[k]; b {
|
|
return restlet.ErrorInvalidData, nil, fmt.Errorf("not allowed to update '%s'", k)
|
|
}
|
|
}
|
|
|
|
session := xql.MakeSession(ctx.SQL(), "postgres")
|
|
defer session.Close()
|
|
if e := session.Begin(); nil != e {
|
|
return restlet.FatalDbWriteFailed, nil, e
|
|
}
|
|
if e := ModGroupProps(session, groupId.String(), updateMap); nil != e {
|
|
return restlet.FatalDbWriteFailed, nil, e
|
|
}
|
|
if e := ModGroupPermissions(session, groupId.String(), true, permissions...); nil != e {
|
|
return restlet.FatalDbWriteFailed, nil, e
|
|
}
|
|
|
|
if e := session.Commit(); nil != e {
|
|
_ = session.Rollback()
|
|
return restlet.FatalDbWriteFailed, nil, e
|
|
}
|
|
return restlet.SuccessOk, map[string]interface{}{
|
|
}, nil
|
|
}
|
|
|
|
func GroupDeleteHandle(ctx restlet.RequestContext, params, queries restlet.Parameters, data []byte) (int, interface{}, error) {
|
|
|
|
groupId, b := params.GetUUID("id")
|
|
if !b {
|
|
return restlet.ErrorInvalidParams, nil, fmt.Errorf("groupId required")
|
|
}
|
|
|
|
session := xql.MakeSession(ctx.SQL(), "postgres")
|
|
defer session.Close()
|
|
if e := session.Begin(); nil != e {
|
|
return restlet.FatalDbWriteFailed, nil, e
|
|
}
|
|
|
|
if _, e := session.Table(groupTable).Where("id", groupId.String()).Delete(); nil != e {
|
|
return restlet.FatalDbWriteFailed, nil, e
|
|
}
|
|
|
|
if e := session.Commit(); nil != e {
|
|
_ = session.Rollback()
|
|
return restlet.FatalDbWriteFailed, nil, e
|
|
}
|
|
return restlet.SuccessOk, map[string]interface{}{
|
|
}, nil
|
|
}
|