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.
515 lines
11 KiB
515 lines
11 KiB
package http |
|
|
|
import ( |
|
"bytes" |
|
"encoding/json" |
|
"fmt" |
|
"io/ioutil" |
|
"strconv" |
|
"strings" |
|
"time" |
|
|
|
"go-common/app/admin/main/aegis/model/business" |
|
"go-common/app/admin/main/aegis/model/common" |
|
taskmod "go-common/app/admin/main/aegis/model/task" |
|
"go-common/library/ecode" |
|
"go-common/library/log" |
|
bm "go-common/library/net/http/blademaster" |
|
libtime "go-common/library/time" |
|
) |
|
|
|
func taskDelay(c *bm.Context) { |
|
opt := &taskmod.DelayOptions{} |
|
if err := c.Bind(opt); err != nil { |
|
return |
|
} |
|
err := srv.Delay(c, opt) |
|
if err == ecode.AccessDenied || err == ecode.NothingFound { |
|
c.JSONMap(map[string]interface{}{"tips": "任务已被他人处理，毋需延迟"}, nil) |
|
return |
|
} |
|
c.JSON(nil, err) |
|
} |
|
|
|
func taskRelease(c *bm.Context) { |
|
opt := &common.BaseOptions{} |
|
if err := c.Bind(opt); err != nil { |
|
return |
|
} |
|
|
|
c.JSON(srv.Release(c, opt, false)) |
|
} |
|
|
|
func taskUnDo(c *bm.Context) { |
|
opt := &common.BaseOptions{} |
|
if err := c.Bind(opt); err != nil { |
|
return |
|
} |
|
|
|
c.JSON(srv.UnDoStat(c, opt)) |
|
} |
|
|
|
func taskStat(c *bm.Context) { |
|
opt := &common.BaseOptions{} |
|
if err := c.Bind(opt); err != nil { |
|
return |
|
} |
|
|
|
c.JSON(srv.TaskStat(c, opt)) |
|
} |
|
|
|
func consumerOn(c *bm.Context) { |
|
opt := &common.BaseOptions{} |
|
if err := c.Bind(opt); err != nil { |
|
return |
|
} |
|
|
|
c.JSON(nil, srv.On(c, opt)) |
|
} |
|
|
|
func consumerOff(c *bm.Context) { |
|
opt := new(struct { |
|
common.BaseOptions |
|
Delay bool `form:"delay" default:"true"` |
|
}) |
|
if err := c.Bind(opt); err != nil { |
|
return |
|
} |
|
if err := srv.Off(c, &opt.BaseOptions); err != nil { |
|
c.JSON(nil, err) |
|
return |
|
} |
|
c.JSON(nil, nil) |
|
|
|
srv.Release(c, &opt.BaseOptions, opt.Delay) |
|
} |
|
|
|
func kickOut(c *bm.Context) { |
|
opt := new(struct { |
|
common.BaseOptions |
|
KickUID int64 `form:"kick_uid" validate:"required"` |
|
}) |
|
if err := c.Bind(opt); err != nil { |
|
return |
|
} |
|
if opt.BaseOptions.Role != taskmod.TaskRoleLeader { |
|
httpCode(c, "组长才有权限踢人", ecode.RequestErr) |
|
return |
|
} |
|
|
|
if err := srv.KickOut(c, &opt.BaseOptions, opt.KickUID); err != nil { |
|
c.JSON(nil, err) |
|
return |
|
} |
|
c.JSON(nil, nil) |
|
|
|
srv.Release(c, &opt.BaseOptions, false) |
|
} |
|
|
|
func consumerWatcher(c *bm.Context) { |
|
opt := new(struct { |
|
BizID int64 `form:"business_id" validate:"required"` |
|
FlowID int64 `form:"flow_id" validate:"required"` |
|
Role int8 `form:"role"` |
|
}) |
|
if err := c.Bind(opt); err != nil { |
|
return |
|
} |
|
|
|
c.JSON(srv.Watcher(c, opt.BizID, opt.FlowID, opt.Role)) |
|
} |
|
|
|
func configEdit(c *bm.Context) { |
|
twc, _, err := readConfig(c) |
|
if err != nil || twc == nil { |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
if twc.ID <= 0 { |
|
httpCode(c, "id错误", ecode.RequestErr) |
|
return |
|
} |
|
|
|
c.JSON(nil, srv.UpdateConfig(c, twc)) |
|
} |
|
|
|
func configAdd(c *bm.Context) { |
|
twc, confJSON, err := readConfig(c) |
|
if err != nil || twc == nil { |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
c.JSON(nil, srv.AddConfig(c, twc, confJSON)) |
|
} |
|
|
|
func readConfig(c *bm.Context) (tc *taskmod.Config, confJSON interface{}, err error) { |
|
opt := &taskmod.ConfigOption{} |
|
if err = c.Bind(opt); err != nil { |
|
return nil, nil, err |
|
} |
|
|
|
switch opt.ConfType { |
|
case taskmod.TaskConfigAssign: |
|
type Assign struct { |
|
Mids string `json:"mids"` |
|
Uids string `json:"uids"` |
|
} |
|
confJSON = new(Assign) |
|
case taskmod.TaskConfigRangeWeight: |
|
confJSON = new(taskmod.RangeWeightConfig) |
|
case taskmod.TaskConfigEqualWeight: |
|
confJSON = new(taskmod.EqualWeightConfig) |
|
default: |
|
return nil, nil, ecode.RequestErr |
|
} |
|
|
|
tc = &taskmod.Config{ |
|
ID: opt.ID, |
|
ConfType: opt.ConfType, |
|
BusinessID: opt.BusinessID, |
|
FlowID: opt.FlowID, |
|
Description: opt.Description, |
|
UID: opt.UID, |
|
Uname: opt.Uname, |
|
} |
|
bt, _ := time.ParseInLocation(common.TimeFormat, opt.Btime, time.Local) |
|
et, _ := time.ParseInLocation(common.TimeFormat, opt.Etime, time.Local) |
|
if !bt.IsZero() { |
|
tc.Btime = libtime.Time(bt.Unix()) |
|
} |
|
if !et.IsZero() { |
|
tc.Etime = libtime.Time(et.Unix()) |
|
} |
|
|
|
err = jsonhelp(confJSON, []byte(opt.ConfJSON), tc) |
|
return |
|
} |
|
|
|
func jsonhelp(jsonObject interface{}, bs []byte, tc *taskmod.Config) (err error) { |
|
if err = json.Unmarshal(bs, jsonObject); err != nil { |
|
log.Error("jsonhelp error(%v)", string(bs), err) |
|
return |
|
} |
|
|
|
if bs, err = json.Marshal(jsonObject); err != nil { |
|
log.Error("jsonhelp json.Marshal(%s) error(%v)", err) |
|
return |
|
} |
|
tc.ConfJSON = string(bs) |
|
return |
|
} |
|
|
|
func configList(c *bm.Context) { |
|
qp := &taskmod.QueryParams{} |
|
if err := c.Bind(qp); err != nil { |
|
return |
|
} |
|
|
|
configs, count, err := srv.QueryConfigs(c, qp) |
|
if err != nil { |
|
c.JSON(nil, err) |
|
return |
|
} |
|
qp.Pager.Total = int(count) |
|
|
|
c.JSONMap(map[string]interface{}{ |
|
"pager": qp.Pager, |
|
"data": configs, |
|
}, nil) |
|
} |
|
|
|
func configDelete(c *bm.Context) { |
|
opt := new(struct { |
|
ID int64 `form:"id" validate:"required"` |
|
}) |
|
if err := c.Bind(opt); err != nil { |
|
return |
|
} |
|
|
|
c.JSON(nil, srv.DeleteConfig(c, opt.ID)) |
|
} |
|
|
|
func configSet(c *bm.Context) { |
|
opt := new(struct { |
|
ID int64 `form:"id" validate:"required"` |
|
State int8 `form:"state"` |
|
}) |
|
if err := c.Bind(opt); err != nil { |
|
return |
|
} |
|
|
|
c.JSON(nil, srv.SetStateConfig(c, opt.ID, opt.State)) |
|
} |
|
|
|
func maxWeight(c *bm.Context) { |
|
opt := &common.BaseOptions{} |
|
if err := c.Bind(opt); err != nil { |
|
return |
|
} |
|
|
|
c.JSON(srv.MaxWeight(c, opt)) |
|
} |
|
|
|
func weightlog(c *bm.Context) { |
|
opt := new(struct { |
|
TaskID int64 `form:"task_id" validate:"required"` |
|
Pn int `form:"pn" default:"1"` |
|
Ps int `form:"ps" default:"20"` |
|
}) |
|
if err := c.Bind(opt); err != nil { |
|
return |
|
} |
|
|
|
ls, count, err := srv.WeightLog(c, opt.TaskID, opt.Pn, opt.Ps) |
|
c.JSONMap(map[string]interface{}{ |
|
"data": ls, |
|
"pager": common.Pager{ |
|
Pn: opt.Pn, |
|
Ps: opt.Ps, |
|
Total: count, |
|
}, |
|
}, err) |
|
} |
|
|
|
func role(c *bm.Context) { |
|
opt := &common.BaseOptions{} |
|
if err := c.Bind(opt); err != nil { |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
opt.UID = uid(c) |
|
opt.Uname = uname(c) |
|
_, role, err := srv.GetRole(c, opt) |
|
c.JSON(role, err) |
|
} |
|
|
|
func roleFlush(c *bm.Context) { |
|
opt := new(struct { |
|
Uids []int64 `form:"uids,split" validate:"required"` |
|
BizID int64 `form:"business_id" validate:"required"` |
|
FlowID int64 `form:"flow_id" validate:"required"` |
|
}) |
|
if err := c.Bind(opt); err != nil { |
|
c.JSON(nil, ecode.RequestErr) |
|
return |
|
} |
|
c.JSON(nil, srv.FlushRole(c, opt.BizID, opt.FlowID, opt.Uids)) |
|
} |
|
|
|
func checkTaskRole() bm.HandlerFunc { |
|
return func(ctx *bm.Context) { |
|
opt := &common.BaseOptions{} |
|
if err := ctx.Bind(opt); err != nil { |
|
ctx.Abort() |
|
return |
|
} |
|
|
|
if opt.BusinessID <= 0 || opt.FlowID <= 0 { |
|
httpCode(ctx, "缺少business_id或flow_id", ecode.RequestErr) |
|
ctx.Abort() |
|
return |
|
} |
|
|
|
if srv.Debug() == "local" { |
|
ctx.Request.Form.Set("role", strconv.Itoa(int(taskmod.TaskRoleLeader))) |
|
return |
|
} |
|
user := uid(ctx) |
|
if srv.IsAdmin(user) { |
|
ctx.Request.Form.Set("role", strconv.Itoa(int(taskmod.TaskRoleLeader))) |
|
log.Info("checkTaskRole uid(%d) is admin", user) |
|
return |
|
} |
|
|
|
_, role, err := srv.GetRole(ctx, opt) |
|
if err != nil || role == 0 { |
|
ctx.JSON(nil, ecode.AccessDenied) |
|
ctx.Abort() |
|
return |
|
} |
|
|
|
log.Info("checkTaskRole opt(%+v) role(%d)", role) |
|
ctx.Request.Form.Set("role", fmt.Sprint(role)) |
|
} |
|
} |
|
|
|
//判断业务用户权限，无授权业务则报错 |
|
func checkBizRole(role string, noAdmin bool, bizID bool) bm.HandlerFunc { |
|
return func(ctx *bm.Context) { |
|
if srv.Debug() == "local" { |
|
return |
|
} |
|
|
|
user := uid(ctx) |
|
if srv.IsAdmin(user) { |
|
log.Info("checkBizRole uid(%d) is admin", user) |
|
return |
|
} |
|
|
|
businessID, err := srv.GetRoleBiz(ctx, user, role, noAdmin) |
|
if err != nil || len(businessID) == 0 { |
|
ctx.JSON(nil, ecode.AccessDenied) |
|
ctx.Abort() |
|
return |
|
} |
|
ctx.Set(business.AccessBiz, businessID) |
|
|
|
//request business in accessed biz range |
|
if bizID { |
|
var biz int64 |
|
if strings.Contains(ctx.Request.Header.Get("Content-Type"), "application/json") { |
|
var body []byte |
|
if body, err = ioutil.ReadAll(ctx.Request.Body); err != nil { |
|
log.Error("checkBizRole ioutil.ReadAll error(%+v)", err) |
|
return |
|
} |
|
ctx.Request.Body.Close() |
|
ctx.Request.Body = ioutil.NopCloser(bytes.NewBuffer(body)) |
|
pm := new(struct { |
|
BusinessID int64 `json:"business_id" form:"business_id"` |
|
}) |
|
if err = json.Unmarshal(body, pm); err != nil { |
|
log.Error("checkBizRole json.Unmarshal error(%+v) body(%s)", err, string(body)) |
|
ctx.JSON(nil, ecode.RequestErr) |
|
ctx.Abort() |
|
return |
|
} |
|
biz = pm.BusinessID |
|
} else { |
|
if biz, err = strconv.ParseInt(ctx.Request.Form.Get("business_id"), 10, 64); err != nil { |
|
log.Error("checkBizRole strconv.ParseInt(%s) error(%v)", ctx.Request.Form.Get("business_id"), err) |
|
ctx.JSON(nil, ecode.RequestErr) |
|
ctx.Abort() |
|
return |
|
} |
|
} |
|
|
|
exist := false |
|
for _, item := range businessID { |
|
if item == biz { |
|
exist = true |
|
break |
|
} |
|
} |
|
if !exist || biz <= 0 { |
|
ctx.JSON(nil, ecode.AccessDenied) |
|
ctx.Abort() |
|
return |
|
} |
|
} |
|
} |
|
} |
|
|
|
//判断任务用户权限，无授权业务则报错 |
|
func checkAccessTask() bm.HandlerFunc { |
|
return func(ctx *bm.Context) { |
|
if srv.Debug() == "local" { |
|
return |
|
} |
|
user := uid(ctx) |
|
if srv.IsAdmin(user) { |
|
log.Info("checkrole uid(%d) is admin", user) |
|
return |
|
} |
|
businessID, flowID, err := srv.GetTaskBizFlows(ctx, user) |
|
if err != nil || len(businessID) == 0 || len(flowID) == 0 { |
|
//ctx.JSON(nil, ecode.AccessDenied) |
|
ctx.JSON(nil, nil) |
|
ctx.Abort() |
|
return |
|
} |
|
log.Info("checkAccessTask uid(%d) can see business(%+v) flow(%+v)", user, businessID, flowID) |
|
ctx.Set(business.AccessBiz, businessID) |
|
ctx.Set(business.AccessFlow, flowID) |
|
} |
|
} |
|
|
|
//是否为指定业务的管理员角色 |
|
func checkBizID() bm.HandlerFunc { |
|
return checkBizRole(business.BizBIDAdmin, false, true) |
|
} |
|
|
|
//为哪些业务的管理员角色 |
|
func checkBizAdmin() bm.HandlerFunc { |
|
return checkBizRole(business.BizBIDAdmin, false, false) |
|
} |
|
|
|
//为哪些业务的非管理员角色 |
|
func checkBizBID() bm.HandlerFunc { |
|
return checkBizRole("", true, false) |
|
} |
|
|
|
func checkBizLeader() bm.HandlerFunc { |
|
return checkBizRole("leader", true, true) |
|
} |
|
|
|
func checkBizOper() bm.HandlerFunc { |
|
return checkBizRole("oper", true, true) |
|
} |
|
|
|
//为指定业务的非管理员角色 |
|
func checkBizBIDBiz() bm.HandlerFunc { |
|
return checkBizRole("", true, true) |
|
} |
|
|
|
func getAccessBiz(c *bm.Context) (biz []int64) { |
|
biz = []int64{} |
|
ids, _ := c.Get(business.AccessBiz) |
|
if ids != nil { |
|
biz = ids.([]int64) |
|
} |
|
return |
|
} |
|
|
|
func getAccessFlow(c *bm.Context) (flowID []int64) { |
|
flowID = []int64{} |
|
ids, _ := c.Get(business.AccessFlow) |
|
if ids != nil { |
|
flowID = ids.([]int64) |
|
} |
|
return |
|
} |
|
|
|
func checkon() bm.HandlerFunc { |
|
return func(ctx *bm.Context) { |
|
if srv.Debug() == "local" { |
|
return |
|
} |
|
opt := &common.BaseOptions{} |
|
if err := ctx.Bind(opt); err != nil { |
|
ctx.Abort() |
|
return |
|
} |
|
|
|
if !srv.IsOn(ctx, opt) { |
|
if err := srv.On(ctx, opt); err != nil { |
|
ctx.JSON(nil, err) |
|
ctx.Abort() |
|
} |
|
return |
|
} |
|
} |
|
} |
|
|
|
func preHandlerUser() bm.HandlerFunc { |
|
return func(ctx *bm.Context) { |
|
if srv.Debug() == "local" { |
|
return |
|
} |
|
uidS, ok := ctx.Get("uid") |
|
if !ok { |
|
ctx.JSON(nil, ecode.NoLogin) |
|
ctx.Abort() |
|
return |
|
} |
|
unamei, ok := ctx.Get("username") |
|
if !ok { |
|
ctx.JSON(nil, ecode.NoLogin) |
|
ctx.Abort() |
|
return |
|
} |
|
|
|
ctx.Request.Form.Set("uid", fmt.Sprint(uidS)) |
|
ctx.Request.Form.Set("uname", unamei.(string)) |
|
} |
|
}
|
|
|