516 lines
11 KiB
Go
516 lines
11 KiB
Go
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))
|
|
}
|
|
}
|